# מטמון שכבות Docker ב‑GitHub Actions: למה כל בנייה מתחילה קרה, ואיך שומרים את השכבות

> כל ג'וב ב‑GitHub Actions מתחיל על VM חדש בלי מטמון build של Docker ובלי אימג'ים שנמשכו, וה‑builder שברירת המחדל של setup-buildx-action יוצר מתחיל ריק. cache-to ו‑cache-from של buildx (gha, registry, local) מחזירים שכבות כהורדות, בתוך 10 GB של GitHub. ראנר ששומר את מטמון ה‑build של Docker על הדיסק שלו לא צריך שום דבר מזה, במחיר קבוע של $39 לחודש.

מטמון השכבות של Docker הולך לאיבוד בכל הרצה של GitHub Actions כי כל ג'וב בראנר שמתארח ב‑GitHub מתחיל על VM חדש: בלי מטמון build, בלי אימג'ים שנמשכו. גם ה‑builder שברירת המחדל של docker/setup-buildx-action יוצר (`docker-container`) מתחיל ריק בכל ג'וב ומוסר בסופו. התיקון הרגיל הוא לייצא את המטמון עם buildx. `cache-to: type=gha,mode=max` ו‑`cache-from: type=gha` שומרים את השכבות במטמון ה‑Actions של GitHub, 10 GB לכל מאגר ומשותפים עם כל מטמון אחר; `type=registry` שומר אותן ב‑registry שלכם; `type=local` בתיקייה שאתם שומרים עם actions/cache. כל אחד מהם הופך בנייה מחדש להעלאה ולהורדה בכל הרצה.

Skipbox שומרת את השכבות איפה שהבנייה רצה. הג'ובים שלכם רצים על המכונה של החשבון שלכם, ששומרת בין ג'ובים את האימג'ים, השכבות ומטמון ה‑build של Docker, על דיסק של 80 GB ב‑S מול 14 GB בראנר של GitHub. `docker build` ו‑`docker compose build` משתמשים שוב בשכבות של הבנייה הקודמת, ואימג'ים ש‑compose משך כבר נמצאים על הדיסק. setup-buildx-action עובד כמו שהוא, וגם ה‑builder שלו מוצא את השכבות האלה. משנים שורה אחת, `runs-on: skipbox`, במחיר קבוע של $39 לחודש עם דקות ללא הגבלה.

- GitHub: VM חדש לכל ג'וב, כלומר בלי שכבות, בלי אימג'ים ועם builder ריק של buildx בכל הרצה
- Skipbox: מטמון ה‑build והאימג'ים של Docker נשארים על הדיסק של המכונה שלכם, כך ששכבות שלא השתנו לא נבנות מחדש ולא מורדות
- 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-docker-layer-cache-github-actions-he)

## למה כל בנייה מתחילה קרה

- **VM חדש לכל ג'וב.** לפי [מסמך העיון של GitHub על הראנרים](https://docs.github.com/en/actions/reference/runners/github-hosted-runners), כל ראנר שמתארח ב‑GitHub הוא מכונה וירטואלית (VM) חדשה ש‑GitHub מארחת. שום דבר שהג'וב הקודם בנה או משך לא נמצא עליה.
- **builder ריק.** [docker/setup-buildx-action](https://github.com/docker/setup-buildx-action) יוצר ומאתחל כברירת מחדל builder עם ה‑driver `docker-container`, וה‑`cleanup` שלו (מופעל כברירת מחדל) מסיר את ה‑builder בסוף הג'וב.
- **14 GB של דיסק.** ל‑`ubuntu-latest` של מאגר פרטי יש 2 מעבדים, 8 GB ו‑14 GB של SSD. אימג' גדול, מטמון ה‑build שלו וארכיון מטמון לפרוס עלולים לגמור את המקום ("no space left on device").

## ה‑backends של המטמון ב‑buildx, ומה כל אחד עולה

מתוך [cache backends](https://docs.docker.com/build/cache/backends/) ו‑[ניהול מטמון עם GitHub Actions](https://docs.docker.com/build/ci/github-actions/cache/) בתיעוד של Docker:

| Backend | לאן השכבות הולכות | מה כל הרצה משלמת | מגבלות |
|---|---|---|---|
| `type=gha` | מטמון ה‑Actions של GitHub | מעלה שכבות חדשות, מורידה את אלה שהיא צריכה | 10 GB לכל מאגר יחד עם כל מטמון אחר, מפונה מהישן לחדש; ה‑scope של ברירת המחדל `buildkit` נדרס בכל בנייה; ה‑API של המטמון של GitHub מגביל קצב |
| `type=registry` | אימג' מטמון נפרד ב‑registry שלכם | מושכת את המטמון מה‑registry, דוחפת את החדש | התחברות ל‑registry עם הרשאת push; האחסון והתעבורה של ה‑registry |
| `type=inline` | בתוך האימג' עצמו | מושכת את האימג' כדי לקרוא את המטמון שלו | `mode=min` בלבד: שכבות של שלבי ביניים לא נשמרות |
| `type=local` + actions/cache | תיקייה שנשמרת עם actions/cache | מורידה ופורסת את כל התיקייה, ואז מעלה אותה | גדלה בכל הרצה אלא אם [`reset=true`](https://docs.docker.com/build/cache/backends/local/) (Buildx 0.35.0 ואילך); נספרת במסגרת 10 GB |

לא משנה איזה backend תבחרו, [סדרו את ה‑Dockerfile](https://docs.docker.com/build/cache/optimize/) כך שהשכבות שמשתנות הכי מעט יבואו ראשונות: העתיקו את קובץ ה‑lock והתקינו את התלויות לפני שאתם מעתיקים את הקוד. אחרת כל commit מבטל את שכבת ההתקנה, ושום מטמון לא מחזיר אותה.

`mode=min`, ברירת המחדל, שומר רק את השכבות של האימג' הסופי. `mode=max` שומר את השכבות של כל שלב, כך שבנייה מרובת שלבים פוגעת יותר במטמון, ומעלה יותר.

הגדרה טיפוסית של `type=gha`, עם scope משלו לכל אימג':

```yaml
- uses: docker/setup-buildx-action@v4
- uses: docker/build-push-action@v7
  with:
    context: .
    tags: app:ci
    load: true
    cache-from: type=gha,scope=app
    cache-to: type=gha,scope=app,mode=max
```

**cache mounts לא שורדים.** `RUN --mount=type=cache` (המטמון של מנהל חבילות בתוך הבנייה) לא נשמר במטמון של GitHub Actions כברירת מחדל; התיעוד של Docker מפנה ל‑[buildkit-cache-dance](https://github.com/reproducible-containers/buildkit-cache-dance) כדי להעביר אותו פנימה והחוצה מ‑actions/cache, עוד הורדה והעלאה בכל הרצה.

## docker compose מושך כל אימג', בכל ג'וב

בדיקות אינטגרציה שמפעילות Postgres, Redis וכמה שירותים עם `docker compose up` מושכות כל אימג' בכל ג'וב, כי ה‑VM חדש. בראנרים שמתארחים ב‑GitHub האפשרויות רק מזיזות את ההורדה:

- לשמור את האימג'ים עם `docker save` לקובץ tar, לשמור אותו במטמון עם actions/cache, ולטעון אותו עם `docker load` בג'וב הבא. זה נספר במסגרת 10 GB, והטעינה לוקחת זמן משלה.
- לבנות את אימג'י השירותים עם buildx ועם אחד מה‑backends שלמעלה, מה שעדיין משאיר את אימג'י הבסיס למשיכה.

## כשהתיקון הוא מכונה ששומרת את המטמון של Docker

כל backend שלמעלה קיים כי ה‑builder שוכח. daemon של Docker שנשאר בין ג'ובים כבר מחזיק את השכבות של הבנייה הקודמת, את ה‑cache mounts שלה ואת כל אימג' שהוא משך, על הדיסק שלו. אין מה לייצא, אין מה לייבא, ואין 10 GB לחלוק.

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

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

- **`docker build` ו‑`docker compose build`** משתמשים שוב בשכבות של הבנייה הקודמת, בלי שינוי בזרימת העבודה.
- **האימג'ים נשארים על הדיסק.** `docker compose up` מוצא את האימג'ים שמשך בפעם הקודמת; `docker compose pull` מביא רק שכבות שהשתנו.
- **cache mounts נשארים** עם מטמון ה‑build של Docker, כך ש‑`RUN --mount=type=cache` שומר את המטמון של מנהל החבילות בלי step נוסף.
- **docker/setup-buildx-action עובד כמו שהוא.** ה‑builder שלו מתחיל מהשכבות שהבנייה הקודמת של המאגר שלכם השאירה על המכונה, ואפשר להסיר את `cache-from` ואת `cache-to`. כשהרצנו בעצמנו את ה‑CI של פרויקט ציבורי על מכונה עם 4 vCPU (19 בנובמבר 2026, הרצה אחת בכל פעם), ה‑step שבונה את האימג' נמשך 177 שניות בהרצה הראשונה ו‑4 שניות בהרצה החוזרת, עם 31 steps במצב CACHED.
- **דיסק:** שום דבר לא נמחק עד שהדיסק כמעט מלא אחרי ג'וב. אז אימג'ים יתומים הולכים ראשונים, ואחריהם מטמון ה‑build שהשימוש בו הכי ישן.

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/setup-buildx-action@v4
      - uses: docker/build-push-action@v7
        with:
          context: .
          tags: app:ci
          load: true
```

ג'וב בוחר את הגודל שלו לפי תווית:

| תווית | מכונה | דיסק | מסלול |
|---|---|---|---|
| `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 לחודש |

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

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

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

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

## אבטחה

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

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

## נסו על בניית ה‑Docker שלכם

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

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

### למה מטמון שכבות ה‑Docker הולך לאיבוד בכל הרצה של GitHub Actions?

כי כל ג'וב בראנר שמתארח ב‑GitHub מתחיל על VM חדש, בלי מטמון build ובלי אימג'ים מההרצה הקודמת. docker/setup-buildx-action מוסיף על זה: כברירת מחדל הוא יוצר builder מסוג docker-container שמתחיל ריק ומוסר בסוף הג'וב. כך שכל שכבה נבנית מחדש, אלא אם מייצאים את המטמון עם cache-to ומייבאים אותו עם cache-from, או מריצים על מכונה ששומרת את מטמון ה‑build של Docker.

### איך שומרים שכבות Docker במטמון ב‑GitHub Actions?

בראנרים שמתארחים ב‑GitHub, עם מייצאי המטמון של buildx: cache-from: type=gha ו‑cache-to: type=gha,mode=max ב‑docker/build-push-action שומרים את השכבות במטמון ה‑Actions של GitHub (10 GB לכל מאגר, משותפים עם כל מטמון אחר). type=registry שומר אותן כאימג' נפרד ב‑registry שלכם, ו‑type=local בתיקייה שאתם שומרים עם actions/cache. תנו לכל אימג' scope משלו עם type=gha, כי ה‑scope של ברירת המחדל נדרס בכל בנייה. במכונה ששומרת את הדיסק שלה, docker build משתמש שוב בשכבות בלי שום מייצא.

### למה buildx עם cache-to type=gha עדיין איטי?

כי השכבות עדיין נוסעות. עם mode=max, כל הרצה מעלה כל שכבה חדשה של כל שלב, והרצה מאוחרת יותר מורידה את השכבות שהיא צריכה. המטמון חולק את 10 GB לכל מאגר של GitHub עם כל השאר, ולכן הוא מפונה, וה‑API של המטמון של GitHub מגביל קצב לבנייה ששולחת יותר מדי בקשות. builder שכבר יש לו את השכבות על הדיסק מדלג על שני הכיוונים.

### איך מונעים מ‑docker compose למשוך את אותם אימג'ים בכל ג'וב?

בראנר שמתארח ב‑GitHub אי אפשר, רק להזיז את ההורדה: לשמור את האימג'ים עם docker save לקובץ tar, לשמור אותו במטמון עם actions/cache, ולטעון אותו עם docker load בג'וב הבא. זה נספר באותם 10 GB, וזו הורדה וטעינה בכל הרצה. במכונה ששומרת את הדיסק שלה, האימג'ים ש‑compose משך בפעם הקודמת כבר שם, ו‑docker compose pull מביא רק שכבות שהשתנו.

### צריך לשנות את זרימת העבודה כדי לשמור את המטמון של Docker ב‑Skipbox?

רק את runs-on: המכונה שלכם שומרת בין ג'ובים את האימג'ים, השכבות ומטמון ה‑build של Docker. docker build ו‑docker compose build משתמשים בהם שוב, ו‑docker/setup-buildx-action עובד כמו שהוא: ה‑builder שלו מתחיל מהשכבות שהבנייה הקודמת של המאגר שלכם השאירה על המכונה. אפשר להסיר את cache-from ואת cache-to.

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

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

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