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

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

resources

resources contains utilities and managers for container resources.

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.