Riscrivere Kubernetes da zero in Rust: uno sguardo al progetto Rusternetes
Le battute sui programmatori di sistemi che cercano di riscrivere tutto in Rust sono diventate da tempo un classico. Di solito, queste imprese si fermano allo stadio di "Hello World" o al parsing di configurazioni base. Ma con Rusternetes, la storia è andata completamente diversamente. L'autore del progetto ha puntato direttamente a Kubernetes e lo ha riscritto da zero.
Non si tratta di un wrapper attorno a codice Go né di un mock di test ridotto all'osso. Il repository contiene un piano di controllo e componenti per node pienamente funzionanti: API server, scheduler, controller manager, kubelet e kube-proxy. Tutto è scritto in Rust senza dipendenze Go di terze parti.
Il progetto contiene oltre 216.000 righe di codice, distribuite in 10 crate, 31 controller e più di 3.100 unit test. Gli sviluppatori verificano la compatibilità usando la suite di test e2e ufficiale di Kubernetes (v1.35) tramite Sonobuoy. Attualmente Rusternetes supera con successo il 94% dei test di conformità (415 su 441).
Perché un altro Kubernetes
Il Kubernetes originale è scritto in Go e richiede risorse considerevoli. Per avviare anche un cluster locale minimo come minikube o k3s, bisogna allocare una macchina virtuale o eseguire diversi container pesanti con etcd.
Rusternetes risolve questo problema con opzioni di deployment flessibili. Ha tre modalità operative:
- Cluster classico con etcd. Tutti i componenti vengono eseguiti in container separati e comunicano con un cluster etcd.
- Sostituire etcd con SQLite o Redis. Al posto di etcd viene connesso Rhino—un server gRPC compatibile con etcd scritto in Rust. Le impostazioni e i binari dell'API rimangono gli stessi; cambia solo il file compose.
- Tutti i componenti in un singolo binario. API server, scheduler, controller manager, kubelet e kube-proxy vengono eseguiti come Tokio async task all'interno di un singolo processo. Lo stato del cluster viene scritto su un singolo file SQLite o su un'istanza Redis.
La modalità All-in-One risolve i punti critici dello sviluppo locale, delle pipeline CI/CD e dell'esecuzione dell'orchestratore su dispositivi edge (Edge/IoT), dove ogni megabyte di RAM conta.
Interfaccia Web Integrata
Rusternetes ha una dashboard di monitoraggio integrata. È incorporata direttamente nel binario dell'API server, quindi non serve configurare o distribuire nulla di extra.
L'interfaccia mostra una mappa della topologia del cluster con animazione del traffico, una heatmap del carico CPU e RAM, lo streaming dei log dei container e permette di visualizzare ConfigMap, Secrets, manifest RBAC e lo stato dei deployment.
Cosa c'è dentro: Architettura del Progetto
Il repository è organizzato come un Cargo workspace di 10 crate.
┌───────────────────────────────────────────────────────────────┐
│ Control Plane │
│ │
│ ┌──────────────────┐ ┌──────────────┐ ┌────────────────┐ │
│ │ API Server │ │ Scheduler │ │ Controller │ │
│ │ Axum + TLS │ │ Affinity │ │ Taints │ │
│ │ REST + Watch │ │ Preemption │ │ Manager │ │
│ │ RBAC + Webhooks │ │ │ │ 31 control │ │
│ │ Web Console │ │ │ │ loops │ │
│ └────────┬─────────┘ └──────────────┘ └────────────────┘ │
│ │ │
│ ┌────────▼─────────┐ │
│ │ Storage │ │
│ │ etcd|SQLite|Redis│ │
│ └──────────────────┘ │
├───────────────────────────────────────────────────────────────┤
│ Node Components │
│ │
│ ┌──────────────────┐ ┌──────────────────────────────────┐ │
│ │ Kubelet │ │ Kube-Proxy │ │
│ │ bollard (Docker)│ │ iptables routing │ │
│ │ Probes+Volumes │ │ ClusterIP/NodePort/LB │ │
│ └──────────────────┘ └──────────────────────────────────┘ │
└───────────────────────────────────────────────────────────────┘
Ogni parte del cluster è responsabile della propria area di lavoro:
- api-server: Scritto usando il framework Axum. Gestisce REST API, Watch API tramite Server-Sent Events, webhook di validazione e mutazione, valutazione delle regole CEL e autorizzazione RBAC.
- scheduler: Seleziona i node per i pod in base ad affinity/anti-affinity, taint, toleration e vincoli di risorse.
- controller-manager: Contiene 31 loop di reconciliation. Gestisce Deployment, ReplicaSet, StatefulSet, DaemonSet, Job, CronJob, HPA, Ingress e CRD.
- kubelet: Comunica con Docker o Podman tramite la crate
bollard. Traccia il ciclo di vita dei container, esegue probe di liveness e readiness e monta i volumi (hostPath, configMap, secret). - kube-proxy: Gestisce le regole iptables per i tipi di servizio ClusterIP, NodePort e LoadBalancer.
Come Eseguire per il Testing
La compilazione richiede una versione recente di Rust, il compilatore protobuf e Docker o Podman.
Il modo più veloce per testare è la modalità All-in-One con SQLite:
cargo build -p rusternetes
./target/release/rusternetes --data-dir ./cluster.db
Se vuoi avviare un'emulazione più realistica di un ambiente multi-componente tramite Docker Compose:
git clone https://github.com/calfonso/rusternetes.git
cd rusternetes
export KUBELET_VOLUMES_PATH=$(pwd)/.rusternetes/volumes
docker compose -f docker-compose.sqlite.yml build
docker compose -f docker-compose.sqlite.yml up -d
bash scripts/bootstrap-cluster.sh
export KUBECONFIG=~/.kube/rusternetes-config
kubectl get nodes
Dopo il bootstrap, puoi interagire con il cluster usando l'utility standard kubectl.
Utilità Pratica e Conclusioni
Portare Rusternetes in produzione adesso non ne vale la pena: sebbene il progetto superi il 94% dei test e2e, rimane sperimentale. Ciononostante, ha tre casi d'uso eccellenti.
Primo, è una guida di studio ideale per imparare i meccanismi interni di Kubernetes. Leggere codice Rust con una chiara suddivisione in moduli è molto più piacevole che scavare nel grande monolite del K8s originale.
Secondo, eseguire un cluster in un singolo processo con SQLite fa risparmiare risorse negli ambienti di test e nelle CI/CD.
Terzo, il progetto è utile per eseguire l'orchestrazione su hardware debole come Raspberry Pi o piattaforme IoT embedded.
Se sei interessato allo sviluppo di sistemi in Rust o a come funzionano gli orchestrator, il progetto merita sicuramente una stella su GitHub.
Progetti correlati