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 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.
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 : 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 :
- 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. 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 :
- Le Remote Caching. Réglez
TURBO_TOKENetTURBO_TEAM(Vercel Remote Cache, ou un serveur auto-hébergé). Chaque succès de cache est un téléchargement depuis celui-ci. actions/cachesur.turbo. Clé${{ runner.os }}-turbo-${{ github.sha }}avecrestore-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 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/cachepour.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 :
| 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, 28 s) |
| 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~/.cachede chaque outil.pnpm installlie depuis le disque au lieu de télécharger. - Le cache de turbo reste. Le
.turbode premier niveau du checkout est conservé entre les tâches quandturbo.jsonest au format turbo 2 : une clétasks, pas depipeline, et pas de"envMode": "loose". AucunTURBO_TOKEN, aucune étape de cache. node_modulesest 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
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
- Connectez-vous à Skipbox avec GitHub.
- Installez l'application GitHub Skipbox et choisissez les dépôts.
- Modifiez
runs-onet 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.
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 19 novembre 2026