# איך מאיצים GitHub Actions: לקצץ pipeline של 25 דקות, מנוף אחרי מנוף

> pipeline איטי של GitHub Actions הוא ג'ובים שמחכים זה לזה, עבודה שלא הייתה צריכה לרוץ, הכנה שחוזרת על VM ריק, ו‑steps שתלויים במעבד על 2 ליבות. תקנו אותם לפי הסדר הזה. שני האחרונים הם המכונה: Skipbox שומרת את המטמונים שלכם על מכונה ייעודית בין ג'ובים, עם עד 16 vCPU, במחיר קבוע של $39 לחודש עם דקות ללא הגבלה.

pipeline של 25 דקות ב‑GitHub Actions הוא בדרך כלל ארבעה עיכובים זה על זה: ג'ובים שמחכים זה לזה, עבודה שלא הייתה צריכה לרוץ, הכנה ש‑VM ריק חוזר עליה בכל ג'וב, ו‑steps שתלויים במעבד דחוסים על 2 ליבות (ל‑`ubuntu-latest` של מאגר פרטי יש 2 מעבדים ו‑8 GB). טפלו בהם לפי הסדר הזה. קודם, מדדו את הנתיב הקריטי, כשזמן ההמתנה בתור בנפרד. אחר כך דלגו על מה שלא היה צריך לרוץ, הריצו ג'ובים עצמאיים במקביל, הפסיקו לבנות מצב מחדש, תנו ל‑steps הכבדים יותר ליבות, ופצלו את מה שעדיין ארוך. שלושת הראשונים הם תיקונים בזרימת העבודה שלא עולים כלום. השאר הם המכונה: ראנר ששומר את המטמונים שלו בין ג'ובים ויש לו יותר ליבות.

Skipbox היא הראנר הזה. הג'ובים שלכם רצים על המכונה של החשבון שלכם, ששומרת שכבות Docker, מטמוני חבילות, כלים ופלט build בין ג'ובים, עם 4 עד 16 vCPU, במחיר קבוע של $39 לחודש עם דקות ללא הגבלה. ב‑CI של astro זה היה 528 s ב‑GitHub ו‑30 s ב‑Skipbox. המעבר הוא שורה אחת: `runs-on: skipbox`.

- המנופים לפי הסדר: למדוד, לדלג, להריץ במקביל, להפסיק לבנות מחדש, להוסיף ליבות, לפצל
- המכונה שלכם שומרת מטמונים ופלט build בין ג'ובים: ה‑CI של astro ירד מ‑528 s ל‑30 s
- 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-speed-up-github-actions-he)

## 1. מדדו את הנתיב הקריטי

הזמן שהצוות שלכם מחכה הוא שרשרת הג'ובים שמסתיימת אחרונה, לא הסכום של כל הג'ובים. פתחו הרצה של pull request מייצג: הגרף מראה אילו ג'ובים מחכים לאילו, והלוג של כל ג'וב מראה את זמני ה‑steps שלו. רשמו, לשרשרת האיטית ביותר:

| שלב | מה לבדוק |
|---|---|
| בתור | הג'וב חיכה לראנר? פקודה מהירה יותר לא יכולה לקצר תור |
| הקמת הג'וב, checkout | אימג' קונטיינר שנמשך, clone מלא איפה ש‑shallow היה מספיק |
| סביבת כלים והתקנה | המטמון פגע, והפגיעה חסכה יותר ממה שהשחזור לקח? |
| Build | אותו פלט נבנה בג'וב אחר? |
| בדיקות | המעבד של הראנר עסוק כל הזמן, או ש‑worker אחד עושה הכול? |
| העלאות | artifacts ושמירות מטמון אחרי שהעבודה המועילה נגמרה |

השוו הרצה חמה להרצה קרה. מטמון שמחטיא חצי מהזמן נראה בסדר בממוצע.

## 2. דלגו על מה שלא היה צריך לרוץ

- **בטלו הרצות שהוחלפו.** כל push אחרי הראשון הופך את ההרצה שבתהליך לחסרת טעם. [קבוצת concurrency](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) עם `cancel-in-progress` עוצרת אותה. הגבילו אותה ל‑pull requests כדי ש‑push לענף ברירת המחדל אף פעם לא יבטל פריסה:

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
```

- **הריצו רק את מה שהשינוי נוגע בו.** מסנני `paths:` מדלגים על זרימת עבודה בשינויים של תיעוד בלבד; ב‑monorepo, `turbo run test --affected` או פקודות ה‑affected של Nx מריצים רק את החבילות שהשתנו. סינון ברמת הטריגר אומר שבדיקת חובה אף פעם לא מדווחת, אז סננו בתוך הג'וב כשהבדיקה היא חובה.

## 3. הריצו ג'ובים עצמאיים במקביל

GitHub מריצה ג'ובים במקביל אלא אם `needs:` משרשר אותם. Lint, בדיקות טיפוסים, בדיקות יחידה וה‑build רק לעתים רחוקות צריכים זה את זה: הפעילו אותם יחד ותנו רק לאריזה או לפריסה לחכות לכולם. אם שני ג'ובים בונים את אותו דבר, בנו אותו פעם אחת והעבירו אותו עם `actions/upload-artifact`, ומדדו את זמן ההעלאה וההורדה.

## 4. הפסיקו לבנות מחדש את אותו מצב

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

- **מטמונים שבאמת פוגעים.** ה‑`cache: npm` של `actions/setup-node` (וגרסאות ה‑pnpm וה‑yarn שלו) שומר את ההורדות של מנהל החבילות עם מפתח לפי ה‑lockfile; הוא לא שומר את `node_modules`, כך שההתקנה עדיין רצה. GitHub שומרת 10 GB לכל מאגר, מוחקת רשומות שלא היו בשימוש 7 ימים, ופגיעה היא עדיין הורדה ל‑VM החדש ([מגבלת גודל המטמון](https://skipbox.dev/he/guides/github-actions-cache-size-limit)).
- **מטמוני כלים.** `eslint --cache`, `tsc --incremental`, תיקיית המטמון של Jest וה‑`.turbo/cache` של turbo שומרים את העבודה עצמה, לא את ההורדות. על VM חדש הם ריקים אלא אם משחזרים גם אותם.
- **שכבות Docker.** `docker build` על VM חדש מתחיל בלי שכבות; ייצוא שלהן עם `cache-to` של buildx וייבוא שלהן בכל הרצה הוא הפתרון העוקף ([מטמון שכבות Docker](https://skipbox.dev/he/guides/docker-layer-cache-github-actions)).

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

## 5. תנו ל‑steps הכבדים יותר ליבות

קומפיילרים, bundlers וכלי בדיקות מפעילים worker אחד לכל ליבה, כך שעל 2 מעבדים הם מריצים שניים בכל פעם. בדקו במה כלי הבדיקות באמת משתמש: [Jest](https://jestjs.io/docs/cli#--maxworkersnumstring) משתמש כברירת מחדל במספר הליבות פחות אחת (worker אחד על 2 מעבדים), pytest רץ טורית עד `-n auto`, ו‑[Playwright](https://playwright.dev/docs/ci#workers) משתמש כברירת מחדל בחצי מהליבות, והתיעוד שלו ממליץ על worker אחד ב‑CI. יותר ליבות עוזרות רק אחרי שאומרים לכלי להשתמש בהן, ורק ב‑steps שמעסיקים את המעבד; הורדה או הפעלה של מסד נתונים לא מואצות.

ב‑GitHub, יותר ליבות פירושו [ראנרים גדולים](https://docs.github.com/en/actions/concepts/runners/larger-runners): 4 עד 96 ליבות, רק בארגונים ב‑GitHub Team או ב‑Enterprise Cloud, בחיוב לפי דקה בתעריף גבוה יותר לכל ליבה.

## 6. פצלו את מה שעדיין ארוך

matrix של shards מחלק סט ארוך בין ג'ובים. הוא מקצר את זמן ההמתנה, לא את הדקות: כל shard עושה checkout, מתקין ובונה שוב, כך שארבעה shards משלמים על ההכנה ארבע פעמים. אזנו את ה‑shards לפי זמן שנמדד, לא לפי מספר קבצים, והפסיקו להוסיף אותם כשההכנה היא רוב כל shard.

## כמה עולה להישאר איטיים

pipeline של 15 דקות שרץ 40 פעמים ביום הוא 10 שעות של המתנה שמתפזרות על הצוות שלכם, בכל יום, עוד לפני שמישהו סופר את החלפות ההקשר. בחיוב לפי דקה, דקות הכנה מחויבות כמו דקות בדיקה:

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

יותר ליבות ב‑GitHub עולות יותר לדקה, כך שהפער גדל עם המכונה:

| 20,000 דקות בחודש | GitHub | Skipbox | החיסכון שלכם בכל חודש |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | **$343** |
| 16 vCPU | $822 | $149 (L) | **$673** |

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

## כשהתיקון הוא המכונה

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

| פרויקט | GitHub | Skipbox, מכונה ייעודית | מה המכונה שמרה |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | **30 s** | המטמון של turbo: 40 משימות build שוחזרו |
| tauri (Rust) | 246 s | **53 s** | ה‑`target/` של Cargo: אף crate לא קומפל שוב |
| ripgrep (Rust) | 200 s | **40 s** | ה‑`target/` ואימג' ה‑Docker של cross |
| vite (Node.js) | 141 s | 100 s | מטמוני חבילות; השאר הוא הבדיקות שלו שרצות |

ל‑`ubuntu-latest` של מאגר פרטי יש חצי מהליבות של הרצות GitHub האלה.

## מה Skipbox עושה ל‑pipeline שלכם

**שומרת את המכונה.** כל מסלול מגיע עם מכונה של החשבון שלכם, שנשמרת בין ג'ובים. אימג'ים, שכבות ומטמון build של Docker, מטמוני חבילות, מטמון הכלים, וה‑checkout שלכם עם ה‑`target/` של Cargo והמטמון של turbo נשארים על הדיסק שלה: לפחות פי 7 משטח המטמון של GitHub, בלי מפתחות, בלי תפוגה אחרי 7 ימים ובלי כלל ענפים.

**מוסיפה ליבות במחיר קבוע.** ג'וב בוחר את הגודל שלו לפי תווית:

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

הדקות ללא הגבלה, כך ש‑shards, הרצות חוזרות ו‑matrix גדול יותר לא מעלים את החשבון. ג'ובים של Skipbox לא מנצלים דקות של GitHub, כך שתקציב של GitHub אף פעם לא עוצר אותם.

**דואגת לעצמה.** Skipbox מקימה את המכונה, שומרת את האימג' מעודכן, מנקה אחרי כל ג'וב, ובונה מחדש מכונה שנכשלת בבדיקת התקינות.

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

```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.

ה‑steps וה‑actions שלכם רצים כמו שהם, על Ubuntu 24.04 עם Docker, Node.js ו‑Python.

## אבטחה

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

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

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

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

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

### ה‑pipeline שלנו ב‑GitHub Actions לוקח 25 דקות. מה הדרך הכי מהירה להאיץ אותו?

עברו עליו לפי הסדר. קראו את הגרף ואת זמני ה‑steps של ההרצה כדי למצוא את שרשרת הג'ובים שקובעת את הזמן, כשזמן ההמתנה בתור בנפרד. בטלו הרצות שהוחלפו ודלגו על ג'ובים שהקבצים שלהם לא השתנו. הסירו needs: שמבטאים רק הרגל, כך שג'ובים עצמאיים ירוצו במקביל. הפסיקו לבנות מצב מחדש בכל ג'וב: מטמונים שבאמת פוגעים, או ראנר ששומר את הדיסק שלו. תנו ל‑steps שתלויים במעבד יותר ליבות ותנו לכלי הבדיקות להשתמש בהן. פצלו רק את מה שעדיין ארוך. ב‑ubuntu-latest של מאגר פרטי (2 מעבדים, 8 GB), שלושת האחרונים הם לעתים קרובות רוב 25 הדקות, והם של המכונה: Skipbox נותנת לג'וב מכונה ייעודית ששומרת מטמונים בין ג'ובים, עם 4 עד 16 vCPU.

### שווה לעבור לראנרים מהירים יותר לעומת אופטימיזציה של זרימת העבודה?

עשו קודם את התיקונים החינמיים בזרימת העבודה: ביטול הרצות שהוחלפו, סינון נתיבים והסרת needs: מיותרים לא עולים כלום ואף ראנר לא עושה אותם בשבילכם. אחרי זה, הסתכלו לאן הולך הזמן שנשאר. הכנה שחוזרת בכל ג'וב (סביבות כלים, התקנות תלויות, בניות Docker) ו‑steps שמעסיקים כל ליבה הם הבעיה של המכונה, וראנר ששומר את המטמונים שלו ויש לו יותר ליבות מסיר אותם בשינוי של שורת runs-on אחת. המתנות רשת ו‑steps טוריים לא מואצים עם מכונה גדולה יותר.

### למה GitHub Actions איטי יותר מהמחשב הנייד שלי?

המחשב הנייד שלכם שומר את החבילות, הכלים, שכבות ה‑Docker ופלט ה‑build שלו על הדיסק, ובדרך כלל יש לו 8 ליבות או יותר. ג'וב ב‑ubuntu-latest של מאגר פרטי מקבל 2 מעבדים ו‑8 GB, על VM חדש שאין בו שום דבר מזה. Skipbox עובדת כמו המחשב הנייד שלכם: המכונה נשארת בין ג'ובים, עם 4 vCPU או יותר.

### פיצול בדיקות (sharding) מאיץ את GitHub Actions?

הוא מקצר את זמן ההמתנה, לא את הדקות. כל shard הוא ג'וב חדש שעושה checkout, מתקין ובונה שוב, כך שארבעה shards משלמים על ההכנה ארבע פעמים, וחיוב לפי דקה סופר כל אחת. פצלו אחרי שההכנה זולה והליבות של הראנר בשימוש. ב‑Skipbox ההכנה נשארת על הדיסק והדקות ללא הגבלה, כך ש‑shards לא עולים שום דבר נוסף.

### איך מקבלים יותר מ‑4 ליבות לג'וב ב‑GitHub Actions?

ב‑GitHub, ראנרים גדולים מגיעים ב‑4 עד 96 ליבות, רק לארגונים ב‑GitHub Team או ב‑Enterprise Cloud, בחיוב לפי דקה. ב‑Skipbox, שנו את runs-on ל‑skipbox-8x16 בשביל 8 vCPU או ל‑skipbox-16x32 בשביל 16 vCPU, במחיר חודשי קבוע, בארגונים ובחשבונות אישיים כאחד.

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

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

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