# Perché rust-cache non rende veloce la tua CI Rust (tauri: da 246 s a 53 s)

> Swatinem/rust-cache mette in cache le tue dipendenze, non i crate del tuo workspace, e spegne la compilazione incrementale. Così sulla VM nuova di GitHub ogni job a caldo compila di nuovo i tuoi crate. Un target/ conservato su una macchina che resta lo risolve: il job di CI di tauri è passato da 246 s a 53 s su Skipbox, a un prezzo fisso di $39 al mese.

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.

- Il job di CI di tauri: 246 s su GitHub, 53 s su Skipbox (4,6× più veloce). Ogni esecuzione è pubblica
- Con `target/` conservato, Cargo non ha compilato nessuno dei crate di tauri: il suo tempo di build è passato da 62 s a meno di 2 s
- 20.000 minuti al mese su 4 vCPU: $222 su GitHub, $39 su Skipbox

**GitHub Actions a prezzo fisso, minuti illimitati** Skipbox esegue i tuoi job di GitHub Actions su una macchina dedicata tutta tua: $39 al mese, per quanti minuti tu esegua. I layer Docker e le cache delle dipendenze restano tra un job e l'altro, così il job successivo parte subito.

Un runner da 4 vCPU, 20.000 minuti al mese: GitHub $222 → Skipbox $39. Risparmi $183 ogni mese.

Per passare basta una riga: `runs-on: skipbox`.

[Inizia la prova gratuita di 7 giorni](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-it)

## Cosa conserva rust-cache, e cosa lascia fuori

Dal [README di rust-cache](https://github.com/Swatinem/rust-cache#cache-details) e dal suo sorgente:

- **Cosa mette in cache:** `~/.cargo` (il registry, le dipendenze git, i binari installati) e `./target` con 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 da `target/` stesso.
- **Compilazione incrementale:** lo step di ripristino esporta `CARGO_INCREMENTAL=0` per 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.lock` e `Cargo.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](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, VM nuova](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, macchina dell'account, 1ª esecuzione a caldo](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **circa 1,5 s** | **53 s** |
| [Skipbox, macchina dell'account, 2ª esecuzione a caldo](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **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](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), 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](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) per tauri, [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) per ripgrep e [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) per helix.

| Progetto | GitHub | Skipbox, VM nuova | Skipbox, macchina dell'account | GitHub ÷ macchina dell'account |
|---|---|---|---|---|
| tauri | 246 s ([220](https://github.com/skipbox-dev/tauri/actions/runs/43233861304), [271](https://github.com/skipbox-dev/tauri/actions/runs/43234522982)) | 210 s ([273](https://github.com/skipbox-dev/tauri/actions/runs/43290912312), [146](https://github.com/skipbox-dev/tauri/actions/runs/43291768486)) | **53 s** ([53](https://github.com/skipbox-dev/tauri/actions/runs/43340142076), [53](https://github.com/skipbox-dev/tauri/actions/runs/43340289959)) | **4,6×** |
| ripgrep | 200 s ([194](https://github.com/skipbox-dev/ripgrep/actions/runs/43220584380), [206](https://github.com/skipbox-dev/ripgrep/actions/runs/43221108547)) | 156 s ([155](https://github.com/skipbox-dev/ripgrep/actions/runs/43292759363), [156](https://github.com/skipbox-dev/ripgrep/actions/runs/43293273127)) | **40 s** ([39](https://github.com/skipbox-dev/ripgrep/actions/runs/43340925562), [40](https://github.com/skipbox-dev/ripgrep/actions/runs/43341036341)) | **5,0×** |
| helix | 330 s ([293](https://github.com/skipbox-dev/helix/actions/runs/43227916673), [366](https://github.com/skipbox-dev/helix/actions/runs/43228816343)) | 350 s ([439](https://github.com/skipbox-dev/helix/actions/runs/43287815770), [260](https://github.com/skipbox-dev/helix/actions/runs/43289134146)) | **224 s** ([222](https://github.com/skipbox-dev/helix/actions/runs/43337749813), [226](https://github.com/skipbox-dev/helix/actions/runs/43338273330)) | **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](https://github.com/skipbox-dev/astro/actions) | Node.js | 528 s | **30 s** |
| [vite](https://github.com/skipbox-dev/vite/actions) | Node.js | 141 s | 100 s |
| [prometheus](https://github.com/skipbox-dev/prometheus/actions) | Go | 335 s | 273 s |
| [cli](https://github.com/skipbox-dev/cli/actions) | Go | 163 s | 137 s |
| [pytest](https://github.com/skipbox-dev/pytest/actions) | Python | 416 s | 365 s |
| [guava](https://github.com/skipbox-dev/guava/actions) | 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](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

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

1. Apri un'esecuzione a caldo del tuo job Rust, una in cui lo step di rust-cache scrive nel log `full match: true`.
2. 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.
3. Somma i tempi `Finished … in` degli step. È quanto costano i tuoi crate a ogni esecuzione, ed è quello che un `target/` 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`, `cdylib` e 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 cancellare `target/`, e impostare `clean: false` su actions/checkout, il cui `git clean -ffdx` di default cancella `target/` 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/HEAD` a 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

```yaml
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
```

1. Accedi a Skipbox con GitHub.
2. Installa la GitHub App di Skipbox e scegli i repository.
3. Cambia `runs-on` e 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](https://docs.skipbox.dev/it/isolation).

## 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 2026-11-16 · https://skipbox.dev/it/guides/rust-cache-slow-rust-ci
