Skipbox

Exit code 137 en GitHub Actions: sin memoria, y un ejecutor de 16 GB o 32 GB a precio fijo

Tu compilación murió otra vez con exit code 137. Alguien la vuelve a ejecutar, baja los workers de las pruebas, agrega swap, y el pipeline se vuelve más lento cada vez. Mientras tanto, el ejecutor que la sigue matando tiene 8 GB de memoria, y los más grandes de GitHub cobran por minuto.

Skipbox le da al trabajo una máquina con 16 GB o 32 GB a un precio mensual fijo con minutos ilimitados. Cambia una línea, runs-on: skipbox, y la compilación tiene 2 veces la memoria de ubuntu-latest por $39 al mes; runs-on: skipbox-8x16 duplica también los núcleos.

Qué significa el exit code 137

137 es 128 + 9: el proceso se mató con la señal 9, SIGKILL, que no puede capturar, así que nunca imprimió un error. En un ejecutor hospedado en GitHub esa señal viene del out-of-memory killer de Linux, cuando los procesos del trabajo juntos usaron más memoria de la que tiene la máquina.

En un repositorio privado, ubuntu-latest tiene 8 GB, y la aplicación del ejecutor, Docker y tus contenedores de servicio se llevan su parte antes que tu compilación. La compilación de un monorepo, un daemon de Gradle con workers en procesos aparte, una compilación release de Rust o una suite de Playwright con varios navegadores abiertos pueden pasar de ahí en un día normal.

Lo que cuesta quedarte en 8 GB

Todos los apaños cambian velocidad por memoria. Menos workers de pruebas, CARGO_BUILD_JOBS=1, un -Xmx más pequeño, swap en disco: cada uno hace que la compilación quepa haciéndola más lenta, y el equipo espera esa compilación más lenta en cada push. Hasta que el código vuelve a crecer y el 137 regresa.

La respuesta de GitHub es un ejecutor más grande, que se cobra por minuto y solo está disponible para organizaciones con GitHub Team o Enterprise Cloud. Frente a Skipbox con la misma memoria:

Las cifras de GitHub son después del uso incluido en GitHub Team. Tus propios minutos van en la calculadora de la página de inicio.

Las necesidades de memoria solo crecen. Los agentes de código agregan código y dependencias más rápido que las personas, las suites de pruebas se hacen más grandes, y una actualización de la cadena de herramientas puede duplicar lo que usa el mismo commit. Encima de eso, una factura por minuto por un ejecutor más grande crece con cada push.

Arreglarlo tú mismo

Si te quedas en 8 GB, el trabajo se ve así:

  • Averiguar qué proceso se mató (dmesg en un paso if: failure()) y ajustar su límite: --max-old-space-size, -Xmx, org.gradle.workers.max, --maxWorkers
  • Limitar la memoria de cada contenedor de servicio en compose.yaml
  • Agregar un swapfile antes del paso pesado, dimensionado contra los 14 GB de disco del ejecutor
  • Dividir el trabajo para que ningún paso necesite toda la memoria

Cada punto hace la compilación más lenta o más frágil, y ninguno sobrevive al siguiente estirón. Una máquina más grande le pone fin.

Lo que Skipbox le da al trabajo

Memoria a precio fijo. Cada trabajo pide su tamaño con la etiqueta:

El plan S cuesta $39 al mes y el plan L $149, con minutos ilimitados. Vuelve a poner los workers donde estaban: la compilación recibe la memoria y los núcleos.

Además, una compilación más rápida. La máquina de tu cuenta se mantiene entre trabajos, así que las capas de Docker, las cachés de paquetes y las herramientas ya están en su disco cuando empieza el siguiente trabajo.

Sin bloqueos por presupuesto. Los trabajos de Skipbox no usan minutos de GitHub, así que un presupuesto de GitHub nunca los detiene, y nada se cobra por minuto.

Ninguna máquina que administrar. Skipbox la aprovisiona, actualiza la imagen, limpia después de cada trabajo y reconstruye una máquina que falla su comprobación de estado.

Pasarte es una línea

jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build
  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. El plan S ($39) tiene 16 GB; elige L para 32 GB.

La máquina ejecuta Ubuntu 24.04 con sudo sin contraseña, Docker, Node.js y Python, así que los pasos se ejecutan tal como están.

Seguridad

  • La máquina es solo de tu cuenta. Ningún trabajo de otra empresa se ejecuta en ella.
  • Después de cada trabajo se borran las credenciales, los procesos y los contenedores del ejecutor. Desde el 13 de noviembre de 2026, tu checkout y su salida de compilación (el target/ de Cargo) se quedan en una máquina que Skipbox aloja solo para tu cuenta, para tus próximos trabajos; “VM nueva en cada trabajo” le da a cada trabajo una máquina nueva.
  • El código de personas sin acceso de escritura (como los pull requests desde forks) se ejecuta en una máquina nueva y desechable.

Los detalles están en cómo se aíslan los trabajos.

Pruébalo

La prueba es gratuita durante 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Ejecuta 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 sigue llegando al 137 y ejecútalo. Para más núcleos con esa memoria, elige el plan M y cambia su etiqueta a skipbox-8x16; para más memoria, el plan L y skipbox-16x32 (32 GB).

Preguntas frecuentes

¿Qué significa el exit code 137 en GitHub Actions?

El proceso se mató con la señal 9, SIGKILL (128 + 9 = 137). En un ejecutor hospedado en GitHub casi siempre es el out-of-memory killer de Linux: el trabajo usó más memoria de la que tiene el ejecutor. La solución que se sostiene es una máquina con más memoria, como los ejecutores de 16 GB o 32 GB de Skipbox a un precio mensual fijo.

¿Cuánta memoria tiene un ejecutor de GitHub Actions?

ubuntu-latest tiene 8 GB y 2 CPU en un repositorio privado. Los ejecutores más grandes de GitHub tienen 16 GB con 4 núcleos y 32 GB con 8 núcleos, se cobran por minuto y solo están disponibles para organizaciones con GitHub Team o Enterprise Cloud. Skipbox tiene 16 GB en el plan S ($39 al mes) y 32 GB en el plan L, con minutos ilimitados.

¿"JavaScript heap out of memory" es lo mismo que el exit code 137?

No. El error del heap es Node deteniéndose en su propio límite, que --max-old-space-size sube. El exit code 137 es el kernel matando el proceso porque la máquina entera se quedó sin memoria, y subir el límite de Node lo empeora. Cuando la compilación de verdad necesita la memoria, ejecútala en una máquina más grande: runs-on: skipbox le da 16 GB.

¿Por qué mi trabajo termina con "The runner has received a shutdown signal"?

Una causa común es que el ejecutor se queda tan sin memoria que deja de responder antes de que un mensaje de falta de memoria llegue al log. Trátalo como el exit code 137: el trabajo necesita más memoria de la que tiene el ejecutor.

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

Le da al trabajo 2× la memoria. La prueba ejecuta runs-on: skipbox con 4 vCPU y 16 GB, frente a los 8 GB de ubuntu-latest en un repositorio privado, y lo mismo que el ejecutor más grande de 4 núcleos de GitHub. Un trabajo que todavía se queda sin memoria necesita el plan L para runs-on: skipbox-16x32 (32 GB).

Actualizado el 19 de noviembre de 2026

CI/CD más rápida con una caché siempre lista

Tu ejecutor siempre encendido, a precio fijo

Nosotros los alojamos. Tú cambias una línea. 1/12 del costo de GitHub a pleno uso. Precio fijo, así que úsalo todo el día. 7× el espacio de caché de GitHub.

  • Sin tarjeta
  • Inicio de sesión con GitHub
  • Cancela cuando quieras