Kubernetes vanaf nul herschrijven in Rust: een blik op het Rusternetes-project
Grappen over systeemprogrammeurs die alles in Rust willen herschrijven zijn allang een klassiek trope geworden. Meestal blijven zulke ondernemingen bij het "Hallo Wereld"-stadium of het parsen van basisconfiguraties. Maar met Rusternetes verliep het verhaal helemaal anders. De auteur van het project ging Kubernetes zelf achterna en herschreef het vanaf nul.
Dit is geen wrapper rond Go-code of een gestripte testmock. De repository bevat een volwaardig control plane en node-componenten: API-server, scheduler, controller manager, kubelet en kube-proxy. Alles is geschreven in Rust zonder externe Go-afhankelijkheden.
Het project bevat meer dan 216.000 regels code, verdeeld over 10 crates, 31 controllers en meer dan 3.100 unit tests. De ontwikkelaars verifiëren compatibiliteit met behulp van de officiële Kubernetes e2e test suite (v1.35) via Sonobuoy. Momenteel slaagt Rusternetes voor 94% van de conformiteitstests (415 van de 441).
Waarom nog een Kubernetes
De originele Kubernetes is geschreven in Go en vereist aanzienlijke resources. Om zelfs een minimale lokale cluster op te zetten zoals minikube of k3s, moet je een virtuele machine toewijzen of verschillende zware containers met etcd draaien.
Rusternetes lost dit probleem op met flexibele implementatieopties. Het heeft drie operationele modi:
- Classieke cluster met etcd. Alle componenten draaien in aparte containers en communiceren met een etcd-cluster.
- Vervang etcd door SQLite of Redis. In plaats van etcd wordt Rhino aangesloten—een etcd-compatibele gRPC-server geschreven in Rust. De API-instellingen en binaries blijven hetzelfde; alleen het compose-bestand verandert.
- Alle componenten in één binary. API-server, scheduler, controller manager, kubelet en kube-proxy draaien als Tokio async-taken binnen één proces. De clusterstatus wordt weggeschreven naar één SQLite-bestand of Redis-instantie.
De All-in-One-modus lost de pijnpunten op van lokale ontwikkeling, CI/CD-pipelines en het draaien van de orchestrator op edge-apparaten (Edge/IoT), waar elke megabyte RAM telt.
Ingebouwde webinterface
Rusternetes heeft een ingebouwd monitoringdashboard. Het is direct ingebed in de API-server binary, dus er hoeft niets extra geconfigureerd of geïmplementeerd te worden.
De interface toont een clustertopologiekaart met verkeersanimatie, een CPU- en RAM-belasting heatmap, container log streaming, en stelt je in staat om ConfigMaps, Secrets, RBAC-manifesten en deploymentstatus te bekijken.
Wat zit erin: projectarchitectuur
De repository is georganiseerd als een Cargo-workspace van 10 crates.
┌───────────────────────────────────────────────────────────────┐
│ 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 │ │
│ └──────────────────┘ └──────────────────────────────────┘ │
└───────────────────────────────────────────────────────────────┘
Elk deel van de cluster is verantwoordelijk voor zijn eigen werkgebied:
- api-server: Geschreven met het Axum-framework. Verwerkt REST API, Watch API via Server-Sent Events, validerende en muterende webhooks, CEL-regelevaluatie en RBAC-autorisatie.
- scheduler: Selecteert nodes voor pods op basis van affiniteit/anti-affiniteit, taints, toleraties en resourcebeperkingen.
- controller-manager: Bevat 31 reconciliatielussen. Verwerkt Deployment, ReplicaSet, StatefulSet, DaemonSet, Job, CronJob, HPA, Ingress en CRDs.
- kubelet: Communiceert met Docker of Podman via de
bollardcrate. Volgt de containerc levenscyclus, voert liveness en readiness probes uit en mount volumes (hostPath, configMap, secret). - kube-proxy: Beheert iptables-regels voor ClusterIP, NodePort en LoadBalancer servicetypen.
Hoe te draaien voor testing
Bouwen vereist een recente Rust, de protobuf compiler en Docker of Podman.
De snelste manier om te testen is de All-in-One-modus met SQLite:
cargo build -p rusternetes
./target/release/rusternetes --data-dir ./cluster.db
Als je een meer realistische emulatie van een multi-componentenomgeving wilt opzetten via 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
Na bootstrap kun je met de cluster communiceren met behulp van het standaard kubectl hulpprogramma.
Praktische bruikbaarheid en conclusies
Rusternetes nu in productie brengen is niet de moeite waard: hoewel het project 94% van de e2e-tests doorstaat, blijft het experimenteel. Desondanks heeft het drie uitstekende use cases.
Ten eerste is het een ideale studiegids voor het leren van Kubernetes internals. Rust-broncode lezen met een duidelijke moduleonderverdeling is veel prettiger dan graven in de enorme monoliet van de originele K8s.
Ten tweede bespaart het draaien van een cluster in één proces met SQLite resources op testomgevingen en in CI/CD.
Ten derde is het project nuttig voor het draaien van orchestratie op zwakke hardware zoals Raspberry Pi of embedded IoT-platforms.
Als je geïnteresseerd bent in systeemontwikkeling in Rust of hoe orchestrators werken, verdient het project zeker een ster op GitHub.
Gerelateerde projecten