Despliegue de Rust en Kubernetes: guía básica para principiantes

Despliegue de Rust en Kubernetes: guía básica para principiantes

El desarrollo moderno cada vez más requiere no solo escribir código rápido y seguro, sino también saber cómo desplegarlo correctamente en una infraestructura en la nube. Rust, conocido por su rendimiento y seguridad de memoria, se convierte en una excelente opción para microservicios. Y Kubernetes, el orquestador de contenedores estándar, ayuda a gestionar estos servicios a escala.

En este artículo, recorreremos el camino completo desde la escritura de un servidor web simple en Rust hasta su despliegue en un clúster de Kubernetes. Aprenderá cómo empaquetar la aplicación en una imagen Docker, crear los manifiestos necesarios y ejecutarla en la nube.

1. Preparación de la aplicación Rust para contenerización

Para empezar, crearemos una aplicación web simple en Rust utilizando el popular framework actix-web. Devolverá un mensaje JSON simple: un ejemplo ideal para un microservicio.

Cree un nuevo proyecto:

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

Agregue la dependencia en Cargo.toml:

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

Ahora escribamos el código de la aplicación en 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}

Tenga en cuenta: nos vinculamos a 0.0.0.0:8080, ya que dentro del contenedor la aplicación debe escuchar en todas las interfaces. Verifique localmente:

cargo run

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

2. Creación de la imagen Docker con la aplicación Rust

Para Kubernetes necesitamos un contenedor. Rust se compila en un binario nativo, por lo que podemos usar una compilación multi-etapa (multi-stage build) para obtener una imagen mínima.

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\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# Imagen final\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"]

Este Dockerfile primero compila las dependencias, luego compila nuestro código y copia el binario en una imagen mínima basada en Debian. Esto ahorra espacio y mejora la seguridad.

Construya la imagen:

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

Verifique el contenedor localmente:

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

Si todo funciona — suba la imagen a un registro (por ejemplo, Docker Hub):

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

3. Configuración de los manifiestos de Kubernetes

Ahora que la imagen está lista, necesitamos crear los manifiestos para Kubernetes. Crearemos un Deployment (para gestionar réplicas) y un Service (para