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

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

Le développement moderne exige de plus en plus non seulement d'écrire du code rapide et sécurisé, mais aussi de savoir le déployer correctement dans une infrastructure cloud. Rust, connu pour ses performances et sa sécurité mémoire, devient un excellent choix pour les microservices. Et Kubernetes — l'orchestrateur de conteneurs standard — aide à gérer ces services à grande échelle.

Dans cet article, nous allons parcourir le chemin complet, de l'écriture d'un simple serveur web en Rust jusqu'à son déploiement dans un cluster Kubernetes. Vous apprendrez à empaqueter l'application dans une image Docker, à créer les manifestes nécessaires et à l'exécuter dans le cloud.

1. Préparation de l'application Rust pour la conteneurisation

Pour commencer, créons une simple application web en Rust en utilisant le framework populaire actix-web. Elle retournera un simple message JSON — un exemple idéal pour un microservice.

Créez un nouveau projet :

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

Ajoutez la dépendance dans Cargo.toml :

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

Écrivons maintenant le code de l'application dans 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}

Notez : nous nous lions à 0.0.0.0:8080, car à l'intérieur du conteneur, l'application doit écouter toutes les interfaces. Testez localement :

cargo run

Ouvrez http://localhost:8080/health — vous devriez voir une réponse JSON.

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

Pour Kubernetes, nous avons besoin d'un conteneur. Rust compile en un binaire natif, nous pouvons donc utiliser une construction multi-étapes (multi-stage build) pour obtenir une image minimale.

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

# Étape de construction\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# Image finale\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"]

Ce Dockerfile construit d'abord les dépendances, puis compile notre code et copie le binaire dans une image minimale basée sur Debian. Cela économise de l'espace et améliore la sécurité.

Construisez l'image :

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

Testez le conteneur localement :

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

Si tout fonctionne — chargez l'image dans un registre (par exemple, Docker Hub) :

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

3. Configuration des manifestes Kubernetes

Maintenant que l'image est prête, nous devons créer les manifestes pour Kubernetes. Nous allons créer un Deployment (pour gérer les répliques) et un Service (pour