Perché rust-cache non rende veloce la tua CI Rust (tauri: da 246 s a 53 s)
Swatinem/rust-cache, lo step di cache della maggior parte delle CI Rust, salva le tue dipendenze e lascia fuori di proposito i crate del tuo workspace. Imposta anche CARGO_INCREMENTAL=0. Sui runner di GitHub ogni job parte su una VM nuova, quindi ogni job a caldo, con un hit completo della cache e tutto, compila di nuovo i tuoi crate. Nessuna impostazione di rust-cache lo evita. Lo evita un target/ ancora lì dall'ultimo job: Cargo allora salta ogni crate che non è cambiato.
Skipbox lo conserva per te. Il tuo job gira sulla macchina del tuo account, che conserva il checkout e il target/ di Cargo tra un job e l'altro. Il job di CI di tauri ha impiegato 246 s su GitHub e 53 s lì, senza compilare nessuno dei suoi crate dalla prima esecuzione a caldo, senza nessuna modifica al workflow a parte runs-on: skipbox, a un prezzo fisso di $39 al mese.
Cosa conserva rust-cache, e cosa lascia fuori
Dal README di rust-cache e dal suo sorgente:
- Cosa mette in cache:
~/.cargo(il registry, le dipendenze git, i binari installati) e./targetcon l'output di build delle tue dipendenze. - Cosa lascia fuori: "the workspace crates themselves are not cached". Prima del salvataggio, la sua pulizia cancella tutto quello che in
target/non è una dipendenza, quindi gli artifact dei tuoi crate vengono tolti datarget/stesso. - Compilazione incrementale: lo step di ripristino esporta
CARGO_INCREMENTAL=0per il resto del job. - Quando salva: solo quando nessuna cache ha ancora la chiave del job. La chiave viene dalla toolchain, dall'ambiente e dai tuoi
Cargo.lockeCargo.toml. I tuoi file sorgente non ne fanno parte.
Su una VM nuova tutto questo porta a una cosa sola. Un job a caldo ripristina le tue dipendenze, poi compila i crate del tuo workspace e tutto quello che ci si costruisce sopra, per intero, ogni volta.
Il meccanismo, nei log di tauri
Il job test di tauri esegue cinque step cargo test su Ubuntu, con rust-cache. Ecco le sue esecuzioni a caldo, ognuna con un hit completo della cache (full match: true nel log):
| Esecuzione a caldo | Righe Compiling | Tempo di build di Cargo | Job |
|---|---|---|---|
| GitHub | 32 | 118 s | 271 s |
| Skipbox, VM nuova | 32 | 62 s | 146 s |
| Skipbox, macchina dell'account, 1ª esecuzione a caldo | 0 | circa 1,5 s | 53 s |
| Skipbox, macchina dell'account, 2ª esecuzione a caldo | 0 | circa 1,9 s | 53 s |
Le 32 righe sono i crate di tauri, più due plugin costruiti sopra. Le dipendenze non compaiono mai: arrivano dalla cache. Il tempo di build di Cargo è la somma dei tempi Finished … in dei cinque step.
La VM nuova ha le CPU della macchina dell'account e la stessa cache, e ha compilato gli stessi 32 crate di GitHub: il suo target/ conteneva solo quello che la cache aveva ripristinato. Sulla macchina dell'account, già la prima esecuzione a caldo non stampa nessuna riga Compiling. Cargo ha solo verificato che niente fosse cambiato, e ogni Finished ha richiesto 0,2-0,7 s.
La prima esecuzione a caldo della macchina dell'account compilava di nuovo tutti i 32 crate (un job da 114 s), perché il salvataggio di rust-cache dopo l'esecuzione a freddo li aveva cancellati da target/. Dal 13 novembre 2026, le macchine dell'account annullano quello che il ripristino e il salvataggio di rust-cache cancellano dal disco, appena lo step finisce. La cache che salva è la stessa, e i tuoi crate restano in target/.
Tempi dei job: tre progetti Rust, sei altri
I job di CI di progetti reali a un commit fissato, gli step byte per byte; sono cambiati solo il trigger e runs-on. Un'esecuzione a freddo, poi due a caldo, su ogni lato:
- GitHub:
ubuntu-24.04, il runner standard di un repository pubblico: 4 vCPU, 16 GB. - Skipbox, VM nuova: una nuova VM per job dall'immagine di produzione del runner, 4 vCPU e 8 GB, cache ripristinate tramite la cache di Skipbox.
- Skipbox, macchina dell'account: la stessa dimensione sulle stesse CPU dell'host, tenuta tra un job e l'altro, con il conserva-e-pulisci che le macchine dell'account eseguono dal 13 novembre 2026: il checkout e
target/restano, e quello che rust-cache cancella viene rimesso al suo posto.
Le esecuzioni Skipbox sono state fatte su un host Skipbox, in un progetto di laboratorio tenuto separato dalle macchine dei clienti. I tempi vanno dall'inizio alla fine di ogni job, dall'API di GitHub. Ogni cifra è la mediana delle due esecuzioni a caldo. Le esecuzioni a freddo della macchina dell'account hanno richiesto 285 s per tauri, 161 s per ripgrep e 442 s per helix.
| Progetto | GitHub | Skipbox, VM nuova | Skipbox, macchina dell'account | GitHub ÷ macchina dell'account |
|---|---|---|---|---|
| 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 l'immagine Docker di cross. cross crea target/ da solo e lo marca "created by cross". Le macchine dell'account scambiavano quel target/ per qualcosa di diverso da quello di Cargo e lo cancellavano dopo ogni job, quindi Cargo ricompilava ogni crate a ogni esecuzione (un job da 108 s). Ora il target/ di cross resta: le esecuzioni a caldo non stampano nessuna riga Compiling, e ogni Finished richiede 0,04-0,05 s. GitHub scarica anche l'immagine di cross a ogni esecuzione (30 s nella seconda esecuzione a caldo); la macchina dell'account la tiene sul disco.
Anche helix gira 1,5× più veloce. Dei suoi crate, solo helix-term (e xtask, che dipende da lui) viene ricompilato, perché lo script di build di helix-term gira a ogni job: 16 s nel profilo test e 61 s nel profilo integration. Nessun altro crate viene compilato. La maggior parte del job di helix sono i suoi test: la sola suite di test di integrazione gira per 112 s. Il suo step di setup, toolchain e ripristino della cache, ha richiesto 9-10 s contro 41-46 s su GitHub.
Gli altri linguaggi:
| Progetto | Linguaggio | GitHub | Skipbox, macchina dell'account |
|---|---|---|---|
| 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 è la stessa storia di target/, con Turborepo: la macchina dell'account conserva la cache di turbo (turbo 2), quindi le sue esecuzioni a caldo riproducono da lì tutti i 40 task di build e il task di test invece di eseguirli (31 s, 28 s).
L'ubuntu-latest di un repository privato ha 2 CPU e 8 GB: metà dei core delle esecuzioni GitHub qui sopra.
Controlla la tua CI
- Apri un'esecuzione a caldo del tuo job Rust, una in cui lo step di rust-cache scrive nel log
full match: true. - Negli step di build e di test, conta le righe
Compiling. Le dipendenze dalla cache non ne stampano. Ognuno dei crate del tuo workspace ne stampa una, e così ogni crate costruito sopra. - Somma i tempi
Finished … indegli step. È quanto costano i tuoi crate a ogni esecuzione, ed è quello che untarget/conservato fa risparmiare quando non sono cambiati.
Cosa puoi fare sui runner di GitHub
cache-workspace-crates: true(da rust-cache v2.8.0). Anche i tuoi crate vanno in cache. Ma un'esecuzione la cui chiave esiste salta il salvataggio, e la chiave non cambia con i tuoi sorgenti, quindi i crate in cache sono vecchi quanto l'ultimo salvataggio. La compilazione incrementale resta spenta, e la cache cresce dentro i 10 GB per repository di GitHub.- sccache. Mette in cache ogni compilazione in base ai suoi input, quindi un crate di libreria invariato torna dallo storage. I crate che invocano il linker non si possono mettere in cache: binari, crate
dylib,cdylibe proc-macro vengono compilati ogni volta, e ogni hit è un download. - Un runner self-hosted che conserva
target/. La macchina la gestisci tu: aggiornarla, pulirla tra un job e l'altro senza cancellaretarget/, e impostareclean: falsesu actions/checkout, il cuigit clean -ffdxdi default cancellatarget/insieme a ogni altro file ignorato.
Skipbox conserva target/ per te
Ogni piano include la macchina del tuo account, tenuta tra un job e l'altro. Dal 13 novembre 2026 conserva il tuo checkout, con gli orari dei suoi file, e il target/ di Cargo:
- La pulizia di actions/checkout gira come al solito, tranne che lascia stare le directory
target/di Cargo. - rust-cache resta nel tuo workflow. Il suo ripristino non scrive più gli artifact più vecchi della cache sopra quelli più nuovi sul disco.
- Quello che il salvataggio e il ripristino di rust-cache cancellano da
target/e~/.cargo, la macchina lo rimette al suo posto appena lo step finisce. La cache salvata è la stessa, e dal job dopo l'esecuzione a freddo i crate che non sono cambiati non vengono compilati. - Resta anche il
target/creato da cross (marcato "created by cross"). - actions/checkout riscrive
.git/HEADa ogni job. Finché indica ancora lo stesso commit, il file riprende il suo orario precedente, così uno script di build che osserva.git/HEAD(vergen lo fa) non rigira solo per questo.
La macchina conserva anche immagini Docker, cache dei pacchetti e tool installati, quindi accelera insieme anche il resto del job. Un job sceglie la sua dimensione con l'etichetta:
| Etichetta | Macchina | Piano |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 al mese |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 al mese |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 al mese |
I minuti sono illimitati. A 20.000 minuti al mese su 4 vCPU, GitHub fattura $222; Skipbox S costa $39, $183 in meno.
Basta una riga
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
- Accedi a Skipbox con GitHub.
- Installa la GitHub App di Skipbox e scegli i repository.
- Cambia
runs-one fai push.
Sicurezza
- La macchina è solo del tuo account. Nessun job di altre aziende gira su di essa.
- Dopo ogni job vengono cancellati le credenziali, i processi e i container del runner, e anche le credenziali git, gli hook e i file non tracciati del checkout conservato. “VM nuova per ogni job” dà invece a ogni job una macchina nuova.
- Il codice di chi non ha accesso in scrittura (come le pull request dai fork) gira su una macchina nuova, usata una volta e poi eliminata, senza nessun
target/conservato.
I dettagli sono in come vengono isolati i job.
Provalo sul tuo job Rust
La prova è gratuita per 7 giorni o 3000 minuti di job, quello che arriva prima, e non chiede la carta. Sposta il tuo job Rust su runs-on: skipbox, eseguilo due volte e metti le righe Compiling della seconda esecuzione accanto a quelle di GitHub.
Domande frequenti
Swatinem/rust-cache mette in cache i crate del mio workspace?
No, non di default. Il suo README dice che i crate del workspace non vengono messi in cache, e il suo step di salvataggio cancella il loro output di build da target/ prima di caricare la cache. Mette in cache ~/.cargo e l'output di build delle tue dipendenze, e imposta CARGO_INCREMENTAL=0 per il resto del job. Così su una VM nuova di GitHub ogni esecuzione a caldo compila di nuovo i crate del tuo workspace, anche con un hit completo della cache. Nella CI di tauri su GitHub erano 32 righe Compiling a ogni esecuzione a caldo.
Devo impostare cache-workspace-crates: true?
Mette in cache anche i tuoi crate (da rust-cache v2.8.0), ma la chiave della cache viene dalla toolchain, dall'ambiente e da Cargo.lock e Cargo.toml, non dai tuoi sorgenti. Un'esecuzione la cui chiave esiste già salta il salvataggio, quindi la copia in cache dei tuoi crate è vecchia quanto l'ultimo salvataggio e si allontana dal tuo codice a ogni commit. La compilazione incrementale resta spenta. Controlla il log di un'esecuzione a caldo: se i tuoi crate mostrano ancora Compiling, non sta aiutando.
sccache risolve la CI Rust lenta su GitHub Actions?
Aiuta con i crate di libreria i cui input non sono cambiati. sccache non può mettere in cache i crate che invocano il linker (crate bin, dylib, cdylib e proc-macro), e ogni hit è un download dal suo storage di cache. Un target/ conservato tra un job e l'altro non ha bisogno di download: un crate che Cargo vede invariato non viene compilato affatto.
Devo cambiare il mio workflow per conservare target/ su Skipbox?
No. Cambia runs-on in skipbox e lascia rust-cache e actions/checkout come sono. La tua macchina conserva il checkout e il target/ di Cargo tra un job e l'altro, e la pulizia del checkout lascia stare le directory target/. Quando il salvataggio di rust-cache cancella i tuoi crate da target/, la macchina li rimette al loro posto, e il suo ripristino non scrive più artifact più vecchi sopra quelli più nuovi. Così dalla prima esecuzione a caldo i crate che non sono cambiati non vengono compilati.
Quanto costa provarlo?
Niente. La prova dura 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta. Sposta il tuo job Rust su runs-on: skipbox, eseguilo due volte e confronta le righe Compiling e gli step di build della seconda esecuzione con quelli di GitHub.
Aggiornata il giorno 16 novembre 2026