วิธีเร่งความเร็ว GitHub Actions: ลด pipeline 25 นาที ทีละคันโยก
pipeline ของ GitHub Actions ที่ใช้ 25 นาทีมักเป็นความล่าช้าสี่อย่างซ้อนกัน: จ็อบที่รอกันเอง งานที่ไม่จำเป็นต้องรัน การตั้งค่าที่ VM ว่างเปล่าทำซ้ำทุกจ็อบ และขั้นตอนที่ใช้ CPU หนักที่ถูกบีบอยู่บน 2 คอร์ (ubuntu-latest ของรีโพสิทอรีส่วนตัวมี 2 CPU และ 8 GB) จัดการตามลำดับนี้ อย่างแรก วัด critical path โดยแยกเวลารอคิวออก จากนั้นข้ามสิ่งที่ไม่จำเป็นต้องรัน รันจ็อบที่ไม่ขึ้นต่อกันพร้อมกัน หยุดสร้างสถานะใหม่ ให้คอร์มากขึ้นแก่ขั้นตอนที่หนัก และแบ่ง shard สิ่งที่ยังยาวอยู่ สามอย่างแรกคือการแก้เวิร์กโฟลว์ที่ไม่มีค่าใช้จ่าย ที่เหลือเป็นเรื่องของเครื่อง: รันเนอร์ที่เก็บแคชไว้ระหว่างจ็อบและมีคอร์มากกว่า
Skipbox คือรันเนอร์นั้น จ็อบของคุณรันบนเครื่องที่โฮสต์ให้บัญชีของคุณเท่านั้น ซึ่งเก็บ layer ของ Docker แคชแพ็กเกจ เครื่องมือ และผลลัพธ์ build ไว้ระหว่างจ็อบ ด้วย 4 ถึง 16 vCPU ในราคาเหมาจ่าย $39 ต่อเดือน ไม่จำกัดนาที บน CI ของ astro นั่นคือ 528 วินาทีบน GitHub และ 30 วินาทีบน Skipbox การย้ายคือบรรทัดเดียว: runs-on: skipbox
1. วัด critical path
เวลาที่ทีมของคุณรอคือสายจ็อบที่จบช้าที่สุด ไม่ใช่ผลรวมของทุกจ็อบ เปิดการรันของ pull request ที่เป็นตัวแทน: กราฟแสดงว่าจ็อบไหนรอจ็อบไหน และ log ของแต่ละจ็อบแสดงเวลาของแต่ละขั้นตอน จดไว้สำหรับสายที่ช้าที่สุด:
| ช่วง | สิ่งที่ต้องตรวจ |
|---|---|
| Queued | จ็อบรอรันเนอร์หรือเปล่า คำสั่งที่เร็วขึ้นลดคิวไม่ได้ |
| Set up job, checkout | ดึงอิมเมจคอนเทนเนอร์ หรือ clone เต็มในที่ที่ shallow ก็พอ |
| Toolchain และการติดตั้ง | แคช hit ไหม และการ hit ประหยัดได้มากกว่าเวลาที่ใช้กู้คืนหรือเปล่า |
| Build | ผลลัพธ์เดียวกันถูก build ในจ็อบอื่นด้วยหรือเปล่า |
| เทสต์ | CPU ของรันเนอร์ทำงานตลอดเวลา หรือมี worker ตัวเดียวทำทุกอย่าง |
| การอัปโหลด | artifact และการ save แคชหลังจากงานที่มีประโยชน์เสร็จแล้ว |
เทียบการรันที่ warm กับการรันเย็น แคชที่ miss ครึ่งหนึ่งของเวลาดูปกติดีเมื่อดูค่าเฉลี่ย
2. ข้ามสิ่งที่ไม่จำเป็นต้องรัน
- ยกเลิกการรันที่ถูกแทนที่ ทุก push หลังครั้งแรกทำให้การรันที่กำลังทำอยู่ไร้ประโยชน์ concurrency group (ภาษาอังกฤษ) ที่มี
cancel-in-progressหยุดมันได้ จำกัดขอบเขตไว้ที่ pull request เพื่อไม่ให้ push ไปยัง default branch ยกเลิก deploy:
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
- รันเฉพาะสิ่งที่การเปลี่ยนแปลงแตะ ตัวกรอง
paths:ข้ามเวิร์กโฟลว์เมื่อเปลี่ยนแค่เอกสาร ใน monorepoturbo run test --affectedหรือคำสั่ง affected ของ Nx รันเฉพาะแพ็กเกจที่เปลี่ยน ตัวกรองระดับ trigger หมายความว่า required check จะไม่รายงานผลเลย ถ้าเป็น required check ให้กรองภายในจ็อบแทน
3. รันจ็อบที่ไม่ขึ้นต่อกันพร้อมกัน
GitHub รันจ็อบแบบขนาน เว้นแต่ needs: จะร้อยมันเป็นสาย lint การตรวจ type เทสต์หน่วย และ build แทบไม่ต้องรอกัน: เริ่มพร้อมกัน แล้วให้เฉพาะการแพ็กหรือ deploy รอทั้งหมด ถ้าสองจ็อบ build สิ่งเดียวกัน ให้ build ครั้งเดียวแล้วส่งต่อด้วย actions/upload-artifact โดยจับเวลาการอัปโหลดและดาวน์โหลดด้วย
4. หยุดสร้างสถานะเดิมซ้ำ
นี่คือที่ที่เวลาส่วนใหญ่ของ pipeline ที่ยาวหายไป ทุกจ็อบบนรันเนอร์ที่ GitHub โฮสต์เริ่มบน VM ใหม่ มันจึงดาวน์โหลด toolchain ติดตั้ง dependency build layer ของ Docker ใหม่ และคอมไพล์ตั้งแต่ต้น ทุกครั้ง
- แคชที่ hit จริง
cache: npmของactions/setup-node(และแบบ pnpm กับ yarn) บันทึกสิ่งที่ package manager ดาวน์โหลดไว้ด้วย key จาก lockfile มันไม่บันทึกnode_modulesการติดตั้งจึงยังรันอยู่ GitHub เก็บ 10 GB ต่อรีโพสิทอรี ลบรายการที่ไม่ได้ใช้ 7 วัน และการ hit ก็ยังเป็นการดาวน์โหลดลง VM ใหม่ (ขีดจำกัดขนาดแคช) - แคชของเครื่องมือ
eslint --cache,tsc --incrementalไดเรกทอรีแคชของ Jest และ.turbo/cacheของ turbo บันทึกตัวงานเอง ไม่ใช่สิ่งที่ดาวน์โหลด บน VM ใหม่มันว่างเปล่า เว้นแต่คุณจะกู้คืนมันด้วย - layer ของ Docker
docker buildบน VM ใหม่เริ่มโดยไม่มี layer การ export มันด้วยcache-toของ buildx แล้ว import ทุกการรันคือทางเลี่ยง (แคช layer ของ Docker)
เครื่องที่เก็บดิสก์ไว้ทำทั้งหมดนี้เอง: แคช แคชของเครื่องมือ layer และผลลัพธ์ build อยู่ที่นั่นตั้งแต่จ็อบล่าสุด
5. ให้คอร์มากขึ้นแก่ขั้นตอนที่หนัก
คอมไพเลอร์ bundler และ test runner เริ่ม worker หนึ่งตัวต่อคอร์ บน 2 CPU มันจึงรันได้ทีละสอง ตรวจว่า test runner ใช้จริงเท่าไร: Jest (ภาษาอังกฤษ) ใช้ค่าเริ่มต้นเป็นจำนวนคอร์ลบหนึ่ง (worker เดียวบน 2 CPU) pytest รันตามลำดับจนกว่าจะใส่ -n auto และ Playwright (ภาษาอังกฤษ) ใช้ค่าเริ่มต้นเป็นครึ่งหนึ่งของคอร์ โดยเอกสารของมันแนะนำ worker เดียวใน CI คอร์ที่มากขึ้นช่วยได้ก็ต่อเมื่อบอกรันเนอร์ให้ใช้มัน และเฉพาะกับขั้นตอนที่ทำให้ CPU ยุ่งอยู่ การดาวน์โหลดหรือการเริ่มฐานข้อมูลไม่เร็วขึ้น
บน GitHub คอร์ที่มากขึ้นหมายถึงรันเนอร์ขนาดใหญ่: 4 ถึง 96 คอร์ เฉพาะองค์กรบน GitHub Team หรือ Enterprise Cloud คิดเงินรายนาทีในอัตราต่อคอร์ที่สูงกว่า
6. แบ่ง shard สิ่งที่ยังยาวอยู่
matrix ของ shard แยกชุดเทสต์ที่ยาวไปหลายจ็อบ มันลดเวลาที่รอ ไม่ใช่นาที: แต่ละ shard checkout ติดตั้ง และ build ใหม่ สี่ shard จึงจ่ายค่าตั้งค่าสี่ครั้ง กระจาย shard ตามเวลาที่วัดได้ ไม่ใช่จำนวนไฟล์ และหยุดเพิ่มเมื่อการตั้งค่ากลายเป็นส่วนใหญ่ของแต่ละ shard
ปล่อยให้ช้าต่อไป เสียเท่าไร
pipeline 15 นาทีที่รัน 40 ครั้งต่อวันคือการรอ 10 ชั่วโมงที่กระจายไปทั่วทีมของคุณ ทุกวัน ก่อนที่ใครจะนับการสลับบริบทเสียอีก ในการคิดเงินรายนาที นาทีของการตั้งค่าถูกคิดเงินเหมือนนาทีของเทสต์:
| นาทีต่อเดือน (4 vCPU) | GitHub | Skipbox S | ประหยัดได้ต่อเดือน |
|---|---|---|---|
| 10,000 | $102 | $39 | $63 |
| 20,000 | $222 | $39 | $183 |
| 30,000 | $342 | $39 | $303 |
คอร์ที่มากขึ้นบน GitHub แพงขึ้นต่อนาที ช่องว่างจึงกว้างขึ้นตามขนาดเครื่อง:
| 20,000 นาทีต่อเดือน | GitHub | Skipbox | ประหยัดได้ต่อเดือน |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | $343 |
| 16 vCPU | $822 | $149 (L) | $673 |
ตัวเลขของ GitHub คือหลังหักการใช้งานที่ GitHub Team รวมให้แล้ว ลองใส่นาทีของคุณเองในเครื่องคำนวณบนหน้าแรก
เมื่อวิธีแก้คือเครื่อง
จ็อบ CI ของโปรเจกต์จริงเอง โดยไม่แก้ขั้นตอน บนรันเนอร์ของรีโพสิทอรีสาธารณะของ GitHub (4 vCPU, 16 GB) และบนเครื่องเฉพาะของตัวเองใน Skipbox ที่มี vCPU เท่ากัน จากการรันเวิร์กโฟลว์ของโปรเจกต์เหล่านั้นของเรา:
| โปรเจกต์ | GitHub | Skipbox, เครื่องเฉพาะของตัวเอง | สิ่งที่เครื่องเก็บไว้ |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 วินาที | 30 วินาที | แคชของ turbo: เล่นซ้ำ build task 40 ตัว |
| tauri (Rust) | 246 วินาที | 53 วินาที | target/ ของ Cargo: ไม่มี crate ไหนถูกคอมไพล์ใหม่ |
| ripgrep (Rust) | 200 วินาที | 40 วินาที | target/ และอิมเมจ Docker ของ cross |
| vite (Node.js) | 141 วินาที | 100 วินาที | แคชแพ็กเกจ ที่เหลือคือเทสต์ของมันที่กำลังรัน |
ubuntu-latest ของรีโพสิทอรีส่วนตัวมีคอร์ครึ่งหนึ่งของการรันบน GitHub เหล่านั้น
Skipbox ทำอะไรให้ pipeline ของคุณ
เก็บเครื่องไว้ ทุกแพ็กเกจมาพร้อมเครื่องเฉพาะของบัญชีคุณ ที่เก็บไว้ระหว่างจ็อบ อิมเมจ layer และ build cache ของ Docker แคชแพ็กเกจ tool cache และโค้ดที่ checkout ไว้พร้อม target/ ของ Cargo และแคชของ turbo อยู่บนดิสก์ของมัน: พื้นที่แคชอย่างน้อย 7× ของ GitHub ไม่มี key ไม่หมดอายุหลัง 7 วัน และไม่มีกฎของ branch
เพิ่มคอร์ในราคาเหมาจ่าย จ็อบเลือกขนาดด้วยเลเบล:
| เลเบล | เครื่อง | แพ็กเกจ |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 ต่อเดือน |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 ต่อเดือน |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 ต่อเดือน |
ไม่จำกัดนาที shard การรันซ้ำ และ matrix ที่ใหญ่ขึ้นจึงไม่ทำให้บิลสูงขึ้น จ็อบของ Skipbox ไม่ใช้นาที GitHub งบประมาณของ GitHub จึงไม่เคยหยุดมัน
ดูแลตัวเอง Skipbox จัดเตรียมเครื่อง อัปเดตอิมเมจ เก็บกวาดหลังทุกจ็อบ และสร้างเครื่องใหม่เมื่อเครื่องตรวจสุขภาพไม่ผ่าน
ย้ายมาแค่บรรทัดเดียว
jobs:
test:
runs-on: skipbox # was ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
cache: npm
- run: npm ci && npm test
- เข้าสู่ระบบ Skipbox ด้วย GitHub
- ติดตั้ง GitHub App ของ Skipbox แล้วเลือกรีโพสิทอรี
- เปลี่ยน
runs-onแล้ว push
ขั้นตอนและ action ของคุณรันได้ตามเดิม บน Ubuntu 24.04 พร้อม Docker, Node.js และ Python
ความปลอดภัย
- เครื่องเป็นของบัญชีคุณเท่านั้น ไม่มีจ็อบของบริษัทอื่นรันบนเครื่องนี้
- หลังทุกจ็อบ ข้อมูลรับรองของรันเนอร์ โปรเซส และคอนเทนเนอร์จะถูกลบ รวมถึงข้อมูลรับรองของ git และไฟล์ที่ไม่ถูก track ในโค้ดที่ checkout เก็บไว้ การตั้งค่า VM ใหม่ทุกจ็อบ ให้แต่ละจ็อบได้เครื่องใหม่แทน
- โค้ดจากคนที่ไม่มีสิทธิ์เขียน (เช่น pull request จาก fork) รันบน VM ใหม่ที่อ่านแคชของคุณได้แต่แก้ไขไม่ได้
รายละเอียดอยู่ในวิธีแยกจ็อบออกจากกัน
ลองกับจ็อบที่ช้าที่สุดของคุณ
ทดลองใช้ฟรี 7 วัน หรือ 3,000 นาทีของจ็อบ แล้วแต่อย่างไหนครบก่อน ไม่ต้องใช้บัตร ย้ายจ็อบที่อยู่บน critical path ไปที่ runs-on: skipbox รันสองครั้ง แล้วอ่านเวลาของแต่ละขั้นตอนในการรันครั้งที่สองเทียบกับของ GitHub
คำถามที่พบบ่อย
pipeline ของ GitHub Actions ของเราใช้ 25 นาที ทางที่เร็วที่สุดที่จะทำให้เร็วขึ้นคืออะไร
ไล่ไปตามลำดับ อ่านกราฟและเวลาของแต่ละขั้นตอนในการรัน เพื่อหาสายจ็อบที่กำหนดเวลา โดยแยกเวลารอคิวออก ยกเลิกการรันที่ถูกแทนที่ และข้ามจ็อบที่ไฟล์ไม่เปลี่ยน ตัด needs: ที่มีไว้แค่ตามความเคยชิน เพื่อให้จ็อบที่ไม่ขึ้นต่อกันรันพร้อมกัน หยุดสร้างสถานะใหม่ทุกจ็อบ: แคชที่ hit จริง หรือรันเนอร์ที่เก็บดิสก์ไว้ ให้คอร์มากขึ้นแก่ขั้นตอนที่ใช้ CPU หนัก และให้ test runner ใช้มัน แบ่ง shard เฉพาะสิ่งที่ยังยาวอยู่ บน ubuntu-latest ของรีโพสิทอรีส่วนตัว (2 CPU, 8 GB) สามอย่างสุดท้ายมักเป็นส่วนใหญ่ของ 25 นาที และเป็นเรื่องของเครื่อง: Skipbox ให้จ็อบได้เครื่องเฉพาะของบัญชีคุณที่เก็บแคชไว้ระหว่างจ็อบ ด้วย 4 ถึง 16 vCPU
การเปลี่ยนไปใช้รันเนอร์ที่เร็วกว่าคุ้มไหม เมื่อเทียบกับการปรับเวิร์กโฟลว์
ทำการแก้เวิร์กโฟลว์ที่ฟรีก่อน: การยกเลิกการรันที่ถูกแทนที่ ตัวกรอง path และการตัด needs: ที่ไม่จำเป็นไม่มีค่าใช้จ่าย และไม่มีรันเนอร์ไหนทำให้คุณ หลังจากนั้นให้ดูว่าเวลาที่เหลือไปอยู่ที่ไหน การตั้งค่าที่ทำซ้ำทุกจ็อบ (toolchain การติดตั้ง dependency การ build Docker) และขั้นตอนที่ใช้ทุกคอร์เต็มที่เป็นปัญหาของเครื่อง และรันเนอร์ที่เก็บแคชไว้และมีคอร์มากกว่าเอามันออกได้ด้วยการเปลี่ยน runs-on บรรทัดเดียว การรอเครือข่ายและขั้นตอนที่รันตามลำดับไม่เร็วขึ้นด้วยเครื่องที่ใหญ่กว่า
ทำไม GitHub Actions ถึงช้ากว่าแล็ปท็อปของฉัน
แล็ปท็อปของคุณเก็บแพ็กเกจ เครื่องมือ layer ของ Docker และผลลัพธ์ build ไว้บนดิสก์ และมักมี 8 คอร์ขึ้นไป จ็อบบน ubuntu-latest ของรีโพสิทอรีส่วนตัวได้ 2 CPU และ 8 GB บน VM ใหม่ที่ไม่มีสิ่งเหล่านั้นเลย Skipbox ทำงานเหมือนแล็ปท็อปของคุณ: เครื่องอยู่ต่อระหว่างจ็อบ ด้วย 4 vCPU ขึ้นไป
การแบ่ง shard เทสต์ทำให้ GitHub Actions เร็วขึ้นไหม
มันลดเวลาที่รอ ไม่ใช่นาที แต่ละ shard คือจ็อบใหม่ที่ checkout ติดตั้ง และ build ใหม่ สี่ shard จึงจ่ายค่าตั้งค่าสี่ครั้ง และการคิดเงินรายนาทีนับทุกครั้ง แบ่ง shard หลังจากที่การตั้งค่าถูกแล้วและคอร์ของรันเนอร์ถูกใช้แล้ว บน Skipbox การตั้งค่าอยู่บนดิสก์และไม่จำกัดนาที shard จึงไม่มีค่าใช้จ่ายเพิ่ม
จะได้มากกว่า 4 คอร์สำหรับจ็อบ GitHub Actions อย่างไร
บน GitHub รันเนอร์ขนาดใหญ่มีตั้งแต่ 4 ถึง 96 คอร์ เฉพาะองค์กรบน GitHub Team หรือ Enterprise Cloud คิดเงินรายนาที บน Skipbox เปลี่ยน runs-on เป็น skipbox-8x16 สำหรับ 8 vCPU หรือ skipbox-16x32 สำหรับ 16 vCPU ในราคาเหมาจ่ายรายเดือน ได้ทั้งองค์กรและบัญชีส่วนตัว
ลองใช้มีค่าใช้จ่ายเท่าไร
ไม่เสียเลย ทดลองใช้ได้ 7 วัน หรือ 3,000 นาทีของจ็อบ แล้วแต่อย่างไหนครบก่อน ไม่ต้องใช้บัตร เปลี่ยน runs-on ของจ็อบที่ช้าที่สุดเป็น skipbox รันสองครั้ง แล้วเทียบเวลาของแต่ละขั้นตอน
อัปเดต 19 พฤศจิกายน 2026