Dlaczego rust-cache nie przyspiesza Twojego CI w Ruście (tauri: z 246 s do 53 s)
Swatinem/rust-cache, krok cache w większości CI w Ruście, zapisuje Twoje zależności i celowo pomija crate'y Twojego workspace'u. Ustawia też CARGO_INCREMENTAL=0. Na runnerach GitHuba każde zadanie startuje na nowej VM, więc każde ciepłe zadanie, nawet przy pełnym trafieniu cache, kompiluje Twoje własne crate'y od nowa. Żadne ustawienie rust-cache tego nie usuwa. Usuwa to target/, który wciąż jest na miejscu z poprzedniego zadania: Cargo pomija wtedy każdy crate, który się nie zmienił.
Skipbox zachowuje go za Ciebie. Twoje zadanie działa na dedykowanej maszynie Twojego konta, która zachowuje checkout i target/ Cargo między zadaniami. Zadanie CI projektu tauri trwało 246 s w GitHubie i 53 s w Skipbox, nie kompilując żadnego ze swoich crate'ów od pierwszego ciepłego uruchomienia, bez żadnej zmiany w workflow poza runs-on: skipbox, za stałe $39 miesięcznie.
Co rust-cache zachowuje, a co pomija
Według README rust-cache i jego kodu źródłowego:
- Co zapisuje w cache:
~/.cargo(rejestr, zależności z gita, zainstalowane binaria) i./targetz wynikami buildu Twoich zależności. - Co pomija: same crate'y workspace'u nie są zapisywane w cache. Przed zapisem jego czyszczenie usuwa z
target/wszystko, co nie jest zależnością, więc artefakty Twoich crate'ów znikają z samegotarget/. - Kompilacja przyrostowa: krok przywracania eksportuje
CARGO_INCREMENTAL=0na resztę zadania. - Kiedy zapisuje: tylko wtedy, gdy żaden cache nie ma jeszcze klucza zadania. Klucz pochodzi z toolchainu, środowiska oraz Twoich
Cargo.lockiCargo.toml. Twoje pliki źródłowe nie są jego częścią.
Na nowej VM sprowadza się to do jednego. Ciepłe zadanie przywraca Twoje zależności, a potem za każdym razem kompiluje w całości crate'y Twojego workspace'u i wszystko, co na nich zbudowano.
Mechanizm w logach projektu tauri
Zadanie test projektu tauri uruchamia pięć kroków cargo test na Ubuntu, z rust-cache. Oto jego ciepłe uruchomienia, każde z pełnym trafieniem cache (full match: true w logu):
| Ciepłe uruchomienie | Linie Compiling | Czas buildu Cargo | Zadanie |
|---|---|---|---|
| GitHub | 32 | 118 s | 271 s |
| Skipbox, nowa VM | 32 | 62 s | 146 s |
| Skipbox, dedykowana maszyna, 1. ciepłe uruchomienie | 0 | około 1,5 s | 53 s |
| Skipbox, dedykowana maszyna, 2. ciepłe uruchomienie | 0 | około 1,9 s | 53 s |
32 linie to własne crate'y projektu tauri i dwie wtyczki na nich zbudowane. Zależności nigdy się nie pojawiają: pochodzą z cache. Czas buildu Cargo to suma czasów Finished … in z pięciu kroków.
Nowa VM ma te same CPU co dedykowana maszyna i ten sam cache, a skompilowała te same 32 crate'y co GitHub: jej target/ zawierał tylko to, co przywrócił cache. Na dedykowanej maszynie już pierwsze ciepłe uruchomienie nie wypisuje żadnej linii Compiling. Cargo tylko sprawdził, że nic się nie zmieniło, a każde Finished zajęło 0,2-0,7 s.
Pierwsze ciepłe uruchomienie na dedykowanej maszynie kompilowało wcześniej wszystkie 32 crate'y od nowa (zadanie trwające 114 s), bo zapis rust-cache po zimnym uruchomieniu usunął je z target/. Od 13 listopada 2026 dedykowane maszyny cofają to, co przywracanie i zapis rust-cache usuwają z dysku, gdy tylko krok się skończy. Zapisywany cache jest taki sam, a Twoje crate'y zostają w target/.
Czasy zadań: trzy projekty w Ruście, sześć innych
Własne zadania CI prawdziwych projektów na przypiętym commicie, kroki bajt w bajt; zmieniły się tylko wyzwalacz i runs-on. Po każdej stronie jedno zimne uruchomienie, a potem dwa ciepłe:
- GitHub:
ubuntu-24.04, standardowy runner repozytorium publicznego: 4 vCPU, 16 GB. - Skipbox, nowa VM: nowa VM dla każdego zadania z produkcyjnego obrazu runnera, 4 vCPU i 8 GB, cache przywracane przez cache Skipbox.
- Skipbox, dedykowana maszyna: ten sam rozmiar na tych samych CPU hosta, zachowywana między zadaniami, z mechanizmem zachowania i czyszczenia, który dedykowane maszyny stosują od 13 listopada 2026: checkout i
target/zostają, a to, co usuwa rust-cache, wraca na miejsce.
Uruchomienia w Skipbox odbyły się na hoście Skipbox, w projekcie laboratoryjnym oddzielonym od maszyn klientów. Czasy liczone są od startu do końca każdego zadania, według API GitHuba. Każda wartość to mediana dwóch ciepłych uruchomień. Zimne uruchomienia na dedykowanej maszynie trwały 285 s dla tauri, 161 s dla ripgrep i 442 s dla helix.
| Projekt | GitHub | Skipbox, nowa VM | Skipbox, dedykowana maszyna | GitHub ÷ dedykowana maszyna |
|---|---|---|---|---|
| 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 buduje się w obrazie Dockera narzędzia cross. cross sam tworzy target/ i oznacza go jako „created by cross”. Dedykowane maszyny brały wcześniej ten target/ za coś innego niż katalog Cargo i usuwały go po każdym zadaniu, więc Cargo kompilował każdy crate od nowa przy każdym uruchomieniu (zadanie trwające 108 s). Teraz target/ crossa zostaje: ciepłe uruchomienia nie wypisują żadnej linii Compiling, a każde Finished trwa 0,04-0,05 s. GitHub pobiera też obraz crossa przy każdym uruchomieniu (30 s w drugim ciepłym uruchomieniu); dedykowana maszyna trzyma go na dysku.
helix też działa 1,5× szybciej. Z jego crate'ów ponownie buduje się tylko helix-term (i xtask, który od niego zależy), bo skrypt buildu helix-term uruchamia się w każdym zadaniu: 16 s w profilu test i 61 s w profilu integration. Żaden inny crate się nie kompiluje. Większość zadania helix to jego testy: sam zestaw testów integracyjnych działa 112 s. Jego krok przygotowania, toolchain i przywracanie cache, trwał 9-10 s wobec 41-46 s w GitHubie.
Pozostałe języki:
| Projekt | Język | GitHub | Skipbox, dedykowana maszyna |
|---|---|---|---|
| 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 to ta sama historia co target/, tyle że z Turborepo: dedykowana maszyna zachowuje cache turbo (turbo 2), więc jego ciepłe uruchomienia odtwarzają z niego wszystkie 40 zadań buildu i zadanie testów, zamiast je wykonywać (31 s, 28 s).
ubuntu-latest repozytorium prywatnego ma 2 CPU i 8 GB: połowę rdzeni z powyższych uruchomień w GitHubie.
Sprawdź własne CI
- Otwórz ciepłe uruchomienie swojego zadania w Ruście, takie, w którym krok rust-cache loguje
full match: true. - W krokach buildu i testów policz linie
Compiling. Zależności z cache nie wypisują żadnej. Każdy crate Twojego workspace'u wypisuje jedną, podobnie jak każdy crate na nich zbudowany. - Zsumuj czasy
Finished … inz tych kroków. Tyle kosztują Twoje własne crate'y przy każdym uruchomieniu i tyle oszczędza zachowanytarget/, gdy się nie zmieniły.
Co możesz zrobić na runnerach GitHuba
cache-workspace-crates: true(rust-cache v2.8.0 i nowsze). Twoje crate'y też trafiają do cache. Ale uruchomienie, którego klucz istnieje, pomija zapis, a klucz nie zmienia się razem z kodem źródłowym, więc crate'y w cache są tak stare jak ostatni zapis. Kompilacja przyrostowa zostaje wyłączona, a cache rośnie w ramach 10 GB GitHuba na repozytorium.- sccache. Zapisuje każdą kompilację według jej wejść, więc niezmieniony crate biblioteczny wraca z magazynu. Crate'ów, które wywołują linker, nie da się zapisać w cache: binaria oraz crate'y
dylib,cdylibi proc-macro kompilują się za każdym razem, a każde trafienie to pobieranie. - Runner self-hosted, który zachowuje
target/. Maszynę prowadzisz Ty: łatasz ją, czyścisz między zadaniami bez kasowaniatarget/i ustawiaszclean: falsew actions/checkout, którego domyślnegit clean -ffdxusuwatarget/razem z każdym innym ignorowanym plikiem.
Skipbox zachowuje target/ za Ciebie
Każdy plan ma dedykowaną maszynę Twojego konta, która zostaje między zadaniami. Od 13 listopada 2026 zachowuje ona Twój checkout, z czasami jego plików, oraz target/ Cargo:
- Czyszczenie w actions/checkout działa jak zwykle, z tym że zostawia katalogi
target/Cargo w spokoju. - rust-cache zostaje w Twoim workflow. Jego przywracanie nie nadpisuje już nowszych artefaktów na dysku starszymi z cache.
- To, co zapis i przywracanie rust-cache usuwają z
target/i~/.cargo, maszyna przywraca, gdy tylko krok się skończy. Zapisywany cache jest taki sam, a od zadania po zimnym uruchomieniu crate'y, które się nie zmieniły, nie są kompilowane. target/, który tworzy cross (oznaczony jako „created by cross”), też zostaje.- actions/checkout przepisuje
.git/HEADw każdym zadaniu. Dopóki wskazuje ten sam commit, plik dostaje z powrotem swój dawny czas, więc skrypt buildu, który obserwuje.git/HEAD(robi to vergen), nie uruchamia się ponownie tylko z tego powodu.
Maszyna zachowuje też obrazy Dockera, cache pakietów i zainstalowane narzędzia, więc reszta zadania przyspiesza razem z nią. Zadanie wybiera rozmiar etykietą:
| Etykieta | Maszyna | Plan |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 miesięcznie |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 miesięcznie |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 miesięcznie |
Minuty są bez limitu. Przy 20 000 minut miesięcznie na 4 vCPU GitHub nalicza $222; Skipbox S to $39, o $183 mniej.
Przejście to jedna linia
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
- Zaloguj się do Skipbox przez GitHuba.
- Zainstaluj aplikację Skipbox w GitHubie i wybierz repozytoria.
- Zmień
runs-oni zrób push.
Bezpieczeństwo
- Maszyna należy tylko do Twojego konta. Nie działają na niej zadania żadnej innej firmy.
- Po każdym zadaniu usuwane są dane uwierzytelniające runnera, procesy i kontenery, a także dane uwierzytelniające gita, hooki i nieśledzone pliki w zachowanym checkoucie. Opcja Nowa VM dla każdego zadania daje zamiast tego każdemu zadaniu nową maszynę.
- Kod od osób bez uprawnień do zapisu (na przykład pull requesty z forków) działa na nowej, jednorazowej maszynie, bez zachowanego
target/.
Szczegóły są w artykule jak zadania są od siebie odizolowane.
Wypróbuj na swoim zadaniu w Ruście
Okres próbny jest bezpłatny przez 7 dni lub 3000 minut zadań, zależnie od tego, co nastąpi wcześniej, i nie wymaga karty. Przenieś swoje zadanie w Ruście na runs-on: skipbox, uruchom je dwa razy i porównaj linie Compiling drugiego uruchomienia z GitHubem.
FAQ
Czy Swatinem/rust-cache zapisuje w cache crate'y mojego workspace'u?
Nie, domyślnie nie. Jego README mówi, że same crate'y workspace'u nie są zapisywane w cache, a jego krok zapisu usuwa ich wyniki buildu z target/, zanim wyśle cache. Zapisuje ~/.cargo i wyniki buildu Twoich zależności, a na resztę zadania ustawia CARGO_INCREMENTAL=0. Na nowej VM GitHuba każde ciepłe uruchomienie kompiluje więc crate'y Twojego workspace'u od nowa, nawet przy pełnym trafieniu cache. W CI projektu tauri w GitHubie było to 32 linie Compiling w każdym ciepłym uruchomieniu.
Czy powinienem ustawić cache-workspace-crates: true?
Wkłada to Twoje crate'y także do cache (rust-cache v2.8.0 i nowsze), ale klucz cache pochodzi z toolchainu, środowiska oraz Twoich Cargo.lock i Cargo.toml, a nie z kodu źródłowego. Uruchomienie, którego klucz już istnieje, pomija zapis, więc kopia Twoich crate'ów w cache jest tak stara jak ostatni zapis i z każdym commitem coraz bardziej odbiega od Twojego kodu. Kompilacja przyrostowa zostaje wyłączona. Sprawdź log ciepłego uruchomienia: jeśli Twoje crate'y nadal pokazują Compiling, to nie pomaga.
Czy sccache naprawia wolne CI w Ruście w GitHub Actions?
Pomaga przy crate'ach bibliotecznych, których wejścia się nie zmieniły. sccache nie może zapisywać w cache crate'ów, które wywołują linker (crate'y bin, dylib, cdylib i proc-macro), a każde trafienie to pobieranie z jego magazynu cache. target/ zachowany między zadaniami nie wymaga pobierania: crate, który Cargo uznaje za niezmieniony, w ogóle nie jest kompilowany.
Czy muszę zmienić workflow, żeby zachować target/ w Skipbox?
Nie. Zmień runs-on na skipbox i zostaw rust-cache oraz actions/checkout bez zmian. Twoja dedykowana maszyna zachowuje checkout i target/ Cargo między zadaniami, a czyszczenie w checkout zostawia katalogi target/ w spokoju. Gdy zapis rust-cache usuwa Twoje crate'y z target/, maszyna je przywraca, a jego przywracanie nie nadpisuje już nowszych artefaktów starszymi. Od pierwszego ciepłego uruchomienia crate'y, które się nie zmieniły, nie są więc kompilowane.
Ile kosztuje wypróbowanie?
Nic. Okres próbny trwa 7 dni lub 3000 minut zadań, zależnie od tego, co nastąpi wcześniej, bez karty. Przenieś swoje zadanie w Ruście na runs-on: skipbox, uruchom je dwa razy i porównaj linie Compiling i kroki buildu drugiego uruchomienia z GitHubem.
Zaktualizowano 19 listopada 2026