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, comobuildytest, 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 solomainescriba la caché y los PR solo la lean. Así evita llenar su cuota con cachés de PR.cache-on-failure: defínalo comotruepara guardar la caché aunque falle una prueba, de modo que una compilación fallida también prepare la siguiente ejecución.cache-all-cratesycache-workspace-crates: ambos tienenfalsepor 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
lldomoldmedianteRUSTFLAGSo.cargo/config.tomlpuede 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"odebug = falsepara las compilaciones de CI. Menos información de depuración significa menos que escribir y enlazar. - Verificar antes de compilar.
cargo clippyya comprueba los tipos. Ejecútelo en un trabajo junto a las pruebas, en lugar de ejecutarcargo checkycargo builduno tras otro. - Compilaciones de release. Compile con
--releasesolo 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.
Relacionado
- Acelere un monorepo de TypeScript en GitHub ActionsAcelere la comprobación de tipos y el linting en un monorepo TypeScript con GitHub Actions: tsc incremental, referencias de proyecto y cachés.
- Acelere Playwright en un monorepo con GitHub ActionsAcelere las pruebas e2e de Playwright en un monorepo Node con GitHub Actions: compile la app una vez y omita e2e si no cambió.
- Añada una insignia de velocidad de CI a su READMEMuestre la velocidad de su CI con una insignia en el README: el tiempo mediano de ejecución en GitHub Actions, actualizado automáticamente. Gratis.
- Cachear Cargo y compilaciones de Rust en GitHub ActionsCachee el registro de Cargo, las dependencias git y el directorio target en GitHub Actions con Swatinem/rust-cache o actions/cache, sin cachés inflados.