# Como acelerar o GitHub Actions: corte um pipeline de 25 minutos, alavanca por alavanca

> Um pipeline lento do GitHub Actions é trabalhos esperando uns pelos outros, trabalho que não precisava rodar, preparação repetida em uma VM em branco e steps limitados pela CPU em 2 núcleos. Resolva nessa ordem. Os dois últimos são a máquina: o Skipbox guarda os seus caches na sua máquina dedicada entre os trabalhos, com até 16 vCPU, por $39 fixos por mês com minutos ilimitados.

Um pipeline de 25 minutos no GitHub Actions costuma ser quatro atrasos empilhados: trabalhos esperando uns pelos outros, trabalho que não precisava rodar, preparação que uma VM em branco repete a cada trabalho e steps limitados pela CPU espremidos em 2 núcleos (o `ubuntu-latest` de um repositório privado tem 2 CPUs e 8 GB). Ataque-os nesta ordem. Primeiro, meça o caminho crítico, com o tempo de fila à parte. Depois pule o que não precisava rodar, rode os trabalhos independentes ao mesmo tempo, pare de reconstruir o estado, dê mais núcleos aos steps pesados e divida em shards o que ainda for longo. Os três primeiros são correções no workflow que não custam nada. O resto é a máquina: um executor que guarda os caches entre os trabalhos e tem mais núcleos.

O Skipbox é esse executor. Os seus trabalhos rodam na máquina dedicada da sua conta, que guarda as camadas Docker, os caches de pacotes, as ferramentas e a saída de build entre os trabalhos, com 4 a 16 vCPU, por $39 fixos por mês com minutos ilimitados. No CI do astro, isso deu 528 s no GitHub e 30 s no Skipbox. Mudar é uma linha: `runs-on: skipbox`.

- As alavancas em ordem: medir, pular, rodar em paralelo, parar de reconstruir, acrescentar núcleos, dividir em shards
- A sua máquina dedicada guarda os caches e a saída de build entre os trabalhos: o CI do astro foi de 528 s para 30 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-speed-up-github-actions-pt-br)

## 1. Meça o caminho crítico

O tempo que a sua equipe espera é a cadeia de trabalhos que termina por último, não a soma de todos os trabalhos. Abra a execução de um pull request representativo: o grafo mostra quais trabalhos esperam por quais, e o log de cada trabalho mostra os tempos dos steps. Anote, para a cadeia mais lenta:

| Fase | O que verificar |
|---|---|
| Na fila | O trabalho esperou um executor? Um comando mais rápido não encurta uma fila |
| Set up job, checkout | Uma imagem de contêiner baixada, um clone completo onde um raso bastaria |
| Toolchain e instalação | O cache acertou, e o acerto economizou mais do que a restauração levou? |
| Build | A mesma saída é compilada em outro trabalho? |
| Testes | A CPU do executor fica ocupada o tempo todo, ou um worker faz tudo? |
| Uploads | Artefatos e salvamentos de cache depois que o trabalho útil terminou |

Compare uma execução aquecida com uma a frio. Um cache que erra metade das vezes parece bom na média.

## 2. Pule o que não precisava rodar

- **Cancele as execuções superadas.** Cada push depois do primeiro torna inútil a execução em andamento. Um [grupo de concorrência](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) com `cancel-in-progress` a para. Restrinja-o aos pull requests para um push no branch padrão nunca cancelar um deploy:

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
```

- **Rode só o que a mudança toca.** Os filtros `paths:` pulam um workflow em mudanças só de documentação; em um monorepo, o `turbo run test --affected` ou os comandos affected do Nx rodam só os pacotes que mudaram. Um filtro no gatilho faz uma verificação obrigatória nunca reportar, então filtre dentro do trabalho quando a verificação for obrigatória.

## 3. Rode os trabalhos independentes ao mesmo tempo

O GitHub roda os trabalhos em paralelo a menos que `needs:` os encadeie. Lint, checagem de tipos, testes unitários e o build raramente precisam uns dos outros: inicie-os juntos e deixe só o empacotamento ou o deploy esperar por todos. Se dois trabalhos compilam a mesma coisa, compile uma vez e passe-a com `actions/upload-artifact`, medindo o tempo do upload e do download.

## 4. Pare de reconstruir o mesmo estado

É para cá que vai a maior parte de um pipeline longo. Cada trabalho em um executor hospedado pelo GitHub começa em uma VM nova, então ele baixa a toolchain, instala as dependências, refaz as camadas Docker e compila do zero, toda vez.

- **Caches que acertam de verdade.** O `cache: npm` do `actions/setup-node` (e as formas para pnpm e yarn) salva os downloads do gerenciador de pacotes com chave no lockfile; ele não salva o `node_modules`, então a instalação ainda roda. O GitHub guarda 10 GB por repositório, descarta as entradas sem uso há 7 dias, e um acerto ainda é um download para a VM nova ([limite de tamanho do cache](https://skipbox.dev/pt-br/guides/github-actions-cache-size-limit)).
- **Caches de ferramentas.** O `eslint --cache`, o `tsc --incremental`, o diretório de cache do Jest e o `.turbo/cache` do turbo salvam o próprio trabalho, não os downloads. Em uma VM nova, eles estão vazios a menos que você os restaure também.
- **Camadas Docker.** O `docker build` em uma VM nova começa sem nenhuma camada; exportá-las com o `cache-to` do buildx e importá-las a cada execução é a solução paliativa ([cache de camadas Docker](https://skipbox.dev/pt-br/guides/docker-layer-cache-github-actions)).

Uma máquina que guarda o disco faz tudo isso sozinha: os caches, os caches de ferramentas, as camadas e a saída de build estão lá desde o último trabalho.

## 5. Dê mais núcleos aos steps pesados

Compiladores, bundlers e executores de testes iniciam um worker por núcleo, então em 2 CPUs eles rodam dois por vez. Confira o que o executor de testes realmente usa: o [Jest](https://jestjs.io/docs/cli#--maxworkersnumstring) usa por padrão os núcleos menos um (um worker em 2 CPUs), o pytest roda em série até o `-n auto`, e o [Playwright](https://playwright.dev/docs/ci#workers) usa por padrão metade dos núcleos, com a documentação dele recomendando um worker no CI. Mais núcleos só ajudam quando o executor de testes recebe a instrução de usá-los, e só em steps que mantêm a CPU ocupada; um download ou a subida de um banco de dados não acelera.

No GitHub, mais núcleos significa [executores maiores](https://docs.github.com/en/actions/concepts/runners/larger-runners): de 4 a 96 núcleos, só em organizações no GitHub Team ou no Enterprise Cloud, cobrados por minuto a uma tarifa maior por núcleo.

## 6. Divida em shards o que ainda for longo

Uma matriz de shards divide uma suíte longa entre trabalhos. Ela corta o tempo de relógio, não os minutos: cada shard faz checkout, instala e compila de novo, então quatro shards pagam a preparação quatro vezes. Equilibre os shards pelo tempo medido, não pelo número de arquivos, e pare de acrescentá-los quando a preparação for a maior parte de cada shard.

## Quanto custa continuar lento

Um pipeline de 15 minutos que roda 40 vezes por dia são 10 horas de espera espalhadas pela sua equipe, todo dia, antes de alguém contar as trocas de contexto. Na cobrança por minuto, os minutos de preparação são cobrados como os de teste:

| Minutos por mês (4 vCPU) | GitHub | Skipbox S | Você economiza por mês |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

Mais núcleos no GitHub custam mais por minuto, então a diferença aumenta com a máquina:

| 20.000 minutos por mês | GitHub | Skipbox | Você economiza por mês |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | **$343** |
| 16 vCPU | $822 | $149 (L) | **$673** |

Os valores do GitHub são depois do uso incluído no GitHub Team. Teste os seus próprios minutos na [calculadora da página inicial](https://skipbox.dev/?ref=g-speed-up-github-actions-pt-br#cost).

## Quando a solução é a máquina

Os próprios trabalhos de CI de projetos reais, com os steps sem mudanças, no executor de repositório público do GitHub (4 vCPU, 16 GB) e em uma máquina dedicada do Skipbox com as mesmas vCPU, das [nossas execuções dos workflows deles](https://skipbox.dev/pt-br/guides/rust-cache-slow-rust-ci):

| Projeto | GitHub | Skipbox, máquina dedicada | O que a máquina guardou |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | **30 s** | o cache do turbo: 40 tarefas de build reaproveitadas |
| tauri (Rust) | 246 s | **53 s** | o `target/` do Cargo: nenhum crate compilado de novo |
| ripgrep (Rust) | 200 s | **40 s** | o `target/` e a imagem Docker do cross |
| vite (Node.js) | 141 s | 100 s | os caches de pacotes; o resto são os testes dele rodando |

O `ubuntu-latest` de um repositório privado tem metade dos núcleos dessas execuções do GitHub.

## O que o Skipbox faz pelo seu pipeline

**Guarda a máquina.** Cada plano vem com a máquina dedicada da sua conta, mantida entre os trabalhos. As imagens, as camadas e o cache de build do Docker, os caches de pacotes, o cache de ferramentas e o seu checkout com o `target/` do Cargo e o cache do turbo ficam no disco dela: pelo menos 7× o espaço de cache do GitHub, sem chaves, sem expiração depois de 7 dias e sem regra de branch.

**Acrescenta núcleos a preço fixo.** 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, então shards, novas execuções e uma matriz maior não aumentam a fatura. Os trabalhos do Skipbox não usam minutos do GitHub, então um orçamento do GitHub nunca os para.

**Cuida de si mesmo.** O Skipbox provisiona a máquina, mantém a imagem atualizada, limpa tudo depois de cada trabalho e recria uma máquina que falha na verificação de integridade.

## Mudar é uma linha

```yaml
jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci && npm test
```

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.

Os seus steps e actions rodam como estão, em Ubuntu 24.04 com Docker, Node.js e Python.

## 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 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 VM nova que lê os seus caches mas não pode alterá-los.

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

## Teste no seu trabalho mais lento

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 trabalho do seu caminho crítico para `runs-on: skipbox`, rode-o duas vezes e leia os tempos dos steps da segunda execução ao lado dos do GitHub.

## Perguntas frequentes

### O nosso pipeline do GitHub Actions leva 25 minutos. Qual é o jeito mais rápido de deixá-lo mais rápido?

Siga a ordem. Leia o grafo e os tempos dos steps da execução para achar a cadeia de trabalhos que define o tempo, com o tempo de fila à parte. Cancele as execuções superadas e pule os trabalhos cujos arquivos não mudaram. Tire os needs: que só expressam hábito, para os trabalhos independentes rodarem ao mesmo tempo. Pare de reconstruir o estado a cada trabalho: caches que acertam de verdade, ou um executor que guarda o disco. Dê mais núcleos aos steps limitados pela CPU e deixe o executor de testes usá-los. Divida em shards só o que ainda for longo. No ubuntu-latest de um repositório privado (2 CPUs, 8 GB), os três últimos costumam ser a maior parte dos 25 minutos, e eles são da máquina: o Skipbox dá ao trabalho uma máquina dedicada, que guarda os caches entre os trabalhos, com 4 a 16 vCPU.

### Mudar para executores mais rápidos vale a pena em comparação com otimizar o workflow?

Faça primeiro as correções gratuitas no workflow: cancelar as execuções superadas, filtros de caminho e tirar os needs: desnecessários não custam nada e nenhum executor faz isso por você. Depois disso, veja para onde vai o tempo restante. A preparação que se repete a cada trabalho (toolchains, instalação de dependências, builds Docker) e os steps que mantêm todos os núcleos ocupados são problema da máquina, e um executor que guarda os caches e tem mais núcleos os elimina com uma mudança de uma linha no runs-on. Esperas de rede e steps sequenciais não ficam mais rápidos com uma máquina maior.

### Por que o GitHub Actions é mais lento que o meu notebook?

O seu notebook guarda os pacotes, as ferramentas, as camadas Docker e a saída de build no disco, e normalmente tem 8 núcleos ou mais. Um trabalho no ubuntu-latest de um repositório privado recebe 2 CPUs e 8 GB, em uma VM nova que não tem nada disso. O Skipbox funciona como o seu notebook: a máquina fica entre os trabalhos, com 4 vCPU ou mais.

### Dividir os testes em shards deixa o GitHub Actions mais rápido?

Encurta o tempo de relógio, não os minutos. Cada shard é um trabalho novo que faz checkout, instala e compila de novo, então quatro shards pagam a preparação quatro vezes, e a cobrança por minuto conta cada um. Divida em shards depois que a preparação estiver barata e os núcleos do executor estiverem em uso. No Skipbox, a preparação fica no disco e os minutos são ilimitados, então os shards não custam nada a mais.

### Como ter mais de 4 núcleos para um trabalho do GitHub Actions?

No GitHub, os executores maiores vão de 4 a 96 núcleos, só para organizações no GitHub Team ou no Enterprise Cloud, cobrados por minuto. No Skipbox, troque o runs-on para skipbox-8x16 para 8 vCPU ou skipbox-16x32 para 16 vCPU, a um preço mensal fixo, tanto em organizações quanto em contas pessoais.

### Quanto custa testar?

Nada. O teste dura 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão. Troque o runs-on do seu trabalho mais lento para skipbox, rode-o duas vezes e compare os tempos dos steps.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/speed-up-github-actions
