Cum accelerezi GitHub Actions: scurtează un pipeline de 25 de minute, pârghie cu pârghie
Un pipeline GitHub Actions de 25 de minute înseamnă de obicei patru întârzieri suprapuse: joburi care se așteaptă între ele, muncă ce nu trebuia să ruleze, setup pe care un VM gol îl repetă la fiecare job și pași care depind de CPU, înghesuiți pe 2 nuclee (ubuntu-latest dintr-un repository privat are 2 CPU și 8 GB). Ia-le în această ordine. Mai întâi, măsoară calea critică, cu timpul de coadă separat. Apoi sari peste ce nu trebuia să ruleze, rulează simultan joburile independente, nu mai reconstrui starea, dă-le pașilor grei mai multe nuclee și împarte în sharduri ce e încă lung. Primele trei sunt corecturi de workflow care nu costă nimic. Restul țin de mașină: un runner care își păstrează cache-urile între joburi și are mai multe nuclee.
Skipbox este acel runner. Joburile tale rulează pe mașina dedicată a contului tău, care păstrează layerele Docker, cache-urile de pachete, instrumentele și rezultatele buildului între joburi, cu 4 până la 16 vCPU, la un preț fix de $39 pe lună, cu minute nelimitate. Pe CI-ul astro, asta a însemnat 528 s pe GitHub și 30 s pe Skipbox. Mutarea înseamnă o singură linie: runs-on: skipbox.
1. Măsoară calea critică
Timpul pe care îl așteaptă echipa ta e lanțul de joburi care se termină ultimul, nu suma tuturor joburilor. Deschide rularea unui pull request reprezentativ: graficul arată ce joburi le așteaptă pe care, iar logul fiecărui job arată duratele pașilor. Notează, pentru lanțul cel mai lent:
| Faza | Ce verifici |
|---|---|
| În coadă | A așteptat jobul un runner? O comandă mai rapidă nu poate scurta o coadă |
| Set up job, checkout | O imagine de container descărcată, o clonă completă unde ar ajunge una superficială |
| Toolchain și instalare | A avut cache-ul potrivire și a economisit potrivirea mai mult decât a durat restaurarea? |
| Build | Se construiește același rezultat și într-un alt job? |
| Teste | E CPU-ul runnerului ocupat tot timpul sau un singur worker face totul? |
| Încărcări | Artefacte și salvări de cache după ce munca utilă s-a terminat |
Compară o rulare cu cache cu una la rece. Un cache care ratează jumătate din timp arată bine într-o medie.
2. Sari peste ce nu trebuia să ruleze
- Anulează rulările depășite. Fiecare push după primul face inutilă rularea aflată în curs. Un grup de concurrency cu
cancel-in-progresso oprește. Limitează-l la pull request-uri, ca un push pe branchul implicit să nu anuleze niciodată un deploy:
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
- Rulează doar ce atinge schimbarea. Filtrele
paths:sar peste un workflow la schimbările doar de documentație; într-un monorepo,turbo run test --affectedsau comenzile affected din Nx rulează doar pachetele care s-au schimbat. Un filtru la nivel de trigger înseamnă că o verificare obligatorie nu raportează niciodată, așa că filtrează în interiorul jobului când verificarea e obligatorie.
3. Rulează simultan joburile independente
GitHub rulează joburile în paralel, dacă nu le înlănțuie needs:. Lint, verificarea tipurilor, testele unitare și buildul rareori au nevoie unele de altele: pornește-le împreună și lasă doar împachetarea sau deployul să le aștepte pe toate. Dacă două joburi construiesc același lucru, construiește-l o singură dată și transmite-l cu actions/upload-artifact, cronometrând încărcarea și descărcarea.
4. Nu mai reconstrui aceeași stare
Aici se duce cea mai mare parte a unui pipeline lung. Fiecare job de pe un runner găzduit de GitHub pornește pe un VM nou, așa că își descarcă toolchainul, instalează dependențele, reconstruiește layerele Docker și compilează de la zero, de fiecare dată.
- Cache-uri care chiar au potriviri.
cache: npmdinactions/setup-node(și formele lui pentru pnpm și yarn) salvează descărcările managerului de pachete, cu cheia legată de lockfile; nu salveazănode_modules, așa că instalarea tot rulează. GitHub păstrează 10 GB per repository, elimină intrările nefolosite de 7 zile, iar o potrivire tot e o descărcare pe VM-ul nou (limita de mărime a cache-ului). - Cache-urile instrumentelor.
eslint --cache,tsc --incremental, directorul de cache Jest și.turbo/cacheal turbo salvează munca însăși, nu descărcările. Pe un VM nou sunt goale, dacă nu le restaurezi și pe ele. - Layerele Docker.
docker buildpe un VM nou pornește fără niciun layer; ocolișul e să le exporți cucache-todin buildx și să le imporți la fiecare rulare (cache-ul de layere Docker).
O mașină care își păstrează discul face toate acestea singură: cache-urile, cache-urile instrumentelor, layerele și rezultatele buildului sunt acolo de la jobul anterior.
5. Dă-le pașilor grei mai multe nuclee
Compilatoarele, bundlerele și test runnerele pornesc câte un worker pe nucleu, așa că pe 2 CPU rulează câte două odată. Verifică ce folosește de fapt test runnerul: Jest folosește implicit numărul de nuclee minus unu (un worker pe 2 CPU), pytest rulează serial până la -n auto, iar Playwright folosește implicit jumătate din nuclee, documentația lui recomandând un singur worker în CI. Mai multe nuclee ajută doar după ce runnerului i se spune să le folosească și doar la pașii care țin CPU-ul ocupat; o descărcare sau pornirea unei baze de date nu se accelerează.
Pe GitHub, mai multe nuclee înseamnă runnere mari: de la 4 la 96 de nuclee, doar pe organizațiile cu GitHub Team sau Enterprise Cloud, facturate la minut, la un tarif mai mare pe nucleu.
6. Împarte în sharduri ce e încă lung
O matrice de sharduri împarte o suită lungă pe mai multe joburi. Scurtează timpul real, nu minutele: fiecare shard face din nou checkout, instalare și build, așa că patru sharduri plătesc setup-ul de patru ori. Echilibrează shardurile după timpul măsurat, nu după numărul de fișiere, și nu mai adăuga când setup-ul înseamnă cea mai mare parte din fiecare shard.
Cât te costă să rămâi lent
Un pipeline de 15 minute care rulează de 40 de ori pe zi înseamnă 10 ore de așteptare împărțite în echipa ta, în fiecare zi, înainte să numere cineva întreruperile. La facturarea la minut, minutele de setup se facturează la fel ca minutele de teste:
| Minute pe lună (4 vCPU) | GitHub | Skipbox S | Economisești în fiecare lună |
|---|---|---|---|
| 10.000 | $102 | $39 | $63 |
| 20.000 | $222 | $39 | $183 |
| 30.000 | $342 | $39 | $303 |
Pe GitHub, mai multe nuclee costă mai mult pe minut, așa că diferența crește odată cu mașina:
| 20.000 de minute pe lună | GitHub | Skipbox | Economisești în fiecare lună |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | $343 |
| 16 vCPU | $822 | $149 (L) | $673 |
Cifrele GitHub sunt după utilizarea inclusă în GitHub Team. Încearcă propriile minute în calculatorul de pe pagina principală.
Când soluția e mașina
Joburile de CI ale unor proiecte reale, cu pașii neschimbați, pe runnerul GitHub pentru repository-uri publice (4 vCPU, 16 GB) și pe o mașină dedicată Skipbox cu același număr de vCPU, din rulările noastre ale workflow-urilor lor:
| Proiect | GitHub | Skipbox, mașina dedicată | Ce a păstrat mașina |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | 30 s | cache-ul turbo: 40 de taskuri de build reluate |
| tauri (Rust) | 246 s | 53 s | target/ de la Cargo: niciun crate recompilat |
| ripgrep (Rust) | 200 s | 40 s | target/ și imaginea Docker ale cross |
| vite (Node.js) | 141 s | 100 s | cache-urile de pachete; restul înseamnă rularea testelor |
ubuntu-latest dintr-un repository privat are jumătate din nucleele acelor rulări GitHub.
Ce face Skipbox pentru pipeline-ul tău
Păstrează mașina. Fiecare plan vine cu mașina dedicată a contului tău, păstrată între joburi. Imaginile, layerele și cache-ul de build Docker, cache-urile de pachete, tool cache-ul și checkoutul tău cu target/ de la Cargo și cache-ul turbo rămân pe discul ei: cel puțin de 7× spațiul de cache de la GitHub, fără chei, fără expirare după 7 zile și fără regula branchurilor.
Adaugă nuclee la preț fix. Un job își alege mărimea prin etichetă:
| Etichetă | Mașină | Plan |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 pe lună |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 pe lună |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 pe lună |
Minutele sunt nelimitate, așa că shardurile, rulările repetate și o matrice mai mare nu măresc factura. Joburile Skipbox nu folosesc minute GitHub, așa că un buget GitHub nu le oprește niciodată.
Se îngrijește singur. Skipbox pregătește mașina, ține imaginea la zi, face curățenie după fiecare job și reface o mașină care nu trece verificarea stării.
Mutarea înseamnă o singură linie
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
- Conectează-te la Skipbox cu GitHub.
- Instalează aplicația GitHub Skipbox și alege repository-urile.
- Schimbă
runs-onși fă push.
Pașii și actions rulează așa cum sunt, pe Ubuntu 24.04 cu Docker, Node.js și Python.
Securitate
- Mașina este doar a contului tău. Niciun job al altei companii nu rulează pe ea.
- După fiecare job, credențialele runnerului, procesele și containerele sunt șterse, la fel și credențialele git și fișierele neurmărite din checkoutul păstrat. „Curățare la fiecare job” îi dă în schimb fiecărui job o mașină nouă.
- Codul de la persoane fără acces de scriere (cum ar fi pull request-urile din forkuri) rulează pe un VM nou, care îți citește cache-urile, dar nu le poate modifica.
Detaliile sunt în cum sunt izolate joburile.
Încearcă pe cel mai lent job
Perioada de probă este gratuită timp de 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, și nu cere card. Mută pe runs-on: skipbox jobul de pe calea ta critică, rulează-l de două ori și citește duratele pașilor de la a doua rulare lângă cele de pe GitHub.
Întrebări frecvente
Pipeline-ul nostru GitHub Actions durează 25 de minute. Care e cea mai rapidă cale să-l facem mai rapid?
Ia-o pe rând. Citește graficul rulării și duratele pașilor ca să găsești lanțul de joburi care stabilește durata, cu timpul de coadă separat. Anulează rulările depășite și sari peste joburile ale căror fișiere nu s-au schimbat. Renunță la needs: care exprimă doar un obicei, ca joburile independente să ruleze simultan. Nu mai reconstrui starea la fiecare job: cache-uri care chiar au potriviri sau un runner care își păstrează discul. Dă-le pașilor care depind de CPU mai multe nuclee și lasă test runnerul să le folosească. Împarte în sharduri doar ce e încă lung. Pe ubuntu-latest dintr-un repository privat (2 CPU, 8 GB), ultimele trei înseamnă adesea cea mai mare parte din cele 25 de minute și țin de mașină: Skipbox îi dă jobului propria mașină, care păstrează cache-urile între joburi, cu 4 până la 16 vCPU.
Merită să trecem pe runnere mai rapide în loc să optimizăm workflow-ul?
Fă mai întâi corecturile gratuite din workflow: anularea rulărilor depășite, filtrele de cale și eliminarea needs: inutile nu costă nimic și niciun runner nu le face în locul tău. După aceea, uită-te unde se duce restul timpului. Setup-ul care se repetă la fiecare job (toolchainuri, instalarea dependențelor, builduri Docker) și pașii care țin ocupat fiecare nucleu sunt problema mașinii, iar un runner care își păstrează cache-urile și are mai multe nuclee le elimină cu o schimbare de o linie în runs-on. Așteptările pe rețea și pașii seriali nu se accelerează cu o mașină mai mare.
De ce e GitHub Actions mai lent decât laptopul meu?
Laptopul tău își păstrează pe disc pachetele, instrumentele, layerele Docker și rezultatele buildului și are de obicei 8 nuclee sau mai multe. Un job pe ubuntu-latest dintr-un repository privat primește 2 CPU și 8 GB, pe un VM nou care nu are nimic din toate acestea. Skipbox funcționează ca laptopul tău: mașina rămâne între joburi, cu 4 vCPU sau mai mult.
Împărțirea testelor în sharduri face GitHub Actions mai rapid?
Scurtează timpul real, nu minutele. Fiecare shard e un job nou care face din nou checkout, instalare și build, așa că patru sharduri plătesc setup-ul de patru ori, iar facturarea la minut le numără pe fiecare. Împarte în sharduri după ce setup-ul e ieftin și nucleele runnerului sunt folosite. Pe Skipbox, setup-ul rămâne pe disc, iar minutele sunt nelimitate, așa că shardurile nu costă nimic în plus.
Cum obțin mai mult de 4 nuclee pentru un job GitHub Actions?
Pe GitHub, runnerele mari au între 4 și 96 de nuclee, doar pentru organizațiile pe GitHub Team sau Enterprise Cloud, facturate la minut. Pe Skipbox, schimbă runs-on în skipbox-8x16 pentru 8 vCPU sau skipbox-16x32 pentru 16 vCPU, la un preț lunar fix, atât pe organizații, cât și pe conturi personale.
Cât costă să încerc?
Nimic. Perioada de probă durează 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, fără card. Schimbă runs-on al celui mai lent job în skipbox, rulează-l de două ori și compară duratele pașilor.
Actualizat pe 13 noiembrie 2026