# Vì sao rust-cache không làm CI Rust của bạn nhanh lên (tauri: 246 giây xuống 53 giây)

> Swatinem/rust-cache cache các dependency, không cache các crate trong workspace của bạn, và tắt incremental compilation. Vì vậy trên VM mới của GitHub, job warm nào cũng biên dịch lại các crate của chính bạn. Một target/ được giữ trên một cái máy không bị xóa sẽ sửa được chuyện này: job CI của tauri từ 246 giây xuống 53 giây trên Skipbox, với giá cố định $39 một tháng.

Swatinem/rust-cache, step cache có trong phần lớn CI Rust, lưu các dependency của bạn và cố ý bỏ ra ngoài các crate trong workspace. Nó còn đặt `CARGO_INCREMENTAL=0`. Trên runner của GitHub, job nào cũng khởi đầu trên một VM mới, nên job warm nào, dù cache hit trọn vẹn, cũng biên dịch lại các crate của chính bạn. Không thiết lập rust-cache nào làm chuyện đó biến mất. Thứ làm được là một `target/` vẫn còn từ job trước: khi đó Cargo bỏ qua mọi crate không thay đổi.

Skipbox giữ nó cho bạn. Job của bạn chạy trên máy riêng của tài khoản bạn, nơi giữ bản checkout và `target/` của Cargo giữa các job. Job CI của tauri mất 246 giây trên GitHub và 53 giây ở đó, không biên dịch crate nào của nó ngay từ lần chạy warm đầu tiên, và workflow không đổi gì ngoài `runs-on: skipbox`, với giá cố định $39 một tháng.

- Job CI của tauri: 246 giây trên GitHub, 53 giây trên Skipbox (nhanh gấp 4,6 lần). Mọi lần chạy đều công khai
- Khi `target/` được giữ, Cargo không biên dịch crate nào của tauri: thời gian build từ 62 giây xuống dưới 2 giây
- 20.000 phút mỗi tháng trên 4 vCPU: $222 trên GitHub, $39 trên Skipbox

**GitHub Actions giá cố định, không giới hạn phút** Skipbox chạy job GitHub Actions của bạn trên máy riêng dành cho bạn: $39 một tháng, dù bạn chạy bao nhiêu phút. Docker layer và cache dependency được giữ giữa các job, nên job tiếp theo khởi chạy ngay.

Runner 4 vCPU, 20.000 phút một tháng: GitHub $222 → Skipbox $39. Bạn tiết kiệm $183 mỗi tháng.

Chỉ cần đổi một dòng: `runs-on: skipbox`.

[Bắt đầu dùng thử miễn phí 7 ngày](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-vi)

## rust-cache giữ gì, và bỏ ra ngoài gì

Theo [README của rust-cache](https://github.com/Swatinem/rust-cache#cache-details) và mã nguồn của nó:

- **Nó cache gì:** `~/.cargo` (registry, dependency từ git, binary đã cài) và `./target` với kết quả build của các dependency.
- **Nó bỏ ra ngoài gì:** bản thân các crate trong workspace không được cache. Trước khi lưu, bước dọn của nó xóa mọi thứ trong `target/` không phải dependency, nên artifact của các crate của bạn bị gỡ khỏi chính `target/`.
- **Incremental compilation:** bước khôi phục export `CARGO_INCREMENTAL=0` cho phần còn lại của job.
- **Khi nào nó lưu:** chỉ khi chưa có cache nào mang key của job. Key lấy từ toolchain, môi trường, `Cargo.lock` và `Cargo.toml` của bạn. Các file mã nguồn không nằm trong đó.

Trên một VM mới, tất cả cộng lại thành một điều. Job warm khôi phục các dependency, rồi biên dịch các crate trong workspace và mọi thứ được build trên chúng, toàn bộ, lần nào cũng vậy.

## Cơ chế, trong log của tauri

Job `test` của tauri chạy năm step `cargo test` trên Ubuntu, với rust-cache. Đây là các lần chạy warm của nó, mỗi lần đều cache hit trọn vẹn (`full match: true` trong log):

| Lần chạy warm | Số dòng `Compiling` | Thời gian build của Cargo | Job |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 giây | 271 giây |
| [Skipbox, VM mới](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 giây | 146 giây |
| [Skipbox, máy riêng, lần warm thứ 1](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **khoảng 1,5 giây** | **53 giây** |
| [Skipbox, máy riêng, lần warm thứ 2](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **khoảng 1,9 giây** | **53 giây** |

32 dòng đó là các crate của chính tauri, và hai plugin được build trên chúng. Các dependency không bao giờ xuất hiện: chúng đến từ cache. Thời gian build của Cargo là tổng các thời gian `Finished … in` của năm step.

VM mới có CPU giống máy riêng và cùng cache đó, và nó biên dịch đúng 32 crate như GitHub: `target/` của nó chỉ chứa những gì cache khôi phục. Trên máy riêng, ngay lần chạy warm đầu tiên đã không in dòng `Compiling` nào. Cargo chỉ kiểm tra rằng không có gì thay đổi, và mỗi `Finished` mất 0,2-0,7 giây.

Lần chạy warm đầu tiên của máy riêng từng biên dịch lại cả 32 crate ([một job 114 giây](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), vì bước lưu của rust-cache sau lần chạy nguội đã xóa chúng khỏi `target/`. Từ ngày 13 tháng 11 năm 2026, máy riêng hoàn tác những gì bước khôi phục và bước lưu của rust-cache xóa khỏi ổ đĩa, ngay khi step kết thúc. Cache nó lưu vẫn như cũ, và các crate của bạn ở lại trong `target/`.

## Thời gian job: ba dự án Rust, sáu dự án khác

Chính các job CI của những dự án thật ở một commit cố định, các step giữ nguyên từng byte; chỉ trigger và `runs-on` thay đổi. Mỗi bên một lần chạy nguội, rồi hai lần warm:

- **GitHub:** `ubuntu-24.04`, runner tiêu chuẩn của repository công khai: 4 vCPU, 16 GB.
- **Skipbox, VM mới:** một VM mới cho mỗi job từ image runner production, 4 vCPU và 8 GB, cache được khôi phục qua cache của Skipbox.
- **Skipbox, máy riêng:** cùng kích thước trên cùng CPU của host, được giữ giữa các job, với cơ chế giữ-và-xóa mà máy riêng chạy từ ngày 13 tháng 11 năm 2026: bản checkout và `target/` được giữ, và những gì rust-cache xóa được đặt trở lại.

Các lần chạy Skipbox diễn ra trên một host của Skipbox, trong một dự án thử nghiệm tách biệt với máy của khách hàng. Thời gian tính từ lúc job bắt đầu đến lúc kết thúc, lấy từ API của GitHub. Mỗi con số là trung vị của hai lần chạy warm. Lần chạy nguội của máy riêng mất [285 giây](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) với tauri, [161 giây](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) với ripgrep và [442 giây](https://github.com/skipbox-dev/helix/actions/runs/43336739720) với helix.

| Dự án | GitHub | Skipbox, VM mới | Skipbox, máy riêng | GitHub ÷ máy riêng |
|---|---|---|---|---|
| tauri | 246 giây ([220](https://github.com/skipbox-dev/tauri/actions/runs/43233861304), [271](https://github.com/skipbox-dev/tauri/actions/runs/43234522982)) | 210 giây ([273](https://github.com/skipbox-dev/tauri/actions/runs/43290912312), [146](https://github.com/skipbox-dev/tauri/actions/runs/43291768486)) | **53 giây** ([53](https://github.com/skipbox-dev/tauri/actions/runs/43340142076), [53](https://github.com/skipbox-dev/tauri/actions/runs/43340289959)) | **4,6×** |
| ripgrep | 200 giây ([194](https://github.com/skipbox-dev/ripgrep/actions/runs/43220584380), [206](https://github.com/skipbox-dev/ripgrep/actions/runs/43221108547)) | 156 giây ([155](https://github.com/skipbox-dev/ripgrep/actions/runs/43292759363), [156](https://github.com/skipbox-dev/ripgrep/actions/runs/43293273127)) | **40 giây** ([39](https://github.com/skipbox-dev/ripgrep/actions/runs/43340925562), [40](https://github.com/skipbox-dev/ripgrep/actions/runs/43341036341)) | **5,0×** |
| helix | 330 giây ([293](https://github.com/skipbox-dev/helix/actions/runs/43227916673), [366](https://github.com/skipbox-dev/helix/actions/runs/43228816343)) | 350 giây ([439](https://github.com/skipbox-dev/helix/actions/runs/43287815770), [260](https://github.com/skipbox-dev/helix/actions/runs/43289134146)) | **224 giây** ([222](https://github.com/skipbox-dev/helix/actions/runs/43337749813), [226](https://github.com/skipbox-dev/helix/actions/runs/43338273330)) | **1,5×** |

ripgrep build bên trong Docker image của cross. cross tự tạo `target/` và gắn tag "created by cross" cho nó. Máy riêng từng coi `target/` đó là thứ gì khác chứ không phải của Cargo và xóa nó sau mỗi job, nên Cargo biên dịch lại mọi crate ở mỗi lần chạy (một job 108 giây). Giờ `target/` của cross được giữ: các lần chạy warm không in dòng `Compiling` nào, và mỗi `Finished` mất 0,04-0,05 giây. GitHub còn tải image của cross ở mỗi lần chạy (30 giây trong lần warm thứ hai); máy riêng giữ nó trên ổ đĩa.

helix cũng nhanh hơn 1,5×. Trong các crate của nó, chỉ helix-term (và xtask, phụ thuộc vào nó) được build lại, vì build script của helix-term chạy ở mọi job: 16 giây ở profile `test` và 61 giây ở profile `integration`. Không crate nào khác bị biên dịch. Phần lớn job của helix là test: riêng bộ integration test chạy 112 giây. Step chuẩn bị của nó, toolchain và khôi phục cache, mất 9-10 giây so với 41-46 giây trên GitHub.

Các ngôn ngữ khác:

| Dự án | Ngôn ngữ | GitHub | Skipbox, máy riêng |
|---|---|---|---|
| [astro](https://github.com/skipbox-dev/astro/actions) | Node.js | 528 giây | **30 giây** |
| [vite](https://github.com/skipbox-dev/vite/actions) | Node.js | 141 giây | 100 giây |
| [prometheus](https://github.com/skipbox-dev/prometheus/actions) | Go | 335 giây | 273 giây |
| [cli](https://github.com/skipbox-dev/cli/actions) | Go | 163 giây | 137 giây |
| [pytest](https://github.com/skipbox-dev/pytest/actions) | Python | 416 giây | 365 giây |
| [guava](https://github.com/skipbox-dev/guava/actions) | Java | 818 giây | 651 giây |

astro là cùng câu chuyện với `target/`, nhưng với Turborepo: máy riêng giữ cache của turbo (turbo 2), nên các lần chạy warm phát lại cả 40 task build và task test từ đó thay vì chạy chúng ([31 giây](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 giây](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

`ubuntu-latest` của repository riêng tư có 2 CPU và 8 GB: một nửa số nhân của các lần chạy GitHub ở trên.

## Kiểm tra CI của chính bạn

1. Mở một lần chạy warm của job Rust, lần mà step rust-cache ghi log `full match: true`.
2. Trong các step build và test, đếm số dòng `Compiling`. Dependency từ cache không in dòng nào. Mỗi crate trong workspace của bạn in một dòng, và mỗi crate được build trên chúng cũng vậy.
3. Cộng các thời gian `Finished … in` của các step. Đó là cái giá các crate của bạn tốn ở mỗi lần chạy, và là phần một `target/` được giữ tiết kiệm được khi chúng không thay đổi.

## Những gì bạn làm được trên runner của GitHub

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 trở lên). Các crate của bạn cũng vào cache. Nhưng lần chạy nào có key đã tồn tại thì bỏ qua bước lưu, và key không thay đổi theo mã nguồn, nên các crate được cache cũ đúng bằng lần lưu cuối. Incremental compilation vẫn tắt, và cache phình dần trong 10 GB mỗi repository của GitHub.
- **sccache.** Nó cache từng lần biên dịch theo input, nên một library crate không đổi được lấy về từ kho lưu trữ. Các crate gọi linker không cache được: binary, crate `dylib`, `cdylib` và proc-macro lần nào cũng biên dịch, và mỗi hit là một lần tải.
- **Một self-hosted runner giữ `target/`.** Bạn tự vận hành máy: vá lỗi, dọn dẹp giữa các job mà không xóa `target/`, và đặt `clean: false` cho actions/checkout, vốn mặc định chạy `git clean -ffdx` xóa `target/` cùng mọi file bị ignore khác.

## Skipbox giữ target/ cho bạn

Mỗi gói đi kèm máy riêng của tài khoản bạn, được giữ lại giữa các job. Từ ngày 13 tháng 11 năm 2026, nó giữ bản checkout của bạn, kèm thời gian của các file, và `target/` của Cargo:

- Bước dọn của actions/checkout vẫn chạy như thường, chỉ để yên các thư mục `target/` của Cargo.
- rust-cache vẫn ở trong workflow của bạn. Bước khôi phục của nó không còn ghi đè artifact cũ hơn từ cache lên artifact mới hơn trên ổ đĩa.
- Những gì bước lưu và khôi phục của rust-cache xóa khỏi `target/` và `~/.cargo`, máy đặt trở lại ngay khi step kết thúc. Cache được lưu vẫn như cũ, và từ job sau lần chạy nguội, crate nào không đổi thì không bị biên dịch.
- `target/` mà cross tạo ra (gắn tag "created by cross") cũng được giữ.
- actions/checkout ghi lại `.git/HEAD` ở mỗi job. Khi nó vẫn trỏ tới cùng một commit, file được trả lại thời gian cũ, nên build script nào theo dõi `.git/HEAD` (vergen có làm vậy) không chạy lại chỉ vì chuyện đó.

Máy còn giữ Docker image, cache package và tool đã cài, nên phần còn lại của job cũng nhanh lên theo. Job chọn kích thước bằng nhãn:

| Nhãn | Máy | Gói |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 một tháng |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 một tháng |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 một tháng |

Không giới hạn phút. Ở mức 20.000 phút mỗi tháng trên 4 vCPU, GitHub tính $222; Skipbox S là $39, ít hơn $183.

## Chuyển sang chỉ cần một dòng

```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. Đăng nhập Skipbox bằng GitHub.
2. Cài ứng dụng GitHub của Skipbox và chọn các repository.
3. Đổi `runs-on` rồi push.

## Bảo mật

- Máy chỉ thuộc về tài khoản của bạn. Không có job của công ty nào khác chạy trên đó.
- Sau mỗi job, thông tin xác thực, tiến trình và container của runner bị xóa, cùng thông tin xác thực git, hook và các file không được track trong bản checkout được giữ lại. Bật VM mới cho mỗi job thì mỗi job chạy trên một máy mới.
- Code từ người không có quyền ghi (chẳng hạn pull request từ fork) chạy trên một máy mới, dùng xong là bỏ, không có `target/` được giữ.

Chi tiết có trong [cách các job được cách ly](https://docs.skipbox.dev/vi/isolation).

## Thử trên job Rust của bạn

Dùng thử miễn phí trong 7 ngày hoặc 3.000 phút chạy job, tùy điều kiện nào đến trước, không cần thẻ. Chuyển job Rust sang `runs-on: skipbox`, chạy hai lần, và đặt các dòng `Compiling` của lần chạy thứ hai cạnh số liệu của GitHub.

## Câu hỏi thường gặp

### Swatinem/rust-cache có cache các crate trong workspace của tôi không?

Mặc định thì không. README của nó ghi rằng bản thân các crate trong workspace không được cache, và step lưu của nó xóa kết quả build của chúng khỏi target/ trước khi tải cache lên. Nó cache ~/.cargo và kết quả build của các dependency, và đặt CARGO_INCREMENTAL=0 cho phần còn lại của job. Vì vậy trên một VM GitHub mới, lần chạy warm nào cũng biên dịch lại các crate trong workspace, kể cả khi cache hit trọn vẹn. Trong CI của tauri trên GitHub, đó là 32 dòng Compiling ở mỗi lần chạy warm.

### Có nên đặt cache-workspace-crates: true không?

Nó đưa cả các crate của bạn vào cache (rust-cache v2.8.0 trở lên), nhưng cache key lấy từ toolchain, môi trường, Cargo.lock và Cargo.toml của bạn, không lấy từ mã nguồn. Lần chạy nào có key đã tồn tại thì bỏ qua bước lưu, nên bản cache các crate của bạn cũ đúng bằng lần lưu cuối và lệch dần khỏi code sau mỗi commit. Incremental compilation vẫn tắt. Hãy xem log của một lần chạy warm: nếu các crate của bạn vẫn hiện Compiling, nó không giúp gì.

### sccache có sửa được CI Rust chậm trên GitHub Actions không?

Nó giúp được với các library crate có input không đổi. sccache không cache được các crate gọi linker (crate bin, dylib, cdylib và proc-macro), và mỗi hit là một lần tải từ kho cache của nó. Một target/ được giữ giữa các job thì không cần tải gì: crate nào Cargo thấy không đổi thì không bị biên dịch.

### Có phải sửa workflow để giữ target/ trên Skipbox không?

Không. Đổi runs-on thành skipbox và giữ nguyên rust-cache và actions/checkout. Máy riêng của bạn giữ bản checkout và target/ của Cargo giữa các job, và bước dọn của checkout để yên các thư mục target/. Khi bước lưu của rust-cache xóa các crate của bạn khỏi target/, máy đặt chúng trở lại, và bước khôi phục của nó không còn ghi đè artifact cũ hơn lên artifact mới hơn. Vì vậy ngay từ lần chạy warm đầu tiên, crate nào không đổi thì không bị biên dịch.

### Thử thì tốn bao nhiêu?

Không tốn gì. Dùng thử kéo dài 7 ngày hoặc 3.000 phút chạy job, tùy điều kiện nào đến trước, không cần thẻ. Chuyển job Rust sang runs-on: skipbox, chạy hai lần, rồi so các dòng Compiling và các step build của lần chạy thứ hai với GitHub.

Cập nhật ngày 2026-11-16 · https://skipbox.dev/vi/guides/rust-cache-slow-rust-ci
