Saltar al contenido

Plantilla de flujo de trabajo de GitHub Actions para Rust

Última actualización

Este es un .github/workflows/ci.yml funcional para un proyecto de Cargo. Instala la cadena de herramientas estable, almacena en caché las dependencias y los artefactos de compilación con Swatinem/rust-cache y, a continuación, comprueba el formato, ejecuta clippy y las pruebas.

El flujo de trabajo

name: CI

on:
  push:
    branches: [main]
  pull_request:

permissions:
  contents: read

concurrency:
  group: ci-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}

env:
  CARGO_TERM_COLOR: always
  CARGO_INCREMENTAL: "0"
  RUSTFLAGS: "-D warnings"

jobs:
  check:
    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v4

      - uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt, clippy

      - uses: Swatinem/rust-cache@v2

      - run: cargo fmt --all -- --check
      - run: cargo clippy --all-targets --all-features
      - run: cargo test --all-features

Qué hacen las partes menos evidentes

  • dtolnay/rust-toolchain@stable instala una cadena de herramientas según la referencia que elija. @stable sigue la versión estable; utilice referencias como @1.85.0 para fijar una versión exacta.
  • Swatinem/rust-cache@v2 almacena en caché ~/.cargo y el directorio target, indexados por Cargo.lock, la cadena de herramientas y los archivos de manifiesto. Además, elimina los artefactos obsoletos antes de guardar la caché para que no crezca indefinidamente. Consulte caché de Cargo en CI.
  • CARGO_INCREMENTAL: "0" desactiva la compilación incremental. Resulta útil para las recompilaciones locales, pero hace que las cachés de CI sean más grandes y más lentas de restaurar.
  • RUSTFLAGS: "-D warnings" convierte cualquier advertencia del compilador en un error en CI. Además, modifica las opciones de compilación, por lo que las entradas de caché de una compilación sin esta opción no se reutilizan. Manténgala configurada de la misma forma en todas partes.
  • cargo fmt --all -- --check falla si el código no tiene el formato correcto, sin modificar los archivos.
  • --all-targets hace que clippy analice también las pruebas, los ejemplos y los benchmarks.
  • Tiempo límite de 30 minutos. Las compilaciones de Rust en frío son lentas, por lo que el límite es superior al de otras plantillas.

Variantes

Matriz de compilación

En el caso de las bibliotecas, añada un job con matrix.toolchain: [stable, beta, "1.80.0"] para comprobar la versión mínima de Rust compatible. Consulte compilaciones con matriz.

Workspaces

Añada --workspace a los comandos de clippy y de pruebas para abarcar todos los crates miembros. Utilice la entrada workspaces: de rust-cache cuando la raíz del workspace no sea la raíz del repositorio.

Pruebas con base de datos

Añada un bloque services: como se muestra en la plantilla de Django y pase DATABASE_URL.

Compilaciones de producción

Añada un job que ejecute cargo build --release y suba el binario como artefacto. La compilación cruzada es más sencilla con cross o cargo-zigbuild.

macOS o Windows

Añádalos a la matriz si distribuye binarios para ellos.

Ejecútelo en máquinas más rápidas

Los tiempos de compilación de Rust escalan con el número de núcleos, por lo que es una de las pilas que más se beneficia. Cambie una línea:

    runs-on: [self-hosted, Linux, compiler-ci]

El job se ejecuta en una máquina nueva de 8 vCPU de compiler.dev, con alternativa automática. En el benchmark de compiler.dev, una aplicación de React y Rust (Axum) pasó de 2m37s a 1m45s; consulte benchmarks. Los consejos de ajuste están en acelerar Rust y Cargo en GitHub Actions, y los precios figuran en precios.

Preguntas frecuentes

¿También necesito sccache?

No al principio. rust-cache gestiona las dependencias. sccache resulta útil cuando muchos proyectos comparten código compilado.

¿Por qué no deja de crecer mi caché?

rust-cache elimina los artefactos antiguos, pero solo de su propia caché. Consulte límites de caché si alcanza el límite del repositorio.

¿Debe clippy hacer fallar la compilación?

Sí en main. En las pull requests, evita que se acumule deuda de estilo.

¿Puedo compartir la caché entre ramas?

Las ramas pueden restaurar cachés de la rama predeterminada. Asegúrese de que main ejecute el flujo de trabajo para que guarde una.