Skipbox

מגבלת נפח המטמון של 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:

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

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. ג'וב בוחר את הגודל שלו לפי תווית:

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

CI/CD מהיר יותר עם מטמון שתמיד חם

הראנר החם שלכם, במחיר קבוע

אנחנו מארחים אותם. אתם משנים שורה אחת. 1/12 מהעלות ב‑GitHub בשימוש מלא. מחיר קבוע, אז אפשר להריץ כל היום. שטח מטמון גדול פי 7 מזה של GitHub.

  • בלי כרטיס
  • התחברות עם GitHub
  • ביטול בכל עת