# להאיץ monorepo של pnpm ו‑Turborepo ב‑GitHub Actions (astro: מ‑528 s ל‑30 s)

> ב‑monorepo של pnpm ו‑Turborepo ב‑GitHub Actions, רוב הזמן הוא pnpm install על VM חדש ו‑turbo שמריץ משימות שהתוצאות שלהן לא נמצאות עליו. הריצו רק חבילות מושפעות, תנו ל‑turbo מטמון, ושמרו את ה‑store של pnpm. או הריצו על מכונה ששומרת את שניהם: ה‑CI של astro ירד מ‑528 s ב‑GitHub ל‑30 s ב‑Skipbox, במחיר קבוע של $39 לחודש.

ב‑monorepo של pnpm ו‑Turborepo ב‑GitHub Actions, רוב הג'וב האיטי הוא שני steps: `pnpm install` על VM חדש, ו‑`turbo run build test` שמריץ משימות שהתוצאות שלהן לא נמצאות ב‑VM. תקנו אותם לפי הסדר הזה. הריצו רק את החבילות ששינוי נוגע בהן (`turbo run build --affected`, עם checkout שיש לו היסטוריה). תנו ל‑turbo מטמון שחי יותר מהג'וב, כי התוצאות שלו נמצאות ב‑`.turbo/cache` על מכונה ש‑GitHub מוחקת אחרי כל ג'וב: Remote Caching, או `.turbo` שמשוחזר עם `actions/cache`. ושמרו את ה‑store של pnpm. בראנרים של GitHub כל אחד מהמטמונים האלה הוא הורדה בכל ג'וב. במכונה ששומרת את הדיסק שלה הם פשוט שם: ג'וב ה‑CI של astro לקח 528 s ב‑GitHub ו‑30 s במכונה ייעודית ב‑Skipbox, ששחזרה את כל 40 משימות ה‑build מהמטמון של turbo שנשמר.

Skipbox מריצה את הג'ובים שלכם על המכונה של החשבון שלכם, ששומרת את ה‑store של pnpm, את הכלים ואת ה‑`.turbo` של ה‑checkout בין ג'ובים, בלי remote cache ובלי מפתחות מטמון. שנו שורה אחת, `runs-on: skipbox`, במחיר קבוע של $39 לחודש עם דקות ללא הגבלה.

- ה‑CI של astro: 528 s ב‑GitHub, 30 s ב‑Skipbox, כש‑turbo משחזר 40 משימות build ואת משימת הבדיקות
- ה‑store של pnpm וה‑`.turbo` של turbo נשארים על המכונה שלכם: אין remote cache להגדיר, אין ארכיון להוריד
- 20,000 דקות בחודש על 4 vCPU: $222 ב‑GitHub, $39 ב‑Skipbox

**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-pnpm-turborepo-monorepo-github-actions-he)

## איפה ג'וב של monorepo מבזבז את הזמן שלו

| Step | על VM חדש של GitHub |
|---|---|
| Checkout | shallow clone כברירת מחדל; `--affected` צריך היסטוריה, אז clone מלא |
| הקמת Node ו‑pnpm | מורדים, אלא אם מטמון הכלים כבר מכיל את הגרסה |
| `pnpm install` | ה‑store משוחזר מארכיון המטמון (או מורד מה‑registry), ואז `node_modules` מקושר לכל חבילה |
| `turbo run build` | כל משימה רצה, אלא אם `.turbo/cache` שוחזר או ש‑remote cache עונה |
| `turbo run test` | אותו דבר, על 2 מעבדים ב‑`ubuntu-latest` של מאגר פרטי |

## 1. הריצו רק מה שהשתנה

מתוך [מדריך ה‑CI של Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci): `turbo run build --affected` מריץ משימות רק בחבילות שהשתנו מול ענף הבסיס. ב‑GitHub Actions הוא קורא את `GITHUB_BASE_REF` ב‑pull requests ואת `GITHUB_EVENT_PATH` ב‑pushes. עם shallow clone כל חבילה נחשבת כמשתנה, אז עשו checkout להיסטוריה:

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

`turbo query affected --packages web` אומר לג'וב אם לרוץ בכלל, כך שג'וב של אפליקציה שלא נגעו בה יכול לדלג על ההתקנה שלו.

## 2. תנו ל‑turbo מטמון שחי יותר מהג'וב

Turborepo שומר תוצאות משימות ב‑`.turbo/cache` [על המכונה](https://turborepo.dev/docs/crafting-your-repository/caching). המכונה של ג'וב שמתארח ב‑GitHub נמחקת כשהוא מסתיים, כך שב‑CI המטמון הזה מתחיל ריק בכל פעם. שתי דרכים לעקוף את זה, מתוך [מדריך GitHub Actions של Turborepo](https://turborepo.dev/docs/guides/ci-vendors/github-actions):

- **Remote Caching.** הגדירו `TURBO_TOKEN` ו‑`TURBO_TEAM` (Vercel Remote Cache, או שרת באירוח עצמי). כל פגיעה במטמון היא הורדה ממנו.
- **`actions/cache` על `.turbo`.** מפתח לפי `${{ runner.os }}-turbo-${{ github.sha }}` עם `restore-keys: ${{ runner.os }}-turbo-`. הוא שומר רשומה חדשה בכל הרצה, בתוך 10 GB של GitHub לכל מאגר יחד עם כל מה שהמאגר שומר במטמון.

## 3. שמרו את ה‑store של pnpm

`actions/setup-node` עם `cache: pnpm`, או `actions/cache` על `pnpm store path`, משחזר את ה‑store עם מפתח לפי `pnpm-lock.yaml`. הוא לא משחזר את `node_modules`, כך ש‑pnpm עדיין מקשר כל חבילה. [תיעוד ה‑CI של pnpm](https://pnpm.io/continuous-integration) אומר את זה בפשטות: שמירת ה‑store במטמון לא מבטיחה התקנה מהירה יותר. ב‑CI pnpm עובר ל‑`--frozen-lockfile` מעצמו.

## 4. השתמשו בליבות

turbo מריץ משימות עצמאיות במקביל וכל כלי build או בדיקות מפעיל workers משלו, כך ש‑monorepo משתמש בכל ליבה שהוא מקבל. ל‑`ubuntu-latest` של מאגר פרטי יש 2.

## כמה כל תיקון עולה בראנרים של GitHub

- **Remote Caching** הוא עוד שירות ועוד טוקן, וכל פגיעה במטמון עוברת ברשת.
- **`actions/cache` ל‑`.turbo`** כותב רשומה בכל הרצה ומתחרה על אותם 10 GB עם ה‑store של pnpm, השכבות של Docker והמטמונים של כל ענף; רשומות שלא היו בשימוש 7 ימים נמחקות.
- **ראנר גדול יותר** הוא ראנר גדול ב‑GitHub Team או ב‑Enterprise Cloud, בחיוב לפי דקה.

## כשהתיקון הוא מכונה ששומרת את הדיסק שלה

ה‑CI של astro עצמו, עם זרימת העבודה שלו בלי שינוי, מתוך [ההרצות שלנו של פרויקטים אמיתיים](https://skipbox.dev/he/guides/rust-cache-slow-rust-ci):

| | GitHub (מאגר ציבורי, 4 vCPU, 16 GB) | מכונה ייעודית ב‑Skipbox (4 vCPU) |
|---|---|---|
| ג'וב | 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)) |
| משימות build | 40 רצות | 40 משוחזרות מהמטמון של turbo |
| משימת בדיקות | רצה | משוחזרת מהמטמון של turbo |

המכונה שלכם שמרה את ה‑`.turbo` של ה‑checkout ואת ה‑store של pnpm מהג'וב הקודם, כך ש‑turbo מצא את התוצאה של כל משימה בלי שום דבר להוריד. turbo משחזר משימה רק כשהקלטים שלה נותנים אותו hash, כך ש‑commit אמיתי מריץ מחדש את החבילות שהוא נוגע בהן ומשחזר את השאר.

## Skipbox שומרת את המצב של ה‑monorepo

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

- **ה‑store של pnpm נשאר** ב‑`~/.local/share/pnpm/store`, עם המטמון של npm וה‑`~/.cache` של כל כלי. `pnpm install` מקשר מהדיסק במקום להוריד.
- **המטמון של turbo נשאר.** ה‑`.turbo` ברמה העליונה של ה‑checkout נשמר בין ג'ובים כש‑`turbo.json` הוא של turbo 2: מפתח `tasks`, בלי `pipeline`, ובלי `"envMode": "loose"`. בלי `TURBO_TOKEN`, בלי step של מטמון.
- **`node_modules` נמחק אחרי כל ג'וב**, כך ש‑matrix של גרסאות Node שחולק checkout אחד אף פעם לא טוען native addon שנבנה ל‑Node אחר.
- **הכלים נשארים:** גרסאות ה‑Node ש‑`setup-node` התקין, pnpm עצמו, האימג'ים והשכבות של Docker.

לפחות פי 7 משטח המטמון של GitHub ב‑S. ג'וב בוחר את הגודל שלו לפי תווית:

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

הדקות ללא הגבלה. ב‑20,000 דקות בחודש על 4 vCPU, GitHub גובה $222; Skipbox S עולה $39, $183 פחות.

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

```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. התחברו ל‑Skipbox עם GitHub.
2. התקינו את אפליקציית Skipbox ל‑GitHub ובחרו את המאגרים.
3. שנו את `runs-on` ובצעו push.

השאירו את ה‑steps של המטמון כמו שהם; מה שהם שומרים נשאר ליד המכונה.

## אבטחה

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

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

## נסו על ה‑monorepo

תקופת הניסיון בחינם נמשכת 7 ימים או 3,000 דקות של ג'ובים, המוקדם מביניהם, ולא דורשת כרטיס. העבירו את ג'וב ה‑build ל‑`runs-on: skipbox`, הריצו אותו פעמיים, ושימו את שורות ההתקנה ו‑turbo של ההרצה השנייה (`cached` מול `executing`) ליד אלה של GitHub.

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

### איך מאיצים monorepo גדול של pnpm/Turborepo ב‑GitHub Actions?

שלושה דברים, לפי הסדר. הריצו רק מה שהשתנה: turbo run build --affected, עם checkout שיש לו היסטוריה (fetch-depth: 0 ו‑filter: blob:none). תנו ל‑turbo מטמון ששורד את הג'וב: ה‑Remote Cache של Turborepo, או ‎.turbo שמשוחזר עם actions/cache. ושמרו את ה‑store של pnpm: ה‑cache: pnpm של setup-node או actions/cache על הנתיב של ה‑store. במכונות החדשות של GitHub כל אחד מאלה הוא הורדה בכל ג'וב; במכונה ששומרת את הדיסק שלה הם כבר שם. ה‑CI של astro לקח 528 s ב‑GitHub ו‑30 s במכונה ייעודית ב‑Skipbox ששומרת את המטמון של turbo ואת ה‑store של pnpm.

### למה pnpm install איטי ב‑GitHub Actions גם כשה‑store במטמון?

כי store משוחזר הוא עדיין ארכיון שמורד ונפרס על VM חדש, ו‑pnpm אז מקשר את node_modules לכל חבילה ב‑workspace. תיעוד ה‑CI של pnpm עצמו אומר ששמירת ה‑store במטמון לא מבטיחה התקנה מהירה יותר. store שכבר נמצא על הדיסק של המכונה מדלג על ההורדה; נשאר רק הקישור.

### המטמון של Turborepo עובד ב‑GitHub Actions?

רק אם המטמון חי יותר מהג'וב. Turborepo שומר תוצאות משימות ב‑‎.turbo/cache על המכונה, והמכונה של ג'וב שמתארח ב‑GitHub נעלמת כשהוא מסתיים. אז CI צריך Remote Caching (TURBO_TOKEN ו‑TURBO_TEAM, של Vercel או שרת באירוח עצמי) או step של actions/cache ל‑‎.turbo. במכונה ייעודית ב‑Skipbox ה‑‎.turbo של ה‑checkout נשאר בין ג'ובים בפרויקטים של turbo 2, כך ש‑turbo משחזר משימות שלא השתנו בלי remote cache.

### turbo --affected עובד ב‑GitHub Actions?

כן. Turborepo קורא את GITHUB_BASE_REF ב‑pull requests, ואת GITHUB_EVENT_PATH ב‑pushes, כדי למצוא את הבסיס להשוואה. הוא צריך את ההיסטוריה: עם shallow clone כל חבילה נחשבת כמשתנה. הגדירו fetch-depth: 0 ו‑filter: blob:none ב‑actions/checkout.

### מה Skipbox שומרת ל‑monorepo של Turborepo?

את ה‑store של pnpm, המטמונים של npm ושל כל כלי, הכלים ש‑setup-node מתקין, השכבות של Docker, ואת ה‑checkout עם ה‑‎.turbo ברמה העליונה שלו כש‑turbo.json הוא של turbo 2 (מפתח tasks, בלי pipeline, ולא envMode loose). node_modules נמחק אחרי כל ג'וב, כך שההתקנה רצה, מה‑store שעל הדיסק. turbo משחזר משימה רק כשהקלטים שלה נותנים אותו hash, כך ש‑commit מריץ מחדש את מה שהוא נוגע בו.

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

כלום. תקופת הניסיון היא 7 ימים או 3,000 דקות של ג'ובים, המוקדם מביניהם, בלי כרטיס. העבירו את ג'וב ה‑build של ה‑monorepo ל‑runs-on: skipbox, הריצו אותו פעמיים, והשוו את ה‑steps של ההתקנה ושל turbo בהרצה השנייה לאלה של GitHub.

עודכן ב‑2026-11-19 · https://skipbox.dev/he/guides/pnpm-turborepo-monorepo-github-actions
