Deployment von Rust auf Kubernetes: Ein grundlegendes Leitfaden für Entwickler

Deployment von Rust auf Kubernetes: Ein grundlegender Leitfaden

Die moderne Cloud-Entwicklung erfordert von Anwendungen hohe Leistung, Sicherheit und effiziente Ressourcennutzung. Rust eignet sich mit seinem Ownership-System und seinen Zero-Cost-Abstraktionen ideal für die Erstellung von Microservices, die in Container-Orchestratoren laufen. Kubernetes wiederum bietet leistungsstarke Werkzeuge zur Verwaltung containerisierter Anwendungen. In diesem Leitfaden gehen wir Schritt für Schritt durch, wie Sie eine Rust-Anwendung für das Deployment in Kubernetes vorbereiten, ein Docker-Image erstellen und es in einem Cluster bereitstellen.

1. Vorbereitung der Rust-Anwendung

Bevor Sie die Anwendung in Kubernetes deployen, muss sie containerisiert werden. Zur Demonstration erstellen wir eine einfache HTTP-Anwendung auf Basis des Frameworks actix-web, die auf Anfragen antwortet und grundlegende Systeminformationen zurückgibt.

Erstellen wir ein neues Projekt:

cargo new rust-k8s-appcd rust-k8s-app

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

[dependencies]actix-web = "4"serde = { version = "1.0", features = ["derive"] }tokio = { version = "1", features = ["full"] }

Schreiben wir eine einfache Anwendung in src/main.rs:

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};use serde::Serialize;

#[derive(Serialize)]struct HealthResponse {    status: String,    version: String,}

#[get("/health")]async fn health_check() -> impl Responder {    HttpResponse::Ok().json(HealthResponse {        status: "ok".to_string(),        version: env!("CARGO_PKG_VERSION").to_string(),    })}

#[get("/")]async fn index() -> impl Responder {    HttpResponse::Ok().body("Rust on Kubernetes! 🚀")}

#[actix_web::main]async fn main() -> std::io::Result<()> {    let host = std::env::var("HOST").unwrap_or_else(|_| "0.0.0.0".to_string());    let port: u16 = std::env::var("PORT")        .unwrap_or_else(|_| "8080".to_string())        .parse()        .expect("PORT must be a number");

    println!("Starting server at {}:{}", host, port);

    HttpServer::new(|| {        App::new()            .service(health_check)            .service(index)    })    .bind((host.as_str(), port))?    .run()    .await}

Überprüfen wir, ob die Anwendung kompiliert und lokal läuft:

cargo build --releasecargo run --release

Nach dem Start öffnen Sie den Browser und gehen Sie zu http://localhost:8080/health – Sie sollten eine JSON-Antwort sehen.

2. Erstellen eines Docker-Images für die Rust-Anwendung

Um die Image-Größe zu minimieren und den Build zu beschleunigen, verwenden wir einen Multi-Stage-Build. Die erste Stufe ist die Kompilierung der Anwendung, die zweite die Erstellung eines minimalen Images basierend auf scratch oder alpine.

Erstellen Sie eine Datei Dockerfile im Projektstammverzeichnis:

# Stage 1: BuildFROM rust:1.75-slim-buster AS builder

WORKDIR /appCOPY Cargo.toml Cargo.lock ./RUN mkdir src && echo "fn main() {}" > src/main.rsRUN cargo build --release 2>/dev/null || true

COPY src/ ./src/RUN cargo build --release

# Stage 2: Minimales ImageFROM debian:buster-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*COPY --from=builder /app/target/release/rust-k8s-app /usr/local/bin/rust-k8s-app

EXPOSE 8080CMD ["rust-k8s-app"]

Bauen Sie das Image:

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

Überprüfen Sie, ob das Image funktioniert:

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

Übertragen Sie dann das Image in Docker Hub oder eine andere Container-Registry, indem Sie username durch Ihren Benutzernamen ersetzen:

docker tag rust-k8s-app:latest username/rust-k8s-app:latestdocker push user