Exit code 137 no GitHub Actions: falta de memória, e um executor de 16 GB ou 32 GB a preço fixo
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.
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.
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 (
dmesgem um stepif: 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
jobs:
build:
runs-on: skipbox # was ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: npm ci && npm run build
- Entre no Skipbox com o GitHub.
- Instale o app do Skipbox no GitHub e escolha os repositórios.
- Troque o
runs-one 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.
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 19 de novembro de 2026