# Wohin 23 Sekunden gingen: eine VM für einen GitHub-Actions-Job in 7 starten

> Eine frische KVM-VM für einen GitHub-Actions-Job brauchte auf den Hosts von Skipbox 22,9 s, bis sie ihren Runner erreichte. Jetzt sind es 7,25 s. Jede Sekunde und wie sie gemessen wurde, vom Runner zum Festpreis von $39 im Monat mit unbegrenzten Minuten.

Eine frische virtuelle Maschine für einen GitHub-Actions-Job brauchte auf einem Skipbox-Host 22,9 Sekunden von „der Host hat den Job angenommen“ bis „der Runner-Prozess startet“. Jetzt sind es 7,25 Sekunden. Dieser Beitrag zeigt, wo die anderen 15 Sekunden steckten und wie jede gemessen wurde.

Skipbox ist ein GitHub-Actions-Runner zum Festpreis von $39 im Monat mit unbegrenzten Minuten. Deine Jobs laufen auf der dedizierten Maschine deines Kontos, die zwischen den Jobs erhalten bleibt, und die Jobs, die eine frische VM brauchen, bekommen eine in 7 Sekunden. Ändere eine `runs-on`-Zeile, um umzuziehen.

- Eine frische Job-VM erreicht ihren Runner in 7,25 s, früher 22,9 s
- Auf deiner dedizierten warmen Maschine dauern die Setup-Steps eines Jobs 7 s, gegenüber 52 s auf `ubuntu-latest` von GitHub
- 20.000 Minuten im Monat auf 4 vCPU: $222 bei GitHub, $39 bei Skipbox

**GitHub Actions zum Festpreis, unbegrenzte Minuten** Skipbox führt deine GitHub-Actions-Jobs auf deiner eigenen dedizierten Maschine aus: $39 im Monat, egal wie viele Minuten du nutzt. Docker-Layer und Caches für Abhängigkeiten bleiben zwischen den Jobs erhalten, sodass der nächste Job sofort startet.

Ein Runner mit 4 vCPU, 20.000 Minuten im Monat: GitHub $222 → Skipbox $39. Du sparst jeden Monat $183.

Der Wechsel braucht eine Zeile: `runs-on: skipbox`.

[7-tägige Testphase kostenlos starten](https://app.skipbox.dev/sign-in?ref=blog-github-actions-job-vm-boot-7-seconds-de)

## Was gemessen wird, und worauf

Ein Skipbox-Host betreibt virtuelle KVM-Maschinen über Incus auf einem ZFS-Pool. Das Runner-Image ist eine gestoppte VM mit einem Snapshot. Ein Job, der eine frische VM braucht, bekommt einen ZFS-Klon dieses Snapshots, bootet ihn, erhält über den Gast-Agenten eine Just-in-time-Konfiguration für den Runner, führt einen Job aus und wird mitsamt seiner Festplatte gelöscht.

Der Host-Daemon protokolliert das Ende jedes Schritts eines Starts in Millisekunden ab dem Moment, in dem er den Job annimmt (`startMs`: `cloned`, `started`, `agent`). Die Zahlen unten stammen von einem Host mit einem Intel i7-7820X mit 16 Threads und einer VM mit 4 vCPU und 8 GB.

| | Annahme bis Start des Runners, je 3 Läufe |
|---|---|
| Vorher | 22,9 s (21,7 bis 24,2) |
| Nachher | 7,25 s (7,1 bis 8,1) |

Wohin sie gingen, jedes Stück einzeln gemessen:

| Änderung | Gemessen | Gespart |
|---|---|---|
| SeaBIOS statt OVMF | VM-Start bis zur ersten Antwort des Agenten, Median aus 3: 13,7 → 8,4 s | 5,3 s |
| `quiet` in der Kernel-Kommandozeile | 8,4 → 6,5 s | 1,9 s |
| Keine initrd | 6,5 → 5,1 s | 1,4 s |
| Ein Image, das schon so groß ist wie seine Klone | Klon 1,5 → 0,1 s, erster Start 2,35 → 1,8 s | 1,9 s |
| Auf den Socket von Docker warten, nicht auf dockerd | dockerd war 3,6 s nach dem Agenten bereit | 3,6 s |
| Den Gast-Agenten alle 100 ms fragen, nicht jede Sekunde | Im Schnitt 0,5 s, bis zu 1 s | 0,5 s |

Die Stücke ergeben zusammen 14,6 s der 15,65 s Unterschied von Ende zu Ende.

## Firmware: 5,3 Sekunden vor GRUB

Incus bootet eine VM standardmäßig mit OVMF und Secure Boot. Auf diesem Host brauchte OVMF 5,3 s bis zur Übergabe an GRUB. SeaBIOS braucht 0,5 s. Zwei Instanz-Keys schalten um: `security.csm=true` und `security.secureboot=false`.

Das war das größte einzelne Stück und das einzige, das die Sicherheit berührt, also hier vollständig. Mit SeaBIOS wird die Signatur der Boot-Kette des Gastes nicht geprüft. Diese Prüfung schützt davor, dass jemand den Bootloader oder Kernel des Gastes ersetzt. In einer CI-Job-VM ist dieser Jemand der Job, und der Job hat in seiner eigenen VM ohnehin Root-Rechte: Er kann alles per `sudo` ausführen, und die VM und ihre Festplatte werden gelöscht, wenn der Job endet. Was die VM eines Kunden von der eines anderen fernhält, sind KVM und eine Firewall-Kette pro VM auf der Bridge des Hosts, und beides hängt nicht von der Firmware des Gastes ab. Das Image bootet mit beiden, und ein Flag auf dem Host bringt UEFI zurück.

## Ein stiller Kernel und keine initrd

Eine Job-VM bootet einmal für jeden Job, und niemand liest ihre serielle Konsole. `quiet` senkte den Median von 8,4 auf 6,5 s.

Die initrd gibt es, um die Treiber zu laden, die das Root-Dateisystem finden. Der generische Kernel von Ubuntu hat virtio-scsi und ext4 fest eingebaut, und jeder Klon teilt sich die Partitions-UUID des Images, also hängt der Kernel `/` direkt über `root=PARTUUID=…` ein. Das waren weitere 1,4 s.

Zwei Schutzmaßnahmen verhindern, dass das unbemerkt schiefgeht. Das GRUB von Ubuntu bootet beim nächsten Mal von selbst mit der initrd, wenn ein Boot ohne sie eine Panic ausgelöst hat (`GRUB_FORCE_PARTUUID`). Dieser Rückfall würde die 1,4 s unbemerkt in jeden Job zurückbringen, also bootet der Image-Build einen Testklon und schlägt fehl, wenn `dmesg` zeigt, dass ein initramfs entpackt wird.

## Keine Festplatte vergrößern, die du gleich in der richtigen Größe hättest bauen können

Das Image wurde auf einer kleineren Festplatte gebaut, und jeder Klon wurde beim Start auf die Größe seines Tarifs vergrößert. Das Vergrößern kostete 1,9 s pro Job: Der Klon dauerte 1,5 s statt 0,1 s und der erste Start 2,35 s statt 1,8 s. Jetzt wird das Image in der Festplattengröße des kleinsten Tarifs gebaut (80 GB). Das Volume ist thin provisioned, also enthält das Image weiterhin nur, was darauf geschrieben wurde. Incus kann einen Klon nicht verkleinern, also ist das Image nie größer als der kleinste Tarif; größere Tarife wachsen beim Booten.

## Der Socket von Docker genügt

Das Startskript wartete früher auf `docker.service`, bevor es den Runner startete. dockerd war 3,6 s nach dem Gast-Agenten bereit. Aber systemd lauscht schon ab dem frühen Boot auf dem Socket von Docker, und ein Client, der sich verbindet, bevor dockerd bereit ist, wartet darauf. Also wartet das Skript nur auf `docker.socket` und DNS, mit begrenzter Wartezeit, und dockerd startet fertig, während der Runner startet.

## Abfragen alle 100 ms

Die Konfiguration des Runners wird über den Gast-Agenten in die VM geschoben, und der ist erst da, wenn der Gast gebootet hat. Der Host versuchte es einmal pro Sekunde erneut, also wartete ein Job im Schnitt 0,5 s, nachdem der Agent bereit war. Incus lehnt einen Push in 20 ms ab, solange der Agent nicht läuft, also kostet die Abfrage alle 100 ms nichts. Nach den ersten 30 s einer VM geht der Host zurück auf einmal pro Sekunde.

## Kein Boot-Fix: fsync auf einer Festplatte, die mit dem Job stirbt

Beim Messen stellte sich heraus, dass das Langsamste in der VM gar nicht der Boot war. Jedes `fsync` im Gast wartete darauf, dass das ZFS des Hosts sein Intent-Log schreibt. Die Festplatte einer frischen Job-VM wird mit dem Job gelöscht, also muss nichts darauf einen Stromausfall überstehen. Das Startskript hängt `/` mit `nobarrier` neu ein, bevor es den Runner startet.

Mediane aus 3, in einer VM mit 4 vCPU und 8 GB:

| | Vorher | Nachher |
|---|---|---|
| 4k-Zufallsschreibvorgänge mit fsync | 227 pro Sekunde | 2.505 pro Sekunde |
| `yarn install`, 1 GB node_modules aus seinem Cache | 12,92 s | 9,99 s (23 % weniger) |
| `docker pull node:22` | 19,12 s | 15,45 s (19 % weniger) |
| Ein Docker-Build von redis | 92,89 s | 87,21 s |
| `make -j4`, `sysbench cpu` | unverändert | unverändert |

Das bekommen nur frische VMs. Deine dedizierte Maschine hält deine Caches zwischen den Jobs, und ihr ext4 behält seine Barriers.

## Dieselbe Suche auf gemieteten Cloud-Servern

Wenn die eigenen Hosts von Skipbox voll sind, läuft ein Job auf einem Cloud-Server, der von einem Snapshot-Image bootet. Dieser Weg hatte seine eigene verlorene Zeit, an einer anderen Stelle. Auf einem geteilten Intel-Server mit 4 vCPU startete das Job-Skript (die User Data des Servers) 28,1 s nach dem Kernel. cloud-init hatte das Skript bei 19,3 s, und Docker war bei 22,2 s bereit, aber cloud-init führt die User Data in seiner letzten Stufe aus, nach allem anderen.

Das Image hat jetzt eine kleine systemd-Unit, die die User Data ausführt, sobald cloud-init sie geschrieben hat. Sie liest das Skript über einen File Descriptor aus einer Datei, die sie schon entfernt hat, also findet die letzte Stufe von cloud-init nichts, was sie ein zweites Mal ausführen könnte. Das Image erzeugt außerdem nur eine Art SSH-Host-Key statt drei (2,0 s auf dem Pfad, auf den alles wartet; niemand meldet sich an diesen Servern an) und startet beim Booten weder snapd, apport, rsyslog noch ein Dutzend Wartungs-Timer.

Mit diesem Image startet das Job-Skript auf einem geteilten AMD-Server mit 4 vCPU 8 bis 14 s nach dem Kernel.

## Gepinnte vCPUs halten die Uhr jedes Hosts richtig

Auf einer hybriden CPU (Performance-Kerne und Effizienzkerne, etwa der Core Ultra 7 265F) kann KVM dem TSC nicht mehr trauen. Während einer Nacht voller Image-Builds protokollierte der Kernel:

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

KVM vergleicht den TSC, wenn eine vCPU auf eine andere Host-CPU wechselt. Es las auf dem neuen Kern einen niedrigeren Wert, über Kerntypen hinweg, und markierte den TSC als instabil. Der Kernel hatte HPET schon beim Booten abgeschaltet („HPET dysfunctional in PC10“), also war die einzige verbleibende Zeitquelle acpi_pm, die auf diesem Board kaum vorankam: etwa 1 Sekunde Uptime in 30 Minuten.

Skipbox löst das in zwei Schritten:

1. **Ein Rückfall, der funktioniert.** Den Package-C-State im BIOS auf C8 zu begrenzen hält HPET am Leben. KVM verwarf den TSC trotzdem, in Runde 11 einer Schleife mit 20 Runden, die eine VM mit 8 vCPU unter Last startet und stoppt, aber die Uhr wechselte zu HPET und ging richtig.
2. **Pinning.** KVM führt diese Prüfung nur aus, wenn eine vCPU wechselt. Mit jeder vCPU an eine Host-CPU gepinnt lief dieselbe Schleife 40 Runden auf dem TSC ohne neue Zeile im Log.

Der Host-Daemon nimmt keinen Job an, solange die Zeitquelle nicht `tsc` ist und `hpet` verfügbar ist, also leert sich ein Host, der seinen TSC verliert, von selbst, und seine Jobs gehen an andere Maschinen. Jeder Skipbox-Host pinnt seine vCPUs.

## Der schnellste Boot ist der, den du überspringst

Sieben Sekunden gelten für die Jobs, die eine frische VM brauchen: Code von Personen ohne Schreibzugriff (etwa Pull Requests aus Forks), ein Job, der ankommt, während deine Maschine beschäftigt ist, und Konten, die eine saubere VM für jeden Job wählen. Jeder andere Job bootet gar nichts. Er läuft auf der dedizierten Maschine deines Kontos, mit den Docker-Layern, Paket-Caches und Tools des letzten Jobs noch auf ihrer Festplatte.

Dort stecken die Minuten. Dieselben Workflows auf `ubuntu-latest` von GitHub (2 vCPU, was ein privates Repository bekommt) und auf einem warmen Skipbox S (4 vCPU), Mediane warmer Läufe:

| | GitHub `ubuntu-latest` | Skipbox S, warm | |
|---|---|---|---|
| excalidraw: Installation, Build und Tests | 613 s | 450 s | 27 % weniger |
| Setup-Steps (Checkout, Node, Cache-Wiederherstellung) | 52 s | 7 s | |
| Tests | 484 s | 354 s | |
| umami: mehrstufiger Docker-Build | 263 s | 188 s | 29 % weniger |

Die Setup-Steps fallen von 52 s auf 7 s, weil es kein Cache-Archiv herunterzuladen und zu entpacken gibt: Node liegt schon im Tool-Cache, und der Cache von yarn liegt auf der Festplatte. Der Docker-Build nutzt den eigenen Layer-Cache des Daemons, ohne dass etwas exportiert oder importiert wird. Auf Skipbox hat der Workflow gar keinen Cache-Step.

## Warum ein Festpreis eine Maschine warm halten kann

Eine untätige Maschine sieht nach Verschwendung aus. So, wie Rechenleistung abgerechnet wird, ist sie die günstigere Wahl, und genau das macht einen Festpreis möglich.

Ein gemieteter Cloud-Server wird für jede Stunde, die er startet, voll berechnet. Ein 3-Minuten-Job auf einem eigenen Server bezahlt 60 Minuten. An einem Tag unserer eigenen CI liefen 44 Jobs mit durchschnittlich 2,5 Minuten auf 44 Servern und wurden mit 44 Server-Stunden berechnet. Spielt man denselben Tag nach, wobei jeder Server innerhalb seiner Stunde für den nächsten Job des Kontos behalten wird, ergeben sich 13 bis 14 Server-Stunden: etwa 70 % weniger. Und ein Monat hat 730 Stunden: Ein Konto, das mehr als 730 kurze Jobs im Monat auf Servern pro Job ausführt, bezahlt mehr Stunden als eine Maschine, die nie stoppt.

Die Maschine, die für dich am schnellsten ist (Caches auf der Festplatte, nichts zu booten), ist also auch die, die am wenigsten im Betrieb kostet. Hosts, die Skipbox gehören, kommen zuerst, weil sie überhaupt keine Stundenrechnung haben, und gemietete Server nehmen den Überlauf. Deshalb berechnet Skipbox die Maschine, nicht die Minute:

| Minuten im Monat (4 vCPU) | GitHub | Skipbox S | Du sparst jeden Monat |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Dauerbetrieb | $500,40 | $39 | **$461,40** |

Bei voller Auslastung ist das 1/12 des Preises von GitHub. Die GitHub-Werte sind die Rechnung nach Abzug der in GitHub Team enthaltenen Rechenzeit. Trag deine eigenen Minuten in den [Rechner auf der Startseite](https://skipbox.dev/?ref=blog-github-actions-job-vm-boot-7-seconds-de#cost) ein; er braucht keine Anmeldung.

## Der Wechsel ist eine Zeile

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

1. Melde dich bei Skipbox mit GitHub an.
2. Installiere die GitHub-App von Skipbox und wähle die Repositorys.
3. Ändere `runs-on` und pushe.

## Probier es aus

Die Testphase braucht keine Karte: 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist. Richte deinen langsamsten Workflow auf `runs-on: skipbox`, führe ihn zweimal aus und vergleich die Step-Zeiten des zweiten Laufs.

## FAQ

### Wie lange braucht eine frische VM für einen GitHub-Actions-Job auf Skipbox zum Starten?

Auf den eigenen Hosts von Skipbox 7,25 Sekunden, von der Annahme des Jobs durch den Host bis zum Start des Runner-Prozesses, früher 22,9 Sekunden. Die meisten Jobs booten gar nichts: Sie laufen auf der dedizierten Maschine deines Kontos, die zwischen den Jobs erhalten bleibt.

### Ist es sicher, CI-Job-VMs mit SeaBIOS statt UEFI Secure Boot zu booten?

Für eine Job-VM ja. Secure Boot schützt die Boot-Kette des Gastes davor, ersetzt zu werden, und ein CI-Job hat in seiner eigenen VM ohnehin Root-Rechte, und die VM wird nach dem Job gelöscht. Auf Skipbox werden VMs durch KVM und eine Firewall pro VM auf dem Host getrennt, und beides hängt nicht von der Firmware des Gastes ab.

### Warum ist fsync in einer VM auf ZFS langsam, und wie behebt man das für CI?

Jedes fsync im Gast wartet darauf, dass das ZFS des Hosts sein Intent-Log schreibt. Die Festplatte einer frischen Job-VM wird mit dem Job gelöscht, also hängt Skipbox ihr ext4 ohne Barriers ein: yarn install ist 23 % schneller und docker pull 19 % schneller. Eine Maschine, die zwischen den Jobs erhalten bleibt, behält ihre Barriers.

### Warum markiert KVM den TSC auf einer hybriden CPU als instabil?

KVM vergleicht den TSC, wenn eine vCPU auf eine andere Host-CPU wechselt, und zwischen Performance- und Effizienzkernen kann es einen niedrigeren Wert lesen. Jede vCPU an eine Host-CPU zu pinnen verhindert, dass die Prüfung läuft: Die Start-und-Stopp-Schleife von Skipbox hielt den TSC danach 40 Runden lang.

### Wie führe ich meine Jobs auf Skipbox aus?

Ändere runs-on in einem Workflow auf skipbox. Die Testphase braucht keine Karte: 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist.

Aktualisiert am 2026-11-19 · https://skipbox.dev/de/blog/github-actions-job-vm-boot-7-seconds
