# בניית Next.js איטית או נגמר לה הזיכרון ב‑GitHub Actions: מטמון, זיכרון, גודל ראנר

> בניית Next.js ב‑GitHub Actions איטית כש‑‎.next/cache לא מועבר להרצה הבאה, ונגמר לה הזיכרון ב‑ubuntu-latest של 8 GB במאגר פרטי ברגע ש‑webpack, בדיקת הטיפוסים ו‑source maps מצטברים. מה לשמור במטמון, אילו הגדרות של Next.js מקצצות זיכרון, וגודל הראנר: 16 GB ב‑$79 לחודש או 32 GB ב‑$149 ב‑Skipbox, שבה ‎.next/cache נשאר בין ג'ובים והדקות ללא הגבלה.

בניית Next.js ב‑GitHub Actions איטית מסיבה אחת ונגמר לה הזיכרון מסיבה אחרת. היא איטית כש‑`.next/cache` לא מועבר להרצה הבאה: Next.js משתמש שוב במטמון הזה בין בניות, ג'וב שמתארח ב‑GitHub מתחיל על VM חדש, ובלי step של מטמון כל בנייה היא קרה (הלוג אומר `No Cache Detected`). נגמר לה הזיכרון כי ל‑`ubuntu-latest` של מאגר פרטי יש 8 GB, והקומפילציה של webpack, בדיקת הטיפוסים וה‑source maps של אפליקציה גדולה יכולים לעבור את זה. תקנו את הראשון עם `actions/cache` על `.next/cache`. בשביל השני, הגדרות הזיכרון של Next.js באות קודם (`experimental.webpackMemoryOptimizations`, בלי source maps בפרודקשן); ואחר כך מכונה עם יותר זיכרון: 16 GB או 32 GB.

Skipbox נותנת לבנייה את הזיכרון הזה במחיר קבוע: 16 GB ו‑8 vCPU ב‑`runs-on: skipbox-8x16` ב‑$79 לחודש, 32 GB ו‑16 vCPU ב‑`skipbox-16x32` ב‑$149. על המכונה שלכם `.next/cache` נשאר לבנייה הבאה, מטמוני החבילות נשארים על הדיסק, ומה ש‑`actions/cache` שומר נקרא מקומית, עם דקות ללא הגבלה.

- `.next/cache` נשאר על המכונה שלכם: הבנייה הבאה משתמשת שוב בקומפילציה האחרונה, בלי step של מטמון
- 16 GB ב‑$79 לחודש או 32 GB ב‑$149, מול 8 GB ב‑`ubuntu-latest` של מאגר פרטי
- מטמוני החבילות נשארים על המכונה שלכם, ושחזורי מטמון קוראים מהדיסק שלה במקום להוריד

**GitHub Actions במחיר קבוע, דקות ללא הגבלה** Skipbox מריצה את ג'ובי ה‑GitHub Actions שלכם על מכונה ייעודית משלכם: $39 לחודש, לא משנה כמה דקות תריצו. שכבות Docker ומטמוני תלויות נשמרים בין ג'ובים, כך שהג'וב הבא מתחיל מיד.

ראנר של 4 vCPU, 20,000 דקות בחודש: GitHub $222 → Skipbox $39. אתם חוסכים $183 בכל חודש.

המעבר הוא שורה אחת: `runs-on: skipbox`.

[התחלת 7 ימי ניסיון בחינם](https://app.skipbox.dev/sign-in?ref=g-nextjs-build-slow-out-of-memory-github-actions-he)

## איטי: .next/cache מתחיל ריק

מתוך [מדריך מטמון ה‑build ב‑CI](https://nextjs.org/docs/app/guides/ci-build-caching) של Next.js: Next.js שומר מטמון ב‑`.next/cache` שמשותף בין בניות, ו‑CI שלא שומר אותו בין בניות מציג שגיאת `No Cache Detected`. ה‑step שלו ל‑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') }}-
```

המפתח משתנה עם כל שינוי בקוד המקור, כך שכל הרצה שומרת רשומה חדשה, בתוך 10 GB של GitHub לכל מאגר. ב‑Turborepo, הוציאו את `.next/cache` מה‑`outputs` של המשימה (`"!.next/cache/**"`), כמו ש[מדריך GitHub Actions של Turborepo](https://turborepo.dev/docs/guides/ci-vendors/github-actions) עושה.

## חוסר זיכרון: שתי שגיאות שונות

| בלוג | מה נגמר | מה לעשות |
|---|---|---|
| `JavaScript heap out of memory` | מגבלת ה‑heap של Node עצמו; למכונה עוד היה זיכרון | הגדילו אותה: `NODE_OPTIONS=--max-old-space-size=6144`, מתחת לזיכרון של המכונה |
| `Process completed with exit code 137` | הזיכרון של המכונה: Linux הרג את התהליך | השתמשו בפחות זיכרון, או במכונה עם יותר |

הגדלת ה‑heap מעבר לזיכרון של המכונה הופכת את השגיאה הראשונה לשנייה.

## השתמשו בפחות זיכרון: ההגדרות של Next.js עצמו

מתוך [מדריך צריכת הזיכרון](https://nextjs.org/docs/app/guides/memory-usage) של Next.js:

- **`experimental.webpackMemoryOptimizations: true`** (v15.0.0 ומעלה) מוריד את שיא הזיכרון של webpack, במחיר קומפילציה קצת יותר ארוכה.
- **ה‑build worker של webpack** מריץ את הקומפילציה ב‑worker נפרד של Node, מה שמוריד זיכרון. הוא פעיל כברירת מחדל מאז v14.1.0 אלא אם יש לכם הגדרת webpack מותאמת; אם יש, הגדירו `experimental.webpackBuildWorker: true`.
- **source maps כבויים:** `productionBrowserSourceMaps: false` ו‑`experimental.serverSourceMaps: false`. אם לבנייה נגמר הזיכרון בזמן "Generating static pages", גם `enablePrerenderSourceMaps: false`.
- **מדידה:** `next build --experimental-debug-memory-usage` (v14.2.0 ומעלה) מדפיס את השימוש ב‑heap לאורך הבנייה, ולוקח heap snapshots ליד המגבלה.
- **בדיקת טיפוסים:** `typescript.ignoreBuildErrors: true` מדלג על בדיקת הטיפוסים ועל הזיכרון שלה, ומכניס שגיאות טיפוסים לבנייה. Next.js מזהיר מפני זה אלא אם step אחר בודק טיפוסים.

## השתמשו במכונה עם יותר זיכרון

| ראנר | מעבד וזיכרון | מי יכול להשתמש בו |
|---|---|---|
| `ubuntu-latest` של GitHub, מאגר פרטי | 2 מעבדים, 8 GB | כולם |
| `ubuntu-latest` של GitHub, מאגר ציבורי | 4 מעבדים, 16 GB | מאגרים ציבוריים |
| ראנר גדול של GitHub, 4 או 8 ליבות | 16 GB או 32 GB | ארגונים ב‑GitHub Team וב‑Enterprise Cloud, לפי דקה ([ראנרים גדולים](https://docs.github.com/en/actions/concepts/runners/larger-runners)) |
| Skipbox `skipbox-8x16` | 8 vCPU, 16 GB | ארגונים וחשבונות אישיים, $79 לחודש |
| Skipbox `skipbox-16x32` | 16 vCPU, 32 GB | ארגונים וחשבונות אישיים, $149 לחודש |

ב‑20,000 דקות בחודש, הראנר של 8 ליבות של GitHub עולה $422 ו‑Skipbox M עולה $79; ב‑16 ליבות, $822 מול $149 ל‑L. הסכומים של GitHub הם אחרי השימוש הכלול ב‑GitHub Team.

## מה Skipbox עושה לבניית Next.js

כל מסלול מגיע עם מכונה של החשבון שלכם, שנשמרת בין ג'ובים:

- **הזיכרון שהבנייה צריכה**, לפי תווית: 16 GB ב‑M, 32 GB ב‑L. הגדירו את ה‑heap בהתאם, למשל `--max-old-space-size=12288` ב‑M.
- **מטמוני החבילות נשארים על הדיסק:** `~/.npm`, ה‑store של pnpm, ה‑`~/.cache` של כל כלי, וגרסאות ה‑Node ש‑`setup-node` התקין. `npm ci` קורא אותם במקום את ה‑registry.
- **`.next/cache` נשאר לג'וב הבא.** המכונה שומרת את ה‑checkout שלכם בין ג'ובים, ואת `.next/cache` שבתוכו, בכל עומק ש‑monorepo שם אותו (`apps/web/.next/cache`). ה‑`next build` הבא מתחיל ממנו, בלי step של מטמון ובלי `No Cache Detected`. שאר `.next` והקבצים האחרים שלא במעקב ב‑checkout מנוקים אחרי כל ג'וב.
- **שחזורים של `actions/cache` קוראים מהמכונה.** מה שהוא שומר נשאר ליד המכונה, עם יותר מקום מ‑10 GB של GitHub לכל מאגר, והשחזור הוא קריאה מקומית. השאירו את ה‑step של `.next/cache` בשביל ג'ובים שרצים על VM חדש; במכונה שלכם השחזור משאיר את המטמון השמור כמו שהוא.
- **יותר ליבות במחיר קבוע.** הקומפילציה ויצירת הדפים הסטטיים משתמשות בהן, והדקות ללא הגבלה.

| תווית | מכונה | מסלול |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 לחודש |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 לחודש |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 לחודש |

## המעבר הוא שורה אחת

```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` רץ במסלול M; תקופת הניסיון מריצה `runs-on: skipbox`.

1. התחברו ל‑Skipbox עם GitHub.
2. התקינו את אפליקציית Skipbox ל‑GitHub ובחרו את המאגרים.
3. שנו את `runs-on` ובצעו push.

## אבטחה

- המכונה שייכת לחשבון שלכם בלבד. ג'ובים של חברה אחרת לא רצים עליה.
- אחרי כל ג'וב נמחקים פרטי הגישה, התהליכים והקונטיינרים של הראנר, וגם פרטי הגישה של git ב‑checkout שנשמר והקבצים שלו שלא במעקב, חוץ ממטמוני build כמו `.next/cache`. "VM חדש לכל ג'וב" נותן במקום זה לכל ג'וב מכונה חדשה.
- קוד של אנשים בלי הרשאת כתיבה (כמו pull requests מ‑forks) רץ על VM חדש שקורא את המטמונים שלכם אבל לא יכול לשנות אותם.

הפרטים נמצאים ב[איך הג'ובים מבודדים](https://docs.skipbox.dev/he/isolation).

## נסו על בניית ה‑Next.js

תקופת הניסיון בחינם נמשכת 7 ימים או 3,000 דקות של ג'ובים, המוקדם מביניהם, בלי כרטיס. היא מריצה `runs-on: skipbox`, עם 16 GB, פי 2 מהזיכרון של `ubuntu-latest` במאגר פרטי: נסו שם את המטמון ואת הזיכרון, והעבירו בנייה שצריכה יותר למסלול L (`skipbox-16x32`, 32 GB).

## שאלות נפוצות

### למה next build איטי ב‑GitHub Actions?

בדרך כלל כי ‎.next/cache מתחיל ריק. Next.js שומר מטמון build ב‑‎.next/cache ומשתמש בו שוב בבנייה הבאה, אבל ג'וב שמתארח ב‑GitHub הוא VM חדש, כך שבלי step שמעביר את ‎.next/cache, כל בנייה היא בנייה קרה והלוג מזהיר No Cache Detected. הוסיפו actions/cache ל‑‎.next/cache עם מפתח לפי ה‑lockfile וקובצי המקור שלכם. שאר הזמן הוא ההתקנה והקומפילציה על 2 מעבדים.

### באיזה גודל ראנר בניית Next.js צריכה להשתמש ב‑GitHub Actions?

מספיק זיכרון לשיא של הבנייה. ל‑ubuntu-latest של מאגר פרטי יש 2 מעבדים ו‑8 GB, ובניית webpack, בדיקת טיפוסים ו‑source maps של אפליקציית Next.js גדולה יכולים לעבור את זה. לראנרים הגדולים של GitHub יש 16 GB ב‑4 ליבות ו‑32 GB ב‑8, רק ב‑GitHub Team או ב‑Enterprise Cloud, לפי דקה. Skipbox נותנת 16 GB עם 8 vCPU ב‑runs-on: skipbox-8x16 ב‑$79 לחודש, ו‑32 GB עם 16 vCPU ב‑skipbox-16x32 ב‑$149.

### איך מתקנים JavaScript heap out of memory בבניית Next.js ב‑GitHub Actions?

השגיאה הזו היא מגבלת ה‑heap של Node עצמו, לא הזיכרון של המכונה. הגדילו אותה עם NODE_OPTIONS=--max-old-space-size=<MiB>, בערך מתחת לזיכרון של המכונה. אם הג'וב מסתיים אז במקום זה עם exit code 137, למכונה עצמה נגמר הזיכרון: קצצו את הזיכרון של הבנייה (experimental.webpackMemoryOptimizations, בלי source maps בפרודקשן) או הריצו על מכונה עם יותר זיכרון.

### איך מקטינים את צריכת הזיכרון של בניית Next.js?

מתוך מדריך הזיכרון של Next.js: נסו את experimental.webpackMemoryOptimizations (גרסה 15 ומעלה), השאירו את ה‑build worker של webpack פעיל (ברירת המחדל בלי הגדרת webpack מותאמת מאז v14.1.0), כבו את productionBrowserSourceMaps ואת experimental.serverSourceMaps, ומדדו עם next build --experimental-debug-memory-usage. דילוג על בדיקת הטיפוסים עם typescript.ignoreBuildErrors חוסך זיכרון אבל מעביר שגיאות טיפוסים, אז עשו את זה רק כשג'וב CI אחר בודק טיפוסים.

### Skipbox שומרת את ‎.next/cache בין ג'ובים?

כן. המכונה שלכם שומרת את ה‑checkout בין ג'ובים, ואת ‎.next/cache שבתוכו, בכל מקום ש‑Next.js שם אותו (apps/web/.next/cache ב‑monorepo), כך שה‑next build הבא מתחיל מהמטמון של הקודם בלי step של מטמון. שאר ‎.next והקבצים האחרים שלא במעקב ב‑checkout מנוקים אחרי כל ג'וב. המטמון של npm או של pnpm, גרסאות ה‑Node ש‑setup-node התקין והשכבות של Docker נשארים גם הם על הדיסק. step של actions/cache ל‑‎.next/cache יכול להישאר: ג'וב על VM חדש, כמו pull request מ‑fork, משחזר ממנו, ובמכונה שלכם השחזור משאיר את המטמון השמור כמו שהוא.

### כמה עולה לנסות?

כלום. תקופת הניסיון היא 7 ימים או 3,000 דקות של ג'ובים, המוקדם מביניהם, בלי כרטיס, על 4 vCPU ו‑16 GB: פי 2 מ‑8 GB של ubuntu-latest במאגר פרטי, וכמו הראנר הגדול של 4 ליבות של GitHub. נסו שם את המטמון ואת הזיכרון; לבנייה שצריכה יותר, בחרו במסלול L ושנו את התווית ל‑skipbox-16x32 (32 GB).

עודכן ב‑2026-11-16 · https://skipbox.dev/he/guides/nextjs-build-slow-out-of-memory-github-actions
