Saltar al contenido

Cómo acelerar los workflows de GitHub Actions

Última actualización

Un CI lento le cuesta por partida doble: los desarrolladores esperan y usted paga por minuto. La mayoría de los workflows puede reducir entre una tercera parte y la mitad de su tiempo de ejecución sin cambiar una sola línea de código de producto. Esta guía le muestra cómo encontrar primero las partes lentas y luego corregirlas por orden de beneficio.

Mida antes de cambiar nada

Abra una ejecución reciente y observe los tiempos por paso, no el total. En la interfaz de Actions, haga clic en un job y expanda los pasos; cada uno muestra su duración. Anote tres cifras de su workflow más lento: el tiempo de espera en la cola, el tiempo de configuración (checkout, toolchain, instalación de dependencias) y el tiempo del paso de build o pruebas.

También puede obtener las duraciones con la GitHub CLI:

gh run list --workflow ci.yml --limit 30 --json databaseId,createdAt,updatedAt,conclusion
gh run view <run-id> --json jobs --jq '.jobs[] | {name, started: .startedAt, done: .completedAt}'

Lo habitual es descubrir que el bloque más grande es la configuración, no las pruebas. Es una buena noticia, porque la configuración es la parte más fácil de cachear.

Deje de ejecutar trabajo que nadie necesita

El minuto más barato es el que nunca se ejecuta. Tres cambios eliminan ejecuciones completas.

Cancele las ejecuciones superadas. Cuando alguien hace dos push a un PR, la primera ejecución es desperdicio:

concurrency:
  group: ci-${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}

La condición evita que las ejecuciones en main se cancelen entre sí, de modo que cada merge sigue obteniendo una ejecución completa.

Omita las ejecuciones para cambios irrelevantes. Una edición de documentación no debería iniciar la suite de pruebas:

on:
  pull_request:
    paths-ignore:
      - "docs/**"
      - "**.md"

Si un workflow omitido es un check obligatorio, el PR esperará indefinidamente. Puede usar un job pequeño que siempre se ejecute y reporte el estado, o filtrar dentro del workflow con un paso de detección de rutas en lugar de hacerlo en el trigger.

Configure los timeouts. El timeout predeterminado de un job es de 360 minutos. Una prueba colgada puede consumir seis horas de tiempo facturado. Configure timeout-minutes: 15 (o el doble de su tiempo normal de ejecución) en cada job.

Cachee lo que descarga

Las instalaciones de dependencias y las descargas de toolchains se repiten en cada ejecución. Las acciones setup-* incluyen caché de forma integrada:

- uses: actions/setup-node@v4
  with:
    node-version: 22
    cache: npm
- run: npm ci

setup-python, setup-java y setup-go tienen la misma opción. Para el resto, use actions/cache con una clave construida a partir del hash de un lockfile. Nuestra guía de caché en GitHub Actions explica las claves, restore-keys y los límites, y el generador de claves de caché escribe el YAML por usted.

No cachee node_modules directamente cuando pueda cachear la caché de descargas del gestor de paquetes y ejecutar una instalación limpia. Un node_modules restaurado puede ocultar un lockfile roto.

Ejecute jobs en paralelo

Un workflow con un único job largo es un pipeline en serie. Divida el trabajo independiente en jobs separados para que se ejecuten a la vez: lint, comprobación de tipos, pruebas unitarias y build no necesitan nada unos de otros.

jobs:
  lint:
    runs-on: ubuntu-latest
    steps: [...]
  test:
    runs-on: ubuntu-latest
    steps: [...]
  build:
    runs-on: ubuntu-latest
    steps: [...]

Cada job asume su propio coste de configuración, así que dividir solo compensa cuando la configuración está cacheada y es corta. Para un único job de pruebas largo, es mejor fragmentarlo: consulte sharding de pruebas y pruebas en paralelo y el planificador de sharding de pruebas.

Haga menos en cada paso

  • Checkout superficial. actions/checkout obtiene un commit por defecto (fetch-depth: 1). No configure fetch-depth: 0 salvo que un paso necesite el historial, como la detección de paquetes afectados.
  • Compile solo lo que cambió. En un monorepo, ejecute solo los proyectos afectados. Consulte CI para monorepos con Nx o Turborepo.
  • Reutilice la salida del build. Compile una vez, suba con actions/upload-artifact y descargue en los jobs posteriores en lugar de recompilar en cada uno.
  • Docker. La caché de capas suele convertir una compilación de imagen de cinco minutos en treinta segundos. Consulte caché de capas de Docker en CI.
  • Reduzca la matriz. Cada SO o versión adicional multiplica el coste. Consulte builds con matriz bien hechos.

Use un runner más grande o más rápido

El runner ubuntu-latest predeterminado para repositorios privados tiene 2 vCPU y 7 GB de RAM. Si su compilación o sus pruebas usan varios núcleos (compiladores, bundlers, pytest -n auto, go test), más núcleos ayudan directamente. El runner grande de 4 núcleos de GitHub cuesta $0.012 por minuto frente a $0.006 del de 2 núcleos, según su página de precios de runners. Un job que se ejecuta más del doble de rápido con 4 núcleos también resulta más barato, además de más rápido.

La herramienta de especificaciones de runners enumera todos los tamaños y etiquetas, y la calculadora de costes muestra qué efecto tiene un cambio de tamaño en su factura mensual. Pruébelo primero en un workflow antes de cambiarlos todos: los pasos monohilo no ganan nada con núcleos adicionales.

Revise el tiempo en cola

Si los jobs esperan antes de empezar, ningún cambio en el YAML ayuda. Las causas son los límites de concurrencia de su plan (el número de jobs que puede ejecutar a la vez depende de su plan de GitHub) o demasiados jobs diminutos. Menos jobs más grandes reducen la cola. Los runners autoalojados o de terceros pueden eliminar el límite.

Un orden práctico de trabajo

  1. Añada concurrency y timeout-minutes (diez minutos, sin riesgo).
  2. Active la caché de dependencias.
  3. Divida lint, pruebas y build en jobs paralelos.
  4. Fragmente el job de pruebas más lento.
  5. Pruebe un runner más grande en el job más lento y compare el coste por ejecución, no solo el tiempo.

Preguntas frecuentes

¿Cuál es un buen objetivo para el tiempo de CI?

Muchos equipos buscan recibir el feedback de los pull requests en menos de 10 minutos. La investigación DORA relaciona los ciclos de feedback cortos con un mejor rendimiento en la entrega. Elija una cifra para su check obligatorio más lento y hágale seguimiento cada semana.

¿Un runner más grande siempre acelera el CI?

No. Solo ayuda con el trabajo en paralelo. Las descargas de red, los scripts de un solo hilo y la espera a servicios externos no se aceleran con más núcleos.

¿La caché hará que mis builds sean incorrectos?

No, siempre que la clave incluya todo lo que afecta al contenido, normalmente el hash del lockfile y el sistema operativo. Una caché obsoleta casi siempre se debe a una clave demasiado genérica.

¿Se me factura el tiempo en cola?

No. GitHub solo factura el tiempo en que se ejecuta un job, pero el tiempo en cola sigue retrasando a los desarrolladores.

Mida sus propios jobs

Si quiere ver lo que una máquina más rápida aporta a sus flujos de trabajo reales, compiler.dev ejecuta los mismos trabajos en runners más rápidos e incluye un modo de comparación que muestra el tiempo de ejecución y el coste uno al lado del otro. En nuestras pruebas, fue una mediana de 1.5× más rápido en 18 pilas medidas (15 más rápidas, 2 iguales, 1 más lenta) que el runner de 2 núcleos de GitHub. Su resultado depende de cuánto se paralelicen sus trabajos, así que mida en lugar de suponer.

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

Pruébelo gratis