Skipbox

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, 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 que o rust-cache guarda, e o que ele deixa de fora

Segundo o README do rust-cache 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):

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), 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 no tauri, 161 s no ripgrep e 442 s no helix.

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:

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, 28 s).

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:

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

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.

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 19 de novembro de 2026

CI/CD mais rápido com um cache sempre aquecido

Seu executor aquecido a preço fixo

Nós hospedamos. Você muda uma linha. 1/12 do custo do GitHub com uso total. Preço fixo, então rode o dia todo. 7× o espaço de cache do GitHub.

  • Sem cartão
  • Entrar com o GitHub
  • Cancele quando quiser