# Executores do GitHub Actions que guardam o seu cache entre os trabalhos

> A maioria dos executores do GitHub Actions, inclusive os do próprio GitHub, começa cada trabalho em uma máquina nova e leva o cache adiante como um arquivo ou um disco cobrado por GB. O Skipbox mantém uma máquina para a sua conta, então as camadas Docker e os caches de pacotes já estão no disco, por $39 fixos por mês.

Quase todo executor do GitHub Actions começa cada trabalho em uma máquina nova. O GitHub, o RunsOn, o Blacksmith, o Depot, o WarpBuild e o Ubicloud levam o seu cache adiante como um arquivo que cada trabalho baixa; o Blacksmith, o RunsOn, o Namespace e o WarpBuild também podem restaurar um disco ou snapshot salvo, cobrado por GB.

O Skipbox, em vez disso, mantém uma máquina para a sua conta. As camadas Docker, os caches de pacotes e a sua saída de build já estão no disco dela quando o próximo trabalho começa, por $39 fixos por mês com minutos ilimitados e sem cobrança de armazenamento.

- A sua máquina dedicada: as imagens e camadas Docker, os caches do npm, do pip e do Gradle e as ferramentas das actions de setup ficam no disco entre os trabalhos
- 7× o espaço do cache padrão de 10 GB do GitHub, incluído nos $39 por mês
- Mova um trabalho trocando uma linha: `runs-on: 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=compare-github-actions-runners-persistent-cache-pt-br)

## Dois jeitos de um executor guardar um cache, e o que pula os dois

**Um arquivo.** No fim de um trabalho, o `actions/cache` empacota arquivos em um arquivo compactado e o envia; o próximo trabalho, em uma máquina nova, o baixa e descompacta. Esse é o cache do GitHub, e os serviços de cache do RunsOn, do Blacksmith, do Depot, do WarpBuild e do Ubicloud funcionam do mesmo jeito por trás da mesma action, com mais espaço ou um armazenamento mais rápido. Um acerto ainda custa um download, e o cache guarda só os caminhos e as chaves que você escreveu.

**Um disco copiado para a próxima máquina.** Os sticky disks do Blacksmith e do RunsOn, os cache volumes do Namespace e os snapshot runners do WarpBuild salvam um disco depois de um trabalho e anexam uma cópia dele ao próximo. Nenhum arquivo para descompactar, mas você dá nome ao disco, define o tamanho e paga por GB armazenado.

**Uma máquina que fica.** No Skipbox, a máquina da sua conta é aquela em que o próximo trabalho roda. Tudo o que um trabalho deixa no disco está lá: as imagens e o cache de build do Docker, `~/.npm`, `~/.cache/pip`, `~/.gradle`, as ferramentas das actions `setup-*`, e a partir de 13 de novembro de 2026 o seu checkout e o `target/` do Cargo. Nada é enviado ou baixado, e nada é cobrado por GB.

## O cache de cada executor, lado a lado

| Executor | Máquina nova a cada trabalho | O que passa adiante | Limite e expiração | Preço do armazenamento |
|---|---|---|---|---|
| Hospedado pelo GitHub | Sim | Arquivos do `actions/cache` | 10 GB por repositório por padrão; entradas sem uso há 7 dias apagadas | Incluído até 10 GB; mais nos planos pagos, pago conforme o uso (50 GB cheios: US$ 2,80 por mês) |
| RunsOn | Sim, uma instância EC2 destruída depois do trabalho | Magic Cache em um bucket S3 na sua conta AWS; sticky disks como snapshots EBS | Sem limite de tamanho; as entradas expiram depois de 10 dias por padrão; sticky disks parados há 10 dias removidos | S3 e EBS na sua fatura da AWS (EBS gp3 a US$ 0,08 por GiB-mês em US East) |
| Blacksmith | Sim | O próprio backend de `actions/cache`; sticky disks; camadas Docker em sticky disks | 25 GB grátis por repositório, o usado há mais tempo sai depois de 7 dias; sticky disks removidos depois de 7 dias parados | Cache grátis; sticky disks e camadas Docker a US$ 0,50 por GB por mês |
| Depot | Sim, instâncias EC2 nunca reutilizadas | Depot Cache por trás do `actions/cache`; um builder BuildKit separado para Docker | De 25 GB a sem limite, por organização; 14 dias por padrão | 25 GB (plano de US$ 20) ou 250 GB (plano de US$ 200) incluídos, depois US$ 0,20 por GB por mês |
| WarpBuild | Sim, VMs efêmeras | `WarpBuilds/cache` no lugar do `actions/cache`; snapshot runners; builders Docker | Ilimitado; expira 7 dias depois do último uso | US$ 0,20 por GB-mês mais US$ 0,0001 por operação; snapshots a US$ 0,025 por hora cada e US$ 0,04 por restauração |
| Namespace | Cada executor recebe a própria cópia do volume | Cache volumes em NVMe, anexados ao executor | A partir de 20 GB, crescendo com o uso; removidos depois de um período sem uso | US$ 0,0048 por GB-dia além da franquia do plano, sobre o tamanho pedido |
| Ubicloud | Sim | O cache dele por trás do `actions/cache` e do `type=gha` do Docker | 30 GB grátis por repositório; sem uso há 7 dias removido | US$ 0,04 por GB por mês, em blocos de 25 GB |
| **Skipbox** | **Não: uma máquina mantida para a sua conta** | **Tudo no disco dela, e o `actions/cache` servido do mesmo disco** | **7× o espaço padrão do GitHub no plano S, mais no M e no L** | **Incluído no preço fixo do plano** |

## Por que uma máquina mantida é mais rápida que um cache restaurado

- **Nenhum step de restauração.** Um arquivo de `node_modules` de 3 GB é um download e uma descompactação em qualquer outro executor. No Skipbox, é um diretório que já está lá.
- **O Docker simplesmente funciona.** O `docker build` e o `docker compose pull` acertam o cache do próprio daemon. Nenhum `cache-from`, `cache-to`, registro ou builder para configurar, e nenhuma camada removida porque o cache do repositório encheu.
- **Nada para colocar em chave.** Os builds incrementais (o `target/` do Cargo, o cache de build do Gradle, o `.next/cache` do Next.js) ficam onde a ferramenta os espera, então uma chave de cache que erra não significa mais um build a frio.
- **Nenhum limite para ajustar.** O disco é seu: 80 GB no S, 160 GB no M e 320 GB no L. Quando ele enche, os caches usados há mais tempo saem primeiro.

As nossas medições em repositórios reais estão em [Benchmarks](https://docs.skipbox.dev/pt-br/benchmarks).

## Quanto custa guardar um cache

Nos executores por minuto, o cache é uma segunda fatura além dos minutos, e as duas crescem com o seu CI. No Skipbox, as duas estão em um preço só:

| Plano | Máquina | Disco | Por mês |
|---|---|---|---|
| S | 4 vCPU, 16 GB | 80 GB | $39 |
| M | 8 vCPU, 16 GB | 160 GB | $79 |
| L | 16 vCPU, 32 GB | 320 GB | $149 |

Minutos ilimitados, sem cobrança por uso nem por armazenamento. Para comparar, 20.000 minutos por mês no executor de 4 núcleos do GitHub custam $222 antes de qualquer armazenamento de cache.

## Uma máquina que fica é segura?

- A sua máquina roda só os trabalhos da sua conta.
- As credenciais do executor, as credenciais do git no checkout e os arquivos de credenciais comuns são apagados depois de cada trabalho.
- O código de pessoas sem acesso de escrita, como pull requests de forks, roda em uma máquina nova, de uso único, que pode ler os seus caches mas não alterá-los.
- Ative Limpar a cada trabalho e cada trabalho recebe uma máquina nova.

Mais em [isolamento dos trabalhos](https://docs.skipbox.dev/pt-br/isolation).

## Mudar é uma linha

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest or another runner's label
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t app .
```

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. A primeira execução enche a máquina; a segunda começa aquecida.

Os seus steps de `actions/cache` podem ficar: eles são servidos da mesma máquina.

## Teste no seu trabalho mais lento

Você pode testar primeiro nos seus próprios trabalhos: grátis por 7 dias ou 3.000 minutos, sem cartão.

Mova o trabalho que passa mais tempo restaurando caches ou refazendo camadas Docker, rode-o duas vezes e compare a segunda execução com o que ele leva hoje.

## Perguntas frequentes

### Existe um executor do GitHub Actions em que os caches persistem entre os trabalhos?

Sim. O Skipbox mantém uma máquina para a sua conta, então as imagens e camadas Docker, os caches de pacotes, as ferramentas instaladas pelas actions de setup e o checkout ficam no disco dela para o próximo trabalho, sem chaves para gerenciar e sem cobrança por GB, a partir de $39 por mês com minutos ilimitados. O RunsOn, o Blacksmith, o WarpBuild e o Namespace restauram um disco ou snapshot salvo em cada máquina nova, cobrado por GB.

### Por que o meu cache do GitHub Actions não sobrevive entre os trabalhos?

Porque cada trabalho em um executor hospedado pelo GitHub recebe uma VM nova. O actions/cache envia um arquivo no fim de um trabalho e o próximo trabalho o baixa, dentro de 10 GB por repositório por padrão, e as entradas sem uso há 7 dias são apagadas. Mesmo um acerto de cache é um download e uma descompactação.

### Como manter um cache de build aquecido sem manter os meus próprios executores auto-hospedados?

Use um serviço de executores cuja máquina ou disco passe adiante. O Skipbox é o mais simples: instale o app dele no GitHub, troque o runs-on para skipbox, e a máquina da sua conta guarda as camadas Docker e os caches de pacotes entre os trabalhos. O Skipbox provisiona, aplica patches e limpa a máquina.

### Qual executor guarda o cache de camadas Docker entre os trabalhos do GitHub Actions?

O Skipbox guarda a imagem e o cache de build do próprio Docker na sua máquina, então o docker build e o docker compose reutilizam as camadas sem nenhuma configuração de cache-to ou cache-from. O Blacksmith guarda as camadas em sticky disks a US$ 0,50 por GB por mês; o RunsOn usa um bucket S3, um registro ECR ou um sticky disk na sua conta AWS; o WarpBuild vende builders Docker.

### Um executor persistente significa que os trabalhos dividem estado com outros clientes?

Não no Skipbox. A sua máquina roda só os trabalhos da sua conta, as credenciais do executor são apagadas depois de cada trabalho, e os pull requests de pessoas sem acesso de escrita rodam em uma máquina nova, de uso único, que pode ler os seus caches mas não alterá-los.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/compare/github-actions-runners-persistent-cache
