Saltar al contenido

Acelere Rust Cargo en GitHub Actions

Última actualización

Para acelerar Rust y Cargo en GitHub Actions, guarde en caché el directorio target y el registro de cargo con Swatinem/rust-cache, desactive la compilación incremental con CARGO_INCREMENTAL=0, ejecute las pruebas con cargo-nextest y asigne más núcleos a la compilación. La CI de Rust es lenta principalmente porque la compilación de dependencias es pesada y se repite en cada máquina virtual nueva.

Esta guía ofrece un flujo de trabajo funcional y explica las ventajas e inconvenientes de cada opción. Para la versión general, consulte cómo acelerar GitHub Actions.

Guarde las dependencias en caché con rust-cache

Swatinem/rust-cache es la opción estándar. Su README documenta lo que almacena: ~/.cargo (registro, caché, dependencias de git y binarios instalados) y ./target (artefactos de compilación de las dependencias). Antes de guardar, elimina lo que no servirá la próxima vez: artefactos incrementales, crates del workspace, dependencias no utilizadas y archivos con más de una semana. Así la caché se mantiene pequeña.

- uses: actions/checkout@v7
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2

Opciones que conviene conocer, todas tomadas del README:

  • shared-key: use una misma clave en los trabajos que compilan lo mismo, como build y test, para que compartan la caché. Sin ella, el id del trabajo forma parte de la clave.
  • workspaces: asigne los workspaces a sus directorios target, por ejemplo . -> target. Es necesario en estructuras no estándar.
  • save-if: defínalo como ${{ github.ref == 'refs/heads/main' }} para que solo main escriba la caché y los PR solo la lean. Así evita llenar su cuota con cachés de PR.
  • cache-on-failure: defínalo como true para guardar la caché aunque falle una prueba, de modo que una compilación fallida también prepare la siguiente ejecución.
  • cache-all-crates y cache-workspace-crates: ambos tienen false por defecto. Active el segundo solo si tiene un workspace grande con crates internos estables.
- uses: Swatinem/rust-cache@v2
  with:
    shared-key: ci
    save-if: ${{ github.ref == 'refs/heads/main' }}
    cache-on-failure: true

Desactive la compilación incremental en CI

La compilación incremental ahorra tiempo de recompilación en la máquina del desarrollador, almacenando datos adicionales en disco. En CI se compila una vez desde un estado prácticamente limpio, así que añade sobrecarga y artefactos voluminosos sin ningún beneficio. Desactívela para todo el trabajo:

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

rust-cache ya elimina los datos incrementales antes de guardar, pero CARGO_INCREMENTAL=0 además evita el coste de generarlos. Considere -D warnings como opcional: hace que las advertencias fallen la compilación, lo cual es una decisión de política y modifica las opciones de compilación, así que manténgala igual en todos los trabajos que compartan caché.

Caché de compilación con sccache

mozilla-actions/sccache-action añade una segunda capa: sccache guarda en caché las salidas individuales de rustc. Según su README, defina SCCACHE_GHA_ENABLED: "true" y RUSTC_WRAPPER: "sccache" en env, y añada el paso de la acción:

env:
  SCCACHE_GHA_ENABLED: "true"
  RUSTC_WRAPPER: "sccache"
steps:
  - uses: mozilla-actions/sccache-action@v0.0.11

sccache y rust-cache se solapan. Use primero rust-cache. sccache aporta más en estos casos: un workspace grande en el que cambiar un crate invalida gran parte de target, compilaciones con muchos conjuntos de features distintos, o un equipo con un almacenamiento remoto compartido. Tiene límites: la salida de la compilación incremental no se guarda en caché (otra razón para definir CARGO_INCREMENTAL=0) y algunos tipos de crate no son cacheables. Mida ambas opciones antes de mantener una pieza adicional.

Ejecute las pruebas con cargo-nextest

cargo-nextest ejecuta cada prueba en su propio proceso y reparte las pruebas entre todos los núcleos. Suele ser más rápido que cargo test en suites con muchos binarios de prueba, y admite particionado para dividir en fragmentos. La documentación de nextest muestra cómo instalarlo con taiki-e/install-action:

- uses: taiki-e/install-action@v2
  with:
    tool: nextest
- run: cargo nextest run --workspace --profile ci

Tenga en cuenta que nextest no ejecuta los doctests, así que mantenga cargo test --doc como un paso aparte. Para dividir en fragmentos entre trabajos, nextest dispone de --partition count:1/4 (también el modo hash:); coloque el índice en una matriz. Consulte división de pruebas en fragmentos en GitHub Actions.

Enlazador y perfil de compilación

  • Enlazador más rápido. El enlazado es monohilo y lento en binarios grandes. Usar lld o mold mediante RUSTFLAGS o .cargo/config.toml puede reducir notablemente el tiempo de enlazado. Las versiones estables recientes de la toolchain en Linux x86_64 pueden incluir ya un enlazador más rápido por defecto, así que revise las notas de la versión antes de añadir opciones.
  • Información de depuración. Defina [profile.dev] debug = "line-tables-only" o debug = false para las compilaciones de CI. Menos información de depuración significa menos que escribir y enlazar.
  • Verificar antes de compilar. cargo clippy ya comprueba los tipos. Ejecútelo en un trabajo junto a las pruebas, en lugar de ejecutar cargo check y cargo build uno tras otro.
  • Compilaciones de release. Compile con --release solo cuando vaya a distribuir. lto = "thin" es más barato que "fat".

Lo que aportan más núcleos de CPU

rustc paraleliza entre crates y unidades de generación de código, y nextest paraleliza entre pruebas, por lo que Rust escala con los núcleos hasta el paso de enlazado. Nuestros benchmarks incluyen una fila de Rust: React + Rust (Axum) + Postgres pasó de 2m37s en un runner alojado por GitHub a 1m45s en compiler.dev (1.5x), en una ejecución completa de CI con 10 particiones de pruebas y una base de datos real, medido el 8 de octubre de 2026. Es menos que en los stacks de Go y Gradle, y una caché caliente influye en ello: una compilación en caché tiene poco que compilar.

Puede probar su propio flujo de trabajo cambiando una línea a runs-on: [self-hosted, Linux, compiler-ci]. Consulte precios y el selector de tamaño de runner. Relacionado: la plantilla de Rust, la caché de GitHub Actions y la caché de capas de Docker para compilaciones de contenedores.

Preguntas frecuentes

¿Necesito tanto rust-cache como sccache?

Normalmente no. Empiece con rust-cache. Añada sccache si los workspaces grandes o las muchas combinaciones de features siguen recompilando demasiado.

¿Por qué definir CARGO_INCREMENTAL=0 en CI?

Los datos incrementales ayudan en las recompilaciones locales repetidas. En CI añaden escrituras en disco y tamaño de caché sin mejorar una compilación limpia.

¿Es cargo-nextest más rápido que cargo test?

A menudo, en suites con muchas pruebas, porque reparte las pruebas entre los núcleos en procesos separados. No incluye las pruebas de documentación (doctests), así que ejecútelas por separado.

¿Cómo evito que las PR llenen la caché?

Use save-if: ${{ github.ref == 'refs/heads/main' }} en rust-cache, de modo que las PR restauren la caché pero nunca la guarden.

Ejecute esta compilación de Rust en compiler.dev Sin tarjeta · 200 minutos gratuitos

Pruébelo gratis