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

> Un pipeline lento de GitHub Actions son trabajos que se esperan entre sí, trabajo que no hacía falta ejecutar, preparación repetida en una VM vacía y pasos limitados por la CPU en 2 núcleos. Arréglalos en ese orden. Los dos últimos son la máquina: Skipbox conserva tus cachés en tu máquina dedicada entre trabajos, con hasta 16 vCPU, por $39 fijos al mes con minutos ilimitados.

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`.

- Las palancas por orden: medir, saltar, ejecutar en paralelo, dejar de reconstruir, sumar núcleos, fragmentar
- Tu máquina dedicada conserva las cachés y la salida de compilación entre trabajos: la CI de astro pasó de 528 s a 30 s
- 20.000 minutos al mes en 4 vCPU: $222 en GitHub, $39 en Skipbox

**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-speed-up-github-actions-es)

## 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:

| Fase | Qué revisar |
|---|---|
| En cola | ¿El trabajo esperó a un ejecutor? Un comando más rápido no acorta una cola |
| Set up job, checkout | Una imagen de contenedor descargada, un clon completo donde bastaría uno superficial |
| Cadena de herramientas e instalación | ¿Acertó la caché, y el acierto ahorró más de lo que tardó la restauración? |
| Compilación | ¿Se compila lo mismo en otro trabajo? |
| Pruebas | ¿La CPU del ejecutor está ocupada todo el tiempo, o hay un solo worker haciéndolo todo? |
| Subidas | Artefactos y guardados de caché después de que termina el trabajo útil |

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](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) con `cancel-in-progress` la detiene. Limítalo a los pull requests para que un push a la rama predeterminada nunca cancele un despliegue:

```yaml
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é](https://skipbox.dev/es/guides/github-actions-cache-size-limit)).
- **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](https://skipbox.dev/es/guides/docker-layer-cache-github-actions)).

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](https://jestjs.io/docs/cli#--maxworkersnumstring) usa por defecto los núcleos menos uno (un worker en 2 CPU), pytest se ejecuta en serie hasta `-n auto`, y [Playwright](https://playwright.dev/docs/ci#workers) 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](https://docs.github.com/en/actions/concepts/runners/larger-runners): 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:

| Minutos al mes (4 vCPU) | GitHub | Skipbox S | Lo que ahorras cada mes |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

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

| 20.000 minutos al mes | GitHub | Skipbox | Lo que ahorras cada mes |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | **$343** |
| 16 vCPU | $822 | $149 (L) | **$673** |

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](https://skipbox.dev/?ref=g-speed-up-github-actions-es#cost).

## 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](https://skipbox.dev/es/guides/rust-cache-slow-rust-ci):

| Proyecto | GitHub | Skipbox, máquina dedicada | Lo que conservó la máquina |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | **30 s** | La caché de turbo: 40 tareas de compilación reproducidas |
| tauri (Rust) | 246 s | **53 s** | El `target/` de Cargo: ningún crate se volvió a compilar |
| ripgrep (Rust) | 200 s | **40 s** | El `target/` y la imagen de Docker de cross |
| vite (Node.js) | 141 s | 100 s | Las cachés de paquetes; el resto es la ejecución de sus pruebas |

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:

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

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

```yaml
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](https://docs.skipbox.dev/es/isolation).

## 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 2026-11-19 · https://skipbox.dev/es/guides/speed-up-github-actions
