# Почему rust-cache не ускоряет ваш CI на Rust (tauri: с 246 с до 53 с)

> Swatinem/rust-cache кэширует зависимости, а не крейты вашего workspace, и выключает инкрементальную компиляцию. Поэтому на новой ВМ GitHub каждое «тёплое» задание снова компилирует ваши собственные крейты. Это исправляет target/, сохранённая на машине, которая остаётся: задание CI проекта tauri сократилось с 246 с до 53 с в Skipbox, за фиксированные $39 в месяц.

Swatinem/rust-cache, шаг кэширования в большинстве CI на Rust, сохраняет ваши зависимости и намеренно не трогает крейты вашего workspace. А ещё он ставит `CARGO_INCREMENTAL=0`. На раннерах GitHub каждое задание начинается на новой ВМ, поэтому каждое «тёплое» задание, даже при полном попадании в кэш, снова компилирует ваши собственные крейты. Никакая настройка rust-cache этого не убирает. Убирает `target/`, оставшаяся от прошлого задания: тогда Cargo пропускает каждый крейт, который не изменился.

Skipbox хранит её за вас. Ваше задание выполняется на выделенной машине вашего аккаунта, которая хранит checkout и `target/` у Cargo между заданиями. Задание CI проекта tauri шло 246 с на GitHub и 53 с там, начиная с первого «тёплого» запуска не компилируя ни одного своего крейта, а в workflow поменялось только `runs-on: skipbox`, за фиксированные $39 в месяц.

- Задание CI проекта tauri: 246 с на GitHub, 53 с в Skipbox (в 4,6× быстрее). Каждый запуск публичный
- С сохранённой `target/` Cargo не скомпилировал ни одного крейта tauri: время сборки сократилось с 62 с до меньше чем 2 с
- 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-ru)

## Что rust-cache сохраняет и что пропускает

Из [README rust-cache](https://github.com/Swatinem/rust-cache#cache-details) (на английском) и его исходников:

- **Что он кэширует:** `~/.cargo` (registry, git-зависимости, установленные бинарники) и `./target` с результатами сборки зависимостей.
- **Что он пропускает:** сами крейты workspace не кэшируются. Перед сохранением его очистка удаляет из `target/` всё, что не является зависимостью, поэтому артефакты ваших крейтов удаляются из самой `target/`.
- **Инкрементальная компиляция:** шаг восстановления экспортирует `CARGO_INCREMENTAL=0` до конца задания.
- **Когда он сохраняет:** только когда ни в одном кэше ещё нет ключа задания. Ключ строится из инструментов, окружения и ваших `Cargo.lock` и `Cargo.toml`. Ваши исходные файлы в него не входят.

На новой ВМ всё это сводится к одному. «Тёплое» задание восстанавливает ваши зависимости, а потом каждый раз целиком компилирует крейты вашего workspace и всё, что на них построено.

## Механизм — в логах 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 с | 271 с |
| [Skipbox, новая ВМ](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 с | 146 с |
| [Skipbox, выделенная машина, 1-й «тёплый» запуск](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **около 1,5 с** | **53 с** |
| [Skipbox, выделенная машина, 2-й «тёплый» запуск](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **около 1,9 с** | **53 с** |

Эти 32 строки — собственные крейты tauri и два плагина, построенные на них. Зависимости там не появляются: они приходят из кэша. Время сборки Cargo — это сумма значений `Finished … in` пяти шагов.

У новой ВМ те же CPU, что у выделенной машины, и тот же кэш, и она скомпилировала те же 32 крейта, что и GitHub: в её `target/` было только то, что восстановил кэш. На выделенной машине уже первый «тёплый» запуск не выводит ни одной строки `Compiling`. Cargo только проверил, что ничего не изменилось, и каждый `Finished` занял 0,2–0,7 с.

Раньше первый «тёплый» запуск на выделенной машине снова компилировал все 32 крейта ([задание на 114 с](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), потому что сохранение rust-cache после «холодного» запуска удаляло их из `target/`. С 13 ноября 2026 года выделенные машины отменяют то, что восстановление и сохранение rust-cache удаляют с диска, как только шаг заканчивается. Сохраняемый кэш тот же, а ваши крейты остаются в `target/`.

## Время заданий: три проекта на Rust и шесть других

Собственные задания CI реальных проектов на закреплённом коммите, шаги байт в байт; поменялись только триггер и `runs-on`. По одному «холодному» запуску, затем по два «тёплых» с каждой стороны:

- **GitHub:** `ubuntu-24.04`, стандартный раннер публичного репозитория: 4 vCPU, 16 ГБ.
- **Skipbox, новая ВМ:** новая ВМ на каждое задание из производственного образа раннера, 4 vCPU и 8 ГБ, кэши восстанавливаются через кэш Skipbox.
- **Skipbox, выделенная машина:** тот же размер на тех же CPU хоста, сохраняется между заданиями, с сохранением и очисткой, которые выделенные машины выполняют с 13 ноября 2026 года: checkout и `target/` остаются, а то, что удаляет rust-cache, возвращается на место.

Запуски Skipbox шли на хосте Skipbox, в лабораторном проекте, отделённом от машин клиентов. Время считается от начала до конца каждого задания, по API GitHub. Каждая цифра — медиана двух «тёплых» запусков. «Холодные» запуски выделенной машины заняли [285 с](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) для tauri, [161 с](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) для ripgrep и [442 с](https://github.com/skipbox-dev/helix/actions/runs/43336739720) для helix.

| Проект | GitHub | Skipbox, новая ВМ | Skipbox, выделенная машина | GitHub ÷ выделенная машина |
|---|---|---|---|---|
| tauri | 246 с ([220](https://github.com/skipbox-dev/tauri/actions/runs/43233861304), [271](https://github.com/skipbox-dev/tauri/actions/runs/43234522982)) | 210 с ([273](https://github.com/skipbox-dev/tauri/actions/runs/43290912312), [146](https://github.com/skipbox-dev/tauri/actions/runs/43291768486)) | **53 с** ([53](https://github.com/skipbox-dev/tauri/actions/runs/43340142076), [53](https://github.com/skipbox-dev/tauri/actions/runs/43340289959)) | **4,6×** |
| ripgrep | 200 с ([194](https://github.com/skipbox-dev/ripgrep/actions/runs/43220584380), [206](https://github.com/skipbox-dev/ripgrep/actions/runs/43221108547)) | 156 с ([155](https://github.com/skipbox-dev/ripgrep/actions/runs/43292759363), [156](https://github.com/skipbox-dev/ripgrep/actions/runs/43293273127)) | **40 с** ([39](https://github.com/skipbox-dev/ripgrep/actions/runs/43340925562), [40](https://github.com/skipbox-dev/ripgrep/actions/runs/43341036341)) | **5,0×** |
| helix | 330 с ([293](https://github.com/skipbox-dev/helix/actions/runs/43227916673), [366](https://github.com/skipbox-dev/helix/actions/runs/43228816343)) | 350 с ([439](https://github.com/skipbox-dev/helix/actions/runs/43287815770), [260](https://github.com/skipbox-dev/helix/actions/runs/43289134146)) | **224 с** ([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 снова компилировал каждый крейт в каждом запуске (задание на 108 с). Теперь `target/` от cross остаётся: «тёплые» запуски не выводят ни одной строки `Compiling`, и каждый `Finished` занимает 0,04–0,05 с. Вдобавок GitHub в каждом запуске скачивает образ cross (30 с во втором «тёплом» запуске); выделенная машина хранит его на диске.

helix тоже быстрее в 1,5 раза. Из его крейтов заново собирается только helix-term (и xtask, который от него зависит), потому что build script у helix-term запускается в каждом задании: 16 с в профиле `test` и 61 с в профиле `integration`. Больше ни один крейт не компилируется. Бо́льшая часть задания helix — тесты: один только набор интеграционных тестов идёт 112 с. Его шаг подготовки — инструменты и восстановление кэша — занял 9–10 с против 41–46 с на GitHub.

Другие языки:

| Проект | Язык | GitHub | Skipbox, выделенная машина |
|---|---|---|---|
| [astro](https://github.com/skipbox-dev/astro/actions) | Node.js | 528 с | **30 с** |
| [vite](https://github.com/skipbox-dev/vite/actions) | Node.js | 141 с | 100 с |
| [prometheus](https://github.com/skipbox-dev/prometheus/actions) | Go | 335 с | 273 с |
| [cli](https://github.com/skipbox-dev/cli/actions) | Go | 163 с | 137 с |
| [pytest](https://github.com/skipbox-dev/pytest/actions) | Python | 416 с | 365 с |
| [guava](https://github.com/skipbox-dev/guava/actions) | Java | 818 с | 651 с |

astro — та же история, что с `target/`, только с Turborepo: выделенная машина хранит кэш turbo (turbo 2), поэтому «тёплые» запуски воспроизводят из него все 40 задач сборки и задачу тестов, а не выполняют их ([31 с](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 с](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

У `ubuntu-latest` в приватном репозитории 2 CPU и 8 ГБ: вдвое меньше ядер, чем в запусках на GitHub выше.

## Проверьте свой CI

1. Откройте «тёплый» запуск своего задания на Rust, у которого шаг rust-cache пишет в лог `full match: true`.
2. В шагах сборки и тестов посчитайте строки `Compiling`. Зависимости из кэша их не выводят. Каждый крейт вашего workspace выводит по одной, как и каждый крейт, построенный на них.
3. Сложите значения `Finished … in` этих шагов. Столько ваши собственные крейты стоят в каждом запуске — и столько экономит сохранённая `target/`, когда они не изменились.

## Что можно сделать на раннерах GitHub

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 и новее). Ваши крейты тоже попадают в кэш. Но запуск, чей ключ уже существует, пропускает сохранение, а ключ не меняется вместе с исходниками, поэтому закэшированные крейты такие же старые, как последнее сохранение. Инкрементальная компиляция остаётся выключенной, а кэш растёт внутри 10 ГБ GitHub на репозиторий.
- **sccache.** Он кэширует каждую компиляцию по её входным данным, поэтому неизменённый библиотечный крейт возвращается из хранилища. Крейты, которые вызывают компоновщик, кэшировать нельзя: бинарники, крейты `dylib`, `cdylib` и proc-macro компилируются каждый раз, а каждое попадание — это скачивание.
- **Self-hosted раннер, который хранит `target/`.** Машину ведёте вы: патчите её, чистите между заданиями, не удаляя `target/`, и ставите `clean: false` у actions/checkout, чей `git clean -ffdx` по умолчанию удаляет `target/` вместе со всеми остальными игнорируемыми файлами.

## Skipbox хранит target/ за вас

Каждый тариф — это выделенная машина вашего аккаунта, которая сохраняется между заданиями. С 13 ноября 2026 года она хранит ваш checkout вместе со временем изменения файлов и `target/` у Cargo:

- Очистка у actions/checkout выполняется как обычно, только не трогает папки `target/` у Cargo.
- rust-cache остаётся в вашем workflow. Его восстановление больше не записывает более старые артефакты из кэша поверх более новых на диске.
- То, что сохранение и восстановление rust-cache удаляют из `target/` и `~/.cargo`, машина возвращает на место, как только шаг заканчивается. Сохраняемый кэш тот же, а начиная с задания после «холодного» запуска неизменённые крейты не компилируются.
- `target/`, которую создаёт cross (с пометкой «created by cross»), тоже остаётся.
- actions/checkout переписывает `.git/HEAD` в каждом задании. Пока файл указывает на тот же коммит, ему возвращается прежнее время изменения, поэтому build script, который следит за `.git/HEAD` (так делает vergen), не перезапускается только из-за этого.

Машина хранит и образы Docker, кэши пакетов и установленные инструменты, поэтому вместе с ней ускоряется и остальная часть задания. Задание выбирает размер меткой:

| Метка | Машина | Тариф |
|---|---|---|
| `skipbox` | 4 vCPU · 16 ГБ | S, $39 в месяц |
| `skipbox-8x16` | 8 vCPU · 16 ГБ | M, $79 в месяц |
| `skipbox-16x32` | 16 vCPU · 32 ГБ | 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. Установите GitHub App Skipbox и выберите репозитории.
3. Измените `runs-on` и сделайте push.

## Безопасность

- Машина принадлежит только вашему аккаунту. Задания других компаний на ней не выполняются.
- После каждого задания стираются учётные данные раннера, процессы и контейнеры, а в сохранённом checkout — учётные данные git, hooks и неотслеживаемые файлы. Режим «Чистая ВМ для каждого задания» вместо этого даёт каждому заданию новую машину.
- Код от людей без прав на запись (например, pull request из форков) выполняется на новой одноразовой машине, без сохранённой `target/`.

Подробности — в разделе [«Как изолированы задания»](https://docs.skipbox.dev/ru/isolation).

## Попробуйте на своём задании на Rust

Пробный период бесплатный и без карты: 7 дней или 3 000 мин работы заданий — что закончится раньше. Перенесите задание на Rust на `runs-on: skipbox`, запустите его дважды и положите строки `Compiling` второго запуска рядом с GitHub.

## Вопросы и ответы

### Кэширует ли Swatinem/rust-cache крейты моего workspace?

Нет, по умолчанию — нет. Его README говорит, что сами крейты workspace не кэшируются, а его шаг сохранения удаляет результаты их сборки из target/ перед загрузкой кэша. Он кэширует ~/.cargo и результаты сборки ваших зависимостей и ставит CARGO_INCREMENTAL=0 до конца задания. Поэтому на новой ВМ GitHub каждый «тёплый» запуск снова компилирует крейты вашего workspace, даже при полном попадании в кэш. В CI проекта tauri на GitHub это 32 строки Compiling в каждом «тёплом» запуске.

### Ставить ли cache-workspace-crates: true?

Это кладёт в кэш и ваши крейты (rust-cache v2.8.0 и новее), но ключ кэша строится из инструментов, окружения и ваших Cargo.lock и Cargo.toml, а не из исходников. Запуск, чей ключ уже существует, пропускает сохранение, поэтому закэшированная копия ваших крейтов такая же старая, как последнее сохранение, и с каждым коммитом всё дальше от вашего кода. Инкрементальная компиляция остаётся выключенной. Проверьте лог «тёплого» запуска: если ваши крейты всё ещё показывают Compiling, это не помогает.

### Исправляет ли sccache медленный CI на Rust в GitHub Actions?

Он помогает с библиотечными крейтами, чьи входные данные не изменились. sccache не умеет кэшировать крейты, которые вызывают компоновщик (крейты bin, dylib, cdylib и proc-macro), а каждое попадание — это скачивание из его хранилища. target/, сохранённой между заданиями, скачивание не нужно: крейт, который Cargo считает неизменным, вообще не компилируется.

### Нужно ли менять workflow, чтобы target/ сохранялась в Skipbox?

Нет. Поменяйте runs-on на skipbox и оставьте rust-cache и actions/checkout как есть. Ваша выделенная машина хранит checkout и target/ у Cargo между заданиями, а очистка checkout не трогает папки target/. Когда сохранение rust-cache удаляет ваши крейты из target/, машина возвращает их на место, а его восстановление больше не записывает более старые артефакты поверх более новых. Поэтому уже с первого «тёплого» запуска неизменённые крейты не компилируются.

### Сколько стоит попробовать?

Ничего. Пробный период — 7 дней или 3 000 мин работы заданий, что закончится раньше, без карты. Перенесите задание на Rust на runs-on: skipbox, запустите его дважды и сравните строки Compiling и шаги сборки второго запуска с GitHub.

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