# De ce rust-cache nu îți face rapid CI-ul Rust (tauri: de la 246 s la 53 s)

> Swatinem/rust-cache pune în cache dependențele, nu crate-urile din workspace, și dezactivează compilarea incrementală. Așa că pe VM-ul nou al GitHub fiecare job cu cache compilează din nou propriile crate-uri. Un target/ păstrat pe o mașină care rămâne rezolvă asta: jobul de CI al tauri a coborât de la 246 s la 53 s pe Skipbox, la un preț fix de $39 pe lună.

Swatinem/rust-cache, pasul de cache din cele mai multe CI-uri Rust, îți salvează dependențele și lasă deliberat pe dinafară crate-urile din workspace. Mai setează și `CARGO_INCREMENTAL=0`. Pe runnerele GitHub fiecare job pornește pe un VM nou, așa că fiecare job cu cache, inclusiv la o potrivire completă, îți compilează din nou propriile crate-uri. Nicio setare rust-cache nu face asta să dispară. Ce o face e un `target/` rămas de la jobul anterior: atunci Cargo sare peste fiecare crate care nu s-a schimbat.

Skipbox ți-l păstrează. Jobul tău rulează pe mașina dedicată a contului tău, care păstrează checkoutul și `target/` de la Cargo între joburi. Jobul de CI al tauri a durat 246 s pe GitHub și 53 s acolo, fără să compileze vreunul dintre crate-urile lui de la prima rulare cu cache, fără nicio schimbare în workflow în afară de `runs-on: skipbox`, la un preț fix de $39 pe lună.

- Jobul de CI al tauri: 246 s pe GitHub, 53 s pe Skipbox (de 4,6× mai rapid). Fiecare rulare e publică
- Cu `target/` păstrat, Cargo nu a compilat niciunul dintre crate-urile tauri: timpul de build a coborât de la 62 s la sub 2 s
- 20.000 de minute pe lună pe 4 vCPU: $222 pe GitHub, $39 pe Skipbox

**GitHub Actions la preț fix, cu minute nelimitate** Skipbox rulează joburile tale GitHub Actions pe propria ta mașină dedicată: $39 pe lună, oricâte minute ai rula. Layerele Docker și cache-urile de dependențe rămân între joburi, așa că jobul următor pornește imediat.

Un runner de 4 vCPU, 20.000 de minute pe lună: GitHub $222 → Skipbox $39. Economisești $183 în fiecare lună.

E nevoie de o singură linie: `runs-on: skipbox`.

[Încearcă gratuit 7 zile](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-ro)

## Ce păstrează rust-cache și ce lasă pe dinafară

Din [README-ul rust-cache](https://github.com/Swatinem/rust-cache#cache-details) și din sursele lui:

- **Ce pune în cache:** `~/.cargo` (registry-ul, dependențele git, binarele instalate) și `./target` cu rezultatul compilării dependențelor.
- **Ce lasă pe dinafară:** crate-urile din workspace nu sunt puse în cache. Înainte de salvare, curățarea lui șterge din `target/` tot ce nu e dependență, așa că artefactele crate-urilor tale dispar chiar din `target/`.
- **Compilarea incrementală:** pasul de restaurare exportă `CARGO_INCREMENTAL=0` pentru restul jobului.
- **Când salvează:** doar când niciun cache nu are încă cheia jobului. Cheia vine din toolchain, din mediu și din `Cargo.lock` și `Cargo.toml`. Fișierele tale sursă nu fac parte din ea.

Pe un VM nou, toate astea duc la un singur lucru. Un job cu cache îți restaurează dependențele, apoi îți compilează crate-urile din workspace și tot ce e construit pe ele, integral, de fiecare dată.

## Mecanismul, în logurile tauri

Jobul `test` al tauri rulează cinci pași `cargo test` pe Ubuntu, cu rust-cache. Iată rulările lui cu cache, fiecare cu potrivire completă (`full match: true` în log):

| Rulare cu cache | Linii `Compiling` | Timpul de build Cargo | Job |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, VM nou](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, mașina dedicată, prima rulare cu cache](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **cam 1,5 s** | **53 s** |
| [Skipbox, mașina dedicată, a doua rulare cu cache](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **cam 1,9 s** | **53 s** |

Cele 32 de linii sunt crate-urile proprii ale tauri și două pluginuri construite pe ele. Dependențele nu apar niciodată: vin din cache. Timpul de build Cargo e suma timpilor `Finished … in` din cei cinci pași.

VM-ul nou are CPU-urile mașinii dedicate și același cache și a compilat aceleași 32 de crate-uri ca GitHub: `target/` al lui conținea doar ce a restaurat cache-ul. Pe mașina dedicată, deja prima rulare cu cache nu afișează nicio linie `Compiling`. Cargo a verificat doar că nu s-a schimbat nimic, iar fiecare `Finished` a durat 0,2-0,7 s.

Prima rulare cu cache de pe mașina dedicată compila înainte din nou toate cele 32 de crate-uri ([un job de 114 s](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), pentru că salvarea rust-cache de după rularea la rece le ștersese din `target/`. Din 13 noiembrie 2026, mașinile dedicate anulează ce șterg de pe disc restaurarea și salvarea rust-cache, imediat după ce se termină pasul. Cache-ul salvat e același, iar crate-urile tale rămân în `target/`.

## Durata joburilor: trei proiecte Rust, alte șase

Joburile de CI ale unor proiecte reale la un commit fixat, cu pașii identici byte cu byte; s-au schimbat doar triggerul și `runs-on`. O rulare la rece, apoi două cu cache, pe fiecare parte:

- **GitHub:** `ubuntu-24.04`, runnerul standard al unui repository public: 4 vCPU, 16 GB.
- **Skipbox, VM nou:** un VM nou pentru fiecare job, din imaginea runnerului de producție, 4 vCPU și 8 GB, cu cache-urile restaurate prin cache-ul Skipbox.
- **Skipbox, mașina dedicată:** aceeași mărime pe aceleași CPU-uri ale hostului, păstrată între joburi, cu păstrarea și curățarea pe care le fac mașinile dedicate din 13 noiembrie 2026: checkoutul și `target/` rămân, iar ce șterge rust-cache e pus la loc.

Rulările Skipbox au fost pe un host Skipbox, într-un proiect de laborator ținut separat de mașinile clienților. Duratele merg de la începutul fiecărui job până la final, din API-ul GitHub. Fiecare cifră e mediana celor două rulări cu cache. Rulările la rece de pe mașina dedicată au durat [285 s](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) pentru tauri, [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) pentru ripgrep și [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) pentru helix.

| Proiect | GitHub | Skipbox, VM nou | Skipbox, mașina dedicată | GitHub ÷ mașina dedicată |
|---|---|---|---|---|
| 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 compilează în imaginea Docker a cross. cross își creează singur `target/` și îl etichetează „created by cross”. Mașinile dedicate considerau înainte acel `target/` ca fiind altceva decât al lui Cargo și îl ștergeau după fiecare job, așa că Cargo compila din nou fiecare crate la fiecare rulare (un job de 108 s). Acum `target/` al cross rămâne: rulările cu cache nu afișează nicio linie `Compiling`, iar fiecare `Finished` durează 0,04-0,05 s. GitHub mai descarcă și imaginea cross la fiecare rulare (30 s în a doua rulare cu cache); mașina dedicată o păstrează pe disc.

Și helix rulează de 1,5× mai repede. Dintre crate-urile lui, doar helix-term (și xtask, care depinde de el) se compilează din nou, pentru că scriptul de build al helix-term rulează la fiecare job: 16 s în profilul `test` și 61 s în profilul `integration`. Niciun alt crate nu se compilează. Cea mai mare parte a jobului helix sunt testele: doar suita de teste de integrare rulează 112 s. Pasul lui de setup, toolchainul și restaurarea cache-ului, a durat 9-10 s, față de 41-46 s pe GitHub.

Celelalte limbaje:

| Proiect | Limbaj | GitHub | Skipbox, mașina dedicată |
|---|---|---|---|
| [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 e aceeași poveste ca `target/`, cu Turborepo: mașina dedicată păstrează cache-ul turbo (turbo 2), așa că rulările lui cu cache reiau din el toate cele 40 de taskuri de build și taskul de test în loc să le ruleze ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

`ubuntu-latest` dintr-un repository privat are 2 CPU și 8 GB: jumătate din nucleele rulărilor GitHub de mai sus.

## Verifică-ți propriul CI

1. Deschide o rulare cu cache a jobului tău Rust, una al cărei pas rust-cache scrie în log `full match: true`.
2. În pașii de build și de test, numără liniile `Compiling`. Dependențele din cache nu afișează niciuna. Fiecare crate din workspace-ul tău afișează una, la fel și fiecare crate construit pe ele.
3. Adună timpii `Finished … in` ai pașilor. Atât te costă propriile crate-uri la fiecare rulare și atât economisește un `target/` păstrat când ele nu s-au schimbat.

## Ce poți face pe runnerele GitHub

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 și mai nou). Îți pune și crate-urile în cache. Dar o rulare a cărei cheie există sare peste salvare, iar cheia nu se schimbă odată cu sursele tale, așa că crate-urile din cache sunt la fel de vechi ca ultima salvare. Compilarea incrementală rămâne dezactivată, iar cache-ul crește în cei 10 GB per repository de la GitHub.
- **sccache.** Pune în cache fiecare compilare după inputurile ei, așa că un crate de bibliotecă neschimbat revine din stocare. Crate-urile care apelează linkerul nu pot fi puse în cache: binarele și crate-urile `dylib`, `cdylib` și proc-macro se compilează de fiecare dată, iar fiecare potrivire e o descărcare.
- **Un runner self-hosted care păstrează `target/`.** Tu rulezi mașina: îi aplici patch-uri, o cureți între joburi fără să ștergi `target/` și setezi `clean: false` pe actions/checkout, al cărui `git clean -ffdx` implicit șterge `target/` împreună cu orice alt fișier ignorat.

## Skipbox îți păstrează target/

Fiecare plan vine cu mașina dedicată a contului tău, păstrată între joburi. Din 13 noiembrie 2026, îți păstrează checkoutul, cu timpii fișierelor lui, și `target/` de la Cargo:

- Curățarea din actions/checkout rulează ca de obicei, doar că lasă în pace directoarele `target/` ale Cargo.
- rust-cache rămâne în workflow-ul tău. Restaurarea lui nu mai scrie artefactele mai vechi din cache peste cele mai noi de pe disc.
- Ce șterg din `target/` și `~/.cargo` salvarea și restaurarea rust-cache, mașina pune la loc imediat după ce se termină pasul. Cache-ul salvat e același, iar de la jobul de după rularea la rece, crate-urile care nu s-au schimbat nu mai sunt compilate.
- Rămâne și `target/` creat de cross (etichetat „created by cross”).
- actions/checkout rescrie `.git/HEAD` la fiecare job. Cât timp indică același commit, fișierul își recapătă timpul vechi, așa că un script de build care urmărește `.git/HEAD` (cum face vergen) nu rulează din nou doar din acest motiv.

Mașina păstrează și imaginile Docker, cache-urile de pachete și instrumentele instalate, așa că și restul jobului se accelerează odată cu ea. Un job își alege mărimea prin etichetă:

| Etichetă | Mașină | Plan |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 pe lună |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 pe lună |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 pe lună |

Minutele sunt nelimitate. La 20.000 de minute pe lună pe 4 vCPU, GitHub facturează $222; Skipbox S costă $39, cu $183 mai puțin.

## Mutarea înseamnă o singură linie

```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. Conectează-te la Skipbox cu GitHub.
2. Instalează aplicația GitHub Skipbox și alege repository-urile.
3. Schimbă `runs-on` și fă push.

## Securitate

- Mașina este doar a contului tău. Niciun job al altei companii nu rulează pe ea.
- După fiecare job, credențialele runnerului, procesele și containerele sunt șterse, la fel și credențialele git, hookurile și fișierele neurmărite din checkoutul păstrat. „Curățare la fiecare job” îi dă în schimb fiecărui job o mașină nouă.
- Codul de la persoane fără acces de scriere (cum ar fi pull request-urile din forkuri) rulează pe o mașină nouă, de unică folosință, fără `target/` păstrat.

Detaliile sunt în [cum sunt izolate joburile](https://docs.skipbox.dev/ro/isolation).

## Încearcă pe jobul tău Rust

Perioada de probă este gratuită timp de 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, și nu cere card. Mută jobul Rust pe `runs-on: skipbox`, rulează-l de două ori și pune liniile `Compiling` de la a doua rulare lângă cele de pe GitHub.

## Întrebări frecvente

### Swatinem/rust-cache pune în cache crate-urile din workspace-ul meu?

Nu, nu implicit. README-ul lui spune că crate-urile din workspace nu sunt puse în cache, iar pasul lui de salvare șterge rezultatul compilării lor din target/ înainte să încarce cache-ul. Pune în cache ~/.cargo și rezultatul compilării dependențelor și setează CARGO_INCREMENTAL=0 pentru restul jobului. Așa că pe un VM GitHub nou, fiecare rulare cu cache compilează din nou crate-urile din workspace, chiar și la o potrivire completă de cache. În CI-ul tauri pe GitHub, asta însemna 32 de linii Compiling la fiecare rulare cu cache.

### Ar trebui să setez cache-workspace-crates: true?

Îți pune și crate-urile în cache (rust-cache v2.8.0 și mai nou), dar cheia cache-ului vine din toolchain, din mediu și din Cargo.lock și Cargo.toml, nu din sursele tale. O rulare a cărei cheie există deja sare peste salvare, așa că copia din cache a crate-urilor tale e la fel de veche ca ultima salvare și se depărtează de codul tău la fiecare commit. Compilarea incrementală rămâne dezactivată. Verifică logul unei rulări cu cache: dacă crate-urile tale încă apar cu Compiling, nu ajută.

### sccache rezolvă CI-ul Rust lent în GitHub Actions?

Ajută la crate-urile de bibliotecă ale căror inputuri nu s-au schimbat. sccache nu poate pune în cache crate-urile care apelează linkerul (crate-urile bin, dylib, cdylib și proc-macro), iar fiecare potrivire e o descărcare din stocarea lui de cache. Un target/ păstrat între joburi nu cere nicio descărcare: un crate pe care Cargo îl vede neschimbat nu e compilat deloc.

### Trebuie să îmi schimb workflow-ul ca să păstrez target/ pe Skipbox?

Nu. Schimbă runs-on în skipbox și lasă rust-cache și actions/checkout cum sunt. Mașina ta dedicată păstrează checkoutul și target/ de la Cargo între joburi, iar curățarea făcută de checkout lasă în pace directoarele target/. Când salvarea rust-cache îți șterge crate-urile din target/, mașina le pune la loc, iar restaurarea lui nu mai scrie artefacte mai vechi peste cele mai noi. Așa că de la prima rulare cu cache, crate-urile care nu s-au schimbat nu mai sunt compilate.

### Cât costă să încerc?

Nimic. Perioada de probă durează 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, fără card. Mută jobul Rust pe runs-on: skipbox, rulează-l de două ori și compară liniile Compiling și pașii de build de la a doua rulare cu cei de pe GitHub.

Actualizat pe 2026-11-16 · https://skipbox.dev/ro/guides/rust-cache-slow-rust-ci
