Защо rust-cache не прави CI на Rust бърз (tauri: от 246 s до 53 s)
Swatinem/rust-cache, стъпката за кеша в повечето CI за Rust, записва зависимостите ви и умишлено оставя извън кеша crate-овете на работното ви пространство. Освен това задава CARGO_INCREMENTAL=0. На рънърите на GitHub всяка задача започва на нова VM, така че всяка затоплена задача, с пълно попадение в кеша и всичко, компилира собствените ви crate-ове отново. Никоя настройка на rust-cache не маха това. Маха го target/, който още е там от предишната задача: тогава Cargo прескача всеки crate, който не се е променил.
Skipbox го пази вместо вас. Задачата ви се изпълнява на отделната машина на профила ви, която пази работното копие и target/ на Cargo между задачите. Задачата в CI на tauri отне 246 s в GitHub и 53 s там, без да компилира нито един от crate-овете си от първото затоплено изпълнение, без промяна в работния поток освен runs-on: skipbox, за фиксирани $39 на месец.
Какво пази rust-cache и какво оставя навън
От README-то на rust-cache и изходния му код:
- Какво кешира:
~/.cargo(регистъра, git зависимостите, инсталираните двоични файлове) и./targetс резултата от компилацията на зависимостите ви. - Какво оставя навън: самите crate-ове на работното пространство не се кешират. Преди записването почистването му изтрива всичко в
target/, което не е зависимост, така че артефактите на crate-овете ви се махат от самияtarget/. - Инкрементална компилация: стъпката за възстановяване експортира
CARGO_INCREMENTAL=0за останалата част от задачата. - Кога записва: само когато още няма кеш с ключа на задачата. Ключът идва от toolchain-а, средата и
Cargo.lockиCargo.tomlви. Изходните ви файлове не са част от него.
На нова VM всичко това се свежда до едно. Затоплената задача възстановява зависимостите ви, после компилира crate-овете на работното ви пространство и всичко, изградено върху тях, изцяло, всеки път.
Механизмът в логовете на tauri
Задачата test на tauri изпълнява пет стъпки cargo test на Ubuntu, с rust-cache. Ето затоплените ѝ изпълнения, всяко с пълно попадение в кеша (full match: true в лога):
| Затоплено изпълнение | Редове Compiling | Време за компилация на Cargo | Задача |
|---|---|---|---|
| GitHub | 32 | 118 s | 271 s |
| Skipbox, нова VM | 32 | 62 s | 146 s |
| Skipbox, отделна машина, 1-во затоплено изпълнение | 0 | около 1,5 s | 53 s |
| Skipbox, отделна машина, 2-ро затоплено изпълнение | 0 | около 1,9 s | 53 s |
32-та реда са собствените crate-ове на tauri и два плъгина, изградени върху тях. Зависимостите не се появяват изобщо: те идват от кеша. Времето за компилация на Cargo е сборът от времената Finished … in на петте стъпки.
Новата VM има процесорите на отделната машина и същия кеш и компилира същите 32 crate-а като GitHub: нейният target/ съдържаше само възстановеното от кеша. На отделната машина още първото затоплено изпълнение не показва нито един ред Compiling. Cargo само провери, че нищо не се е променило, а всеки Finished отне 0,2–0,7 s.
Преди първото затоплено изпълнение на отделната машина компилираше отново всичките 32 crate-а (задача от 114 s), защото записването на rust-cache след студеното изпълнение ги беше изтрило от target/. От 13 ноември 2026 г. отделните машини връщат това, което възстановяването и записването на rust-cache изтриват от диска, щом стъпката приключи. Кешът, който той записва, е същият, а crate-овете ви остават в target/.
Времена на задачите: три проекта на Rust, шест други
Собствените задачи в CI на реални проекти на фиксиран commit, стъпките байт по байт; променени са само тригерът и runs-on. Едно студено изпълнение, после две затоплени, от всяка страна:
- GitHub:
ubuntu-24.04, стандартният рънър на публично хранилище: 4 vCPU, 16 GB. - Skipbox, нова VM: нова VM за всяка задача от production образа на рънъра, 4 vCPU и 8 GB, кешовете се възстановяват през кеша на Skipbox.
- Skipbox, отделна машина: същият размер на същите процесори на хоста, пазена между задачите, с пазенето и изтриването, които отделните машини изпълняват от 13 ноември 2026 г.: работното копие и
target/остават, а изтритото от rust-cache се връща.
Изпълненията в Skipbox бяха на хост на Skipbox, в лабораторен проект, държан отделно от машините на клиентите. Времената са от началото до края на всяка задача, от API на GitHub. Всяка цифра е медианата на двете затоплени изпълнения. Студените изпълнения на отделната машина отнеха 285 s за tauri, 161 s за ripgrep и 442 s за helix.
| Проект | GitHub | Skipbox, нова VM | Skipbox, отделна машина | GitHub ÷ отделна машина |
|---|---|---|---|---|
| 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 се компилира в Docker образа на cross. cross сам създава target/ и го маркира с „created by cross“. Преди отделните машини смятаха този target/ за нещо различно от този на Cargo и го изтриваха след всяка задача, така че Cargo компилираше отново всеки crate при всяко изпълнение (задача от 108 s). Сега target/ на cross остава: затоплените изпълнения не показват нито един ред Compiling, а всеки Finished отнема 0,04–0,05 s. GitHub освен това изтегля образа на cross при всяко изпълнение (30 s във второто затоплено изпълнение); отделната машина го пази на диска.
helix също върви 1,5× по-бързо. От неговите crate-ове отново се компилира само helix-term (и xtask, който зависи от него), защото build скриптът на helix-term се изпълнява при всяка задача: 16 s в профила test и 61 s в профила integration. Никой друг crate не се компилира. По-голямата част от задачата на helix са тестовете му: само пакетът интеграционни тестове върви 112 s. Стъпката му за настройка, toolchain и възстановяване на кеша, отне 9–10 s срещу 41–46 s в GitHub.
Другите езици:
| Проект | Език | GitHub | Skipbox, отделна машина |
|---|---|---|---|
| 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 е същата история като target/, с Turborepo: отделната машина пази кеша на turbo (turbo 2), така че затоплените ѝ изпълнения възпроизвеждат от него всичките 40 задачи на компилацията и задачата с тестовете, вместо да ги изпълняват (31 s, 28 s).
ubuntu-latest в частно хранилище има 2 CPU и 8 GB: половината от ядрата на изпълненията в GitHub по-горе.
Проверете собствения си CI
- Отворете затоплено изпълнение на задачата си за Rust, такова, чиято стъпка rust-cache записва в лога
full match: true. - В стъпките за компилация и тестове пребройте редовете
Compiling. Зависимостите от кеша не показват нито един. Всеки crate от работното ви пространство показва по един, както и всеки crate, изграден върху тях. - Съберете времената
Finished … inна стъпките. Това струват собствените ви crate-ове при всяко изпълнение и това спестява пазениятtarget/, когато те не са се променили.
Какво можете да направите на рънърите на GitHub
cache-workspace-crates: true(rust-cache v2.8.0 и по-нови). Вашите crate-ове също влизат в кеша. Но изпълнение, чийто ключ съществува, прескача записването, а ключът не се променя с изходния ви код, така че кешираните crate-ове са толкова стари, колкото последното записване. Инкременталната компилация остава изключена, а кешът расте в рамките на 10-те GB на хранилище в GitHub.- sccache. Той кешира всяка компилация по входовете ѝ, така че непроменен library crate се връща от хранилището. Crate-овете, които извикват линкера, не могат да се кешират: двоичните файлове,
dylib,cdylibи proc-macro crate-овете се компилират всеки път, а всяко попадение е изтегляне. - Самостоятелно хостван рънър, който пази
target/. Вие поддържате машината: кърпите я, почиствате я между задачите, без да изтриватеtarget/, и задаватеclean: falseна actions/checkout, чийтоgit clean -ffdxпо подразбиране изтриваtarget/с всеки друг игнориран файл.
Skipbox пази target/ вместо вас
Всеки план идва с отделна машина за профила ви, пазена между задачите. От 13 ноември 2026 г. тя пази работното ви копие, с времената на файловете му, и target/ на Cargo:
- Почистването на actions/checkout върви както обикновено, само че не пипа директориите
target/на Cargo. - rust-cache остава в работния ви поток. Възстановяването му вече не презаписва по-новите артефакти на диска с по-старите от кеша.
- Това, което записването и възстановяването на rust-cache изтриват от
target/и~/.cargo, машината връща, щом стъпката приключи. Записаният кеш е същият, а от задачата след студеното изпълнение непроменените crate-ове не се компилират. target/, който създава cross (маркиран с „created by cross“), също остава.- actions/checkout пренаписва
.git/HEADпри всяка задача. Докато той още посочва същия commit, файлът получава старото си време обратно, така че build скрипт, който следи.git/HEAD(vergen го прави), не се изпълнява отново само заради това.
Машината пази и Docker образите, кешовете на пакетите и инсталираните инструменти, така че с нея се ускорява и останалата част от задачата. Задачата избира размера си чрез етикета:
| Етикет | Машина | План |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 на месец |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 на месец |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 на месец |
Минутите са неограничени. При 20 000 минути на месец на 4 vCPU GitHub таксува $222; Skipbox S е $39, с $183 по-малко.
Преминаването е един ред
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
- Влезте в Skipbox с GitHub.
- Инсталирайте приложението Skipbox в GitHub и изберете хранилищата.
- Сменете
runs-onи направете push.
Сигурност
- Машината е само на вашия профил. Задачи на друга компания никога не се изпълняват на нея.
- След всяка задача идентификационните данни, процесите и контейнерите на рънъра се изтриват, както и идентификационните данни на git, hook-овете и непроследените файлове в пазеното работно копие. „Чиста VM за всяка задача“ дава вместо това на всяка задача нова машина.
- Код от хора без права за запис (например pull request-и от форкове) се изпълнява на нова машина за еднократна употреба, без пазен
target/.
Подробностите са в как са изолирани задачите.
Изпробвайте го със задачата си за Rust
Пробният период е безплатен за 7 дни или 3000 минути на задачи, което настъпи първо, и не изисква карта. Преместете задачата си за Rust на runs-on: skipbox, пуснете я два пъти и сложете редовете Compiling от второто изпълнение до тези в GitHub.
Често задавани въпроси
Кешира ли Swatinem/rust-cache crate-овете на работното ми пространство?
Не, не по подразбиране. README-то му казва, че самите crate-ове на работното пространство не се кешират, а стъпката му за записване изтрива резултата от компилацията им от target/, преди да качи кеша. Той кешира ~/.cargo и резултата от компилацията на зависимостите ви и задава CARGO_INCREMENTAL=0 за останалата част от задачата. Така на нова VM в GitHub всяко затоплено изпълнение компилира отново crate-овете на работното ви пространство, дори при пълно попадение в кеша. В CI на tauri в GitHub това бяха 32 реда Compiling при всяко затоплено изпълнение.
Да задам ли cache-workspace-crates: true?
То слага и вашите crate-ове в кеша (rust-cache v2.8.0 и по-нови), но ключът на кеша идва от toolchain-а, средата и Cargo.lock и Cargo.toml ви, не от изходния ви код. Изпълнение, чийто ключ вече съществува, прескача записването, така че кешираното копие на crate-овете ви е толкова старо, колкото последното записване, и се отдалечава от кода ви с всеки commit. Инкременталната компилация остава изключена. Проверете лога на затоплено изпълнение: ако crate-овете ви още показват Compiling, не помага.
Оправя ли sccache бавния CI на Rust в GitHub Actions?
Помага при library crate-ове, чиито входове не са се променили. sccache не може да кешира crate-ове, които извикват линкера (bin, dylib, cdylib и proc-macro crate-ове), а всяко попадение е изтегляне от хранилището на кеша му. target/, пазен между задачите, не се нуждае от изтегляне: crate, който Cargo вижда като непроменен, изобщо не се компилира.
Трябва ли да променя работния си поток, за да пазя target/ в Skipbox?
Не. Сменете runs-on на skipbox и оставете rust-cache и actions/checkout както са. Отделната ви машина пази работното копие и target/ на Cargo между задачите, а почистването на checkout не пипа директориите target/. Когато записването на rust-cache изтрие crate-овете ви от target/, машината ги връща, а възстановяването му вече не презаписва по-новите артефакти с по-стари. Така от първото затоплено изпълнение непроменените crate-ове не се компилират.
Колко струва да го изпробвам?
Нищо. Пробният период е 7 дни или 3000 минути на задачи, което настъпи първо, без карта. Преместете задачата си за Rust на runs-on: skipbox, пуснете я два пъти и сравнете редовете Compiling и стъпките за компилация от второто изпълнение с тези в GitHub.
Обновено на 19 ноември 2026 г.