Skipbox

Защо 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 в лога):

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.

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.

Другите езици:

astro е същата история като target/, с Turborepo: отделната машина пази кеша на turbo (turbo 2), така че затоплените ѝ изпълнения възпроизвеждат от него всичките 40 задачи на компилацията и задачата с тестовете, вместо да ги изпълняват (31 s, 28 s).

ubuntu-latest в частно хранилище има 2 CPU и 8 GB: половината от ядрата на изпълненията в GitHub по-горе.

Проверете собствения си CI

  1. Отворете затоплено изпълнение на задачата си за Rust, такова, чиято стъпка rust-cache записва в лога full match: true.
  2. В стъпките за компилация и тестове пребройте редовете Compiling. Зависимостите от кеша не показват нито един. Всеки crate от работното ви пространство показва по един, както и всеки crate, изграден върху тях.
  3. Съберете времената 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 образите, кешовете на пакетите и инсталираните инструменти, така че с нея се ускорява и останалата част от задачата. Задачата избира размера си чрез етикета:

Минутите са неограничени. При 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
  1. Влезте в Skipbox с GitHub.
  2. Инсталирайте приложението Skipbox в GitHub и изберете хранилищата.
  3. Сменете 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 г.

По-бърз CI/CD с винаги топъл кеш

Вашият топъл рънър на фиксирана цена

Ние ги хостваме. Вие променяте един ред. 1/12 от цената на GitHub при пълно натоварване. Цената е фиксирана, затова пускайте задачи по цял ден. 7× повече място за кеш от GitHub.

  • Без карта
  • Вход с GitHub
  • Прекратяване по всяко време