CI/CD para projetos Rust: configuração do GitHub Actions

Introdução: Por que CI/CD é importante para projetos Rust

Desenvolver em Rust não é apenas sobre segurança de memória e alta performance. No mundo moderno, qualquer projeto sério requer automação dos processos de compilação, teste e implantação. CI/CD (Continuous Integration / Continuous Deployment) permite que as equipes lancem atualizações mais rapidamente, reduzindo o risco de erros humanos e garantindo a estabilidade da base de código.

GitHub Actions é uma ferramenta integrada do GitHub para automatizar fluxos de trabalho. Ela é ideal para projetos Rust, pois fornece actions prontas para instalar o compilador, armazenar dependências em cache e publicar crates no crates.io. Neste artigo, vamos abordar como configurar um pipeline CI/CD completo para uma aplicação Rust do zero.

1. Fundamentos do GitHub Actions para Rust

Antes de mergulhar no código, vamos entender a estrutura básica do GitHub Actions. Cada workflow é definido por um arquivo YAML localizado no diretório .github/workflows/. Um workflow consiste em um ou mais jobs (tarefas), que são executados sequencialmente ou em paralelo em máquinas virtuais (runners).

Para projetos Rust, um workflow mínimo inclui os seguintes passos:

• Checkout — obter a versão mais recente do código do repositório.
• Instalar Rust — através da action actions-rs/toolchain ou da oficial dtolnay/rust-toolchain.
• Armazenar dependências em cache — acelerar a compilação salvando target/ e ~/.cargo/.
• Compilar e testar — executar cargo build e cargo test.

Exemplo de workflow básico (arquivo .github/workflows/ci.yml):

name: Rust CI

on:  push:    branches: [ main ]  pull_request:    branches: [ main ]

env:  CARGO_TERM_COLOR: always

jobs:  build:    runs-on: ubuntu-latest

    steps:    - uses: actions/checkout@v3        - name: Install Rust      uses: dtolnay/rust-toolchain@stable      with:        components: clippy, rustfmt        - name: Cache dependencies      uses: actions/cache@v3      with:        path: |          ~/.cargo/          target/        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}        - name: Build      run: cargo build --verbose        - name: Run tests      run: cargo test --verbose        - name: Lint with clippy      run: cargo clippy -- -D warnings        - name: Check formatting      run: cargo fmt --check

Este workflow é executado a cada push no branch main e ao criar um pull request. Ele verifica se o código compila, passa nos testes, não contém erros de lint e está em conformidade com o estilo de formatação.

2. Estratégias avançadas: compilação matricial e cache

Rust é uma linguagem multiplataforma, e muitas vezes é necessário verificar a compilação em vários sistemas operacionais ou arquiteturas. Para isso, utiliza-se a compilação matricial (matrix build).

Vamos adicionar suporte para Windows e macOS ao nosso workflow:

jobs:  build:    strategy:      matrix:        os: [ubuntu-latest, windows-latest, macos-latest]        rust: [stable, beta]        runs-on: ${{ matrix.os }}        steps:    - uses: actions/checkout@v3        - name: Install Rust      uses: dtolnay/rust-toolchain@master      with:        toolchain: ${{ matrix.rust }}        components: clippy        - name: Cache      uses: actions/cache@v3      with:        path: |          ~/.cargo/registry/          ~/.cargo/git/          target/        key: ${{ matrix.os }}-cargo-${{ matrix.rust }}-${{ hashFiles('**/Cargo.lock') }}        - name: Build      run: cargo build --