# Build Next.js lent sau fără memorie în GitHub Actions: cache, memorie, mărimea runnerului

> Un build Next.js în GitHub Actions e lent când .next/cache nu ajunge la rularea următoare și rămâne fără memorie pe ubuntu-latest de 8 GB dintr-un repository privat când se adună webpack, verificarea tipurilor și source maps. Ce pui în cache, ce setări Next.js reduc memoria și mărimea runnerului: 16 GB pentru $79 pe lună sau 32 GB pentru $149 pe Skipbox, unde .next/cache rămâne între joburi, iar minutele sunt nelimitate.

Un build Next.js în GitHub Actions e lent dintr-un motiv și rămâne fără memorie din altul. E lent când `.next/cache` nu ajunge la rularea următoare: Next.js refolosește acel cache între builduri, un job găzduit de GitHub pornește pe un VM nou, iar fără un pas de cache fiecare build pornește la rece (logul spune `No Cache Detected`). Rămâne fără memorie pentru că `ubuntu-latest` dintr-un repository privat are 8 GB, iar compilarea webpack, verificarea tipurilor și source maps ale unei aplicații mari pot depăși asta. Prima problemă o rezolvi cu `actions/cache` pe `.next/cache`. Pentru a doua, vin mai întâi setările de memorie Next.js (`experimental.webpackMemoryOptimizations`, fără source maps de producție), apoi o mașină cu mai multă memorie: 16 GB sau 32 GB.

Skipbox îi dă buildului acea memorie la un preț fix: 16 GB și 8 vCPU pe `runs-on: skipbox-8x16` pentru $79 pe lună, 32 GB și 16 vCPU pe `skipbox-16x32` pentru $149. Pe mașina ta dedicată, `.next/cache` rămâne pentru buildul următor, cache-urile de pachete rămân pe disc, iar ce salvează `actions/cache` se citește local, cu minute nelimitate.

- `.next/cache` rămâne pe mașina ta dedicată: buildul următor își refolosește ultima compilare, fără niciun pas de cache
- 16 GB pentru $79 pe lună sau 32 GB pentru $149, față de 8 GB pe un `ubuntu-latest` privat
- Cache-urile de pachete rămân pe mașina ta, iar restaurările de cache citesc discul ei în loc să descarce

**GitHub Actions la preț fix, cu minute nelimitate** Skipbox rulează joburile tale GitHub Actions pe propria ta mașină dedicată: $39 pe lună, oricâte minute ai rula. Layerele Docker și cache-urile de dependențe rămân între joburi, așa că jobul următor pornește imediat.

Un runner de 4 vCPU, 20.000 de minute pe lună: GitHub $222 → Skipbox $39. Economisești $183 în fiecare lună.

E nevoie de o singură linie: `runs-on: skipbox`.

[Încearcă gratuit 7 zile](https://app.skipbox.dev/sign-in?ref=g-nextjs-build-slow-out-of-memory-github-actions-ro)

## Lent: .next/cache pornește gol

Din [ghidul Next.js despre cache-ul de build în CI](https://nextjs.org/docs/app/guides/ci-build-caching): Next.js salvează în `.next/cache` un cache împărțit între builduri, iar un CI care nu îl păstrează între builduri afișează eroarea `No Cache Detected`. Pasul lui pentru 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') }}-
```

Cheia se schimbă la fiecare schimbare din surse, așa că fiecare rulare salvează o intrare nouă, în cei 10 GB per repository de la GitHub. Într-un Turborepo, exclude `.next/cache` din `outputs` ale taskului (`"!.next/cache/**"`), cum face [ghidul Turborepo pentru GitHub Actions](https://turborepo.dev/docs/guides/ci-vendors/github-actions).

## Fără memorie: două erori diferite

| În log | Ce s-a terminat | Ce faci |
|---|---|---|
| `JavaScript heap out of memory` | Limita proprie de heap a lui Node; mașina mai avea memorie | Ridic-o: `NODE_OPTIONS=--max-old-space-size=6144`, sub memoria mașinii |
| `Process completed with exit code 137` | Memoria mașinii: Linux a oprit procesul | Folosește mai puțină memorie sau o mașină cu mai multă |

Dacă ridici heapul peste memoria mașinii, prima eroare devine a doua.

## Folosește mai puțină memorie: setările proprii Next.js

Din [ghidul Next.js despre folosirea memoriei](https://nextjs.org/docs/app/guides/memory-usage):

- **`experimental.webpackMemoryOptimizations: true`** (v15.0.0 și mai nou) reduce vârful de memorie al webpack, cu o compilare puțin mai lungă.
- **Build workerul webpack** rulează compilarea într-un worker Node separat, ceea ce reduce memoria. E activat implicit din v14.1.0, dacă nu ai o configurație webpack proprie; dacă ai, setează `experimental.webpackBuildWorker: true`.
- **Source maps dezactivate:** `productionBrowserSourceMaps: false` și `experimental.serverSourceMaps: false`. Dacă buildul rămâne fără memorie în timpul „Generating static pages”, și `enablePrerenderSourceMaps: false`.
- **Măsoară:** `next build --experimental-debug-memory-usage` (v14.2.0 și mai nou) afișează folosirea heapului pe tot parcursul buildului și face heap snapshots aproape de limită.
- **Verificarea tipurilor:** `typescript.ignoreBuildErrors: true` sare peste verificarea tipurilor și memoria ei și lasă erorile de tip să intre în build. Next.js o descurajează, dacă nu există un alt pas care verifică tipurile.

## Folosește o mașină cu mai multă memorie

| Runner | CPU și memorie | Cine îl poate folosi |
|---|---|---|
| GitHub `ubuntu-latest`, repository privat | 2 CPU, 8 GB | Toată lumea |
| GitHub `ubuntu-latest`, repository public | 4 CPU, 16 GB | Repository-urile publice |
| Runner mare GitHub, 4 sau 8 nuclee | 16 GB sau 32 GB | Organizațiile pe GitHub Team și Enterprise Cloud, la minut ([larger runners](https://docs.github.com/en/actions/concepts/runners/larger-runners)) |
| Skipbox `skipbox-8x16` | 8 vCPU, 16 GB | Organizații și conturi personale, $79 pe lună |
| Skipbox `skipbox-16x32` | 16 vCPU, 32 GB | Organizații și conturi personale, $149 pe lună |

La 20.000 de minute pe lună, runnerul GitHub de 8 nuclee costă $422, iar Skipbox M $79; la 16 nuclee, $822 față de $149 pentru L. Cifrele GitHub sunt după utilizarea inclusă în GitHub Team.

## Ce face Skipbox pentru un build Next.js

Fiecare plan vine cu mașina dedicată a contului tău, păstrată între joburi:

- **Memoria de care are nevoie buildul**, după etichetă: 16 GB pe M, 32 GB pe L. Setează heapul pe măsură, de exemplu `--max-old-space-size=12288` pe M.
- **Cache-urile de pachete rămân pe disc:** `~/.npm`, store-ul pnpm, `~/.cache` al fiecărui instrument și versiunile de Node instalate de `setup-node`. `npm ci` le citește pe ele în loc de registry.
- **`.next/cache` rămâne pentru jobul următor.** Mașina îți păstrează checkoutul între joburi și, în el, `.next/cache`, la orice adâncime îl pune un monorepo (`apps/web/.next/cache`). Următorul `next build` pornește de la el, fără niciun pas de cache și fără `No Cache Detected`. Restul lui `.next` și celelalte fișiere neurmărite ale checkoutului sunt curățate după fiecare job.
- **Restaurările `actions/cache` citesc mașina.** Ce salvează el rămâne lângă mașină, cu mai mult spațiu decât cei 10 GB per repository de la GitHub, iar restaurarea e o citire locală. Păstrează pasul pentru `.next/cache` pentru joburile care rulează pe un VM nou; pe mașina ta dedicată, restaurarea lasă neatins cache-ul păstrat.
- **Mai multe nuclee la preț fix.** Compilarea și generarea paginilor statice le folosesc, iar minutele sunt nelimitate.

| Etichetă | Mașină | Plan |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 pe lună |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 pe lună |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 pe lună |

## Mutarea înseamnă o singură linie

```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` rulează pe un plan M; perioada de probă rulează `runs-on: skipbox`.

1. Conectează-te la Skipbox cu GitHub.
2. Instalează aplicația GitHub Skipbox și alege repository-urile.
3. Schimbă `runs-on` și fă push.

## Securitate

- Mașina este doar a contului tău. Niciun job al altei companii nu rulează pe ea.
- După fiecare job, credențialele runnerului, procesele și containerele sunt șterse, la fel și credențialele git din checkoutul păstrat și fișierele lui neurmărite, în afară de cache-urile de build precum `.next/cache`. „Curățare la fiecare job” îi dă în schimb fiecărui job o mașină nouă.
- Codul de la persoane fără acces de scriere (cum ar fi pull request-urile din forkuri) rulează pe un VM nou, care îți citește cache-urile, dar nu le poate modifica.

Detaliile sunt în [cum sunt izolate joburile](https://docs.skipbox.dev/ro/isolation).

## Încearcă pe buildul Next.js

Perioada de probă este gratuită timp de 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, fără card. Rulează `runs-on: skipbox`, cu 16 GB, de 2× memoria `ubuntu-latest` dintr-un repository privat: încearcă acolo cache-ul și memoria și mută un build care are nevoie de mai mult pe planul L (`skipbox-16x32`, 32 GB).

## Întrebări frecvente

### De ce e lent next build în GitHub Actions?

De obicei pentru că .next/cache pornește gol. Next.js salvează un cache de build în .next/cache și îl refolosește la buildul următor, dar un job găzduit de GitHub e un VM nou, așa că fără un pas care să ducă mai departe .next/cache, fiecare build pornește la rece, iar logul avertizează No Cache Detected. Adaugă actions/cache pentru .next/cache, cu cheia legată de lockfile și de fișierele tale sursă. Restul timpului înseamnă instalarea și compilarea pe 2 CPU.

### Ce mărime de runner ar trebui să folosească un build Next.js în GitHub Actions?

Destulă memorie pentru vârful buildului. ubuntu-latest dintr-un repository privat are 2 CPU și 8 GB, iar buildul webpack, verificarea tipurilor și source maps ale unei aplicații Next.js mari pot depăși asta. Runnerele mari GitHub au 16 GB la 4 nuclee și 32 GB la 8, doar pe GitHub Team sau Enterprise Cloud, la minut. Skipbox îți dă 16 GB cu 8 vCPU pe runs-on: skipbox-8x16 pentru $79 pe lună și 32 GB cu 16 vCPU pe skipbox-16x32 pentru $149.

### Cum rezolv JavaScript heap out of memory într-un build Next.js în GitHub Actions?

Eroarea aceea e propria limită de heap a lui Node, nu memoria mașinii. Ridic-o cu NODE_OPTIONS=--max-old-space-size=<MiB>, setată sub memoria mașinii. Dacă jobul se termină atunci cu exit code 137, a rămas fără memorie chiar mașina: redu memoria buildului (experimental.webpackMemoryOptimizations, fără source maps de producție) sau rulează pe o mașină cu mai multă memorie.

### Cum reduc memoria folosită de buildul Next.js?

Din ghidul de memorie Next.js: încearcă experimental.webpackMemoryOptimizations (v15 și mai nou), lasă activat build workerul webpack (implicit fără o configurație webpack proprie, din v14.1.0), dezactivează productionBrowserSourceMaps și experimental.serverSourceMaps și măsoară cu next build --experimental-debug-memory-usage. Sărirea verificării tipurilor cu typescript.ignoreBuildErrors economisește memorie, dar lasă să treacă erorile de tip, așa că fă asta doar când un alt job de CI verifică tipurile.

### Skipbox păstrează .next/cache între joburi?

Da. Mașina ta dedicată păstrează checkoutul între joburi și, în el, .next/cache, oriunde l-a pus Next.js (apps/web/.next/cache într-un monorepo), așa că următorul next build pornește de la cache-ul celui dinainte, fără niciun pas de cache. Restul lui .next și celelalte fișiere neurmărite ale checkoutului sunt curățate după fiecare job. Cache-ul npm sau pnpm, versiunile de Node instalate de setup-node și layerele Docker rămân și ele pe disc. Un pas actions/cache pentru .next/cache poate rămâne: un job pe un VM nou, cum e un pull request dintr-un fork, restaurează din el, iar pe mașina ta dedicată restaurarea lasă neatins cache-ul păstrat.

### Cât costă să încerc?

Nimic. Perioada de probă durează 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, fără card, pe 4 vCPU și 16 GB: de 2× cei 8 GB ai ubuntu-latest dintr-un repository privat, cât runnerul mare GitHub de 4 nuclee. Încearcă acolo cache-ul și memoria; pentru un build care are nevoie de mai mult, alege planul L și schimbă eticheta în skipbox-16x32 (32 GB).

Actualizat pe 2026-11-16 · https://skipbox.dev/ro/guides/nextjs-build-slow-out-of-memory-github-actions
