GitHub Actions exit code 137: memoria esaurita, e un runner da 16 GB o 32 GB a prezzo fisso
La tua build è morta di nuovo con exit code 137. Qualcuno la riesegue, abbassa i worker dei test, aggiunge swap, e la pipeline diventa ogni volta più lenta. Intanto il runner che continua a terminarla ha 8 GB di memoria, e quelli più grandi di GitHub fatturano al minuto.
Skipbox dà al job una macchina da 16 GB o 32 GB a un prezzo mensile fisso con minuti illimitati. Cambi una riga, runs-on: skipbox, e la build ha 2× la memoria di ubuntu-latest per $39 al mese; runs-on: skipbox-8x16 raddoppia anche i core.
Cosa vuol dire exit code 137
137 è 128 + 9: il processo è stato terminato con il segnale 9, SIGKILL, che non si può intercettare, quindi non ha mai stampato un errore. Su un runner ospitato da GitHub quel segnale arriva dall'out-of-memory killer di Linux, quando i processi del job insieme hanno usato più memoria di quella della macchina.
| Il log mostra | Cosa è successo |
|---|---|
Process completed with exit code 137. (spesso dopo Killed) | Il kernel ha terminato un processo per liberare memoria |
JavaScript heap out of memory | Node è arrivato al suo limite di heap; la macchina aveva ancora memoria |
The runner has received a shutdown signal. | Tutto il runner ha finito la memoria e ha smesso di rispondere |
Su un repository privato, ubuntu-latest ha 8 GB, e l'applicazione del runner, Docker e i container dei tuoi servizi prendono la loro parte prima della tua build. La build di un monorepo, un daemon Gradle con worker separati, una build release di Rust o una suite Playwright con qualche browser aperto possono superarli in un giorno qualsiasi.
Quanto costa restare su 8 GB
Tutti i rimedi scambiano velocità con memoria. Meno worker di test, CARGO_BUILD_JOBS=1, un -Xmx più piccolo, swap su disco: ognuno fa entrare la build rendendola più lenta, e il team aspetta quella build più lenta a ogni push. Finché il codice non cresce di nuovo e 137 torna.
La risposta di GitHub è un runner più grande, fatturato al minuto e solo per le organizzazioni su GitHub Team o Enterprise Cloud. Contro Skipbox con la stessa memoria:
| Minuti al mese | GitHub 4 core, 16 GB | Skipbox S, 16 GB | GitHub 8 core, 32 GB | Skipbox L, 32 GB |
|---|---|---|---|---|
| 10.000 | $102 | $39 | $202 | $149 |
| 20.000 | $222 | $39 | $422 | $149 |
| 30.000 | $342 | $39 | $642 | $149 |
Le cifre di GitHub sono al netto dell'uso incluso in GitHub Team. I tuoi minuti vanno nel calcolatore della home.
Il bisogno di memoria cresce soltanto. Gli agenti di coding aggiungono codice e dipendenze più in fretta delle persone, le suite di test si allungano, e un aggiornamento della toolchain può raddoppiare quello che usa lo stesso commit. Una fattura al minuto per un runner più grande ci cresce sopra a ogni push.
Risolverlo da solo
Se resti su 8 GB, il lavoro è questo:
- Trovare quale processo è stato terminato (
dmesgin uno stepif: failure()) e regolarne il limite:--max-old-space-size,-Xmx,org.gradle.workers.max,--maxWorkers - Limitare la memoria di ogni container di servizio in
compose.yaml - Aggiungere uno swapfile prima dello step pesante, dimensionato sui 14 GB di disco del runner
- Dividere il job perché nessuno step abbia bisogno di tutta la memoria
Ogni voce rende la build più lenta o più fragile, e nessuna sopravvive alla prossima crescita. Una macchina più grande chiude la questione.
Cosa dà Skipbox al job
Memoria a prezzo fisso. Un job chiede la sua dimensione con l'etichetta:
| Etichetta | Macchina | Piano |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 al mese |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 al mese |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 al mese |
Il piano S costa $39 al mese e il piano L $149, con minuti illimitati. Rimetti i worker dov'erano: la build ha la memoria e i core.
In più, una build più veloce. La macchina del tuo account resta tra un job e l'altro, quindi layer Docker, cache dei pacchetti e tool sono già sul suo disco quando parte il job successivo.
Nessun budget che ferma. I job di Skipbox non usano minuti di GitHub, quindi un budget di GitHub non li ferma mai, e niente si paga al minuto.
Nessuna macchina da gestire. Skipbox la prepara, aggiorna l'immagine, fa pulizia dopo ogni job e ricostruisce la macchina che non supera il controllo di salute.
Basta una riga
jobs:
build:
runs-on: skipbox # was ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: npm ci && npm run build
- Accedi a Skipbox con GitHub.
- Installa la GitHub App di Skipbox e scegli i repository.
- Cambia
runs-one fai push. Il piano S ($39) ha 16 GB; scegli L per 32 GB.
La macchina usa Ubuntu 24.04 con sudo senza password, Docker, Node.js e Python, quindi gli step girano come sono.
Sicurezza
- La macchina è solo del tuo account. Nessun job di altre aziende gira su di essa.
- Dopo ogni job vengono cancellati le credenziali, i processi e i container del runner. Dal 13 novembre 2026 il tuo checkout e il suo output di build (il
target/di Cargo) restano sulla tua macchina per i job successivi; “VM nuova per ogni job” dà a ogni job una macchina nuova. - Il codice di chi non ha accesso in scrittura (come le pull request dai fork) gira su una macchina nuova, usata una volta e poi eliminata.
I dettagli sono in come vengono isolati i job.
Provalo
La prova è gratuita per 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta. Esegue runs-on: skipbox a 4 vCPU e 16 GB, 2× la memoria dell'ubuntu-latest di un repository privato, quindi sposta lì il job che continua ad arrivare a 137. Per più core con quella memoria, scegli il piano M e cambia la sua etichetta in skipbox-8x16; per più memoria, il piano L e skipbox-16x32 (32 GB).
Domande frequenti
Cosa vuol dire exit code 137 in GitHub Actions?
Il processo è stato terminato con il segnale 9, SIGKILL (128 + 9 = 137). Su un runner ospitato da GitHub è quasi sempre l'out-of-memory killer di Linux: il job ha usato più memoria di quella che ha il runner. La soluzione che regge è una macchina con più memoria, come i runner di Skipbox da 16 GB o 32 GB a un prezzo mensile fisso.
Quanta memoria ha un runner GitHub Actions?
ubuntu-latest ha 8 GB e 2 CPU in un repository privato. I runner più grandi di GitHub hanno 16 GB a 4 core e 32 GB a 8 core, fatturati al minuto e solo per le organizzazioni su GitHub Team o Enterprise Cloud. Skipbox ha 16 GB sul piano S ($39 al mese) e 32 GB sul piano L, con minuti illimitati.
“JavaScript heap out of memory” è la stessa cosa di exit code 137?
No. L'errore di heap è Node che si ferma al suo limite, che --max-old-space-size alza. Exit code 137 è il kernel che termina il processo perché la memoria dell'intera macchina è finita, e alzare il limite di Node peggiora le cose. Quando la build ha davvero bisogno di quella memoria, eseguila su una macchina più grande: runs-on: skipbox le dà 16 GB.
Perché il mio job finisce con “The runner has received a shutdown signal”?
Una causa comune è che il runner finisce la memoria così del tutto da smettere di rispondere prima che un messaggio di memoria esaurita arrivi nel log. Trattalo come exit code 137: il job ha bisogno di più memoria di quella che ha il runner.
La prova gratuita di Skipbox risolve un job che finisce la memoria?
Dà al job 2× la memoria. La prova esegue runs-on: skipbox a 4 vCPU e 16 GB, contro i 8 GB di ubuntu-latest su un repository privato, e quanto il runner più grande di GitHub a 4 core. Un job che la finisce ancora ha bisogno del piano L per runs-on: skipbox-16x32 (32 GB).
Aggiornata il giorno 16 novembre 2026