Deploy de uma aplicação Rust no Brasil: passo a passo

Se você procurou como fazer deploy de uma aplicação Rust no Brasil, este post é o caminho mais curto entre o seu cargo run local e a aplicação no ar, rodando em infraestrutura nacional.

A Brasa Cloud faz deploy direto do Git: você conecta o repositório, dá push e a plataforma faz o build e publica o serviço. Rust está entre as linguagens suportadas — a regra é simples: se tem Dockerfile, roda na Brasa. Aqui a gente mostra o Dockerfile e o fluxo, sem prometer nada que a plataforma não faça.

Por que rodar Rust no Brasil

Rust gera um binário compilado, sem runtime pesado pra carregar junto. É uma combinação natural com containers: imagem pequena, processo único, sobe rápido.

Rodar esse binário em infraestrutura no Brasil tem efeitos práticos:

• Latência menor para usuários no Brasil, já que os servidores estão em território nacional.
• Dados em território nacional, o que facilita a adequação à LGPD.
• Cobrança em Real (BRL), sem variação cambial na fatura.

E, durante o beta aberto, você pode começar gratuitamente.

Pré-requisitos

Você vai precisar de:

• Uma aplicação Rust que compila localmente (cargo build --release funcionando).
• Um repositório no GitHub.
• Uma conta na Brasa Cloud (o beta é gratuito).

Pro exemplo, vamos assumir um serviço HTTP simples que escuta numa porta lida da variável de ambiente PORT. Ler a porta do ambiente é importante: é assim que a plataforma diz pro seu serviço onde escutar.

Passo 1: o Dockerfile

A plataforma detecta um Dockerfile no repositório e usa ele pro build. Pra Rust, o padrão é um multi-stage build: um estágio compila com cargo build, outro estágio só carrega o binário final. Isso mantém a imagem de produção pequena.

# Estágio 1: build
FROM rust:1-slim AS builder
WORKDIR /app

# Cacheia as dependências separadamente do código
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo "fn main() {}" > src/main.rs
RUN cargo build --release
RUN rm -rf src

# Compila a aplicação de verdade
COPY src ./src
RUN cargo build --release

# Estágio 2: runtime
FROM debian:stable-slim
WORKDIR /app
COPY --from=builder /app/target/release/meu-app /usr/local/bin/meu-app

# A plataforma injeta a variável PORT
ENV PORT=8080
EXPOSE 8080
CMD ["meu-app"]

Troque meu-app pelo nome do binário definido no seu Cargo.toml (o campo name em [package], ou o nome do binário em [[bin]]).

O truque do estágio de build — copiar Cargo.toml e Cargo.lock e compilar um main.rs vazio antes de copiar o código real — faz o Docker cachear a camada de dependências. Como o build da plataforma usa cache inteligente entre builds, os deploys seguintes ficam mais rápidos quando só o seu código muda.

Passo 2: leia a porta do ambiente

O ponto onde a maioria dos deploys de Rust trava é o bind da porta. Não fixe a porta no código; leia de PORT. Com a crate axum, por exemplo:

use std::env;
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    let port: u16 = env::var("PORT")
        .unwrap_or_else(|_| "8080".to_string())
        .parse()
        .expect("PORT inválida");

    let app = axum::Router::new()
        .route("/", axum::routing::get(|| async { "ok" }));

    let addr = SocketAddr::from(([0, 0, 0, 0], port));
    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Repare no 0.0.0.0: dentro de um container, escutar só em 127.0.0.1 deixa o serviço inacessível de fora. Escute em todas as interfaces.

Passo 3: deploy via Git

Com o Dockerfile no repositório, o fluxo é o mesmo de qualquer outro serviço na Brasa Cloud:

1. Conecte o GitHub pelo painel, autorizando via OAuth. Sem copiar token na mão.
2. Escolha o repositório e a branch que dispara o deploy (por exemplo, main para produção).
3. Faça push. Cada commit na branch configurada inicia o build automaticamente. Você acompanha os logs de build em tempo real pelo painel.

Quando o build termina, o serviço recebe uma URL pública com HTTPS. Se algum deploy der problema, dá pra fazer rollback para uma versão anterior pelo painel.

git add Dockerfile src Cargo.toml Cargo.lock
git commit -m "Deploy do serviço Rust na Brasa Cloud"
git push origin main
# o build inicia sozinho; acompanhe os logs no painel

Variáveis de ambiente e banco de dados

Se a sua aplicação Rust precisa de segredos (uma chave de API, uma connection string), configure as variáveis de ambiente pelo painel — elas ficam disponíveis pro processo em runtime.

Precisa de banco? A plataforma tem bancos de dados gerenciados (PostgreSQL, MySQL, Redis, MongoDB, entre outros). Você provisiona pelo painel e usa a connection string como variável de ambiente no seu serviço Rust.

Resumo do fluxo de deploy de Rust no Brasil

Código Rust  →  Dockerfile (cargo build, multi-stage)
            →  git push na branch configurada
            →  build automático com cache
            →  serviço no ar, URL com HTTPS, infra no Brasil

Sem YAML pra escrever, sem servidor pra configurar. O que você precisa garantir é o básico do lado do container: um Dockerfile que compila o binário e um processo que escuta na porta de PORT, em 0.0.0.0.

A Brasa Cloud está em beta aberto e a cobrança é em Real (BRL), operada pela FULCRO TECNOLOGIA LTDA (CNPJ 62.771.087/0001-58). Conecte seu repositório e suba seu serviço Rust: brasacloud.com.