# Unde s-au dus 23 de secunde: pornirea VM-ului unui job GitHub Actions în 7

> O mașină virtuală KVM nouă pentru un job GitHub Actions avea nevoie de 22,9 s ca să ajungă la runner pe hosturile Skipbox. Acum are nevoie de 7,25 s. Fiecare secundă și cum a fost măsurată, de la runnerul cu preț fix de $39 pe lună și minute nelimitate.

O mașină virtuală nouă pentru un job GitHub Actions avea nevoie de 22,9 secunde pe un host Skipbox ca să ajungă de la „hostul a acceptat jobul” la „pornește procesul runnerului”. Acum are nevoie de 7,25 secunde. Articolul acesta arată unde erau celelalte 15 secunde și cum a fost măsurată fiecare.

Skipbox este un runner GitHub Actions la un preț fix de $39 pe lună, cu minute nelimitate. Joburile tale rulează pe mașina dedicată a contului tău, păstrată între joburi, iar joburile care au nevoie de un VM nou îl primesc în 7 secunde. Schimbi o singură linie `runs-on` ca să te muți.

- Un VM nou de job ajunge la runner în 7,25 s, față de 22,9 s înainte
- Pe mașina ta dedicată, deja pregătită, pașii de setup ai unui job durează 7 s, față de 52 s pe `ubuntu-latest` de la GitHub
- 20.000 de minute pe lună pe 4 vCPU: $222 pe GitHub, $39 pe Skipbox

**GitHub Actions la preț fix, cu minute nelimitate** Skipbox rulează joburile tale GitHub Actions pe propria ta mașină dedicată: $39 pe lună, oricâte minute ai rula. Layerele Docker și cache-urile de dependențe rămân între joburi, așa că jobul următor pornește imediat.

Un runner de 4 vCPU, 20.000 de minute pe lună: GitHub $222 → Skipbox $39. Economisești $183 în fiecare lună.

E nevoie de o singură linie: `runs-on: skipbox`.

[Încearcă gratuit 7 zile](https://app.skipbox.dev/sign-in?ref=blog-github-actions-job-vm-boot-7-seconds-ro)

## Ce se cronometrează și pe ce

Un host Skipbox rulează mașini virtuale KVM prin Incus, pe un pool ZFS. Imaginea runnerului e un VM oprit, cu un snapshot. Un job care are nevoie de un VM nou primește o clonă ZFS a acelui snapshot, o pornește, primește prin guest agent o configurație de runner just-in-time, rulează un singur job și e șters împreună cu discul.

Daemonul hostului înregistrează sfârșitul fiecărui pas al unei porniri, în milisecunde de la momentul în care acceptă jobul (`startMs`: `cloned`, `started`, `agent`). Cifrele de mai jos sunt de pe un host Intel i7-7820X cu 16 fire de execuție și un VM de 4 vCPU și 8 GB.

| | De la acceptare la pornirea runnerului, câte 3 rulări |
|---|---|
| Înainte | 22,9 s (între 21,7 și 24,2) |
| După | 7,25 s (între 7,1 și 8,1) |

Unde s-au dus, fiecare bucată măsurată separat:

| Schimbarea | Măsurat | Economisit |
|---|---|---|
| SeaBIOS în loc de OVMF | De la pornirea VM-ului la primul răspuns al agentului, mediana a 3: 13,7 → 8,4 s | 5,3 s |
| `quiet` în linia de comandă a kernelului | 8,4 → 6,5 s | 1,9 s |
| Fără initrd | 6,5 → 5,1 s | 1,4 s |
| O imagine care are deja mărimea clonelor ei | Clona 1,5 → 0,1 s, prima pornire 2,35 → 1,8 s | 1,9 s |
| Așteptarea socketului Docker, nu a dockerd | dockerd pornea la 3,6 s după agent | 3,6 s |
| Interogarea guest agentului la 100 ms, nu la o secundă | 0,5 s în medie, până la 1 s | 0,5 s |

Bucățile adunate dau 14,6 s din cele 15,65 s de diferență totală.

## Firmware-ul: 5,3 secunde înainte de GRUB

Incus pornește implicit un VM cu OVMF și secure boot. Pe acest host, OVMF avea nevoie de 5,3 s ca să predea controlul lui GRUB. SeaBIOS are nevoie de 0,5 s. Două chei ale instanței fac schimbarea: `security.csm=true` și `security.secureboot=false`.

Asta a fost cea mai mare bucată și singura care atinge securitatea, așa că iată-o pe larg. Cu SeaBIOS, lanțul de boot al guestului nu e verificat prin semnătură. Verificarea aceea protejează împotriva cuiva care înlocuiește bootloaderul sau kernelul guestului. Într-un VM de job de CI, acel cineva e jobul, iar jobul are deja root în propriul VM: poate rula orice cu `sudo`, iar VM-ul și discul lui sunt șterse când se termină jobul. Ce ține VM-ul unui client departe de al altuia e KVM și un lanț de firewall per VM pe bridge-ul hostului, iar niciunul nu depinde de firmware-ul guestului. Imaginea pornește sub ambele, iar un singur flag pe host readuce UEFI.

## Un kernel tăcut și fără initrd

Un VM de job pornește o dată pentru fiecare job și nimeni nu îi citește consola serială. `quiet` a coborât mediana de la 8,4 la 6,5 s.

Initrd-ul există ca să încarce driverele care găsesc sistemul de fișiere rădăcină. Kernelul generic Ubuntu are virtio-scsi și ext4 incluse, iar fiecare clonă împarte UUID-ul de partiție al imaginii, așa că kernelul montează `/` direct din `root=PARTUUID=…`. Asta a însemnat încă 1,4 s.

Două protecții împiedică o greșeală să treacă neobservată. GRUB-ul Ubuntu pornește singur data următoare cu initrd dacă o pornire fără el a dat panic (`GRUB_FORCE_PARTUUID`). Acel fallback ar aduce înapoi pe tăcute cele 1,4 s la fiecare job, așa că buildul imaginii pornește o clonă de test și eșuează dacă `dmesg` arată că se dezarhivează un initramfs.

## Nu redimensiona un disc pe care l-ai fi putut construi la mărimea potrivită

Imaginea era construită pe un disc mai mic, iar fiecare clonă era mărită la pornire la mărimea planului ei. Mărirea costa 1,9 s pe job: clona dura 1,5 s în loc de 0,1 s, iar prima pornire 2,35 s în loc de 1,8 s. Acum imaginea e construită la mărimea discului celui mai mic plan (80 GB). Volumul e thin, așa că imaginea conține în continuare doar ce s-a scris în ea. Incus nu poate micșora o clonă, așa că imaginea nu e niciodată mai mare decât cel mai mic plan; planurile mai mari cresc la pornire.

## Socketul Docker e de ajuns

Scriptul de rulare aștepta înainte `docker.service` înainte să pornească runnerul. dockerd pornea la 3,6 s după guest agent. Dar systemd ascultă pe socketul Docker de la începutul pornirii, iar un client care se conectează înainte să pornească dockerd îl așteaptă. Așa că scriptul așteaptă doar `docker.socket` și DNS-ul, cu o așteptare limitată, iar dockerd termină de pornit în timp ce pornește runnerul.

## Interogare la 100 ms

Configurația runnerului e trimisă în VM prin guest agent, care nu există până nu a pornit guestul. Hostul reîncerca o dată pe secundă, așa că un job aștepta în medie 0,5 s după ce apărea agentul. Incus refuză o trimitere în 20 ms cât timp agentul nu e pornit, așa că o interogare la fiecare 100 ms nu costă nimic. După primele 30 s ale unui VM, hostul revine la o dată pe secundă.

## Nu e o corectură de boot: fsync pe un disc care moare odată cu jobul

În timpul măsurătorilor, cel mai lent lucru din VM s-a dovedit a nu fi bootul. Fiecare `fsync` din guest aștepta ca ZFS-ul hostului să își confirme intent logul. Discul unui VM de job nou e șters odată cu jobul, așa că nimic de pe el nu trebuie să supraviețuiască unei căderi de curent. Scriptul de rulare remontează `/` cu `nobarrier` înainte să pornească runnerul.

Mediane din 3, într-un VM de 4 vCPU și 8 GB:

| | Înainte | După |
|---|---|---|
| Scrieri aleatorii de 4k cu fsync | 227 pe secundă | 2.505 pe secundă |
| `yarn install`, 1 GB de node_modules din cache-ul lui | 12,92 s | 9,99 s (cu 23% mai puțin) |
| `docker pull node:22` | 19,12 s | 15,45 s (cu 19% mai puțin) |
| Un build Docker al redis | 92,89 s | 87,21 s |
| `make -j4`, `sysbench cpu` | neschimbat | neschimbat |

Doar VM-urile noi primesc asta. Mașina ta dedicată îți ține cache-urile între joburi, iar ext4-ul ei își păstrează barriers.

## Aceeași vânătoare pe servere cloud închiriate

Când hosturile proprii Skipbox sunt pline, un job rulează pe un server cloud pornit dintr-o imagine snapshot. Pe acea cale exista propriul timp pierdut, în alt loc. Pe un server partajat Intel de 4 vCPU, scriptul jobului (user data al serverului) pornea la 28,1 s după kernel. cloud-init avea scriptul la 19,3 s, iar Docker era pornit la 22,2 s, dar cloud-init rulează user data în ultima etapă, după toate celelalte.

Imaginea are acum o mică unitate systemd care rulează user data imediat ce cloud-init l-a scris. Citește scriptul printr-un file descriptor dintr-un fișier pe care l-a șters deja, așa că ultima etapă a cloud-init nu găsește nimic de rulat a doua oară. Imaginea mai generează și un singur tip de cheie SSH de host în loc de trei (2,0 s pe calea pe care o așteaptă totul; nimeni nu se conectează la aceste servere) și nu mai pornește la boot snapd, apport, rsyslog sau o duzină de timere de întreținere.

Cu acea imagine, pe un server partajat AMD de 4 vCPU, scriptul jobului pornește la 8 până la 14 s după kernel.

## vCPU-urile fixate țin corect ceasul fiecărui host

Pe un CPU hibrid (nuclee de performanță și nuclee eficiente, cum e Core Ultra 7 265F), KVM poate înceta să aibă încredere în TSC. Într-o noapte de builduri de imagini, kernelul a scris în log:

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

KVM compară TSC-ul când un vCPU trece pe alt CPU al hostului. A citit o valoare mai mică pe noul nucleu, între tipuri de nuclee, și a marcat TSC-ul ca instabil. Kernelul dezactivase deja HPET la pornire („HPET dysfunctional in PC10”), așa că singura sursă de ceas rămasă era acpi_pm, care pe această placă abia înainta: cam 1 secundă de uptime în 30 de minute.

Skipbox o rezolvă în doi pași:

1. **Un fallback care funcționează.** Limitarea C-state-ului pachetului la C8 din BIOS ține HPET în viață. KVM tot a renunțat la TSC, în runda 11 a unei bucle de 20 de runde care pornește și oprește un VM de 8 vCPU sub sarcină, dar ceasul a trecut pe HPET și a ținut timpul corect.
2. **Fixarea.** KVM face acea verificare doar când un vCPU se mută. Cu fiecare vCPU fixat pe un singur CPU al hostului, aceeași buclă a rulat 40 de runde pe TSC, fără nicio linie nouă în log.

Daemonul hostului nu acceptă niciun job dacă sursa de ceas nu e `tsc` și `hpet` nu e disponibil, așa că un host care își pierde TSC-ul se golește singur, iar joburile lui merg pe alte mașini. Fiecare host Skipbox își fixează vCPU-urile.

## Cel mai rapid boot e cel pe care îl sari

Cele șapte secunde sunt pentru joburile care au nevoie de un VM nou: codul de la persoane fără acces de scriere (cum ar fi pull request-urile din forkuri), un job care sosește cât timp mașina ta e ocupată și conturile care aleg un VM curat pentru fiecare job. Orice alt job nu pornește nimic. Rulează pe mașina dedicată a contului tău, cu layerele Docker, cache-urile de pachete și instrumentele jobului anterior încă pe disc.

Acolo sunt minutele. Aceleași workflow-uri pe `ubuntu-latest` de la GitHub (2 vCPU, cât primește un repository privat) și pe un Skipbox S deja pregătit (4 vCPU), mediane ale rulărilor cu cache:

| | GitHub `ubuntu-latest` | Skipbox S, pregătit | |
|---|---|---|---|
| excalidraw: instalare, build și teste | 613 s | 450 s | cu 27% mai puțin |
| Pașii de setup (checkout, Node, restaurarea cache-ului) | 52 s | 7 s | |
| Teste | 484 s | 354 s | |
| umami: build Docker multi-stage | 263 s | 188 s | cu 29% mai puțin |

Pașii de setup coboară de la 52 s la 7 s pentru că nu există nicio arhivă de cache de descărcat și dezarhivat: Node e deja în tool cache, iar cache-ul yarn e pe disc. Buildul Docker folosește cache-ul de layere al propriului daemon, fără nimic exportat sau importat. Pe Skipbox, workflow-ul nu are niciun pas de cache.

## De ce un preț fix poate ține o mașină pregătită

O mașină nefolosită pare risipă. Așa cum se facturează calculul, ea e alegerea mai ieftină, iar asta face ca un preț fix să funcționeze.

Un server cloud închiriat se facturează pentru fiecare oră în care pornește, integral. Un job de 3 minute pe propriul server plătește 60 de minute. Într-o zi din propriul nostru CI, 44 de joburi de 2,5 minute în medie au rulat pe 44 de servere și au fost facturate 44 de ore-server. Reluând aceeași zi cu fiecare server păstrat pentru următorul job al contului în ora lui, ies 13 până la 14 ore-server: cu aproximativ 70% mai puțin. Iar o lună are 730 de ore: un cont care rulează peste 730 de joburi scurte pe lună pe servere per job plătește mai multe ore decât o mașină care nu se oprește niciodată.

Așa că mașina cea mai rapidă pentru tine (cache-uri pe disc, nimic de pornit) e și cea care costă cel mai puțin de rulat. Hosturile deținute de Skipbox au prioritate pentru că nu au deloc o factură pe oră, iar serverele închiriate preiau surplusul. De aceea Skipbox taxează mașina, nu minutul:

| 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** |
| Pornit tot timpul | $500,40 | $39 | **$461,40** |

La utilizare completă, asta înseamnă 1/12 din prețul GitHub. Cifrele GitHub sunt factura după calculul inclus în GitHub Team. Introdu propriile minute în [calculatorul de pe pagina principală](https://skipbox.dev/?ref=blog-github-actions-job-vm-boot-7-seconds-ro#cost); nu cere conectare.

## Mutarea înseamnă o singură linie

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

1. Conectează-te la Skipbox cu GitHub.
2. Instalează aplicația GitHub Skipbox și alege repository-urile.
3. Schimbă `runs-on` și fă push.

## Încearcă

Perioada de probă nu cere card: 7 zile sau 3.000 de minute de job, oricare se termină mai întâi. Îndreaptă cel mai lent workflow spre `runs-on: skipbox`, rulează-l de două ori și compară duratele pașilor de la a doua rulare.

## Întrebări frecvente

### Cât îi ia unui VM nou pentru un job GitHub Actions să pornească pe Skipbox?

Pe hosturile proprii Skipbox, 7,25 secunde de când hostul acceptă jobul până pornește procesul runnerului, față de 22,9 secunde înainte. Cele mai multe joburi nu pornesc nimic: rulează pe mașina dedicată a contului tău, păstrată între joburi.

### E sigur să pornești VM-urile joburilor de CI cu SeaBIOS în loc de UEFI secure boot?

Da, pentru un VM de job. Secure boot protejează lanțul de boot al guestului de înlocuire, iar un job de CI are deja root în propriul VM, care e șters după job. Pe Skipbox, VM-urile sunt ținute separat de KVM și de un firewall per VM pe host, iar niciunul nu depinde de firmware-ul guestului.

### De ce e lent fsync într-un VM pe ZFS și cum îl rezolvi pentru CI?

Fiecare fsync din guest așteaptă ca ZFS-ul hostului să își confirme intent logul. Discul unui VM de job nou e șters odată cu jobul, așa că Skipbox îi montează ext4 fără barriers: yarn install e cu 23% mai rapid, iar docker pull cu 19% mai rapid. O mașină păstrată între joburi își păstrează barriers.

### De ce marchează KVM TSC-ul ca instabil pe un CPU hibrid?

KVM compară TSC-ul când un vCPU trece pe alt CPU al hostului, iar între nucleele de performanță și cele eficiente poate citi o valoare mai mică. Fixarea fiecărui vCPU pe un singur CPU al hostului oprește verificarea: bucla de pornire și oprire a Skipbox a ținut atunci TSC-ul timp de 40 de runde.

### Cum îmi rulez joburile pe Skipbox?

Schimbă runs-on în skipbox într-un workflow. Perioada de probă nu cere card: 7 zile sau 3.000 de minute de job, oricare se termină mai întâi.

Actualizat pe 2026-11-16 · https://skipbox.dev/ro/blog/github-actions-job-vm-boot-7-seconds
