Bereitstellung von Rust auf Kubernetes: Ein grundlegender Leitfaden für Anfänger

Bereitstellung von Rust auf Kubernetes: Ein grundlegender Leitfaden für Anfänger

Die moderne Entwicklung erfordert zunehmend nicht nur das Schreiben von schnellem und sicherem Code, sondern auch die Fähigkeit, diesen korrekt in einer Cloud-Infrastruktur bereitzustellen. Rust, bekannt für seine Leistung und Speichersicherheit, wird zu einer hervorragenden Wahl für Microservices. Und Kubernetes – der Standard-Container-Orchestrator – hilft bei der Verwaltung dieser Dienste im großen Maßstab.

In diesem Artikel gehen wir den gesamten Weg vom Schreiben eines einfachen Webservers in Rust bis zu seiner Bereitstellung in einem Kubernetes-Cluster. Sie erfahren, wie Sie die Anwendung in ein Docker-Image verpacken, die erforderlichen Manifeste erstellen und sie in der Cloud ausführen.

1. Vorbereitung der Rust-Anwendung für die Containerisierung

Erstellen wir zunächst eine einfache Webanwendung in Rust mit dem beliebten Framework actix-web. Sie wird eine einfache JSON-Nachricht zurückgeben – ein ideales Beispiel für einen Microservice.

Erstellen Sie ein neues Projekt:

cargo new rust-k8s-demo\ncd rust-k8s-demo

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

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

Schreiben wir nun den Anwendungscode in src/main.rs:

use actix_web::{web, App, HttpServer, Responder, HttpResponse};\nuse serde::Serialize;\n\n#[derive(Serialize)]\nstruct HealthResponse {\n    status: String,\n    message: String,\n}\n\nasync fn health_check() -> impl Responder {\n    HttpResponse::Ok().json(HealthResponse {\n        status: "ok".to_string(),\n        message: "Rust service is running on Kubernetes!".to_string(),\n    })\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    println!("Starting server on 0.0.0.0:8080");\n    HttpServer::new(|| {\n        App::new()\n            .route("/health", web::get().to(health_check))\n    })\n    .bind("0.0.0.0:8080")?\n    .run()\n    .await\n}

Beachten Sie: Wir binden an 0.0.0.0:8080, da die Anwendung innerhalb des Containers auf allen Schnittstellen lauschen muss. Testen Sie lokal:

cargo run

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

2. Erstellen eines Docker-Images mit der Rust-Anwendung

Für Kubernetes benötigen wir einen Container. Rust wird in eine native Binärdatei kompiliert, daher können wir einen mehrstufigen Build (multi-stage build) verwenden, um ein minimales Image zu erhalten.

Erstellen Sie eine Datei Dockerfile im Projektstammverzeichnis:

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

Dieses Dockerfile baut zuerst die Abhängigkeiten, kompiliert dann unseren Code und kopiert die Binärdatei in ein minimales Image basierend auf Debian. Das spart Platz und erhöht die Sicherheit.

Erstellen Sie das Image:

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

Testen Sie den Container lokal:

docker run -p 8080:8080 rust-k8s-demo:latest

Wenn alles funktioniert, laden Sie das Image in eine Registry (z. B. Docker Hub) hoch:

docker tag rust-k8s-demo:latest yourusername/rust-k8s-demo:v1\ndocker push yourusername/rust-k8s-demo:v1

3. Konfiguration der Kubernetes-Manifeste

Nachdem das Image fertig ist, müssen wir Manifeste für Kubernetes erstellen. Wir werden ein Deployment (zur Verwaltung von Replikaten) und einen Service (zur