Skipbox

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:

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-progress la 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 --affected o 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: npm di actions/setup-node (e le sue forme per pnpm e yarn) salva i download del gestore di pacchetti con chiave sul lockfile; non salva node_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/cache di 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 build su una VM nuova parte senza layer; esportarli con cache-to di 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:

Più core su GitHub costano di più al minuto, quindi la differenza cresce con la macchina:

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:

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:

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
  1. Accedi a Skipbox con GitHub.
  2. Installa la GitHub App di Skipbox e scegli i repository.
  3. Cambia runs-on e 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

CI/CD più veloce con una cache sempre calda

Il tuo runner sempre caldo a prezzo fisso

Li ospitiamo noi. Tu cambi una riga. 1/12 del costo di GitHub a pieno utilizzo. Prezzo fisso, quindi puoi farlo girare tutto il giorno. 7× lo spazio cache di GitHub.

  • Nessuna carta
  • Accedi con GitHub
  • Disdici quando vuoi