Rust Admin

O que Todo Dev Deve Saber sobre Deploy de Aplicações Rust em VPS com Docker e Nginx Já leu

Preparando sua Aplicação Rust para Produção Antes de fazer deploy, sua aplicação Rust precisa estar otimizada. O modo release é obrigatório em produção, pois oferece performance significativamente superior ao modo debug. Configure seu com perfis adequados para garantir binários eficientes e tempos de inicialização rápidos. Compile sua aplicação com . Isso gera um executável otimizado em . Para aplicações web, recomendo usar frameworks como Axum ou Actix-web. Aqui está um exemplo simples com Axum que funciona perfeitamente em produção: Adicione ao seu : e . Containerizando com Docker Docker garante que sua aplicação rode identicamente em qualquer VPS. Um bom Dockerfile usa multistage build para reduzir o tamanho final da imagem, eliminando dependências de compilação desnecessárias. Este Dockerfile reduz a imagem final de ~2GB para ~100MB aproximadamente. O primeiro estágio compila tudo, enquanto o segundo estágio contém apenas o binário e dependências mínimas. Crie um para acelerar o build: Configurando Nginx como Reverse Proxy O Nginx atua como intermediário entre

Preparando sua Aplicação Rust para Produção

Antes de fazer deploy, sua aplicação Rust precisa estar otimizada. O modo release é obrigatório em produção, pois oferece performance significativamente superior ao modo debug. Configure seu Cargo.toml com perfis adequados para garantir binários eficientes e tempos de inicialização rápidos.

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
strip = true

Compile sua aplicação com cargo build --release. Isso gera um executável otimizado em target/release/seu_app. Para aplicações web, recomendo usar frameworks como Axum ou Actix-web. Aqui está um exemplo simples com Axum que funciona perfeitamente em produção:

use axum::{routing::get, Router};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(|| async { "Deploy concluído!" }))
        .route("/health", get(|| async { "OK" }));

    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();

    axum::serve(listener, app).await.unwrap();
}

Adicione ao seu Cargo.toml: axum = "0.7" e tokio = { version = "1", features = ["full"] }.

Containerizando com Docker

Docker garante que sua aplicação rode identicamente em qualquer VPS. Um bom Dockerfile usa multistage build para reduzir o tamanho final da imagem, eliminando dependências de compilação desnecessárias.

# Stage 1: Build
FROM rust:latest as builder

WORKDIR /app
COPY . .

RUN cargo build --release

# Stage 2: Runtime
FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=builder /app/target/release/seu_app .

EXPOSE 3000
CMD ["./seu_app"]

Este Dockerfile reduz a imagem final de ~2GB para ~100MB aproximadamente. O primeiro estágio compila tudo, enquanto o segundo estágio contém apenas o binário e dependências mínimas. Crie um .dockerignore para acelerar o build:

target/
.git/
.env
.env.local

Configurando Nginx como Reverse Proxy

O Nginx atua como intermediário entre internet e sua aplicação, gerenciando SSL, compressão e roteamento. Sua aplicação Rust escuta internamente na porta 3000, enquanto o Nginx expõe as portas 80 e 443 publicamente.

Crie um arquivo nginx.conf na raiz do seu projeto:

upstream rust_app {
    server app:3000;
}

server {
    listen 80;
    server_name seu_dominio.com www.seu_dominio.com;

    location / {
        proxy_pass http://rust_app;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
    }

    location /health {
        access_log off;
        proxy_pass http://rust_app;
    }
}

Para HTTPS com Let's Encrypt, use Certbot via Docker ou acesse manualmente na VPS. O nome app refere-se ao serviço Docker definido no docker-compose.yml.

Deploy em VPS com Docker Compose

Docker Compose orquestra seus contêineres, simplificando gerenciamento em produção. Crie um docker-compose.yml:

version: '3.8'

services:
  app:
    build: .
    container_name: rust_app
    restart: always
    networks:
      - app_network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx:
    image: nginx:alpine
    container_name: nginx_proxy
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - ./certs:/etc/nginx/certs:ro
    depends_on:
      - app
    networks:
      - app_network

networks:
  app_network:
    driver: bridge

Na VPS, execute: docker compose up -d. O healthcheck garante que o Docker reinicie automático em caso de falha. Monitore com docker compose logs -f app.

Para atualizações futuras: docker compose down && docker compose up -d --build reconstrói e reinicia tudo.

Conclusão

Você domina agora o pipeline completo de deploy: otimizar código Rust em release, containerizar com multistage Docker, configurar Nginx como reverse proxy profissional e orquestrar tudo com Docker Compose. A combinação garante segurança, performance e resiliência. Lembre-se que o healthcheck é crucial — sem ele, sua aplicação pode cair silenciosamente. Teste localmente com docker compose up antes de fazer push para produção.

Referências

Artigos relacionados