# Waar 23 seconden heen gingen: een job-VM voor GitHub Actions starten in 7

> Een nieuwe virtuele KVM-machine voor één GitHub Actions-job deed er op de hosts van Skipbox 22,9 s over om bij zijn runner te komen. Nu is dat 7,25 s. Elke seconde en hoe hij is gemeten, van de runner voor een vaste $39 per maand met onbeperkte minuten.

Een nieuwe virtuele machine voor één GitHub Actions-job deed er op een Skipbox-host 22,9 seconden over om van ‘de host heeft de job aangenomen’ naar ‘het runnerproces start’ te komen. Nu is dat 7,25 seconden. Deze post laat zien waar de andere 15 seconden zaten en hoe elk ervan is gemeten.

Skipbox is een GitHub Actions-runner voor een vaste $39 per maand met onbeperkte minuten. Je jobs draaien op de dedicated machine van je account, die tussen jobs bewaard blijft, en de jobs die een nieuwe VM nodig hebben, krijgen er een in 7 seconden. Wijzig één `runs-on`-regel om over te stappen.

- Een nieuwe job-VM bereikt zijn runner in 7,25 s, omlaag van 22,9 s
- Op je dedicated warme machine duren de setupsteps van een job 7 s, tegenover 52 s op `ubuntu-latest` van GitHub
- 20.000 minuten per maand op 4 vCPU: $222 op GitHub, $39 op Skipbox

**GitHub Actions voor een vaste prijs, onbeperkte minuten** Skipbox draait je GitHub Actions-jobs op je eigen dedicated machine: $39 per maand, hoeveel minuten je ook draait. Docker-layers en dependencycaches blijven tussen jobs bewaard, dus de volgende job start meteen.

Een runner met 4 vCPU, 20.000 minuten per maand: GitHub $222 → Skipbox $39. Je bespaart elke maand $183.

Overstappen kost één regel: `runs-on: skipbox`.

[Gratis 7-daagse proefperiode starten](https://app.skipbox.dev/sign-in?ref=blog-github-actions-job-vm-boot-7-seconds-nl)

## Wat er wordt gemeten, en waarop

Een Skipbox-host draait virtuele KVM-machines via Incus op een ZFS-pool. De runnerimage is een gestopte VM met een snapshot. Een job die een nieuwe VM nodig heeft, krijgt een ZFS-clone van die snapshot, start hem op, ontvangt via de guest agent een just-in-timeconfiguratie voor de runner, draait één job, en wordt met zijn schijf verwijderd.

De daemon op de host logt het einde van elke stap van een start in milliseconden vanaf het moment dat hij de job aanneemt (`startMs`: `cloned`, `started`, `agent`). De getallen hieronder komen van een host met een Intel i7-7820X met 16 threads en een VM met 4 vCPU en 8 GB.

| | Van aannemen tot de start van de runner, 3 runs per stuk |
|---|---|
| Voor | 22,9 s (21,7 tot 24,2) |
| Na | 7,25 s (7,1 tot 8,1) |

Waar het heen ging, elk stuk apart gemeten:

| Wijziging | Gemeten | Bespaard |
|---|---|---|
| SeaBIOS in plaats van OVMF | Start van de VM tot het eerste antwoord van de agent, mediaan van 3: 13,7 → 8,4 s | 5,3 s |
| `quiet` op de kernelcommandoregel | 8,4 → 6,5 s | 1,9 s |
| Geen initrd | 6,5 → 5,1 s | 1,4 s |
| Een image die al de grootte van zijn clones heeft | Clone 1,5 → 0,1 s, eerste start 2,35 → 1,8 s | 1,9 s |
| Wachten op de socket van Docker, niet op dockerd | dockerd was 3,6 s na de agent klaar | 3,6 s |
| De guest agent elke 100 ms vragen, niet elke seconde | gemiddeld 0,5 s, tot 1 s | 0,5 s |

De stukken tellen op tot 14,6 s van het totale verschil van 15,65 s.

## Firmware: 5,3 seconden vóór GRUB

Incus start een VM standaard met OVMF en secure boot. Op deze host deed OVMF er 5,3 s over om aan GRUB over te dragen. SeaBIOS doet er 0,5 s over. Twee instance-keys schakelen het om: `security.csm=true` en `security.secureboot=false`.

Dit was het grootste losse stuk, en het enige dat beveiliging raakt, dus hier staat het volledig. Met SeaBIOS wordt de handtekening van de bootketen van de guest niet gecontroleerd. Wat die controle tegenhoudt, is iemand die de bootloader of kernel van de guest vervangt. In een CI-job-VM is die iemand de job, en de job heeft al root in zijn eigen VM: hij kan alles met `sudo`, en de VM en zijn schijf worden verwijderd als de job eindigt. Wat de VM van de ene klant weghoudt van die van een andere, zijn KVM en een firewallketen per VM op de bridge van de host, en geen van beide hangt af van de firmware van de guest. De image start onder beide, en één vlag op de host zet UEFI terug.

## Een stille kernel, en geen initrd

Een job-VM start één keer voor elke job, en niemand leest zijn seriële console. `quiet` bracht de mediaan van 8,4 naar 6,5 s.

De initrd bestaat om de drivers te laden die het rootbestandssysteem vinden. De generieke kernel van Ubuntu heeft virtio-scsi en ext4 ingebouwd, en elke clone deelt de partitie-UUID van de image, dus de kernel mount `/` direct vanaf `root=PARTUUID=…`. Dat was nog eens 1,4 s.

Twee bewakingen zorgen dat het niet stilletjes misgaat. De GRUB van Ubuntu start de volgende keer vanzelf met de initrd als een start zonder initrd in paniek raakte (`GRUB_FORCE_PARTUUID`). Die terugval zou de 1,4 s stilletjes bij elke job terugbrengen, dus de imagebuild start een testclone en faalt als `dmesg` laat zien dat er een initramfs wordt uitgepakt.

## Vergroot geen schijf die je meteen op de goede grootte had kunnen bouwen

De image werd gebouwd op een kleinere schijf, en elke clone werd bij de start vergroot tot de grootte van zijn abonnement. Vergroten kostte 1,9 s per job: de clone duurde 1,5 s in plaats van 0,1 s, en de eerste start 2,35 s in plaats van 1,8 s. De image wordt nu gebouwd op de schijfgrootte van het kleinste abonnement (80 GB). Het volume is thin, dus de image bevat nog steeds alleen wat erop is geschreven. Incus kan een clone niet verkleinen, dus de image is nooit groter dan het kleinste abonnement; grotere abonnementen groeien bij het opstarten.

## De socket van Docker is genoeg

Het runscript wachtte vroeger op `docker.service` voordat het de runner startte. dockerd was 3,6 s na de guest agent klaar. Maar systemd luistert vanaf het begin van het opstarten op de socket van Docker, en een client die verbinding maakt voordat dockerd klaar is, wacht erop. Het script wacht dus alleen op `docker.socket` en DNS, met een begrensde wachttijd, en dockerd start verder terwijl de runner dat doet.

## Pollen op 100 ms

De configuratie van de runner wordt via de guest agent de VM in geduwd, en die is er pas als de guest is opgestart. De host probeerde het één keer per seconde opnieuw, dus een job wachtte gemiddeld 0,5 s nadat de agent er was. Incus weigert een push in 20 ms zolang de agent er niet is, dus elke 100 ms vragen kost niets. Na de eerste 30 s van een VM gaat de host terug naar één keer per seconde.

## Geen bootfix: fsync op een schijf die met de job sterft

Tijdens het meten bleek het traagste in de VM niet het opstarten te zijn. Elke `fsync` in de guest wachtte tot de ZFS van de host zijn intent log had vastgelegd. De schijf van een nieuwe job-VM wordt met de job verwijderd, dus niets erop hoeft een stroomstoring te overleven. Het runscript mount `/` opnieuw met `nobarrier` voordat het de runner start.

Medianen van 3, in een VM met 4 vCPU en 8 GB:

| | Voor | Na |
|---|---|---|
| Willekeurige 4k-writes met fsync | 227 per seconde | 2.505 per seconde |
| `yarn install`, 1 GB node_modules uit zijn cache | 12,92 s | 9,99 s (23% minder) |
| `docker pull node:22` | 19,12 s | 15,45 s (19% minder) |
| Een Docker-build van redis | 92,89 s | 87,21 s |
| `make -j4`, `sysbench cpu` | ongewijzigd | ongewijzigd |

Alleen nieuwe VM's krijgen dit. Je dedicated machine bewaart je caches tussen jobs, en zijn ext4 houdt zijn barriers.

## Dezelfde zoektocht op gehuurde cloudservers

Als de eigen hosts van Skipbox vol zijn, draait een job op een cloudserver die vanaf een snapshotimage opstart. Dat pad had zijn eigen verloren tijd, op een andere plek. Op een gedeelde Intel-server met 4 vCPU startte het jobscript (de user data van de server) 28,1 s na de kernel. cloud-init had het script na 19,3 s en Docker was klaar na 22,2 s, maar cloud-init draait user data in zijn laatste fase, na al het andere.

De image heeft nu een kleine systemd-unit die de user data draait zodra cloud-init die heeft geschreven. Hij leest het script via een file descriptor uit een bestand dat hij al heeft verwijderd, dus de laatste fase van cloud-init vindt niets om een tweede keer te draaien. De image maakt ook één soort SSH-hostsleutel in plaats van drie (2,0 s op het pad waar alles op wacht; niemand logt in op deze servers), en start bij het opstarten geen snapd, apport, rsyslog of een dozijn onderhoudstimers meer.

Met die image start het jobscript op een gedeelde AMD-server met 4 vCPU 8 tot 14 s na de kernel.

## Vastgepinde vCPU's houden de klok van elke host juist

Op een hybride CPU (performance-cores en efficiency-cores, zoals de Core Ultra 7 265F) kan KVM de TSC niet meer vertrouwen. Tijdens een nacht van imagebuilds logde de kernel:

```
tsc: Marking TSC unstable due to KVM discovered backwards TSC
clocksource: Switched to clocksource acpi_pm
```

KVM vergelijkt de TSC als een vCPU naar een andere host-CPU verhuist. Het las op de nieuwe core een lagere waarde, tussen coretypes, en markeerde de TSC als instabiel. De kernel had HPET bij het opstarten al uitgeschakeld ("HPET dysfunctional in PC10"), dus de enige overgebleven klokbron was acpi_pm, die op dit moederbord nauwelijks vooruitging: ongeveer 1 seconde uptime in 30 minuten.

Skipbox lost het op in twee stappen:

1. **Een terugval die werkt.** De package-C-state in het BIOS beperken tot C8 houdt HPET in leven. KVM liet de TSC nog steeds vallen, in ronde 11 van een lus van 20 rondes die onder belasting een VM met 8 vCPU start en stopt, maar de klok ging over op HPET en hield de tijd bij.
2. **Vastpinnen.** KVM doet die controle alleen als een vCPU verhuist. Met elke vCPU vastgepind op één host-CPU draaide dezelfde lus 40 rondes op de TSC zonder nieuwe regel in het log.

De hostdaemon neemt geen job aan tenzij de klokbron `tsc` is en `hpet` beschikbaar is, dus een host die zijn TSC laat vallen, loopt vanzelf leeg en zijn jobs gaan naar andere machines. Elke Skipbox-host pint zijn vCPU's vast.

## De snelste start is de start die je overslaat

Zeven seconden geldt voor de jobs die een nieuwe VM nodig hebben: code van mensen zonder schrijfrechten (zoals pull requests vanuit forks), een job die binnenkomt terwijl je machine bezig is, en accounts die voor elke job een schone VM kiezen. Elke andere job start niets op. Hij draait op de dedicated machine van je account, met de Docker-layers, packagecaches en tools van de vorige job nog op de schijf.

Daar zitten de minuten. Dezelfde workflows op `ubuntu-latest` van GitHub (2 vCPU, wat een privé-repository krijgt) en op een warme Skipbox S (4 vCPU), medianen van warme runs:

| | GitHub `ubuntu-latest` | Skipbox S, warm | |
|---|---|---|---|
| excalidraw: installatie, build en tests | 613 s | 450 s | 27% minder |
| Setupsteps (checkout, Node, terugzetten van de cache) | 52 s | 7 s | |
| Tests | 484 s | 354 s | |
| umami: Docker-build in meerdere fasen | 263 s | 188 s | 29% minder |

De setupsteps zakken van 52 s naar 7 s omdat er geen cachearchief is om te downloaden en uit te pakken: Node staat al in de toolcache en de cache van yarn staat op de schijf. De Docker-build gebruikt de eigen layercache van de daemon, zonder iets te exporteren of te importeren. Op Skipbox heeft de workflow helemaal geen cachestep.

## Waarom een vaste prijs een machine warm kan houden

Een machine die niets doet, lijkt verspilling. Met de manier waarop rekenkracht wordt gefactureerd, is het de goedkopere keuze, en dat maakt een vaste prijs mogelijk.

Een gehuurde cloudserver wordt voor elk uur dat hij start volledig gerekend. Een job van 3 minuten op een eigen server betaalt voor 60 minuten. Op één dag van onze eigen CI draaiden 44 jobs van gemiddeld 2,5 minuten op 44 servers, en werden 44 serveruren gerekend. Dezelfde dag opnieuw afgespeeld, met elke server bewaard voor de volgende job van het account binnen zijn uur, geeft 13 tot 14 serveruren: ongeveer 70% minder. En een maand heeft 730 uur: een account dat meer dan 730 korte jobs per maand draait op servers per job, betaalt voor meer uren dan een machine die nooit stopt.

Dus de machine die voor jou het snelst is (caches op de schijf, niets op te starten), is ook de machine die het minst kost om te draaien. Hosts die van Skipbox zelf zijn, komen eerst, omdat ze helemaal geen uurtarief hebben, en gehuurde servers vangen de overloop op. Daarom rekent Skipbox voor de machine, niet voor de minuut:

| Minuten per maand (4 vCPU) | GitHub | Skipbox S | Je bespaart elke maand |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Altijd aan | $500,40 | $39 | **$461,40** |

Bij volledig gebruik is dat 1/12 van de prijs van GitHub. De bedragen van GitHub zijn de rekening na de inbegrepen rekentijd van GitHub Team. Vul je eigen minuten in bij de [calculator op de startpagina](https://skipbox.dev/?ref=blog-github-actions-job-vm-boot-7-seconds-nl#cost); inloggen is niet nodig.

## Overstappen kost één regel

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
```

1. Log in bij Skipbox met GitHub.
2. Installeer de GitHub-app van Skipbox en kies de repository's.
3. Wijzig `runs-on` en push.

## Probeer het

De proefperiode vraagt geen kaart: 7 dagen of 3.000 jobminuten, wat het eerst komt. Wijs je traagste workflow naar `runs-on: skipbox`, draai hem twee keer, en vergelijk de steptijden van de tweede run.

## Veelgestelde vragen

### Hoe lang duurt het voordat een nieuwe VM voor een GitHub Actions-job op Skipbox is gestart?

Op de eigen hosts van Skipbox 7,25 seconden vanaf het moment dat de host de job aanneemt tot het runnerproces start, omlaag van 22,9 seconden. De meeste jobs starten niets op: ze draaien op de dedicated machine van je account, die tussen jobs bewaard blijft.

### Is het veilig om CI-job-VM's op te starten met SeaBIOS in plaats van UEFI secure boot?

Voor een job-VM wel. Secure boot beschermt de bootketen van de guest tegen vervanging, en een CI-job heeft al root in zijn eigen VM, die na de job wordt verwijderd. Op Skipbox worden VM's gescheiden gehouden door KVM en een firewall per VM op de host, en geen van beide hangt af van de firmware van de guest.

### Waarom is fsync traag in een VM op ZFS, en hoe los je dat op voor CI?

Elke fsync in de guest wacht tot de ZFS van de host zijn intent log heeft vastgelegd. De schijf van een nieuwe job-VM wordt met de job verwijderd, dus Skipbox mount zijn ext4 zonder barriers: yarn install is 23% sneller en docker pull 19% sneller. Een machine die tussen jobs bewaard blijft, houdt zijn barriers.

### Waarom markeert KVM de TSC als instabiel op een hybride CPU?

KVM vergelijkt de TSC als een vCPU naar een andere host-CPU verhuist, en tussen performance- en efficiency-cores kan het een lagere waarde lezen. Elke vCPU vastpinnen op één host-CPU zorgt dat die controle niet draait: de start-en-stoplus van Skipbox hield de TSC daarna 40 rondes vast.

### Hoe draai ik mijn jobs op Skipbox?

Wijzig runs-on in een workflow in skipbox. De proefperiode vraagt geen kaart: 7 dagen of 3.000 jobminuten, wat het eerst komt.

Bijgewerkt op 2026-11-19 · https://skipbox.dev/nl/blog/github-actions-job-vm-boot-7-seconds
