Kubernetes von Grund auf in Rust neu schreiben: Ein Blick auf das Rusternetes-Projekt
Witze darüber, dass Systemprogrammierer alles in Rust neu schreiben wollen, sind längst ein klassischer Trope. Normalerweise enden solche Vorhaben im Stadium von „Hello World" oder beim Parsen einfacher Konfigurationen. Aber bei Rusternetes verlief die Geschichte völlig anders. Der Autor des Projekts hat sich Kubernetes selbst vorgenommen und es von Grund auf neu geschrieben.
Dies ist kein Wrapper um Go-Code oder ein abgespecktes Test-Mock. Das Repository enthält eine vollwertige Control-Plane und Node-Komponenten: API-Server, Scheduler, Controller-Manager, Kubelet und Kube-Proxy. Alles ist in Rust geschrieben, ohne Go-Drittabhängigkeiten.
Das Projekt enthält über 216.000 Zeilen Code, aufgeteilt in 10 Crates, 31 Controller und mehr als 3.100 Unit-Tests. Die Entwickler verifizieren die Kompatibilität mit der offiziellen Kubernetes e2e-Testsuite (v1.35) über Sonobuoy. Derzeit bestehen 94 % der Konformitätstests (415 von 441) erfolgreich.
Warum noch ein Kubernetes
Das originale Kubernetes ist in Go geschrieben und erfordert erhebliche Ressourcen. Um selbst einen minimalen lokalen Cluster wie Minikube oder K3s zu starten, muss man eine virtuelle Maschine zuweisen oder mehrere schwere Container mit etcd ausführen.
Rusternetes löst dieses Problem mit flexiblen Deployment-Optionen. Es hat drei Betriebsmodi:
- Klassischer Cluster mit etcd. Alle Komponenten laufen in separaten Containern und kommunizieren mit einem etcd-Cluster.
- etcd durch SQLite oder Redis ersetzen. Statt etcd wird Rhino angebunden – ein etcd-kompatibler gRPC-Server in Rust. Die API-Einstellungen und Binärdateien bleiben gleich; nur die Compose-Datei ändert sich.
- Alle Komponenten in einer einzigen Binärdatei. API-Server, Scheduler, Controller-Manager, Kubelet und Kube-Proxy laufen als Tokio-Async-Tasks in einem einzigen Prozess. Der Cluster-Zustand wird in eine einzelne SQLite-Datei oder Redis-Instanz geschrieben.
Der All-in-One-Modus löst die Probleme bei lokaler Entwicklung, CI/CD-Pipelines und beim Ausführen des Orchestrators auf Edge-Geräten (Edge/IoT), wo jedes Megabyte RAM zählt.
Integrierte Web-Oberfläche
Rusternetes verfügt über ein integriertes Monitoring-Dashboard. Es ist direkt in die API-Server-Binärdatei eingebettet, sodass nichts Weiteres konfiguriert oder bereitgestellt werden muss.
Die Oberfläche zeigt eine Cluster-Topologiekarte mit Traffic-Animation, eine CPU- und RAM-Auslastungs-Heatmap, Container-Log-Streaming und ermöglicht das Anzeigen von ConfigMaps, Secrets, RBAC-Manifesten und Deployment-Status.
Was drinsteckt: Projektarchitektur
Das Repository ist als Cargo-Workspace mit 10 Crates organisiert.
┌───────────────────────────────────────────────────────────────┐
│ 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 │ │
│ └──────────────────┘ └──────────────────────────────────┘ │
└───────────────────────────────────────────────────────────────┘
Jeder Teil des Clusters ist für seinen eigenen Arbeitsbereich verantwortlich:
- api-server: Geschrieben mit dem Axum-Framework. Verarbeitet REST-API, Watch-API über Server-Sent Events, validierende und mutierende Webhooks, CEL-Regelauswertung und RBAC-Autorisierung.
- scheduler: Wählt Nodes für Pods basierend auf Affinity/Anti-Affinity, Taints, Tolerations und Ressourcenbeschränkungen aus.
- controller-manager: Enthält 31 Reconciliation-Loops. Behandelt Deployment, ReplicaSet, StatefulSet, DaemonSet, Job, CronJob, HPA, Ingress und CRDs.
- kubelet: Kommuniziert mit Docker oder Podman über den
bollard-Crate. Verfolgt den Container-Lebenszyklus, führt Liveness- und Readiness-Probes aus und bindet Volumes ein (hostPath, configMap, secret). - kube-proxy: Verwaltet iptables-Regeln für ClusterIP-, NodePort- und LoadBalancer-Service-Typen.
Wie man zum Testen ausführt
Der Build erfordert eine aktuelle Rust-Version, den protobuf-Compiler und Docker oder Podman.
Der schnellste Weg zum Testen ist der All-in-One-Modus mit SQLite:
cargo build -p rusternetes
./target/release/rusternetes --data-dir ./cluster.db
Wenn Sie eine ehrlichere Emulation einer Multi-Komponenten-Umgebung über Docker Compose aufsetzen möchten:
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
Nach dem Bootstrap können Sie mit dem Cluster über das Standard-Dienstprogramm kubectl interagieren.
Praktischer Nutzen und Fazit
Rusternetes jetzt in die Produktion zu bringen, lohnt sich nicht: Obwohl das Projekt 94 % der e2e-Tests besteht, bleibt es experimentell. Dennoch hat es drei ausgezeichnete Anwendungsfälle.
Erstens ist es ein ideales Lernmaterial für das Verständnis der Kubernetes-Internals. Rust-Quellcode mit klarer Modulaufteilung zu lesen, ist viel angenehmer als sich durch das große Monolith des originalen K8s zu wühlen.
Zweitens spart das Ausführen eines Clusters in einem einzigen Prozess mit SQLite Ressourcen in Testumgebungen und in CI/CD.
Drittens ist das Projekt nützlich für das Ausführen von Orchestrierung auf schwacher Hardware wie Raspberry Pi oder eingebetteten IoT-Plattformen.
Wenn Sie sich für Systementwicklung in Rust oder die Funktionsweise von Orchestratoren interessieren, verdient das Projekt definitiv einen Star auf GitHub.
Ähnliche Projekte