# Acelera un monorepo de pnpm y Turborepo en GitHub Actions (astro: de 528 s a 30 s)

> En un monorepo de pnpm y Turborepo en GitHub Actions, la mayor parte del tiempo es pnpm install en una VM nueva y turbo ejecutando tareas cuyos resultados no están en ella. Ejecuta solo los paquetes afectados, dale a turbo una caché y conserva el store de pnpm. O ejecútalo en una máquina que conserve las dos cosas: la CI de astro pasó de 528 s en GitHub a 30 s en Skipbox, por $39 fijos al mes.

En un monorepo de pnpm y Turborepo en GitHub Actions, la mayor parte de un trabajo lento son dos pasos: `pnpm install` en una VM nueva, y `turbo run build test` ejecutando tareas cuyos resultados la VM no tiene. Arréglalos en este orden. Ejecuta solo los paquetes que toca un cambio (`turbo run build --affected`, con un checkout que tenga historial). Dale a turbo una caché que sobreviva al trabajo, porque sus resultados viven en `.turbo/cache` en una máquina que GitHub borra después de cada trabajo: Remote Caching, o `.turbo` restaurado con `actions/cache`. Y conserva el store de pnpm. En los ejecutores de GitHub, cada una de esas cachés es una descarga en cada trabajo. En una máquina que conserva su disco simplemente están ahí: el trabajo de CI de astro tardaba 528 s en GitHub y 30 s en una máquina dedicada de Skipbox, que reprodujo las 40 tareas de compilación desde la caché conservada de turbo.

Skipbox ejecuta tus trabajos en la máquina dedicada de tu cuenta, que conserva el store de pnpm, las herramientas y el `.turbo` del checkout entre trabajos, sin caché remota y sin claves de caché. Cambia una línea, `runs-on: skipbox`, por $39 fijos al mes con minutos ilimitados.

- La CI de astro: 528 s en GitHub, 30 s en Skipbox, con turbo reproduciendo 40 tareas de compilación y la tarea de pruebas
- El store de pnpm y el `.turbo` de turbo se quedan en tu máquina: ninguna caché remota que configurar, ningún archivo que descargar
- 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-pnpm-turborepo-monorepo-github-actions-es)

## En qué gasta su tiempo un trabajo de monorepo

| Paso | En una VM nueva de GitHub |
|---|---|
| Checkout | Un clon superficial por defecto; `--affected` necesita historial, así que uno completo |
| Configurar Node y pnpm | Se descargan, salvo que la caché de herramientas tenga la versión |
| `pnpm install` | El store se restaura desde el archivo de caché (o se descarga del registro), y luego se enlaza `node_modules` para cada paquete |
| `turbo run build` | Se ejecutan todas las tareas, salvo que se haya restaurado `.turbo/cache` o responda una caché remota |
| `turbo run test` | Lo mismo, en 2 CPU en el `ubuntu-latest` de un repositorio privado |

## 1. Ejecuta solo lo que cambió

Según la [guía de CI de Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci): `turbo run build --affected` ejecuta tareas solo en los paquetes que cambiaron respecto a la rama base. En GitHub Actions lee `GITHUB_BASE_REF` en los pull requests y `GITHUB_EVENT_PATH` en los push. Con un clon superficial todos los paquetes cuentan como cambiados, así que haz checkout del historial:

```yaml
- uses: actions/checkout@v4
  with:
    fetch-depth: 0
    filter: blob:none
```

`turbo query affected --packages web` le dice a un trabajo si debe ejecutarse siquiera, así que el trabajo de una app que no se tocó puede saltarse su instalación.

## 2. Dale a turbo una caché que sobreviva al trabajo

Turborepo guarda los resultados de las tareas en `.turbo/cache` [en la máquina](https://turborepo.dev/docs/crafting-your-repository/caching). La máquina de un trabajo hospedado en GitHub se borra cuando termina, así que en la CI esa caché empieza vacía cada vez. Dos formas de esquivarlo, según la [guía de GitHub Actions de Turborepo](https://turborepo.dev/docs/guides/ci-vendors/github-actions):

- **Remote Caching.** Configura `TURBO_TOKEN` y `TURBO_TEAM` (Vercel Remote Cache, o un servidor autohospedado). Cada acierto es una descarga desde él.
- **`actions/cache` sobre `.turbo`.** Usa la clave `${{ runner.os }}-turbo-${{ github.sha }}` con `restore-keys: ${{ runner.os }}-turbo-`. Guarda una entrada nueva en cada ejecución, dentro de los 10 GB por repositorio de GitHub junto con todo lo demás que guarda en caché el repositorio.

## 3. Conserva el store de pnpm

`actions/setup-node` con `cache: pnpm`, o `actions/cache` sobre `pnpm store path`, restaura el store con una clave basada en `pnpm-lock.yaml`. No restaura `node_modules`, así que pnpm sigue enlazando cada paquete. La [documentación de CI de pnpm](https://pnpm.io/continuous-integration) lo dice claramente: guardar el store en caché no garantiza (“is not guaranteed”) que la instalación sea más rápida. En la CI, pnpm pasa a `--frozen-lockfile` por sí solo.

## 4. Usa los núcleos

turbo ejecuta en paralelo las tareas independientes y cada herramienta de compilación o de pruebas inicia sus propios workers, así que un monorepo usa todos los núcleos que recibe. El `ubuntu-latest` de un repositorio privado tiene 2.

## Lo que cuesta cada solución en los ejecutores de GitHub

- **Remote Caching** es otro servicio y otro token, y cada acierto de caché cruza la red.
- **`actions/cache` para `.turbo`** escribe una entrada en cada ejecución y compite por los mismos 10 GB que el store de pnpm, las capas de Docker y las cachés de todas las ramas; las entradas sin usar durante 7 días se eliminan.
- **Un ejecutor más grande** es un ejecutor más grande en GitHub Team o Enterprise Cloud, que se cobra por minuto.

## Cuando la solución es una máquina que conserva su disco

La propia CI de astro, con su flujo de trabajo sin cambios, según [nuestras ejecuciones de proyectos reales](https://skipbox.dev/es/guides/rust-cache-slow-rust-ci):

| | GitHub (repositorio público, 4 vCPU, 16 GB) | Máquina dedicada de Skipbox (4 vCPU) |
|---|---|---|
| Trabajo | 528 s | **30 s** ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)) |
| Tareas de compilación | 40 ejecutadas | 40 reproducidas desde la caché de turbo |
| Tarea de pruebas | se ejecuta | reproducida desde la caché de turbo |

La máquina dedicada conservaba el `.turbo` del checkout y el store de pnpm del último trabajo, así que turbo encontró el resultado de cada tarea sin nada que descargar. turbo reproduce una tarea solo cuando el hash de sus entradas es el mismo, así que un commit real vuelve a ejecutar los paquetes que toca y reproduce el resto.

## Skipbox conserva el estado del monorepo

Cada plan trae la máquina dedicada de tu cuenta, que se mantiene entre trabajos:

- **El store de pnpm se queda** en `~/.local/share/pnpm/store`, con la caché de npm y el `~/.cache` de cada herramienta. `pnpm install` enlaza desde el disco en lugar de descargar.
- **La caché de turbo se queda.** El `.turbo` de nivel superior del checkout se conserva entre trabajos cuando `turbo.json` es de turbo 2: una clave `tasks`, sin `pipeline` y sin `"envMode": "loose"`. Sin `TURBO_TOKEN`, sin paso de caché.
- **`node_modules` se borra después de cada trabajo**, así que una matriz de versiones de Node que comparte un checkout nunca carga un addon nativo compilado para otra versión de Node.
- **Las herramientas se quedan:** las versiones de Node que instaló `setup-node`, el propio pnpm, las imágenes y capas de Docker.

Al menos 7× el espacio de caché de GitHub en S. 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. Con 20.000 minutos al mes en 4 vCPU, GitHub cobra $222; Skipbox S cuesta $39, $183 menos.

## Pasarte es una línea

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          filter: blob:none
      - uses: pnpm/action-setup@v3
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install
      - run: pnpm turbo run build test --affected
```

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.

Deja los pasos de caché como están; lo que guardan se queda junto a la máquina.

## 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, los hooks 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 el monorepo

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 compilación a `runs-on: skipbox`, ejecútalo dos veces y pon las líneas de instalación y de turbo de la segunda ejecución (`cached` frente a `executing`) junto a las de GitHub.

## Preguntas frecuentes

### ¿Cómo acelero un monorepo grande de pnpm/Turborepo en GitHub Actions?

Tres cosas, por orden. Ejecuta solo lo que cambió: turbo run build --affected, con un checkout que tenga historial (fetch-depth: 0 y filter: blob:none). Dale a turbo una caché que sobreviva al trabajo: el Remote Cache de Turborepo, o .turbo restaurado con actions/cache. Y conserva el store de pnpm: el cache: pnpm de setup-node o actions/cache sobre la ruta del store. En las VM nuevas de GitHub, cada una de esas cosas es una descarga en cada trabajo; en una máquina que conserva su disco ya están ahí. La CI de astro tardaba 528 s en GitHub y 30 s en una máquina dedicada de Skipbox que conserva la caché de turbo y el store de pnpm.

### ¿Por qué pnpm install es lento en GitHub Actions incluso con el store en caché?

Porque un store restaurado sigue siendo un archivo que se descarga y se descomprime en una VM nueva, y luego pnpm enlaza node_modules para cada paquete del workspace. La propia documentación de CI de pnpm dice que guardar el store en caché no garantiza que la instalación sea más rápida. Un store que ya está en el disco de la máquina se salta la descarga; solo queda el enlazado.

### ¿La caché de Turborepo funciona en GitHub Actions?

Solo si la caché sobrevive al trabajo. Turborepo guarda los resultados de las tareas en .turbo/cache en la máquina, y la máquina de un trabajo hospedado en GitHub desaparece cuando termina. Así que la CI necesita Remote Caching (TURBO_TOKEN y TURBO_TEAM, el de Vercel o uno autohospedado) o un paso de actions/cache para .turbo. En una máquina dedicada de Skipbox, el .turbo del checkout se queda entre trabajos en los proyectos con turbo 2, así que turbo reproduce las tareas sin cambios sin ninguna caché remota.

### ¿turbo --affected funciona en GitHub Actions?

Sí. Turborepo lee GITHUB_BASE_REF en los pull requests, y GITHUB_EVENT_PATH en los push, para encontrar la base con la que comparar. Necesita el historial: con un clon superficial, todos los paquetes cuentan como cambiados. Configura fetch-depth: 0 y filter: blob:none en actions/checkout.

### ¿Qué conserva Skipbox para un monorepo de Turborepo?

El store de pnpm, las cachés de npm y de cada herramienta, las herramientas que instala setup-node, las capas de Docker y el checkout con su .turbo de nivel superior cuando turbo.json es de turbo 2 (una clave tasks, sin pipeline, y sin envMode loose). node_modules se borra después de cada trabajo, así que la instalación se ejecuta, desde el store en el disco. turbo reproduce una tarea solo cuando el hash de sus entradas es el mismo, así que un commit vuelve a ejecutar lo que toca.

### ¿Cuánto cuesta probarlo?

Nada. La prueba dura 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Pasa el trabajo de compilación del monorepo a runs-on: skipbox, ejecútalo dos veces y compara los pasos de instalación y de turbo de la segunda ejecución con los de GitHub.

Actualizado el 2026-11-19 · https://skipbox.dev/es/guides/pnpm-turborepo-monorepo-github-actions
