# GitHub Actions exit code 137: memoria esaurita, e un runner da 16 GB o 32 GB a prezzo fisso

> Exit code 137 vuol dire che il job ha finito la memoria e Linux l'ha terminato: l'ubuntu-latest di un repository privato ha 8 GB. Skipbox esegue il job su macchine da 16 GB o 32 GB a un prezzo fisso di $39 o $149 al mese con minuti illimitati, cambiando una riga runs-on.

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.

- 16 GB per $39 al mese, 32 GB per $149, per quanti minuti vuoi
- Il doppio dei core del runner più grande di GitHub con la stessa memoria: 8 vCPU con 16 GB
- 10.000 minuti al mese sul runner da 16 GB di GitHub: $102. Su Skipbox S: $39

**GitHub Actions a prezzo fisso, minuti illimitati** Skipbox esegue i tuoi job di GitHub Actions su una macchina dedicata tutta tua: $39 al mese, per quanti minuti tu esegua. I layer Docker e le cache delle dipendenze restano tra un job e l'altro, così il job successivo parte subito.

Un runner da 4 vCPU, 20.000 minuti al mese: GitHub $222 → Skipbox $39. Risparmi $183 ogni mese.

Per passare basta una riga: `runs-on: skipbox`.

[Inizia la prova gratuita di 7 giorni](https://app.skipbox.dev/sign-in?ref=g-github-actions-exit-code-137-out-of-memory-it)

## 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](https://skipbox.dev/?ref=g-github-actions-exit-code-137-out-of-memory-it#cost).

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 (`dmesg` in uno step `if: 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

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

1. Accedi a Skipbox con GitHub.
2. Installa la GitHub App di Skipbox e scegli i repository.
3. Cambia `runs-on` e 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](https://docs.skipbox.dev/it/isolation).

## 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 2026-11-16 · https://skipbox.dev/it/guides/github-actions-exit-code-137-out-of-memory
