# Exit code 137 no GitHub Actions: falta de memória, e um executor de 16 GB ou 32 GB a preço fixo

> O exit code 137 significa que o trabalho ficou sem memória e o Linux o matou: o ubuntu-latest de um repositório privado tem 8 GB. O Skipbox roda o trabalho em máquinas de 16 GB ou 32 GB por $39 ou $149 fixos por mês com minutos ilimitados, trocando uma linha de runs-on.

O seu build morreu com `exit code 137` de novo. Alguém roda de novo, diminui os workers de teste, acrescenta swap, e o pipeline fica mais lento a cada vez. Enquanto isso, o executor que continua matando o build tem 8 GB de memória, e os maiores do GitHub cobram por minuto.

O Skipbox dá ao trabalho uma máquina com 16 GB ou 32 GB a um preço mensal fixo com minutos ilimitados. Troque uma linha, `runs-on: skipbox`, e o build tem 2 vezes a memória do `ubuntu-latest` por $39 por mês; `runs-on: skipbox-8x16` dobra os núcleos também.

- 16 GB por $39 por mês, 32 GB por $149, quantos minutos você rodar
- O dobro dos núcleos do executor maior do GitHub com a mesma memória: 8 vCPU com 16 GB
- 10.000 minutos por mês no executor de 16 GB do GitHub: $102. No Skipbox S: $39

**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-github-actions-exit-code-137-out-of-memory-pt-br)

## O que significa exit code 137

137 é 128 + 9: o processo foi morto com o sinal 9, SIGKILL, que ele não consegue capturar, então nunca imprimiu um erro. Em um executor hospedado pelo GitHub, esse sinal vem do out-of-memory killer do Linux, quando os processos do trabalho juntos usaram mais memória do que a máquina tem.

| O log mostra | O que aconteceu |
|---|---|
| `Process completed with exit code 137.` (muitas vezes depois de `Killed`) | O kernel matou um processo para liberar memória |
| `JavaScript heap out of memory` | O Node bateu no próprio limite de heap; a máquina ainda tinha memória |
| `The runner has received a shutdown signal.` | O executor inteiro ficou sem memória e parou de responder |

Em um repositório privado, o `ubuntu-latest` tem 8 GB, e o aplicativo do executor, o Docker e os seus contêineres de serviço pegam a parte deles antes do seu build. Um build de monorepo, um daemon do Gradle com workers separados, um build de release em Rust ou uma suíte Playwright com alguns navegadores abertos podem passar disso em um dia comum.

## Quanto custa ficar em 8 GB

Todas as soluções paliativas trocam velocidade por memória. Menos workers de teste, `CARGO_BUILD_JOBS=1`, um `-Xmx` menor, swap em disco: cada uma faz o build caber deixando-o mais lento, e a equipe espera esse build mais lento a cada push. Até o código crescer de novo e o 137 voltar.

A resposta do GitHub é um executor maior, cobrado por minuto e só para organizações no GitHub Team ou no Enterprise Cloud. Contra o Skipbox com a mesma memória:

| Minutos por mês | GitHub 4 núcleos, 16 GB | Skipbox S, 16 GB | GitHub 8 núcleos, 32 GB | Skipbox L, 32 GB |
|---|---|---|---|---|
| 10.000 | $102 | $39 | $202 | $149 |
| 20.000 | $222 | $39 | $422 | $149 |
| 30.000 | $342 | $39 | $642 | $149 |

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

A necessidade de memória só cresce. Os agentes de programação acrescentam código e dependências mais rápido do que as pessoas faziam, as suítes de teste aumentam, e uma atualização de toolchain pode dobrar o que o mesmo commit usa. Uma fatura por minuto de um executor maior cresce a cada push além disso.

## Resolver por conta própria

Se você ficar em 8 GB, o trabalho é este:

- Descobrir qual processo foi morto (`dmesg` em um step `if: failure()`) e ajustar o limite dele: `--max-old-space-size`, `-Xmx`, `org.gradle.workers.max`, `--maxWorkers`
- Limitar a memória de cada contêiner de serviço no `compose.yaml`
- Acrescentar um swapfile antes do step pesado, dimensionado para o disco de 14 GB do executor
- Dividir o trabalho para nenhum step sozinho precisar de tudo

Cada item deixa o build mais lento ou mais frágil, e nenhum deles sobrevive ao próximo surto de crescimento. Uma máquina maior acaba com isso.

## O que o Skipbox dá ao trabalho

**Memória a preço fixo.** Um trabalho pede 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 |

O plano S custa $39 por mês e o plano L $149, com minutos ilimitados. Volte os workers para onde estavam: o build ganha a memória e os núcleos.

**Um build mais rápido, além disso.** A máquina da sua conta fica entre os trabalhos, então as camadas Docker, os caches de pacotes e as ferramentas já estão no disco dela quando o próximo trabalho começa.

**Nenhum orçamento trava.** Os trabalhos do Skipbox não usam minutos do GitHub, então um orçamento do GitHub nunca os para, e nada é cobrado por minuto.

**Nenhuma máquina para gerenciar.** O Skipbox a provisiona, atualiza a imagem, limpa tudo depois de cada trabalho e recria uma máquina que falha na verificação de integridade.

## Mudar é uma linha

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build
```

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. O plano S ($39) tem 16 GB; escolha o L para 32 GB.

A máquina roda Ubuntu 24.04 com `sudo` sem senha, Docker, Node.js e Python, então os steps rodam como estão.

## 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. A partir de 13 de novembro de 2026, o seu checkout e a saída de build dele (o `target/` do Cargo) ficam em uma máquina que o Skipbox hospeda só para a sua conta, para os próximos trabalhos; Limpar a cada trabalho dá a cada trabalho uma máquina nova.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma máquina nova, descartável.

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

## Teste

O teste é grátis por 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão. Ele roda `runs-on: skipbox` com 4 vCPU e 16 GB, 2× a memória do `ubuntu-latest` de um repositório privado, então mova o trabalho que continua batendo no 137 e rode-o lá. Para mais núcleos com essa memória, escolha o plano M e troque o rótulo para `skipbox-8x16`; para mais memória, o plano L e `skipbox-16x32` (32 GB).

## Perguntas frequentes

### O que significa exit code 137 no GitHub Actions?

O processo foi morto com o sinal 9, SIGKILL (128 + 9 = 137). Em um executor hospedado pelo GitHub, isso quase sempre é o out-of-memory killer do Linux: o trabalho usou mais memória do que o executor tem. A solução que se sustenta é uma máquina com mais memória, como os executores de 16 GB ou 32 GB do Skipbox a um preço mensal fixo.

### Quanta memória tem um executor do GitHub Actions?

O ubuntu-latest tem 8 GB e 2 CPUs em um repositório privado. Os executores maiores do GitHub têm 16 GB com 4 núcleos e 32 GB com 8 núcleos, cobrados por minuto e só para organizações no GitHub Team ou no Enterprise Cloud. O Skipbox tem 16 GB no plano S ($39 por mês) e 32 GB no plano L, com minutos ilimitados.

### "JavaScript heap out of memory" é o mesmo que exit code 137?

Não. O erro de heap é o Node parando no próprio limite, que o --max-old-space-size aumenta. O exit code 137 é o kernel matando o processo porque a máquina inteira ficou sem memória, e aumentar o limite do Node piora isso. Quando o build realmente precisa da memória, rode-o em uma máquina maior: runs-on: skipbox dá a ele 16 GB.

### Por que o meu trabalho termina com "The runner has received a shutdown signal"?

Uma causa comum é o executor ficar tão sem memória que para de responder antes de uma mensagem de falta de memória chegar ao log. Trate como o exit code 137: o trabalho precisa de mais memória do que o executor tem.

### O teste grátis do Skipbox resolve um trabalho sem memória?

Ele dá ao trabalho 2× a memória. O teste roda runs-on: skipbox com 4 vCPU e 16 GB, contra os 8 GB do ubuntu-latest em um repositório privado, o mesmo que o executor maior de 4 núcleos do GitHub. Um trabalho que ainda fica sem memória precisa do plano L para runs-on: skipbox-16x32 (32 GB).

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/github-actions-exit-code-137-out-of-memory
