Crate kubelet

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::plugin_watcher::PluginRegistry;
use kubelet::pod::Pod;
use kubelet::provider::Provider;
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 {}))
    }

    fn plugin_registry(&self) -> Option<Arc<PluginRegistry>> {
        Some(Arc::new(Default::default()))
    }

    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!() }
}

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();
};

Modules

backoff	Provides backoff timing control for Kubernetes pod states such as ImagePullBackoff and CrashLoopBackoff.
config	Configuration for a Kubelet
container	container is a collection of utilities surrounding the Kubernetes container API.
handle	A convenience handle type for providers
log	log contains convenient wrappers around fetching logs from the Kubernetes API.
node	node contains wrappers around the Kubernetes node API, containing ways to create and update nodes operating within the cluster.
plugin_watcher	The Kubelet plugin manager. Used to lookup which plugins are registered with this node.
pod	pod is a collection of utilities surrounding the Kubernetes pod API.
provider	Traits and types needed to create backend providers for a Kubelet
secret	Resolves image pull secrets
state	Re-export of krator::state and common states for Kubelets.
store	store contains logic around fetching and storing modules.
volume	A module for use in managing volumes in providers. Use of this module is not mandatory to create a Provider, but it does provide common implementation logic for supported volume providers.

Structs

Kubelet

A Kubelet server backed by a given Provider.

Functions

bootstrap

Bootstrap the cluster with TLS certificates but only if no existing kubeconfig can be found.