Implantação de Rust no Kubernetes: guia básico na prática

Introdução

Rust é uma linguagem de programação moderna que combina o alto desempenho de C/C++ com segurança de memória em nível de compilação. Graças à ausência de coletor de lixo e ao baixo consumo de recursos, aplicações em Rust são ideais para execução em ambientes conteinerizados. Kubernetes (K8s) é o padrão de facto para orquestração de contêineres. Neste guia, vamos abordar na prática como criar uma aplicação web simples em Rust, empacotá-la em uma imagem Docker e implantá-la em um cluster Kubernetes.

O artigo é voltado para desenvolvedores que já conhecem os fundamentos de Rust e têm uma noção básica de Docker e Kubernetes. Não vamos nos aprofundar na teoria, mas focar em instruções passo a passo com exemplos reais de código e comandos.

1. Preparação da aplicação em Rust

Como exemplo, criaremos um servidor HTTP mínimo usando o popular framework actix-web. Ele responderá a requisições GET e retornará uma resposta JSON.

Crie um novo projeto:

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

Adicione as dependências no Cargo.toml:

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

Agora vamos escrever o código do servidor em 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: "Serviço 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 must be a number");\n\n    println!("Servidor iniciado em {}:{}", 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}

Observe: extraímos o host e a porta para variáveis de ambiente. Esta é uma prática padrão para aplicações conteinerizadas — a configuração deve vir de fora.

Verifique se a aplicação compila e executa localmente:

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

Abra o navegador em http://localhost:8080/health — você deve ver uma resposta JSON.

2. Criação da imagem Docker

Para implantar no Kubernetes, precisamos empacotar a aplicação em uma imagem Docker. Usaremos multi-stage build para minimizar o tamanho da imagem final.

Crie um arquivo Dockerfile na raiz do projeto:

# Estágio de compilação\nFROM rust:1.75-slim-bookworm AS builder\n\nWORKDIR /app\n\n# Copiar apenas Cargo.toml para cache de dependências\nCOPY Cargo.toml Cargo.lock ./\nRUN mkdir src && echo "fn main() {}" > src/main.rs\nRUN cargo build --release 2>/dev/null || true\n\n# Agora copiar o código fonte real\nCOPY src ./src\nRUN cargo build --release\n\n# Imagem 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"]

Compile a imagem:

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

Verifique o tamanho da imagem