מגבלת נפח המטמון של GitHub Actions: למה המטמון שלכם מפונה, משתחזר לאט או מפספס
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
מתוך מסמך העיון של GitHub על שמירת תלויות במטמון, החיוב של Actions והעדכון שלה על מטמונים מעל 10 GB:
| כלל | מה 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.
כדי לראות מה ממלא אותו, הציגו את הרשומות לפי גודל:
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 שומר את מטמון ההורדות של מנהל החבילות, לא את 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 של פרויקטים אמיתיים, מתוך ההרצות שלנו על הג'ובים שלהם:
- 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). - **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 פחות.
המעבר הוא שורה אחת
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
- התחברו ל‑Skipbox עם GitHub.
- התקינו את אפליקציית Skipbox ל‑GitHub ובחרו את המאגרים.
- שנו את
runs-onובצעו push.
השאירו את שלבי המטמון שלכם כמו שהם. ההרצה השנייה מוצאת את המטמונים של הראשונה על המכונה.
אבטחה
- המכונה שייכת לחשבון שלכם בלבד. ג'ובים של חברה אחרת לא רצים עליה.
- אחרי כל ג'וב נמחקים פרטי הגישה, התהליכים והקונטיינרים של הראנר. "VM חדש לכל ג'וב" נותן במקום זה לכל ג'וב מכונה חדשה.
- קוד של אנשים בלי הרשאת כתיבה (כמו pull requests מ‑forks) רץ על VM חדש שקורא את המטמונים שלכם אבל לא יכול לשנות אותם.
הפרטים נמצאים באיך הג'ובים מבודדים.
נסו על הג'וב שהמטמון שלו מפספס
תקופת הניסיון בחינם נמשכת 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.
עודכן ב‑19 בנובמבר 2026