Come accelerare GitHub Actions: tagliare una pipeline da 25 minuti, una leva alla volta
Una pipeline GitHub Actions da 25 minuti di solito sono quattro ritardi uno sopra l'altro: job che si aspettano a vicenda, lavoro che non serviva eseguire, preparazione che una VM vuota ripete a ogni job, e step che consumano CPU schiacciati su 2 core (l'ubuntu-latest di un repository privato ha 2 CPU e 8 GB). Affrontali in quest'ordine. Prima misura il percorso critico, con il tempo in coda a parte. Poi salta quello che non serviva eseguire, fai girare insieme i job indipendenti, smetti di ricostruire lo stato, dai più core agli step pesanti e dividi in shard quello che è ancora lungo. I primi tre sono correzioni al workflow che non costano niente. Il resto è la macchina: un runner che conserva le sue cache tra un job e l'altro e ha più core.
Skipbox è quel runner. I tuoi job girano sulla macchina del tuo account, che conserva layer Docker, cache dei pacchetti, tool e output di build tra un job e l'altro, con da 4 a 16 vCPU, a un prezzo fisso di $39 al mese con minuti illimitati. Sulla CI di astro sono stati 528 s su GitHub e 30 s su Skipbox. Il passaggio è una riga: runs-on: skipbox.
1. Misura il percorso critico
Il tempo che il tuo team aspetta è la catena di job che finisce per ultima, non la somma di tutti i job. Apri l'esecuzione di una pull request rappresentativa: il grafo mostra quali job aspettano quali, e il log di ogni job mostra i tempi dei suoi step. Per la catena più lenta, annota:
| Fase | Cosa controllare |
|---|---|
| In coda | Il job ha aspettato un runner? Un comando più veloce non accorcia una coda |
| Set up job, checkout | Un'immagine di container scaricata, un clone completo dove ne basterebbe uno superficiale |
| Toolchain e installazione | La cache ha fatto hit, e l'hit ha fatto risparmiare più di quanto ha richiesto il ripristino? |
| Build | Lo stesso output viene compilato in un altro job? |
| Test | La CPU del runner è occupata tutto il tempo, o c'è un solo worker che fa tutto? |
| Upload | Artifact e salvataggi della cache dopo che il lavoro utile è finito |
Confronta un'esecuzione a caldo con una a freddo. Una cache che fallisce metà delle volte sembra a posto in una media.
2. Salta quello che non serviva eseguire
- Annulla le esecuzioni superate. Ogni push dopo il primo rende inutile l'esecuzione in corso. Un gruppo di concorrenza con
cancel-in-progressla ferma. Limitalo alle pull request così un push sul branch di default non annulla mai un deploy:
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
- Esegui solo quello che la modifica tocca. I filtri
paths:saltano un workflow sulle modifiche solo di documentazione; in un monorepo,turbo run test --affectedo i comandi affected di Nx eseguono solo i pacchetti cambiati. Un filtro a livello di trigger vuol dire che un controllo obbligatorio non riporta mai, quindi filtra dentro il job quando il controllo è obbligatorio.
3. Esegui insieme i job indipendenti
GitHub esegue i job in parallelo a meno che needs: non li concateni. Lint, controllo dei tipi, test unitari e build raramente hanno bisogno l'uno dell'altro: avviali insieme e fai aspettare tutti solo il packaging o il deploy. Se due job compilano la stessa cosa, compilala una volta e passala con actions/upload-artifact, misurando upload e download.
4. Smetti di ricostruire lo stesso stato
È qui che va la maggior parte di una pipeline lunga. Ogni job su un runner ospitato da GitHub parte su una VM nuova, quindi scarica la sua toolchain, installa le dipendenze, ricostruisce i layer Docker e compila da zero, ogni volta.
- Cache che fanno davvero hit.
cache: npmdiactions/setup-node(e le sue forme per pnpm e yarn) salva i download del gestore di pacchetti con chiave sul lockfile; non salvanode_modules, quindi l'installazione gira comunque. GitHub tiene 10 GB per repository, toglie le voci non usate da 7 giorni, e un hit resta un download sulla nuova VM (limite di dimensione della cache). - Cache dei tool.
eslint --cache,tsc --incremental, la directory di cache di Jest e la.turbo/cachedi turbo salvano il lavoro stesso, non i download. Su una VM nuova sono vuote a meno che tu non ripristini anche quelle. - Layer Docker.
docker buildsu una VM nuova parte senza layer; esportarli concache-todi buildx e importarli a ogni esecuzione è il rimedio (cache dei layer Docker).
Una macchina che conserva il suo disco fa tutto questo da sola: le cache, le cache dei tool, i layer e l'output di build sono lì dall'ultimo job.
5. Dai più core agli step pesanti
Compilatori, bundler e test runner avviano un worker per core, quindi su 2 CPU ne eseguono due alla volta. Controlla cosa usa davvero il test runner: Jest usa di default i core meno uno (un worker su 2 CPU), pytest gira in serie finché non usi -n auto, e Playwright usa di default metà dei core, e la sua documentazione raccomanda un worker in CI. Più core aiutano solo quando al runner viene detto di usarli, e solo sugli step che tengono occupata la CPU; un download o l'avvio di un database non accelerano.
Su GitHub, più core vuol dire runner più grandi: da 4 a 96 core, solo nelle organizzazioni su GitHub Team o Enterprise Cloud, fatturati al minuto a una tariffa per core più alta.
6. Dividi in shard quello che è ancora lungo
Una matrice di shard divide una suite lunga su più job. Taglia il tempo reale, non i minuti: ogni shard rifà checkout, installazione e build, quindi quattro shard pagano la preparazione quattro volte. Bilancia gli shard in base al tempo misurato, non al numero di file, e smetti di aggiungerne quando la preparazione è la maggior parte di ogni shard.
Quanto costa restare lenti
Una pipeline da 15 minuti che gira 40 volte al giorno sono 10 ore di attesa distribuite sul tuo team, ogni giorno, prima ancora di contare i cambi di contesto. Con la fatturazione al minuto, i minuti di preparazione si pagano come quelli dei test:
| 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 |
Più core su GitHub costano di più al minuto, quindi la differenza cresce con la macchina:
| 20.000 minuti al mese | GitHub | Skipbox | Risparmi ogni mese |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | $343 |
| 16 vCPU | $822 | $149 (L) | $673 |
Le cifre di GitHub sono al netto dell'uso incluso in GitHub Team. Prova con i tuoi minuti nel calcolatore della home.
Quando la soluzione è la macchina
I job di CI di progetti reali, con gli step invariati, sul runner per repository pubblici di GitHub (4 vCPU, 16 GB) e sulla macchina dell'account di Skipbox con le stesse vCPU, dalle nostre esecuzioni dei loro workflow:
| Progetto | GitHub | Skipbox, macchina dell'account | Cosa ha conservato la macchina |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | 30 s | La cache di turbo: 40 task di build riprodotti |
| tauri (Rust) | 246 s | 53 s | Il target/ di Cargo: nessun crate ricompilato |
| ripgrep (Rust) | 200 s | 40 s | Il target/ e l'immagine Docker di cross |
| vite (Node.js) | 141 s | 100 s | Le cache dei pacchetti; il resto sono i suoi test che girano |
L'ubuntu-latest di un repository privato ha metà dei core di quelle esecuzioni GitHub.
Cosa fa Skipbox per la tua pipeline
Conserva la macchina. Ogni piano include la macchina del tuo account, tenuta tra un job e l'altro. Immagini, layer e cache di build di Docker, cache dei pacchetti, la tool cache, e il tuo checkout con il target/ di Cargo e la cache di turbo restano sul suo disco: almeno 7× lo spazio cache di GitHub, senza chiavi, senza scadenza dopo 7 giorni e senza regole sui branch.
Aggiunge core a prezzo fisso. Un job sceglie la sua dimensione con l'etichetta:
| Etichetta | Macchina | Piano |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 al mese |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 al mese |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 al mese |
I minuti sono illimitati, quindi shard, riesecuzioni e una matrice più grande non alzano la fattura. I job di Skipbox non usano minuti di GitHub, quindi un budget di GitHub non li ferma mai.
Si cura da sola. Skipbox prepara la macchina, tiene aggiornata l'immagine, fa pulizia dopo ogni job e ricostruisce la macchina che non supera il controllo di salute.
Basta una riga
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
- Accedi a Skipbox con GitHub.
- Installa la GitHub App di Skipbox e scegli i repository.
- Cambia
runs-one fai push.
I tuoi step e le tue action girano come sono, su Ubuntu 24.04 con Docker, Node.js e Python.
Sicurezza
- La macchina è solo del tuo account. Nessun job di altre aziende gira su di essa.
- Dopo ogni job vengono cancellati le credenziali, i processi e i container del runner, e anche le credenziali git e i file non tracciati del checkout conservato. “VM nuova per ogni job” dà invece a ogni job una macchina nuova.
- Il codice di chi non ha accesso in scrittura (come le pull request dai fork) gira su una VM nuova che legge le tue cache ma non le può modificare.
I dettagli sono in come vengono isolati i job.
Provalo sul tuo job più lento
La prova è gratuita per 7 giorni o 3000 minuti di job, quello che arriva prima, e non chiede la carta. Sposta su runs-on: skipbox il job sul tuo percorso critico, eseguilo due volte e leggi i tempi degli step della seconda esecuzione accanto a quelli di GitHub.
Domande frequenti
La nostra pipeline GitHub Actions dura 25 minuti. Qual è il modo più rapido per renderla più veloce?
Procedi in ordine. Leggi il grafo dell'esecuzione e i tempi degli step per trovare la catena di job che determina il tempo, con il tempo in coda a parte. Annulla le esecuzioni superate e salta i job i cui file non sono cambiati. Togli i needs: che esprimono solo un'abitudine, così i job indipendenti girano insieme. Smetti di ricostruire lo stato a ogni job: cache che fanno davvero hit, o un runner che conserva il suo disco. Dai più core agli step che consumano CPU e lascia che il test runner li usi. Dividi in shard solo quello che è ancora lungo. Sull'ubuntu-latest di un repository privato (2 CPU, 8 GB), gli ultimi tre sono spesso la maggior parte dei 25 minuti, e sono della macchina: Skipbox dà al job la sua macchina che conserva le cache tra un job e l'altro, con da 4 a 16 vCPU.
Passare a runner più veloci conviene rispetto a ottimizzare il workflow?
Fai prima le correzioni gratuite al workflow: annullare le esecuzioni superate, i filtri sui percorsi e togliere i needs: inutili non costano niente e nessun runner le fa per te. Dopo, guarda dove va il tempo che resta. La preparazione che si ripete a ogni job (toolchain, installazione delle dipendenze, build Docker) e gli step che tengono occupato ogni core sono un problema della macchina, e un runner che conserva le sue cache e ha più core li elimina con una riga runs-on. Le attese di rete e gli step in serie non accelerano con una macchina più grande.
Perché GitHub Actions è più lento del mio portatile?
Il tuo portatile tiene su disco i pacchetti, i tool, i layer Docker e l'output di build, e di solito ha 8 o più core. Un job sull'ubuntu-latest di un repository privato ha 2 CPU e 8 GB, su una VM nuova che non ha niente di tutto questo. Skipbox funziona come il tuo portatile: la macchina resta tra un job e l'altro, con 4 vCPU o più.
Dividere i test in shard rende GitHub Actions più veloce?
Accorcia il tempo reale, non i minuti. Ogni shard è un nuovo job che rifà checkout, installazione e build, quindi quattro shard pagano la preparazione quattro volte, e la fatturazione al minuto le conta tutte. Dividi in shard dopo che la preparazione costa poco e i core del runner sono in uso. Su Skipbox la preparazione resta sul disco e i minuti sono illimitati, quindi gli shard non costano niente in più.
Come ottengo più di 4 core per un job GitHub Actions?
Su GitHub, i runner più grandi vanno da 4 a 96 core, solo per le organizzazioni su GitHub Team o Enterprise Cloud, fatturati al minuto. Su Skipbox, cambia runs-on in skipbox-8x16 per 8 vCPU o skipbox-16x32 per 16 vCPU, a un prezzo mensile fisso, sia sulle organizzazioni sia sugli account personali.
Quanto costa provarlo?
Niente. La prova dura 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta. Cambia il runs-on del tuo job più lento in skipbox, eseguilo due volte e confronta i tempi dei suoi step.
Aggiornata il giorno 13 novembre 2026