CI/CD para proyectos Rust: GitHub Actions — parte 2

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

CI/CD para proyectos Rust: GitHub Actions — Parte 2: Pruebas y Despliegue

En la primera parte, configuramos un pipeline de compilación básico para un proyecto Rust. Ahora, profundizando en la programación en Rust, veremos las pruebas automatizadas, el linting y el despliegue. Esta es una etapa obligatoria del aprendizaje de Rust para principiantes que quieren escribir código profesional. Hoy aprenderás cómo hacer que tu CI/CD sea realmente útil.

1. Ejecución de pruebas y verificación de cobertura

Cualquier proyecto Rust serio requiere la ejecución automática de pruebas. En GitHub Actions, esto se hace con el comando cargo test. Sin embargo, para obtener el máximo beneficio, añade la verificación de cobertura de código usando tarpaulin.

Configuración del entorno de pruebas

Añade un paso a tu archivo de workflow (.github/workflows/ci.yml):

name: CI for Rust

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      - name: Run tests
        run: cargo test --verbose
      - name: Generate coverage
        run: |
          cargo install cargo-tarpaulin
          cargo tarpaulin --out Xml
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          token: ${{ secrets.CODECOV_TOKEN }}

Este código muestra lo fácil que es integrar Rust con servicios externos. cargo tarpaulin creará un informe que se puede subir a Codecov o Coveralls. Para Rust para principiantes, es importante entender: las pruebas son tu primera línea de defensa.

2. Linting y formateo

El código de calidad no solo es código que funciona, sino también código legible. En Rust, hay dos herramientas poderosas: clippy (linter) y rustfmt (formateador). Inclúyelas en el pipeline.

Añadiendo Clippy y Rustfmt

Añade un nuevo job o extiende el existente:

  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          components: clippy, rustfmt
      - name: Check formatting
        run: cargo fmt -- --check
      - name: Run Clippy
        run: cargo clippy -- -D warnings

La bandera -D warnings convierte las advertencias en errores. Esto es estricto pero efectivo para el aprendizaje: descubrirás inmediatamente posibles problemas. Recuerda que en la programación en Rust, la rigurosidad es una ventaja.

3. Despliegue automático en GitHub Pages

Cuando las pruebas y el linting hayan pasado, puedes publicar automáticamente la documentación. Rust genera documentación mediante cargo doc. Desplegar en GitHub Pages es una excelente manera de mostrar los resultados.

Workflow para el despliegue

Crea un archivo separado .github/workflows/deploy.yml:

name: Deploy Documentation

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
      - name: Build documentation
        run: cargo doc --no-deps --document-private-items
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./target/doc

Este pipeline se activa solo con pushes a main. Genera documentación y la publica. Para Rust para principiantes, esta es una excelente manera de mostrar tus proyectos al mundo.