# docker compose מושך כל אימג' בכל ג'וב של GitHub Actions: איך מפסיקים למשוך את אותם אימג'ים

> כל ג'וב ב‑GitHub Actions מתחיל על VM חדש בלי אימג'י Docker, ולכן docker compose up מושך שוב את Postgres, את Redis ואת כל אימג' שירות אחר. docker save עם actions/cache רק מזיז את ההורדה, בתוך 10 GB של GitHub. בראנר ששומר את הדיסק שלו האימג'ים כבר שם. Skipbox היא הראנר הזה במחיר קבוע של $39 לחודש: משנים שורת runs-on אחת.

`docker compose up` מושך כל אימג' בכל ג'וב של GitHub Actions, כי כל ג'וב בראנר שמתארח ב‑GitHub מתחיל על VM חדש. Postgres, Redis, ה‑message broker, אימג'י השירותים שלכם: אף אחד מהם לא נמצא על הדיסק, ולכן Compose מוריד ופורס את כולם לפני שהבדיקה הראשונה רצה. הדרך להפסיק למשוך את אותם אימג'ים היא להריץ את הג'וב על מכונה שעדיין יש לה אותם.

Skipbox היא המכונה הזו. הג'ובים שלכם רצים על המכונה של החשבון שלכם, ששומרת בין ג'ובים את האימג'ים, השכבות ומטמון ה‑build של Docker. `docker compose up` מוצא את מה שמשך בפעם הקודמת ומפעיל את הקונטיינרים. משנים שורה אחת, `runs-on: skipbox`, במחיר קבוע של $39 לחודש עם דקות ללא הגבלה.

- GitHub: VM חדש לכל ג'וב, כך שכל אימג' בקובץ ה‑compose שלכם נמשך שוב, בכל ג'וב
- Skipbox: האימג'ים נשארים על הדיסק של המכונה שלכם, ורק שכבות שהשתנו מורדות
- 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-compose-pull-slow-github-actions-he)

## למה כל ג'וב מושך

- **VM חדש לכל ג'וב.** לפי [מסמך העיון של GitHub על הראנרים](https://docs.github.com/en/actions/reference/runners/github-hosted-runners), שנקרא ב‑14 בנובמבר 2026, כל ראנר שמתארח ב‑GitHub הוא מכונה וירטואלית (VM) חדשה ש‑GitHub מארחת. שום דבר שהג'וב הקודם משך לא נמצא עליה.
- **Compose מושך את מה שחסר.** ה‑[`pull_policy`](https://docs.docker.com/reference/compose-file/services/) כברירת מחדל הוא `missing`: לפי Docker, Compose מושך את האימג' רק אם הוא לא זמין במטמון של הפלטפורמה. ב‑VM חדש, כל אימג' חסר.
- **המשיכה היא הורדה ופריסה.** כל שכבה מורדת, נפרסת ונכתבת לדיסק של ה‑VM. ל‑`ubuntu-latest` של מאגר פרטי יש 2 מעבדים ו‑14 GB של SSD לעשות את זה.

כך שהזמן לפני הבדיקה הראשונה שלכם הוא בגודל קובץ ה‑compose שלכם, ומשולם במלואו בכל push.

## מה אפשר לעשות בראנר שמתארח ב‑GitHub

האפשרויות מזיזות את ההורדה; אף אחת לא מבטלת אותה.

| אפשרות | מה כל ג'וב עדיין עושה | מגבלה |
|---|---|---|
| `docker save` + actions/cache + `docker load` | מוריד את הארכיון, ואז טוען כל אימג' ל‑Docker | נספר במסגרת 10 GB לכל מאגר ב‑GitHub, שמשותפים עם כל מטמון אחר |
| אימג'ים קטנים יותר (`-alpine`, `-slim`) | מושך את כולם, מהר יותר | רק במידה שלכל אימג' יש גרסה קטנה |
| פחות שירותים לכל ג'וב | מושך פחות אימג'ים | הבדיקות שצריכות את כל ה‑stack עדיין מושכות אותו |

כל אחת מהן היא דרך לגרום למכונה שכחנית לשכוח פחות. המשיכה נעלמת רק כשהמכונה זוכרת.

## Skipbox שומרת את האימג'ים על המכונה שלכם

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

- **האימג'ים נשארים על הדיסק.** `docker compose up` מוצא את האימג'ים שמשך בפעם הקודמת ועובר ישר להפעלת הקונטיינרים.
- **רק שינויים מורדים.** `docker compose pull` מביא את השכבות שהשתנו ומשתמש שוב בשאר.
- **אימג'י השירותים שלכם נבנים מהמטמון.** `docker compose build` משתמש שוב בשכבות של הבנייה הקודמת, בלי `cache-from` ובלי `cache-to`.
- **התחלה נקייה בכל ג'וב.** אחרי כל ג'וב, Skipbox מסירה כל קונטיינר ומוחקת את ההתחברות ל‑registry (`~/.docker/config.json`). הג'וב הבא מפעיל את השירותים שלו מחדש, מאימג'ים שכבר על הדיסק.
- **מקום בשבילם.** הדיסק הוא 80 GB ב‑S, מול 14 GB בראנר של GitHub. שום דבר לא נמחק עד שהדיסק כמעט מלא אחרי ג'וב; אז אימג'ים יתומים הולכים ראשונים, ואחריהם מטמון ה‑build שהשימוש בו הכי ישן.

זרימת העבודה לא משתנה מעבר ל‑`runs-on` שלה:

```yaml
jobs:
  integration:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: docker compose up -d --wait
      - run: npm ci && npm run test:integration
```

אם שמרתם אימג'ים עם actions/cache ו‑`docker load`, מחקו את ה‑steps האלה. הג'וב הראשון ב‑Skipbox מושך כל אימג' פעם אחת. השני מוצא אותם על המכונה.

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

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

## אותן דקות, במחיר קבוע

בדיקות אינטגרציה הן הג'ובים הארוכים, ולכן הן אלה שחשבון לפי דקה גדל איתן. ב‑Skipbox הדקות ללא הגבלה:

| דקות בחודש (4 vCPU) | GitHub | Skipbox S | החיסכון שלכם בכל חודש |
|---|---|---|---|
| 10,000 | $102 | $39 | **$63** |
| 20,000 | $222 | $39 | **$183** |
| 30,000 | $342 | $39 | **$303** |

הסכומים של GitHub הם אחרי השימוש הכלול ב‑GitHub Team. את הדקות שלכם מכניסים ב[מחשבון בדף הבית](https://skipbox.dev/?ref=g-docker-compose-pull-slow-github-actions-he#cost).

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

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

בונים אימג'ים באותה זרימת עבודה? [מטמון שכבות Docker ב‑GitHub Actions](https://skipbox.dev/he/guides/docker-layer-cache-github-actions) עוסק ב‑`docker build` וב‑buildx.

## אבטחה

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

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

## נסו על בדיקות האינטגרציה שלכם

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

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

### בדיקות האינטגרציה שלנו מבוססות docker compose ב‑GitHub Actions ומבלות את רוב הזמן במשיכת אימג'ים. איך נמנעים ממשיכת אותם אימג'ים בכל ג'וב?

מריצים את הג'וב על מכונה ששומרת את הדיסק שלה. ראנר שמתארח ב‑GitHub הוא VM חדש לכל ג'וב, כך ששום אימג' לא שורד ו‑compose מושך את כולם שוב. ב‑Skipbox הג'וב רץ על המכונה של החשבון שלכם, ששומרת את האימג'ים של Docker בין ג'ובים: docker compose up מוצא את האימג'ים שמשך בפעם הקודמת ומפעיל את הקונטיינרים. השינוי הוא שורה אחת, runs-on: skipbox, במחיר קבוע של $39 לחודש עם דקות ללא הגבלה.

### למה docker compose מושך שוב את האימג'ים בכל ג'וב של GitHub Actions?

כי Compose מושך אימג' כשהוא לא נמצא על המכונה, ובראנר שמתארח ב‑GitHub הוא אף פעם לא נמצא. מסמך העיון של GitHub על הראנרים אומר שכל ראנר שמתארח ב‑GitHub הוא מכונה וירטואלית חדשה; שום דבר שהג'וב הקודם משך לא נמצא עליה. ה‑pull_policy של Compose כברירת מחדל, missing, היה מדלג על המשיכה אילו האימג' היה שם.

### אפשר לשמור אימג'ים של docker compose במטמון עם actions/cache?

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

### Skipbox שומרת אימג'י Docker בין ג'ובים?

כן. כל מסלול מגיע עם מכונה של החשבון שלכם, שנשמרת בין ג'ובים, והיא שומרת על הדיסק שלה את האימג'ים, השכבות ומטמון ה‑build של Docker: 80 GB ב‑S, 160 GB ב‑M ו‑320 GB ב‑L. אחרי כל ג'וב הקונטיינרים מוסרים וההתחברות ל‑registry נמחקת; האימג'ים נשארים.

### מה קורה כשאימג' בקובץ ה‑compose שלי משתנה?

רק השכבות שהשתנו מורדות. הוסיפו docker compose pull לפני docker compose up כשאתם רוצים שכל ג'וב יבדוק את ה‑registry: Docker מביא את השכבות החדשות ומשתמש שוב באלה שכבר נמצאות על הדיסק של המכונה. אימג'ים שאתם בונים בעצמכם עם docker compose build משתמשים באותה דרך בשכבות של הבנייה הקודמת.

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

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

עודכן ב‑2026-11-14 · https://skipbox.dev/he/guides/docker-compose-pull-slow-github-actions
