De ce rust-cache nu îți face rapid CI-ul Rust (tauri: de la 246 s la 53 s)
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ă.
Ce păstrează rust-cache și ce lasă pe dinafară
Din README-ul rust-cache și din sursele lui:
- Ce pune în cache:
~/.cargo(registry-ul, dependențele git, binarele instalate) și./targetcu 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 dintarget/. - Compilarea incrementală: pasul de restaurare exportă
CARGO_INCREMENTAL=0pentru 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șiCargo.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 | 32 | 118 s | 271 s |
| Skipbox, VM nou | 32 | 62 s | 146 s |
| Skipbox, mașina dedicată, prima rulare cu cache | 0 | cam 1,5 s | 53 s |
| Skipbox, mașina dedicată, a doua rulare cu cache | 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), 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 pentru tauri, 161 s pentru ripgrep și 442 s pentru helix.
| Proiect | GitHub | Skipbox, VM nou | Skipbox, mașina dedicată | GitHub ÷ mașina dedicată |
|---|---|---|---|---|
| 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 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 | 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 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, 28 s).
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
- Deschide o rulare cu cache a jobului tău Rust, una al cărei pas rust-cache scrie în log
full match: true. - Î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. - Adună timpii
Finished … inai pașilor. Atât te costă propriile crate-uri la fiecare rulare și atât economisește untarget/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ă ștergitarget/și seteziclean: falsepe actions/checkout, al căruigit clean -ffdximplicit ștergetarget/î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~/.cargosalvarea ș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/HEADla 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
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
- Conectează-te la Skipbox cu GitHub.
- Instalează aplicația GitHub Skipbox și alege repository-urile.
- 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.
Î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 16 noiembrie 2026