# Dove sono finiti 23 secondi: avviare in 7 la VM di un job GitHub Actions

> Una macchina virtuale KVM nuova per un job GitHub Actions impiegava 22,9 s per arrivare al suo runner sugli host di Skipbox. Ora ne impiega 7,25. Ogni secondo e come è stato misurato, dal runner a un prezzo fisso di $39 al mese con minuti illimitati.

Una macchina virtuale nuova per un job GitHub Actions impiegava 22,9 secondi su un host Skipbox per passare da "l'host ha accettato il job" a "parte il processo del runner". Ora ne impiega 7,25. Questo articolo racconta dov'erano gli altri 15 secondi e come è stato misurato ciascuno.

Skipbox è un runner GitHub Actions a un prezzo fisso di $39 al mese con minuti illimitati. I tuoi job girano sulla macchina del tuo account, che resta tra un job e l'altro, e i job che hanno bisogno di una VM nuova ne hanno una in 7 secondi. Cambia una riga `runs-on` per passare.

- Una VM di job nuova arriva al suo runner in 7,25 s, contro i 22,9 s di prima
- Sulla tua macchina già pronta, gli step di preparazione di un job richiedono 7 s contro 52 s sull'`ubuntu-latest` di GitHub
- 20.000 minuti al mese su 4 vCPU: $222 su GitHub, $39 su Skipbox

**GitHub Actions a prezzo fisso, minuti illimitati** Skipbox esegue i tuoi job di GitHub Actions su una macchina dedicata tutta tua: $39 al mese, per quanti minuti tu esegua. I layer Docker e le cache delle dipendenze restano tra un job e l'altro, così il job successivo parte subito.

Un runner da 4 vCPU, 20.000 minuti al mese: GitHub $222 → Skipbox $39. Risparmi $183 ogni mese.

Per passare basta una riga: `runs-on: skipbox`.

[Inizia la prova gratuita di 7 giorni](https://app.skipbox.dev/sign-in?ref=blog-github-actions-job-vm-boot-7-seconds-it)

## Cosa viene cronometrato, e su cosa

Un host Skipbox esegue macchine virtuali KVM tramite Incus su un pool ZFS. L'immagine del runner è una VM ferma con uno snapshot. Un job che ha bisogno di una VM nuova riceve un clone ZFS di quello snapshot, lo avvia, riceve tramite il guest agent una configurazione del runner just-in-time, esegue un job, e viene cancellato con il suo disco.

Il daemon dell'host registra la fine di ogni passo di un avvio in millisecondi dal momento in cui accetta il job (`startMs`: `cloned`, `started`, `agent`). I numeri qui sotto vengono da un host Intel i7-7820X a 16 thread e da una VM con 4 vCPU e 8 GB.

| | Dall'accettazione all'avvio del runner, 3 esecuzioni ciascuno |
|---|---|
| Prima | 22,9 s (da 21,7 a 24,2) |
| Dopo | 7,25 s (da 7,1 a 8,1) |

Dove sono finiti, ogni pezzo misurato da solo:

| Modifica | Misurato | Risparmiato |
|---|---|---|
| SeaBIOS invece di OVMF | Dall'avvio della VM alla prima risposta dell'agent, mediana di 3: 13,7 → 8,4 s | 5,3 s |
| `quiet` sulla riga di comando del kernel | 8,4 → 6,5 s | 1,9 s |
| Niente initrd | 6,5 → 5,1 s | 1,4 s |
| Un'immagine già della dimensione dei suoi cloni | Clone 1,5 → 0,1 s, primo avvio 2,35 → 1,8 s | 1,9 s |
| Aspettare il socket di Docker, non dockerd | dockerd era su 3,6 s dopo l'agent | 3,6 s |
| Interrogare il guest agent ogni 100 ms, non ogni secondo | 0,5 s in media, fino a 1 s | 0,5 s |

I pezzi sommano 14,6 s dei 15,65 s di differenza complessiva.

## Firmware: 5,3 secondi prima di GRUB

Incus avvia di default una VM con OVMF e secure boot. Su questo host OVMF impiegava 5,3 s per passare la mano a GRUB. SeaBIOS ne impiega 0,5. Due chiavi dell'istanza fanno il cambio: `security.csm=true` e `security.secureboot=false`.

Questo era il pezzo singolo più grande, e l'unico che tocca la sicurezza, quindi eccolo per intero. Con SeaBIOS la firma della catena di avvio del guest non viene verificata. Quel controllo protegge da qualcuno che sostituisce il bootloader o il kernel del guest. In una VM di job di CI quel qualcuno è il job, e il job ha già root nella sua VM: può fare `sudo` di qualsiasi cosa, e la VM e il suo disco vengono cancellati quando il job finisce. Quello che tiene la VM di un cliente lontana da quella di un altro è KVM e una catena di firewall per VM sul bridge dell'host, e nessuno dei due dipende dal firmware del guest. L'immagine si avvia con entrambi, e un flag sull'host rimette UEFI.

## Un kernel silenzioso, e niente initrd

Una VM di job si avvia una volta per ogni job, e nessuno legge la sua console seriale. `quiet` ha portato la mediana da 8,4 a 6,5 s.

L'initrd esiste per caricare i driver che trovano il file system root. Il kernel generico di Ubuntu ha virtio-scsi ed ext4 integrati, e ogni clone condivide l'UUID di partizione dell'immagine, quindi il kernel monta `/` direttamente da `root=PARTUUID=…`. Altri 1,4 s.

Due protezioni evitano che vada storto in silenzio. Il GRUB di Ubuntu riavvia da solo con l'initrd la volta successiva se un avvio senza è andato in panic (`GRUB_FORCE_PARTUUID`). Quel ripiego riporterebbe in silenzio gli 1,4 s su ogni job, quindi la build dell'immagine avvia un clone di prova e fallisce se `dmesg` mostra un initramfs scompattato.

## Non ridimensionare un disco che potevi costruire della misura giusta

L'immagine veniva costruita su un disco più piccolo, e ogni clone veniva ingrandito alla dimensione del suo piano all'avvio. Ingrandirlo costava 1,9 s per job: il clone richiedeva 1,5 s invece di 0,1, e il primo avvio 2,35 s invece di 1,8. Ora l'immagine viene costruita alla dimensione del disco del piano più piccolo (80 GB). Il volume è thin, quindi l'immagine contiene comunque solo quello che ci è stato scritto. Incus non può ridurre un clone, quindi l'immagine non è mai più grande del piano più piccolo; i piani più grandi crescono all'avvio.

## Il socket di Docker basta

Lo script di avvio aspettava `docker.service` prima di avviare il runner. dockerd era su 3,6 s dopo il guest agent. Ma systemd ascolta sul socket di Docker fin dall'inizio dell'avvio, e un client che si collega prima che dockerd sia su lo aspetta. Così lo script aspetta solo `docker.socket` e il DNS, con un'attesa limitata, e dockerd finisce di partire mentre parte il runner.

## Interrogare a 100 ms

La configurazione del runner viene inviata nella VM tramite il guest agent, che non c'è finché il guest non si è avviato. L'host riprovava una volta al secondo, quindi un job aspettava in media 0,5 s dopo che l'agent era su. Incus rifiuta un invio in 20 ms mentre l'agent è giù, quindi chiedere ogni 100 ms non costa niente. Dopo i primi 30 s di una VM l'host torna a una volta al secondo.

## Non è una correzione dell'avvio: fsync su un disco che muore con il job

Durante le misure, la cosa più lenta nella VM si è rivelata non essere l'avvio. Ogni `fsync` nel guest aspettava che lo ZFS dell'host facesse il commit del suo intent log. Il disco di una VM di job nuova viene cancellato con il job, quindi niente su di esso deve sopravvivere a un'interruzione di corrente. Lo script di avvio rimonta `/` con `nobarrier` prima di avviare il runner.

Mediane di 3, in una VM con 4 vCPU e 8 GB:

| | Prima | Dopo |
|---|---|---|
| Scritture casuali da 4k con fsync | 227 al secondo | 2.505 al secondo |
| `yarn install`, 1 GB di node_modules dalla sua cache | 12,92 s | 9,99 s (23% in meno) |
| `docker pull node:22` | 19,12 s | 15,45 s (19% in meno) |
| Una build Docker di redis | 92,89 s | 87,21 s |
| `make -j4`, `sysbench cpu` | invariati | invariati |

Questo vale solo per le VM nuove. La tua macchina tiene le tue cache tra un job e l'altro, e il suo ext4 mantiene le barriere.

## La stessa caccia sui server cloud a noleggio

Quando gli host di Skipbox sono pieni, un job gira su un server cloud avviato da un'immagine snapshot. Quel percorso aveva il suo tempo perso, in un punto diverso. Su un server condiviso Intel a 4 vCPU, lo script del job (gli user data del server) partiva 28,1 s dopo il kernel. cloud-init aveva lo script a 19,3 s e Docker era su a 22,2 s, ma cloud-init esegue gli user data nella sua ultima fase, dopo tutto il resto.

Ora l'immagine ha una piccola unit systemd che esegue gli user data appena cloud-init li ha scritti. Legge lo script tramite un file descriptor da un file che ha già rimosso, così l'ultima fase di cloud-init non trova niente da eseguire una seconda volta. L'immagine genera anche un solo tipo di chiave host SSH invece di tre (2,0 s sul percorso che tutto aspetta; nessuno accede a questi server), e non avvia più snapd, apport, rsyslog o una dozzina di timer di manutenzione all'avvio.

Con quell'immagine, su un server condiviso AMD a 4 vCPU, lo script del job parte da 8 a 14 s dopo il kernel.

## Le vCPU fissate tengono giusto l'orologio di ogni host

Su una CPU ibrida (core performance e core efficiency, come la Core Ultra 7 265F), KVM può smettere di fidarsi del TSC. Durante una notte di build di immagini, il kernel ha scritto nel log:

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

KVM confronta il TSC quando una vCPU passa a un'altra CPU dell'host. Ha letto un valore più basso sul nuovo core, tra tipi di core diversi, e ha marcato il TSC come instabile. Il kernel aveva già disattivato HPET all'avvio ("HPET dysfunctional in PC10"), quindi l'unica sorgente di clock rimasta era acpi_pm, che su questa scheda avanzava appena: circa 1 secondo di uptime in 30 minuti.

Skipbox lo risolve in due passi:

1. **Un ripiego che funziona.** Limitare il C-state del package a C8 nel BIOS tiene in vita HPET. KVM ha comunque scartato il TSC, al giro 11 di un ciclo di 20 giri che avvia e ferma una VM a 8 vCPU sotto carico, ma il clock è passato a HPET e ha tenuto il tempo.
2. **Il pinning.** KVM esegue quel controllo solo quando una vCPU si sposta. Con ogni vCPU fissata a una CPU dell'host, lo stesso ciclo ha girato 40 volte sul TSC senza nessuna nuova riga nel log.

Il daemon dell'host non prende nessun job a meno che la sorgente di clock non sia `tsc` e `hpet` non sia disponibile, quindi un host che perde il suo TSC si svuota da solo e i suoi job vanno ad altre macchine. Ogni host Skipbox fissa le sue vCPU.

## L'avvio più veloce è quello che salti

Sette secondi sono per i job che hanno bisogno di una VM nuova: il codice di chi non ha accesso in scrittura (come le pull request dai fork), un job che arriva mentre la tua macchina è occupata, e gli account che scelgono una VM pulita per ogni job. Ogni altro job non avvia niente. Gira sulla macchina del tuo account, con i layer Docker, le cache dei pacchetti e i tool dell'ultimo job ancora sul suo disco.

È lì che stanno i minuti. Gli stessi workflow sull'`ubuntu-latest` di GitHub (2 vCPU, quello che ha un repository privato) e su uno Skipbox S già pronto (4 vCPU), mediane delle esecuzioni a caldo:

| | GitHub `ubuntu-latest` | Skipbox S, a caldo | |
|---|---|---|---|
| excalidraw: installazione, build e test | 613 s | 450 s | 27% in meno |
| Step di preparazione (checkout, Node, ripristino della cache) | 52 s | 7 s | |
| Test | 484 s | 354 s | |
| umami: build Docker multi-stage | 263 s | 188 s | 29% in meno |

Gli step di preparazione scendono da 52 s a 7 s perché non c'è nessun archivio di cache da scaricare e scompattare: Node è già nella tool cache e la cache di yarn è sul disco. La build Docker usa la cache dei layer del daemon stesso, senza niente da esportare o importare. Su Skipbox il workflow non ha nessuno step di cache.

## Perché un prezzo fisso può tenere una macchina pronta

Una macchina inattiva sembra uno spreco. Con il modo in cui si paga il calcolo, è la scelta più economica, ed è questo che fa funzionare un prezzo fisso.

Un server cloud a noleggio si paga per ogni ora che inizia, per intero. Un job da 3 minuti sul suo server paga 60 minuti. In un giorno della nostra CI, 44 job da 2,5 minuti in media hanno girato su 44 server e sono stati fatturati 44 ore-server. Rigiocando lo stesso giorno con ogni server tenuto per il job successivo dell'account entro la sua ora si ottengono da 13 a 14 ore-server: circa il 70% in meno. E un mese ha 730 ore: un account che esegue più di 730 job brevi al mese su server per job paga più ore di una macchina che non si ferma mai.

Quindi la macchina più veloce per te (cache sul disco, niente da avviare) è anche quella che costa meno da gestire. Gli host di proprietà di Skipbox vengono prima perché non hanno nessuna fattura oraria, e i server a noleggio prendono quello che avanza. Per questo Skipbox fa pagare la macchina, non il minuto:

| Minuti al mese (4 vCPU) | GitHub | Skipbox S | Risparmi ogni mese |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Sempre acceso | $500,40 | $39 | **$461,40** |

A pieno uso è 1/12 del prezzo di GitHub. Le cifre di GitHub sono la fattura dopo il calcolo incluso in GitHub Team. Inserisci i tuoi minuti nel [calcolatore della home](https://skipbox.dev/?ref=blog-github-actions-job-vm-boot-7-seconds-it#cost); non serve accedere.

## Basta una riga

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

1. Accedi a Skipbox con GitHub.
2. Installa la GitHub App di Skipbox e scegli i repository.
3. Cambia `runs-on` e fai push.

## Provalo

La prova non chiede la carta: 7 giorni o 3000 minuti di job, quello che arriva prima. Punta il tuo workflow più lento su `runs-on: skipbox`, eseguilo due volte e confronta i tempi degli step della seconda esecuzione.

## Domande frequenti

### Quanto ci mette a partire una VM nuova per un job GitHub Actions su Skipbox?

Sugli host di Skipbox, 7,25 secondi da quando l'host accetta il job a quando parte il processo del runner, contro i 22,9 secondi di prima. La maggior parte dei job non avvia niente: gira sulla macchina del tuo account, che resta tra un job e l'altro.

### È sicuro avviare le VM dei job di CI con SeaBIOS invece che con UEFI secure boot?

Sì, per una VM di job. Il secure boot protegge la catena di avvio del guest dall'essere sostituita, e un job di CI ha già root nella sua VM, che viene cancellata dopo il job. Su Skipbox le VM sono tenute separate da KVM e da un firewall per VM sull'host, e nessuno dei due dipende dal firmware del guest.

### Perché fsync è lento in una VM su ZFS, e come si risolve per la CI?

Ogni fsync nel guest aspetta che lo ZFS dell'host faccia il commit del suo intent log. Il disco di una VM di job nuova viene cancellato con il job, quindi Skipbox monta il suo ext4 senza barriere: yarn install è più veloce del 23% e docker pull del 19%. Una macchina tenuta tra un job e l'altro mantiene le sue barriere.

### Perché KVM marca il TSC come instabile su una CPU ibrida?

KVM confronta il TSC quando una vCPU passa a un'altra CPU dell'host, e tra core performance e core efficiency può leggere un valore più basso. Fissare ogni vCPU a una CPU dell'host impedisce al controllo di partire: il ciclo di avvio e arresto di Skipbox ha poi tenuto il TSC per 40 giri.

### Come eseguo i miei job su Skipbox?

Cambia runs-on in skipbox in un workflow. La prova non chiede la carta: 7 giorni o 3000 minuti di job, quello che arriva prima.

Aggiornata il giorno 2026-11-16 · https://skipbox.dev/it/blog/github-actions-job-vm-boot-7-seconds
