# Accélérer un monorepo pnpm et Turborepo dans GitHub Actions (astro : de 528 s à 30 s)

> Dans un monorepo pnpm et Turborepo sur GitHub Actions, l'essentiel du temps passe dans pnpm install sur une VM neuve et dans turbo qui exécute des tâches dont les résultats ne s'y trouvent pas. N'exécutez que les paquets concernés, donnez un cache à turbo, et gardez le store pnpm. Ou exécutez sur une machine qui garde les deux : la CI d'astro est passée de 528 s sur GitHub à 30 s sur Skipbox, pour un prix fixe de $39 par mois.

Dans un monorepo pnpm et Turborepo sur GitHub Actions, l'essentiel d'une tâche lente tient en deux étapes : `pnpm install` sur une VM neuve, et `turbo run build test` qui exécute des tâches dont la VM n'a pas les résultats. Corrigez-les dans cet ordre. N'exécutez que les paquets touchés par une modification (`turbo run build --affected`, avec un checkout qui a l'historique). Donnez à turbo un cache qui survit à la tâche, puisque ses résultats vivent dans `.turbo/cache` sur une machine que GitHub supprime après chaque tâche : le Remote Caching, ou `.turbo` restauré avec `actions/cache`. Et gardez le store pnpm. Sur les exécuteurs de GitHub, chacun de ces caches est un téléchargement à chaque tâche. Sur une machine qui garde son disque, ils sont tout simplement là : la tâche CI d'astro prenait 528 s sur GitHub et 30 s sur une machine dédiée au compte chez Skipbox, qui a rejoué les 40 tâches de build depuis le cache conservé de turbo.

Skipbox exécute vos tâches sur la machine dédiée à votre compte, qui garde le store pnpm, les outils et le `.turbo` du checkout entre les tâches, sans cache distant ni clé de cache. Modifiez une ligne, `runs-on: skipbox`, pour un prix fixe de $39 par mois avec des minutes illimitées.

- La CI d'astro : 528 s sur GitHub, 30 s sur Skipbox, avec turbo qui rejoue 40 tâches de build et la tâche de test
- Le store pnpm et le `.turbo` de turbo restent sur votre machine : aucun cache distant à configurer, aucune archive à télécharger
- 20 000 minutes par mois sur 4 vCPU : $222 sur GitHub, $39 sur Skipbox

**GitHub Actions à prix fixe, minutes illimitées** Skipbox exécute vos tâches GitHub Actions sur votre propre machine dédiée : $39 par mois, quel que soit le nombre de minutes. Les couches Docker et les caches de dépendances restent d'une tâche à l'autre : la tâche suivante démarre tout de suite.

Un exécuteur de 4 vCPU, 20 000 minutes par mois: GitHub $222 → Skipbox $39. Vous économisez $183 chaque mois.

Le changement tient en une ligne : `runs-on: skipbox`.

[Commencer mon essai gratuit de 7 j](https://app.skipbox.dev/sign-in?ref=g-pnpm-turborepo-monorepo-github-actions-fr)

## Où une tâche de monorepo passe son temps

| Étape | Sur une VM GitHub neuve |
|---|---|
| Checkout | Un clone superficiel par défaut ; `--affected` a besoin de l'historique, donc d'un clone complet |
| Installer Node et pnpm | Téléchargés, sauf si le cache d'outils a la version |
| `pnpm install` | Store restauré depuis l'archive de cache (ou téléchargé depuis le registre), puis `node_modules` lié pour chaque paquet |
| `turbo run build` | Chaque tâche s'exécute, sauf si `.turbo/cache` a été restauré ou qu'un cache distant répond |
| `turbo run test` | Pareil, sur 2 CPU avec l'`ubuntu-latest` d'un dépôt privé |

## 1. N'exécuter que ce qui a changé

D'après le [guide CI de Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci) : `turbo run build --affected` n'exécute les tâches que dans les paquets modifiés par rapport à la branche de base. Dans GitHub Actions, il lit `GITHUB_BASE_REF` sur les pull requests et `GITHUB_EVENT_PATH` sur les push. Avec un clone superficiel, chaque paquet compte comme modifié : récupérez donc l'historique :

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

`turbo query affected --packages web` indique à une tâche si elle doit s'exécuter : une tâche pour une application non touchée peut sauter son installation.

## 2. Donner à turbo un cache qui survit à la tâche

Turborepo stocke les résultats des tâches dans `.turbo/cache` [sur la machine](https://turborepo.dev/docs/crafting-your-repository/caching). La machine d'une tâche hébergée par GitHub est supprimée quand elle se termine : en CI, ce cache démarre donc vide à chaque fois. Deux façons de contourner cela, d'après le [guide GitHub Actions de Turborepo](https://turborepo.dev/docs/guides/ci-vendors/github-actions) :

- **Le Remote Caching.** Réglez `TURBO_TOKEN` et `TURBO_TEAM` (Vercel Remote Cache, ou un serveur auto-hébergé). Chaque succès de cache est un téléchargement depuis celui-ci.
- **`actions/cache` sur `.turbo`.** Clé `${{ runner.os }}-turbo-${{ github.sha }}` avec `restore-keys: ${{ runner.os }}-turbo-`. Cela enregistre une nouvelle entrée à chaque exécution, dans les 10 Go par dépôt de GitHub, avec tout ce que le dépôt met d'autre en cache.

## 3. Garder le store pnpm

`actions/setup-node` avec `cache: pnpm`, ou `actions/cache` sur `pnpm store path`, restaure le store avec une clé basée sur `pnpm-lock.yaml`. Cela ne restaure pas `node_modules` : pnpm lie donc toujours chaque paquet. La [documentation CI de pnpm](https://pnpm.io/continuous-integration) le dit clairement : la mise en cache du store ne garantit pas une installation plus rapide. En CI, pnpm passe de lui-même à `--frozen-lockfile`.

## 4. Utiliser les cœurs

turbo exécute les tâches indépendantes en parallèle et chaque outil de build ou de test lance ses propres workers : un monorepo utilise tous les cœurs qu'on lui donne. L'`ubuntu-latest` d'un dépôt privé en a 2.

## Ce que coûte chaque correctif sur les exécuteurs de GitHub

- **Le Remote Caching** est un service de plus et un jeton de plus, et chaque succès de cache traverse le réseau.
- **`actions/cache` pour `.turbo`** écrit une entrée à chaque exécution et se dispute les mêmes 10 Go que le store pnpm, les couches de Docker et les caches de chaque branche ; les entrées inutilisées pendant 7 jours disparaissent.
- **Un exécuteur plus gros**, c'est un exécuteur plus grand sur GitHub Team ou Enterprise Cloud, facturé à la minute.

## Quand le correctif est une machine qui garde son disque

La CI d'astro elle-même, son workflow inchangé, d'après [nos exécutions de vrais projets](https://skipbox.dev/fr/guides/rust-cache-slow-rust-ci) :

| | GitHub (dépôt public, 4 vCPU, 16 Go) | Machine dédiée au compte chez Skipbox (4 vCPU) |
|---|---|---|
| Tâche | 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)) |
| Tâches de build | 40 exécutées | 40 rejouées depuis le cache de turbo |
| Tâche de test | exécutée | rejouée depuis le cache de turbo |

La machine dédiée au compte a gardé le `.turbo` du checkout et le store pnpm de la tâche précédente : turbo a trouvé le résultat de chaque tâche sans rien télécharger. turbo ne rejoue une tâche que quand le hachage de ses entrées est identique : un vrai commit réexécute donc les paquets qu'il touche et rejoue le reste.

## Skipbox garde l'état du monorepo

Chaque forfait est livré avec la machine dédiée à votre compte, conservée entre les tâches :

- **Le store pnpm reste** dans `~/.local/share/pnpm/store`, avec le cache de npm et le `~/.cache` de chaque outil. `pnpm install` lie depuis le disque au lieu de télécharger.
- **Le cache de turbo reste.** Le `.turbo` de premier niveau du checkout est conservé entre les tâches quand `turbo.json` est au format turbo 2 : une clé `tasks`, pas de `pipeline`, et pas de `"envMode": "loose"`. Aucun `TURBO_TOKEN`, aucune étape de cache.
- **`node_modules` est supprimé après chaque tâche** : une matrice de versions de Node qui partage un checkout ne charge jamais un addon natif compilé pour un autre Node.
- **Les outils restent :** les versions de Node installées par `setup-node`, pnpm lui-même, les images et les couches de Docker.

Au moins 7× l'espace de cache de GitHub sur S. Une tâche choisit sa taille par le label :

| Label | Machine | Forfait |
|---|---|---|
| `skipbox` | 4 vCPU · 16 Go | S, $39 par mois |
| `skipbox-8x16` | 8 vCPU · 16 Go | M, $79 par mois |
| `skipbox-16x32` | 16 vCPU · 32 Go | L, $149 par mois |

Les minutes sont illimitées. À 20 000 minutes par mois sur 4 vCPU, GitHub facture $222 ; Skipbox S coûte $39, soit $183 de moins.

## Le passage tient en une ligne

```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. Connectez-vous à Skipbox avec GitHub.
2. Installez l'application GitHub Skipbox et choisissez les dépôts.
3. Modifiez `runs-on` et faites un push.

Gardez les étapes de cache telles quelles ; ce qu'elles enregistrent reste à côté de la machine.

## Sécurité

- La machine appartient à votre seul compte. Aucune tâche d'une autre entreprise n'y tourne.
- Après chaque tâche, les identifiants de l'exécuteur, ses processus et ses conteneurs sont effacés, ainsi que les identifiants git, les hooks et les fichiers non suivis du checkout conservé. « Nouvelle VM pour chaque tâche » donne plutôt une nouvelle machine à chaque tâche.
- Le code des personnes sans accès en écriture (comme les pull requests venant de forks) s'exécute sur une nouvelle VM qui lit vos caches sans pouvoir les modifier.

Les détails sont dans [Comment les tâches sont isolées](https://docs.skipbox.dev/fr/isolation).

## Essayez-le sur le monorepo

L'essai est gratuit pendant 7 jours ou 3 000 minutes de tâches, selon ce qui arrive en premier, et ne demande pas de carte. Passez la tâche de build sur `runs-on: skipbox`, exécutez-la deux fois, et mettez les lignes d'installation et de turbo de la deuxième exécution (`cached` contre `executing`) à côté de celles de GitHub.

## FAQ

### Comment accélérer un grand monorepo pnpm/Turborepo dans GitHub Actions ?

Trois choses, dans l'ordre. N'exécutez que ce qui a changé : turbo run build --affected, avec un checkout qui a l'historique (fetch-depth: 0 et filter: blob:none). Donnez à turbo un cache qui survit à la tâche : le Remote Cache de Turborepo, ou .turbo restauré avec actions/cache. Et gardez le store pnpm : cache: pnpm de setup-node ou actions/cache sur le chemin du store. Sur les VM neuves de GitHub, chacun de ces éléments est un téléchargement à chaque tâche ; sur une machine qui garde son disque, ils sont déjà là. La CI d'astro prenait 528 s sur GitHub et 30 s sur une machine dédiée au compte chez Skipbox, qui garde le cache de turbo et le store pnpm.

### Pourquoi pnpm install est-il lent dans GitHub Actions même avec le store en cache ?

Parce qu'un store restauré reste une archive téléchargée et décompressée sur une nouvelle VM, et pnpm lie ensuite node_modules pour chaque paquet de l'espace de travail. La documentation CI de pnpm elle-même indique que la mise en cache du store ne garantit pas une installation plus rapide. Un store déjà présent sur le disque de la machine évite le téléchargement ; il ne reste que la liaison.

### Le cache de Turborepo fonctionne-t-il dans GitHub Actions ?

Seulement si le cache survit à la tâche. Turborepo garde les résultats des tâches dans .turbo/cache sur la machine, et la machine d'une tâche hébergée par GitHub disparaît quand elle se termine. La CI a donc besoin du Remote Caching (TURBO_TOKEN et TURBO_TEAM, celui de Vercel ou un serveur auto-hébergé) ou d'une étape actions/cache pour .turbo. Sur une machine dédiée au compte chez Skipbox, le .turbo du checkout reste entre les tâches pour les projets turbo 2 : turbo rejoue donc les tâches inchangées sans cache distant.

### turbo --affected fonctionne-t-il dans GitHub Actions ?

Oui. Turborepo lit GITHUB_BASE_REF sur les pull requests, et GITHUB_EVENT_PATH sur les push, pour trouver la base de comparaison. Il a besoin de l'historique : avec un clone superficiel, chaque paquet compte comme modifié. Réglez fetch-depth: 0 et filter: blob:none sur actions/checkout.

### Que garde Skipbox pour un monorepo Turborepo ?

Le store pnpm, les caches de npm et de chaque outil, les outils qu'installe setup-node, les couches de Docker, et le checkout avec son .turbo de premier niveau quand turbo.json est au format turbo 2 (une clé tasks, pas de pipeline, pas d'envMode loose). node_modules est supprimé après chaque tâche : l'installation s'exécute donc, à partir du store sur le disque. turbo ne rejoue une tâche que quand le hachage de ses entrées est identique : un commit réexécute donc ce qu'il touche.

### Combien coûte l'essai ?

Rien. L'essai dure 7 jours ou 3 000 minutes de tâches, selon ce qui arrive en premier, sans carte. Passez la tâche de build du monorepo sur runs-on: skipbox, exécutez-la deux fois, et comparez les étapes d'installation et de turbo de la deuxième exécution avec celles de GitHub.

Mis à jour le 2026-11-19 · https://skipbox.dev/fr/guides/pnpm-turborepo-monorepo-github-actions
