Skipbox

למה rust-cache לא הופך את ה‑CI של Rust למהיר (tauri: מ‑246 s ל‑53 s)

Swatinem/rust-cache, ה‑step של המטמון ברוב ה‑CI של Rust, שומר את התלויות שלכם ומשאיר בכוונה בחוץ את ה‑crates של ה‑workspace. הוא גם מגדיר CARGO_INCREMENTAL=0. בראנרים של GitHub כל ג'וב מתחיל על VM חדש, כך שכל ג'וב חם, גם עם פגיעה מלאה במטמון, מקמפל שוב את ה‑crates שלכם. אף הגדרה של rust-cache לא מעלימה את זה. מה שכן מעלים הוא target/ שעדיין נמצא שם מהג'וב הקודם: Cargo אז מדלג על כל crate שלא השתנה.

Skipbox שומרת אותו בשבילכם. הג'וב שלכם רץ על המכונה של החשבון שלכם, ששומרת את ה‑checkout ואת ה‑target/ של Cargo בין ג'ובים. ג'וב ה‑CI של tauri לקח 246 s ב‑GitHub ו‑53 s שם, בלי לקמפל אף אחד מה‑crates שלו מההרצה החמה הראשונה, בלי שום שינוי בזרימת העבודה שלו מלבד runs-on: skipbox, במחיר קבוע של $39 לחודש.

מה rust-cache שומר, ומה הוא משאיר בחוץ

מתוך ה‑README של rust-cache וקוד המקור שלו:

  • מה הוא שומר במטמון: ~/.cargo (ה‑registry, תלויות git, בינאריים מותקנים) ו‑./target עם פלט ה‑build של התלויות שלכם.
  • מה הוא משאיר בחוץ: לפי ה‑README, ה‑crates של ה‑workspace עצמם לא נשמרים במטמון. לפני השמירה, הניקוי שלו מוחק כל דבר ב‑target/ שאינו תלות, כך שהארטיפקטים של ה‑crates שלכם נמחקים מ‑target/ עצמו.
  • קומפילציה אינקרמנטלית: ה‑step של השחזור מייצא CARGO_INCREMENTAL=0 לשאר הג'וב.
  • מתי הוא שומר: רק כשאין עדיין מטמון עם המפתח של הג'וב. המפתח נגזר מסביבת הכלים, מהסביבה, ומה‑Cargo.lock וה‑Cargo.toml שלכם. קובצי המקור שלכם לא חלק ממנו.

על VM חדש זה מצטבר לדבר אחד. ג'וב חם משחזר את התלויות שלכם, ואז מקמפל את ה‑crates של ה‑workspace שלכם וכל מה שבנוי עליהם, במלואם, בכל פעם.

המנגנון, בלוגים של tauri

ג'וב ה‑test של tauri מריץ חמישה steps של cargo test על Ubuntu, עם rust-cache. הנה ההרצות החמות שלו, כל אחת פגיעה מלאה במטמון (full match: true בלוג):

32 השורות הן ה‑crates של tauri עצמו, ושני פלאגינים שבנויים עליהם. התלויות אף פעם לא מופיעות: הן מגיעות מהמטמון. זמן ה‑build של Cargo הוא זמני ה‑Finished … in של חמשת ה‑steps, מחוברים.

ל‑VM החדש יש את המעבדים של המכונה הקבועה ואותו מטמון, והוא קימפל את אותם 32 crates כמו GitHub: ה‑target/ שלו הכיל רק את מה שהמטמון שחזר. במכונה הקבועה, כבר ההרצה החמה הראשונה לא מדפיסה אף שורת Compiling. Cargo רק בדק ששום דבר לא השתנה, וכל Finished לקח 0.2-0.7 s.

ההרצה החמה הראשונה של המכונה הקבועה נהגה לקמפל שוב את כל 32 ה‑crates (ג'וב של 114 s), כי השמירה של rust-cache אחרי ההרצה הקרה מחקה אותם מ‑target/. החל מ‑13 בנובמבר 2026, מכונות קבועות מבטלות את מה שהשחזור והשמירה של rust-cache מוחקים מהדיסק, ברגע שה‑step מסתיים. המטמון שהוא שומר זהה, וה‑crates שלכם נשארים ב‑target/.

זמני ג'ובים: שלושה פרויקטים של Rust, שישה אחרים

ג'ובי ה‑CI של פרויקטים אמיתיים ב‑commit נעול, ה‑steps בית אחר בית; רק הטריגר ו‑runs-on שונו. הרצה קרה אחת, ואז שתי הרצות חמות, בכל צד:

  • GitHub: ubuntu-24.04, הראנר הסטנדרטי של מאגר ציבורי: 4 vCPU, 16 GB.
  • Skipbox, VM חדש: VM חדש לכל ג'וב מאימג' הראנר של הפרודקשן, 4 vCPU ו‑8 GB, מטמונים משוחזרים דרך המטמון של Skipbox.
  • Skipbox, מכונה ייעודית: אותו גודל על אותם מעבדי מארח, נשמרת בין ג'ובים, עם השמירה-והמחיקה שמכונות קבועות מריצות מאז 13 בנובמבר 2026: ה‑checkout ו‑target/ נשארים, ומה ש‑rust-cache מוחק מוחזר.

ההרצות של Skipbox היו על מארח של Skipbox, בפרויקט מעבדה שמופרד מהמכונות של הלקוחות. הזמנים נמדדים מתחילת כל ג'וב ועד סופו, מה‑API של GitHub. כל מספר הוא החציון של שתי ההרצות החמות. ההרצות הקרות של המכונה הקבועה לקחו 285 s ל‑tauri, 161 s ל‑ripgrep ו‑442 s ל‑helix.

ripgrep נבנה בתוך אימג' ה‑Docker של cross. cross יוצר את target/ בעצמו ומתייג אותו "created by cross". מכונות קבועות נהגו לחשוב שה‑target/ הזה הוא משהו אחר משל Cargo ולמחוק אותו אחרי כל ג'וב, כך ש‑Cargo קימפל שוב כל crate בכל הרצה (ג'וב של 108 s). עכשיו ה‑target/ של cross נשאר: ההרצות החמות לא מדפיסות אף שורת Compiling, וכל Finished לוקח 0.04-0.05 s. GitHub גם מורידה את האימג' של cross בכל הרצה (30 s בהרצה החמה השנייה); המכונה הקבועה שומרת אותו על הדיסק.

גם helix רץ מהר יותר, ב‑1.5×. מבין ה‑crates שלו, רק helix-term (ו‑xtask, שתלוי בו) נבנה שוב, כי ה‑build script של helix-term רץ בכל ג'וב: 16 s בפרופיל test ו‑61 s בפרופיל integration. אף crate אחר לא מתקמפל. רוב הג'וב של helix הוא הבדיקות שלו: סט בדיקות האינטגרציה לבדו רץ 112 s. ה‑step של ההכנה שלו, סביבת הכלים ושחזור המטמון, לקח 9-10 s מול 41-46 s ב‑GitHub.

השפות האחרות:

astro הוא אותו סיפור כמו target/, עם Turborepo: המכונה הקבועה שומרת את המטמון של turbo (turbo 2), כך שההרצות החמות שלה משחזרות ממנו את כל 40 משימות ה‑build ואת משימת הבדיקות במקום להריץ אותן (31 s, 28 s).

ל‑ubuntu-latest של מאגר פרטי יש 2 מעבדים ו‑8 GB: חצי מהליבות של הרצות GitHub שלמעלה.

בדקו את ה‑CI שלכם

  1. פתחו הרצה חמה של ג'וב ה‑Rust שלכם, כזו שה‑step של rust-cache שלה רושם full match: true.
  2. ב‑steps של ה‑build והבדיקות, ספרו את שורות ה‑Compiling. תלויות מהמטמון לא מדפיסות אף אחת. כל crate של ה‑workspace שלכם מדפיס אחת, וכך גם כל crate שבנוי עליהם.
  3. חברו את זמני ה‑Finished … in של ה‑steps. זה מה שה‑crates שלכם עולים בכל הרצה, ומה ש‑target/ שנשמר חוסך כשהם לא השתנו.

מה אפשר לעשות בראנרים של GitHub

  • cache-workspace-crates: true (rust-cache v2.8.0 ומעלה). ה‑crates שלכם נכנסים גם הם למטמון. אבל הרצה שהמפתח שלה קיים מדלגת על השמירה, והמפתח לא משתנה עם קוד המקור שלכם, כך שה‑crates השמורים ישנים כמו השמירה האחרונה. הקומפילציה האינקרמנטלית נשארת כבויה, והמטמון גדל בתוך 10 GB של GitHub לכל מאגר.
  • sccache. הוא שומר במטמון כל קומפילציה לפי הקלטים שלה, כך ש‑crate של ספרייה שלא השתנה חוזר מהאחסון. crates שמפעילים את ה‑linker לא יכולים להישמר במטמון: בינאריים, crates מסוג dylib, cdylib ו‑proc-macro מתקמפלים בכל פעם, וכל פגיעה היא הורדה.
  • ראנר באירוח עצמי ששומר את target/. אתם מפעילים את המכונה: מעדכנים אותה, מנקים אותה בין ג'ובים בלי למחוק את target/, ומגדירים clean: false ב‑actions/checkout, שברירת המחדל שלו git clean -ffdx מוחקת את target/ עם כל קובץ מוחרג אחר.

Skipbox שומרת את target/ בשבילכם

כל מסלול מגיע עם מכונה של החשבון שלכם, שנשמרת בין ג'ובים. מאז 13 בנובמבר 2026 היא שומרת את ה‑checkout שלכם, עם הזמנים של הקבצים שלו, ואת ה‑target/ של Cargo:

  • הניקוי של actions/checkout רץ כרגיל, חוץ מזה שהוא לא נוגע בתיקיות ה‑target/ של Cargo.
  • rust-cache נשאר בזרימת העבודה שלכם. השחזור שלו כבר לא כותב את הארטיפקטים הישנים יותר של המטמון מעל החדשים יותר שעל הדיסק.
  • מה שהשמירה והשחזור של rust-cache מוחקים מ‑target/ ומ‑~/.cargo, המכונה מחזירה ברגע שה‑step מסתיים. המטמון שנשמר זהה, ומהג'וב שאחרי ההרצה הקרה, crates שלא השתנו לא מקומפלים.
  • ה‑target/ ש‑cross יוצר (מתויג "created by cross") נשאר גם הוא.
  • actions/checkout כותב מחדש את .git/HEAD בכל ג'וב. כל עוד הוא עדיין מצביע על אותו commit, הקובץ מקבל בחזרה את הזמן הישן שלו, כך ש‑build script שעוקב אחרי .git/HEAD (כמו vergen) לא רץ שוב רק בגלל זה.

המכונה שומרת גם אימג'י Docker, מטמוני חבילות וכלים מותקנים, כך ששאר הג'וב מואץ איתה. ג'וב בוחר את הגודל שלו לפי תווית:

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

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

jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - uses: Swatinem/rust-cache@v2
      - run: cargo test --workspace
  1. התחברו ל‑Skipbox עם GitHub.
  2. התקינו את אפליקציית Skipbox ל‑GitHub ובחרו את המאגרים.
  3. שנו את runs-on ובצעו push.

אבטחה

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

הפרטים נמצאים באיך הג'ובים מבודדים.

נסו על ג'וב ה‑Rust שלכם

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

שאלות נפוצות

Swatinem/rust-cache שומר במטמון את ה‑crates של ה‑workspace שלי?

לא, לא כברירת מחדל. ה‑README שלו אומר שה‑crates של ה‑workspace עצמם לא נשמרים במטמון, וה‑step של השמירה שלו מוחק את פלט ה‑build שלהם מ‑target/ לפני שהוא מעלה את המטמון. הוא שומר במטמון את ‎~/.cargo ואת פלט ה‑build של התלויות שלכם, ומגדיר CARGO_INCREMENTAL=0 לשאר הג'וב. כך שב‑VM חדש של GitHub, כל הרצה חמה מקמפלת שוב את ה‑crates של ה‑workspace שלכם, גם בפגיעה מלאה במטמון. ב‑CI של tauri ב‑GitHub אלה היו 32 שורות Compiling בכל הרצה חמה.

כדאי להגדיר cache-workspace-crates: true?

זה מכניס גם את ה‑crates שלכם למטמון (rust-cache v2.8.0 ומעלה), אבל מפתח המטמון נגזר מסביבת הכלים, מהסביבה ומה‑Cargo.lock וה‑Cargo.toml שלכם, לא מקוד המקור. הרצה שהמפתח שלה כבר קיים מדלגת על השמירה, כך שהעותק השמור של ה‑crates שלכם ישן כמו השמירה האחרונה ומתרחק מהקוד שלכם עם כל commit. הקומפילציה האינקרמנטלית נשארת כבויה. בדקו את הלוג של הרצה חמה: אם ה‑crates שלכם עדיין מציגים Compiling, זה לא עוזר.

sccache מתקן CI איטי של Rust ב‑GitHub Actions?

הוא עוזר ב‑crates של ספריות שהקלטים שלהן לא השתנו. sccache לא יכול לשמור במטמון crates שמפעילים את ה‑linker (crates מסוג bin, dylib, cdylib ו‑proc-macro), וכל פגיעה היא הורדה מאחסון המטמון שלו. target/ שנשמר בין ג'ובים לא צריך הורדה: crate ש‑Cargo רואה כלא משתנה לא מקומפל בכלל.

אני צריך לשנות את זרימת העבודה שלי כדי לשמור את target/ ב‑Skipbox?

לא. שנו את runs-on ל‑skipbox והשאירו את rust-cache ואת actions/checkout כמו שהם. המכונה שלכם שומרת את ה‑checkout ואת ה‑target/ של Cargo בין ג'ובים, והניקוי של checkout לא נוגע בתיקיות target/. כשהשמירה של rust-cache מוחקת את ה‑crates שלכם מ‑target/, המכונה מחזירה אותם, והשחזור שלו כבר לא כותב ארטיפקטים ישנים מעל חדשים. כך שמההרצה החמה הראשונה, crates שלא השתנו לא מקומפלים.

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

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

עודכן ב‑19 בנובמבר 2026

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

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

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

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