CI/CD para proyectos Rust: configuración de GitHub Actions

Introducción: Por qué CI/CD es importante para proyectos Rust

Desarrollar en Rust no solo se trata de seguridad de memoria y alto rendimiento. En el mundo moderno, cualquier proyecto serio requiere automatización de los procesos de compilación, prueba e implementación. CI/CD (Continuous Integration / Continuous Deployment) permite a los equipos lanzar actualizaciones más rápido, reduciendo el riesgo de errores humanos y garantizando la estabilidad de la base de código.

GitHub Actions es una herramienta integrada de GitHub para automatizar flujos de trabajo. Es ideal para proyectos Rust, ya que proporciona acciones listas para instalar el compilador, almacenar en caché dependencias y publicar crates en crates.io. En este artículo, analizaremos cómo configurar un pipeline CI/CD completo para una aplicación Rust desde cero.

1. Fundamentos de GitHub Actions para Rust

Antes de sumergirnos en el código, comprendamos la estructura básica de GitHub Actions. Cada workflow se define en un archivo YAML ubicado en el directorio .github/workflows/. Un workflow consta de uno o más jobs (tareas), que se ejecutan de forma secuencial o paralela en máquinas virtuales (runners).

Para proyectos Rust, un workflow mínimo incluye los siguientes pasos:

• Checkout — obtener la última versión del código del repositorio.
• Instalar Rust — mediante la acción actions-rs/toolchain o la oficial dtolnay/rust-toolchain.
• Cachear dependencias — acelerar la compilación guardando target/ y ~/.cargo/.
• Compilar y probar — ejecutar cargo build y cargo test.

Ejemplo de un workflow básico (archivo .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 se ejecuta con cada push a la rama main y al crear un pull request. Verifica que el código compile, pase las pruebas, no contenga errores de linter y cumpla con el estilo de formato.

2. Estrategias avanzadas: compilación matricial y almacenamiento en caché

Rust es un lenguaje multiplataforma y, a menudo, es necesario verificar la compilación en varios sistemas operativos o arquitecturas. Para esto se utiliza la compilación matricial (matrix build).

Agreguemos soporte para Windows y macOS a nuestro 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 --