Limite de taille du cache GitHub Actions : pourquoi votre cache est évincé, lent à restaurer ou introuvable
GitHub Actions donne à chaque dépôt 10 Go de cache. Une fois la limite dépassée, GitHub enregistre quand même la nouvelle entrée et supprime les entrées lues le moins récemment jusqu'à repasser sous la limite, et il supprime toute entrée qu'aucune tâche n'a lue depuis 7 jours. Une branche ne lit que ses propres caches et ceux de la branche par défaut : la première exécution d'une nouvelle branche rate donc souvent le cache. Et un cache trouvé reste un téléchargement : chaque tâche sur un exécuteur hébergé par GitHub démarre sur une nouvelle VM, et retélécharge et décompresse l'archive. Vous pouvez augmenter la limite, à 0,07 $US par Go et par mois au-delà de 10 Go, et régler vos clés, mais le téléchargement reste.
Skipbox supprime le téléchargement. Vos tâches s'exécutent sur une machine que Skipbox héberge pour votre seul compte, conservée entre les tâches : les caches npm, pnpm, Gradle, Go et Cargo et les couches Docker sont toujours sur son disque depuis la dernière tâche (80 Go sur S, contre 14 Go sur l'exécuteur de GitHub). Ce qu'enregistre actions/cache reste à côté de la machine : une restauration est une lecture locale. Modifiez une ligne, runs-on: skipbox, pour un prix fixe de $39 par mois avec des minutes illimitées.
Les règles du cache de GitHub
D'après la référence du cache des dépendances de GitHub, la facturation d'Actions et son changelog sur les caches au-delà de 10 Go :
| Règle | Ce que fait GitHub |
|---|---|
| Taille | 10 Go par dépôt par défaut, partagés par toutes les branches et tous les workflows |
| Au-delà de la taille | Enregistre la nouvelle entrée, puis supprime des entrées selon leur dernier accès, les plus anciennes d'abord, jusqu'à repasser sous la limite. L'éviction tourne toutes les heures |
| Entrées inutilisées | Supprime toute entrée non lue depuis plus de 7 jours |
| Une limite plus haute | Sur un compte Pro, Team ou Enterprise, les administrateurs peuvent augmenter la taille et le nombre de jours. Au-delà de 10 Go, 0,07 $US par Go et par mois, au pic de chaque heure. Un budget atteint fait passer le cache en lecture seule jusqu'au cycle de facturation suivant |
| Branches | Une exécution restaure les caches de sa branche et de la branche par défaut ; celle d'une pull request aussi ceux de sa branche de base. Jamais ceux d'une branche voisine ou enfant |
| Pull requests | Les caches d'une pull request sont limités à sa merge ref : seules les relances de cette pull request les lisent |
| Entrées | Ne peuvent pas être modifiées. Une clé qui existe déjà n'est pas réenregistrée |
| Succès | cache-hit vaut true seulement pour une correspondance exacte de key ; une correspondance restore-keys vaut false |
| Débit | Jusqu'à 200 envois et 1 500 téléchargements par minute et par dépôt |
Pourquoi le cache est évincé
Les mêmes 10 Go contiennent tout ce que le dépôt enregistre. Chaque branche et chaque pull request enregistre ses propres entrées. Une matrice de trois versions de Node sur deux systèmes d'exploitation en enregistre six. Le cache de build type=gha de Docker atterrit dans les mêmes 10 Go. Quand les enregistrements d'une journée dépassent la limite, chaque nouvel enregistrement supprime une entrée plus ancienne, souvent celle dont la tâche suivante a besoin. GitHub appelle cela le cache thrashing.
Pour voir ce qui le remplit, listez les entrées par taille :
gh cache list --sort size_in_bytes --limit 20
La page Actions › Caches du dépôt affiche la même chose, avec la branche et la dernière utilisation de chaque entrée.
Pourquoi la restauration est lente
Un cache trouvé sur un exécuteur hébergé par GitHub, c'est un téléchargement sur une nouvelle VM, puis une décompression. Sa durée grandit avec l'archive : un cache qui a grossi jusqu'à plusieurs Go peut prendre autant de temps que l'installation qu'il devait éviter. Un téléchargement bloqué est interrompu par le délai de segment d'actions/cache, 10 minutes par défaut (SEGMENT_DOWNLOAD_TIMEOUT_MINS).
La plupart des configurations restaurent aussi moins qu'on ne le croit. L'entrée cache: de setup-node enregistre le cache de téléchargement du gestionnaire de paquets, pas node_modules : après la restauration, npm ci réinstalle tous les paquets. Le cache pip de setup-python fonctionne pareil : les téléchargements reviennent, l'environnement est réinstallé.
Pourquoi le cache rate
- La clé a changé. Une clé avec
hashFiles('**/package-lock.json')rate à chaque modification du lockfile.restore-keysdonne une correspondance partielle, etcache-hitvaut alorsfalse. - Une nouvelle branche. Elle peut lire les caches de la branche par défaut, pas ceux d'une autre branche de fonctionnalité. Si la branche par défaut n'a jamais exécuté le workflow, il n'y a rien à lire.
- Évincé. La limite ou les 7 jours l'ont emporté.
- Jamais enregistré. Les entrées ne peuvent pas être modifiées : une clé qui existe n'est jamais réenregistrée, et le contenu en cache reste aussi ancien que son premier enregistrement. Une pull request venant d'un fork n'a parfois pas le droit d'enregistrer du tout.
Passer des fichiers à la tâche suivante de la même exécution relève d'un autre outil. Le cache sert à l'exécution suivante ; la sortie de build dont a besoin une tâche ultérieure du même workflow passe par actions/upload-artifact et actions/download-artifact. Les artefacts ont leur propre stockage, à part des 10 Go, et c'est aussi un téléchargement sur une nouvelle VM.
Ce que coûte chaque correction sur les exécuteurs de GitHub
- Augmenter la limite. Moins d'évictions, à 0,07 $US par Go et par mois au-delà de 10 Go (l'exemple de GitHub lui-même : 200 Go entièrement utilisés coûtent 13,30 $US par mois), sur un compte Pro, Team ou Enterprise. Les restaurations restent des téléchargements, et les caches plus gros sont plus longs à télécharger.
- Enregistrer moins. Mettez en cache
~/.npmou le store pnpm, pasnode_modulesni la sortie de build. N'enregistrez que sur la branche par défaut, avecactions/cache/restoredans chaque tâche etactions/cache/savedans une seule. Cela vous coûte du temps, et un cache plus petit restaure moins. - Corriger les clés. Basez la clé sur le lockfile, ajoutez
restore-keys, et exécutez le workflow sur les push vers la branche par défaut pour que les nouvelles branches aient quelque chose à lire. - Un exécuteur auto-hébergé qui garde son disque. Pas de téléchargement, pas de limite à 10 Go. C'est vous qui faites tourner la machine : mises à jour de l'OS, nettoyage entre les tâches sans supprimer les caches, et réparation quand elle tombe en panne.
Quand la solution est une machine qui garde son disque
Le cache existe parce que la machine oublie. Un exécuteur hébergé par GitHub est une nouvelle VM pour chaque tâche : la tâche enregistre donc son état dans le stockage de GitHub et le récupère la fois suivante. Sur une machine qui reste, cet état est déjà sur son disque : le cache du gestionnaire de paquets, le cache d'outils, les images et le cache de build de Docker, et même la sortie de build.
La différence se voit dans la CI de vrais projets, d'après nos exécutions de leurs propres tâches :
- astro (Node.js, Turborepo) : 528 s sur GitHub, 30 s sur une machine dédiée Skipbox, qui garde le cache de turbo : ses exécutions à chaud rejouent 40 tâches de build au lieu de les exécuter.
- helix (Rust) : l'étape chaîne d'outils et cache prenait 9-10 s sur la machine dédiée, contre 41-46 s sur GitHub.
- tauri (Rust) : 246 s sur GitHub, 53 s sur la machine dédiée, avec
target/gardé entre les tâches.
Skipbox garde le cache sur votre machine
Chaque forfait comprend la machine dédiée à votre compte, conservée entre les tâches :
- Les caches de paquets restent sur le disque :
~/.npm, le store pnpm, le~/.cachede chaque outil, et les caches Go, Gradle, Cargo et Maven, avec les outils installés parsetup-*. Rien à restaurer. - Les images, les couches et le cache de build de Docker restent aussi.
docker buildréutilise les couches du dernier build (cache de couches Docker). - **actions/cache, setup-* et rust-cache ne demandent aucune modification.** Ce qu'ils enregistrent reste à côté de la machine plutôt que dans le stockage de GitHub, avec plus de place que les 10 Go par dépôt de GitHub, et une restauration le lit localement.
- Pas d'expiration à 7 jours sur le disque. Rien n'est supprimé tant que le disque n'est pas presque plein après une tâche ; ensuite, ce qui a été utilisé le moins récemment part en premier.
Au moins 7× l'espace de cache de GitHub sur S. Une tâche choisit sa taille par son label :
| Label | Machine | Disque | Forfait |
|---|---|---|---|
skipbox | 4 vCPU · 16 Go | 80 Go | S, $39 par mois |
skipbox-8x16 | 8 vCPU · 16 Go | 160 Go | M, $79 par mois |
skipbox-16x32 | 16 vCPU · 32 Go | 320 Go | L, $149 par mois |
L'ubuntu-latest d'un dépôt privé a 2 CPU, 8 Go et 14 Go de SSD. Les minutes sont illimitées sur Skipbox. À 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:
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
- Connectez-vous à Skipbox avec GitHub.
- Installez l'application GitHub Skipbox et choisissez les dépôts.
- Modifiez
runs-onet faites un push.
Gardez vos étapes de cache telles quelles. La deuxième exécution trouve les caches de la première sur 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. « 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 la tâche dont le cache rate
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 cette tâche sur runs-on: skipbox, exécutez-la deux fois et comparez les étapes de restauration et d'installation de la deuxième exécution avec celles de GitHub.
FAQ
Quelle est la limite de taille du cache GitHub Actions ?
10 Go par dépôt par défaut, pour toutes les branches et tous les workflows ensemble. Au-delà, GitHub enregistre quand même la nouvelle entrée et supprime des entrées dans l'ordre du dernier accès, les plus anciennes d'abord, jusqu'à repasser sous la limite. Les entrées qu'aucune tâche n'a lues depuis 7 jours sont supprimées quelle que soit la taille. Sur un compte Pro, Team ou Enterprise, les administrateurs peuvent augmenter la limite et le nombre de jours ; le stockage au-delà de 10 Go est facturé 0,07 $US par Go et par mois, mesuré au pic de chaque heure, et une fois un budget atteint, le cache passe en lecture seule jusqu'au cycle de facturation suivant.
Pourquoi mon cache GitHub Actions est-il évincé si souvent ?
Parce que tout le dépôt partage les mêmes 10 Go : chaque branche, chaque pull request, chaque tâche de matrice et chaque OS enregistre ses propres entrées, et le cache type=gha de Docker atterrit au même endroit. Quand les enregistrements d'une journée dépassent la limite, chaque enregistrement supprime une entrée plus ancienne, et la tâche suivante ne trouve pas celle dont elle avait besoin. GitHub appelle cela le cache thrashing. Listez les entrées par taille (gh cache list --sort size_in_bytes) pour voir ce qui le remplit.
Pourquoi la restauration du cache prend-elle autant de temps qu'une installation complète ?
Parce qu'un cache trouvé reste un téléchargement. Chaque tâche sur un exécuteur hébergé par GitHub démarre sur une nouvelle VM : actions/cache télécharge l'archive et la décompresse à chaque fois, et plus le cache est gros, plus c'est long. Le cache de setup-node ramène le cache de téléchargement du gestionnaire de paquets, pas node_modules : npm ci réinstalle donc tous les paquets après la restauration. Sur un exécuteur qui garde son disque, les caches sont déjà là et rien n'est téléchargé.
Pourquoi actions/cache ne trouve-t-il rien sur une nouvelle branche ?
Une exécution peut restaurer les caches de sa propre branche et de la branche par défaut, et celle d'une pull request aussi ceux de sa branche de base. Elle ne peut pas lire les caches d'une branche voisine. La première exécution d'une branche de fonctionnalité ne trouve donc le cache que si la branche par défaut a enregistré cette clé. Exécutez le workflow sur les push vers la branche par défaut pour qu'il enregistre, et ajoutez des restore-keys pour une correspondance partielle ; cache-hit ne vaut true que pour une correspondance exacte de key.
Combien de cache Actions Skipbox garde-t-il ?
Plus que les 10 Go par dépôt de GitHub, à côté de votre machine plutôt que dans le stockage de GitHub. Sur une machine cloud, ce que les tâches enregistrent avec actions/cache, setup-* et rust-cache reste sur le disque de la machine, jusqu'à la moitié de ce disque (80 Go sur S, 160 Go sur M, 320 Go sur L) ; sur un hôte Skipbox, le cache de l'hôte garde 20 Go par dépôt. Dans les deux cas, une entrée est gardée 7 jours après sa dernière utilisation, avec les règles de branches de GitHub. Les caches de paquets et les couches Docker n'y passent pas : ils restent sur le disque lui-même.
Qu'est-ce qui vide les caches d'une machine Skipbox ?
Rien entre les tâches : les caches restent sur la machine, et c'est seulement quand une tâche laisse le disque presque plein que ce qui a été utilisé le moins récemment part en premier. La machine repart à neuf lors d'une réinitialisation : quand vous appuyez sur Réinitialiser la machine, quand son image est mise à jour (au moins une fois par mois), quand elle échoue à son contrôle d'intégrité après une tâche, et quand une tâche atteint la limite de 6 heures. La machine est supprimée avec son disque à la fin du forfait.
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 dont le cache rate ou se restaure lentement sur runs-on: skipbox, exécutez-la deux fois et comparez les étapes de restauration et d'installation de la deuxième exécution avec celles de GitHub.
Mis à jour le 19 novembre 2026