# rust-cache आपके Rust CI को तेज़ क्यों नहीं बनाता (tauri: 246 s से 53 s)

> Swatinem/rust-cache आपकी डिपेंडेंसी कैश करता है, आपके workspace crates नहीं, और incremental compilation बंद कर देता है। इसलिए GitHub की नई VM पर हर बाद वाली जॉब आपके अपने crates फिर से compile करती है। बनी रहने वाली मशीन पर रखा target/ इसे ठीक करता है: tauri की CI जॉब Skipbox पर 246 s से 53 s पर आ गई, हर महीने तय $39 में।

Swatinem/rust-cache, ज़्यादातर Rust CI का कैश स्टेप, आपकी डिपेंडेंसी सेव करता है और जानबूझकर आपके workspace crates छोड़ देता है। यह `CARGO_INCREMENTAL=0` भी सेट करता है। GitHub के रनर पर हर जॉब नई VM पर शुरू होती है, इसलिए हर बाद वाली जॉब, पूरे कैश हिट के साथ भी, आपके अपने crates फिर से compile करती है। rust-cache की कोई सेटिंग इसे नहीं हटाती। जो हटाता है, वह है पिछली जॉब से अब भी मौजूद `target/`: तब Cargo हर वह crate छोड़ देता है जो नहीं बदला।

Skipbox इसे आपके लिए रखता है। आपकी जॉब आपके अकाउंट की डेडिकेटेड मशीन पर चलती है, जो जॉब के बीच चेकआउट और Cargo का `target/` रखती है। tauri की CI जॉब GitHub पर 246 s और वहां 53 s लेती थी, पहले बाद वाले रन से अपना कोई crate compile किए बिना, `runs-on: skipbox` के अलावा अपने वर्कफ़्लो में कोई बदलाव किए बिना, हर महीने तय $39 में।

- tauri की CI जॉब: GitHub पर 246 s, Skipbox पर 53 s (4.6× तेज़)। हर रन पब्लिक है
- `target/` रखे जाने पर Cargo ने tauri का कोई crate compile नहीं किया: उसका बिल्ड समय 62 s से 2 s से कम पर आ गया
- 4 vCPU पर हर महीने 20,000 मिनट: GitHub पर $222, Skipbox पर $39

**तय कीमत पर 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-rust-cache-slow-rust-ci-hi)

## rust-cache क्या रखता है, और क्या छोड़ता है

[rust-cache के README](https://github.com/Swatinem/rust-cache#cache-details) और उसके सोर्स से:

- **यह क्या कैश करता है:** `~/.cargo` (रजिस्ट्री, git डिपेंडेंसी, इंस्टॉल किए binaries) और आपकी डिपेंडेंसी के बिल्ड आउटपुट के साथ `./target`।
- **यह क्या छोड़ता है:** workspace crates खुद कैश नहीं होते। save से पहले उसकी सफ़ाई `target/` में हर उस चीज़ को डिलीट करती है जो डिपेंडेंसी नहीं है, इसलिए आपके crates के artifacts खुद `target/` से हट जाते हैं।
- **incremental compilation:** restore स्टेप बाकी जॉब के लिए `CARGO_INCREMENTAL=0` export करता है।
- **यह कब सेव करता है:** सिर्फ़ तब जब किसी कैश के पास अभी जॉब की key न हो। key toolchain, environment, और आपके `Cargo.lock` और `Cargo.toml` से बनती है। आपकी सोर्स फ़ाइलें उसका हिस्सा नहीं हैं।

नई VM पर इसका नतीजा एक ही है। बाद वाली जॉब आपकी डिपेंडेंसी restore करती है, फिर आपके workspace crates और उन पर बनी हर चीज़ पूरी compile करती है, हर बार।

## तंत्र, tauri के लॉग में

tauri की `test` जॉब Ubuntu पर पांच `cargo test` स्टेप चलाती है, rust-cache के साथ। ये हैं उसके बाद वाले रन, हर एक पूरा कैश हिट (लॉग में `full match: true`):

| बाद वाला रन | `Compiling` लाइनें | Cargo का बिल्ड समय | जॉब |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, नई VM](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, डेडिकेटेड मशीन, पहला बाद वाला रन](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **लगभग 1.5 s** | **53 s** |
| [Skipbox, डेडिकेटेड मशीन, दूसरा बाद वाला रन](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **लगभग 1.9 s** | **53 s** |

32 लाइनें tauri के अपने crates हैं, और उन पर बने दो plugin। डिपेंडेंसी कभी नहीं दिखतीं: वे कैश से आती हैं। Cargo का बिल्ड समय पांचों स्टेप के `Finished … in` समय को जोड़कर है।

नई VM में डेडिकेटेड मशीन जैसे ही CPU और वही कैश है, और उसने GitHub जितने ही 32 crates compile किए: उसके `target/` में सिर्फ़ वही था जो कैश ने restore किया। डेडिकेटेड मशीन पर पहला बाद वाला रन ही कोई `Compiling` लाइन नहीं छापता। Cargo ने सिर्फ़ जांचा कि कुछ नहीं बदला, और हर `Finished` ने 0.2-0.7 s लिए।

डेडिकेटेड मशीन का पहला बाद वाला रन पहले सभी 32 crates फिर से compile करता था ([114 s की जॉब](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), क्योंकि पहले रन के बाद rust-cache के save ने उन्हें `target/` से डिलीट कर दिया था। 13 नवंबर 2026 से अपनी मशीनें, स्टेप खत्म होते ही, rust-cache के restore और save के डिस्क से डिलीट किए को वापस कर देती हैं। वह जो कैश सेव करता है वह वही है, और आपके crates `target/` में बने रहते हैं।

## जॉब के समय: तीन Rust प्रोजेक्ट, छह दूसरे

असली प्रोजेक्ट की अपनी CI जॉब, एक तय कमिट पर, स्टेप बाइट-दर-बाइट वही; सिर्फ़ trigger और `runs-on` बदला। हर तरफ़ एक पहला रन, फिर दो बाद वाले:

- **GitHub:** `ubuntu-24.04`, पब्लिक रिपॉज़िटरी का स्टैंडर्ड रनर: 4 vCPU, 16 GB।
- **Skipbox, नई VM:** production रनर इमेज से हर जॉब के लिए नई VM, 4 vCPU और 8 GB, कैश Skipbox के कैश से restore हुए।
- **Skipbox, डेडिकेटेड मशीन:** उन्हीं होस्ट CPU पर वही साइज़, जॉब के बीच बनी रहती है, उस रखने-और-मिटाने के साथ जो डेडिकेटेड मशीनें 13 नवंबर 2026 से चलाती हैं: चेकआउट और `target/` बने रहते हैं, और rust-cache जो डिलीट करता है वह वापस रखा जाता है।

Skipbox के रन एक Skipbox होस्ट पर थे, ग्राहकों की मशीनों से अलग रखे गए एक lab प्रोजेक्ट में। समय हर जॉब की शुरुआत से अंत तक है, GitHub के API से। हर आंकड़ा दो बाद वाले रन का median है। डेडिकेटेड मशीन के पहले रन tauri के लिए [285 s](https://github.com/skipbox-dev/tauri/actions/runs/43339483384), ripgrep के लिए [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) और helix के लिए [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) के थे।

| प्रोजेक्ट | GitHub | Skipbox, नई VM | Skipbox, डेडिकेटेड मशीन | GitHub ÷ डेडिकेटेड मशीन |
|---|---|---|---|---|
| tauri | 246 s ([220](https://github.com/skipbox-dev/tauri/actions/runs/43233861304), [271](https://github.com/skipbox-dev/tauri/actions/runs/43234522982)) | 210 s ([273](https://github.com/skipbox-dev/tauri/actions/runs/43290912312), [146](https://github.com/skipbox-dev/tauri/actions/runs/43291768486)) | **53 s** ([53](https://github.com/skipbox-dev/tauri/actions/runs/43340142076), [53](https://github.com/skipbox-dev/tauri/actions/runs/43340289959)) | **4.6×** |
| ripgrep | 200 s ([194](https://github.com/skipbox-dev/ripgrep/actions/runs/43220584380), [206](https://github.com/skipbox-dev/ripgrep/actions/runs/43221108547)) | 156 s ([155](https://github.com/skipbox-dev/ripgrep/actions/runs/43292759363), [156](https://github.com/skipbox-dev/ripgrep/actions/runs/43293273127)) | **40 s** ([39](https://github.com/skipbox-dev/ripgrep/actions/runs/43340925562), [40](https://github.com/skipbox-dev/ripgrep/actions/runs/43341036341)) | **5.0×** |
| helix | 330 s ([293](https://github.com/skipbox-dev/helix/actions/runs/43227916673), [366](https://github.com/skipbox-dev/helix/actions/runs/43228816343)) | 350 s ([439](https://github.com/skipbox-dev/helix/actions/runs/43287815770), [260](https://github.com/skipbox-dev/helix/actions/runs/43289134146)) | **224 s** ([222](https://github.com/skipbox-dev/helix/actions/runs/43337749813), [226](https://github.com/skipbox-dev/helix/actions/runs/43338273330)) | **1.5×** |

ripgrep, cross की Docker इमेज के अंदर बिल्ड होता है। cross खुद `target/` बनाता है और उस पर "created by cross" का tag लगाता है। डेडिकेटेड मशीनें पहले उस `target/` को Cargo के अलावा किसी और का मानकर हर जॉब के बाद डिलीट कर देती थीं, इसलिए Cargo हर रन पर हर crate फिर से compile करता था (108 s की जॉब)। अब cross का `target/` बना रहता है: बाद वाले रन कोई `Compiling` लाइन नहीं छापते, और हर `Finished` 0.04-0.05 s लेता है। GitHub हर रन पर cross की इमेज भी डाउनलोड करता है (दूसरे बाद वाले रन में 30 s); डेडिकेटेड मशीन उसे डिस्क पर रखती है।

helix भी 1.5× तेज़ चलता है। उसके crates में से सिर्फ़ helix-term (और xtask, जो उस पर निर्भर है) फिर से बिल्ड होता है, क्योंकि helix-term की build script हर जॉब में चलती है: `test` profile में 16 s और `integration` profile में 61 s। कोई दूसरा crate compile नहीं होता। helix की ज़्यादातर जॉब उसके टेस्ट हैं: सिर्फ़ integration टेस्ट सुइट 112 s चलता है। उसका सेटअप स्टेप, toolchain और कैश restore, 9-10 s लेता था, जबकि GitHub पर 41-46 s।

दूसरी भाषाएं:

| प्रोजेक्ट | भाषा | GitHub | Skipbox, डेडिकेटेड मशीन |
|---|---|---|---|
| [astro](https://github.com/skipbox-dev/astro/actions) | Node.js | 528 s | **30 s** |
| [vite](https://github.com/skipbox-dev/vite/actions) | Node.js | 141 s | 100 s |
| [prometheus](https://github.com/skipbox-dev/prometheus/actions) | Go | 335 s | 273 s |
| [cli](https://github.com/skipbox-dev/cli/actions) | Go | 163 s | 137 s |
| [pytest](https://github.com/skipbox-dev/pytest/actions) | Python | 416 s | 365 s |
| [guava](https://github.com/skipbox-dev/guava/actions) | Java | 818 s | 651 s |

astro की कहानी `target/` जैसी ही है, Turborepo के साथ: डेडिकेटेड मशीन turbo का कैश (turbo 2) रखती है, इसलिए उसके बाद वाले रन सभी 40 बिल्ड task और test task चलाने के बजाय उससे replay करते हैं ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436))।

प्राइवेट रिपॉज़िटरी के `ubuntu-latest` में 2 CPU और 8 GB हैं: ऊपर के GitHub रन के आधे कोर।

## अपना CI जांचें

1. अपनी Rust जॉब का कोई बाद वाला रन खोलें, जिसका rust-cache स्टेप `full match: true` लॉग करता हो।
2. बिल्ड और टेस्ट स्टेप में `Compiling` लाइनें गिनें। कैश से आई डिपेंडेंसी कोई नहीं छापतीं। आपका हर workspace crate एक छापता है, और उन पर बना हर crate भी।
3. स्टेप के `Finished … in` समय जोड़ें। यह आपके अपने crates की हर रन की कीमत है, और उनके न बदलने पर रखा गया `target/` यही बचाता है।

## GitHub के रनर पर आप क्या कर सकते हैं

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 और बाद में)। आपके crates भी कैश में जाते हैं। पर जिस रन की key मौजूद है वह save छोड़ देता है, और key आपके सोर्स के साथ नहीं बदलती, इसलिए कैश किए crates आखिरी save जितने पुराने होते हैं। incremental compilation बंद रहता है, और कैश GitHub के हर रिपॉज़िटरी के 10 GB के अंदर बढ़ता है।
- **sccache।** यह हर compilation को उसके inputs से कैश करता है, इसलिए बिना बदला library crate स्टोरेज से वापस आता है। linker चलाने वाले crates कैश नहीं हो सकते: binaries, `dylib`, `cdylib` और proc-macro crates हर बार compile होते हैं, और हर हिट एक डाउनलोड है।
- **`target/` रखने वाला सेल्फ़-होस्टेड रनर।** मशीन आप चलाते हैं: उसे पैच करें, `target/` डिलीट किए बिना जॉब के बीच साफ़ करें, और actions/checkout पर `clean: false` सेट करें, जिसका डिफ़ॉल्ट `git clean -ffdx` हर दूसरी ignored फ़ाइल के साथ `target/` डिलीट कर देता है।

## Skipbox आपके लिए target/ रखता है

हर प्लान के साथ आपके अकाउंट की डेडिकेटेड मशीन आती है, जो जॉब के बीच बनी रहती है। 13 नवंबर 2026 से यह आपका चेकआउट, उसकी फ़ाइलों के समय के साथ, और Cargo का `target/` रखती है:

- actions/checkout की सफ़ाई हमेशा की तरह चलती है, सिवाय इसके कि वह Cargo की `target/` डायरेक्टरी को नहीं छूती।
- rust-cache आपके वर्कफ़्लो में रहता है। उसका restore अब डिस्क पर नए artifacts के ऊपर कैश के पुराने artifacts नहीं लिखता।
- rust-cache का save और restore `target/` और `~/.cargo` से जो डिलीट करते हैं, उसे मशीन स्टेप खत्म होते ही वापस रख देती है। सेव हुआ कैश वही है, और पहले रन के बाद की जॉब से, जो crates नहीं बदले वे compile नहीं होते।
- cross का बनाया `target/` ("created by cross" tag वाला) भी बना रहता है।
- actions/checkout हर जॉब में `.git/HEAD` फिर से लिखता है। जब तक वह उसी कमिट का नाम लेता है, फ़ाइल को उसका पुराना समय वापस मिल जाता है, इसलिए `.git/HEAD` पर नज़र रखने वाली build script (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 |

मिनट अनलिमिटेड हैं। 4 vCPU पर हर महीने 20,000 मिनट के लिए 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. GitHub से Skipbox में साइन इन करें।
2. Skipbox GitHub App इंस्टॉल करें और रिपॉज़िटरी चुनें।
3. `runs-on` बदलें और push करें।

## सुरक्षा

- मशीन सिर्फ़ आपके अकाउंट की है। किसी दूसरी कंपनी की जॉब उस पर नहीं चलतीं।
- हर जॉब के बाद रनर के क्रेडेंशियल, प्रोसेस और कंटेनर मिटा दिए जाते हैं, और रखे गए चेकआउट के git क्रेडेंशियल, hooks और untracked फ़ाइलें भी। “हर जॉब नई VM पर” इसके बजाय हर जॉब को नई मशीन देता है।
- बिना write एक्सेस वाले लोगों का कोड (जैसे फ़ोर्क से आई पुल रिक्वेस्ट) एक नई, इस्तेमाल के बाद हटाई जाने वाली मशीन पर चलता है, बिना किसी रखे गए `target/` के।

पूरी जानकारी [जॉब को अलग कैसे रखा जाता है](https://docs.skipbox.dev/hi/isolation) में है।

## अपनी Rust जॉब पर आज़माएं

ट्रायल 7 दिन या 3,000 जॉब-मिनट तक मुफ़्त है, जो भी पहले पूरा हो, और कार्ड नहीं लगता। अपनी Rust जॉब को `runs-on: skipbox` पर ले जाएं, उसे दो बार चलाएं, और दूसरे रन की `Compiling` लाइनें GitHub के साथ रखकर देखें।

## अक्सर पूछे जाने वाले सवाल

### क्या Swatinem/rust-cache मेरे workspace crates कैश करता है?

नहीं, डिफ़ॉल्ट रूप से नहीं। उसका README कहता है कि workspace crates खुद कैश नहीं होते, और उसका save स्टेप कैश अपलोड करने से पहले target/ से उनका बिल्ड आउटपुट डिलीट कर देता है। यह ~/.cargo और आपकी डिपेंडेंसी का बिल्ड आउटपुट कैश करता है, और बाकी जॉब के लिए CARGO_INCREMENTAL=0 सेट करता है। इसलिए नई GitHub VM पर हर बाद वाला रन, पूरे कैश हिट पर भी, आपके workspace crates फिर से compile करता है। GitHub पर tauri के CI में यह हर बाद वाले रन पर 32 Compiling लाइनें थीं।

### क्या मुझे cache-workspace-crates: true सेट करना चाहिए?

यह आपके crates को भी कैश में डालता है (rust-cache v2.8.0 और बाद में), पर cache key आपके toolchain, आपके environment और आपके Cargo.lock और Cargo.toml से बनती है, आपके सोर्स से नहीं। जिस रन की key पहले से है, वह save छोड़ देता है, इसलिए आपके crates की कैश की गई कॉपी आखिरी save जितनी पुरानी होती है और हर कमिट के साथ आपके कोड से दूर होती जाती है। incremental compilation बंद रहता है। किसी बाद वाले रन का लॉग जांचें: अगर आपके crates अब भी Compiling दिखाते हैं, तो यह मदद नहीं कर रहा।

### क्या sccache, GitHub Actions पर धीमे Rust CI को ठीक करता है?

यह उन library crates में मदद करता है जिनके inputs नहीं बदले। sccache linker चलाने वाले crates (bin, dylib, cdylib और proc-macro crates) कैश नहीं कर सकता, और हर हिट उसके कैश स्टोरेज से एक डाउनलोड है। जॉब के बीच रखे गए target/ को किसी डाउनलोड की ज़रूरत नहीं: जिस crate को Cargo बिना बदला देखता है, वह compile ही नहीं होता।

### क्या Skipbox पर target/ रखने के लिए मुझे अपना वर्कफ़्लो बदलना होगा?

नहीं। runs-on को skipbox में बदलें और rust-cache और actions/checkout जैसे हैं वैसे छोड़ दें। आपकी डेडिकेटेड मशीन जॉब के बीच चेकआउट और Cargo का target/ रखती है, और checkout की सफ़ाई target/ डायरेक्टरी को नहीं छूती। जब rust-cache का save आपके crates target/ से डिलीट करता है, तो मशीन उन्हें वापस रख देती है, और उसका restore अब नए artifacts के ऊपर पुराने नहीं लिखता। इसलिए पहले बाद वाले रन से ही, जो crates नहीं बदले वे compile नहीं होते।

### आज़माने में कितना खर्च आता है?

कुछ नहीं। ट्रायल 7 दिन या 3,000 जॉब-मिनट का है, जो भी पहले पूरा हो, और कार्ड नहीं लगता। अपनी Rust जॉब को runs-on: skipbox पर ले जाएं, उसे दो बार चलाएं, और दूसरे रन की Compiling लाइनें और बिल्ड स्टेप GitHub से मिलाएं।

2026-11-19 को अपडेट किया गया · https://skipbox.dev/hi/guides/rust-cache-slow-rust-ci
