Déploiement de Rust sur Kubernetes : guide de base pour développeurs

Déploiement de Rust sur Kubernetes : guide de base

Le développement cloud moderne exige des applications une haute performance, une sécurité renforcée et une utilisation efficace des ressources. Rust, avec son système de possession et ses abstractions à coût zéro, est idéal pour créer des microservices fonctionnant dans des orchestrateurs de conteneurs. Kubernetes, quant à lui, fournit une boîte à outils puissante pour gérer les applications conteneurisées. Dans ce guide, nous allons pas à pas préparer une application Rust pour le déploiement sur Kubernetes, créer une image Docker et la déployer dans un cluster.

1. Préparation de l'application Rust

Avant de déployer l'application sur Kubernetes, il faut la conteneuriser. Pour la démonstration, créons une simple application HTTP basée sur le framework actix-web, qui répondra aux requêtes et renverra des informations de base sur le système.

Créons un nouveau projet :

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

Ajoutons les dépendances dans Cargo.toml :

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

Écrivons une application simple dans 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}

Vérifions que l'application se compile et se lance localement :

cargo build --releasecargo run --release

Après le lancement, ouvrez le navigateur et allez à l'adresse http://localhost:8080/health — vous devriez voir un JSON avec la réponse.

2. Création de l'image Docker pour l'application Rust

Pour minimiser la taille de l'image et accélérer la construction, nous allons utiliser une construction multi-étapes (multi-stage build). La première étape est la compilation de l'application, la seconde est la création d'une image minimale basée sur scratch ou alpine.

Créez un fichier Dockerfile à la racine du projet :

# Étape 1 : ConstructionFROM 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

# Étape 2 : Image minimaleFROM 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"]

Construisez l'image :

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

Vérifiez que l'image fonctionne :

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

Ensuite, envoyez l'image sur Docker Hub ou un autre registre de conteneurs, en remplaçant username par votre nom d'utilisateur :

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