# Build Next.js w GitHub Actions jest wolny albo brakuje mu pamięci: cache, pamięć, rozmiar runnera

> Build Next.js w GitHub Actions jest wolny, gdy .next/cache nie przechodzi do następnego uruchomienia, a brakuje mu pamięci na 8 GB ubuntu-latest repozytorium prywatnego, gdy zsumują się webpack, sprawdzanie typów i source mapy. Co zapisać w cache, które ustawienia Next.js zmniejszają zużycie pamięci i jaki rozmiar runnera: 16 GB za $79 miesięcznie albo 32 GB za $149 w Skipbox, gdzie .next/cache zostaje między zadaniami, a minuty są bez limitu.

Build Next.js w GitHub Actions jest wolny z jednego powodu, a pamięci brakuje mu z innego. Jest wolny, gdy `.next/cache` nie przechodzi do następnego uruchomienia: Next.js używa tego cache ponownie między buildami, zadanie hostowane przez GitHub startuje na nowej VM, a bez kroku cache każdy build jest zimny (log pokazuje `No Cache Detected`). Brakuje mu pamięci, bo `ubuntu-latest` repozytorium prywatnego ma 8 GB, a kompilacja webpacka, sprawdzanie typów i source mapy dużej aplikacji mogą to przekroczyć. Pierwsze napraw przez `actions/cache` na `.next/cache`. Przy drugim najpierw ustawienia pamięci Next.js (`experimental.webpackMemoryOptimizations`, bez produkcyjnych source map); potem maszyna z większą pamięcią: 16 GB albo 32 GB.

Skipbox daje buildowi tę pamięć w stałej cenie: 16 GB i 8 vCPU na `runs-on: skipbox-8x16` za $79 miesięcznie, 32 GB i 16 vCPU na `skipbox-16x32` za $149. Na Twojej dedykowanej maszynie `.next/cache` zostaje dla następnego buildu, cache pakietów zostają na dysku, a to, co zapisuje `actions/cache`, jest czytane lokalnie, z minutami bez limitu.

- `.next/cache` zostaje na Twojej dedykowanej maszynie: następny build używa ponownie swojej ostatniej kompilacji, bez kroku cache
- 16 GB za $79 miesięcznie albo 32 GB za $149, wobec 8 GB na prywatnym `ubuntu-latest`
- Cache pakietów zostają na Twojej maszynie, a przywracanie cache czyta jej dysk zamiast pobierać

**GitHub Actions w stałej cenie, minuty bez limitu** Skipbox uruchamia Twoje zadania GitHub Actions na Twojej własnej, dedykowanej maszynie: $39 miesięcznie, niezależnie od liczby minut. Warstwy Dockera i cache zależności zostają między zadaniami, więc kolejne zadanie startuje od razu.

Runner 4 vCPU, 20 000 minut miesięcznie: GitHub $222 → Skipbox $39. Oszczędzasz $183 co miesiąc.

Przejście to jedna linia: `runs-on: skipbox`.

[Rozpocznij 7-dniowy okres próbny](https://app.skipbox.dev/sign-in?ref=g-nextjs-build-slow-out-of-memory-github-actions-pl)

## Wolno: .next/cache startuje pusty

Według [przewodnika Next.js o cache buildów w CI](https://nextjs.org/docs/app/guides/ci-build-caching) Next.js zapisuje w `.next/cache` cache wspólny dla kolejnych buildów, a CI, które nie przenosi go między buildami, pokazuje błąd `No Cache Detected`. Jego krok dla 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') }}-
```

Klucz zmienia się przy każdej zmianie kodu źródłowego, więc każde uruchomienie zapisuje nowy wpis, w ramach 10 GB GitHuba na repozytorium. W Turborepo wyłącz `.next/cache` z `outputs` zadania (`"!.next/cache/**"`), tak jak robi to [przewodnik Turborepo dla GitHub Actions](https://turborepo.dev/docs/guides/ci-vendors/github-actions).

## Brak pamięci: dwa różne błędy

| W logu | Czego zabrakło | Co zrobić |
|---|---|---|
| `JavaScript heap out of memory` | Własnego limitu sterty Node'a; maszyna wciąż miała pamięć | Podnieś go: `NODE_OPTIONS=--max-old-space-size=6144`, poniżej pamięci maszyny |
| `Process completed with exit code 137` | Pamięci maszyny: Linux zabił proces | Zużywaj mniej pamięci albo użyj maszyny z większą pamięcią |

Podniesienie sterty ponad pamięć maszyny zamienia pierwszy błąd w drugi.

## Zużywaj mniej pamięci: własne ustawienia Next.js

Według [przewodnika Next.js o zużyciu pamięci](https://nextjs.org/docs/app/guides/memory-usage):

- **`experimental.webpackMemoryOptimizations: true`** (v15.0.0 i nowsze) obniża szczytowe zużycie pamięci przez webpacka, kosztem nieco dłuższej kompilacji.
- **Webpack build worker** uruchamia kompilację w osobnym workerze Node, co zmniejsza zużycie pamięci. Od v14.1.0 jest domyślnie włączony, chyba że masz własną konfigurację webpacka; wtedy ustaw `experimental.webpackBuildWorker: true`.
- **Source mapy wyłączone:** `productionBrowserSourceMaps: false` i `experimental.serverSourceMaps: false`. Jeśli pamięci brakuje na etapie „Generating static pages”, także `enablePrerenderSourceMaps: false`.
- **Mierz:** `next build --experimental-debug-memory-usage` (v14.2.0 i nowsze) wypisuje zużycie sterty w trakcie buildu i robi zrzuty sterty blisko limitu.
- **Sprawdzanie typów:** `typescript.ignoreBuildErrors: true` pomija sprawdzanie typów i jego pamięć, ale przepuszcza błędy typów do buildu. Next.js odradza to, chyba że typy sprawdza inny krok.

## Użyj maszyny z większą pamięcią

| Runner | CPU i pamięć | Kto może go używać |
|---|---|---|
| `ubuntu-latest` GitHuba, repozytorium prywatne | 2 CPU, 8 GB | Każdy |
| `ubuntu-latest` GitHuba, repozytorium publiczne | 4 CPU, 16 GB | Repozytoria publiczne |
| Większy runner GitHuba, 4 albo 8 rdzeni | 16 GB albo 32 GB | Organizacje w GitHub Team i Enterprise Cloud, za minutę ([larger runners](https://docs.github.com/en/actions/concepts/runners/larger-runners)) |
| Skipbox `skipbox-8x16` | 8 vCPU, 16 GB | Organizacje i konta osobiste, $79 miesięcznie |
| Skipbox `skipbox-16x32` | 16 vCPU, 32 GB | Organizacje i konta osobiste, $149 miesięcznie |

Przy 20 000 minut miesięcznie 8-rdzeniowy runner GitHuba to $422, a Skipbox M to $79; przy 16 rdzeniach $822 wobec $149 za L. Kwoty GitHuba są po odjęciu użycia wliczonego w GitHub Team.

## Co Skipbox robi dla buildu Next.js

Każdy plan ma dedykowaną maszynę Twojego konta, która zostaje między zadaniami:

- **Tyle pamięci, ile potrzebuje build**, przez etykietę: 16 GB w M, 32 GB w L. Dopasuj do niej stertę, na przykład `--max-old-space-size=12288` w M.
- **Cache pakietów zostają na dysku:** `~/.npm`, magazyn pnpm, `~/.cache` każdego narzędzia i wersje Node zainstalowane przez `setup-node`. `npm ci` czyta je zamiast rejestru.
- **`.next/cache` zostaje dla następnego zadania.** Maszyna zachowuje Twój checkout między zadaniami, a w nim `.next/cache`, na dowolnej głębokości, na jakiej umieści go monorepo (`apps/web/.next/cache`). Następny `next build` startuje z niego, bez kroku cache i bez `No Cache Detected`. Reszta `.next` i pozostałe nieśledzone pliki checkoutu są czyszczone po każdym zadaniu.
- **Przywracanie przez `actions/cache` czyta maszynę.** To, co zapisuje, zostaje obok maszyny, z większym miejscem niż 10 GB GitHuba na repozytorium, a przywrócenie to odczyt lokalny. Zostaw krok dla `.next/cache` na potrzeby zadań, które działają na nowej VM; na Twojej dedykowanej maszynie przywracanie zostawia zachowany cache bez zmian.
- **Więcej rdzeni w stałej cenie.** Korzystają z nich kompilacja i generowanie stron statycznych, a minuty są bez limitu.

| Etykieta | Maszyna | Plan |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 miesięcznie |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 miesięcznie |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 miesięcznie |

## Przejście to jedna linia

```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` działa w planie M; okres próbny uruchamia `runs-on: skipbox`.

1. Zaloguj się do Skipbox przez GitHuba.
2. Zainstaluj aplikację Skipbox w GitHubie i wybierz repozytoria.
3. Zmień `runs-on` i zrób push.

## Bezpieczeństwo

- Maszyna należy tylko do Twojego konta. Nie działają na niej zadania żadnej innej firmy.
- Po każdym zadaniu usuwane są dane uwierzytelniające runnera, procesy i kontenery, a także dane uwierzytelniające gita w zachowanym checkoucie i jego nieśledzone pliki inne niż cache buildów, takie jak `.next/cache`. Opcja **Nowa VM dla każdego zadania** daje zamiast tego każdemu zadaniu nową maszynę.
- Kod od osób bez uprawnień do zapisu (na przykład pull requesty z forków) działa na nowej VM, która czyta Twój cache, ale nie może go zmienić.

Szczegóły są w artykule [jak zadania są od siebie odizolowane](https://docs.skipbox.dev/pl/isolation).

## Wypróbuj na buildzie Next.js

Okres próbny jest bezpłatny przez 7 dni lub 3000 minut zadań, zależnie od tego, co nastąpi wcześniej, bez karty. Uruchamia `runs-on: skipbox` z 16 GB, 2× więcej pamięci niż `ubuntu-latest` repozytorium prywatnego: wypróbuj tam cache i pamięć, a build, który potrzebuje więcej, przenieś na plan L (`skipbox-16x32`, 32 GB).

## FAQ

### Dlaczego next build jest wolny w GitHub Actions?

Zwykle dlatego, że .next/cache startuje pusty. Next.js zapisuje build cache w .next/cache i używa go ponownie przy następnym buildzie, ale zadanie hostowane przez GitHub to nowa VM, więc bez kroku, który przenosi .next/cache, każdy build jest zimny, a log ostrzega No Cache Detected. Dodaj actions/cache dla .next/cache z kluczem opartym na pliku blokady i Twoich plikach źródłowych. Reszta czasu to instalacja i kompilacja na 2 CPU.

### Jakiego rozmiaru runnera powinien używać build Next.js w GitHub Actions?

Takiego, który ma dość pamięci na szczyt buildu. ubuntu-latest repozytorium prywatnego ma 2 CPU i 8 GB, a build webpacka, sprawdzanie typów i source mapy dużej aplikacji Next.js mogą to przekroczyć. Większe runnery GitHuba mają 16 GB przy 4 rdzeniach i 32 GB przy 8, tylko w GitHub Team albo Enterprise Cloud, za minutę. Skipbox daje 16 GB z 8 vCPU na runs-on: skipbox-8x16 za $79 miesięcznie i 32 GB z 16 vCPU na skipbox-16x32 za $149.

### Jak naprawić JavaScript heap out of memory w buildzie Next.js w GitHub Actions?

Ten błąd to własny limit sterty Node'a, a nie pamięć maszyny. Podnieś go przez NODE_OPTIONS=--max-old-space-size=<MiB>, ustawione poniżej pamięci maszyny. Jeśli zadanie kończy się potem z exit code 137, zabrakło pamięci samej maszynie: zmniejsz zużycie pamięci przez build (experimental.webpackMemoryOptimizations, bez produkcyjnych source map) albo uruchamiaj go na maszynie z większą pamięcią.

### Jak zmniejszyć zużycie pamięci przez build Next.js?

Według przewodnika Next.js o pamięci: wypróbuj experimental.webpackMemoryOptimizations (v15 i nowsze), zostaw włączony webpack build worker (domyślny bez własnej konfiguracji webpacka od v14.1.0), wyłącz productionBrowserSourceMaps i experimental.serverSourceMaps i mierz przez next build --experimental-debug-memory-usage. Pominięcie sprawdzania typów przez typescript.ignoreBuildErrors oszczędza pamięć, ale przepuszcza błędy typów, więc rób to tylko wtedy, gdy typy sprawdza inne zadanie CI.

### Czy Skipbox zachowuje .next/cache między zadaniami?

Tak. Twoja dedykowana maszyna zachowuje checkout między zadaniami, a w nim .next/cache, gdziekolwiek Next.js go umieścił (apps/web/.next/cache w monorepo), więc następny next build startuje z cache poprzedniego, bez kroku cache. Reszta .next i pozostałe nieśledzone pliki checkoutu są czyszczone po każdym zadaniu. Cache npm albo pnpm, wersje Node zainstalowane przez setup-node i warstwy Dockera też zostają na dysku. Krok actions/cache dla .next/cache może zostać: zadanie na nowej VM, na przykład pull request z forka, przywraca z niego cache, a na Twojej dedykowanej maszynie przywracanie zostawia zachowany cache bez zmian.

### Ile kosztuje wypróbowanie?

Nic. Okres próbny trwa 7 dni lub 3000 minut zadań, zależnie od tego, co nastąpi wcześniej, bez karty, na 4 vCPU i 16 GB: 2× więcej niż 8 GB ubuntu-latest w repozytorium prywatnym i tyle samo co 4-rdzeniowy większy runner GitHuba. Wypróbuj tam cache i pamięć; dla buildu, który potrzebuje więcej, wybierz plan L i zmień etykietę na skipbox-16x32 (32 GB).

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