# Een pnpm- en Turborepo-monorepo versnellen in GitHub Actions (astro: van 528 s naar 30 s)

> In een monorepo met pnpm en Turborepo op GitHub Actions gaat de meeste tijd naar pnpm install op een nieuwe VM en naar turbo dat taken draait waarvan de resultaten er niet op staan. Draai alleen geraakte packages, geef turbo een cache, en bewaar de pnpm-store. Of draai op een machine die beide bewaart: de CI van astro ging van 528 s op GitHub naar 30 s op Skipbox, voor een vaste $39 per maand.

In een monorepo met pnpm en Turborepo op GitHub Actions bestaat het grootste deel van een trage job uit twee steps: `pnpm install` op een nieuwe VM, en `turbo run build test` dat taken draait waarvan de VM de resultaten niet heeft. Los ze in deze volgorde op. Draai alleen de packages die een wijziging raakt (`turbo run build --affected`, met een checkout die geschiedenis heeft). Geef turbo een cache die de job overleeft, want zijn resultaten staan in `.turbo/cache` op een machine die GitHub na elke job verwijdert: Remote Caching, of `.turbo` teruggezet met `actions/cache`. En bewaar de pnpm-store. Op de runners van GitHub is elk van die caches bij elke job een download. Op een machine die zijn schijf bewaart, staan ze er gewoon: de CI-job van astro duurde 528 s op GitHub en 30 s op een dedicated machine van Skipbox, die alle 40 buildtaken afspeelde vanuit de bewaarde cache van turbo.

Skipbox draait je jobs op de dedicated machine van je account, die de pnpm-store, de tools en de `.turbo` van de checkout tussen jobs bewaart, zonder remote cache en zonder cachekeys. Wijzig één regel, `runs-on: skipbox`, voor een vaste $39 per maand met onbeperkte minuten.

- De CI van astro: 528 s op GitHub, 30 s op Skipbox, met turbo dat 40 buildtaken en de testtaak afspeelt
- De pnpm-store en de `.turbo` van turbo blijven op je machine: geen remote cache om in te richten, geen archief om te downloaden
- 20.000 minuten per maand op 4 vCPU: $222 op GitHub, $39 op Skipbox

**GitHub Actions voor een vaste prijs, onbeperkte minuten** Skipbox draait je GitHub Actions-jobs op je eigen dedicated machine: $39 per maand, hoeveel minuten je ook draait. Docker-layers en dependencycaches blijven tussen jobs bewaard, dus de volgende job start meteen.

Een runner met 4 vCPU, 20.000 minuten per maand: GitHub $222 → Skipbox $39. Je bespaart elke maand $183.

Overstappen kost één regel: `runs-on: skipbox`.

[Gratis 7-daagse proefperiode starten](https://app.skipbox.dev/sign-in?ref=g-pnpm-turborepo-monorepo-github-actions-nl)

## Waar een monorepo-job zijn tijd aan besteedt

| Step | Op een nieuwe VM van GitHub |
|---|---|
| Checkout | Standaard een shallow clone; `--affected` heeft geschiedenis nodig, dus een volledige |
| Node en pnpm instellen | Gedownload, tenzij de toolcache de versie heeft |
| `pnpm install` | Store teruggezet uit het cachearchief (of gedownload van de registry), daarna `node_modules` gelinkt voor elk package |
| `turbo run build` | Elke taak draait, tenzij `.turbo/cache` is teruggezet of een remote cache antwoordt |
| `turbo run test` | Hetzelfde, op 2 CPU's op `ubuntu-latest` van een privé-repository |

## 1. Draai alleen wat is gewijzigd

Uit de [CI-gids van Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci): `turbo run build --affected` draait alleen taken in packages die zijn gewijzigd ten opzichte van de basisbranch. In GitHub Actions leest het `GITHUB_BASE_REF` bij pull requests en `GITHUB_EVENT_PATH` bij pushes. Met een shallow clone telt elk package als gewijzigd, dus check de geschiedenis uit:

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

`turbo query affected --packages web` vertelt een job of hij überhaupt moet draaien, zodat een job voor een ongewijzigde app zijn installatie kan overslaan.

## 2. Geef turbo een cache die de job overleeft

Turborepo bewaart taakresultaten in `.turbo/cache` [op de machine](https://turborepo.dev/docs/crafting-your-repository/caching). De machine van een door GitHub gehoste job wordt verwijderd als die eindigt, dus in CI begint die cache elke keer leeg. Twee manieren om dat te omzeilen, uit de [GitHub Actions-gids van Turborepo](https://turborepo.dev/docs/guides/ci-vendors/github-actions):

- **Remote Caching.** Stel `TURBO_TOKEN` en `TURBO_TEAM` in (Vercel Remote Cache, of een eigen server). Elke hit is een download daarvandaan.
- **`actions/cache` op `.turbo`.** Gebruik als key `${{ runner.os }}-turbo-${{ github.sha }}` met `restore-keys: ${{ runner.os }}-turbo-`. Het slaat bij elke run een nieuw item op, binnen de 10 GB per repository van GitHub, samen met al het andere dat de repository cachet.

## 3. Bewaar de pnpm-store

`actions/setup-node` met `cache: pnpm`, of `actions/cache` op `pnpm store path`, zet de store terug met een key op `pnpm-lock.yaml`. Het zet `node_modules` niet terug, dus pnpm linkt nog steeds elk package. De [CI-documentatie van pnpm](https://pnpm.io/continuous-integration) zegt het duidelijk: het cachen van de store maakt de installatie niet gegarandeerd sneller. In CI schakelt pnpm zelf over op `--frozen-lockfile`.

## 4. Gebruik de cores

turbo draait onafhankelijke taken parallel en elke build- of testtool start zijn eigen workers, dus een monorepo gebruikt elke core die hij krijgt. `ubuntu-latest` van een privé-repository heeft er 2.

## Wat elke fix kost op de runners van GitHub

- **Remote Caching** is nog een dienst en nog een token, en elke cache hit gaat over het netwerk.
- **`actions/cache` voor `.turbo`** schrijft bij elke run een item en concurreert om dezelfde 10 GB als de pnpm-store, de layers van Docker en de caches van elke branch; items die 7 dagen ongebruikt zijn, verdwijnen.
- **Een grotere runner** is een larger runner op GitHub Team of Enterprise Cloud, gerekend per minuut.

## Wanneer de oplossing een machine is die zijn schijf bewaart

De eigen CI van astro, met ongewijzigde workflow, uit [onze runs van echte projecten](https://skipbox.dev/nl/guides/rust-cache-slow-rust-ci):

| | GitHub (openbare repository, 4 vCPU, 16 GB) | Dedicated machine van Skipbox (4 vCPU) |
|---|---|---|
| Job | 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)) |
| Buildtaken | 40 gedraaid | 40 afgespeeld vanuit de cache van turbo |
| Testtaak | draait | afgespeeld vanuit de cache van turbo |

De dedicated machine bewaarde de `.turbo` van de checkout en de pnpm-store van de vorige job, dus turbo vond het resultaat van elke taak zonder iets te downloaden. turbo speelt een taak alleen af als de hash van zijn invoer gelijk is, dus een echte commit draait de packages die hij raakt opnieuw en speelt de rest af.

## Skipbox bewaart de toestand van de monorepo

Elk abonnement komt met de dedicated machine van je account, die tussen jobs bewaard blijft:

- **De pnpm-store blijft** in `~/.local/share/pnpm/store`, met de cache van npm en de `~/.cache` van elke tool. `pnpm install` linkt vanaf de schijf in plaats van te downloaden.
- **De cache van turbo blijft.** De `.turbo` op het hoogste niveau van de checkout blijft tussen jobs bewaard als `turbo.json` die van turbo 2 is: een `tasks`-key, geen `pipeline`, en geen `"envMode": "loose"`. Geen `TURBO_TOKEN`, geen cachestep.
- **`node_modules` wordt na elke job verwijderd**, zodat een matrix van Node-versies die één checkout deelt nooit een native addon laadt die voor een andere Node is gebouwd.
- **De tools blijven:** de Node-versies die `setup-node` installeerde, pnpm zelf, de images en layers van Docker.

Minstens 7× de cacheruimte van GitHub op S. Een job kiest zijn grootte met zijn label:

| Label | Machine | Abonnement |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 per maand |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 per maand |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 per maand |

De minuten zijn onbeperkt. Bij 20.000 minuten per maand op 4 vCPU rekent GitHub $222; Skipbox S is $39, $183 minder.

## Overstappen kost één regel

```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. Log in bij Skipbox met GitHub.
2. Installeer de GitHub-app van Skipbox en kies de repository's.
3. Wijzig `runs-on` en push.

Laat de cachesteps zoals ze zijn; wat ze opslaan, blijft naast de machine.

## Beveiliging

- De machine is alleen van je account. Er draaien geen jobs van een ander bedrijf op.
- Na elke job worden de credentials, processen en containers van de runner gewist, en ook de git-credentials, hooks en niet-gevolgde bestanden in de bewaarde checkout. Met Schone VM per job krijgt elke job in plaats daarvan een nieuwe machine.
- Code van mensen zonder schrijfrechten (zoals pull requests vanuit forks) draait op een nieuwe VM die je caches leest maar niet kan wijzigen.

De details staan in [zo worden jobs geïsoleerd](https://docs.skipbox.dev/nl/isolation).

## Probeer het op de monorepo

De proefperiode is gratis voor 7 dagen of 3.000 jobminuten, wat het eerst komt, en er is geen kaart voor nodig. Zet de buildjob op `runs-on: skipbox`, draai hem twee keer, en leg de install- en turbo-regels van de tweede run (`cached` tegenover `executing`) naast die van GitHub.

## Veelgestelde vragen

### Hoe versnel ik een grote pnpm/Turborepo-monorepo in GitHub Actions?

Drie dingen, in deze volgorde. Draai alleen wat is gewijzigd: turbo run build --affected, met een checkout die geschiedenis heeft (fetch-depth: 0 en filter: blob:none). Geef turbo een cache die de job overleeft: de Remote Cache van Turborepo, of .turbo teruggezet met actions/cache. En bewaar de pnpm-store: cache: pnpm van setup-node of actions/cache op het pad van de store. Op de nieuwe VM's van GitHub is elk daarvan bij elke job een download; op een machine die zijn schijf bewaart, staan ze er al. De CI van astro duurde 528 s op GitHub en 30 s op een dedicated machine van Skipbox die de cache van turbo en de pnpm-store bewaart.

### Waarom is pnpm install traag in GitHub Actions, zelfs met de store in de cache?

Omdat een teruggezette store nog steeds een archief is dat op een nieuwe VM wordt gedownload en uitgepakt, waarna pnpm node_modules linkt voor elk package van de workspace. Volgens de eigen CI-documentatie van pnpm maakt het cachen van de store de installatie niet gegarandeerd sneller. Een store die al op de schijf van de machine staat, slaat de download over; alleen het linken blijft over.

### Werkt de cache van Turborepo in GitHub Actions?

Alleen als de cache de job overleeft. Turborepo bewaart taakresultaten in .turbo/cache op de machine, en de machine van een door GitHub gehoste job is weg als die eindigt. CI heeft dus Remote Caching nodig (TURBO_TOKEN en TURBO_TEAM, die van Vercel of een eigen server) of een actions/cache-step voor .turbo. Op een dedicated machine van Skipbox blijft de .turbo van de checkout tussen jobs staan voor turbo 2-projecten, dus turbo speelt ongewijzigde taken af zonder remote cache.

### Werkt turbo --affected in GitHub Actions?

Ja. Turborepo leest GITHUB_BASE_REF bij pull requests, en GITHUB_EVENT_PATH bij pushes, om de basis te vinden om mee te vergelijken. Het heeft de geschiedenis nodig: met een shallow clone telt elk package als gewijzigd. Stel fetch-depth: 0 en filter: blob:none in op actions/checkout.

### Wat bewaart Skipbox voor een Turborepo-monorepo?

De pnpm-store, de caches van npm en van elke tool, de tools die setup-node installeert, de layers van Docker, en de checkout met zijn .turbo op het hoogste niveau als turbo.json die van turbo 2 is (een tasks-key, geen pipeline, niet envMode loose). node_modules wordt na elke job verwijderd, dus install draait, vanuit de store op de schijf. turbo speelt een taak alleen af als de hash van zijn invoer gelijk is, dus een commit draait opnieuw wat hij raakt.

### Hoeveel kost het om te proberen?

Niets. De proefperiode is 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart. Zet de buildjob van de monorepo op runs-on: skipbox, draai hem twee keer, en vergelijk de install- en turbo-steps van de tweede run met die van GitHub.

Bijgewerkt op 2026-11-19 · https://skipbox.dev/nl/guides/pnpm-turborepo-monorepo-github-actions
