# "The runner has received a shutdown signal": a causa, e um executor com a memória para resolvê-la

> Em um executor hospedado pelo GitHub, a causa que o GitHub confirmou é a memória: o trabalho ficou sem memória e a VM caiu antes de uma linha de falta de memória chegar ao log. O ubuntu-latest tem 8 GB em um repositório privado. O Skipbox dá a um trabalho 16 GB por $39 fixos por mês, ou 32 GB por $149, com minutos ilimitados.

O seu trabalho morreu com "The runner has received a shutdown signal" e sem exit code. Em um executor hospedado pelo GitHub, a causa que os mantenedores do GitHub confirmaram é a memória: o `ubuntu-latest` tem 8 GB em um repositório privado, e quando ela acaba a VM para antes de qualquer linha de falta de memória chegar ao log. Cada nova tentativa queima minutos e trava o merge.

O Skipbox dá ao trabalho a memória de que ele precisa a preço fixo: `runs-on: skipbox` para 16 GB por $39 por mês, ou `skipbox-16x32` para 32 GB por $149, com minutos ilimitados.

- O dobro da memória do `ubuntu-latest` de um repositório privado com `runs-on: skipbox`, quatro vezes com `skipbox-16x32`
- 16 GB com 20.000 minutos por mês: $222 no executor de 4 núcleos do GitHub, $39 fixos no Skipbox
- A sua máquina dedicada guarda as camadas Docker e os caches de pacotes, então a nova execução que funciona também é mais rápida

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

## O que a mensagem significa

O aplicativo do executor a registra quando o processo dele recebe a ordem de parar durante um trabalho: "The runner has received a shutdown signal. This can happen when the runner service is stopped, or a manually started runner is canceled." O step então termina com "The operation was canceled." e sem exit code, porque nenhum dos seus comandos falhou.

| O que o log mostra | O que aconteceu |
|---|---|
| A linha de desligamento, sem exit code, ninguém cancelou a execução | A VM ficou sem memória e caiu |
| `Process completed with exit code 137.` | O kernel matou um processo por memória; o executor sobreviveu |
| A linha de desligamento, e a página da execução diz que ela foi cancelada | Uma execução mais nova, uma pessoa ou um timeout a encerrou |

Na issue #15202 do actions/runner-images, um mantenedor do GitHub reproduziu o problema em um executor `ubuntu-24.04` de 8 GB: os trabalhos abaixo da memória mais o swap passaram, os que passaram disso perderam o executor com exatamente essa mensagem. Uma imagem nova pode provocá-lo sem nenhuma mudança do seu lado, quando uma nova versão padrão de uma ferramenta precisa de mais memória que a antiga.

## Quanto custa ficar em 8 GB

Cada execução perdida é minutos cobrados por nada, uma nova execução e um pull request que não pode entrar. Contornar isso também dá trabalho:

- diminuir os workers de teste, o `make -j` ou o número de workers do Gradle, para o trabalho rodar mais devagar
- limitar o `--max-old-space-size` do Node ou o `-Xmx` da JVM
- dividir um trabalho em vários e ligá-los de novo
- fixar a versão de uma ferramenta até alguém achar tempo para resolver

A necessidade de memória só cresce: suítes de teste maiores, builds maiores, mais trabalhos de agentes de programação fazendo push de correções. A resposta do GitHub é um executor maior, cobrado a cada minuto:

| Memória | Executor do GitHub com ela | Com 20.000 minutos por mês | Skipbox | Por mês, minutos ilimitados |
|---|---|---|---|---|
| 16 GB | Executor maior de 4 núcleos, $0,012 por minuto | $222 | `skipbox`, plano S | $39 |
| 32 GB | Executor maior de 8 núcleos, $0,022 por minuto | $422 | `skipbox-16x32`, plano L | $149 |

Os valores do GitHub são no GitHub Team, depois da computação incluída; os executores maiores exigem o Team ou o Enterprise Cloud. Confira os seus próprios minutos na [calculadora da página inicial](https://skipbox.dev/?ref=g-github-actions-runner-shutdown-signal-pt-br#cost).

Um executor auto-hospedado seu não custa nada na fatura do GitHub, mas mostra a mesma mensagem sempre que o serviço dele reinicia, o host reinicializa para aplicar patches ou um autoscaler retira a máquina. Manter um bem significa servidores, patches, limpeza e escalonamento.

## O Skipbox resolve

### A memória, a preço fixo

| `runs-on` | Máquina | Plano, por mês |
|---|---|---|
| `skipbox` | 4 vCPU, 16 GB | S, $39 |
| `skipbox-8x16` | 8 vCPU, 16 GB | M, $79 |
| `skipbox-16x32` | 16 vCPU, 32 GB | L, $149 |

Os minutos são ilimitados. O Skipbox se registra como executor auto-hospedado, então os trabalhos dele não usam nenhum dos seus minutos do GitHub e não param em um orçamento do Actions. Os trabalhos além das máquinas do seu plano esperam a vez.

### Novas execuções mais rápidas

Cada plano é uma VM mantida para a sua conta. As imagens, as camadas e o cache de build do Docker, os caches de pacotes e o cache de ferramentas ficam no disco dela, então a próxima execução começa com eles em vez de baixar tudo de novo.

### Uma máquina que você não precisa vigiar

O Skipbox mantém a imagem atualizada, apaga as credenciais, os processos e os contêineres de cada trabalho (o checkout e o `target/` do Cargo ficam a partir de 13 de novembro de 2026), verifica a integridade da máquina depois de cada trabalho e recria uma que falha. As VMs rodam Ubuntu 24.04 com Docker, Node.js e Python.

## Mudar é uma linha

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

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 `skipbox` roda em todos os planos, o `skipbox-16x32` no plano L. Para voltar, troque a linha de volta.

## Teste nos seus próprios trabalhos

O teste é grátis por 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão. Ele roda trabalhos `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 fica sem memória e veja-o rodar com os caches mantidos, e depois fique com o plano L para um trabalho que precisa de mais.

## Perguntas frequentes

### O que significa "The runner has received a shutdown signal"?

O aplicativo do executor recebeu a ordem de parar enquanto o seu trabalho rodava. Em um executor hospedado pelo GitHub, você não parou nada: a VM por baixo do trabalho sumiu, na maioria das vezes porque o trabalho usou toda a memória dela. O skipbox e o skipbox-16x32 do Skipbox dão a um trabalho 16 ou 32 GB a um preço mensal fixo.

### Por que o meu trabalho é cancelado sem erro?

Quando o log termina com a linha de desligamento e "The operation was canceled." sem exit code, o executor foi perdido, em vez de um step falhar. Um mantenedor do GitHub confirmou na issue #15202 do actions/runner-images que, quando a memória acaba, a VM para de responder antes de uma mensagem de falta de memória chegar ao log. Dê mais memória ao trabalho: no Skipbox, isso é uma linha de runs-on.

### É um erro de falta de memória?

Nos executores hospedados, normalmente sim. Um trabalho morto enquanto o executor sobrevive mostra o exit code 137; um trabalho que derruba a VM inteira mostra a linha de desligamento. Nos dois casos, o trabalho precisa de mais que os 8 GB do ubuntu-latest, e todos os planos do Skipbox dão isso a preço fixo.

### Por que um executor auto-hospedado mostra essa mensagem?

Algo parou o processo do executor ou a máquina dele no meio do trabalho: um reinício do serviço, uma reinicialização para atualizações, um autoscaler removendo a máquina ou o host ficando sem memória. No Skipbox, as máquinas são gerenciadas para você, com uma verificação de integridade depois de cada trabalho e a recriação automática de uma máquina que falha nela.

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

Ele dá ao trabalho 2× a memória. O teste roda trabalhos runs-on: skipbox com 4 vCPU e 16 GB, contra os 8 GB do ubuntu-latest em um repositório privado. Mais memória que isso significa runs-on: skipbox-16x32 (32 GB) no plano L.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/github-actions-runner-shutdown-signal
