# Защо rust-cache не прави CI на Rust бърз (tauri: от 246 s до 53 s)

> Swatinem/rust-cache кешира зависимостите ви, не crate-овете на работното ви пространство, и изключва инкременталната компилация. Така на новата VM на GitHub всяка затоплена задача компилира собствените ви crate-ове отново. target/, пазен на машина, която остава, оправя това: задачата в CI на tauri падна от 246 s до 53 s в Skipbox, за фиксирани $39 на месец.

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 на месец.

- Задачата в CI на tauri: 246 s в GitHub, 53 s в Skipbox (4,6× по-бързо). Всяко изпълнение е публично
- С пазен `target/` Cargo не компилира нито един от crate-овете на tauri: времето на компилацията му падна от 62 s до под 2 s
- 20 000 минути на месец на 4 vCPU: $222 в GitHub, $39 в Skipbox

**GitHub Actions на фиксирана цена, неограничени минути** Skipbox изпълнява задачите ви в GitHub Actions на собствена, отделена само за вас машина: $39 на месец, колкото и минути да изпълнявате. Docker слоевете и кешовете на зависимостите остават между задачите, така че следващата задача започва веднага.

Рънър с 4 vCPU, 20 000 минути на месец: GitHub $222 → Skipbox $39. Спестявате $183 всеки месец.

Преминаването изисква един ред: `runs-on: skipbox`.

[Започнете 7-дневния безплатен пробен период](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-bg)

## Какво пази rust-cache и какво оставя навън

От [README-то на rust-cache](https://github.com/Swatinem/rust-cache#cache-details) и изходния му код:

- **Какво кешира:** `~/.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](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, нова VM](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, отделна машина, 1-во затоплено изпълнение](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **около 1,5 s** | **53 s** |
| [Skipbox, отделна машина, 2-ро затоплено изпълнение](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **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](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), защото записването на 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](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) за tauri, [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) за ripgrep и [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) за helix.

| Проект | GitHub | Skipbox, нова VM | Skipbox, отделна машина | GitHub ÷ отделна машина |
|---|---|---|---|---|
| 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 се компилира в 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](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 е същата история като `target/`, с Turborepo: отделната машина пази кеша на turbo (turbo 2), така че затоплените ѝ изпълнения възпроизвеждат от него всичките 40 задачи на компилацията и задачата с тестовете, вместо да ги изпълняват ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

`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 образите, кешовете на пакетите и инсталираните инструменти, така че с нея се ускорява и останалата част от задачата. Задачата избира размера си чрез етикета:

| Етикет | Машина | План |
|---|---|---|
| `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 по-малко.

## Преминаването е един ред

```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. Влезте в Skipbox с GitHub.
2. Инсталирайте приложението Skipbox в GitHub и изберете хранилищата.
3. Сменете `runs-on` и направете push.

## Сигурност

- Машината е само на вашия профил. Задачи на друга компания никога не се изпълняват на нея.
- След всяка задача идентификационните данни, процесите и контейнерите на рънъра се изтриват, както и идентификационните данни на git, hook-овете и непроследените файлове в пазеното работно копие. „Чиста VM за всяка задача“ дава вместо това на всяка задача нова машина.
- Код от хора без права за запис (например pull request-и от форкове) се изпълнява на нова машина за еднократна употреба, без пазен `target/`.

Подробностите са в [как са изолирани задачите](https://docs.skipbox.dev/bg/isolation).

## Изпробвайте го със задачата си за 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.

Обновено на 2026-11-19 · https://skipbox.dev/bg/guides/rust-cache-slow-rust-ci
