# Accelerare un monorepo pnpm e Turborepo in GitHub Actions (astro: da 528 s a 30 s)

> In un monorepo pnpm e Turborepo su GitHub Actions, la maggior parte del tempo è pnpm install su una VM nuova e turbo che esegue task i cui risultati non ci sono. Esegui solo i pacchetti toccati, dai a turbo una cache e conserva lo store di pnpm. Oppure esegui su una macchina che li conserva entrambi: la CI di astro è passata da 528 s su GitHub a 30 s su Skipbox, a un prezzo fisso di $39 al mese.

In un monorepo pnpm e Turborepo su GitHub Actions, la maggior parte di un job lento sono due step: `pnpm install` su una VM nuova, e `turbo run build test` che esegue task i cui risultati la VM non ha. Risolvili in quest'ordine. Esegui solo i pacchetti toccati da una modifica (`turbo run build --affected`, con un checkout che ha la cronologia). Dai a turbo una cache che sopravviva al job, perché i suoi risultati stanno in `.turbo/cache` su una macchina che GitHub cancella dopo ogni job: il Remote Caching, o `.turbo` ripristinata con `actions/cache`. E conserva lo store di pnpm. Sui runner di GitHub ognuna di queste cache è un download a ogni job. Su una macchina che conserva il suo disco sono semplicemente lì: il job di CI di astro ha impiegato 528 s su GitHub e 30 s sulla macchina dell'account di Skipbox, che ha riprodotto tutti i 40 task di build dalla cache conservata di turbo.

Skipbox esegue i tuoi job sulla macchina del tuo account, che conserva lo store di pnpm, i tool e la `.turbo` del checkout tra un job e l'altro, senza remote cache e senza chiavi di cache. Cambi una riga, `runs-on: skipbox`, a un prezzo fisso di $39 al mese con minuti illimitati.

- La CI di astro: 528 s su GitHub, 30 s su Skipbox, con turbo che riproduce 40 task di build e il task di test
- Lo store di pnpm e la `.turbo` di turbo restano sulla tua macchina: nessun remote cache da configurare, nessun archivio da scaricare
- 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-pnpm-turborepo-monorepo-github-actions-it)

## Dove passa il tempo un job di monorepo

| Step | Su una VM nuova di GitHub |
|---|---|
| Checkout | Un clone superficiale di default; `--affected` ha bisogno della cronologia, quindi uno completo |
| Configurare Node e pnpm | Scaricati, a meno che la tool cache non abbia la versione |
| `pnpm install` | Store ripristinato dall'archivio della cache (o scaricato dal registry), poi `node_modules` collegata per ogni pacchetto |
| `turbo run build` | Ogni task gira, a meno che `.turbo/cache` non sia stata ripristinata o non risponda un remote cache |
| `turbo run test` | Lo stesso, su 2 CPU sull'`ubuntu-latest` di un repository privato |

## 1. Esegui solo quello che è cambiato

Dalla [guida CI di Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci): `turbo run build --affected` esegue i task solo nei pacchetti cambiati rispetto al branch base. In GitHub Actions legge `GITHUB_BASE_REF` sulle pull request e `GITHUB_EVENT_PATH` sui push. Con un clone superficiale ogni pacchetto conta come cambiato, quindi fai il checkout della cronologia:

```yaml
- uses: actions/checkout@v4
  with:
    fetch-depth: 0
    filter: blob:none
```

`turbo query affected --packages web` dice a un job se deve girare o no, così il job di un'app non toccata può saltare la sua installazione.

## 2. Dai a turbo una cache che sopravviva al job

Turborepo salva i risultati dei task in `.turbo/cache` [sulla macchina](https://turborepo.dev/docs/crafting-your-repository/caching). La macchina di un job ospitato da GitHub viene cancellata quando il job finisce, quindi in CI quella cache parte vuota ogni volta. Due modi per aggirarlo, dalla [guida di Turborepo per GitHub Actions](https://turborepo.dev/docs/guides/ci-vendors/github-actions):

- **Remote Caching.** Imposta `TURBO_TOKEN` e `TURBO_TEAM` (Vercel Remote Cache, o un server self-hosted). Ogni hit è un download da lì.
- **`actions/cache` su `.turbo`.** Chiave `${{ runner.os }}-turbo-${{ github.sha }}` con `restore-keys: ${{ runner.os }}-turbo-`. Salva una nuova voce a ogni esecuzione, dentro i 10 GB per repository di GitHub insieme a tutto il resto che il repository mette in cache.

## 3. Conserva lo store di pnpm

`actions/setup-node` con `cache: pnpm`, o `actions/cache` su `pnpm store path`, ripristina lo store con chiave su `pnpm-lock.yaml`. Non ripristina `node_modules`, quindi pnpm collega comunque ogni pacchetto. La [documentazione CI di pnpm](https://pnpm.io/continuous-integration) lo dice chiaramente: mettere in cache lo store "is not guaranteed" a rendere l'installazione più veloce. In CI pnpm passa da solo a `--frozen-lockfile`.

## 4. Usa i core

turbo esegue in parallelo i task indipendenti e ogni tool di build o di test avvia i suoi worker, quindi un monorepo usa tutti i core che ha. L'`ubuntu-latest` di un repository privato ne ha 2.

## Quanto costa ogni soluzione sui runner di GitHub

- **Il Remote Caching** è un altro servizio e un altro token, e ogni hit della cache passa dalla rete.
- **`actions/cache` per `.turbo`** scrive una voce a ogni esecuzione e si contende gli stessi 10 GB con lo store di pnpm, i layer di Docker e le cache di ogni branch; le voci non usate da 7 giorni se ne vanno.
- **Un runner più grande** è un runner più grande su GitHub Team o Enterprise Cloud, fatturato al minuto.

## Quando la soluzione è una macchina che conserva il suo disco

La CI di astro, con il suo workflow invariato, dalle [nostre esecuzioni di progetti reali](https://skipbox.dev/it/guides/rust-cache-slow-rust-ci):

| | GitHub (repository pubblico, 4 vCPU, 16 GB) | Macchina dell'account di Skipbox (4 vCPU) |
|---|---|---|
| Job | 528 s | **30 s** ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)) |
| Task di build | 40 eseguiti | 40 riprodotti dalla cache di turbo |
| Task di test | eseguito | riprodotto dalla cache di turbo |

La macchina dell'account ha conservato la `.turbo` del checkout e lo store di pnpm dall'ultimo job, quindi turbo ha trovato il risultato di ogni task senza niente da scaricare. turbo riproduce un task solo quando l'hash dei suoi input è lo stesso, quindi un commit vero riesegue i pacchetti che tocca e riproduce il resto.

## Skipbox conserva lo stato del monorepo

Ogni piano include la macchina del tuo account, tenuta tra un job e l'altro:

- **Lo store di pnpm resta** in `~/.local/share/pnpm/store`, con la cache di npm e la `~/.cache` di ogni tool. `pnpm install` collega dal disco invece di scaricare.
- **La cache di turbo resta.** La `.turbo` di primo livello del checkout viene conservata tra un job e l'altro quando `turbo.json` è di turbo 2: una chiave `tasks`, niente `pipeline` e niente `"envMode": "loose"`. Niente `TURBO_TOKEN`, nessuno step di cache.
- **`node_modules` viene cancellata dopo ogni job**, così una matrice di versioni di Node che condivide un checkout non carica mai un addon nativo compilato per un altro Node.
- **I tool restano:** le versioni di Node installate da `setup-node`, pnpm stesso, le immagini e i layer di Docker.

Almeno 7× lo spazio cache di GitHub su S. 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. A 20.000 minuti al mese su 4 vCPU, GitHub fattura $222; Skipbox S costa $39, $183 in meno.

## Basta una riga

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          filter: blob:none
      - uses: pnpm/action-setup@v3
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install
      - run: pnpm turbo run build test --affected
```

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

Tieni gli step di cache come sono; quello che salvano resta accanto alla macchina.

## 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, gli hook 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 monorepo

La prova è gratuita per 7 giorni o 3000 minuti di job, quello che arriva prima, e non chiede la carta. Sposta il job di build su `runs-on: skipbox`, eseguilo due volte e metti le righe di installazione e di turbo della seconda esecuzione (`cached` contro `executing`) accanto a quelle di GitHub.

## Domande frequenti

### Come accelero un grande monorepo pnpm/Turborepo in GitHub Actions?

Tre cose, in ordine. Esegui solo quello che è cambiato: turbo run build --affected, con un checkout che ha la cronologia (fetch-depth: 0 e filter: blob:none). Dai a turbo una cache che sopravviva al job: il Remote Cache di Turborepo, o .turbo ripristinata con actions/cache. E conserva lo store di pnpm: cache: pnpm di setup-node o actions/cache sul percorso dello store. Sulle VM nuove di GitHub ognuna di queste è un download a ogni job; su una macchina che conserva il suo disco sono già lì. La CI di astro ha impiegato 528 s su GitHub e 30 s sulla macchina dell'account di Skipbox, che conserva la cache di turbo e lo store di pnpm.

### Perché pnpm install è lento in GitHub Actions anche con lo store in cache?

Perché uno store ripristinato resta un archivio scaricato e scompattato su una VM nuova, e poi pnpm collega node_modules per ogni pacchetto del workspace. La documentazione CI di pnpm dice che mettere in cache lo store non garantisce un'installazione più veloce. Uno store che è già sul disco della macchina salta il download; resta solo il collegamento.

### La cache di Turborepo funziona in GitHub Actions?

Solo se la cache sopravvive al job. Turborepo tiene i risultati dei task in .turbo/cache sulla macchina, e la macchina di un job ospitato da GitHub sparisce quando il job finisce. Quindi la CI ha bisogno del Remote Caching (TURBO_TOKEN e TURBO_TEAM, quello di Vercel o uno self-hosted) o di uno step actions/cache per .turbo. Sulla macchina dell'account di Skipbox la .turbo del checkout resta tra un job e l'altro per i progetti turbo 2, quindi turbo riproduce i task invariati senza remote cache.

### turbo --affected funziona in GitHub Actions?

Sì. Turborepo legge GITHUB_BASE_REF sulle pull request, e GITHUB_EVENT_PATH sui push, per trovare la base con cui confrontare. Ha bisogno della cronologia: con un clone superficiale ogni pacchetto conta come cambiato. Imposta fetch-depth: 0 e filter: blob:none su actions/checkout.

### Cosa conserva Skipbox per un monorepo Turborepo?

Lo store di pnpm, le cache di npm e di ogni tool, i tool che installa setup-node, i layer di Docker, e il checkout con la sua .turbo di primo livello quando turbo.json è di turbo 2 (una chiave tasks, niente pipeline, non envMode loose). node_modules viene cancellata dopo ogni job, quindi l'installazione gira, dallo store sul disco. turbo riproduce un task solo quando l'hash dei suoi input è lo stesso, quindi un commit riesegue quello che tocca.

### Quanto costa provarlo?

Niente. La prova dura 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta. Sposta il job di build del monorepo su runs-on: skipbox, eseguilo due volte e confronta gli step di installazione e di turbo della seconda esecuzione con quelli di GitHub.

Aggiornata il giorno 2026-11-13 · https://skipbox.dev/it/guides/pnpm-turborepo-monorepo-github-actions
