Déploiement de Rust sur Kubernetes : guide pratique de base

Introduction

Rust est un langage de programmation système moderne qui combine les hautes performances du C/C++ avec la sécurité mémoire au niveau de la compilation. Grâce à l'absence de ramasse-miettes et à une faible consommation de ressources, les applications Rust sont idéales pour fonctionner dans des environnements conteneurisés. Kubernetes (K8s) est la norme de facto pour l'orchestration de conteneurs. Dans ce guide, nous allons voir en pratique comment construire une simple application web en Rust, l'empaqueter dans une image Docker et la déployer dans un cluster Kubernetes.

Cet article s'adresse aux développeurs qui connaissent déjà les bases de Rust et ont une compréhension élémentaire de Docker et Kubernetes. Nous n'approfondirons pas la théorie, mais nous concentrerons sur des instructions étape par étape avec des exemples concrets de code et de commandes.

1. Préparation de l'application Rust

À titre d'exemple, nous allons créer un serveur HTTP minimal utilisant le framework populaire actix-web. Il répondra aux requêtes GET et renverra une réponse JSON.

Créez un nouveau projet :

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

Ajoutez les dépendances dans Cargo.toml :

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

Écrivons maintenant le code du serveur dans 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: "Le service fonctionne".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 must be a number");\n\n    println!("Serveur démarré sur {}:{}", 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}

Notez que nous avons externalisé l'hôte et le port dans des variables d'environnement. C'est une pratique standard pour les applications conteneurisées — la configuration doit venir de l'extérieur.

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

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

Ouvrez le navigateur à l'adresse http://localhost:8080/health — vous devriez voir une réponse JSON.

2. Construction de l'image Docker

Pour le déploiement dans Kubernetes, nous devons empaqueter l'application dans une image Docker. Nous utilisons une construction multi-étapes (multi-stage build) pour minimiser la taille de l'image finale.

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

# Étape de construction\nFROM rust:1.75-slim-bookworm AS builder\n\nWORKDIR /app\n\n# Copier uniquement Cargo.toml pour mettre en cache les dépendances\nCOPY Cargo.toml Cargo.lock ./\nRUN mkdir src && echo "fn main() {}" > src/main.rs\nRUN cargo build --release 2>/dev/null || true\n\n# Copier maintenant le code source réel\nCOPY src ./src\nRUN cargo build --release\n\n# Image finale\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"]

Construisez l'image :

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

Vérifiez la taille de l'image