Kubelet

Rust libraries for implementing your own kubelet in Rust.

lib.rs:

A crate for building custom Kubernetes kubelets.

The crate provides the Provider trait for declaring a Kubelet backend as well as a the Kubelet type which takes a Provider and runs a Kubelet server.

Example

use kubelet::Kubelet;
use kubelet::config::Config;
use kubelet::resources::DeviceManager;
use kubelet::plugin_watcher::PluginRegistry;
use kubelet::pod::Pod;
use kubelet::provider::{DevicePluginSupport, Provider, PluginSupport};
use std::sync::Arc;
use tokio::sync::RwLock;
use kubelet::pod::state::prelude::*;
use kubelet::pod::state::Stub;

// Create some type that will act as your provider
struct MyProvider;

// Track shared provider-level state across pods.
struct ProviderState;
// Track pod state amongst pod state handlers.
struct PodState;

#[async_trait::async_trait]
impl ObjectState for PodState {
    type Manifest = Pod;
    type Status = PodStatus;
    type SharedState = ProviderState;
    async fn async_drop(self, _provider_state: &mut ProviderState) {}
}

// Implement the `Provider` trait for that type
#[async_trait::async_trait]
impl Provider for MyProvider {
    const ARCH: &'static str = "my-arch";
    type ProviderState = ProviderState;
    type InitialState = Stub;
    type TerminatedState = Stub;
    type PodState = PodState;

    fn provider_state(&self) -> SharedState<ProviderState> {
        Arc::new(RwLock::new(ProviderState {}))
    }

    async fn initialize_pod_state(&self, _pod: &Pod) -> anyhow::Result<Self::PodState> {
        Ok(PodState)
    }

    async fn logs(&self, namespace: String, pod: String, container: String, sender: kubelet::log::Sender) -> anyhow::Result<()> { todo!() }
}

impl PluginSupport for ProviderState {
    fn plugin_registry(&self) -> Option<Arc<PluginRegistry>> {
        None
    }
}

impl DevicePluginSupport for ProviderState {
    fn device_plugin_manager(&self) -> Option<Arc<DeviceManager>> {
        None
    }
}

async {
    // Instantiate your provider type
    let provider = MyProvider;

    // Load a kubernetes configuration
    let kubeconfig = kube::Config::infer().await.unwrap();
    // Get a configuration for the Kubelet
    let kubelet_config = Config::default();

    // Instantiate the Kubelet
    let kubelet = Kubelet::new(provider, kubeconfig, kubelet_config).await.unwrap();
    // Start the Kubelet and block on it
    kubelet.start().await.unwrap();
};