Despliegue de Rust en Kubernetes: guía básica práctica

Introducción

Rust es un lenguaje de programación de sistemas moderno que combina el alto rendimiento de C/C++ con la seguridad de memoria a nivel de compilación. Gracias a la ausencia de un recolector de basura y al bajo consumo de recursos, las aplicaciones en Rust son ideales para ejecutarse en entornos contenerizados. Kubernetes (K8s) es el estándar de facto para la orquestación de contenedores. En esta guía, veremos en la práctica cómo crear una aplicación web simple en Rust, empaquetarla en una imagen Docker y desplegarla en un clúster de Kubernetes.

El artículo está dirigido a desarrolladores que ya conocen los fundamentos de Rust y tienen una comprensión básica de Docker y Kubernetes. No profundizaremos en la teoría, sino que nos centraremos en una instrucción paso a paso con ejemplos reales de código y comandos.

1. Preparación de la aplicación en Rust

Como ejemplo, crearemos un servidor HTTP mínimo utilizando el popular framework actix-web. Responderá a solicitudes GET y devolverá una respuesta JSON.

Cree un nuevo proyecto:

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

Agregue las dependencias en Cargo.toml:

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

Ahora escribamos el código del servidor en 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: "Servicio funcionando".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 debe ser un número");\n\n    println!("Servidor iniciado en {}:{}", 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}

Tenga en cuenta: hemos externalizado el host y el puerto a variables de entorno. Esta es una práctica estándar para aplicaciones contenerizadas: la configuración debe provenir del exterior.

Verifique que la aplicación se compile y ejecute localmente:

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

Abra el navegador en http://localhost:8080/health — debería ver una respuesta JSON.

2. Creación de la imagen Docker

Para el despliegue en Kubernetes, necesitamos empaquetar la aplicación en una imagen Docker. Usaremos una compilación de múltiples etapas (multi-stage build) para minimizar el tamaño de la imagen final.

Cree un archivo Dockerfile en la raíz del proyecto:

# Etapa de compilación\nFROM rust:1.75-slim-bookworm AS builder\n\nWORKDIR /app\n\n# Copiamos solo Cargo.toml para almacenar en caché las dependencias\nCOPY Cargo.toml Cargo.lock ./\nRUN mkdir src && echo "fn main() {}" > src/main.rs\nRUN cargo build --release 2>/dev/null || true\n\n# Ahora copiamos el código fuente real\nCOPY src ./src\nRUN cargo build --release\n\n# Imagen final\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"]

Construya la imagen:

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

Verifique el tamaño de la imagen