rust-cache आपके Rust CI को तेज़ क्यों नहीं बनाता (tauri: 246 s से 53 s)
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 में।
rust-cache क्या रखता है, और क्या छोड़ता है
rust-cache के README और उसके सोर्स से:
- यह क्या कैश करता है:
~/.cargo(रजिस्ट्री, git डिपेंडेंसी, इंस्टॉल किए binaries) और आपकी डिपेंडेंसी के बिल्ड आउटपुट के साथ./target। - यह क्या छोड़ता है: workspace crates खुद कैश नहीं होते। save से पहले उसकी सफ़ाई
target/में हर उस चीज़ को डिलीट करती है जो डिपेंडेंसी नहीं है, इसलिए आपके crates के artifacts खुदtarget/से हट जाते हैं। - incremental compilation: restore स्टेप बाकी जॉब के लिए
CARGO_INCREMENTAL=0export करता है। - यह कब सेव करता है: सिर्फ़ तब जब किसी कैश के पास अभी जॉब की 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 | 32 | 118 s | 271 s |
| Skipbox, नई VM | 32 | 62 s | 146 s |
| Skipbox, डेडिकेटेड मशीन, पहला बाद वाला रन | 0 | लगभग 1.5 s | 53 s |
| Skipbox, डेडिकेटेड मशीन, दूसरा बाद वाला रन | 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 की जॉब), क्योंकि पहले रन के बाद 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, ripgrep के लिए 161 s और helix के लिए 442 s के थे।
| प्रोजेक्ट | GitHub | Skipbox, नई VM | Skipbox, डेडिकेटेड मशीन | GitHub ÷ डेडिकेटेड मशीन |
|---|---|---|---|---|
| tauri | 246 s (220, 271) | 210 s (273, 146) | 53 s (53, 53) | 4.6× |
| ripgrep | 200 s (194, 206) | 156 s (155, 156) | 40 s (39, 40) | 5.0× |
| helix | 330 s (293, 366) | 350 s (439, 260) | 224 s (222, 226) | 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 | Node.js | 528 s | 30 s |
| vite | Node.js | 141 s | 100 s |
| prometheus | Go | 335 s | 273 s |
| cli | Go | 163 s | 137 s |
| pytest | Python | 416 s | 365 s |
| guava | Java | 818 s | 651 s |
astro की कहानी target/ जैसी ही है, Turborepo के साथ: डेडिकेटेड मशीन turbo का कैश (turbo 2) रखती है, इसलिए उसके बाद वाले रन सभी 40 बिल्ड task और test task चलाने के बजाय उससे replay करते हैं (31 s, 28 s)।
प्राइवेट रिपॉज़िटरी के ubuntu-latest में 2 CPU और 8 GB हैं: ऊपर के GitHub रन के आधे कोर।
अपना CI जांचें
- अपनी Rust जॉब का कोई बाद वाला रन खोलें, जिसका rust-cache स्टेप
full match: trueलॉग करता हो। - बिल्ड और टेस्ट स्टेप में
Compilingलाइनें गिनें। कैश से आई डिपेंडेंसी कोई नहीं छापतीं। आपका हर workspace crate एक छापता है, और उन पर बना हर crate भी। - स्टेप के
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 कम।
आना बस एक लाइन का काम है
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
- GitHub से Skipbox में साइन इन करें।
- Skipbox GitHub App इंस्टॉल करें और रिपॉज़िटरी चुनें।
runs-onबदलें और push करें।
सुरक्षा
- मशीन सिर्फ़ आपके अकाउंट की है। किसी दूसरी कंपनी की जॉब उस पर नहीं चलतीं।
- हर जॉब के बाद रनर के क्रेडेंशियल, प्रोसेस और कंटेनर मिटा दिए जाते हैं, और रखे गए चेकआउट के git क्रेडेंशियल, hooks और untracked फ़ाइलें भी। “हर जॉब नई VM पर” इसके बजाय हर जॉब को नई मशीन देता है।
- बिना write एक्सेस वाले लोगों का कोड (जैसे फ़ोर्क से आई पुल रिक्वेस्ट) एक नई, इस्तेमाल के बाद हटाई जाने वाली मशीन पर चलता है, बिना किसी रखे गए
target/के।
पूरी जानकारी जॉब को अलग कैसे रखा जाता है में है।
अपनी 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 से मिलाएं।
19 नवंबर 2026 को अपडेट किया गया