Skipbox

ทำไม rust-cache ไม่ได้ทำให้ Rust CI ของคุณเร็ว (tauri: 246 วินาที เหลือ 53 วินาที)

Swatinem/rust-cache ขั้นตอนแคชใน Rust CI ส่วนใหญ่ บันทึก dependency ของคุณ และตั้งใจไม่รวม crate ใน workspace ของคุณ มันยังตั้ง CARGO_INCREMENTAL=0 ด้วย บนรันเนอร์ของ GitHub ทุกจ็อบเริ่มบน VM ใหม่ ทุกจ็อบที่ warm แม้แคชจะ hit ทั้งหมด จึงคอมไพล์ crate ของคุณเองใหม่ ไม่มีการตั้งค่าไหนของ rust-cache ที่ทำให้สิ่งนี้หายไป สิ่งที่ทำได้คือ target/ ที่ยังอยู่จากจ็อบล่าสุด: Cargo จะข้ามทุก crate ที่ไม่เปลี่ยน

Skipbox เก็บมันไว้ให้คุณ จ็อบของคุณรันบนเครื่องที่โฮสต์ให้บัญชีของคุณเท่านั้น ซึ่งเก็บโค้ดที่ checkout ไว้และ target/ ของ Cargo ระหว่างจ็อบ จ็อบ CI ของ tauri ใช้ 246 วินาทีบน GitHub และ 53 วินาทีที่นั่น โดยไม่คอมไพล์ crate ของมันเลยตั้งแต่การรันที่ warm ครั้งแรก ไม่ได้แก้เวิร์กโฟลว์อะไรนอกจาก runs-on: skipbox ในราคาเหมาจ่าย $39 ต่อเดือน

rust-cache เก็บอะไร และไม่เก็บอะไร

จาก README ของ rust-cache (ภาษาอังกฤษ) และซอร์สของมัน:

  • สิ่งที่มันแคช: ~/.cargo (registry, dependency จาก git, ไบนารีที่ติดตั้ง) และ ./target พร้อมผลลัพธ์ build ของ dependency ของคุณ
  • สิ่งที่มันไม่เก็บ: README เขียนไว้ว่า crate ใน workspace เองไม่ถูกแคช ก่อนการ save ขั้นตอนเก็บกวาดของมันลบทุกอย่างใน target/ ที่ไม่ใช่ dependency artifact ของ crate ของคุณจึงถูกลบออกจาก target/ เอง
  • incremental compilation: ขั้นตอน restore export CARGO_INCREMENTAL=0 ไว้ตลอดส่วนที่เหลือของจ็อบ
  • มัน save เมื่อไร: เฉพาะเมื่อยังไม่มีแคชที่มี key ของจ็อบ key มาจาก toolchain สภาพแวดล้อม และ Cargo.lock กับ Cargo.toml ของคุณ ไฟล์ซอร์สของคุณไม่ได้เป็นส่วนหนึ่งของมัน

บน VM ใหม่ ทั้งหมดนี้รวมกันเป็นเรื่องเดียว จ็อบที่ warm กู้คืน dependency ของคุณ แล้วคอมไพล์ crate ใน workspace และทุกอย่างที่ build อยู่บนมันใหม่ทั้งหมด ทุกครั้ง

กลไกนี้ใน log ของ tauri

จ็อบ test ของ tauri รันขั้นตอน cargo test ห้าขั้นบน Ubuntu พร้อม rust-cache นี่คือการรันที่ warm ของมัน ทุกครั้งแคช hit ทั้งหมด (full match: true ใน log):

32 บรรทัดคือ crate ของ tauri เอง และ plugin สองตัวที่ build อยู่บนมัน dependency ไม่โผล่มาเลย: มันมาจากแคช เวลา build ของ Cargo คือเวลา Finished … in ของห้าขั้นตอนรวมกัน

VM ใหม่มี CPU เท่ากับเครื่องเฉพาะของตัวเองและแคชเดียวกัน และมันคอมไพล์ crate 32 ตัวเดียวกับ GitHub: target/ ของมันมีแค่สิ่งที่แคชกู้คืนมา บนเครื่องเฉพาะของตัวเอง การรันที่ warm ครั้งแรกก็ไม่แสดงบรรทัด Compiling แล้ว Cargo แค่ตรวจว่าไม่มีอะไรเปลี่ยน และแต่ละ Finished ใช้ 0.2-0.7 วินาที

การรันที่ warm ครั้งแรกบนเครื่องเฉพาะของตัวเองเคยคอมไพล์ crate ทั้ง 32 ตัวใหม่ (จ็อบ 114 วินาที) เพราะการ save ของ rust-cache หลังการรันเย็นได้ลบมันออกจาก target/ ตั้งแต่ 13 พฤศจิกายน 2026 เครื่องเฉพาะของตัวเองย้อนสิ่งที่การ restore และ save ของ rust-cache ลบออกจากดิสก์ เมื่อขั้นตอนนั้นจบ แคชที่มันบันทึกยังเหมือนเดิม และ crate ของคุณยังอยู่ใน target/

เวลาของจ็อบ: โปรเจกต์ Rust สามตัว และอีกหกตัว

จ็อบ CI ของโปรเจกต์จริงเองที่ commit ที่ปักไว้ ขั้นตอนตรงกันทุกไบต์ เปลี่ยนแค่ trigger และ runs-on การรันเย็นหนึ่งครั้ง แล้วการรันที่ warm สองครั้ง ในแต่ละฝั่ง:

  • GitHub: ubuntu-24.04 รันเนอร์มาตรฐานของรีโพสิทอรีสาธารณะ: 4 vCPU, 16 GB
  • Skipbox, VM ใหม่: VM ใหม่ต่อจ็อบจากอิมเมจรันเนอร์ของ production 4 vCPU และ 8 GB แคชกู้คืนผ่านแคชของ Skipbox
  • Skipbox, เครื่องเฉพาะของตัวเอง: ขนาดเดียวกันบน CPU ของโฮสต์เดียวกัน เก็บไว้ระหว่างจ็อบ พร้อมการเก็บและล้างที่เครื่องเฉพาะของตัวเองทำตั้งแต่ 13 พฤศจิกายน 2026: โค้ดที่ checkout ไว้และ target/ อยู่ต่อ และสิ่งที่ rust-cache ลบจะถูกใส่กลับคืน

การรันของ Skipbox อยู่บนโฮสต์ของ Skipbox ในโปรเจกต์ทดสอบที่แยกจากเครื่องของลูกค้า เวลานับจากจุดเริ่มจนจบของแต่ละจ็อบ จาก API ของ GitHub แต่ละตัวเลขคือค่ามัธยฐานของการรันที่ warm สองครั้ง การรันเย็นของเครื่องเฉพาะของตัวเองใช้ 285 วินาที สำหรับ tauri 161 วินาที สำหรับ ripgrep และ 442 วินาที สำหรับ helix

ripgrep build ภายในอิมเมจ Docker ของ cross cross สร้าง target/ เองและติด tag ว่า "created by cross" เครื่องเฉพาะของตัวเองเคยเข้าใจว่า target/ นั้นไม่ใช่ของ Cargo และลบมันหลังทุกจ็อบ Cargo จึงคอมไพล์ทุก crate ใหม่ในทุกการรัน (จ็อบ 108 วินาที) ตอนนี้ target/ ของ cross อยู่ต่อ: การรันที่ warm ไม่แสดงบรรทัด Compiling เลย และแต่ละ Finished ใช้ 0.04-0.05 วินาที GitHub ยังดาวน์โหลดอิมเมจของ cross ทุกการรันด้วย (30 วินาทีในการรันที่ warm ครั้งที่สอง) ส่วนเครื่องเฉพาะของตัวเองเก็บมันไว้บนดิสก์

helix ก็เร็วขึ้น 1.5× เช่นกัน ใน crate ทั้งหมดของมัน มีเพียง helix-term (และ xtask ซึ่งขึ้นกับมัน) ที่ build ใหม่ เพราะ build script ของ helix-term รันในทุกจ็อบ: 16 วินาทีใน profile test และ 61 วินาทีใน profile integration ไม่มี crate อื่นถูกคอมไพล์ จ็อบของ helix ส่วนใหญ่คือการเทสต์: ชุด integration test อย่างเดียวรัน 112 วินาที ขั้นตอนตั้งค่า toolchain และการกู้คืนแคชใช้ 9-10 วินาที เทียบกับ 41-46 วินาทีบน GitHub

ภาษาอื่นๆ:

astro เป็นเรื่องเดียวกับ target/ แต่กับ Turborepo: เครื่องเฉพาะของตัวเองเก็บแคชของ turbo ไว้ (turbo 2) การรันที่ warm ของมันจึงเล่นซ้ำ build task ทั้ง 40 ตัวและ test task จากแคชแทนที่จะรันใหม่ (31 วินาที, 28 วินาที)

ubuntu-latest ของรีโพสิทอรีส่วนตัวมี 2 CPU และ 8 GB: ครึ่งหนึ่งของคอร์ในการรันบน GitHub ข้างต้น

ตรวจ CI ของคุณเอง

  1. เปิดการรันที่ warm ของจ็อบ Rust ของคุณ ตัวที่ขั้นตอน rust-cache บันทึก full match: true
  2. ในขั้นตอน build และ test นับบรรทัด Compiling dependency จากแคชไม่แสดงเลย crate ใน workspace แต่ละตัวแสดงหนึ่งบรรทัด และ crate ที่ build อยู่บนมันแต่ละตัวก็เช่นกัน
  3. รวมเวลา Finished … in ของขั้นตอนต่างๆ นั่นคือต้นทุนของ crate ของคุณเองในแต่ละการรัน และคือสิ่งที่ target/ ที่เก็บไว้ประหยัดได้เมื่อมันไม่เปลี่ยน

สิ่งที่คุณทำได้บนรันเนอร์ของ GitHub

  • cache-workspace-crates: true (rust-cache v2.8.0 ขึ้นไป) crate ของคุณเข้าไปอยู่ในแคชด้วย แต่การรันที่ key มีอยู่แล้วจะข้ามการ save และ key ไม่เปลี่ยนตามซอร์ส crate ในแคชจึงเก่าเท่ากับการ save ครั้งล่าสุด incremental compilation ยังปิดอยู่ และแคชโตขึ้นภายใน 10 GB ต่อรีโพสิทอรีของ GitHub
  • sccache มันแคชแต่ละการคอมไพล์ตาม input library crate ที่ไม่เปลี่ยนจึงกลับมาจากที่เก็บ crate ที่เรียก linker แคชไม่ได้: ไบนารี crate แบบ dylib, cdylib และ proc-macro คอมไพล์ทุกครั้ง และทุกครั้งที่ hit คือการดาวน์โหลด
  • รันเนอร์แบบ self-hosted ที่เก็บ target/ ไว้ คุณดูแลเครื่องเอง: แพตช์ ล้างระหว่างจ็อบโดยไม่ลบ target/ และตั้ง clean: false บน actions/checkout ซึ่งค่าเริ่มต้น git clean -ffdx ลบ target/ ไปพร้อมกับไฟล์ที่ถูก ignore ทั้งหมด

Skipbox เก็บ target/ ไว้ให้คุณ

ทุกแพ็กเกจมาพร้อมเครื่องเฉพาะของบัญชีคุณ ที่เก็บไว้ระหว่างจ็อบ ตั้งแต่ 13 พฤศจิกายน 2026 มันเก็บโค้ดที่ checkout ไว้พร้อมเวลาของไฟล์ และ target/ ของ Cargo:

  • การล้างของ actions/checkout รันตามปกติ เว้นแต่ไม่แตะโฟลเดอร์ target/ ของ Cargo
  • rust-cache อยู่ในเวิร์กโฟลว์ของคุณต่อไป การ restore ของมันไม่เขียน artifact ที่เก่ากว่าในแคชทับตัวที่ใหม่กว่าบนดิสก์อีกต่อไป
  • สิ่งที่การ save และ restore ของ rust-cache ลบออกจาก target/ และ ~/.cargo เครื่องจะใส่กลับคืนเมื่อขั้นตอนนั้นจบ แคชที่บันทึกยังเหมือนเดิม และตั้งแต่จ็อบหลังการรันเย็น crate ที่ไม่เปลี่ยนจะไม่ถูกคอมไพล์
  • target/ ที่ cross สร้าง (ติด tag ว่า "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. ติดตั้ง GitHub App ของ Skipbox แล้วเลือกรีโพสิทอรี
  3. เปลี่ยน runs-on แล้ว push

ความปลอดภัย

  • เครื่องเป็นของบัญชีคุณเท่านั้น ไม่มีจ็อบของบริษัทอื่นรันบนเครื่องนี้
  • หลังทุกจ็อบ ข้อมูลรับรองของรันเนอร์ โปรเซส และคอนเทนเนอร์จะถูกลบ รวมถึงข้อมูลรับรองของ git, hook และไฟล์ที่ไม่ถูก track ในโค้ดที่ checkout เก็บไว้ การตั้งค่า VM ใหม่ทุกจ็อบ ให้แต่ละจ็อบได้เครื่องใหม่แทน
  • โค้ดจากคนที่ไม่มีสิทธิ์เขียน (เช่น pull request จาก fork) รันบนเครื่องใหม่ที่ใช้แล้วทิ้ง โดยไม่มี target/ ที่เก็บไว้

รายละเอียดอยู่ในวิธีแยกจ็อบออกจากกัน

ลองกับจ็อบ Rust ของคุณ

ทดลองใช้ฟรี 7 วัน หรือ 3,000 นาทีของจ็อบ แล้วแต่อย่างไหนครบก่อน ไม่ต้องใช้บัตร ย้ายจ็อบ Rust ของคุณไปที่ runs-on: skipbox รันสองครั้ง แล้ววางบรรทัด Compiling ของการรันครั้งที่สองไว้ข้างของ GitHub

คำถามที่พบบ่อย

Swatinem/rust-cache แคช crate ใน workspace ของฉันไหม

ไม่ ไม่ใช่ค่าเริ่มต้น README ของมันบอกว่า crate ใน workspace เองไม่ถูกแคช และขั้นตอน save ของมันลบผลลัพธ์ build ของ crate เหล่านั้นออกจาก target/ ก่อนอัปโหลดแคช มันแคช ~/.cargo และผลลัพธ์ build ของ dependency และตั้ง CARGO_INCREMENTAL=0 ไว้ตลอดส่วนที่เหลือของจ็อบ บน VM ใหม่ของ GitHub ทุกการรันที่ warm จึงคอมไพล์ crate ใน workspace ใหม่ แม้แคชจะ hit ทั้งหมด ใน CI ของ tauri บน GitHub นั่นคือ 32 บรรทัด Compiling ในทุกการรันที่ warm

ควรตั้ง cache-workspace-crates: true ไหม

มันใส่ crate ของคุณลงในแคชด้วย (rust-cache v2.8.0 ขึ้นไป) แต่ cache key มาจาก toolchain สภาพแวดล้อม และ Cargo.lock กับ Cargo.toml ของคุณ ไม่ใช่ซอร์ส การรันที่ key มีอยู่แล้วจะข้ามการ save สำเนาของ crate ในแคชจึงเก่าเท่ากับการ save ครั้งล่าสุด และห่างจากโค้ดของคุณไปทุก commit incremental compilation ยังปิดอยู่ ตรวจ log ของการรันที่ warm: ถ้า crate ของคุณยังแสดง Compiling แปลว่ามันไม่ได้ช่วย

sccache แก้ Rust CI ที่ช้าบน GitHub Actions ได้ไหม

ช่วยได้กับ library crate ที่ input ไม่เปลี่ยน sccache แคช crate ที่เรียก linker ไม่ได้ (crate แบบ bin, dylib, cdylib และ proc-macro) และทุกครั้งที่ hit คือการดาวน์โหลดจากที่เก็บแคชของมัน target/ ที่เก็บไว้ระหว่างจ็อบไม่ต้องดาวน์โหลดอะไร: crate ที่ Cargo เห็นว่าไม่เปลี่ยนจะไม่ถูกคอมไพล์เลย

ต้องแก้เวิร์กโฟลว์เพื่อเก็บ target/ ไว้บน Skipbox ไหม

ไม่ต้อง เปลี่ยน runs-on เป็น skipbox และปล่อย rust-cache กับ actions/checkout ไว้ตามเดิม เครื่องเฉพาะของคุณเก็บโค้ดที่ checkout ไว้และ target/ ของ Cargo ระหว่างจ็อบ และการล้างของ checkout ไม่แตะโฟลเดอร์ target/ เมื่อการ save ของ rust-cache ลบ crate ของคุณออกจาก target/ เครื่องจะใส่มันกลับคืน และการ restore ของมันไม่เขียน artifact ที่เก่ากว่าทับตัวที่ใหม่กว่าอีกต่อไป ตั้งแต่การรันที่ warm ครั้งแรก crate ที่ไม่เปลี่ยนจึงไม่ถูกคอมไพล์

ลองใช้มีค่าใช้จ่ายเท่าไร

ไม่เสียเลย ทดลองใช้ได้ 7 วัน หรือ 3,000 นาทีของจ็อบ แล้วแต่อย่างไหนครบก่อน ไม่ต้องใช้บัตร ย้ายจ็อบ Rust ของคุณไปที่ runs-on: skipbox รันสองครั้ง แล้วเทียบบรรทัด Compiling และขั้นตอน build ของการรันครั้งที่สองกับของ GitHub

อัปเดต 19 พฤศจิกายน 2026

CI/CD ที่เร็วขึ้นด้วยแคชที่พร้อมเสมอ

รันเนอร์ที่พร้อมทำงานเสมอ ในราคาเหมาจ่าย

เราโฮสต์ให้ คุณแก้แค่บรรทัดเดียว ค่าใช้จ่ายเพียง 1/12 ของ GitHub เมื่อใช้เต็มที่ ราคาเหมาจ่าย จึงรันได้ทั้งวัน พื้นที่แคช 7 เท่าของ GitHub

  • ไม่ต้องใช้บัตร
  • เข้าสู่ระบบด้วย GitHub
  • ยกเลิกได้ทุกเมื่อ