# Acelere um monorepo pnpm e Turborepo no GitHub Actions (astro: de 528 s para 30 s)

> Em um monorepo pnpm e Turborepo no GitHub Actions, a maior parte do tempo é o pnpm install em uma VM nova e o turbo rodando tarefas cujos resultados não estão nela. Rode só os pacotes afetados, dê um cache ao turbo e mantenha o store do pnpm. Ou rode em uma máquina que guarda os dois: o CI do astro foi de 528 s no GitHub para 30 s no Skipbox, por $39 fixos por mês.

Em um monorepo pnpm e Turborepo no GitHub Actions, a maior parte de um trabalho lento são dois steps: o `pnpm install` em uma VM nova, e o `turbo run build test` rodando tarefas cujos resultados a VM não tem. Resolva nesta ordem. Rode só os pacotes que uma mudança toca (`turbo run build --affected`, com um checkout que tenha o histórico). Dê ao turbo um cache que dure mais que o trabalho, já que os resultados dele ficam em `.turbo/cache` em uma máquina que o GitHub apaga depois de cada trabalho: Remote Caching, ou o `.turbo` restaurado com `actions/cache`. E mantenha o store do pnpm. Nos executores do GitHub, cada um desses caches é um download a cada trabalho. Em uma máquina que guarda o disco, eles simplesmente estão lá: o trabalho de CI do astro levou 528 s no GitHub e 30 s em uma máquina dedicada do Skipbox, que reaproveitou todas as 40 tarefas de build do cache mantido do turbo.

O Skipbox roda os seus trabalhos na máquina dedicada da sua conta, que guarda o store do pnpm, as ferramentas e o `.turbo` do checkout entre os trabalhos, sem cache remoto e sem chaves de cache. Troque uma linha, `runs-on: skipbox`, por $39 fixos por mês com minutos ilimitados.

- O CI do astro: 528 s no GitHub, 30 s no Skipbox, com o turbo reaproveitando 40 tarefas de build e a tarefa de teste
- O store do pnpm e o `.turbo` do turbo ficam na sua máquina: nenhum cache remoto para configurar, nenhum arquivo para baixar
- 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-pnpm-turborepo-monorepo-github-actions-pt-br)

## Onde um trabalho de monorepo gasta o tempo

| Step | Em uma VM nova do GitHub |
|---|---|
| Checkout | Um clone raso por padrão; o `--affected` precisa do histórico, então um completo |
| Configurar o Node e o pnpm | Baixados, a menos que o cache de ferramentas tenha a versão |
| `pnpm install` | O store é restaurado do arquivo de cache (ou baixado do registro), e depois o `node_modules` é ligado para cada pacote |
| `turbo run build` | Todas as tarefas rodam, a menos que o `.turbo/cache` tenha sido restaurado ou um cache remoto responda |
| `turbo run test` | O mesmo, em 2 CPUs no `ubuntu-latest` de um repositório privado |

## 1. Rode só o que mudou

Segundo o [guia de CI do Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci): `turbo run build --affected` roda tarefas só nos pacotes alterados em relação ao branch base. No GitHub Actions, ele lê o `GITHUB_BASE_REF` em pull requests e o `GITHUB_EVENT_PATH` em pushes. Com um clone raso, todos os pacotes contam como alterados, então faça checkout do histórico:

```yaml
- uses: actions/checkout@v4
  with:
    fetch-depth: 0
    filter: blob:none
```

O `turbo query affected --packages web` diz a um trabalho se ele deve rodar, então o trabalho de um app não tocado pode pular o install.

## 2. Dê ao turbo um cache que dure mais que o trabalho

O Turborepo guarda os resultados das tarefas em `.turbo/cache` [na máquina](https://turborepo.dev/docs/crafting-your-repository/caching). A máquina de um trabalho hospedado pelo GitHub é excluída quando ele termina, então no CI esse cache começa vazio toda vez. Duas saídas, segundo o [guia de GitHub Actions do Turborepo](https://turborepo.dev/docs/guides/ci-vendors/github-actions):

- **Remote Caching.** Defina `TURBO_TOKEN` e `TURBO_TEAM` (o Remote Cache da Vercel, ou um servidor auto-hospedado). Cada acerto é um download dele.
- **`actions/cache` no `.turbo`.** Use a chave `${{ runner.os }}-turbo-${{ github.sha }}` com `restore-keys: ${{ runner.os }}-turbo-`. Ele salva uma entrada nova a cada execução, dentro dos 10 GB por repositório do GitHub junto com tudo o mais que o repositório coloca em cache.

## 3. Mantenha o store do pnpm

O `actions/setup-node` com `cache: pnpm`, ou o `actions/cache` no `pnpm store path`, restaura o store com chave no `pnpm-lock.yaml`. Ele não restaura o `node_modules`, então o pnpm ainda liga cada pacote. A [documentação de CI do pnpm](https://pnpm.io/continuous-integration) diz com todas as letras que fazer cache do store não garante uma instalação mais rápida. No CI, o pnpm passa sozinho para `--frozen-lockfile`.

## 4. Use os núcleos

O turbo roda tarefas independentes em paralelo e cada ferramenta de build ou de teste inicia os próprios workers, então um monorepo usa todos os núcleos que receber. O `ubuntu-latest` de um repositório privado tem 2.

## Quanto cada solução custa nos executores do GitHub

- **O Remote Caching** é mais um serviço e mais um token, e cada acerto de cache passa pela rede.
- **O `actions/cache` para o `.turbo`** grava uma entrada a cada execução e disputa os mesmos 10 GB com o store do pnpm, as camadas do Docker e os caches de todos os branches; as entradas sem uso há 7 dias somem.
- **Um executor maior** é um executor maior no GitHub Team ou no Enterprise Cloud, cobrado por minuto.

## Quando a solução é uma máquina que guarda o disco

O próprio CI do astro, com o workflow sem mudanças, das [nossas execuções de projetos reais](https://skipbox.dev/pt-br/guides/rust-cache-slow-rust-ci):

| | GitHub (repositório público, 4 vCPU, 16 GB) | Máquina dedicada do Skipbox (4 vCPU) |
|---|---|---|
| Trabalho | 528 s | **30 s** ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)) |
| Tarefas de build | 40 rodadas | 40 reaproveitadas do cache do turbo |
| Tarefa de teste | rodada | reaproveitada do cache do turbo |

A máquina dedicada guardou o `.turbo` do checkout e o store do pnpm do último trabalho, então o turbo achou o resultado de cada tarefa sem nada para baixar. O turbo só reaproveita uma tarefa quando as entradas dela têm o mesmo hash, então um commit real roda de novo os pacotes que ele toca e reaproveita o resto.

## O Skipbox guarda o estado do monorepo

Cada plano vem com a máquina dedicada da sua conta, mantida entre os trabalhos:

- **O store do pnpm fica** em `~/.local/share/pnpm/store`, com o cache do npm e o `~/.cache` de cada ferramenta. O `pnpm install` liga a partir do disco em vez de baixar.
- **O cache do turbo fica.** O `.turbo` de nível superior do checkout é mantido entre os trabalhos quando o `turbo.json` é do turbo 2: uma chave `tasks`, sem `pipeline` e sem `"envMode": "loose"`. Sem `TURBO_TOKEN`, sem step de cache.
- **O `node_modules` é apagado depois de cada trabalho**, então uma matriz de versões do Node que divide um checkout nunca carrega um addon nativo compilado para outro Node.
- **As ferramentas ficam:** as versões do Node que o `setup-node` instalou, o próprio pnpm, as imagens e camadas do Docker.

Pelo menos 7× o espaço de cache do GitHub no S. 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:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          filter: blob:none
      - uses: pnpm/action-setup@v3
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install
      - run: pnpm turbo run build test --affected
```

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.

Deixe os steps de cache como estão; o que eles salvam fica ao lado da máquina.

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

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 de build para `runs-on: skipbox`, rode-o duas vezes e coloque as linhas de install e de turbo da segunda execução (`cached` contra `executing`) ao lado das do GitHub.

## Perguntas frequentes

### Como acelerar um monorepo pnpm/Turborepo grande no GitHub Actions?

Três coisas, nesta ordem. Rode só o que mudou: turbo run build --affected, com um checkout que tenha o histórico (fetch-depth: 0 e filter: blob:none). Dê ao turbo um cache que sobreviva ao trabalho: o Remote Cache do Turborepo, ou o .turbo restaurado com actions/cache. E mantenha o store do pnpm: o cache: pnpm do setup-node ou um actions/cache no caminho do store. Nas VMs novas do GitHub, cada um deles é um download a cada trabalho; em uma máquina que guarda o disco, eles já estão lá. O CI do astro levou 528 s no GitHub e 30 s em uma máquina dedicada do Skipbox que guarda o cache do turbo e o store do pnpm.

### Por que o pnpm install é lento no GitHub Actions mesmo com o store em cache?

Porque um store restaurado ainda é um arquivo baixado e descompactado em uma VM nova, e o pnpm depois liga o node_modules de cada pacote do workspace. A própria documentação de CI do pnpm diz que fazer cache do store não garante uma instalação mais rápida. Um store que já está no disco da máquina pula o download; só resta a ligação.

### O cache do Turborepo funciona no GitHub Actions?

Só se o cache durar mais que o trabalho. O Turborepo guarda os resultados das tarefas em .turbo/cache na máquina, e a máquina de um trabalho hospedado pelo GitHub desaparece quando ele termina. Então o CI precisa do Remote Caching (TURBO_TOKEN e TURBO_TEAM, o da Vercel ou um auto-hospedado) ou de um step de actions/cache para o .turbo. Em uma máquina dedicada do Skipbox, o .turbo do checkout fica entre os trabalhos em projetos turbo 2, então o turbo reaproveita as tarefas sem mudanças sem nenhum cache remoto.

### O turbo --affected funciona no GitHub Actions?

Sim. O Turborepo lê o GITHUB_BASE_REF em pull requests, e o GITHUB_EVENT_PATH em pushes, para achar a base de comparação. Ele precisa do histórico: com um clone raso, todos os pacotes contam como alterados. Defina fetch-depth: 0 e filter: blob:none no actions/checkout.

### O que o Skipbox guarda de um monorepo Turborepo?

O store do pnpm, os caches do npm e de cada ferramenta, as ferramentas que o setup-node instala, as camadas do Docker e o checkout com o .turbo de nível superior quando o turbo.json é do turbo 2 (uma chave tasks, sem pipeline, sem envMode loose). O node_modules é apagado depois de cada trabalho, então o install roda, a partir do store no disco. O turbo só reaproveita uma tarefa quando as entradas dela têm o mesmo hash, então um commit roda de novo o que ele toca.

### Quanto custa testar?

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

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/pnpm-turborepo-monorepo-github-actions
