GitHub Actions versnellen: een pipeline van 25 minuten inkorten, hefboom voor hefboom
Een GitHub Actions-pipeline van 25 minuten bestaat meestal uit vier opgestapelde vertragingen: jobs die op elkaar wachten, werk dat niet hoefde te draaien, setup die een lege VM bij elke job herhaalt, en CPU-zware steps die op 2 cores worden geperst (ubuntu-latest van een privé-repository heeft 2 CPU's en 8 GB). Pak ze in deze volgorde aan. Meet eerst het kritieke pad, met de wachttijd apart. Sla dan over wat niet hoefde te draaien, draai onafhankelijke jobs tegelijk, stop met het opnieuw opbouwen van toestand, geef de zware steps meer cores, en shard wat nog lang is. De eerste drie zijn workflowfixes die niets kosten. De rest is de machine: een runner die zijn caches tussen jobs bewaart en meer cores heeft.
Skipbox is die runner. Je jobs draaien op de dedicated machine van je account, die Docker-layers, packagecaches, tools en builduitvoer tussen jobs bewaart, met 4 tot 16 vCPU, voor een vaste $39 per maand met onbeperkte minuten. Voor de CI van astro was dat 528 s op GitHub en 30 s op Skipbox. Overstappen is één regel: runs-on: skipbox.
1. Meet het kritieke pad
De tijd waarop je team wacht, is de keten van jobs die als laatste klaar is, niet de som van alle jobs. Open de run van een representatieve pull request: de grafiek laat zien welke jobs op welke wachten, en het log van elke job toont zijn steptijden. Noteer voor de traagste keten:
| Fase | Wat je controleert |
|---|---|
| In de wachtrij | Wachtte de job op een runner? Een sneller commando verkort geen wachtrij |
| Set up job, checkout | Een containerimage die wordt opgehaald, een volledige clone waar een shallow clone volstaat |
| Toolchain en installatie | Was de cache raak, en bespaarde de hit meer dan het terugzetten kostte? |
| Build | Wordt dezelfde uitvoer in een andere job gebouwd? |
| Tests | Is de CPU van de runner de hele tijd bezig, of doet één worker alles? |
| Uploads | Artifacts en cache-opslagen nadat het nuttige werk klaar is |
Vergelijk een warme run met een koude. Een cache die de helft van de tijd mist, ziet er in een gemiddelde prima uit.
2. Sla over wat niet hoefde te draaien
- Annuleer ingehaalde runs. Elke push na de eerste maakt de lopende run zinloos. Een concurrency-groep met
cancel-in-progressstopt hem. Beperk hem tot pull requests, zodat een push naar de standaardbranch nooit een deploy annuleert:
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
- Draai alleen wat de wijziging raakt.
paths:-filters slaan een workflow over bij wijzigingen die alleen de documentatie raken; in een monorepo draaienturbo run test --affectedof de affected-commando's van Nx alleen de packages die zijn gewijzigd. Een filter op triggerniveau betekent dat een verplichte check nooit rapporteert, dus filter binnen de job als de check verplicht is.
3. Draai onafhankelijke jobs tegelijk
GitHub draait jobs parallel, tenzij needs: ze aan elkaar koppelt. Lint, typecontroles, unittests en de build hebben elkaar zelden nodig: start ze samen en laat alleen het verpakken of de deploy op alle wachten. Bouwen twee jobs hetzelfde, bouw het dan één keer en geef het door met actions/upload-artifact, en meet de tijd van de upload en download.
4. Stop met het opnieuw opbouwen van dezelfde toestand
Hier gaat het meeste van een lange pipeline heen. Elke job op een door GitHub gehoste runner start op een nieuwe VM, dus hij downloadt zijn toolchain, installeert dependencies, bouwt Docker-layers opnieuw en compileert vanaf nul, elke keer.
- Caches die echt raak zijn.
cache: npmvanactions/setup-node(en de varianten voor pnpm en yarn) slaat de downloads van de packagemanager op met een key op de lockfile; het slaatnode_modulesniet op, dus de installatie draait nog steeds. GitHub bewaart 10 GB per repository, laat items vallen die 7 dagen ongebruikt zijn, en een hit is nog steeds een download naar de nieuwe VM (limiet van de cache). - Toolcaches.
eslint --cache,tsc --incremental, de cachemap van Jest en.turbo/cachevan turbo bewaren het werk zelf, niet de downloads. Op een nieuwe VM zijn ze leeg, tenzij je ze ook terugzet. - Docker-layers.
docker buildop een nieuwe VM start zonder layers; ze exporteren metcache-tovan buildx en ze bij elke run importeren is de workaround (Docker-layercache).
Een machine die zijn schijf bewaart, doet dit allemaal vanzelf: de caches, de toolcaches, de layers en de builduitvoer staan er nog van de vorige job.
5. Geef de zware steps meer cores
Compilers, bundlers en testrunners starten één worker per core, dus op 2 CPU's draaien ze er twee tegelijk. Controleer wat de testrunner echt gebruikt: Jest gebruikt standaard het aantal cores min één (één worker op 2 CPU's), pytest draait serieel tot -n auto, en Playwright gebruikt standaard de helft van de cores, waarbij zijn documentatie één worker in CI aanraadt. Meer cores helpen pas als de runner wordt verteld ze te gebruiken, en alleen bij steps die de CPU bezighouden; een download of het starten van een database wordt niet sneller.
Op GitHub betekent meer cores larger runners: 4 tot 96 cores, alleen op organisaties op GitHub Team of Enterprise Cloud, gerekend per minuut tegen een hoger tarief per core.
6. Shard wat nog lang is
Een matrix van shards verdeelt een lange suite over jobs. Het verkort de doorlooptijd, niet de minuten: elke shard checkt opnieuw uit, installeert en bouwt opnieuw, dus vier shards betalen de setup vier keer. Verdeel shards op gemeten tijd, niet op aantal bestanden, en stop met toevoegen als de setup het grootste deel van elke shard is.
Wat traag blijven kost
Een pipeline van 15 minuten die 40 keer per dag draait, is 10 uur wachten verdeeld over je team, elke dag, nog voordat iemand de contextwisselingen telt. Bij facturering per minuut worden setupminuten gerekend zoals testminuten:
| Minuten per maand (4 vCPU) | GitHub | Skipbox S | Je bespaart per maand |
|---|---|---|---|
| 10.000 | $102 | $39 | $63 |
| 20.000 | $222 | $39 | $183 |
| 30.000 | $342 | $39 | $303 |
Meer cores op GitHub kosten meer per minuut, dus het verschil groeit met de machine:
| 20.000 minuten per maand | GitHub | Skipbox | Je bespaart per maand |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | $343 |
| 16 vCPU | $822 | $149 (L) | $673 |
De bedragen van GitHub zijn na het inbegrepen gebruik van GitHub Team. Probeer je eigen minuten in de calculator op de startpagina.
Wanneer de oplossing de machine is
De eigen CI-jobs van echte projecten, steps ongewijzigd, op de runner van GitHub voor openbare repository's (4 vCPU, 16 GB) en op een dedicated machine van Skipbox met dezelfde vCPU, uit onze runs van hun workflows:
| Project | GitHub | Skipbox, dedicated machine | Wat de machine bewaarde |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | 30 s | de cache van turbo: 40 buildtaken afgespeeld |
| tauri (Rust) | 246 s | 53 s | target/ van Cargo: geen crate opnieuw gecompileerd |
| ripgrep (Rust) | 200 s | 40 s | target/ van cross en de Docker-image |
| vite (Node.js) | 141 s | 100 s | packagecaches; de rest is het draaien van zijn tests |
ubuntu-latest van een privé-repository heeft de helft van de cores van die GitHub-runs.
Wat Skipbox voor je pipeline doet
Het bewaart de machine. Elk abonnement komt met de dedicated machine van je account, die tussen jobs bewaard blijft. Docker-images, layers en buildcache, packagecaches, de toolcache, en je checkout met target/ van Cargo en de cache van turbo blijven op de schijf: minstens 7× de cacheruimte van GitHub, zonder keys, zonder verloop na 7 dagen en zonder branchregel.
Het voegt cores toe voor een vaste prijs. Een job kiest zijn grootte met zijn label:
| Label | Machine | Abonnement |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 per maand |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 per maand |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 per maand |
De minuten zijn onbeperkt, dus shards, herhaalde runs en een grotere matrix maken de rekening niet hoger. Skipbox-jobs gebruiken geen GitHub-minuten, dus een GitHub-budget houdt ze nooit tegen.
Het zorgt voor zichzelf. Skipbox richt de machine in, houdt de image bijgewerkt, ruimt na elke job op, en bouwt een machine die zijn health check niet haalt opnieuw op.
Overstappen kost één regel
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
- Log in bij Skipbox met GitHub.
- Installeer de GitHub-app van Skipbox en kies de repository's.
- Wijzig
runs-onen push.
Je steps en actions draaien zoals ze zijn, op Ubuntu 24.04 met Docker, Node.js en Python.
Beveiliging
- De machine is alleen van je account. Er draaien geen jobs van een ander bedrijf op.
- Na elke job worden de credentials, processen en containers van de runner gewist, en ook de git-credentials en niet-gevolgde bestanden in de bewaarde checkout. Met Schone VM per job krijgt elke job in plaats daarvan een nieuwe machine.
- Code van mensen zonder schrijfrechten (zoals pull requests vanuit forks) draait op een nieuwe VM die je caches leest maar niet kan wijzigen.
De details staan in zo worden jobs geïsoleerd.
Probeer het op je traagste job
De proefperiode is gratis voor 7 dagen of 3.000 jobminuten, wat het eerst komt, en er is geen kaart voor nodig. Zet de job op je kritieke pad op runs-on: skipbox, draai hem twee keer, en lees de steptijden van de tweede run naast die van GitHub.
Veelgestelde vragen
Onze GitHub Actions-pipeline duurt 25 minuten. Wat is de snelste manier om hem sneller te maken?
Werk hem in volgorde af. Lees de grafiek en de steptijden van de run om de keten van jobs te vinden die de tijd bepaalt, met de wachttijd apart. Annuleer ingehaalde runs en sla jobs over waarvan de bestanden niet zijn veranderd. Schrap needs: die alleen gewoonte uitdrukken, zodat onafhankelijke jobs tegelijk draaien. Bouw niet bij elke job de toestand opnieuw op: caches die echt raak zijn, of een runner die zijn schijf bewaart. Geef CPU-zware steps meer cores en laat de testrunner ze gebruiken. Shard alleen wat nog lang is. Op ubuntu-latest van een privé-repository (2 CPU's, 8 GB) zijn de laatste drie vaak het grootste deel van de 25 minuten, en die horen bij de machine: Skipbox geeft de job een dedicated machine die caches tussen jobs bewaart, met 4 tot 16 vCPU.
Is overstappen op snellere runners de moeite waard vergeleken met de workflow optimaliseren?
Doe eerst de gratis workflowfixes: ingehaalde runs annuleren, padfilters en overbodige needs: schrappen kosten niets, en geen runner doet ze voor je. Kijk daarna waar de resterende tijd heen gaat. Setup die bij elke job terugkomt (toolchains, installaties van dependencies, Docker-builds) en steps die elke core bezighouden, zijn het probleem van de machine, en een runner die zijn caches bewaart en meer cores heeft, haalt ze weg met een wijziging van één runs-on-regel. Wachten op het netwerk en seriële steps worden niet sneller met een grotere machine.
Waarom is GitHub Actions trager dan mijn laptop?
Je laptop houdt zijn packages, tools, Docker-layers en builduitvoer op de schijf, en heeft meestal 8 of meer cores. Een job op ubuntu-latest van een privé-repository krijgt 2 CPU's en 8 GB, op een nieuwe VM die daar niets van heeft. Skipbox werkt zoals je laptop: de machine blijft tussen jobs bestaan, met 4 vCPU of meer.
Maakt het sharden van tests GitHub Actions sneller?
Het verkort de doorlooptijd, niet de minuten. Elke shard is een nieuwe job die opnieuw uitcheckt, installeert en bouwt, dus vier shards betalen de setup vier keer, en facturering per minuut telt ze allemaal. Shard pas als de setup goedkoop is en de cores van de runner in gebruik zijn. Op Skipbox blijft de setup op de schijf en zijn de minuten onbeperkt, dus shards kosten niets extra.
Hoe krijg ik meer dan 4 cores voor een GitHub Actions-job?
Op GitHub komen larger runners in 4 tot 96 cores, alleen voor organisaties op GitHub Team of Enterprise Cloud, gerekend per minuut. Op Skipbox wijzig je runs-on in skipbox-8x16 voor 8 vCPU of skipbox-16x32 voor 16 vCPU, voor een vaste maandprijs, op organisaties en persoonlijke accounts.
Hoeveel kost het om te proberen?
Niets. De proefperiode is 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart. Wijzig de runs-on van je traagste job in skipbox, draai hem twee keer, en vergelijk de steptijden.
Bijgewerkt op 19 november 2026