# “The runner has received a shutdown signal”: la causa, e un runner con la memoria per risolverla

> Su un runner ospitato da GitHub la causa confermata da GitHub è la memoria: il job l'ha finita e la VM si è spenta prima che una riga di memoria esaurita arrivasse nel log. ubuntu-latest ha 8 GB su un repository privato. Skipbox dà a un job 16 GB a un prezzo fisso di $39 al mese, o 32 GB per $149, minuti illimitati.

Il tuo job è morto con “The runner has received a shutdown signal” e nessun exit code. Su un runner ospitato da GitHub la causa confermata dai maintainer di GitHub è la memoria: `ubuntu-latest` ha 8 GB su un repository privato, e quando finiscono la VM si ferma prima che una riga di memoria esaurita arrivi nel log. Ogni nuovo tentativo brucia minuti e blocca il merge.

Skipbox dà al job la memoria che gli serve a prezzo fisso: `runs-on: skipbox` per 16 GB a $39 al mese, o `skipbox-16x32` per 32 GB a $149, con minuti illimitati.

- Il doppio della memoria dell'`ubuntu-latest` di un repository privato con `runs-on: skipbox`, quattro volte con `skipbox-16x32`
- 16 GB a 20.000 minuti al mese: $222 sul runner a 4 core di GitHub, $39 fissi su Skipbox
- La tua macchina conserva layer Docker e cache dei pacchetti, quindi la riesecuzione che funziona è anche più veloce

**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-runner-shutdown-signal-it)

## Cosa vuol dire il messaggio

L'applicazione del runner lo scrive nel log quando al suo processo viene detto di fermarsi durante un job: "The runner has received a shutdown signal. This can happen when the runner service is stopped, or a manually started runner is canceled." Lo step finisce poi con "The operation was canceled." e nessun exit code, perché nessuno dei tuoi comandi è fallito.

| Cosa mostra il log | Cosa è successo |
|---|---|
| La riga di shutdown, nessun exit code, nessuno ha annullato l'esecuzione | La VM ha finito la memoria e si è spenta |
| `Process completed with exit code 137.` | Il kernel ha terminato un processo per la memoria; il runner è sopravvissuto |
| La riga di shutdown, e la pagina dell'esecuzione dice che è stata annullata | L'ha chiusa un'esecuzione più recente, una persona o un timeout |

Nella issue #15202 di actions/runner-images, un maintainer di GitHub l'ha riprodotto su un runner `ubuntu-24.04` da 8 GB: i job sotto memoria più swap passavano, quelli sopra perdevano il runner con esattamente questo messaggio. Una nuova immagine può provocarlo senza nessuna modifica da parte tua, quando una nuova versione di default di un tool ha bisogno di più memoria della precedente.

## Quanto costa restare a 8 GB

Ogni esecuzione persa sono minuti pagati per niente, una riesecuzione e una pull request che non si può fare merge. Aggirare il problema è lavoro anche quello:

- abbassare i worker dei test, `make -j` o il numero di worker di Gradle, così il job gira più lento
- limitare `--max-old-space-size` di Node o `-Xmx` della JVM
- dividere un job in più job e ricollegarli tra loro
- bloccare la versione di un tool finché qualcuno non trova il tempo di sistemarlo

Il bisogno di memoria cresce soltanto: suite di test più grandi, build più grandi, più job dagli agenti di coding che fanno push delle correzioni. La risposta di GitHub è un runner più grande, fatturato ogni minuto:

| Memoria | Runner di GitHub che la ha | A 20.000 minuti al mese | Skipbox | Al mese, minuti illimitati |
|---|---|---|---|---|
| 16 GB | Runner più grande a 4 core, $0,012 al minuto | $222 | `skipbox`, piano S | $39 |
| 32 GB | Runner più grande a 8 core, $0,022 al minuto | $422 | `skipbox-16x32`, piano L | $149 |

Le cifre di GitHub sono su GitHub Team, dopo il calcolo incluso; i runner più grandi richiedono Team o Enterprise Cloud. Controlla i tuoi minuti nel [calcolatore della home](https://skipbox.dev/?ref=g-github-actions-runner-shutdown-signal-it#cost).

Un tuo runner self-hosted non costa niente nella fattura di GitHub, ma mostra lo stesso messaggio ogni volta che il suo servizio si riavvia, l'host si riavvia per le patch o un autoscaler toglie la macchina. Gestirne uno bene vuol dire server, patch, pulizia e scalabilità.

## Skipbox lo risolve

### La memoria, a prezzo fisso

| `runs-on` | Macchina | Piano, al mese |
|---|---|---|
| `skipbox` | 4 vCPU, 16 GB | S, $39 |
| `skipbox-8x16` | 8 vCPU, 16 GB | M, $79 |
| `skipbox-16x32` | 16 vCPU, 32 GB | L, $149 |

I minuti sono illimitati. Skipbox si registra come runner self-hosted, quindi i suoi job non usano nessuno dei tuoi minuti di GitHub e non si fermano a un budget di Actions. I job oltre le macchine del tuo piano aspettano il loro turno.

### Riesecuzioni più veloci

Ogni piano è una VM tenuta per il tuo account. Immagini, layer e cache di build di Docker, cache dei pacchetti e tool cache restano sul suo disco, quindi l'esecuzione successiva parte con tutto questo invece di riscaricare tutto.

### Una macchina da non sorvegliare

Skipbox tiene aggiornata l'immagine, cancella le credenziali, i processi e i container di ogni job (il checkout e il `target/` di Cargo restano dal 13 novembre 2026), controlla la salute della macchina dopo ogni job e ricostruisce quella che non supera il controllo. Le VM usano Ubuntu 24.04 con Docker, Node.js e Python.

## Basta una riga

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

1. Accedi a Skipbox con GitHub.
2. Installa la GitHub App di Skipbox e scegli i repository.
3. Cambia `runs-on` e fai push.

`skipbox` gira su tutti i piani, `skipbox-16x32` sul piano L. Per tornare indietro, rimetti la riga com'era.

## Provalo sui tuoi job

La prova è gratuita per 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta. Esegue i job `runs-on: skipbox` a 4 vCPU e 16 GB, 2× la memoria dell'`ubuntu-latest` di un repository privato, quindi sposta il job che finisce la memoria e guardalo girare con le cache conservate, poi prendi il piano L per un job che ha bisogno di più.

## Domande frequenti

### Cosa vuol dire “The runner has received a shutdown signal”?

All'applicazione del runner è stato detto di fermarsi mentre il tuo job girava. Su un runner ospitato da GitHub non hai fermato niente tu: la VM sotto il job è sparita, il più delle volte perché il job ha usato tutta la sua memoria. skipbox e skipbox-16x32 di Skipbox danno a un job 16 o 32 GB a un prezzo mensile fisso.

### Perché il mio job viene annullato senza errori?

Quando il log finisce con la riga di shutdown e “The operation was canceled.” senza exit code, si è perso il runner, non è fallito uno step. Un maintainer di GitHub ha confermato nella issue #15202 di actions/runner-images che, quando la memoria finisce, la VM smette di rispondere prima che un messaggio di memoria esaurita arrivi nel log. Dai al job più memoria: su Skipbox è una riga runs-on.

### È un errore di memoria esaurita?

Sui runner ospitati, di solito sì. Un job terminato mentre il runner sopravvive mostra invece exit code 137; un job che fa cadere tutta la VM mostra la riga di shutdown. In entrambi i casi il job ha bisogno di più degli 8 GB di ubuntu-latest, che ogni piano Skipbox supera a prezzo fisso.

### Perché la mostra un runner self-hosted?

Qualcosa ha fermato il processo del runner o la sua macchina a metà job: un riavvio del servizio, un riavvio per gli aggiornamenti, un autoscaler che rimuove la macchina, o l'host che finisce la memoria. Su Skipbox le macchine sono gestite per te, con un controllo di salute dopo ogni job e la ricostruzione automatica di una macchina che non lo supera.

### La prova gratuita di Skipbox risolve un job che finisce la memoria?

Dà al job 2× la memoria. La prova esegue i job runs-on: skipbox a 4 vCPU e 16 GB, contro i 8 GB di ubuntu-latest su un repository privato. Per più memoria c'è runs-on: skipbox-16x32 (32 GB) sul piano L.

Aggiornata il giorno 2026-11-11 · https://skipbox.dev/it/guides/github-actions-runner-shutdown-signal
