# 为什么 rust-cache 不能让你的 Rust CI 变快（tauri：246 秒到 53 秒）

> Swatinem/rust-cache 缓存的是你的依赖，而不是你工作区里的 crate，还会关掉增量编译。所以在 GitHub 每次都是新的虚拟机上，每个热作业都要重新编译你自己的 crate。在一台保留下来的机器上保留 target/ 就能解决：tauri 的 CI 作业在 Skipbox 上从 246 秒降到 53 秒，每月固定 $39。

Swatinem/rust-cache 是大多数 Rust CI 中的缓存步骤，它保存你的依赖，却有意不保存你工作区里的 crate。它还会设置 `CARGO_INCREMENTAL=0`。在 GitHub 的运行器上，每个作业都在一台新虚拟机上启动，所以每个热作业，哪怕缓存完全命中，都要重新编译你自己的 crate。没有哪个 rust-cache 设置能消除这一点。能消除它的，是一个上一个作业留下来的 `target/`：这样 Cargo 会跳过每一个没有变化的 crate。

Skipbox 替你保留它。你的作业在你账号的专属机器上运行，这台机器在作业之间保留检出目录和 Cargo 的 `target/`。tauri 的 CI 作业在 GitHub 上要 246 秒，在那里只要 53 秒，从第一次热运行起，它的 crate 一个都没编译，工作流除了 `runs-on: skipbox` 什么都没改，每月固定 $39。

- tauri 的 CI 作业：GitHub 上 246 秒，Skipbox 上 53 秒（快 4.6 倍）。每次运行都是公开的
- 保留了 `target/`，Cargo 一个 tauri 的 crate 都没编译：它的构建时间从 62 秒降到不到 2 秒
- 4 vCPU 每月 2万分钟：GitHub 上 $222，Skipbox 上 $39

**固定价格的 GitHub Actions，分钟数不限** Skipbox 在你的专属机器上运行 GitHub Actions 作业：每月 $39，无论运行多少分钟。Docker 层和依赖缓存在作业之间保留，所以下一个作业能立即开始。

4 vCPU 运行器，每月 2万分钟: GitHub $222 → Skipbox $39. 每月节省 $183.

切换只需改一行：`runs-on: skipbox`。

[开始 7 天免费试用](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-zh-hans)

## rust-cache 保留什么，又漏掉什么

根据 [rust-cache 的 README](https://github.com/Swatinem/rust-cache#cache-details) 和它的源代码：

- **它缓存的东西**：`~/.cargo`（注册表、git 依赖、已安装的二进制文件）以及 `./target` 中你依赖的构建输出。
- **它漏掉的东西**：工作区 crate 本身不会被缓存。保存之前，它的清理步骤会删掉 `target/` 中所有不属于依赖的东西，所以你的 crate 的产物会从 `target/` 本身被删除。
- **增量编译**：恢复步骤在作业剩下的部分导出 `CARGO_INCREMENTAL=0`。
- **什么时候保存**：只在还没有缓存用这个作业的键时才保存。键来自工具链、环境，以及你的 `Cargo.lock` 和 `Cargo.toml`。你的源文件不在其中。

在一台新虚拟机上，这些加起来就是一件事。热作业恢复你的依赖，然后每一次都要把你的工作区 crate 以及建立在它们之上的所有东西整个编译一遍。

## 从 tauri 的日志看这个机制

tauri 的 `test` 作业在 Ubuntu 上用 rust-cache 运行五个 `cargo test` 步骤。下面是它的热运行，每一次缓存都完全命中（日志中为 `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 自己的 crate，以及建立在它们之上的两个插件。依赖从来不会出现：它们来自缓存。Cargo 的构建时间是五个步骤的 `Finished … in` 时间之和。

新虚拟机和专属机器的 CPU 相同，缓存也相同，它编译的也是和 GitHub 一样的 32 个 crate：它的 `target/` 里只有缓存恢复的东西。在专属机器上，第一次热运行就已经一行 `Compiling` 都不打印了。Cargo 只是确认了什么都没变，每个 `Finished` 只用了 0.2-0.7 秒。

专属机器的第一次热运行过去会把 32 个 crate 全部重新编译（[一个 114 秒的作业](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)），因为冷运行之后 rust-cache 的保存步骤已经把它们从 `target/` 中删掉了。从 2026年11月13日起，专属机器会在步骤结束后，撤销 rust-cache 的恢复和保存从磁盘上删掉的东西。它保存的缓存不变，而你的 crate 留在 `target/` 中。

## 作业时间：三个 Rust 项目，另外六个

真实项目自己的 CI 作业，固定在某个提交上，步骤一字不改；只改了触发条件和 `runs-on`。每一边都是一次冷运行，再加两次热运行：

- **GitHub**：`ubuntu-24.04`，公开仓库的标准运行器：4 vCPU，16 GB。
- **Skipbox，新虚拟机**：每个作业一台用生产运行器镜像创建的新虚拟机，4 vCPU、8 GB，缓存通过 Skipbox 的缓存恢复。
- **Skipbox，专属机器**：同样的规格、同样的主机 CPU，在作业之间保留，并采用专属机器自 2026年11月13日起的保留与清除方式：检出目录和 `target/` 保留，rust-cache 删掉的东西会被放回去。

Skipbox 的运行在一台 Skipbox 主机上进行，放在一个与客户机器隔开的实验项目中。时间从每个作业开始到结束计算，取自 GitHub 的 API。每个数字是两次热运行的中位数。专属机器的冷运行，tauri 用了 [285 秒](https://github.com/skipbox-dev/tauri/actions/runs/43339483384)，ripgrep 用了 [161 秒](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466)，helix 用了 [442 秒](https://github.com/skipbox-dev/helix/actions/runs/43336739720)。

| 项目 | 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 在 cross 的 Docker 镜像里构建。cross 自己创建 `target/`，并给它打上 "created by cross" 的标记。专属机器过去会把这个 `target/` 当成不属于 Cargo 的东西，在每个作业后删掉，所以 Cargo 每次运行都要重新编译每个 crate（一个 108 秒的作业）。现在 cross 的 `target/` 会保留：热运行一行 `Compiling` 都不打印，每个 `Finished` 只用 0.04-0.05 秒。GitHub 还要在每次运行时下载 cross 的镜像（第二次热运行中为 30 秒）；专属机器把它留在磁盘上。

helix 也快了 1.5×。它的 crate 里只有 helix-term（以及依赖它的 xtask）会重新构建，因为 helix-term 的构建脚本每个作业都会运行：在 `test` 配置下要 16 秒，在 `integration` 配置下要 61 秒。没有其他 crate 要编译。helix 的作业大部分是测试：光是集成测试套件就要跑 112 秒。它的准备步骤，也就是工具链和缓存恢复，用了 9-10 秒，而在 GitHub 上是 41-46 秒。

其他语言：

| 项目 | 语言 | 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 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 和上一次保存一样旧。增量编译仍然是关的，缓存还会占用 GitHub 每个仓库 10 GB 的空间。
- **sccache**：它按输入缓存每一次编译，所以没有变化的库 crate 会从存储中取回。调用链接器的 crate 无法缓存：二进制文件、`dylib`、`cdylib` 和 proc-macro crate 每次都要编译，而且每次命中都是一次下载。
- **一台保留 `target/` 的自托管运行器**：机器由你运行：打补丁，在作业之间清理又不删掉 `target/`，并在 actions/checkout 上设置 `clean: false`，因为它默认的 `git clean -ffdx` 会把 `target/` 和其他所有被忽略的文件一起删掉。

## Skipbox 替你保留 target/

每个套餐都附带你账号的专属机器，在作业之间一直保留。从 2026年11月13日起，它会保留你的检出目录（连同文件的时间戳）以及 Cargo 的 `target/`：

- actions/checkout 的清理照常运行，只是不会动 Cargo 的 `target/` 目录。
- rust-cache 留在你的工作流中。它的恢复步骤不再用缓存里较旧的产物覆盖磁盘上较新的产物。
- rust-cache 的保存和恢复从 `target/` 和 `~/.cargo` 中删掉的东西，机器会在步骤结束后放回去。保存的缓存不变，从冷运行之后的那个作业起，没有变化的 crate 就不会编译。
- cross 创建的 `target/`（标记为 "created by cross"）也会保留。
- actions/checkout 每个作业都会重写 `.git/HEAD`。只要它指向的仍是同一个提交，这个文件就会恢复原来的时间戳，所以监视 `.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 |

分钟数不限。在 4 vCPU 上每月 2万分钟，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. 使用 GitHub 登录 Skipbox。
2. 安装 Skipbox GitHub 应用，并选择仓库。
3. 修改 `runs-on` 并推送。

## 安全

- 这台机器只属于你的账号。不会运行其他公司的作业。
- 每个作业结束后，运行器的凭据、进程和容器都会被清除，保留的检出目录中的 git 凭据、钩子和未跟踪文件也一样。开启“每个作业用新虚拟机”后，每个作业改在一台新机器上运行。
- 没有写入权限的人提交的代码（例如来自复刻的拉取请求）在一台新的一次性机器上运行，不带保留的 `target/`。

详情见[作业如何隔离](https://docs.skipbox.dev/zh-hans/isolation)。

## 用你的 Rust 作业试试

试用免费，为期 7 天 或 3,000 作业分钟，以先到者为准，无需绑卡。把你的 Rust 作业改为 `runs-on: skipbox`，运行两次，再把第二次运行的 `Compiling` 行和 GitHub 上的放在一起看。

## 常见问题

### Swatinem/rust-cache 会缓存我工作区里的 crate 吗？

不会，默认不会。它的 README 说，工作区 crate 本身不会被缓存；它的保存步骤在上传缓存之前，会从 target/ 中删掉它们的构建输出。它缓存的是 ~/.cargo 和你依赖的构建输出，并在作业剩下的部分设置 CARGO_INCREMENTAL=0。所以在一台新的 GitHub 虚拟机上，每次热运行都会重新编译你的工作区 crate，即使缓存完全命中也一样。在 GitHub 上 tauri 的 CI 中，每次热运行都有 32 行 Compiling。

### 应该设置 cache-workspace-crates: true 吗？

它也会把你的 crate 放进缓存（rust-cache v2.8.0 及以上），但缓存键来自你的工具链、环境以及 Cargo.lock 和 Cargo.toml，而不是你的源代码。键已经存在的运行会跳过保存，所以缓存里那份 crate 和上一次保存一样旧，每次提交都离你的代码更远。增量编译仍然是关的。看看一次热运行的日志：如果你的 crate 还显示 Compiling，它就没起作用。

### sccache 能解决 GitHub Actions 上 Rust CI 慢的问题吗？

对输入没有变化的库 crate 有帮助。sccache 无法缓存调用链接器的 crate（bin、dylib、cdylib 和 proc-macro crate），而且每次命中都要从它的缓存存储下载。在作业之间保留的 target/ 不需要下载：Cargo 认为没有变化的 crate 根本不会编译。

### 要在 Skipbox 上保留 target/，必须修改工作流吗？

不用。把 runs-on 改为 skipbox，rust-cache 和 actions/checkout 保持原样。你的专属机器在作业之间保留检出目录和 Cargo 的 target/，checkout 的清理不会动 target/ 目录。rust-cache 的保存步骤从 target/ 中删掉你的 crate 时，机器会把它们放回去，它的恢复步骤也不再用旧的产物覆盖新的。所以从第一次热运行起，没有变化的 crate 就不会编译。

### 试用要花多少钱？

不花钱。试用为期 7 天 或 3,000 作业分钟，以先到者为准，无需绑卡。把你的 Rust 作业改为 runs-on: skipbox，运行两次，再把第二次运行的 Compiling 行和构建步骤与 GitHub 上的比一比。

更新于 2026-11-16 · https://skipbox.dev/zh-hans/guides/rust-cache-slow-rust-ci
