# Come accelerare GitHub Actions: tagliare una pipeline da 25 minuti, una leva alla volta

> Una pipeline GitHub Actions lenta è fatta di job che si aspettano a vicenda, lavoro che non serviva eseguire, preparazione ripetuta su una VM vuota e step che consumano CPU su 2 core. Risolvili in quest'ordine. Gli ultimi due sono la macchina: Skipbox conserva le tue cache sulla tua macchina tra un job e l'altro, con fino a 16 vCPU, a un prezzo fisso di $39 al mese con minuti illimitati.

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`.

- Le leve in ordine: misura, salta, esegui in parallelo, smetti di ricostruire, aggiungi core, dividi in shard
- La tua macchina conserva cache e output di build tra un job e l'altro: la CI di astro è passata da 528 s a 30 s
- 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=g-speed-up-github-actions-it)

## 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](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) con `cancel-in-progress` la ferma. Limitalo alle pull request così un push sul branch di default non annulla mai un deploy:

```yaml
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](https://skipbox.dev/it/guides/github-actions-cache-size-limit)).
- **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](https://skipbox.dev/it/guides/docker-layer-cache-github-actions)).

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](https://jestjs.io/docs/cli#--maxworkersnumstring) usa di default i core meno uno (un worker su 2 CPU), pytest gira in serie finché non usi `-n auto`, e [Playwright](https://playwright.dev/docs/ci#workers) 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](https://docs.github.com/en/actions/concepts/runners/larger-runners): 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](https://skipbox.dev/?ref=g-speed-up-github-actions-it#cost).

## 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](https://skipbox.dev/it/guides/rust-cache-slow-rust-ci):

| 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

```yaml
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](https://docs.skipbox.dev/it/isolation).

## 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 2026-11-13 · https://skipbox.dev/it/guides/speed-up-github-actions
