# Next.js-build traag of zonder geheugen in GitHub Actions: cache, geheugen, runnergrootte

> Een Next.js-build in GitHub Actions is traag als .next/cache niet naar de volgende run wordt meegenomen, en raakt zonder geheugen op de 8 GB van ubuntu-latest van een privé-repository zodra webpack, typecontrole en source maps optellen. Wat je cachet, welke instellingen van Next.js geheugen besparen, en de runnergrootte: 16 GB voor $79 per maand of 32 GB voor $149 op Skipbox, waar .next/cache tussen jobs blijft staan en minuten onbeperkt zijn.

Een Next.js-build in GitHub Actions is om één reden traag en raakt om een andere reden zonder geheugen. Hij is traag als `.next/cache` niet naar de volgende run wordt meegenomen: Next.js hergebruikt die cache tussen builds, een door GitHub gehoste job start op een nieuwe VM, en zonder cachestep is elke build koud (het log zegt `No Cache Detected`). Hij raakt zonder geheugen omdat `ubuntu-latest` van een privé-repository 8 GB heeft, en het compileren met webpack, de typecontrole en de source maps van een grote app kunnen daaroverheen gaan. Los het eerste op met `actions/cache` op `.next/cache`. Voor het tweede komen eerst de geheugeninstellingen van Next.js (`experimental.webpackMemoryOptimizations`, geen source maps in productie); daarna een machine met meer geheugen: 16 GB of 32 GB.

Skipbox geeft de build dat geheugen voor een vaste prijs: 16 GB en 8 vCPU op `runs-on: skipbox-8x16` voor $79 per maand, 32 GB en 16 vCPU op `skipbox-16x32` voor $149. Op je dedicated machine blijft `.next/cache` staan voor de volgende build, blijven de packagecaches op de schijf en wordt wat `actions/cache` opslaat lokaal gelezen, met onbeperkte minuten.

- `.next/cache` blijft op je dedicated machine: de volgende build hergebruikt zijn laatste compilatie, zonder cachestep
- 16 GB voor $79 per maand of 32 GB voor $149, tegenover 8 GB op een privé-`ubuntu-latest`
- Packagecaches blijven op je machine, en cache-restores lezen de schijf in plaats van te downloaden

**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-nextjs-build-slow-out-of-memory-github-actions-nl)

## Traag: .next/cache begint leeg

Uit de [gids voor CI-buildcaching](https://nextjs.org/docs/app/guides/ci-build-caching) van Next.js (in het Engels): Next.js slaat in `.next/cache` een cache op die tussen builds wordt gedeeld, en een CI die hem niet tussen builds bewaart, toont de fout `No Cache Detected`. De step voor GitHub Actions:

```yaml
- uses: actions/cache@v4
  with:
    path: |
      ~/.npm
      ${{ github.workspace }}/.next/cache
    key: ${{ runner.os }}-nextjs-${{ hashFiles('**/package-lock.json') }}-${{ hashFiles('**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx') }}
    restore-keys: |
      ${{ runner.os }}-nextjs-${{ hashFiles('**/package-lock.json') }}-
```

De key verandert bij elke wijziging in de broncode, dus elke run slaat een nieuw item op, binnen de 10 GB per repository van GitHub. Sluit in een Turborepo `.next/cache` uit van de `outputs` van de taak (`"!.next/cache/**"`), zoals de [GitHub Actions-gids van Turborepo](https://turborepo.dev/docs/guides/ci-vendors/github-actions) doet.

## Zonder geheugen: twee verschillende fouten

| In het log | Wat er op was | Wat je doet |
|---|---|---|
| `JavaScript heap out of memory` | De eigen heaplimiet van Node; de machine had nog geheugen | Verhoog hem: `NODE_OPTIONS=--max-old-space-size=6144`, onder het geheugen van de machine |
| `Process completed with exit code 137` | Het geheugen van de machine: Linux stopte het proces | Gebruik minder geheugen, of een machine met meer |

De heap boven het geheugen van de machine verhogen, maakt van de eerste fout de tweede.

## Gebruik minder geheugen: de eigen instellingen van Next.js

Uit de [gids over geheugengebruik](https://nextjs.org/docs/app/guides/memory-usage) van Next.js:

- **`experimental.webpackMemoryOptimizations: true`** (v15.0.0 en later) verlaagt het piekgeheugen van webpack, met een iets langere compilatie.
- **De webpack-buildworker** draait de compilatie in een aparte Node-worker, wat geheugen bespaart. Hij staat sinds v14.1.0 standaard aan, tenzij je een eigen webpack-config hebt; heb je die, stel dan `experimental.webpackBuildWorker: true` in.
- **Source maps uit:** `productionBrowserSourceMaps: false` en `experimental.serverSourceMaps: false`. Raakt de build zonder geheugen tijdens "Generating static pages", dan ook `enablePrerenderSourceMaps: false`.
- **Meten:** `next build --experimental-debug-memory-usage` (v14.2.0 en later) toont het heapgebruik tijdens de build, en maakt heapsnapshots vlak bij de limiet.
- **Typecontrole:** `typescript.ignoreBuildErrors: true` slaat de typecontrole en zijn geheugen over, en laat typefouten de build in. Next.js raadt het af, tenzij een andere step de types controleert.

## Gebruik een machine met meer geheugen

| Runner | CPU en geheugen | Wie hem kan gebruiken |
|---|---|---|
| GitHub `ubuntu-latest`, privé-repository | 2 CPU's, 8 GB | Iedereen |
| GitHub `ubuntu-latest`, openbare repository | 4 CPU's, 16 GB | Openbare repository's |
| Larger runner van GitHub, 4 of 8 cores | 16 GB of 32 GB | Organisaties op GitHub Team en Enterprise Cloud, per minuut ([larger runners](https://docs.github.com/en/actions/concepts/runners/larger-runners)) |
| Skipbox `skipbox-8x16` | 8 vCPU, 16 GB | Organisaties en persoonlijke accounts, $79 per maand |
| Skipbox `skipbox-16x32` | 16 vCPU, 32 GB | Organisaties en persoonlijke accounts, $149 per maand |

Bij 20.000 minuten per maand kost de 8-core runner van GitHub $422 en Skipbox M $79; bij 16 cores $822 tegenover $149 voor L. De bedragen van GitHub zijn na het inbegrepen gebruik van GitHub Team.

## Wat Skipbox voor een Next.js-build doet

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

- **Het geheugen dat de build nodig heeft**, per label: 16 GB op M, 32 GB op L. Stel de heap daarop af, zoals `--max-old-space-size=12288` op M.
- **Packagecaches blijven op de schijf:** `~/.npm`, de pnpm-store, de `~/.cache` van elke tool, en de Node-versies die `setup-node` installeerde. `npm ci` leest ze in plaats van de registry.
- **`.next/cache` blijft staan voor de volgende job.** De machine bewaart je checkout tussen jobs, en `.next/cache` daarin, op elke diepte waar een monorepo hem neerzet (`apps/web/.next/cache`). De volgende `next build` start daarvandaan, zonder cachestep en zonder `No Cache Detected`. De rest van `.next` en de andere niet-gevolgde bestanden van de checkout worden na elke job opgeruimd.
- **Restores van `actions/cache` lezen de machine.** Wat hij opslaat, blijft naast de machine, met meer ruimte dan de 10 GB per repository van GitHub, en terugzetten is lokaal lezen. Houd de step voor `.next/cache` voor jobs die op een nieuwe VM draaien; op je dedicated machine laat het terugzetten de bewaarde cache zoals hij is.
- **Meer cores voor een vaste prijs.** Het compileren en het genereren van statische pagina's gebruiken ze, en de minuten zijn onbeperkt.

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

## Overstappen kost één regel

```yaml
jobs:
  build:
    runs-on: skipbox-8x16 # was ubuntu-latest
    env:
      NODE_OPTIONS: --max-old-space-size=12288
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - uses: actions/cache@v4
        with:
          path: ${{ github.workspace }}/.next/cache
          key: ${{ runner.os }}-nextjs-${{ hashFiles('**/package-lock.json') }}-${{ hashFiles('**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx') }}
          restore-keys: |
            ${{ runner.os }}-nextjs-${{ hashFiles('**/package-lock.json') }}-
      - run: npm ci
      - run: npx next build
```

`skipbox-8x16` draait op een M-abonnement; de proefperiode draait `runs-on: skipbox`.

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.

## 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 in de bewaarde checkout en de niet-gevolgde bestanden ervan, behalve buildcaches zoals `.next/cache`. 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 Next.js-build

De proefperiode is gratis voor 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart. Hij draait `runs-on: skipbox`, met 16 GB, 2× het geheugen van `ubuntu-latest` van een privé-repository: probeer daar de cache en het geheugen, en verhuis een build die meer nodig heeft naar abonnement L (`skipbox-16x32`, 32 GB).

## Veelgestelde vragen

### Waarom is next build traag in GitHub Actions?

Meestal omdat .next/cache leeg begint. Next.js slaat een buildcache op in .next/cache en hergebruikt die bij de volgende build, maar een door GitHub gehoste job is een nieuwe VM, dus zonder step die .next/cache meeneemt, is elke build een koude build en waarschuwt het log met No Cache Detected. Voeg actions/cache toe voor .next/cache, met een key op de lockfile en je bronbestanden. De rest van de tijd gaat naar de installatie en het compileren op 2 CPU's.

### Welke runnergrootte moet een Next.js-build in GitHub Actions gebruiken?

Genoeg geheugen voor de piek van de build. ubuntu-latest van een privé-repository heeft 2 CPU's en 8 GB, en de webpack-build, typecontrole en source maps van een grote Next.js-app kunnen daaroverheen gaan. De larger runners van GitHub hebben 16 GB bij 4 cores en 32 GB bij 8, alleen op GitHub Team of Enterprise Cloud, per minuut. Skipbox geeft 16 GB met 8 vCPU op runs-on: skipbox-8x16 voor $79 per maand, en 32 GB met 16 vCPU op skipbox-16x32 voor $149.

### Hoe los ik JavaScript heap out of memory op in een Next.js-build op GitHub Actions?

Die fout is de eigen heaplimiet van Node, niet het geheugen van de machine. Verhoog hem met NODE_OPTIONS=--max-old-space-size=<MiB>, onder het geheugen van de machine. Eindigt de job daarna met exit code 137, dan zat de machine zelf vol: verlaag het geheugen van de build (experimental.webpackMemoryOptimizations, geen source maps in productie) of draai op een machine met meer geheugen.

### Hoe verlaag ik het geheugengebruik van een Next.js-build?

Uit de geheugengids van Next.js: probeer experimental.webpackMemoryOptimizations (v15 en later), laat de webpack-buildworker aan (de standaard zonder eigen webpack-config sinds v14.1.0), zet productionBrowserSourceMaps en experimental.serverSourceMaps uit, en meet met next build --experimental-debug-memory-usage. De typecontrole overslaan met typescript.ignoreBuildErrors bespaart geheugen maar laat typefouten door, dus doe het alleen als een andere CI-job de types controleert.

### Bewaart Skipbox .next/cache tussen jobs?

Ja. Je dedicated machine bewaart de checkout tussen jobs, en .next/cache daarin, waar Next.js hem ook neerzette (apps/web/.next/cache in een monorepo), dus de volgende next build start vanaf de cache van de vorige, zonder cachestep. De rest van .next en de andere niet-gevolgde bestanden van de checkout worden na elke job opgeruimd. De cache van npm of pnpm, de Node-versies die setup-node installeerde en de layers van Docker blijven ook op de schijf. Een actions/cache-step voor .next/cache mag blijven: een job op een nieuwe VM, zoals een pull request vanuit een fork, zet daaruit terug, en op je dedicated machine laat het terugzetten de bewaarde cache zoals hij is.

### Hoeveel kost het om te proberen?

Niets. De proefperiode is 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart, op 4 vCPU en 16 GB: 2× de 8 GB van ubuntu-latest op een privé-repository, en evenveel als de larger runner van GitHub met 4 cores. Probeer daar de caching en het geheugen; kies voor een build die meer nodig heeft abonnement L en wijzig het label in skipbox-16x32 (32 GB).

Bijgewerkt op 2026-11-19 · https://skipbox.dev/nl/guides/nextjs-build-slow-out-of-memory-github-actions
