# "The runner has received a shutdown signal": la causa, y un ejecutor con la memoria para arreglarlo

> En un ejecutor hospedado en GitHub, la causa que confirmó GitHub es la memoria: el trabajo se quedó sin ella y la VM se cayó antes de que una línea de falta de memoria llegara al log. ubuntu-latest tiene 8 GB en un repositorio privado. Skipbox le da a un trabajo 16 GB por $39 fijos al mes, o 32 GB por $149, con minutos ilimitados.

Tu trabajo murió con "The runner has received a shutdown signal" y sin exit code. En un ejecutor hospedado en GitHub, la causa que confirmaron los mantenedores de GitHub es la memoria: `ubuntu-latest` tiene 8 GB en un repositorio privado, y cuando se agotan, la VM se detiene antes de que ninguna línea de falta de memoria llegue al log. Cada reintento quema minutos y bloquea la fusión.

Skipbox le da al trabajo la memoria que necesita a precio fijo: `runs-on: skipbox` para 16 GB por $39 al mes, o `skipbox-16x32` para 32 GB por $149, con minutos ilimitados.

- El doble de memoria que el `ubuntu-latest` de un repositorio privado con `runs-on: skipbox`, cuatro veces más con `skipbox-16x32`
- 16 GB durante 20.000 minutos al mes: $222 en el ejecutor de 4 núcleos de GitHub, $39 fijos en Skipbox
- Tu máquina dedicada conserva las capas de Docker y las cachés de paquetes, así que la nueva ejecución que funciona además es más rápida

**GitHub Actions a precio fijo, minutos ilimitados** Skipbox ejecuta tus trabajos de GitHub Actions en tu propia máquina dedicada: $39 al mes, ejecutes los minutos que ejecutes. Las capas de Docker y las cachés de dependencias se conservan entre trabajos, así que el siguiente trabajo empieza enseguida.

Un ejecutor de 4 vCPU, 20.000 minutos al mes: GitHub $222 → Skipbox $39. Ahorras $183 cada mes.

Pasarte lleva una sola línea: `runs-on: skipbox`.

[Empezar mi prueba gratuita de 7 días](https://app.skipbox.dev/sign-in?ref=g-github-actions-runner-shutdown-signal-es)

## Qué significa el mensaje

La aplicación del ejecutor lo registra cuando a su proceso se le dice que se detenga durante un trabajo: “The runner has received a shutdown signal. This can happen when the runner service is stopped, or a manually started runner is canceled.” (es decir, puede pasar cuando se detiene el servicio del ejecutor o se cancela un ejecutor iniciado a mano). Después, el paso termina con “The operation was canceled.” y sin exit code, porque ninguno de tus comandos falló.

| Lo que muestra el log | Lo que pasó |
|---|---|
| La línea del apagado, sin exit code, nadie canceló la ejecución | La VM se quedó sin memoria y se cayó |
| `Process completed with exit code 137.` | El kernel mató un proceso por memoria; el ejecutor sobrevivió |
| La línea del apagado, y la página de la ejecución dice que se canceló | La terminó una ejecución más reciente, una persona o un tiempo de espera |

En el issue #15202 de actions/runner-images, un mantenedor de GitHub lo reprodujo en un ejecutor `ubuntu-24.04` de 8 GB: los trabajos por debajo de la memoria más el swap pasaban, y los que la superaban perdían el ejecutor con este mismo mensaje. Una imagen nueva puede provocarlo sin ningún cambio por tu parte, cuando una nueva versión predeterminada de una herramienta necesita más memoria que la anterior.

## Lo que cuesta quedarte en 8 GB

Cada ejecución perdida son minutos cobrados para nada, una nueva ejecución y un pull request que no se puede fusionar. Esquivarlo también es trabajo:

- bajar los workers de las pruebas, `make -j` o la cantidad de workers de Gradle, así que el trabajo va más lento
- limitar el `--max-old-space-size` de Node o el `-Xmx` de la JVM
- dividir un trabajo en varios y volver a conectarlos
- fijar la versión de una herramienta hasta que alguien tenga tiempo de arreglarlo

La necesidad de memoria solo crece: suites de pruebas más grandes, compilaciones más grandes, más trabajos de agentes de código que suben correcciones. La respuesta de GitHub es un ejecutor más grande, que cobra cada minuto:

| Memoria | Ejecutor de GitHub que la tiene | Con 20.000 minutos al mes | Skipbox | Al mes, minutos ilimitados |
|---|---|---|---|---|
| 16 GB | Ejecutor más grande de 4 núcleos, $0,012 por minuto | $222 | `skipbox`, plan S | $39 |
| 32 GB | Ejecutor más grande de 8 núcleos, $0,022 por minuto | $422 | `skipbox-16x32`, plan L | $149 |

Las cifras de GitHub son en GitHub Team, después de su cómputo incluido; los ejecutores más grandes necesitan Team o Enterprise Cloud. Comprueba tus propios minutos en la [calculadora de la página de inicio](https://skipbox.dev/?ref=g-github-actions-runner-shutdown-signal-es#cost).

Un ejecutor autohospedado propio no cuesta nada en la factura de GitHub, pero muestra el mismo mensaje cada vez que su servicio se reinicia, el host se reinicia por parches o un autoescalador retira la máquina. Mantener uno bien son servidores, parches, limpieza y escalado.

## Skipbox lo arregla

### La memoria, a precio fijo

| `runs-on` | Máquina | Plan, al mes |
|---|---|---|
| `skipbox` | 4 vCPU, 16 GB | S, $39 |
| `skipbox-8x16` | 8 vCPU, 16 GB | M, $79 |
| `skipbox-16x32` | 16 vCPU, 32 GB | L, $149 |

Los minutos son ilimitados. Skipbox se registra como ejecutor autohospedado, así que sus trabajos no usan ninguno de tus minutos de GitHub y no se detienen por un presupuesto de Actions. Los trabajos que pasan de las máquinas de tu plan esperan su turno.

### Nuevas ejecuciones más rápidas

Cada plan es una VM que se mantiene para tu cuenta. Las imágenes de Docker, las capas y la caché de compilación, las cachés de paquetes y la caché de herramientas se quedan en su disco, así que la siguiente ejecución empieza con ellas en lugar de volver a descargarlo todo.

### Una máquina que no tienes que vigilar

Skipbox mantiene la imagen actualizada, borra las credenciales, los procesos y los contenedores de cada trabajo (el checkout y el `target/` de Cargo se quedan desde el 13 de noviembre de 2026), comprueba el estado de la máquina después de cada trabajo y reconstruye la que falla. Las VM ejecutan Ubuntu 24.04 con Docker, Node.js y Python.

## Pasarte es una línea

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

1. Inicia sesión en Skipbox con GitHub.
2. Instala la app de GitHub de Skipbox y elige los repositorios.
3. Cambia `runs-on` y haz push.

`skipbox` se ejecuta en todos los planes, `skipbox-16x32` en el plan L. Para volver, cambia la línea de nuevo.

## Pruébalo con tus propios trabajos

La prueba es gratuita durante 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Ejecuta los trabajos con `runs-on: skipbox` con 4 vCPU y 16 GB, 2× la memoria del `ubuntu-latest` de un repositorio privado, así que pasa ahí el trabajo que se queda sin memoria, míralo ejecutarse con sus cachés conservadas y luego toma el plan L para un trabajo que necesite más.

## Preguntas frecuentes

### ¿Qué significa "The runner has received a shutdown signal"?

A la aplicación del ejecutor se le dijo que se detuviera mientras tu trabajo se ejecutaba. En un ejecutor hospedado en GitHub tú no detuviste nada: la VM debajo del trabajo desapareció, casi siempre porque el trabajo usó toda su memoria. skipbox y skipbox-16x32 de Skipbox le dan a un trabajo 16 o 32 GB a un precio mensual fijo.

### ¿Por qué mi trabajo se cancela sin ningún error?

Cuando el log termina con la línea del apagado y "The operation was canceled." sin exit code, lo que se perdió fue el ejecutor, no falló un paso. Un mantenedor de GitHub confirmó en el issue #15202 de actions/runner-images que, cuando se agota la memoria, la VM deja de responder antes de que un mensaje de falta de memoria llegue al log. Dale más memoria al trabajo: en Skipbox es una línea runs-on.

### ¿Es un error de falta de memoria?

En los ejecutores hospedados, normalmente sí. Un trabajo que se mata mientras el ejecutor sobrevive muestra en su lugar el exit code 137; un trabajo que tumba la VM entera muestra la línea del apagado. En los dos casos el trabajo necesita más que los 8 GB de ubuntu-latest, y todos los planes de Skipbox los dan a precio fijo.

### ¿Por qué lo muestra un ejecutor autohospedado?

Algo detuvo el proceso del ejecutor o su máquina a mitad del trabajo: un reinicio del servicio, un reinicio por actualizaciones, un autoescalador que quitó la máquina o el host quedándose sin memoria. En Skipbox las máquinas se administran en tu lugar, con una comprobación de estado después de cada trabajo y una reconstrucción automática de la máquina que no la pasa.

### ¿La prueba gratuita de Skipbox arregla un trabajo que se queda sin memoria?

Le da al trabajo 2× la memoria. La prueba ejecuta los trabajos con runs-on: skipbox con 4 vCPU y 16 GB, frente a los 8 GB de ubuntu-latest en un repositorio privado. Más memoria que eso significa runs-on: skipbox-16x32 (32 GB) en el plan L.

Actualizado el 2026-11-19 · https://skipbox.dev/es/guides/github-actions-runner-shutdown-signal
