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

> Swatinem/rust-cache แคช dependency ของคุณ ไม่ใช่ crate ใน workspace ของคุณ และปิด incremental compilation บน VM ใหม่ของ GitHub ทุกจ็อบที่ warm จึงคอมไพล์ crate ของคุณเองใหม่ target/ ที่เก็บไว้บนเครื่องที่อยู่ต่อแก้ปัญหานี้ได้: จ็อบ CI ของ tauri จาก 246 วินาทีเหลือ 53 วินาทีบน Skipbox ในราคาเหมาจ่าย $39 ต่อเดือน

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 ต่อเดือน

- จ็อบ CI ของ tauri: 246 วินาทีบน GitHub 53 วินาทีบน Skipbox (เร็วขึ้น 4.6×) ทุกการรันเปิดให้ดูได้
- เมื่อเก็บ `target/` ไว้ Cargo ไม่คอมไพล์ crate ของ tauri เลย: เวลา build ของมันจาก 62 วินาทีเหลือไม่ถึง 2 วินาที
- 20,000 นาทีต่อเดือนบน 4 vCPU: บน GitHub $222 บน Skipbox $39

**GitHub Actions ราคาเหมาจ่าย ไม่จำกัดนาที** Skipbox รันจ็อบ GitHub Actions บนเครื่องเฉพาะของคุณเอง: $39 ต่อเดือน ไม่ว่าจะรันกี่นาที layer ของ Docker และแคช dependency ยังอยู่ระหว่างจ็อบ จ็อบถัดไปจึงเริ่มได้ทันที

รันเนอร์ 4 vCPU, 20,000 นาทีต่อเดือน: GitHub $222 → Skipbox $39. ประหยัด $183 ทุกเดือน.

ย้ายได้ด้วยบรรทัดเดียว: `runs-on: skipbox`

[เริ่มทดลองใช้ฟรี 7 วัน](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-th)

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

จาก [README ของ rust-cache](https://github.com/Swatinem/rust-cache#cache-details) (ภาษาอังกฤษ) และซอร์สของมัน:

- **สิ่งที่มันแคช:** `~/.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):

| การรันที่ warm | บรรทัด `Compiling` | เวลา build ของ Cargo | จ็อบ |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 วินาที | 271 วินาที |
| [Skipbox, VM ใหม่](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 วินาที | 146 วินาที |
| [Skipbox, เครื่องเฉพาะของตัวเอง, การรันที่ warm ครั้งที่ 1](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **ประมาณ 1.5 วินาที** | **53 วินาที** |
| [Skipbox, เครื่องเฉพาะของตัวเอง, การรันที่ warm ครั้งที่ 2](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **ประมาณ 1.9 วินาที** | **53 วินาที** |

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 วินาที](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)) เพราะการ 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 วินาที](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) สำหรับ tauri [161 วินาที](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) สำหรับ ripgrep และ [442 วินาที](https://github.com/skipbox-dev/helix/actions/runs/43336739720) สำหรับ helix

| โปรเจกต์ | GitHub | Skipbox, VM ใหม่ | Skipbox, เครื่องเฉพาะของตัวเอง | GitHub ÷ เครื่องเฉพาะของตัวเอง |
|---|---|---|---|---|
| tauri | 246 วินาที ([220](https://github.com/skipbox-dev/tauri/actions/runs/43233861304), [271](https://github.com/skipbox-dev/tauri/actions/runs/43234522982)) | 210 วินาที ([273](https://github.com/skipbox-dev/tauri/actions/runs/43290912312), [146](https://github.com/skipbox-dev/tauri/actions/runs/43291768486)) | **53 วินาที** ([53](https://github.com/skipbox-dev/tauri/actions/runs/43340142076), [53](https://github.com/skipbox-dev/tauri/actions/runs/43340289959)) | **4.6×** |
| ripgrep | 200 วินาที ([194](https://github.com/skipbox-dev/ripgrep/actions/runs/43220584380), [206](https://github.com/skipbox-dev/ripgrep/actions/runs/43221108547)) | 156 วินาที ([155](https://github.com/skipbox-dev/ripgrep/actions/runs/43292759363), [156](https://github.com/skipbox-dev/ripgrep/actions/runs/43293273127)) | **40 วินาที** ([39](https://github.com/skipbox-dev/ripgrep/actions/runs/43340925562), [40](https://github.com/skipbox-dev/ripgrep/actions/runs/43341036341)) | **5.0×** |
| helix | 330 วินาที ([293](https://github.com/skipbox-dev/helix/actions/runs/43227916673), [366](https://github.com/skipbox-dev/helix/actions/runs/43228816343)) | 350 วินาที ([439](https://github.com/skipbox-dev/helix/actions/runs/43287815770), [260](https://github.com/skipbox-dev/helix/actions/runs/43289134146)) | **224 วินาที** ([222](https://github.com/skipbox-dev/helix/actions/runs/43337749813), [226](https://github.com/skipbox-dev/helix/actions/runs/43338273330)) | **1.5×** |

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

ภาษาอื่นๆ:

| โปรเจกต์ | ภาษา | GitHub | Skipbox, เครื่องเฉพาะของตัวเอง |
|---|---|---|---|
| [astro](https://github.com/skipbox-dev/astro/actions) | Node.js | 528 วินาที | **30 วินาที** |
| [vite](https://github.com/skipbox-dev/vite/actions) | Node.js | 141 วินาที | 100 วินาที |
| [prometheus](https://github.com/skipbox-dev/prometheus/actions) | Go | 335 วินาที | 273 วินาที |
| [cli](https://github.com/skipbox-dev/cli/actions) | Go | 163 วินาที | 137 วินาที |
| [pytest](https://github.com/skipbox-dev/pytest/actions) | Python | 416 วินาที | 365 วินาที |
| [guava](https://github.com/skipbox-dev/guava/actions) | Java | 818 วินาที | 651 วินาที |

astro เป็นเรื่องเดียวกับ `target/` แต่กับ Turborepo: เครื่องเฉพาะของตัวเองเก็บแคชของ turbo ไว้ (turbo 2) การรันที่ warm ของมันจึงเล่นซ้ำ build task ทั้ง 40 ตัวและ test task จากแคชแทนที่จะรันใหม่ ([31 วินาที](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 วินาที](https://github.com/skipbox-dev/astro/actions/runs/43351638436))

`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 แคชแพ็กเกจ และเครื่องมือที่ติดตั้งไว้ด้วย ส่วนที่เหลือของจ็อบจึงเร็วขึ้นไปพร้อมกัน จ็อบเลือกขนาดด้วยเลเบล:

| เลเบล | เครื่อง | แพ็กเกจ |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 ต่อเดือน |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 ต่อเดือน |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 ต่อเดือน |

ไม่จำกัดนาที ที่ 20,000 นาทีต่อเดือนบน 4 vCPU GitHub คิดเงิน $222 ส่วน Skipbox S คือ $39 ถูกกว่า $183

## ย้ายมาแค่บรรทัดเดียว

```yaml
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/` ที่เก็บไว้

รายละเอียดอยู่ใน[วิธีแยกจ็อบออกจากกัน](https://docs.skipbox.dev/th/isolation)

## ลองกับจ็อบ 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

อัปเดต 2026-11-19 · https://skipbox.dev/th/guides/rust-cache-slow-rust-ci
