# לאן הלכו 23 שניות: הפעלת VM לג'וב של GitHub Actions ב‑7

> מכונה וירטואלית חדשה של KVM לג'וב אחד של GitHub Actions לקחה 22.9 s עד שהגיעה לראנר שלה במארחים של Skipbox. עכשיו זה לוקח 7.25 s. כל שנייה ואיך היא נמדדה, מהראנר במחיר קבוע של $39 לחודש עם דקות ללא הגבלה.

מכונה וירטואלית חדשה לג'וב אחד של GitHub Actions לקחה 22.9 שניות על מארח של Skipbox כדי להגיע מ"המארח קיבל את הג'וב" ל"תהליך הראנר מתחיל". עכשיו זה לוקח 7.25 שניות. הפוסט הזה מספר איפה היו 15 השניות האחרות ואיך כל אחת נמדדה.

Skipbox היא ראנר ל‑GitHub Actions במחיר קבוע של $39 לחודש עם דקות ללא הגבלה. הג'ובים שלכם רצים על המכונה של החשבון שלכם, שנשמרת בין ג'ובים, והג'ובים שצריכים VM חדש מקבלים אחד ב‑7 שניות. שנו שורת `runs-on` אחת כדי לעבור.

- VM חדש לג'וב מגיע לראנר שלו ב‑7.25 s, ירידה מ‑22.9 s
- על המכונה החמה שלכם, ה‑steps של ההכנה של ג'וב לוקחים 7 s מול 52 s ב‑`ubuntu-latest` של GitHub
- 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=blog-github-actions-job-vm-boot-7-seconds-he)

## מה נמדד, ועל מה

מארח של Skipbox מריץ מכונות וירטואליות של KVM דרך Incus על pool של ZFS. אימג' הראנר הוא VM עצור עם snapshot. ג'וב שצריך VM חדש מקבל clone של ZFS מה‑snapshot הזה, מעלה אותו, מקבל תצורת ראנר just-in-time דרך ה‑guest agent, מריץ ג'וב אחד, ונמחק עם הדיסק שלו.

ה‑daemon של המארח רושם ללוג את הסוף של כל שלב בהפעלה במילישניות מהרגע שהוא מקבל את הג'וב (`startMs`: `cloned`, `started`, `agent`). המספרים למטה הם ממארח Intel i7-7820X עם 16 threads ו‑VM של 4 vCPU ו‑8 GB.

| | מקבלת הג'וב ועד תחילת הראנר, 3 הרצות לכל אחד |
|---|---|
| לפני | 22.9 s (21.7 עד 24.2) |
| אחרי | 7.25 s (7.1 עד 8.1) |

לאן זה הלך, כל חלק נמדד בנפרד:

| שינוי | נמדד | נחסך |
|---|---|---|
| SeaBIOS במקום OVMF | מהפעלת ה‑VM ועד התשובה הראשונה של ה‑agent, חציון של 3: 13.7 → 8.4 s | 5.3 s |
| `quiet` בשורת הפקודה של הקרנל | 8.4 → 6.5 s | 1.9 s |
| בלי initrd | 6.5 → 5.1 s | 1.4 s |
| אימג' שכבר בגודל של ה‑clones שלו | Clone 1.5 → 0.1 s, הפעלה ראשונה 2.35 → 1.8 s | 1.9 s |
| לחכות ל‑socket של Docker, לא ל‑dockerd | dockerd עלה 3.6 s אחרי ה‑agent | 3.6 s |
| לשאול את ה‑guest agent כל 100 ms, לא כל שנייה | 0.5 s בממוצע, עד 1 s | 0.5 s |

החלקים מצטברים ל‑14.6 s מתוך ההפרש של 15.65 s מקצה לקצה.

## Firmware: 5.3 שניות לפני GRUB

Incus מעלה VM עם OVMF ו‑secure boot כברירת מחדל. במארח הזה OVMF לקח 5.3 s עד שהעביר את השליטה ל‑GRUB. SeaBIOS לוקח 0.5 s. שני מפתחות של המופע מחליפים את זה: `security.csm=true` ו‑`security.secureboot=false`.

זה היה החלק היחיד הגדול ביותר, והיחיד שנוגע באבטחה, אז הנה הוא במלואו. עם SeaBIOS שרשרת האתחול של האורח לא נבדקת בחתימה. מה שהבדיקה הזו מגינה מפניו הוא מישהו שמחליף את ה‑bootloader או את הקרנל של האורח. ב‑VM של ג'וב CI המישהו הזה הוא הג'וב, והג'וב כבר מחזיק root ב‑VM שלו: הוא יכול להריץ כל דבר עם `sudo`, וה‑VM והדיסק שלו נמחקים כשהג'וב מסתיים. מה שמרחיק VM של לקוח אחד מזה של אחר הוא KVM ושרשרת חומת אש לכל VM על ה‑bridge של המארח, ואף אחד מהם לא תלוי ב‑firmware של האורח. האימג' עולה תחת שניהם, ודגל אחד על המארח מחזיר את UEFI.

## קרנל שקט, ובלי initrd

VM של ג'וב עולה פעם אחת לכל ג'וב, ואף אחד לא קורא את הקונסולה הטורית שלו. `quiet` הוריד את החציון מ‑8.4 ל‑6.5 s.

ה‑initrd קיים כדי לטעון את הדרייברים שמוצאים את מערכת הקבצים הראשית. בקרנל הגנרי של Ubuntu virtio-scsi ו‑ext4 מובנים, וכל clone חולק את ה‑UUID של המחיצה של האימג', כך שהקרנל מעגן את `/` ישירות מ‑`root=PARTUUID=…`. זה היה עוד 1.4 s.

שתי הגנות מונעות מזה להשתבש בשקט. ה‑GRUB של Ubuntu עולה בפעם הבאה עם ה‑initrd מעצמו אם אתחול בלעדיו נכשל ב‑panic (`GRUB_FORCE_PARTUUID`). הנפילה לאחור הזו הייתה מחזירה בשקט את 1.4 השניות לכל ג'וב, אז בניית האימג' מעלה clone לבדיקה ונכשלת אם `dmesg` מראה initramfs שנפרס.

## אל תשנו גודל של דיסק שיכולתם לבנות בגודל הנכון

האימג' נבנה על דיסק קטן יותר, וכל clone הוגדל לגודל של המסלול שלו בהפעלה. ההגדלה עלתה 1.9 s לכל ג'וב: ה‑clone לקח 1.5 s במקום 0.1 s, וההפעלה הראשונה 2.35 s במקום 1.8 s. האימג' נבנה עכשיו בגודל הדיסק של המסלול הקטן ביותר (80 GB). ה‑volume דליל, כך שהאימג' עדיין מחזיק רק את מה שנכתב אליו. Incus לא יכול להקטין clone, אז האימג' אף פעם לא גדול מהמסלול הקטן ביותר; מסלולים גדולים יותר גדלים באתחול.

## ה‑socket של Docker מספיק

סקריפט ההרצה נהג לחכות ל‑`docker.service` לפני שהפעיל את הראנר. dockerd עלה 3.6 s אחרי ה‑guest agent. אבל systemd מאזין ל‑socket של Docker מתחילת האתחול, ו‑client שמתחבר לפני ש‑dockerd עלה מחכה לו. אז הסקריפט מחכה רק ל‑`docker.socket` ול‑DNS, עם המתנה מוגבלת, ו‑dockerd מסיים לעלות בזמן שהראנר עולה.

## תשאול כל 100 ms

התצורה של הראנר נדחפת לתוך ה‑VM דרך ה‑guest agent, שלא קיים עד שהאורח עלה. המארח ניסה שוב פעם בשנייה, כך שג'וב חיכה 0.5 s בממוצע אחרי שה‑agent עלה. Incus דוחה דחיפה תוך 20 ms כשה‑agent לא זמין, כך ששאלה כל 100 ms לא עולה כלום. אחרי 30 השניות הראשונות של VM המארח חוזר לפעם בשנייה.

## לא תיקון אתחול: fsync על דיסק שמת עם הג'וב

תוך כדי מדידה, הדבר האיטי ביותר ב‑VM התברר כלא האתחול. כל `fsync` באורח חיכה ש‑ZFS של המארח יבצע commit ל‑intent log שלו. הדיסק של VM חדש לג'וב נמחק עם הג'וב, כך ששום דבר עליו לא צריך לשרוד הפסקת חשמל. סקריפט ההרצה מעגן מחדש את `/` עם `nobarrier` לפני שהוא מפעיל את הראנר.

חציונים של 3, ב‑VM של 4 vCPU ו‑8 GB:

| | לפני | אחרי |
|---|---|---|
| כתיבות אקראיות של 4k עם fsync | 227 בשנייה | 2,505 בשנייה |
| `yarn install`, 1 GB של node_modules מהמטמון שלו | 12.92 s | 9.99 s (23% פחות) |
| `docker pull node:22` | 19.12 s | 15.45 s (19% פחות) |
| בניית Docker של redis | 92.89 s | 87.21 s |
| `make -j4`, `sysbench cpu` | ללא שינוי | ללא שינוי |

רק VMs חדשים מקבלים את זה. המכונה שלכם מחזיקה את המטמונים שלכם בין ג'ובים, וה‑ext4 שלה שומר על ה‑barriers שלו.

## אותו ציד על שרתי ענן שכורים

כשהמארחים של Skipbox עצמה מלאים, ג'וב רץ על שרת ענן שמועלה מאימג' snapshot. לנתיב הזה היה זמן אבוד משלו, במקום אחר. בשרת משותף של Intel עם 4 vCPU, סקריפט הג'וב (ה‑user data של השרת) התחיל 28.1 s אחרי הקרנל. ל‑cloud-init היה הסקריפט ב‑19.3 s ו‑Docker עלה ב‑22.2 s, אבל cloud-init מריץ user data בשלב האחרון שלו, אחרי כל השאר.

לאימג' יש עכשיו unit קטן של systemd שמריץ את ה‑user data ברגע ש‑cloud-init כתב אותו. הוא קורא את הסקריפט דרך file descriptor מקובץ שהוא כבר הסיר, כך שהשלב האחרון של cloud-init לא מוצא שום דבר להריץ פעם שנייה. האימג' גם יוצר סוג אחד של מפתח SSH של המארח במקום שלושה (2.0 s על הנתיב שהכול מחכה לו; אף אחד לא מתחבר לשרתים האלה), וכבר לא מפעיל באתחול את snapd, apport, rsyslog או תריסר timers של תחזוקה.

עם האימג' הזה, בשרת משותף של AMD עם 4 vCPU, סקריפט הג'וב מתחיל 8 עד 14 s אחרי הקרנל.

## vCPUs מוצמדים שומרים על השעון של כל מארח מדויק

במעבד היברידי (ליבות ביצועים וליבות יעילות, כמו Core Ultra 7 265F), KVM עלול להפסיק לסמוך על ה‑TSC. במהלך לילה של בניות אימג'ים, הקרנל רשם ללוג:

```
tsc: Marking TSC unstable due to KVM discovered backwards TSC
clocksource: Switched to clocksource acpi_pm
```

KVM משווה את ה‑TSC כש‑vCPU עובר למעבד מארח אחר. הוא קרא ערך נמוך יותר בליבה החדשה, בין סוגי ליבות, וסימן את ה‑TSC כלא יציב. הקרנל כבר כיבה את HPET באתחול ("HPET dysfunctional in PC10"), כך שמקור השעון היחיד שנשאר היה acpi_pm, שבלוח הזה כמעט לא התקדם: בערך 1 שנייה של uptime ב‑30 דקות.

Skipbox מתקנת את זה בשני צעדים:

1. **נפילה לאחור שעובדת.** הגבלת ה‑C-state של החבילה ל‑C8 ב‑BIOS שומרת את HPET בחיים. KVM עדיין הפיל את ה‑TSC, בסבב 11 של לולאה של 20 סבבים שמפעילה ועוצרת VM של 8 vCPU תחת עומס, אבל השעון עבר ל‑HPET ושמר על הזמן.
2. **נעיצה.** KVM מריץ את הבדיקה הזו רק כש‑vCPU עובר. כשכל vCPU נעוץ למעבד מארח אחד, אותה לולאה רצה 40 סבבים על ה‑TSC בלי שורה חדשה בלוג.

ה‑daemon של המארח לא לוקח אף ג'וב אלא אם מקור השעון הוא `tsc` ו‑`hpet` זמין, כך שמארח שמפיל את ה‑TSC שלו מתרוקן מעצמו והג'ובים שלו הולכים למכונות אחרות. כל מארח של Skipbox נועץ את ה‑vCPUs שלו.

## האתחול המהיר ביותר הוא זה שמדלגים עליו

שבע שניות הן לג'ובים שצריכים VM חדש: קוד של אנשים בלי הרשאת כתיבה (כמו pull requests מ‑forks), ג'וב שמגיע כשהמכונה שלכם עסוקה, וחשבונות שבוחרים VM נקי לכל ג'וב. כל ג'וב אחר לא מעלה כלום. הוא רץ על המכונה של החשבון שלכם, עם שכבות ה‑Docker, מטמוני החבילות והכלים של הג'וב הקודם שעדיין על הדיסק שלה.

שם נמצאות הדקות. אותן זרימות עבודה ב‑`ubuntu-latest` של GitHub (2 vCPU, מה שמאגר פרטי מקבל) וב‑Skipbox S חם (4 vCPU), חציונים של הרצות חמות:

| | `ubuntu-latest` של GitHub | Skipbox S, חם | |
|---|---|---|---|
| excalidraw: התקנה, build ובדיקות | 613 s | 450 s | 27% פחות |
| steps של הכנה (checkout, Node, שחזור מטמון) | 52 s | 7 s | |
| בדיקות | 484 s | 354 s | |
| umami: בניית Docker רב-שלבית | 263 s | 188 s | 29% פחות |

ה‑steps של ההכנה יורדים מ‑52 s ל‑7 s כי אין ארכיון מטמון להוריד ולפרוס: Node כבר במטמון הכלים והמטמון של yarn נמצא על הדיסק. בניית ה‑Docker משתמשת במטמון השכבות של ה‑daemon עצמו, בלי שום דבר שמיוצא או מיובא. ב‑Skipbox לזרימת העבודה אין step של מטמון בכלל.

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

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

שרת ענן שכור מחויב על כל שעה שהוא מתחיל, במלואה. ג'וב של 3 דקות על שרת משלו משלם על 60 דקות. ביום אחד של ה‑CI שלנו, 44 ג'ובים של 2.5 דקות בממוצע רצו על 44 שרתים וחויבו על 44 שעות שרת. הרצה חוזרת של אותו יום, כשכל שרת נשמר לג'וב הבא של החשבון בתוך השעה שלו, נותנת 13 עד 14 שעות שרת: בערך 70% פחות. ולחודש יש 730 שעות: חשבון שמריץ יותר מ‑730 ג'ובים קצרים בחודש על שרתים לכל ג'וב משלם על יותר שעות ממכונה שאף פעם לא נעצרת.

כך שהמכונה שהכי מהירה בשבילכם (מטמונים על הדיסק, שום דבר להעלות) היא גם זו שהכי זולה להפעיל. מארחים ש‑Skipbox מחזיקה באים קודם כי אין להם חשבון שעתי בכלל, ושרתים שכורים לוקחים את העודף. זו הסיבה ש‑Skipbox גובה על המכונה, לא על הדקה:

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

בניצול מלא זה 1/12 מהמחיר של GitHub. הסכומים של GitHub הם החשבון אחרי המחשוב הכלול ב‑GitHub Team. הכניסו את הדקות שלכם ב[מחשבון בדף הבית](https://skipbox.dev/?ref=blog-github-actions-job-vm-boot-7-seconds-he#cost); הוא לא דורש התחברות.

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

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
```

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

## נסו את זה

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

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

### כמה זמן לוקח ל‑VM חדש לג'וב של GitHub Actions לעלות ב‑Skipbox?

במארחים של Skipbox עצמה, 7.25 שניות מהרגע שהמארח קיבל את הג'וב ועד שתהליך הראנר מתחיל, ירידה מ‑22.9 שניות. רוב הג'ובים לא מעלים שום דבר: הם רצים על המכונה של החשבון שלכם, שנשמרת בין ג'ובים.

### בטוח להעלות VMs של ג'ובי CI עם SeaBIOS במקום UEFI secure boot?

כן, ל‑VM של ג'וב. Secure boot מגן על שרשרת האתחול של האורח מפני החלפה, וג'וב CI כבר מחזיק root ב‑VM שלו, שנמחק אחרי הג'וב. ב‑Skipbox, ה‑VMs מופרדים זה מזה על ידי KVM וחומת אש לכל VM על המארח, ואף אחד מהם לא תלוי ב‑firmware של האורח.

### למה fsync איטי ב‑VM על ZFS, ואיך מתקנים את זה ל‑CI?

כל fsync באורח מחכה ש‑ZFS של המארח יבצע commit ל‑intent log שלו. הדיסק של VM חדש לג'וב נמחק עם הג'וב, אז Skipbox מעגנת את ה‑ext4 שלו בלי barriers: yarn install מהיר ב‑23% ו‑docker pull מהיר ב‑19%. מכונה שנשמרת בין ג'ובים שומרת על ה‑barriers שלה.

### למה KVM מסמן את ה‑TSC כלא יציב במעבד היברידי?

KVM משווה את ה‑TSC כש‑vCPU עובר למעבד מארח אחר, ובין ליבות ביצועים לליבות יעילות הוא יכול לקרוא ערך נמוך יותר. נעיצת כל vCPU למעבד מארח אחד מונעת מהבדיקה לרוץ: לולאת ההפעלה והעצירה של Skipbox החזיקה אז את ה‑TSC במשך 40 סבבים.

### איך מריצים את הג'ובים שלי ב‑Skipbox?

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

עודכן ב‑2026-11-16 · https://skipbox.dev/he/blog/github-actions-job-vm-boot-7-seconds
