Skipbox

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

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.

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:

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 com cancel-in-progress a para. Restrinja-o aos pull requests para um push no branch padrão nunca cancelar um deploy:
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).
  • 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).

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 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 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: 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:

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

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.

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:

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:

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

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.

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 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