# מגבלת נפח המטמון של GitHub Actions: למה המטמון שלכם מפונה, משתחזר לאט או מפספס

> מטמון ה‑Actions של GitHub מחזיק 10 GB לכל מאגר, מוחק את הרשומות שנקראו לפני הכי הרבה זמן כשעוברים את הנפח, ומוחק כל רשומה שלא נעשה בה שימוש 7 ימים. גם פגיעה היא הורדה ל‑VM חדש. כמה כל תיקון עולה, ולמה ראנר ששומר את הדיסק שלו הופך את רוב המטמון למיותר, במחיר קבוע של $39 לחודש.

GitHub Actions נותנת לכל מאגר 10 GB של מטמון. כשהמאגר עובר את זה, GitHub עדיין שומרת את הרשומה החדשה ומוחקת את הרשומות שנקראו לפני הכי הרבה זמן עד שהוא חוזר מתחת למגבלה, והיא מוחקת כל רשומה שאף ג'וב לא קרא 7 ימים. ענף קורא רק את המטמונים שלו ואת אלה של ענף ברירת המחדל, ולכן ההרצה הראשונה של ענף חדש מפספסת לעתים קרובות. ופגיעה היא עדיין הורדה: כל ג'וב בראנר שמתארח ב‑GitHub מתחיל על VM חדש, ולכן הוא מוריד ופורס את הארכיון שוב. אפשר להגדיל את המגבלה, ב‑$0.07 ל‑GB לחודש מעבר ל‑10 GB, ולכוונן את המפתחות, אבל ההורדה נשארת.

Skipbox מבטלת את ההורדה. הג'ובים שלכם רצים על המכונה של החשבון שלכם, שנשמרת בין ג'ובים, כך שהמטמונים של npm, pnpm, Gradle, Go ו‑Cargo והשכבות של Docker עדיין נמצאים על הדיסק שלה מהג'וב הקודם (80 GB ב‑S, מול 14 GB בראנר של GitHub). מה ש‑actions/cache שומר נשאר ליד המכונה, כך ששחזור הוא קריאה מקומית. משנים שורה אחת, `runs-on: skipbox`, במחיר קבוע של $39 לחודש עם דקות ללא הגבלה.

- GitHub: 10 GB לכל מאגר, רשומות שלא נעשה בהן שימוש 7 ימים נמחקות, וכל פגיעה מורדת שוב
- Skipbox: מטמוני חבילות והשכבות של Docker נשארים על הדיסק של המכונה שלכם, עם לפחות פי 7 משטח המטמון של GitHub
- 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-github-actions-cache-size-limit-he)

## כללי המטמון של GitHub

מתוך [מסמך העיון של GitHub על שמירת תלויות במטמון](https://docs.github.com/en/actions/reference/workflows-and-actions/dependency-caching), [החיוב של Actions](https://docs.github.com/en/billing/concepts/product-billing/github-actions) והעדכון שלה על [מטמונים מעל 10 GB](https://github.blog/changelog/2025-11-20-github-actions-cache-size-can-now-exceed-10-gb-per-repository/):

| כלל | מה GitHub עושה |
|---|---|
| נפח | 10 GB לכל מאגר כברירת מחדל, משותפים לכל הענפים וזרימות העבודה |
| מעבר לנפח | שומרת את הרשומה החדשה, ואז מוחקת רשומות לפי הגישה האחרונה, מהישנה ביותר, עד שהמאגר מתחת למגבלה. הפינוי רץ כל שעה |
| רשומות שלא בשימוש | מוחקת כל רשומה שלא נקראה יותר מ‑7 ימים |
| מגבלה גדולה יותר | בחשבון Pro, Team או Enterprise, מנהלים יכולים להגדיל את הנפח ואת מספר הימים. מעבר ל‑10 GB, $0.07 ל‑GB לחודש, לפי השיא של כל שעה. כשמגיעים לתקציב, המטמון הופך לקריאה בלבד עד מחזור החיוב הבא |
| ענפים | הרצה משחזרת מטמונים מהענף שלה ומענף ברירת המחדל; הרצה של pull request גם מענף הבסיס שלו. אף פעם לא מענף מקביל או מענף בן |
| Pull requests | המטמונים של pull request מוגבלים ל‑merge ref שלו: רק הרצות חוזרות של אותו pull request קוראות אותם |
| רשומות | אי אפשר לשנות אותן. מפתח שכבר קיים לא נשמר שוב |
| פגיעות | `cache-hit` הוא `true` רק בהתאמה מדויקת של `key`; התאמה של `restore-keys` היא `false` |
| קצב | עד 200 העלאות ו‑1,500 הורדות בדקה לכל מאגר |

## למה המטמון מפונה

10 GB אחד מחזיקים את כל מה שהמאגר שומר. כל ענף וכל pull request שומרים רשומות משלהם. matrix של שלוש גרסאות Node על שתי מערכות הפעלה שומר שש. מטמון ה‑build מסוג `type=gha` של Docker נוחת באותם 10 GB. כשהשמירות של יום מצטברות למעל המגבלה, כל שמירה חדשה מוחקת רשומה ישנה יותר, ולעתים קרובות את זו שהג'וב הבא צריך. GitHub קוראת לזה cache thrashing.

כדי לראות מה ממלא אותו, הציגו את הרשומות לפי גודל:

```bash
gh cache list --sort size_in_bytes --limit 20
```

הדף Actions › Caches של המאגר מציג את אותו דבר, עם הענף והשימוש האחרון של כל רשומה.

## למה השחזור איטי

פגיעה במטמון בראנר שמתארח ב‑GitHub היא הורדה ל‑VM חדש, ואחריה פריסה. הזמן שלה גדל עם הארכיון, כך שמטמון שגדל לכמה GB יכול לקחת כמו ההתקנה שהוא אמור לחסוך. הורדה שנתקעת נקטעת על ידי ה‑timeout של המקטעים ב‑actions/cache, 10 דקות כברירת מחדל (`SEGMENT_DOWNLOAD_TIMEOUT_MINS`).

רוב ההגדרות גם משחזרות פחות ממה שאנשים חושבים. הקלט `cache:` של [setup-node](https://github.com/actions/setup-node) שומר את מטמון ההורדות של מנהל החבילות, לא את `node_modules`: אחרי השחזור, `npm ci` עדיין מתקין כל חבילה. מטמון ה‑pip של setup-python זהה: ההורדות חוזרות, הסביבה מותקנת שוב.

## למה המטמון מפספס

- **המפתח השתנה.** מפתח עם `hashFiles('**/package-lock.json')` מפספס בכל שינוי של קובץ ה‑lock. `restore-keys` נותן התאמה חלקית, ו‑`cache-hit` מחזיר אז `false`.
- **ענף חדש.** הוא יכול לקרוא את המטמונים של ענף ברירת המחדל, לא של ענף פיצ'ר אחר. אם ענף ברירת המחדל אף פעם לא הריץ את זרימת העבודה, אין מה לקרוא.
- **פונה.** המגבלה או 7 הימים לקחו אותו.
- **הוא אף פעם לא נשמר.** אי אפשר לשנות רשומות, כך שמפתח שקיים לא נשמר שוב, והתוכן שבמטמון נשאר ישן כמו השמירה הראשונה שלו. ייתכן ש‑pull request מ‑fork בכלל לא יורשה לשמור.

**העברת קבצים לג'וב הבא באותה הרצה** היא כלי אחר. המטמון מיועד להרצה הבאה; פלט build שג'וב מאוחר יותר באותה זרימת עבודה צריך עובר דרך `actions/upload-artifact` ו‑`actions/download-artifact`. ל‑artifacts יש אחסון משלהם, בנפרד מ‑10 GB, וגם הם הורדה ל‑VM חדש.

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

- **להגדיל את המגבלה.** פחות פינויים, ב‑$0.07 ל‑GB לחודש מעבר ל‑10 GB (הדוגמה של GitHub עצמה: 200 GB בשימוש מלא הם $13.30 לחודש), בחשבון Pro, Team או Enterprise. השחזורים נשארים הורדות, ומטמונים גדולים יותר לוקחים יותר זמן להוריד.
- **לשמור פחות.** לשמור במטמון את `~/.npm` או את ה‑store של pnpm, לא את `node_modules` או פלט build. לשמור רק בענף ברירת המחדל, עם `actions/cache/restore` בכל ג'וב ו‑`actions/cache/save` באחד. זה עולה לכם זמן, ומטמון קטן יותר משחזר פחות.
- **לתקן את המפתחות.** מפתח לפי קובץ ה‑lock, להוסיף `restore-keys`, ולהריץ את זרימת העבודה על pushes לענף ברירת המחדל כדי שלענפים חדשים יהיה מה לקרוא.
- **ראנר באירוח עצמי ששומר את הדיסק שלו.** בלי הורדה, בלי 10 GB. אתם מפעילים את המכונה: עדכוני מערכת הפעלה, ניקוי בין ג'ובים בלי למחוק את המטמונים, ותיקון כשהיא נשברת.

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

המטמון קיים כי המכונה שוכחת. ראנר שמתארח ב‑GitHub הוא VM חדש לכל ג'וב, ולכן הג'וב שומר את המצב שלו באחסון של GitHub ומביא אותו בחזרה בפעם הבאה. במכונה שנשארת, המצב הזה כבר על הדיסק שלה: המטמון של מנהל החבילות, מטמון הכלים, האימג'ים ומטמון ה‑build של Docker, ואפילו פלט ה‑build.

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

- **astro (Node.js, Turborepo):** 528 שניות ב‑GitHub, 30 שניות על מכונה ייעודית ב‑Skipbox, ששומרת את המטמון של turbo, כך שההרצות החמות שלה משחזרות 40 משימות build במקום להריץ אותן.
- **helix (Rust):** השלב של סביבת הכלים והמטמון לקח 9-10 שניות על המכונה הייעודית, מול 41-46 שניות ב‑GitHub.
- **tauri (Rust):** 246 שניות ב‑GitHub, 53 שניות על המכונה הייעודית, עם `target/` שנשמר בין ג'ובים.

## Skipbox שומרת את המטמון על המכונה שלכם

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

- **מטמוני חבילות נשארים על הדיסק:** `~/.npm`, ה‑store של pnpm, ה‑`~/.cache` של כל כלי, והמטמונים של Go, Gradle, Cargo ו‑Maven, יחד עם הכלים ש‑`setup-*` התקינו. אין מה לשחזר.
- **גם האימג'ים, השכבות ומטמון ה‑build של Docker נשארים.** `docker build` משתמש שוב בשכבות של הבנייה הקודמת ([מטמון שכבות Docker](https://skipbox.dev/he/guides/docker-layer-cache-github-actions)).
- **actions/cache, setup-* ו‑rust-cache לא צריכים שינוי.** מה שהם שומרים נשאר ליד המכונה במקום באחסון של GitHub, עם יותר מקום מ‑10 GB לכל מאגר של GitHub, ושחזור קורא אותו מקומית.
- **בלי תפוגה של 7 ימים על הדיסק.** שום דבר לא נמחק עד שהדיסק כמעט מלא אחרי ג'וב; אז מה שהשימוש בו הכי ישן הולך ראשון.

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

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

ל‑`ubuntu-latest` של מאגר פרטי יש 2 מעבדים, 8 GB ו‑14 GB של SSD. ב‑Skipbox הדקות ללא הגבלה. ב‑20,000 דקות בחודש על 4 vCPU, GitHub גובה $222; Skipbox S עולה $39, $183 פחות.

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

```yaml
jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci && npm test
```

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

השאירו את שלבי המטמון שלכם כמו שהם. ההרצה השנייה מוצאת את המטמונים של הראשונה על המכונה.

## אבטחה

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

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

## נסו על הג'וב שהמטמון שלו מפספס

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

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

### מהי מגבלת נפח המטמון של GitHub Actions?

10 GB לכל מאגר כברירת מחדל, לכל הענפים וזרימות העבודה יחד. מעבר לזה, GitHub עדיין שומרת את הרשומה החדשה ומוחקת רשומות לפי סדר הגישה האחרונה, מהישנה ביותר, עד שהמאגר שוב מתחת למגבלה. רשומות שאף ג'וב לא קרא 7 ימים נמחקות בלי קשר לנפח. בחשבון Pro, Team או Enterprise, מנהלים יכולים להגדיל את הנפח ואת מספר הימים; אחסון מעבר ל‑10 GB מחויב ב‑$0.07 ל‑GB לחודש, לפי השיא של כל שעה, וכשמגיעים לתקציב המטמון הופך לקריאה בלבד עד מחזור החיוב הבא.

### למה המטמון שלי ב‑GitHub Actions מפונה כל כך הרבה?

כי כל מה שבמאגר חולק 10 GB אחד: כל ענף, כל pull request, כל ג'וב ב‑matrix וכל מערכת הפעלה שומרים רשומות משלהם, ומטמון ה‑type=gha של Docker נוחת באותו מקום. כשהשמירות של יום מצטברות למעל המגבלה, כל שמירה מוחקת רשומה ישנה יותר, והג'וב הבא מפספס את זו שהיה צריך. GitHub קוראת לזה cache thrashing. הציגו את הרשומות לפי גודל (gh cache list --sort size_in_bytes) כדי לראות מה ממלא אותו.

### למה שחזור המטמון לוקח כמו התקנה מאפס?

כי פגיעה היא עדיין הורדה. כל ג'וב בראנר שמתארח ב‑GitHub מתחיל על VM חדש, כך ש‑actions/cache מוריד את הארכיון ופורס אותו בכל פעם, וככל שהמטמון גדול יותר זה לוקח יותר זמן. המטמון של setup-node מחזיר את מטמון ההורדות של מנהל החבילות, לא את node_modules, כך ש‑npm ci עדיין מתקין כל חבילה אחרי השחזור. בראנר ששומר את הדיסק שלו, המטמונים כבר שם ושום דבר לא מורד.

### למה actions/cache מפספס בענף חדש?

הרצה יכולה לשחזר מטמונים מהענף שלה ומענף ברירת המחדל, והרצה של pull request גם מענף הבסיס שלו. היא לא יכולה לקרוא מטמונים של ענף מקביל. כך שההרצה הראשונה של ענף פיצ'ר פוגעת רק אם ענף ברירת המחדל שמר את המפתח הזה. הריצו את זרימת העבודה על pushes לענף ברירת המחדל כדי שהוא ישמור, והוסיפו restore-keys להתאמה חלקית; cache-hit הוא true רק בהתאמה מדויקת של key.

### כמה מטמון Actions Skipbox שומרת?

יותר מ‑10 GB לכל מאגר של GitHub, ליד המכונה שלכם במקום באחסון של GitHub. במכונת ענן, מה שג'ובים שומרים עם actions/cache, setup-* ו‑rust-cache נשאר על הדיסק של המכונה עצמה, עד חצי מהדיסק הזה (80 GB ב‑S, 160 GB ב‑M, 320 GB ב‑L); במארח של Skipbox, המטמון של המארח שומר 20 GB לכל מאגר. בשני המקרים רשומה נשמרת 7 ימים אחרי השימוש האחרון בה, עם כללי הענפים של GitHub. מטמוני חבילות והשכבות של Docker לא עוברים דרכו: הם נשארים על הדיסק עצמו.

### מה מנקה את המטמונים במכונה של Skipbox?

שום דבר בין ג'ובים: המטמונים נשארים על המכונה, ורק כשג'וב משאיר את הדיסק כמעט מלא, מה שהשימוש בו הכי ישן הולך ראשון. המכונה מתחילה נקייה באיפוס: כשאתם לוחצים על "איפוס המכונה", כשהאימג' שלה מתעדכן (לפחות פעם בחודש), כשהיא נכשלת בבדיקת התקינות אחרי ג'וב, וכשג'וב מגיע למגבלה של 6 שעות. כשהמסלול מסתיים, המכונה נמחקת יחד עם הדיסק שלה.

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

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

עודכן ב‑2026-11-19 · https://skipbox.dev/he/guides/github-actions-cache-size-limit
