# Kenapa rust-cache tidak membuat CI Rust Anda cepat (tauri: 246 s menjadi 53 s)

> Swatinem/rust-cache meng-cache dependensi Anda, bukan crate workspace Anda, dan mematikan kompilasi inkremental. Jadi di VM baru milik GitHub, setiap job hangat mengompilasi ulang crate Anda sendiri. target/ yang disimpan di mesin yang tetap ada memperbaikinya: job CI tauri turun dari 246 detik menjadi 53 detik di Skipbox, dengan harga tetap $39 per bulan.

Swatinem/rust-cache, step cache di sebagian besar CI Rust, menyimpan dependensi Anda dan sengaja tidak menyertakan crate workspace Anda. Step ini juga mengatur `CARGO_INCREMENTAL=0`. Di runner GitHub setiap job dimulai di VM baru, jadi setiap job hangat, bahkan dengan cache hit penuh, mengompilasi ulang crate Anda sendiri. Tidak ada setelan rust-cache yang menghilangkannya. Yang menghilangkannya adalah `target/` yang masih ada dari job terakhir: Cargo lalu melewati setiap crate yang tidak berubah.

Skipbox menyimpannya untuk Anda. Job Anda berjalan di mesin khusus untuk akun Anda, yang menyimpan checkout dan `target/` milik Cargo di antara job. Job CI tauri memakan 246 detik di GitHub dan 53 detik di sana, tanpa mengompilasi satu pun crate-nya sejak run hangat pertama, tanpa perubahan workflow selain `runs-on: skipbox`, dengan harga tetap $39 per bulan.

- Job CI tauri: 246 detik di GitHub, 53 detik di Skipbox (4,6× lebih cepat). Setiap run-nya publik
- Dengan `target/` yang disimpan, Cargo tidak mengompilasi satu pun crate tauri: waktu build-nya turun dari 62 detik menjadi di bawah 2 detik
- 20.000 menit per bulan di 4 vCPU: $222 di GitHub, $39 di Skipbox

**GitHub Actions dengan harga tetap, menit tanpa batas** Skipbox menjalankan job GitHub Actions Anda di mesin khusus milik Anda sendiri: $39 per bulan, berapa pun menit yang Anda jalankan. Layer Docker dan cache dependensi tetap tersimpan di antara job, jadi job berikutnya langsung dimulai.

Runner 4 vCPU, 20.000 menit per bulan: GitHub $222 → Skipbox $39. Anda hemat $183 setiap bulan.

Pindah cukup dengan satu baris: `runs-on: skipbox`.

[Mulai uji coba gratis 7 hari](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-id)

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

Dari [README rust-cache](https://github.com/Swatinem/rust-cache#cache-details) dan source-nya:

- **Yang di-cache:** `~/.cargo` (registry, dependensi git, binary yang terpasang) dan `./target` dengan output build dependensi Anda.
- **Yang ditinggalkan:** "the workspace crates themselves are not cached". Sebelum save, pembersihannya menghapus semua isi `target/` yang bukan dependensi, jadi artifact crate Anda dihapus dari `target/` itu sendiri.
- **Kompilasi inkremental:** step restore mengekspor `CARGO_INCREMENTAL=0` untuk sisa job.
- **Kapan menyimpan:** hanya saat belum ada cache dengan key job itu. Key-nya berasal dari toolchain, environment, serta `Cargo.lock` dan `Cargo.toml` Anda. File source Anda tidak termasuk.

Di VM baru, semua itu berujung pada satu hal. Job hangat memulihkan dependensi Anda, lalu mengompilasi crate workspace Anda dan semua yang dibangun di atasnya, secara utuh, setiap kali.

## Mekanismenya, di log tauri

Job `test` tauri menjalankan lima step `cargo test` di Ubuntu, dengan rust-cache. Berikut run hangatnya, masing-masing dengan cache hit penuh (`full match: true` di log):

| Run hangat | Baris `Compiling` | Waktu build Cargo | Job |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, VM baru](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, mesin khusus untuk Anda, run hangat ke-1](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **sekitar 1,5 s** | **53 s** |
| [Skipbox, mesin khusus untuk Anda, run hangat ke-2](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **sekitar 1,9 s** | **53 s** |

32 baris itu adalah crate milik tauri sendiri, dan dua plugin yang dibangun di atasnya. Dependensinya tidak pernah muncul: semuanya berasal dari cache. Waktu build Cargo adalah jumlah waktu `Finished … in` dari kelima step.

VM baru memakai CPU yang sama dengan mesin khusus untuk Anda dan cache yang sama, dan VM itu mengompilasi 32 crate yang sama dengan GitHub: `target/`-nya hanya berisi apa yang dipulihkan cache. Di mesin khusus untuk Anda, run hangat pertama sudah tidak mencetak baris `Compiling`. Cargo hanya memeriksa bahwa tidak ada yang berubah, dan setiap `Finished` memakan 0,2-0,7 detik.

Run hangat pertama di mesin khusus untuk Anda dulu mengompilasi ulang seluruh 32 crate ([job 114 detik](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), karena save rust-cache setelah run dingin telah menghapusnya dari `target/`. Sejak 13 November 2026, mesin khusus untuk Anda mengembalikan apa yang dihapus restore dan save rust-cache dari disk, begitu step-nya selesai. Cache yang disimpannya sama, dan crate Anda tetap ada di `target/`.

## Waktu job: tiga proyek Rust, enam lainnya

Job CI milik proyek nyata pada commit yang dipatok, dengan step yang sama persis byte demi byte; hanya trigger dan `runs-on` yang diubah. Satu run dingin, lalu dua run hangat, di setiap sisi:

- **GitHub:** `ubuntu-24.04`, runner standar repositori publik: 4 vCPU, 16 GB.
- **Skipbox, VM baru:** VM baru per job dari image runner produksi, 4 vCPU dan 8 GB, dengan cache dipulihkan lewat cache Skipbox.
- **Skipbox, mesin khusus untuk Anda:** ukuran yang sama di CPU host yang sama, disimpan di antara job, dengan proses simpan-dan-hapus yang dijalankan mesin khusus untuk Anda sejak 13 November 2026: checkout dan `target/` tetap ada, dan apa yang dihapus rust-cache dikembalikan.

Run Skipbox berjalan di host Skipbox, dalam proyek lab yang terpisah dari mesin pelanggan. Waktunya dihitung dari awal hingga akhir setiap job, dari API GitHub. Setiap angka adalah median dari dua run hangat. Run dingin di mesin khusus untuk Anda memakan [285 detik](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) untuk tauri, [161 detik](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) untuk ripgrep, dan [442 detik](https://github.com/skipbox-dev/helix/actions/runs/43336739720) untuk helix.

| Proyek | GitHub | Skipbox, VM baru | Skipbox, mesin khusus untuk Anda | GitHub ÷ mesin khusus untuk Anda |
|---|---|---|---|---|
| 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 di-build di dalam image Docker milik cross. cross membuat `target/` sendiri dan menandainya "created by cross". Mesin khusus untuk Anda dulu mengira `target/` itu bukan milik Cargo dan menghapusnya setelah setiap job, jadi Cargo mengompilasi ulang setiap crate di setiap run (job 108 detik). Kini `target/` milik cross tetap ada: run hangatnya tidak mencetak baris `Compiling`, dan setiap `Finished` memakan 0,04-0,05 detik. GitHub juga mengunduh image cross di setiap run (30 detik di run hangat kedua); mesin khusus untuk Anda menyimpannya di disk.

helix juga 1,5× lebih cepat. Dari crate-nya, hanya helix-term (dan xtask, yang bergantung padanya) yang di-build ulang, karena build script helix-term berjalan di setiap job: 16 detik di profil `test` dan 61 detik di profil `integration`. Tidak ada crate lain yang dikompilasi. Sebagian besar job helix adalah testing: suite integration test-nya saja berjalan 112 detik. Step setup-nya, toolchain dan pemulihan cache, memakan 9-10 detik dibandingkan 41-46 detik di GitHub.

Bahasa lainnya:

| Proyek | Bahasa | GitHub | Skipbox, mesin khusus untuk Anda |
|---|---|---|---|
| [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 punya cerita yang sama dengan `target/`, dengan Turborepo: mesin khusus untuk Anda menyimpan cache turbo (turbo 2), jadi run hangatnya memutar ulang seluruh 40 task build dan task test dari cache itu alih-alih menjalankannya ([31 detik](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 detik](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

`ubuntu-latest` di repositori privat punya 2 CPU dan 8 GB: separuh jumlah core run GitHub di atas.

## Periksa CI Anda sendiri

1. Buka run hangat job Rust Anda, yang step rust-cache-nya mencatat `full match: true`.
2. Di step build dan test, hitung baris `Compiling`. Dependensi dari cache tidak mencetak apa pun. Setiap crate workspace Anda mencetak satu baris, begitu juga setiap crate yang dibangun di atasnya.
3. Jumlahkan waktu `Finished … in` dari step-step itu. Itulah biaya crate Anda sendiri di setiap run, dan yang dihemat `target/` yang disimpan saat crate itu tidak berubah.

## Yang bisa Anda lakukan di runner GitHub

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 dan yang lebih baru). Crate Anda juga masuk ke cache. Tetapi run yang key-nya sudah ada melewati save, dan key-nya tidak berubah mengikuti source Anda, jadi crate yang di-cache setua save terakhir. Kompilasi inkremental tetap mati, dan cache-nya tumbuh di dalam 10 GB per repositori milik GitHub.
- **sccache.** sccache meng-cache setiap kompilasi berdasarkan input-nya, jadi crate library yang tidak berubah kembali dari storage. Crate yang memanggil linker tidak bisa di-cache: binary, crate `dylib`, `cdylib`, dan proc-macro dikompilasi setiap kali, dan setiap hit adalah unduhan.
- **Self-hosted runner yang menyimpan `target/`.** Anda yang menjalankan mesinnya: mem-patch-nya, membersihkannya di antara job tanpa menghapus `target/`, dan mengatur `clean: false` di actions/checkout, yang `git clean -ffdx` default-nya menghapus `target/` bersama setiap file lain yang di-ignore.

## Skipbox menyimpan target/ untuk Anda

Setiap paket datang dengan mesin khusus untuk akun Anda, yang disimpan di antara job. Sejak 13 November 2026 mesin itu menyimpan checkout Anda, beserta waktu file-filenya, dan `target/` milik Cargo:

- Clean milik actions/checkout berjalan seperti biasa, kecuali bahwa clean itu membiarkan direktori `target/` milik Cargo.
- rust-cache tetap ada di workflow Anda. Restore-nya tidak lagi menimpa artifact yang lebih baru di disk dengan artifact cache yang lebih lama.
- Apa yang dihapus save dan restore rust-cache dari `target/` dan `~/.cargo` dikembalikan oleh mesin begitu step-nya selesai. Cache yang disimpan sama, dan sejak job setelah run dingin, crate yang tidak berubah tidak dikompilasi.
- `target/` yang dibuat cross (ditandai "created by cross") juga tetap ada.
- actions/checkout menulis ulang `.git/HEAD` di setiap job. Selama file itu masih menunjuk commit yang sama, file itu mendapat kembali waktu lamanya, jadi build script yang memantau `.git/HEAD` (seperti vergen) tidak berjalan ulang hanya karena itu.

Mesinnya juga menyimpan image Docker, cache paket, dan tool yang terpasang, jadi bagian lain job ikut menjadi lebih cepat. Sebuah job memilih ukurannya lewat label:

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

Menitnya tanpa batas. Untuk 20.000 menit per bulan di 4 vCPU, GitHub menagih $222; Skipbox S $39, $183 lebih murah.

## Pindah cukup 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. Masuk ke Skipbox dengan GitHub.
2. Instal aplikasi GitHub Skipbox dan pilih repositorinya.
3. Ubah `runs-on`, lalu push.

## Keamanan

- Mesinnya hanya milik akun Anda. Tidak ada job perusahaan lain yang berjalan di sana.
- Setelah setiap job, kredensial runner, proses, dan container dihapus, begitu juga kredensial git, hook, dan file yang tidak dilacak di checkout yang disimpan. Bersih setiap job memberi setiap job mesin baru sebagai gantinya.
- Kode dari orang tanpa akses tulis (misalnya pull request dari fork) berjalan di mesin baru sekali pakai, tanpa `target/` yang disimpan.

Detailnya ada di [cara job diisolasi](https://docs.skipbox.dev/id/isolation).

## Coba di job Rust Anda

Uji cobanya gratis selama 7 hari atau 3.000 menit job, mana yang lebih dulu tercapai, dan tanpa kartu. Pindahkan job Rust Anda ke `runs-on: skipbox`, jalankan dua kali, lalu letakkan baris `Compiling` di run kedua di samping hasil di GitHub.

## FAQ

### Apakah Swatinem/rust-cache meng-cache crate workspace saya?

Tidak, tidak secara default. README-nya menyebutkan bahwa crate workspace itu sendiri tidak di-cache, dan step save-nya menghapus output build crate itu dari target/ sebelum mengunggah cache. rust-cache meng-cache ~/.cargo dan output build dependensi Anda, dan mengatur CARGO_INCREMENTAL=0 untuk sisa job. Jadi di VM GitHub yang baru, setiap run hangat mengompilasi ulang crate workspace Anda, bahkan saat cache hit penuh. Di CI tauri di GitHub, itu berarti 32 baris Compiling di setiap run hangat.

### Perlukah saya mengatur cache-workspace-crates: true?

Opsi itu memasukkan crate Anda juga ke cache (rust-cache v2.8.0 dan yang lebih baru), tetapi cache key-nya berasal dari toolchain, environment, serta Cargo.lock dan Cargo.toml Anda, bukan dari source Anda. Run yang key-nya sudah ada melewati save, jadi salinan crate Anda di cache setua save terakhir dan makin menyimpang dari kode Anda di setiap commit. Kompilasi inkremental tetap mati. Periksa log run hangat: jika crate Anda masih menampilkan Compiling, opsi itu tidak membantu.

### Apakah sccache memperbaiki CI Rust yang lambat di GitHub Actions?

sccache membantu untuk crate library yang input-nya tidak berubah. sccache tidak bisa meng-cache crate yang memanggil linker (crate bin, dylib, cdylib, dan proc-macro), dan setiap hit adalah unduhan dari storage cache-nya. target/ yang disimpan di antara job tidak butuh unduhan: crate yang dianggap Cargo tidak berubah tidak dikompilasi sama sekali.

### Apakah saya harus mengubah workflow agar target/ disimpan di Skipbox?

Tidak. Ubah runs-on menjadi skipbox dan biarkan rust-cache dan actions/checkout seperti apa adanya. Mesin khusus untuk Anda menyimpan checkout dan target/ milik Cargo di antara job, dan clean milik checkout membiarkan direktori target/. Saat save rust-cache menghapus crate Anda dari target/, mesin mengembalikannya, dan restore-nya tidak lagi menimpa artifact yang lebih baru dengan yang lebih lama. Jadi sejak run hangat pertama, crate yang tidak berubah tidak dikompilasi.

### Berapa biaya untuk mencobanya?

Gratis. Uji cobanya 7 hari atau 3.000 menit job, mana yang lebih dulu tercapai, tanpa kartu. Pindahkan job Rust Anda ke runs-on: skipbox, jalankan dua kali, lalu bandingkan baris Compiling dan step build di run kedua dengan di GitHub.

Diperbarui 2026-11-19 · https://skipbox.dev/id/guides/rust-cache-slow-rust-ci
