Skipbox

Cómo acelerar GitHub Actions: recorta un pipeline de 25 minutos, palanca por palanca

Un pipeline de GitHub Actions de 25 minutos suele ser cuatro retrasos apilados: trabajos que se esperan entre sí, trabajo que no hacía falta ejecutar, preparación que una VM vacía repite en cada trabajo, y pasos limitados por la CPU apretados en 2 núcleos (el ubuntu-latest de un repositorio privado tiene 2 CPU y 8 GB). Atácalos en este orden. Primero, mide la ruta crítica, con el tiempo en cola aparte. Después, sáltate lo que no hacía falta ejecutar, ejecuta a la vez los trabajos independientes, deja de reconstruir el estado, dale más núcleos a los pasos pesados y fragmenta lo que siga siendo largo. Los tres primeros son arreglos del flujo de trabajo que no cuestan nada. El resto es la máquina: un ejecutor que conserva sus cachés entre trabajos y tiene más núcleos.

Skipbox es ese ejecutor. Tus trabajos se ejecutan en la máquina dedicada de tu cuenta, que conserva las capas de Docker, las cachés de paquetes, las herramientas y la salida de compilación entre trabajos, con de 4 a 16 vCPU, por $39 fijos al mes con minutos ilimitados. En la CI de astro fueron 528 s en GitHub y 30 s en Skipbox. Pasarte es una línea: runs-on: skipbox.

1. Mide la ruta crítica

El tiempo que espera tu equipo es la cadena de trabajos que termina última, no la suma de todos los trabajos. Abre la ejecución de un pull request representativo: el grafo muestra qué trabajos esperan a cuáles, y el log de cada trabajo muestra los tiempos de sus pasos. Anota, para la cadena más lenta:

Compara una ejecución en caliente con una en frío. Una caché que falla la mitad de las veces parece estar bien en un promedio.

2. Sáltate lo que no hacía falta ejecutar

  • Cancela las ejecuciones reemplazadas. Cada push después del primero vuelve inútil la ejecución en curso. Un grupo de concurrencia con cancel-in-progress la detiene. Limítalo a los pull requests para que un push a la rama predeterminada nunca cancele un despliegue:
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
  • Ejecuta solo lo que toca el cambio. Los filtros paths: se saltan un flujo de trabajo en los cambios que solo tocan documentación; en un monorepo, turbo run test --affected o los comandos affected de Nx ejecutan solo los paquetes que cambiaron. Un filtro a nivel de disparador hace que una comprobación obligatoria nunca informe, así que filtra dentro del trabajo cuando la comprobación es obligatoria.

3. Ejecuta a la vez los trabajos independientes

GitHub ejecuta los trabajos en paralelo salvo que needs: los encadene. El lint, la comprobación de tipos, las pruebas unitarias y la compilación rara vez se necesitan entre sí: inícialos juntos y deja que solo el empaquetado o el despliegue esperen a todos. Si dos trabajos compilan lo mismo, compílalo una vez y pásalo con actions/upload-artifact, midiendo cuánto tardan la subida y la descarga.

4. Deja de reconstruir el mismo estado

Aquí se va la mayor parte de un pipeline largo. Cada trabajo en un ejecutor hospedado en GitHub empieza en una VM nueva, así que descarga su cadena de herramientas, instala dependencias, reconstruye capas de Docker y compila desde cero, cada vez.

  • Cachés que acierten de verdad. El cache: npm de actions/setup-node (y sus variantes para pnpm y yarn) guarda las descargas del gestor de paquetes con una clave basada en el lockfile; no guarda node_modules, así que la instalación se sigue ejecutando. GitHub guarda 10 GB por repositorio, descarta las entradas sin usar durante 7 días, y un acierto sigue siendo una descarga a la VM nueva (límite de tamaño de la caché).
  • Cachés de herramientas. eslint --cache, tsc --incremental, el directorio de caché de Jest y el .turbo/cache de turbo guardan el propio trabajo, no las descargas. En una VM nueva están vacías salvo que también las restaures.
  • Capas de Docker. docker build en una VM nueva empieza sin capas; exportarlas con cache-to de buildx e importarlas en cada ejecución es el apaño (caché de capas de Docker).

Una máquina que conserva su disco hace todo esto por sí sola: las cachés, las cachés de herramientas, las capas y la salida de compilación están ahí desde el último trabajo.

5. Dale más núcleos a los pasos pesados

Los compiladores, los bundlers y los ejecutores de pruebas inician un worker por núcleo, así que en 2 CPU ejecutan dos a la vez. Revisa lo que usa de verdad el ejecutor de pruebas: Jest usa por defecto los núcleos menos uno (un worker en 2 CPU), pytest se ejecuta en serie hasta -n auto, y Playwright usa por defecto la mitad de los núcleos, y su documentación recomienda un worker en la CI. Más núcleos solo ayudan cuando se le dice al ejecutor que los use, y solo en los pasos que mantienen ocupada la CPU; una descarga o el arranque de una base de datos no se aceleran.

En GitHub, más núcleos significa ejecutores más grandes: de 4 a 96 núcleos, solo en organizaciones con GitHub Team o Enterprise Cloud, cobrados por minuto a una tarifa más alta por núcleo.

6. Fragmenta lo que siga siendo largo

Una matriz de fragmentos reparte una suite larga entre trabajos. Recorta el tiempo de reloj, no los minutos: cada fragmento vuelve a hacer checkout, instalar y compilar, así que cuatro fragmentos pagan la preparación cuatro veces. Equilibra los fragmentos por tiempo medido, no por cantidad de archivos, y deja de agregarlos cuando la preparación sea la mayor parte de cada fragmento.

Lo que cuesta seguir siendo lento

Un pipeline de 15 minutos que se ejecuta 40 veces al día son 10 horas de espera repartidas entre tu equipo, cada día, antes de contar los cambios de contexto. Con facturación por minuto, los minutos de preparación se cobran igual que los de pruebas:

Más núcleos en GitHub cuestan más por minuto, así que la diferencia crece con la máquina:

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

Cuando la solución es la máquina

Los propios trabajos de CI de proyectos reales, con los pasos sin cambios, en el ejecutor de repositorio público de GitHub (4 vCPU, 16 GB) y en una máquina dedicada de Skipbox con los mismos vCPU, según nuestras ejecuciones de sus flujos de trabajo:

El ubuntu-latest de un repositorio privado tiene la mitad de los núcleos que esas ejecuciones de GitHub.

Lo que Skipbox hace por tu pipeline

Conserva la máquina. Cada plan trae la máquina dedicada de tu cuenta, que se mantiene entre trabajos. Las imágenes de Docker, las capas y la caché de compilación, las cachés de paquetes, la caché de herramientas, y tu checkout con el target/ de Cargo y la caché de turbo se quedan en su disco: al menos 7× el espacio de caché de GitHub, sin claves, sin caducidad a los 7 días y sin regla de ramas.

Suma núcleos a precio fijo. Cada trabajo elige su tamaño con la etiqueta:

Los minutos son ilimitados, así que los fragmentos, las nuevas ejecuciones y una matriz más grande no suben la factura. Los trabajos de Skipbox no usan minutos de GitHub, así que un presupuesto de GitHub nunca los detiene.

Se cuida sola. Skipbox aprovisiona la máquina, mantiene la imagen actualizada, limpia después de cada trabajo y reconstruye una máquina que falla su comprobación de estado.

Pasarte es una línea

jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - 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.

Tus pasos y acciones se ejecutan tal como están, en Ubuntu 24.04 con Docker, Node.js y Python.

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, y también las credenciales de git y los archivos sin seguimiento del checkout conservado. “VM nueva en cada trabajo” le da a cada trabajo una máquina nueva en su lugar.
  • El código de personas sin acceso de escritura (como los pull requests desde forks) se ejecuta en una VM nueva que lee tus cachés pero no puede cambiarlas.

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

Pruébalo con tu trabajo más lento

La prueba es gratuita durante 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Pasa el trabajo de tu ruta crítica a runs-on: skipbox, ejecútalo dos veces y lee los tiempos de los pasos de la segunda ejecución junto a los de GitHub.

Preguntas frecuentes

Nuestro pipeline de GitHub Actions tarda 25 minutos. ¿Cuál es la forma más rápida de acelerarlo?

Recórrelo por orden. Lee el grafo de la ejecución y los tiempos de los pasos para encontrar la cadena de trabajos que fija el tiempo, con el tiempo en cola aparte. Cancela las ejecuciones reemplazadas y sáltate los trabajos cuyos archivos no cambiaron. Quita los needs: que solo expresan costumbre, para que los trabajos independientes se ejecuten a la vez. Deja de reconstruir el estado en cada trabajo: cachés que acierten de verdad, o un ejecutor que conserve su disco. Dale más núcleos a los pasos limitados por la CPU y deja que el ejecutor de pruebas los use. Fragmenta solo lo que siga siendo largo. En el ubuntu-latest de un repositorio privado (2 CPU, 8 GB), las tres últimas suelen ser la mayor parte de los 25 minutos, y son cosa de la máquina: Skipbox le da al trabajo una máquina dedicada, que conserva las cachés entre trabajos, con de 4 a 16 vCPU.

¿Vale la pena pasar a ejecutores más rápidos en lugar de optimizar el flujo de trabajo?

Haz primero los arreglos gratuitos del flujo de trabajo: cancelar las ejecuciones reemplazadas, los filtros de rutas y quitar los needs: innecesarios no cuestan nada y ningún ejecutor los hace por ti. Después, mira a dónde va el tiempo que queda. La preparación que se repite en cada trabajo (cadenas de herramientas, instalación de dependencias, compilaciones de Docker) y los pasos que mantienen ocupados todos los núcleos son problema de la máquina, y un ejecutor que conserva sus cachés y tiene más núcleos los elimina con un cambio de una línea en runs-on. Las esperas de red y los pasos en serie no se aceleran con una máquina más grande.

¿Por qué GitHub Actions es más lento que mi laptop?

Tu laptop conserva en el disco sus paquetes, herramientas, capas de Docker y salida de compilación, y normalmente tiene 8 núcleos o más. Un trabajo en el ubuntu-latest de un repositorio privado recibe 2 CPU y 8 GB, en una VM nueva que no tiene nada de eso. Skipbox funciona como tu laptop: la máquina se queda entre trabajos, con 4 vCPU o más.

¿Fragmentar las pruebas hace más rápido GitHub Actions?

Acorta el tiempo de reloj, no los minutos. Cada fragmento es un trabajo nuevo que vuelve a hacer checkout, instalar y compilar, así que cuatro fragmentos pagan la preparación cuatro veces, y la facturación por minuto cuenta cada una. Fragmenta cuando la preparación ya sea barata y los núcleos del ejecutor estén en uso. En Skipbox la preparación se queda en el disco y los minutos son ilimitados, así que los fragmentos no cuestan nada extra.

¿Cómo consigo más de 4 núcleos para un trabajo de GitHub Actions?

En GitHub, los ejecutores más grandes van de 4 a 96 núcleos, solo para organizaciones con GitHub Team o Enterprise Cloud, y se cobran por minuto. En Skipbox, cambia runs-on a skipbox-8x16 para 8 vCPU o a skipbox-16x32 para 16 vCPU, a un precio mensual fijo, tanto en organizaciones como en cuentas personales.

¿Cuánto cuesta probarlo?

Nada. La prueba dura 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Cambia el runs-on de tu trabajo más lento a skipbox, ejecútalo dos veces y compara los tiempos de sus pasos.

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