CI/CD para proyectos Rust: GitHub Actions nivel avanzado

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

Un pipeline básico de CI/CD para Rust está bien, pero en proyectos reales, especialmente con múltiples plataformas, dependencias y la necesidad de retroalimentación rápida, un simple cargo test no es suficiente. Una configuración avanzada de GitHub Actions permite reducir el tiempo de compilación en 2-3 veces, verificar automáticamente el código en diferentes arquitecturas, publicar crates y realizar linting.

En este artículo, analizaremos técnicas avanzadas: almacenamiento en caché de dependencias, matriz de compilaciones para Windows/macOS/Linux, ejecución paralela de pruebas, publicación en crates.io e integración con Clippy.

1. Optimización del tiempo de compilación: almacenamiento en caché y compilaciones incrementales

La operación más costosa en CI para Rust es la compilación de dependencias. Sin almacenamiento en caché, cada ejecución descargará y compilará todos los crates de nuevo. La solución es usar el caché integrado de GitHub Actions.

Almacenamiento en caché básico del directorio target

jobs:  build:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4      - uses: actions-rust-lang/setup-rust-toolchain@v1      - name: Cache Rust dependencies        uses: actions/cache@v3        with:          path: |            ~/.cargo/registry            ~/.cargo/git            target          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}      - run: cargo build --release

Punto clave: la clave de caché incluye el hash de Cargo.lock. Si las dependencias no cambian, la caché se restaura instantáneamente.

Separación avanzada de caché para pruebas y compilación

Para proyectos grandes, tiene sentido separar la caché para cargo build y cargo test, para no recompilar los binarios de prueba al compilar la versión de lanzamiento:

- name: Cache cargo build  uses: actions/cache@v3  with:    path: |      ~/.cargo/registry      ~/.cargo/git      target/debug/.fingerprint      target/debug/build    key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }}

2. Matriz de compilaciones: pruebas en todas las plataformas

Rust se compila para múltiples plataformas. Para garantizar el correcto funcionamiento en Windows, macOS y Linux, utilizamos una estrategia de matriz (matrix strategy).

Ejemplo de matriz para tres SO

jobs:  test:    strategy:      matrix:        os: [ubuntu-latest, windows-latest, macos-latest]        toolchain: [stable, beta]        features:          - default          - all    runs-on: ${{ matrix.os }}    steps:      - uses: actions/checkout@v4      - uses: actions-rust-lang/setup-rust-toolchain@v1        with:          toolchain: ${{ matrix.toolchain }}      - name: Run tests        run: cargo test --features ${{ matrix.features }}

Este enfoque crea automáticamente 6 trabajos paralelos (3 SO × 2 toolchains). Puede agregar verificación para nightly, arquitecturas arm64 o compilación cruzada para WASM.

Exclusión de combinaciones innecesarias

strategy:  matrix:    os: [ubuntu-latest, windows-latest, macos-latest]    toolchain: [stable, nightly]    exclude:      - os: macos-latest        toolchain: nightly  # No probamos nightly en macOS

3. Linting, formateo y seguridad

Además de las pruebas, el CI avanzado incluye análisis estático. Agreguemos verificaciones de clippy, rustfmt y cargo-audit para vulnerabilidades.

Trabajo separado para linting

lint:  runs-on: ubuntu-latest  steps:    - uses: actions/checkout@v4    - uses: actions-rust-lang/setup-rust-toolchain@v1      with:        components: clippy, rustfmt    - name: Check formatting      run: cargo fmt --check    - name: Clippy with warnings as errors      run: cargo clippy -- -D warnings

Verificación de seguridad