Implantação de Rust no Kubernetes: guia básico para desenvolvedores

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

O desenvolvimento moderno em nuvem exige que as aplicações tenham alta performance, segurança e uso eficiente de recursos. Rust, com seu sistema de ownership e abstrações de custo zero, é ideal para criar microsserviços que rodam em orquestradores de contêineres. Kubernetes, por sua vez, fornece um poderoso conjunto de ferramentas para gerenciar aplicações conteinerizadas. Neste guia, vamos passo a passo preparar uma aplicação Rust para implantação no Kubernetes, criar uma imagem Docker e implantá-la em um cluster.

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

Antes de implantar a aplicação no Kubernetes, é necessário conteinerizá-la. Para demonstração, criaremos uma aplicação HTTP simples baseada no framework actix-web, que responderá a requisições e retornará informações básicas do sistema.

Criaremos um novo projeto:

cargo new rust-k8s-appcd rust-k8s-app

Adicionaremos as dependências no Cargo.toml:

[dependencies]actix-web = "4"serde = { version = "1.0", features = ["derive"] }tokio = { version = "1", features = ["full"] }

Escreveremos uma aplicação simples em src/main.rs:

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};use serde::Serialize;

#[derive(Serialize)]struct HealthResponse {    status: String,    version: String,}

#[get("/health")]async fn health_check() -> impl Responder {    HttpResponse::Ok().json(HealthResponse {        status: "ok".to_string(),        version: env!("CARGO_PKG_VERSION").to_string(),    })}

#[get("/")]async fn index() -> impl Responder {    HttpResponse::Ok().body("Rust on Kubernetes! 🚀")}

#[actix_web::main]async fn main() -> std::io::Result<()> {    let host = std::env::var("HOST").unwrap_or_else(|_| "0.0.0.0".to_string());    let port: u16 = std::env::var("PORT")        .unwrap_or_else(|_| "8080".to_string())        .parse()        .expect("PORT must be a number");

    println!("Starting server at {}:{}", host, port);

    HttpServer::new(|| {        App::new()            .service(health_check)            .service(index)    })    .bind((host.as_str(), port))?    .run()    .await}

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

cargo build --releasecargo run --release

Após a execução, abra o navegador e acesse http://localhost:8080/health — você deverá ver um JSON com a resposta.

2. Criação da imagem Docker para a aplicação Rust

Para minimizar o tamanho da imagem e acelerar a construção, usaremos multi-stage build. O primeiro estágio é a compilação da aplicação, o segundo é a criação de uma imagem mínima baseada em scratch ou alpine.

Crie um arquivo Dockerfile na raiz do projeto:

# Estágio 1: CompilaçãoFROM rust:1.75-slim-buster AS builder

WORKDIR /appCOPY Cargo.toml Cargo.lock ./RUN mkdir src && echo "fn main() {}" > src/main.rsRUN cargo build --release 2>/dev/null || true

COPY src/ ./src/RUN cargo build --release

# Estágio 2: Imagem mínimaFROM debian:buster-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*COPY --from=builder /app/target/release/rust-k8s-app /usr/local/bin/rust-k8s-app

EXPOSE 8080CMD ["rust-k8s-app"]

Compile a imagem:

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

Verifique se a imagem funciona:

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

Em seguida, envie a imagem para o Docker Hub ou outro registry de contêineres, substituindo username pelo seu nome de usuário:

docker tag rust-k8s-app:latest username/rust-k8s-app:latestdocker push user