Por qué rust-cache no hace rápida tu CI de Rust (tauri: de 246 s a 53 s)
Swatinem/rust-cache, el paso de caché de la mayoría de las CI de Rust, guarda tus dependencias y deja fuera a propósito los crates de tu workspace. Además fija CARGO_INCREMENTAL=0. En los ejecutores de GitHub cada trabajo empieza en una VM nueva, así que cada trabajo en caliente, con acierto de caché completo y todo, vuelve a compilar tus propios crates. Ningún ajuste de rust-cache lo evita. Lo que sí lo evita es un target/ que sigue ahí desde el último trabajo: entonces Cargo se salta todos los crates que no cambiaron.
Skipbox lo conserva por ti. Tu trabajo se ejecuta en la máquina dedicada de tu cuenta, que conserva el checkout y el target/ de Cargo entre trabajos. El trabajo de CI de tauri tardaba 246 s en GitHub y 53 s ahí, sin compilar ninguno de sus crates desde la primera ejecución en caliente, sin otro cambio en su flujo de trabajo que runs-on: skipbox, por $39 fijos al mes.
Lo que conserva rust-cache, y lo que deja fuera
Según el README de rust-cache y su código fuente:
- Lo que guarda en caché:
~/.cargo(el registro, las dependencias de git, los binarios instalados) y./targetcon la salida de compilación de tus dependencias. - Lo que deja fuera: los crates del workspace no se guardan en caché (“the workspace crates themselves are not cached”). Antes del guardado, su limpieza borra todo lo que hay en
target/que no sea una dependencia, así que los artefactos de tus crates se quitan del propiotarget/. - Compilación incremental: el paso de restauración exporta
CARGO_INCREMENTAL=0para el resto del trabajo. - Cuándo guarda: solo cuando ninguna caché tiene todavía la clave del trabajo. La clave sale de la cadena de herramientas, el entorno, y tus
Cargo.lockyCargo.toml. Tus archivos fuente no forman parte de ella.
En una VM nueva, todo eso se resume en una cosa. Un trabajo en caliente restaura tus dependencias, y luego compila los crates de tu workspace y todo lo que se construye sobre ellos, enteros, cada vez.
El mecanismo, en los logs de tauri
El trabajo test de tauri ejecuta cinco pasos cargo test en Ubuntu, con rust-cache. Estas son sus ejecuciones en caliente, cada una con acierto de caché completo (full match: true en el log):
| Ejecución en caliente | Líneas Compiling | Tiempo de compilación de Cargo | Trabajo |
|---|---|---|---|
| GitHub | 32 | 118 s | 271 s |
| Skipbox, VM nueva | 32 | 62 s | 146 s |
| Skipbox, máquina dedicada, 1.ª ejecución en caliente | 0 | unos 1,5 s | 53 s |
| Skipbox, máquina dedicada, 2.ª ejecución en caliente | 0 | unos 1,9 s | 53 s |
Las 32 líneas son los propios crates de tauri, y dos plugins construidos sobre ellos. Las dependencias nunca aparecen: vienen de la caché. El tiempo de compilación de Cargo es la suma de los tiempos Finished … in de los cinco pasos.
La VM nueva tiene las CPU de la máquina dedicada y la misma caché, y compiló los mismos 32 crates que GitHub: su target/ solo tenía lo que restauró la caché. En la máquina dedicada, la primera ejecución en caliente ya no imprime ninguna línea Compiling. Cargo solo comprobó que nada había cambiado, y cada Finished tardó 0,2-0,7 s.
La primera ejecución en caliente de la máquina dedicada antes volvía a compilar los 32 crates (un trabajo de 114 s), porque el guardado de rust-cache después de la ejecución en frío los había borrado de target/. Desde el 13 de noviembre de 2026, las máquinas dedicadas deshacen lo que la restauración y el guardado de rust-cache borran del disco, cuando termina el paso. La caché que guarda es la misma, y tus crates se quedan en target/.
Tiempos de trabajo: tres proyectos de Rust, seis más
Los propios trabajos de CI de proyectos reales en un commit fijo, con los pasos byte a byte; solo cambiaron el disparador y runs-on. Una ejecución en frío y luego dos en caliente, en cada lado:
- GitHub:
ubuntu-24.04, el ejecutor estándar de un repositorio público: 4 vCPU, 16 GB. - Skipbox, VM nueva: una VM nueva por trabajo a partir de la imagen de ejecutor de producción, 4 vCPU y 8 GB, con las cachés restauradas a través de la caché de Skipbox.
- Skipbox, máquina dedicada: el mismo tamaño en las mismas CPU de host, conservada entre trabajos, con el conservar-y-borrar que ejecutan las máquinas dedicadas desde el 13 de noviembre de 2026: el checkout y
target/se quedan, y lo que borra rust-cache se vuelve a poner.
Las ejecuciones de Skipbox fueron en un host de Skipbox, en un proyecto de laboratorio separado de las máquinas de los clientes. Los tiempos van del inicio de cada trabajo a su final, según la API de GitHub. Cada cifra es la mediana de las dos ejecuciones en caliente. Las ejecuciones en frío de la máquina dedicada tardaron 285 s en tauri, 161 s en ripgrep y 442 s en helix.
| Proyecto | GitHub | Skipbox, VM nueva | Skipbox, máquina dedicada | GitHub ÷ máquina dedicada |
|---|---|---|---|---|
| tauri | 246 s (220, 271) | 210 s (273, 146) | 53 s (53, 53) | 4,6× |
| ripgrep | 200 s (194, 206) | 156 s (155, 156) | 40 s (39, 40) | 5,0× |
| helix | 330 s (293, 366) | 350 s (439, 260) | 224 s (222, 226) | 1,5× |
ripgrep compila dentro de la imagen de Docker de cross. cross crea el propio target/ y lo marca con “created by cross”. Las máquinas dedicadas antes tomaban ese target/ por algo que no era de Cargo y lo borraban después de cada trabajo, así que Cargo volvía a compilar todos los crates en cada ejecución (un trabajo de 108 s). Ahora el target/ de cross se queda: las ejecuciones en caliente no imprimen ninguna línea Compiling, y cada Finished tarda 0,04-0,05 s. GitHub además descarga la imagen de cross en cada ejecución (30 s en la segunda ejecución en caliente); la máquina dedicada la conserva en el disco.
helix también va 1,5× más rápido. De sus crates, solo helix-term (y xtask, que depende de él) se vuelve a compilar, porque el build script de helix-term se ejecuta en cada trabajo: 16 s en el perfil test y 61 s en el perfil integration. Ningún otro crate se compila. La mayor parte del trabajo de helix son pruebas: solo su suite de pruebas de integración tarda 112 s. Su paso de preparación, la cadena de herramientas y la restauración de la caché, tardó 9-10 s frente a 41-46 s en GitHub.
Los demás lenguajes:
| Proyecto | Lenguaje | GitHub | Skipbox, máquina dedicada |
|---|---|---|---|
| astro | Node.js | 528 s | 30 s |
| vite | Node.js | 141 s | 100 s |
| prometheus | Go | 335 s | 273 s |
| cli | Go | 163 s | 137 s |
| pytest | Python | 416 s | 365 s |
| guava | Java | 818 s | 651 s |
astro es la misma historia que target/, con Turborepo: la máquina dedicada conserva la caché de turbo (turbo 2), así que sus ejecuciones en caliente reproducen desde ella las 40 tareas de compilación y la tarea de pruebas en lugar de ejecutarlas (31 s, 28 s).
El ubuntu-latest de un repositorio privado tiene 2 CPU y 8 GB: la mitad de los núcleos de las ejecuciones de GitHub de arriba.
Comprueba tu propia CI
- Abre una ejecución en caliente de tu trabajo de Rust, una cuyo paso de rust-cache registre
full match: true. - En los pasos de compilación y de pruebas, cuenta las líneas
Compiling. Las dependencias que vienen de la caché no imprimen ninguna. Cada uno de los crates de tu workspace imprime una, y también cada crate construido sobre ellos. - Suma los tiempos
Finished … inde los pasos. Eso es lo que te cuestan tus propios crates en cada ejecución, y lo que ahorra untarget/conservado cuando no cambiaron.
Lo que puedes hacer en los ejecutores de GitHub
cache-workspace-crates: true(rust-cache v2.8.0 y posteriores). Tus crates también entran en la caché. Pero una ejecución cuya clave existe se salta el guardado, y la clave no cambia con tu código fuente, así que los crates en caché tienen la edad del último guardado. La compilación incremental sigue desactivada, y la caché crece dentro de los 10 GB por repositorio de GitHub.- sccache. Guarda en caché cada compilación según sus entradas, así que un crate de biblioteca sin cambios vuelve desde el almacenamiento. Los crates que invocan al enlazador no se pueden guardar en caché: los binarios y los crates
dylib,cdyliby proc-macro se compilan cada vez, y cada acierto es una descarga. - Un ejecutor autohospedado que conserve
target/. Tú mantienes la máquina: parchearla, limpiarla entre trabajos sin borrartarget/, y configurarclean: falseen actions/checkout, cuyogit clean -ffdxpredeterminado borratarget/junto con todos los demás archivos ignorados.
Skipbox conserva target/ por ti
Cada plan trae la máquina dedicada de tu cuenta, que se mantiene entre trabajos. Desde el 13 de noviembre de 2026 conserva tu checkout, con las fechas de sus archivos, y el target/ de Cargo:
- La limpieza de actions/checkout se ejecuta como siempre, salvo que deja en paz los directorios
target/de Cargo. - rust-cache se queda en tu flujo de trabajo. Su restauración ya no escribe los artefactos más viejos de la caché encima de los más nuevos del disco.
- Lo que el guardado y la restauración de rust-cache borran de
target/y~/.cargo, la máquina lo vuelve a poner cuando termina el paso. La caché guardada es la misma, y desde el trabajo siguiente a la ejecución en frío, los crates que no cambiaron no se compilan. - El
target/que crea cross (marcado con “created by cross”) también se queda. - actions/checkout reescribe
.git/HEADen cada trabajo. Mientras siga apuntando al mismo commit, el archivo recupera su fecha anterior, así que un build script que vigila.git/HEAD(como hace vergen) no se vuelve a ejecutar solo por eso.
La máquina también conserva las imágenes de Docker, las cachés de paquetes y las herramientas instaladas, así que el resto del trabajo se acelera con ella. Cada trabajo elige su tamaño con la etiqueta:
| Etiqueta | Máquina | Plan |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 al mes |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 al mes |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 al mes |
Los minutos son ilimitados. Con 20.000 minutos al mes en 4 vCPU, GitHub cobra $222; Skipbox S cuesta $39, $183 menos.
Pasarte es una línea
jobs:
test:
runs-on: skipbox # was ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- run: cargo test --workspace
- Inicia sesión en Skipbox con GitHub.
- Instala la app de GitHub de Skipbox y elige los repositorios.
- Cambia
runs-ony haz push.
Seguridad
- La máquina es solo de tu cuenta. Ningún trabajo de otra empresa se ejecuta en ella.
- Después de cada trabajo se borran las credenciales, los procesos y los contenedores del ejecutor, y también las credenciales de git, los hooks y los archivos sin seguimiento del checkout conservado. “VM nueva en cada trabajo” le da a cada trabajo una máquina nueva en su lugar.
- El código de personas sin acceso de escritura (como los pull requests desde forks) se ejecuta en una máquina nueva y desechable, sin
target/conservado.
Los detalles están en cómo se aíslan los trabajos.
Pruébalo con tu trabajo de Rust
La prueba es gratuita durante 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Pasa tu trabajo de Rust a runs-on: skipbox, ejecútalo dos veces y pon las líneas Compiling de la segunda ejecución junto a las de GitHub.
Preguntas frecuentes
¿Swatinem/rust-cache guarda en caché los crates de mi workspace?
No, no de forma predeterminada. Su README dice que los crates del workspace no se guardan en caché, y su paso de guardado borra su salida de compilación de target/ antes de subir la caché. Guarda ~/.cargo y la salida de compilación de tus dependencias, y fija CARGO_INCREMENTAL=0 para el resto del trabajo. Así que en una VM nueva de GitHub, cada ejecución en caliente vuelve a compilar los crates de tu workspace, incluso con un acierto de caché completo. En la CI de tauri en GitHub fueron 32 líneas Compiling en cada ejecución en caliente.
¿Debería configurar cache-workspace-crates: true?
Mete también tus crates en la caché (rust-cache v2.8.0 y posteriores), pero la clave de la caché sale de tu cadena de herramientas, tu entorno y tus Cargo.lock y Cargo.toml, no de tu código fuente. Una ejecución cuya clave ya existe se salta el guardado, así que la copia en caché de tus crates tiene la edad del último guardado y se aleja de tu código con cada commit. La compilación incremental sigue desactivada. Revisa el log de una ejecución en caliente: si tus crates siguen mostrando Compiling, no está ayudando.
¿sccache arregla una CI de Rust lenta en GitHub Actions?
Ayuda con los crates de biblioteca cuyas entradas no cambiaron. sccache no puede guardar en caché los crates que invocan al enlazador (crates bin, dylib, cdylib y proc-macro), y cada acierto es una descarga desde su almacenamiento de caché. Un target/ conservado entre trabajos no necesita descarga: un crate que Cargo ve sin cambios no se compila en absoluto.
¿Tengo que cambiar mi flujo de trabajo para conservar target/ en Skipbox?
No. Cambia runs-on a skipbox y deja rust-cache y actions/checkout como están. Tu máquina dedicada conserva el checkout y el target/ de Cargo entre trabajos, y la limpieza de checkout deja en paz los directorios target/. Cuando el guardado de rust-cache borra tus crates de target/, la máquina los vuelve a poner, y su restauración ya no escribe artefactos más viejos encima de los más nuevos. Así que desde la primera ejecución en caliente, los crates que no cambiaron no se compilan.
¿Cuánto cuesta probarlo?
Nada. La prueba dura 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Pasa tu trabajo de Rust a runs-on: skipbox, ejecútalo dos veces y compara las líneas Compiling y los pasos de compilación de la segunda ejecución con los de GitHub.
Actualizado el 19 de noviembre de 2026