Saltar al contenido

Límite de tiempo en GitHub Actions: 6 h por job, 35 días (2026)

Última actualización: · Publicada por primera vez:

El límite de tiempo de GitHub Actions es de 6 horas por job en runners alojados en GitHub y de 35 días por ejecución de workflow, y existen otros límites que pueden parecer lentitud hasta que se conocen. Esta guía enumera los límites documentados (verificados en la página de límites de uso de GitHub el 11/10/2026), muestra cómo establecer tiempos de espera más cortos y después aborda la otra cara de la cuestión: cómo retrasar un job, un step o un workflow completo de forma intencionada. Está relacionada con la guía sobre CI lento.

Los límites que importan

LímiteValor
Tiempo de ejecución de jobs, runners alojados en GitHub6 horas; el job se termina y falla
Tiempo de ejecución de workflows35 días; la ejecución se cancela (incluye el tiempo en cola y de aprobación)
Tiempo en cola de jobs, runners autoalojados24 horas, después se cancela
Tamaño de la matriz256 jobs por ejecución de workflow
Ejecuciones de workflow iniciadas500 por cada 10 segundos por repositorio
Aprobaciones en environmentsUna ejecución puede esperar hasta 30 días

Los límites pueden cambiar, por lo que conviene consultar la documentación de GitHub sobre límites de uso para ver las cifras vigentes. El que más afecta en la práctica es el límite de jobs: si un job se acerca a las 6 horas, el problema es otro, y la solución es dividirlo en fragmentos o usar una matriz.

Establecer tiempos de espera más cortos

El valor predeterminado de timeout-minutes para un job es 360, es decir, las mismas 6 horas. Un test bloqueado consume entonces seis horas de tiempo facturado. Configure un tiempo de espera cercano al doble de su duración habitual:

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      - run: npm ci
      - run: npm test
        timeout-minutes: 10   # steps can have their own timeout

Un timeout hace fallar el job de forma limpia y detiene la facturación. Combínelo con concurrency para cancelar las ejecuciones reemplazadas (guía de aceleración). El verificador de YAML de workflows puede detectar timeouts ausentes. Si un job alcanza su timeout con regularidad, consulte GitHub Actions lento y pruebas e2e lentas.

Cómo retrasar un step

El retraso más sencillo es un comando de shell:

- name: Wait for deploy to settle
  run: sleep 60

Esto consume minutos facturados, así que úselo con moderación. Es mejor esperar a una condición en lugar de un tiempo fijo, con un timeout:

- name: Wait for the service
  run: |
    for i in $(seq 1 30); do
      curl -fsS https://staging.example.com/health && exit 0
      sleep 10
    done
    exit 1

Cómo retrasar un job

Los jobs comienzan cuando terminan sus needs. Para retrasar uno, añada un job que espere y haga que el siguiente dependa de él. Hay dos enfoques que evitan pagar tiempo de runner mientras se espera:

  • Environment con temporizador de espera. En la configuración del repositorio, cree un environment (por ejemplo production) con un temporizador de espera de hasta 43 200 minutos (30 días) y revisores obligatorios opcionales. Un job que lo referencie espera sin usar un runner:
jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production   # wait timer and approvals configured in settings
    steps:
      - run: ./deploy.sh

Los temporizadores de espera en environments están disponibles para repositorios públicos y, para repositorios privados, en planes compatibles, así que compruebe su plan.

  • Grupos de concurrencia para serializar ejecuciones en lugar de retrasarlas: concurrency: group: deploy hace que la siguiente ejecución espere a la actual.

Cómo retrasar un workflow

  • Programarlo. Ejecútelo en un momento futuro con on: schedule. Las programaciones usan UTC y pueden retrasarse con carga alta, sobre todo al inicio de una hora; consulte programaciones cron para la sintaxis y los problemas de "schedule not running". El intervalo más corto es de una vez cada 5 minutos.
  • Despachar más tarde. Otro workflow o un programador externo puede llamar a workflow_dispatch mediante la API o gh workflow run en el momento que usted elija.
  • Esperar a otro workflow. El disparador workflow_run inicia un workflow cuando otro termina, lo que supone un retraso por dependencia y no por reloj.

Retrasos inesperados que parecen límites

  • En cola, no en ejecución: no hay runners libres o se alcanzó un límite de concurrencia. Los jobs autoalojados pueden esperar en cola hasta 24 horas.
  • Retraso de cron: las ejecuciones programadas pueden iniciarse con minutos de retraso durante picos de carga.
  • Aprobaciones: una ejecución que espera a un revisor cuenta para el límite de 35 días del workflow.
  • Acciones con límite de tasa: las APIs de terceros devuelven 429 y su bucle de reintentos duerme; establezca un timeout total.

Si muchos jobs esperan a runners, añadir capacidad o usar runners más rápidos reduce el tiempo que los jobs ocupan los slots. Consulte runners más rápidos de GitHub Actions. compiler.dev fue, de mediana, 1.5× más rápido en 18 stacks medidos (15 más rápidos, 2 iguales, 1 más lento) que el runner de 2 núcleos de GitHub, y recurre automáticamente a sus propios runners.

Nota sobre facturación

Los retrasos que ocupan un runner, como sleep, se facturan como minutos de runner según las tarifas de precios de GitHub Actions explicados. Los temporizadores de espera de environments no ocupan un runner.

Preguntas frecuentes

¿Cuál es el límite de tiempo de GitHub Actions?

6 horas por job en runners alojados por GitHub, y 35 días por workflow run. Configure timeout-minutes con un valor menor para detener los jobs bloqueados antes.

¿Cómo retraso un job de GitHub Actions?

Use un environment con un temporizador de espera, o haga que el job dependa de un job anterior que espere. Para esperas cortas, sleep en un step funciona, pero consume minutos facturables.

¿Cómo retraso un workflow?

Programe su ejecución con on: schedule, actívela más tarde mediante workflow_dispatch, o encadénela con workflow_run.

¿Qué ocurre cuando un job alcanza el límite?

El job se termina y se marca como fallido. La caché o los artefactos generados anteriormente se conservan.

Ejecute este workflow en compiler.dev Sin tarjeta · 200 minutos gratuitos

Pruébelo gratis