# Comment accélérer GitHub Actions : réduire un pipeline de 25 minutes, levier par levier

> Un pipeline GitHub Actions lent, ce sont des tâches qui s'attendent les unes les autres, du travail qui n'avait pas besoin de tourner, une préparation répétée sur une VM vierge, et des étapes limitées par le CPU sur 2 cœurs. Corrigez-les dans cet ordre. Les deux derniers points relèvent de la machine : Skipbox garde vos caches sur votre machine dédiée entre les tâches, avec jusqu'à 16 vCPU, pour un prix fixe de $39 par mois avec des minutes illimitées.

Un pipeline GitHub Actions de 25 minutes, ce sont généralement quatre retards empilés : des tâches qui s'attendent les unes les autres, du travail qui n'avait pas besoin de tourner, une préparation qu'une VM vierge répète à chaque tâche, et des étapes limitées par le CPU entassées sur 2 cœurs (l'`ubuntu-latest` d'un dépôt privé a 2 CPU et 8 Go). Prenez-les dans cet ordre. D'abord, mesurez le chemin critique, en mettant le temps d'attente à part. Ensuite, sautez ce qui n'avait pas besoin de tourner, exécutez les tâches indépendantes en même temps, arrêtez de reconstruire l'état, donnez plus de cœurs aux étapes lourdes, et découpez en shards ce qui reste long. Les trois premiers points sont des corrections de workflow qui ne coûtent rien. Le reste relève de la machine : un exécuteur qui garde ses caches entre les tâches et a plus de cœurs.

Skipbox est cet exécuteur. Vos tâches tournent sur la machine dédiée à votre compte, qui garde les couches Docker, les caches de paquets, les outils et la sortie de build entre les tâches, avec 4 à 16 vCPU, pour un prix fixe de $39 par mois avec des minutes illimitées. Sur la CI d'astro, cela faisait 528 s sur GitHub et 30 s sur Skipbox. Le passage tient en une ligne : `runs-on: skipbox`.

- Les leviers dans l'ordre : mesurer, sauter, paralléliser, arrêter de reconstruire, ajouter des cœurs, découper
- Votre machine dédiée garde les caches et la sortie de build entre les tâches : la CI d'astro est passée de 528 s à 30 s
- 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-speed-up-github-actions-fr)

## 1. Mesurer le chemin critique

Le temps que votre équipe attend, c'est la chaîne de tâches qui se termine en dernier, pas la somme de toutes les tâches. Ouvrez l'exécution d'une pull request représentative : le graphe montre quelles tâches en attendent d'autres, et le log de chaque tâche montre les durées de ses étapes. Notez, pour la chaîne la plus lente :

| Phase | Ce qu'il faut vérifier |
|---|---|
| En file d'attente | La tâche a-t-elle attendu un exécuteur ? Une commande plus rapide ne raccourcit pas une file d'attente |
| Set up job, checkout | Une image de conteneur téléchargée, un clone complet là où un clone superficiel suffirait |
| Chaîne d'outils et installation | Le cache a-t-il servi, et ce succès a-t-il fait gagner plus que la restauration n'a pris ? |
| Build | La même sortie est-elle construite dans une autre tâche ? |
| Tests | Le CPU de l'exécuteur est-il occupé en permanence, ou un seul worker fait-il tout ? |
| Téléversements | Artefacts et enregistrements de cache après la fin du travail utile |

Comparez une exécution à chaud avec une exécution à froid. Un cache qui rate une fois sur deux a l'air correct dans une moyenne.

## 2. Sauter ce qui n'avait pas besoin de tourner

- **Annulez les exécutions remplacées.** Chaque push après le premier rend inutile l'exécution en cours. Un [groupe concurrency](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) avec `cancel-in-progress` l'arrête. Limitez-le aux pull requests pour qu'un push sur la branche par défaut n'annule jamais un déploiement :

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
```

- **N'exécutez que ce que la modification touche.** Les filtres `paths:` sautent un workflow pour les modifications qui ne touchent que la documentation ; dans un monorepo, `turbo run test --affected` ou les commandes affected de Nx n'exécutent que les paquets modifiés. Un filtre au niveau du déclencheur signifie qu'une vérification obligatoire ne rend jamais de résultat : filtrez donc à l'intérieur de la tâche quand la vérification est obligatoire.

## 3. Exécuter les tâches indépendantes en même temps

GitHub exécute les tâches en parallèle sauf si `needs:` les enchaîne. Le lint, les vérifications de types, les tests unitaires et le build ont rarement besoin les uns des autres : lancez-les ensemble et ne faites attendre que le packaging ou le déploiement. Si deux tâches construisent la même chose, construisez-la une fois et transmettez-la avec `actions/upload-artifact`, en chronométrant le téléversement et le téléchargement.

## 4. Arrêter de reconstruire le même état

C'est là que part l'essentiel d'un long pipeline. Chaque tâche sur un exécuteur hébergé par GitHub démarre sur une nouvelle VM : elle télécharge sa chaîne d'outils, installe les dépendances, reconstruit les couches Docker et compile à partir de zéro, à chaque fois.

- **Des caches qui servent vraiment.** Le `cache: npm` d'`actions/setup-node` (et ses variantes pnpm et yarn) enregistre les téléchargements du gestionnaire de paquets avec une clé basée sur le lockfile ; il n'enregistre pas `node_modules`, donc l'installation tourne toujours. GitHub garde 10 Go par dépôt, retire les entrées inutilisées pendant 7 jours, et un succès de cache reste un téléchargement sur la nouvelle VM ([limite de taille du cache](https://skipbox.dev/fr/guides/github-actions-cache-size-limit)).
- **Les caches d'outils.** `eslint --cache`, `tsc --incremental`, le répertoire de cache de Jest et le `.turbo/cache` de turbo enregistrent le travail lui-même, pas les téléchargements. Sur une VM neuve, ils sont vides sauf si vous les restaurez aussi.
- **Les couches Docker.** `docker build` sur une VM neuve démarre sans aucune couche ; les exporter avec `cache-to` de buildx et les importer à chaque exécution est le contournement ([cache des couches Docker](https://skipbox.dev/fr/guides/docker-layer-cache-github-actions)).

Une machine qui garde son disque fait tout cela d'elle-même : les caches, les caches d'outils, les couches et la sortie de build sont là depuis la dernière tâche.

## 5. Donner plus de cœurs aux étapes lourdes

Les compilateurs, les bundlers et les outils de test lancent un worker par cœur : sur 2 CPU, ils en font tourner deux à la fois. Vérifiez ce que votre outil de test utilise réellement : [Jest](https://jestjs.io/docs/cli#--maxworkersnumstring) prend par défaut le nombre de cœurs moins un (un worker sur 2 CPU), pytest s'exécute en série jusqu'à `-n auto`, et [Playwright](https://playwright.dev/docs/ci#workers) prend par défaut la moitié des cœurs, sa documentation recommandant un seul worker en CI. Plus de cœurs n'aident qu'une fois que l'outil est configuré pour s'en servir, et seulement sur les étapes qui occupent le CPU ; un téléchargement ou le démarrage d'une base de données n'accélère pas.

Sur GitHub, plus de cœurs veut dire des [exécuteurs plus grands](https://docs.github.com/en/actions/concepts/runners/larger-runners) : de 4 à 96 cœurs, uniquement pour les organisations GitHub Team ou Enterprise Cloud, facturés à la minute à un tarif plus élevé par cœur.

## 6. Découper ce qui reste long

Une matrice de shards répartit une longue suite entre plusieurs tâches. Cela réduit la durée réelle, pas les minutes : chaque shard refait le checkout, l'installation et le build, donc quatre shards paient la préparation quatre fois. Équilibrez les shards selon le temps mesuré, pas selon le nombre de fichiers, et arrêtez d'en ajouter quand la préparation représente l'essentiel de chaque shard.

## Ce que coûte le fait de rester lent

Un pipeline de 15 minutes qui tourne 40 fois par jour, ce sont 10 heures d'attente réparties sur votre équipe, chaque jour, avant même de compter les changements de contexte. Avec une facturation à la minute, les minutes de préparation sont facturées comme les minutes de test :

| Minutes par mois (4 vCPU) | GitHub | Skipbox S | Votre économie chaque mois |
|---|---|---|---|
| 10 000 | $102 | $39 | **$63** |
| 20 000 | $222 | $39 | **$183** |
| 30 000 | $342 | $39 | **$303** |

Sur GitHub, plus de cœurs coûtent plus cher à la minute : l'écart se creuse avec la machine :

| 20 000 minutes par mois | GitHub | Skipbox | Votre économie chaque mois |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | **$343** |
| 16 vCPU | $822 | $149 (L) | **$673** |

Les montants GitHub s'entendent après l'utilisation incluse de GitHub Team. Essayez vos propres minutes dans le [calculateur de la page d'accueil](https://skipbox.dev/?ref=g-speed-up-github-actions-fr#cost).

## Quand le correctif, c'est la machine

Les tâches CI de vrais projets, étapes inchangées, sur l'exécuteur de dépôt public de GitHub (4 vCPU, 16 Go) et sur une machine dédiée au compte chez Skipbox avec les mêmes vCPU, d'après [nos exécutions de leurs workflows](https://skipbox.dev/fr/guides/rust-cache-slow-rust-ci) :

| Projet | GitHub | Skipbox, machine dédiée au compte | Ce que la machine a gardé |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | **30 s** | le cache de turbo : 40 tâches de build rejouées |
| tauri (Rust) | 246 s | **53 s** | le `target/` de Cargo : aucune crate recompilée |
| ripgrep (Rust) | 200 s | **40 s** | le `target/` et l'image Docker de cross |
| vite (Node.js) | 141 s | 100 s | les caches de paquets ; le reste, c'est l'exécution de ses tests |

L'`ubuntu-latest` d'un dépôt privé a la moitié des cœurs de ces exécutions GitHub.

## Ce que Skipbox fait pour votre pipeline

**Il garde la machine.** Chaque forfait est livré avec la machine dédiée à votre compte, conservée entre les tâches. Les images Docker, les couches et le cache de build, les caches de paquets, le cache d'outils, et votre checkout avec le `target/` de Cargo et le cache de turbo restent sur son disque : au moins 7× l'espace de cache de GitHub, sans clé, sans expiration au bout de 7 jours et sans règle de branche.

**Il ajoute des cœurs à prix fixe.** 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 : les shards, les relances et une matrice plus grande ne font pas monter la facture. Les tâches Skipbox n'utilisent aucune minute GitHub : un budget GitHub ne les arrête jamais.

**Il s'occupe de lui-même.** Skipbox provisionne la machine, tient l'image à jour, nettoie après chaque tâche et reconstruit une machine qui échoue à son contrôle d'intégrité.

## Le passage tient en une ligne

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

Vos étapes et vos actions s'exécutent telles quelles, sous Ubuntu 24.04 avec Docker, Node.js et Python.

## 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 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 votre tâche la plus lente

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 votre chemin critique sur `runs-on: skipbox`, exécutez-la deux fois, et lisez les durées des étapes de la deuxième exécution à côté de celles de GitHub.

## FAQ

### Notre pipeline GitHub Actions prend 25 minutes. Quelle est la façon la plus rapide de l'accélérer ?

Procédez dans l'ordre. Lisez le graphe de l'exécution et les durées des étapes pour trouver la chaîne de tâches qui fixe la durée, en mettant le temps d'attente à part. Annulez les exécutions remplacées et sautez les tâches dont les fichiers n'ont pas changé. Retirez les needs: qui ne traduisent qu'une habitude, pour que les tâches indépendantes tournent en même temps. Arrêtez de reconstruire l'état à chaque tâche : des caches qui servent vraiment, ou un exécuteur qui garde son disque. Donnez plus de cœurs aux étapes limitées par le CPU et laissez l'outil de test s'en servir. Ne découpez en shards que ce qui reste long. Sur l'ubuntu-latest d'un dépôt privé (2 CPU, 8 Go), les trois derniers points représentent souvent l'essentiel des 25 minutes, et ils relèvent de la machine : Skipbox donne à la tâche une machine dédiée qui garde les caches entre les tâches, avec 4 à 16 vCPU.

### Passer à des exécuteurs plus rapides vaut-il la peine par rapport à l'optimisation du workflow ?

Faites d'abord les corrections de workflow gratuites : annuler les exécutions remplacées, les filtres de chemins et le retrait des needs: inutiles ne coûtent rien, et aucun exécuteur ne les fait pour vous. Ensuite, regardez où part le temps restant. La préparation qui se répète à chaque tâche (chaînes d'outils, installation des dépendances, builds Docker) et les étapes qui occupent tous les cœurs sont le problème de la machine, et un exécuteur qui garde ses caches et a plus de cœurs les supprime en modifiant une ligne runs-on. Les attentes réseau et les étapes séquentielles n'accélèrent pas avec une machine plus grosse.

### Pourquoi GitHub Actions est-il plus lent que mon portable ?

Votre portable garde ses paquets, ses outils, ses couches Docker et sa sortie de build sur le disque, et a généralement 8 cœurs ou plus. Une tâche ubuntu-latest d'un dépôt privé reçoit 2 CPU et 8 Go, sur une nouvelle VM qui n'a rien de tout cela. Skipbox fonctionne comme votre portable : la machine reste entre les tâches, avec 4 vCPU ou plus.

### Découper les tests en shards accélère-t-il GitHub Actions ?

Cela raccourcit la durée réelle, pas les minutes. Chaque shard est une nouvelle tâche qui refait le checkout, l'installation et le build : quatre shards paient la préparation quatre fois, et la facturation à la minute les compte toutes. Découpez une fois que la préparation est bon marché et que les cœurs de l'exécuteur sont utilisés. Sur Skipbox, la préparation reste sur le disque et les minutes sont illimitées : les shards ne coûtent rien de plus.

### Comment obtenir plus de 4 cœurs pour une tâche GitHub Actions ?

Sur GitHub, les exécuteurs plus grands vont de 4 à 96 cœurs, réservés aux organisations sur GitHub Team ou Enterprise Cloud, facturés à la minute. Sur Skipbox, remplacez runs-on par skipbox-8x16 pour 8 vCPU ou skipbox-16x32 pour 16 vCPU, à prix mensuel fixe, sur les organisations comme sur les comptes personnels.

### 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. Remplacez le runs-on de votre tâche la plus lente par skipbox, exécutez-la deux fois, et comparez les durées de ses étapes.

Mis à jour le 2026-11-19 · https://skipbox.dev/fr/guides/speed-up-github-actions
