CI/CD para Rust: Automatização de build e deploy do zero

Por que seu projeto Rust merece um CI/CD de verdade?

Imagine: você escreve em Rust, o compilador é seu melhor amigo, o borrow checker não deixa você relaxar, e o código funciona na velocidade da luz. Mas quando chega a hora do deploy, a magia acaba. Executar testes manualmente, compilar na máquina local, enviar o binário para o servidor via SCP — isso é um caminho sem volta. Especialmente quando o projeto cresce e um segundo desenvolvedor entra na equipe.

CI/CD (Continuous Integration / Continuous Deployment) não é apenas uma palavra da moda. É um sistema que assume a rotina: rodar testes, verificar o estilo do código, compilar a versão de release e enviá-la para onde ela deve funcionar. Para Rust, com seu foco em confiabilidade e desempenho, a automatização da compilação é uma extensão natural da filosofia da linguagem.

Neste artigo, configuraremos do zero um pipeline CI/CD para uma aplicação Rust no GitHub Actions. Você aprenderá a organizar testes, linting, compilação de binários para diferentes plataformas e deploy. Tudo com exemplos reais de código que podem ser copiados para o seu projeto.

O que vamos automatizar?

Antes de escrever código, vamos definir os objetivos. Nosso pipeline fará quatro coisas:

\n
• Linting e formatação — para que o código esteja de acordo com os padrões do Rust e não contenha erros típicos.
\n
• Testes — execução de todos os testes unitários e, se houver, testes de integração.
\n
• Compilação do binário — compilação da versão otimizada (release).
\n
• Deploy — upload do artefato compilado para o servidor ou para as releases do GitHub.
\n

Tudo isso acontecerá automaticamente a cada push no branch main ou ao criar um pull request. Parece mágica? Na verdade, são apenas arquivos YAML e alguns comandos do Cargo.

Passo 1: Preparação do projeto

Para o exemplo, usaremos um servidor web simples com Actix-web. Mas o pipeline é universal: serve para qualquer projeto Rust, seja uma CLI, biblioteca ou microsserviço.

Criaremos um novo projeto:

cargo new rust-ci-cd-demo --bin\ncd rust-ci-cd-demo

Adicionaremos as dependências no Cargo.toml:

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

E o código mais simples no src/main.rs:

use actix_web::{get, App, HttpResponse, HttpServer, Responder};\n\n#[get("/")]\nasync fn hello() -> impl Responder {\n    HttpResponse::Ok().body("Hello from Rust CI/CD!")\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    HttpServer::new(|| {\n        App::new().service(hello)\n    })\n    .bind(("0.0.0.0", 8080))?\n    .run()\n    .await\n}

Adicionaremos um teste simples no src/main.rs (no final do arquivo):

#[cfg(test)]\nmod tests {\n    use actix_web::{test, App, web};\n    use crate::hello;\n\n    #[actix_web::test]\n    async fn test_hello_endpoint() {\n        let app = test::init_service(App::new().service(hello)).await;\n        let req = test::TestRequest::get().uri("/").to_request();\n        let resp = test::call_service(&app, req).await;\n        assert!(resp.status().is_success());\n    }\n}

Tudo pronto. Agora a parte mais interessante — a configuração do CI/CD.

Passo 2: Criando o workflow do GitHub Actions

GitHub Actions é a ferramenta de CI/CD integrada do GitHub. Ela funciona com base em arquivos YAML que ficam no diretório .github/workflows/. Vamos criá-lo:

mkdir -p .github/workflows\ntouch .github/workflows/ci.yml

Abriremos o ci.yml e começaremos a escrever o pipeline. Vamos chamá-lo de "Rust CI/CD Pipeline".

Trigger básico e ambiente

name: Rust CI/CD Pipeline\n\non:\n  push:\n    branches: [ main ]\n  pull_request:\n    branches: [ main ]\n\nenv:\n  CARGO_TERM_CO