Bereitstellung von Rust auf Kubernetes: Ein praktisches Grundlagen-Tutorial

Einleitung

Rust ist eine moderne systemnahe Programmiersprache, die die hohe Leistung von C/C++ mit Speichersicherheit auf Compiler-Ebene kombiniert. Dank des Fehlens eines Garbage Collectors und des geringen Ressourcenverbrauchs eignen sich Rust-Anwendungen ideal für den Einsatz in Container-Umgebungen. Kubernetes (K8s) ist der De-facto-Standard für die Container-Orchestrierung. In diesem Tutorial werden wir praktisch durchgehen, wie man eine einfache Webanwendung in Rust erstellt, sie in ein Docker-Image packt und in einem Kubernetes-Cluster bereitstellt.

Der Artikel richtet sich an Entwickler, die bereits mit den Grundlagen von Rust vertraut sind und grundlegende Kenntnisse über Docker und Kubernetes haben. Wir werden nicht in die Theorie eintauchen, sondern uns auf eine Schritt-für-Schritt-Anleitung mit echten Code- und Befehlsbeispielen konzentrieren.

1. Vorbereitung der Rust-Anwendung

Als Beispiel erstellen wir einen minimalen HTTP-Server mit dem beliebten Framework actix-web. Er wird auf GET-Anfragen antworten und eine JSON-Antwort zurückgeben.

Erstellen Sie ein neues Projekt:

cargo new rust-k8s-app\ncd rust-k8s-app

Fügen Sie die Abhängigkeiten in Cargo.toml hinzu:

[dependencies]\nactix-web = "4"\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"

Jetzt schreiben wir den Server-Code in src/main.rs:

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};\nuse serde::Serialize;\n\n#[derive(Serialize)]\nstruct HealthResponse {\n    status: String,\n    message: String,\n}\n\n#[get("/health")]\nasync fn health_check() -> impl Responder {\n    HttpResponse::Ok().json(HealthResponse {\n        status: "ok".to_string(),\n        message: "Dienst läuft".to_string(),\n    })\n}\n\n#[get("/")]\nasync fn index() -> impl Responder {\n    HttpResponse::Ok().json(serde_json::json!({\n        "service": "rust-k8s-app",\n        "version": env!("CARGO_PKG_VERSION")\n    }))\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    let host = std::env::var("HOST").unwrap_or_else(|_| "0.0.0.0".to_string());\n    let port: u16 = std::env::var("PORT")\n        .unwrap_or_else(|_| "8080".to_string())\n        .parse()\n        .expect("PORT muss eine Zahl sein");\n\n    println!("Server gestartet auf {}:{}", host, port);\n\n    HttpServer::new(|| {\n        App::new()\n            .service(health_check)\n            .service(index)\n    })\n    .bind((host.as_str(), port))?\n    .run()\n    .await\n}

Beachten Sie: Wir haben Host und Port in Umgebungsvariablen ausgelagert. Dies ist eine gängige Praxis für containerisierte Anwendungen – die Konfiguration sollte von außen kommen.

Überprüfen Sie, ob die Anwendung lokal erstellt wird und läuft:

cargo build --release\n./target/release/rust-k8s-app

Öffnen Sie den Browser unter http://localhost:8080/health – Sie sollten eine JSON-Antwort sehen.

2. Erstellung des Docker-Images

Für die Bereitstellung in Kubernetes müssen wir die Anwendung in ein Docker-Image packen. Wir verwenden einen Multi-Stage-Build, um die Größe des endgültigen Images zu minimieren.

Erstellen Sie eine Datei Dockerfile im Projektstammverzeichnis:

# Build-Stufe\nFROM rust:1.75-slim-bookworm AS builder\n\nWORKDIR /app\n\n# Nur Cargo.toml kopieren, um Abhängigkeiten zu cachen\nCOPY Cargo.toml Cargo.lock ./\nRUN mkdir src && echo "fn main() {}" > src/main.rs\nRUN cargo build --release 2>/dev/null || true\n\n# Jetzt den echten Quellcode kopieren\nCOPY src ./src\nRUN cargo build --release\n\n# Finales Image\nFROM debian:bookworm-slim\n\nRUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*\n\nCOPY --from=builder /app/target/release/rust-k8s-app /usr/local/bin/rust-k8s-app\n\nEXPOSE 8080\n\nCMD ["rust-k8s-app"]

Erstellen Sie das Image:

docker build -t rust-k8s-app:latest .

Überprüfen Sie die Image-Größe