# Por que o rust-cache não deixa o seu CI de Rust rápido (tauri: de 246 s para 53 s)

> O Swatinem/rust-cache faz cache das suas dependências, não dos crates do seu workspace, e desliga a compilação incremental. Então, na VM nova do GitHub, todo trabalho aquecido compila os seus próprios crates de novo. Um target/ mantido em uma máquina que fica resolve: o trabalho de CI do tauri foi de 246 s para 53 s no Skipbox, por $39 fixos por mês.

O Swatinem/rust-cache, o step de cache da maioria dos CIs de Rust, salva as suas dependências e deixa de fora, de propósito, os crates do seu workspace. Ele também define `CARGO_INCREMENTAL=0`. Nos executores do GitHub, cada trabalho começa em uma VM nova, então todo trabalho aquecido, mesmo com acerto completo de cache, compila os seus próprios crates de novo. Nenhuma configuração do rust-cache faz isso sumir. O que faz é um `target/` ainda lá desde o último trabalho: aí o Cargo pula todo crate que não mudou.

O Skipbox o guarda para você. O seu trabalho roda na máquina dedicada da sua conta, que guarda o checkout e o `target/` do Cargo entre os trabalhos. O trabalho de CI do tauri levou 246 s no GitHub e 53 s lá, sem compilar nenhum dos seus crates desde a primeira execução aquecida, sem nenhuma mudança no workflow além de `runs-on: skipbox`, por $39 fixos por mês.

- O trabalho de CI do tauri: 246 s no GitHub, 53 s no Skipbox (4,6× mais rápido). Todas as execuções são públicas
- Com o `target/` mantido, o Cargo não compilou nenhum dos crates do tauri: o tempo de build dele foi de 62 s para menos de 2 s
- 20.000 minutos por mês em 4 vCPU: $222 no GitHub, $39 no Skipbox

**GitHub Actions a preço fixo, minutos ilimitados** O Skipbox roda os seus trabalhos do GitHub Actions na sua própria máquina dedicada: $39 por mês, não importa quantos minutos você rode. As camadas Docker e o cache de dependências ficam entre os trabalhos, então o próximo trabalho começa na hora.

Um executor de 4 vCPU, 20.000 minutos por mês: GitHub $222 → Skipbox $39. Você economiza $183 todo mês.

A mudança é uma linha: `runs-on: skipbox`.

[Começar meu teste grátis de 7 dias](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-pt-br)

## O que o rust-cache guarda, e o que ele deixa de fora

Segundo o [README do rust-cache](https://github.com/Swatinem/rust-cache#cache-details) e o código dele:

- **Do que ele faz cache:** do `~/.cargo` (o registro, as dependências git, os binários instalados) e do `./target` com a saída de build das suas dependências.
- **O que ele deixa de fora:** os próprios crates do workspace não vão para o cache. Antes do salvamento, a limpeza dele apaga tudo o que não é dependência no `target/`, então os artefatos dos seus crates são removidos do próprio `target/`.
- **Compilação incremental:** o step de restauração exporta `CARGO_INCREMENTAL=0` para o resto do trabalho.
- **Quando ele salva:** só quando nenhum cache tem ainda a chave do trabalho. A chave vem da toolchain, do ambiente e do seu `Cargo.lock` e `Cargo.toml`. Os seus arquivos de código não fazem parte dela.

Em uma VM nova, isso se resume a uma coisa. Um trabalho aquecido restaura as suas dependências e depois compila os crates do seu workspace e tudo o que é construído sobre eles, inteiros, toda vez.

## O mecanismo, nos logs do tauri

O trabalho `test` do tauri roda cinco steps `cargo test` no Ubuntu, com rust-cache. Aqui estão as execuções aquecidas dele, cada uma com acerto completo de cache (`full match: true` no log):

| Execução aquecida | Linhas `Compiling` | Tempo de build do Cargo | Trabalho |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, VM nova](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, máquina dedicada, 1ª execução aquecida](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **cerca de 1,5 s** | **53 s** |
| [Skipbox, máquina dedicada, 2ª execução aquecida](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **cerca de 1,9 s** | **53 s** |

As 32 linhas são os crates do próprio tauri e dois plugins construídos sobre eles. As dependências nunca aparecem: elas vêm do cache. O tempo de build do Cargo é a soma dos tempos `Finished … in` dos cinco steps.

A VM nova tem as CPUs da máquina dedicada e o mesmo cache, e compilou os mesmos 32 crates que o GitHub: o `target/` dela só tinha o que o cache restaurou. Na máquina dedicada, a primeira execução aquecida já não mostra nenhuma linha `Compiling`. O Cargo só verificou que nada tinha mudado, e cada `Finished` levou 0,2-0,7 s.

A primeira execução aquecida da máquina dedicada compilava antes todos os 32 crates de novo ([um trabalho de 114 s](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), porque o salvamento do rust-cache depois da execução a frio os tinha apagado do `target/`. Desde 13 de novembro de 2026, as máquinas dedicadas desfazem o que a restauração e o salvamento do rust-cache apagam do disco, assim que o step termina. O cache que ele salva é o mesmo, e os seus crates ficam no `target/`.

## Tempos de trabalho: três projetos Rust, seis outros

Os próprios trabalhos de CI de projetos reais em um commit fixo, com os steps byte a byte; só o gatilho e o `runs-on` mudaram. Uma execução a frio, depois duas aquecidas, de cada lado:

- **GitHub:** `ubuntu-24.04`, o executor padrão de um repositório público: 4 vCPU, 16 GB.
- **Skipbox, VM nova:** uma VM nova por trabalho a partir da imagem de executor de produção, 4 vCPU e 8 GB, com os caches restaurados pelo cache do Skipbox.
- **Skipbox, máquina dedicada:** o mesmo tamanho nas mesmas CPUs do host, mantida entre os trabalhos, com o manter-e-apagar que as máquinas dedicadas rodam desde 13 de novembro de 2026: o checkout e o `target/` ficam, e o que o rust-cache apaga é colocado de volta.

As execuções do Skipbox foram em um host do Skipbox, em um projeto de laboratório separado das máquinas dos clientes. Os tempos vão do início ao fim de cada trabalho, segundo a API do GitHub. Cada valor é a mediana das duas execuções aquecidas. As execuções a frio da máquina dedicada levaram [285 s](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) no tauri, [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) no ripgrep e [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) no helix.

| Projeto | GitHub | Skipbox, VM nova | Skipbox, máquina dedicada | GitHub ÷ máquina dedicada |
|---|---|---|---|---|
| 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×** |

O ripgrep compila dentro da imagem Docker do cross. O cross cria o próprio `target/` e o marca com "created by cross". As máquinas dedicadas tomavam antes esse `target/` por algo que não era do Cargo e o apagavam depois de cada trabalho, então o Cargo compilava todos os crates de novo a cada execução (um trabalho de 108 s). Agora o `target/` do cross fica: as execuções aquecidas não mostram nenhuma linha `Compiling`, e cada `Finished` leva 0,04-0,05 s. O GitHub também baixa a imagem do cross a cada execução (30 s na segunda execução aquecida); a máquina dedicada a guarda no disco.

O helix também fica 1,5× mais rápido. Dos crates dele, só o helix-term (e o xtask, que depende dele) compila de novo, porque o build script do helix-term roda em todo trabalho: 16 s no perfil `test` e 61 s no perfil `integration`. Nenhum outro crate compila. A maior parte do trabalho do helix é teste: só a suíte de testes de integração dele roda por 112 s. O step de preparação dele, toolchain e restauração de cache, levou 9-10 s contra 41-46 s no GitHub.

As outras linguagens:

| Projeto | Linguagem | GitHub | Skipbox, máquina dedicada |
|---|---|---|---|
| [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 |

O astro é a mesma história do `target/`, com o Turborepo: a máquina dedicada guarda o cache do turbo (turbo 2), então as execuções aquecidas dele reaproveitam do cache todas as 40 tarefas de build e a tarefa de teste em vez de rodá-las ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

O `ubuntu-latest` de um repositório privado tem 2 CPUs e 8 GB: metade dos núcleos das execuções do GitHub acima.

## Confira o seu próprio CI

1. Abra uma execução aquecida do seu trabalho de Rust, uma cujo step do rust-cache registre `full match: true`.
2. Nos steps de build e de teste, conte as linhas `Compiling`. As dependências vindas do cache não mostram nenhuma. Cada crate do seu workspace mostra uma, e também cada crate construído sobre eles.
3. Some os tempos `Finished … in` dos steps. Isso é quanto os seus próprios crates custam a cada execução, e o que um `target/` mantido economiza quando eles não mudaram.

## O que dá para fazer nos executores do GitHub

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 em diante). Os seus crates vão para o cache também. Mas uma execução cuja chave existe pula o salvamento, e a chave não muda com o seu código, então os crates em cache são tão velhos quanto o último salvamento. A compilação incremental continua desligada, e o cache cresce dentro dos 10 GB por repositório do GitHub.
- **sccache.** Ele faz cache de cada compilação pelas entradas dela, então um crate de biblioteca inalterado volta do armazenamento. Os crates que chamam o linker não podem ir para o cache: binários, crates `dylib`, `cdylib` e proc-macro compilam toda vez, e cada acerto é um download.
- **Um executor auto-hospedado que guarda o `target/`.** Você mantém a máquina: aplica os patches, a limpa entre os trabalhos sem apagar o `target/` e define `clean: false` no actions/checkout, cujo `git clean -ffdx` padrão apaga o `target/` junto com todos os outros arquivos ignorados.

## O Skipbox guarda o target/ para você

Cada plano vem com a máquina dedicada da sua conta, mantida entre os trabalhos. Desde 13 de novembro de 2026, ela guarda o seu checkout, com os horários dos arquivos, e o `target/` do Cargo:

- A limpeza do actions/checkout roda como sempre, só que não mexe nos diretórios `target/` do Cargo.
- O rust-cache continua no seu workflow. A restauração dele não grava mais os artefatos antigos do cache por cima dos mais novos no disco.
- O que o salvamento e a restauração do rust-cache apagam do `target/` e do `~/.cargo`, a máquina coloca de volta assim que o step termina. O cache salvo é o mesmo, e a partir do trabalho seguinte à execução a frio, os crates que não mudaram não são compilados.
- O `target/` que o cross cria (marcado com "created by cross") também fica.
- O actions/checkout reescreve o `.git/HEAD` a cada trabalho. Enquanto ele ainda aponta para o mesmo commit, o arquivo recebe de volta o horário antigo, então um build script que observa o `.git/HEAD` (o vergen faz isso) não roda de novo só por isso.

A máquina guarda também as imagens Docker, os caches de pacotes e as ferramentas instaladas, então o resto do trabalho acelera junto. Um trabalho escolhe o tamanho pelo rótulo:

| Rótulo | Máquina | Plano |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 por mês |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 por mês |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 por mês |

Os minutos são ilimitados. Com 20.000 minutos por mês em 4 vCPU, o GitHub cobra $222; o Skipbox S custa $39, $183 a menos.

## Mudar é uma linha

```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. Entre no Skipbox com o GitHub.
2. Instale o app do Skipbox no GitHub e escolha os repositórios.
3. Troque o `runs-on` e faça push.

## Segurança

- A máquina é só da sua conta. Nenhum trabalho de outra empresa roda nela.
- Depois de cada trabalho, as credenciais, os processos e os contêineres do executor são apagados, e também as credenciais do git, os hooks e os arquivos não rastreados no checkout mantido. Limpar a cada trabalho dá, em vez disso, uma máquina nova a cada trabalho.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma máquina nova, descartável, sem `target/` mantido.

Os detalhes estão em [como os trabalhos são isolados](https://docs.skipbox.dev/pt-br/isolation).

## Teste no seu trabalho de Rust

O teste é grátis por 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, e não pede cartão. Mova o seu trabalho de Rust para `runs-on: skipbox`, rode-o duas vezes e coloque as linhas `Compiling` da segunda execução ao lado das do GitHub.

## Perguntas frequentes

### O Swatinem/rust-cache faz cache dos crates do meu workspace?

Não, por padrão não. O README dele diz que os próprios crates do workspace não vão para o cache, e o step de salvamento dele apaga a saída de build deles do target/ antes de enviar o cache. Ele faz cache do ~/.cargo e da saída de build das suas dependências, e define CARGO_INCREMENTAL=0 para o resto do trabalho. Então, em uma VM nova do GitHub, toda execução aquecida compila os crates do seu workspace de novo, mesmo com um acerto completo de cache. No CI do tauri no GitHub, isso deu 32 linhas Compiling em cada execução aquecida.

### Devo definir cache-workspace-crates: true?

Isso coloca os seus crates no cache também (rust-cache v2.8.0 em diante), mas a chave do cache vem da sua toolchain, do seu ambiente e do seu Cargo.lock e Cargo.toml, não do seu código. Uma execução cuja chave já existe pula o salvamento, então a cópia dos seus crates em cache é tão velha quanto o último salvamento e se afasta do seu código a cada commit. A compilação incremental continua desligada. Confira o log de uma execução aquecida: se os seus crates ainda mostram Compiling, não está ajudando.

### O sccache resolve um CI de Rust lento no GitHub Actions?

Ele ajuda com crates de biblioteca cujas entradas não mudaram. O sccache não consegue fazer cache de crates que chamam o linker (crates bin, dylib, cdylib e proc-macro), e cada acerto é um download do armazenamento de cache dele. Um target/ mantido entre os trabalhos não precisa de download: um crate que o Cargo vê como inalterado nem é compilado.

### Preciso mudar o meu workflow para manter o target/ no Skipbox?

Não. Troque o runs-on para skipbox e deixe o rust-cache e o actions/checkout como estão. A sua máquina dedicada guarda o checkout e o target/ do Cargo entre os trabalhos, e a limpeza do checkout não mexe nos diretórios target/. Quando o salvamento do rust-cache apaga os seus crates do target/, a máquina os coloca de volta, e a restauração dele não grava mais artefatos antigos por cima dos novos. Então, desde a primeira execução aquecida, os crates que não mudaram não são compilados.

### Quanto custa testar?

Nada. O teste dura 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão. Mova o seu trabalho de Rust para runs-on: skipbox, rode-o duas vezes e compare as linhas Compiling e os steps de build da segunda execução com os do GitHub.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/rust-cache-slow-rust-ci
