23 सेकंड कहां गए: GitHub Actions जॉब की VM 7 सेकंड में शुरू करना
एक GitHub Actions जॉब के लिए नई वर्चुअल मशीन को Skipbox होस्ट पर "होस्ट ने जॉब स्वीकार की" से "रनर प्रोसेस शुरू होता है" तक पहुंचने में 22.9 सेकंड लगते थे। अब 7.25 सेकंड लगते हैं। यह पोस्ट बताती है कि बाकी 15 सेकंड कहां थे और हर एक को कैसे मापा गया।
Skipbox हर महीने तय $39 में अनलिमिटेड मिनट वाला GitHub Actions रनर है। आपकी जॉब आपके अकाउंट की डेडिकेटेड मशीन पर चलती हैं, जो जॉब के बीच बनी रहती है, और जिन जॉब को नई VM चाहिए उन्हें वह 7 सेकंड में मिलती है। आने के लिए एक runs-on लाइन बदलें।
क्या मापा गया, और किस पर
Skipbox होस्ट ZFS pool पर Incus के ज़रिए KVM वर्चुअल मशीनें चलाता है। रनर इमेज एक snapshot वाली रुकी हुई VM है। जिस जॉब को नई VM चाहिए, उसे उस snapshot का ZFS clone मिलता है, वह बूट होती है, guest agent के ज़रिए just-in-time रनर config पाती है, एक जॉब चलाती है, और अपनी डिस्क के साथ डिलीट हो जाती है।
होस्ट daemon शुरुआत के हर स्टेप का अंत जॉब स्वीकार करने के पल से मिलीसेकंड में लॉग करता है (startMs: cloned, started, agent)। नीचे के आंकड़े 16-thread Intel i7-7820X होस्ट और 4 vCPU और 8 GB वाली VM से हैं।
| स्वीकार करने से रनर की शुरुआत तक, हर एक के 3 रन | |
|---|---|
| पहले | 22.9 s (21.7 से 24.2) |
| बाद में | 7.25 s (7.1 से 8.1) |
यह कहां गया, हर हिस्सा अलग से मापा गया:
| बदलाव | मापा गया | बचत |
|---|---|---|
| OVMF के बजाय SeaBIOS | VM शुरू होने से agent के पहले जवाब तक, 3 का median: 13.7 → 8.4 s | 5.3 s |
kernel command line पर quiet | 8.4 → 6.5 s | 1.9 s |
| कोई initrd नहीं | 6.5 → 5.1 s | 1.4 s |
| पहले से अपने clones के साइज़ की इमेज | Clone 1.5 → 0.1 s, पहली शुरुआत 2.35 → 1.8 s | 1.9 s |
| dockerd के बजाय Docker के socket का इंतज़ार | dockerd agent के 3.6 s बाद चालू हुआ | 3.6 s |
| guest agent से हर सेकंड के बजाय हर 100 ms पूछना | औसतन 0.5 s, 1 s तक | 0.5 s |
ये हिस्से शुरू से अंत तक के 15.65 s के अंतर में से 14.6 s जोड़ते हैं।
Firmware: GRUB से पहले 5.3 सेकंड
Incus डिफ़ॉल्ट रूप से VM को OVMF और secure boot के साथ बूट करता है। इस होस्ट पर OVMF को GRUB तक पहुंचाने में 5.3 s लगे। SeaBIOS 0.5 s लेता है। दो instance keys इसे बदलती हैं: security.csm=true और security.secureboot=false।
यह सबसे बड़ा एक हिस्सा था, और अकेला जो सुरक्षा को छूता है, इसलिए यहां पूरा है। SeaBIOS के साथ guest की boot chain का signature जांचा नहीं जाता। वह जांच जिससे बचाती है, वह है किसी का guest का bootloader या kernel बदलना। CI जॉब VM में वह कोई खुद जॉब है, और जॉब के पास पहले से अपनी VM में root है: वह कुछ भी sudo कर सकती है, और जॉब खत्म होने पर VM और उसकी डिस्क डिलीट हो जाती हैं। एक ग्राहक की VM को दूसरे से दूर रखने वाली चीज़ें KVM और होस्ट के bridge पर हर VM की firewall chain हैं, और इनमें से कोई guest के firmware पर निर्भर नहीं। इमेज दोनों के तहत बूट होती है, और होस्ट पर एक flag UEFI वापस ला देता है।
शांत kernel, और कोई initrd नहीं
जॉब VM हर जॉब के लिए एक बार बूट होती है, और कोई उसका serial console नहीं पढ़ता। quiet ने median 8.4 से 6.5 s कर दिया।
initrd इसलिए है ताकि वह root file system ढूंढने वाले drivers लोड करे। Ubuntu के generic kernel में virtio-scsi और ext4 पहले से built-in हैं, और हर clone इमेज का partition UUID शेयर करता है, इसलिए kernel root=PARTUUID=… से सीधे / mount करता है। यह 1.4 s और था।
दो सुरक्षा उपाय इसे चुपचाप गलत होने से रोकते हैं। अगर initrd के बिना बूट panic हुआ, तो Ubuntu का GRUB अगली बार अपने-आप initrd के साथ बूट करता है (GRUB_FORCE_PARTUUID)। वह fallback हर जॉब में चुपचाप 1.4 s वापस ला देता, इसलिए इमेज बिल्ड एक टेस्ट clone बूट करता है और अगर dmesg initramfs के अनपैक होने को दिखाए तो फ़ेल हो जाता है।
जिस डिस्क को सही साइज़ में बना सकते थे, उसका साइज़ न बदलें
इमेज छोटी डिस्क पर बनाई गई थी, और हर clone शुरू होने पर अपने प्लान के साइज़ तक बढ़ाया जाता था। बढ़ाने में हर जॉब के 1.9 s लगते थे: clone ने 0.1 s के बजाय 1.5 s लिए, और पहली शुरुआत ने 1.8 s के बजाय 2.35 s। अब इमेज सबसे छोटे प्लान की डिस्क साइज़ (80 GB) पर बनती है। volume thin है, इसलिए इमेज में अब भी सिर्फ़ वही है जो उसमें लिखा गया। Incus clone को छोटा नहीं कर सकता, इसलिए इमेज कभी सबसे छोटे प्लान से बड़ी नहीं होती; बड़े प्लान बूट पर बढ़ते हैं।
Docker का socket काफ़ी है
run script पहले रनर शुरू करने से पहले docker.service का इंतज़ार करती थी। dockerd guest agent के 3.6 s बाद चालू होता था। पर systemd शुरुआती बूट से ही Docker के socket पर सुनता है, और जो client dockerd चालू होने से पहले जुड़ता है वह उसका इंतज़ार करता है। इसलिए script सिर्फ़ docker.socket और DNS का इंतज़ार करती है, सीमित समय तक, और dockerd रनर के साथ-साथ शुरू होना पूरा करता है।
100 ms पर polling
रनर का config guest agent के ज़रिए VM में भेजा जाता है, जो guest के बूट होने तक मौजूद नहीं होता। होस्ट हर सेकंड एक बार फिर से कोशिश करता था, इसलिए agent आने के बाद जॉब औसतन 0.5 s इंतज़ार करती थी। agent बंद होने पर Incus 20 ms में push मना कर देता है, इसलिए हर 100 ms पूछने में कुछ नहीं लगता। VM के पहले 30 s के बाद होस्ट वापस हर सेकंड एक बार पर आ जाता है।
बूट का हल नहीं: जॉब के साथ खत्म होने वाली डिस्क पर fsync
मापते समय पता चला कि VM में सबसे धीमी चीज़ बूट नहीं थी। guest में हर fsync होस्ट के ZFS के intent log commit करने का इंतज़ार करता था। नई जॉब VM की डिस्क जॉब के साथ डिलीट हो जाती है, इसलिए उस पर किसी चीज़ को बिजली जाने से बचना ज़रूरी नहीं। run script रनर शुरू करने से पहले / को nobarrier के साथ फिर से mount करती है।
4 vCPU और 8 GB वाली VM में, 3 का median:
| पहले | बाद में | |
|---|---|---|
| fsync के साथ 4k random writes | 227 प्रति सेकंड | 2,505 प्रति सेकंड |
yarn install, उसके कैश से 1 GB node_modules | 12.92 s | 9.99 s (23% कम) |
docker pull node:22 | 19.12 s | 15.45 s (19% कम) |
| redis का Docker बिल्ड | 92.89 s | 87.21 s |
make -j4, sysbench cpu | बिना बदलाव | बिना बदलाव |
यह सिर्फ़ नई VM को मिलता है। आपकी डेडिकेटेड मशीन जॉब के बीच आपका कैश रखती है, और उसका ext4 अपने barriers रखता है।
किराए के क्लाउड सर्वर पर वही खोज
जब Skipbox के अपने होस्ट भरे होते हैं, तो जॉब snapshot इमेज से बूट हुए क्लाउड सर्वर पर चलती है। उस रास्ते का अपना खोया समय था, दूसरी जगह पर। 4 vCPU Intel shared सर्वर पर जॉब script (सर्वर का user data) kernel के 28.1 s बाद शुरू हुई। cloud-init के पास script 19.3 s पर थी और Docker 22.2 s पर चालू था, पर cloud-init user data को अपने आखिरी चरण में चलाता है, बाकी सब के बाद।
अब इमेज में एक छोटा systemd unit है जो cloud-init के user data लिखते ही उसे चला देता है। यह script को ऐसी फ़ाइल के file descriptor से पढ़ता है जिसे वह पहले ही हटा चुका है, इसलिए cloud-init के आखिरी चरण को दूसरी बार चलाने को कुछ नहीं मिलता। इमेज तीन के बजाय एक तरह की SSH host key भी बनाती है (उस रास्ते पर 2.0 s जिसका सब इंतज़ार करते हैं; इन सर्वर में कोई साइन इन नहीं करता), और अब बूट पर snapd, apport, rsyslog या दर्जन भर maintenance timers शुरू नहीं करती।
उस इमेज के साथ, 4 vCPU AMD shared सर्वर पर, जॉब script kernel के 8 से 14 s बाद शुरू होती है।
पिन किए गए vCPU हर होस्ट की घड़ी सही रखते हैं
hybrid CPU पर (performance कोर और efficiency कोर, जैसे Core Ultra 7 265F), KVM TSC पर भरोसा करना बंद कर सकता है। इमेज बिल्ड की एक रात के दौरान kernel ने लॉग किया:
tsc: Marking TSC unstable due to KVM discovered backwards TSC
clocksource: Switched to clocksource acpi_pm
जब कोई vCPU दूसरे होस्ट CPU पर जाता है, तो KVM TSC की तुलना करता है। उसने नए कोर पर, कोर के प्रकारों के बीच, कम वैल्यू पढ़ी और TSC को अस्थिर चिह्नित किया। kernel ने बूट पर पहले ही HPET बंद कर दिया था ("HPET dysfunctional in PC10"), इसलिए बचा हुआ एकमात्र clock source acpi_pm था, जो इस board पर मुश्किल से आगे बढ़ता था: 30 मिनट में लगभग 1 सेकंड का uptime।
Skipbox इसे दो कदमों में ठीक करता है:
- काम करने वाला fallback। BIOS में package C-state को C8 तक सीमित करने से HPET चालू रहता है। लोड के तहत 8-vCPU VM शुरू और बंद करने वाले 20 राउंड के लूप के 11वें राउंड में KVM ने फिर भी TSC छोड़ा, पर घड़ी HPET पर चली गई और समय सही रखा।
- पिन करना। KVM वह जांच तभी चलाता है जब कोई vCPU जगह बदलता है। हर vCPU एक होस्ट CPU पर पिन होने पर, वही लूप TSC पर 40 राउंड चला, लॉग में बिना किसी नई लाइन के।
होस्ट daemon कोई जॉब तब तक नहीं लेता जब तक clock source tsc न हो और hpet उपलब्ध न हो, इसलिए जो होस्ट अपना TSC छोड़ता है वह खुद को खाली कर देता है और उसकी जॉब दूसरी मशीनों पर चली जाती हैं। हर Skipbox होस्ट अपने vCPU पिन करता है।
सबसे तेज़ बूट वह है जिसे आप छोड़ देते हैं
सात सेकंड उन जॉब के लिए हैं जिन्हें नई VM चाहिए: बिना write एक्सेस वाले लोगों का कोड (जैसे फ़ोर्क से आई पुल रिक्वेस्ट), आपकी मशीन व्यस्त होने पर आने वाली जॉब, और वे अकाउंट जो हर जॉब के लिए साफ़ VM चुनते हैं। बाकी हर जॉब कुछ बूट नहीं करती। वह आपके अकाउंट की डेडिकेटेड मशीन पर चलती है, जिसकी डिस्क पर पिछली जॉब की Docker लेयर, पैकेज कैश और टूल अब भी होते हैं।
मिनट वहीं हैं। वही वर्कफ़्लो GitHub के ubuntu-latest (2 vCPU, जो प्राइवेट रिपॉज़िटरी को मिलता है) पर और पहले से तैयार Skipbox S (4 vCPU) पर, बाद वाले रन के median:
GitHub ubuntu-latest | Skipbox S, पहले से तैयार | ||
|---|---|---|---|
| excalidraw: install, बिल्ड और टेस्ट | 613 s | 450 s | 27% कम |
| सेटअप स्टेप (checkout, Node, कैश restore) | 52 s | 7 s | |
| टेस्ट | 484 s | 354 s | |
| umami: multi-stage Docker बिल्ड | 263 s | 188 s | 29% कम |
सेटअप स्टेप 52 s से 7 s पर आ जाते हैं क्योंकि डाउनलोड और अनपैक करने को कोई कैश आर्काइव नहीं है: Node पहले से टूल कैश में है और yarn का कैश डिस्क पर है। Docker बिल्ड daemon का अपना लेयर कैश इस्तेमाल करता है, बिना कुछ एक्सपोर्ट या इंपोर्ट किए। Skipbox पर वर्कफ़्लो में कोई कैश स्टेप ही नहीं है।
तय कीमत मशीन को तैयार क्यों रख सकती है
खाली मशीन बर्बादी लगती है। जिस तरह compute का बिल बनता है, उसमें यह सस्ता विकल्प है, और इसी से तय कीमत काम करती है।
किराए का क्लाउड सर्वर हर उस घंटे के लिए पूरा बिल होता है जो वह शुरू करता है। अपने सर्वर पर 3 मिनट की जॉब 60 मिनट के पैसे देती है। हमारे अपने CI के एक दिन में, औसतन 2.5 मिनट की 44 जॉब 44 सर्वर पर चलीं और 44 सर्वर-घंटे बिल हुए। उसी दिन को दोबारा चलाने पर, जब हर सर्वर उसके घंटे के अंदर अकाउंट की अगली जॉब के लिए रखा गया, 13 से 14 सर्वर-घंटे आते हैं: लगभग 70% कम। और एक महीने में 730 घंटे होते हैं: जो अकाउंट प्रति-जॉब सर्वर पर हर महीने 730 से ज़्यादा छोटी जॉब चलाता है, वह कभी न रुकने वाली मशीन से ज़्यादा घंटों के पैसे देता है।
इसलिए जो मशीन आपके लिए सबसे तेज़ है (डिस्क पर कैश, बूट करने को कुछ नहीं), वही चलाने में सबसे सस्ती भी है। Skipbox के अपने होस्ट पहले आते हैं क्योंकि उनका कोई घंटे का बिल ही नहीं, और किराए के सर्वर बाकी संभालते हैं। इसीलिए Skipbox मिनट के नहीं, मशीन के पैसे लेता है:
| हर महीने के मिनट (4 vCPU) | GitHub | Skipbox S | आपकी हर महीने की बचत |
|---|---|---|---|
| 10,000 | $102 | $39 | $63 |
| 20,000 | $222 | $39 | $183 |
| 30,000 | $342 | $39 | $303 |
| हमेशा चालू | $500.40 | $39 | $461.40 |
पूरे इस्तेमाल पर यह GitHub की कीमत का 1/12 है। GitHub के आंकड़े GitHub Team के शामिल compute के बाद का बिल हैं। अपने मिनट होम पेज के कैलकुलेटर में डालें; उसे साइन इन की ज़रूरत नहीं।
आना बस एक लाइन का काम है
jobs:
build:
runs-on: skipbox # was ubuntu-latest
- GitHub से Skipbox में साइन इन करें।
- Skipbox GitHub App इंस्टॉल करें और रिपॉज़िटरी चुनें।
runs-onबदलें और push करें।
आज़माएं
ट्रायल में कार्ड नहीं लगता: 7 दिन या 3,000 जॉब-मिनट, जो भी पहले पूरा हो। अपने सबसे धीमे वर्कफ़्लो को runs-on: skipbox पर ले जाएं, उसे दो बार चलाएं, और दूसरे रन के स्टेप के समय मिलाएं।
अक्सर पूछे जाने वाले सवाल
Skipbox पर GitHub Actions जॉब के लिए नई VM शुरू होने में कितना समय लगता है?
Skipbox के अपने होस्ट पर, होस्ट के जॉब स्वीकार करने से रनर प्रोसेस शुरू होने तक 7.25 सेकंड, जो पहले 22.9 सेकंड था। ज़्यादातर जॉब कुछ बूट नहीं करतीं: वे आपके अकाउंट की डेडिकेटेड मशीन पर चलती हैं, जो जॉब के बीच बनी रहती है।
क्या CI जॉब की VM को UEFI secure boot के बजाय SeaBIOS से बूट करना सुरक्षित है?
जॉब की VM के लिए हां। secure boot guest की boot chain को बदले जाने से बचाता है, और CI जॉब के पास पहले से अपनी VM में root है, जो जॉब के बाद डिलीट हो जाती है। Skipbox पर VM को KVM और होस्ट पर हर VM के firewall से अलग रखा जाता है, और इनमें से कोई guest के firmware पर निर्भर नहीं।
ZFS पर VM में fsync धीमा क्यों है, और CI के लिए इसे कैसे ठीक करें?
guest में हर fsync होस्ट के ZFS के intent log commit करने का इंतज़ार करता है। नई जॉब VM की डिस्क जॉब के साथ डिलीट हो जाती है, इसलिए Skipbox उसका ext4 बिना barriers के mount करता है: yarn install 23% तेज़ और docker pull 19% तेज़। जो मशीन जॉब के बीच बनी रहती है, वह अपने barriers रखती है।
hybrid CPU पर KVM, TSC को अस्थिर क्यों चिह्नित करता है?
जब कोई vCPU दूसरे होस्ट CPU पर जाता है, तो KVM TSC की तुलना करता है, और performance और efficiency कोर के बीच वह कम वैल्यू पढ़ सकता है। हर vCPU को एक होस्ट CPU पर पिन करने से यह जांच चलना बंद हो जाती है: तब Skipbox के शुरू-और-बंद लूप ने 40 राउंड तक TSC बनाए रखा।
मैं अपनी जॉब Skipbox पर कैसे चलाऊं?
वर्कफ़्लो में runs-on को skipbox में बदलें। ट्रायल में कार्ड नहीं लगता: 7 दिन या 3,000 जॉब-मिनट, जो भी पहले पूरा हो।
19 नवंबर 2026 को अपडेट किया गया