# Kenapa rust-cache tidak menjadikan CI Rust anda pantas (tauri: 246 s kepada 53 s)

> Swatinem/rust-cache menyimpan cache dependency anda, bukan crate workspace anda, dan mematikan kompilasi inkremental. Jadi pada VM baharu GitHub setiap job hangat mengompil crate anda sendiri sekali lagi. target/ yang dikekalkan pada mesin yang kekal membetulkannya: job CI tauri turun daripada 246 s kepada 53 s di Skipbox, pada harga tetap $39 sebulan.

Swatinem/rust-cache, step cache dalam kebanyakan CI Rust, menyimpan dependency anda dan dengan sengaja meninggalkan crate workspace anda. Ia juga menetapkan `CARGO_INCREMENTAL=0`. Pada runner GitHub setiap job bermula pada VM baharu, jadi setiap job hangat, walaupun cache kena sepenuhnya, mengompil crate anda sendiri sekali lagi. Tiada tetapan rust-cache yang menghilangkannya. Yang menghilangkannya ialah `target/` yang masih ada daripada job sebelumnya: Cargo kemudian melangkau setiap crate yang tidak berubah.

Skipbox mengekalkannya untuk anda. Job anda berjalan pada mesin khusus akaun anda, yang mengekalkan checkout dan `target/` Cargo antara job. Job CI tauri mengambil masa 246 s di GitHub dan 53 s di sana, tanpa mengompil sebarang crate-nya sejak larian hangat pertama, tanpa perubahan pada workflow-nya selain `runs-on: skipbox`, pada harga tetap $39 sebulan.

- Job CI tauri: 246 s di GitHub, 53 s di Skipbox (4.6× lebih pantas). Setiap larian adalah awam
- Dengan `target/` dikekalkan, Cargo tidak mengompil sebarang crate tauri: masa build-nya turun daripada 62 s kepada kurang daripada 2 s
- 20,000 minit sebulan pada 4 vCPU: $222 di GitHub, $39 di Skipbox

**GitHub Actions pada harga tetap, minit tanpa had** Skipbox menjalankan job GitHub Actions anda pada mesin khusus anda sendiri: $39 sebulan, berapa minit pun anda jalankan. Lapisan Docker dan cache dependency kekal antara job, jadi job seterusnya bermula serta-merta.

Runner 4 vCPU, 20,000 minit sebulan: GitHub $222 → Skipbox $39. Anda jimat $183 setiap bulan.

Beralih hanya memerlukan satu baris: `runs-on: skipbox`.

[Mulakan percubaan percuma 7 hari saya](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-ms)

## Apa yang disimpan rust-cache, dan apa yang ditinggalkannya

Daripada [README rust-cache](https://github.com/Swatinem/rust-cache#cache-details) dan kod sumbernya:

- **Apa yang disimpan dalam cache:** `~/.cargo` (registry, dependency git, binari yang dipasang) dan `./target` dengan output build dependency anda.
- **Apa yang ditinggalkan:** "the workspace crates themselves are not cached". Sebelum simpanan, pembersihannya memadam segala-galanya dalam `target/` yang bukan dependency, jadi artifact crate anda dibuang daripada `target/` itu sendiri.
- **Kompilasi inkremental:** step pemulihan mengeksport `CARGO_INCREMENTAL=0` untuk baki job.
- **Bila ia menyimpan:** hanya apabila belum ada cache dengan key job itu. Key datang daripada toolchain, persekitaran, dan `Cargo.lock` serta `Cargo.toml` anda. Fail kod sumber anda bukan sebahagian daripadanya.

Pada VM baharu semua itu membawa kepada satu perkara. Job hangat memulihkan dependency anda, kemudian mengompil crate workspace anda dan semua yang dibina di atasnya, sepenuhnya, setiap kali.

## Mekanismenya, dalam log tauri

Job `test` tauri menjalankan lima step `cargo test` pada Ubuntu, dengan rust-cache. Ini larian hangatnya, setiap satu dengan cache kena sepenuhnya (`full match: true` dalam log):

| Larian hangat | Baris `Compiling` | Masa build Cargo | Job |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, VM baharu](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, mesin khusus, larian hangat pertama](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **kira-kira 1.5 s** | **53 s** |
| [Skipbox, mesin khusus, larian hangat kedua](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **kira-kira 1.9 s** | **53 s** |

32 baris itu ialah crate tauri sendiri, dan dua plugin yang dibina di atasnya. Dependency tidak pernah muncul: ia datang daripada cache. Masa build Cargo ialah masa `Finished … in` bagi lima step itu, dijumlahkan.

VM baharu mempunyai CPU mesin khusus dan cache yang sama, dan ia mengompil 32 crate yang sama seperti GitHub: `target/`-nya hanya mengandungi apa yang dipulihkan cache. Pada mesin khusus, larian hangat pertama sudah tidak mencetak sebarang baris `Compiling`. Cargo hanya menyemak bahawa tiada apa-apa berubah, dan setiap `Finished` mengambil masa 0.2-0.7 s.

Larian hangat pertama mesin khusus dahulu mengompil kesemua 32 crate sekali lagi ([job 114 s](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), kerana simpanan rust-cache selepas larian sejuk telah memadamnya daripada `target/`. Sejak 13 November 2026, mesin khusus membatalkan apa yang dipadam oleh pemulihan dan simpanan rust-cache daripada cakera, sebaik step itu tamat. Cache yang disimpannya sama, dan crate anda kekal dalam `target/`.

## Masa job: tiga projek Rust, enam yang lain

Job CI projek sebenar pada commit yang ditetapkan, step sama bait demi bait; hanya pencetus dan `runs-on` diubah. Satu larian sejuk, kemudian dua larian hangat, pada setiap pihak:

- **GitHub:** `ubuntu-24.04`, runner standard repositori awam: 4 vCPU, 16 GB.
- **Skipbox, VM baharu:** VM baharu bagi setiap job daripada imej runner production, 4 vCPU dan 8 GB, cache dipulihkan melalui cache Skipbox.
- **Skipbox, mesin khusus:** saiz yang sama pada CPU hos yang sama, dikekalkan antara job, dengan simpan-dan-padam yang dijalankan mesin khusus sejak 13 November 2026: checkout dan `target/` kekal, dan apa yang dipadam rust-cache dikembalikan.

Larian Skipbox berada pada hos Skipbox, dalam projek makmal yang diasingkan daripada mesin pelanggan. Masa dikira dari permulaan hingga tamat setiap job, daripada API GitHub. Setiap angka ialah median dua larian hangat. Larian sejuk mesin khusus mengambil masa [285 s](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) untuk tauri, [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) untuk ripgrep dan [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) untuk helix.

| Projek | GitHub | Skipbox, VM baharu | Skipbox, mesin khusus | GitHub ÷ mesin khusus |
|---|---|---|---|---|
| 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 membina di dalam imej Docker cross. cross membuat `target/` sendiri dan menandakannya "created by cross". Mesin khusus dahulu menganggap `target/` itu sebagai sesuatu selain milik Cargo dan memadamnya selepas setiap job, jadi Cargo mengompil setiap crate sekali lagi pada setiap larian (job 108 s). Kini `target/` cross kekal: larian hangat tidak mencetak sebarang baris `Compiling`, dan setiap `Finished` mengambil masa 0.04-0.05 s. GitHub juga memuat turun imej cross pada setiap larian (30 s dalam larian hangat kedua); mesin khusus menyimpannya pada cakera.

helix juga berjalan 1.5× lebih pantas. Daripada crate-nya, hanya helix-term (dan xtask, yang bergantung padanya) dibina semula, kerana skrip build helix-term berjalan pada setiap job: 16 s dalam profil `test` dan 61 s dalam profil `integration`. Tiada crate lain dikompil. Kebanyakan job helix ialah ujiannya: suite ujian integrasi sahaja berjalan selama 112 s. Step persediaannya, toolchain dan pemulihan cache, mengambil masa 9-10 s berbanding 41-46 s di GitHub.

Bahasa lain:

| Projek | Bahasa | GitHub | Skipbox, mesin khusus |
|---|---|---|---|
| [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 ialah cerita yang sama seperti `target/`, dengan Turborepo: mesin khusus mengekalkan cache turbo (turbo 2), jadi larian hangatnya memainkan semula kesemua 40 tugas build dan tugas ujian daripadanya dan bukannya menjalankannya ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

`ubuntu-latest` repositori peribadi mempunyai 2 CPU dan 8 GB: separuh teras larian GitHub di atas.

## Semak CI anda sendiri

1. Buka larian hangat job Rust anda, yang step rust-cache-nya mencatat `full match: true`.
2. Dalam step build dan ujian, kira baris `Compiling`. Dependency daripada cache tidak mencetak apa-apa. Setiap crate workspace anda mencetak satu, begitu juga setiap crate yang dibina di atasnya.
3. Jumlahkan masa `Finished … in` step-step itu. Itulah kos crate anda sendiri pada setiap larian, dan apa yang dijimatkan oleh `target/` yang dikekalkan apabila crate itu tidak berubah.

## Apa yang boleh anda lakukan pada runner GitHub

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 dan kemudian). Crate anda turut masuk ke dalam cache. Tetapi larian yang key-nya wujud melangkau simpanan, dan key tidak berubah dengan kod sumber anda, jadi crate dalam cache setua simpanan terakhir. Kompilasi inkremental kekal dimatikan, dan cache membesar di dalam 10 GB GitHub bagi setiap repositori.
- **sccache.** Ia menyimpan cache setiap kompilasi mengikut inputnya, jadi crate library yang tidak berubah kembali daripada storan. Crate yang memanggil linker tidak boleh disimpan dalam cache: binari, crate `dylib`, `cdylib` dan proc-macro dikompil setiap kali, dan setiap hit ialah muat turun.
- **Self-hosted runner yang mengekalkan `target/`.** Anda menjalankan mesinnya: menampalnya, membersihkannya antara job tanpa memadam `target/`, dan menetapkan `clean: false` pada actions/checkout, yang `git clean -ffdx` lalainya memadam `target/` bersama setiap fail lain yang diabaikan.

## Skipbox mengekalkan target/ untuk anda

Setiap pelan disertakan dengan mesin khusus akaun anda, dikekalkan antara job. Sejak 13 November 2026 ia mengekalkan checkout anda, dengan masa fail-failnya, dan `target/` Cargo:

- Pembersihan actions/checkout berjalan seperti biasa, kecuali ia tidak menyentuh direktori `target/` Cargo.
- rust-cache kekal dalam workflow anda. Pemulihannya tidak lagi menulis artifact cache yang lebih lama di atas yang lebih baharu pada cakera.
- Apa yang dipadam oleh simpanan dan pemulihan rust-cache daripada `target/` dan `~/.cargo`, mesin mengembalikannya sebaik step itu tamat. Cache yang disimpan sama, dan sejak job selepas larian sejuk, crate yang tidak berubah tidak dikompil.
- `target/` yang dibuat oleh cross (ditandakan "created by cross") juga kekal.
- actions/checkout menulis semula `.git/HEAD` pada setiap job. Selagi ia masih menamakan commit yang sama, fail itu mendapat semula masa lamanya, jadi skrip build yang memerhati `.git/HEAD` (vergen melakukannya) tidak berjalan semula hanya kerana itu.

Mesin itu juga mengekalkan imej Docker, cache pakej dan alat yang dipasang, jadi baki job turut menjadi lebih pantas. Job memilih saiznya melalui label:

| Label | Mesin | Pelan |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 sebulan |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 sebulan |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 sebulan |

Minit tanpa had. Pada 20,000 minit sebulan pada 4 vCPU, GitHub mengecaj $222; Skipbox S ialah $39, $183 lebih murah.

## Beralih hanya satu baris

```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. Log masuk ke Skipbox dengan GitHub.
2. Pasang GitHub App Skipbox dan pilih repositori.
3. Tukar `runs-on` dan push.

## Keselamatan

- Mesin itu milik akaun anda seorang. Tiada job syarikat lain berjalan padanya.
- Selepas setiap job, bukti kelayakan, proses dan container runner dipadam, begitu juga bukti kelayakan git, hook dan fail tidak dijejak dalam checkout yang dikekalkan. “VM baharu bagi setiap job” memberi setiap job mesin baharu sebaliknya.
- Kod daripada orang tanpa akses tulis (seperti pull request daripada fork) berjalan pada mesin baharu sekali guna, tanpa `target/` yang dikekalkan.

Butirannya dalam [cara job diasingkan](https://docs.skipbox.dev/ms/isolation).

## Cuba pada job Rust anda

Percubaan adalah percuma selama 7 hari atau 3,000 minit job, yang mana dahulu, dan tidak memerlukan kad. Pindahkan job Rust anda ke `runs-on: skipbox`, jalankan dua kali, dan letakkan baris `Compiling` larian kedua bersebelahan dengan GitHub.

## Soalan lazim

### Adakah Swatinem/rust-cache menyimpan cache crate workspace saya?

Tidak, secara lalai tidak. README-nya menyatakan crate workspace itu sendiri tidak disimpan dalam cache, dan step simpannya memadam output build crate tersebut daripada target/ sebelum memuat naik cache. Ia menyimpan ~/.cargo dan output build dependency anda, dan menetapkan CARGO_INCREMENTAL=0 untuk baki job. Jadi pada VM GitHub yang baharu, setiap larian hangat mengompil crate workspace anda sekali lagi, walaupun cache kena sepenuhnya. Dalam CI tauri di GitHub itu ialah 32 baris Compiling pada setiap larian hangat.

### Patutkah saya menetapkan cache-workspace-crates: true?

Ia turut memasukkan crate anda ke dalam cache (rust-cache v2.8.0 dan kemudian), tetapi cache key datang daripada toolchain, persekitaran, dan Cargo.lock serta Cargo.toml anda, bukan kod sumber anda. Larian yang key-nya sudah wujud melangkau simpanan, jadi salinan crate anda dalam cache setua simpanan terakhir dan semakin jauh daripada kod anda dengan setiap commit. Kompilasi inkremental kekal dimatikan. Semak log larian hangat: jika crate anda masih menunjukkan Compiling, ia tidak membantu.

### Adakah sccache membetulkan CI Rust yang perlahan di GitHub Actions?

Ia membantu bagi crate library yang inputnya tidak berubah. sccache tidak boleh menyimpan cache crate yang memanggil linker (crate bin, dylib, cdylib dan proc-macro), dan setiap hit ialah muat turun daripada storan cache-nya. target/ yang dikekalkan antara job tidak memerlukan muat turun: crate yang dilihat Cargo sebagai tidak berubah tidak dikompil langsung.

### Adakah saya perlu mengubah workflow untuk mengekalkan target/ di Skipbox?

Tidak. Tukar runs-on kepada skipbox dan biarkan rust-cache dan actions/checkout seperti sedia ada. Mesin khusus untuk anda mengekalkan checkout dan target/ Cargo antara job, dan pembersihan checkout tidak menyentuh direktori target/. Apabila simpanan rust-cache memadam crate anda daripada target/, mesin mengembalikannya, dan pemulihannya tidak lagi menulis artifact yang lebih lama di atas yang lebih baharu. Jadi sejak larian hangat pertama, crate yang tidak berubah tidak dikompil.

### Berapakah kos untuk mencuba?

Tiada. Percubaan ialah 7 hari atau 3,000 minit job, yang mana dahulu, tanpa kad. Pindahkan job Rust anda ke runs-on: skipbox, jalankan dua kali, dan bandingkan baris Compiling dan step build larian kedua dengan GitHub.

Dikemas kini 2026-11-19 · https://skipbox.dev/ms/guides/rust-cache-slow-rust-ci
