# วิธีเร่งความเร็ว GitHub Actions: ลด pipeline 25 นาที ทีละคันโยก

> pipeline ของ GitHub Actions ที่ช้าคือจ็อบที่รอกันเอง งานที่ไม่จำเป็นต้องรัน การตั้งค่าที่ทำซ้ำบน VM ว่างเปล่า และขั้นตอนที่ใช้ CPU หนักบน 2 คอร์ แก้ตามลำดับนั้น สองอย่างสุดท้ายเป็นเรื่องของเครื่อง: Skipbox เก็บแคชของคุณไว้บนเครื่องเฉพาะของคุณระหว่างจ็อบ ได้ถึง 16 vCPU ในราคาเหมาจ่าย $39 ต่อเดือน ไม่จำกัดนาที

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`

- คันโยกตามลำดับ: วัด ข้าม รันขนาน หยุดสร้างใหม่ เพิ่มคอร์ แบ่ง shard
- เครื่องเฉพาะของคุณเก็บแคชและผลลัพธ์ build ไว้ระหว่างจ็อบ: CI ของ astro จาก 528 วินาทีเหลือ 30 วินาที
- 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-speed-up-github-actions-th)

## 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](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) (ภาษาอังกฤษ) ที่มี `cancel-in-progress` หยุดมันได้ จำกัดขอบเขตไว้ที่ pull request เพื่อไม่ให้ push ไปยัง default branch ยกเลิก deploy:

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
```

- **รันเฉพาะสิ่งที่การเปลี่ยนแปลงแตะ** ตัวกรอง `paths:` ข้ามเวิร์กโฟลว์เมื่อเปลี่ยนแค่เอกสาร ใน monorepo `turbo 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 ใหม่ ([ขีดจำกัดขนาดแคช](https://skipbox.dev/th/guides/github-actions-cache-size-limit))
- **แคชของเครื่องมือ** `eslint --cache`, `tsc --incremental` ไดเรกทอรีแคชของ Jest และ `.turbo/cache` ของ turbo บันทึกตัวงานเอง ไม่ใช่สิ่งที่ดาวน์โหลด บน VM ใหม่มันว่างเปล่า เว้นแต่คุณจะกู้คืนมันด้วย
- **layer ของ Docker** `docker build` บน VM ใหม่เริ่มโดยไม่มี layer การ export มันด้วย `cache-to` ของ buildx แล้ว import ทุกการรันคือทางเลี่ยง ([แคช layer ของ Docker](https://skipbox.dev/th/guides/docker-layer-cache-github-actions))

เครื่องที่เก็บดิสก์ไว้ทำทั้งหมดนี้เอง: แคช แคชของเครื่องมือ layer และผลลัพธ์ build อยู่ที่นั่นตั้งแต่จ็อบล่าสุด

## 5. ให้คอร์มากขึ้นแก่ขั้นตอนที่หนัก

คอมไพเลอร์ bundler และ test runner เริ่ม worker หนึ่งตัวต่อคอร์ บน 2 CPU มันจึงรันได้ทีละสอง ตรวจว่า test runner ใช้จริงเท่าไร: [Jest](https://jestjs.io/docs/cli#--maxworkersnumstring) (ภาษาอังกฤษ) ใช้ค่าเริ่มต้นเป็นจำนวนคอร์ลบหนึ่ง (worker เดียวบน 2 CPU) pytest รันตามลำดับจนกว่าจะใส่ `-n auto` และ [Playwright](https://playwright.dev/docs/ci#workers) (ภาษาอังกฤษ) ใช้ค่าเริ่มต้นเป็นครึ่งหนึ่งของคอร์ โดยเอกสารของมันแนะนำ worker เดียวใน CI คอร์ที่มากขึ้นช่วยได้ก็ต่อเมื่อบอกรันเนอร์ให้ใช้มัน และเฉพาะกับขั้นตอนที่ทำให้ CPU ยุ่งอยู่ การดาวน์โหลดหรือการเริ่มฐานข้อมูลไม่เร็วขึ้น

บน GitHub คอร์ที่มากขึ้นหมายถึง[รันเนอร์ขนาดใหญ่](https://docs.github.com/en/actions/concepts/runners/larger-runners): 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 รวมให้แล้ว ลองใส่นาทีของคุณเองใน[เครื่องคำนวณบนหน้าแรก](https://skipbox.dev/?ref=g-speed-up-github-actions-th#cost)

## เมื่อวิธีแก้คือเครื่อง

จ็อบ CI ของโปรเจกต์จริงเอง โดยไม่แก้ขั้นตอน บนรันเนอร์ของรีโพสิทอรีสาธารณะของ GitHub (4 vCPU, 16 GB) และบนเครื่องเฉพาะของตัวเองใน Skipbox ที่มี vCPU เท่ากัน จาก[การรันเวิร์กโฟลว์ของโปรเจกต์เหล่านั้นของเรา](https://skipbox.dev/th/guides/rust-cache-slow-rust-ci):

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

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

```yaml
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
```

1. เข้าสู่ระบบ Skipbox ด้วย GitHub
2. ติดตั้ง GitHub App ของ Skipbox แล้วเลือกรีโพสิทอรี
3. เปลี่ยน `runs-on` แล้ว push

ขั้นตอนและ action ของคุณรันได้ตามเดิม บน Ubuntu 24.04 พร้อม Docker, Node.js และ Python

## ความปลอดภัย

- เครื่องเป็นของบัญชีคุณเท่านั้น ไม่มีจ็อบของบริษัทอื่นรันบนเครื่องนี้
- หลังทุกจ็อบ ข้อมูลรับรองของรันเนอร์ โปรเซส และคอนเทนเนอร์จะถูกลบ รวมถึงข้อมูลรับรองของ git และไฟล์ที่ไม่ถูก track ในโค้ดที่ checkout เก็บไว้ การตั้งค่า **VM ใหม่ทุกจ็อบ** ให้แต่ละจ็อบได้เครื่องใหม่แทน
- โค้ดจากคนที่ไม่มีสิทธิ์เขียน (เช่น pull request จาก fork) รันบน VM ใหม่ที่อ่านแคชของคุณได้แต่แก้ไขไม่ได้

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

## ลองกับจ็อบที่ช้าที่สุดของคุณ

ทดลองใช้ฟรี 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 รันสองครั้ง แล้วเทียบเวลาของแต่ละขั้นตอน

อัปเดต 2026-11-19 · https://skipbox.dev/th/guides/speed-up-github-actions
