Skipbox

Cache de couches Docker dans GitHub Actions : pourquoi chaque build démarre à froid, et comment garder les couches

Le cache de couches Docker est perdu à chaque exécution GitHub Actions parce que chaque tâche sur un exécuteur hébergé par GitHub démarre sur une nouvelle VM : pas de cache de build, pas d'images tirées. Le builder par défaut de docker/setup-buildx-action (docker-container) démarre lui aussi vide à chaque tâche et est supprimé à la fin. La solution habituelle est d'exporter le cache avec buildx. cache-to: type=gha,mode=max et cache-from: type=gha gardent les couches dans le cache Actions de GitHub, 10 Go par dépôt partagés avec tous les autres caches ; type=registry les garde dans votre registre ; type=local dans un répertoire que vous sauvegardez avec actions/cache. Chacun transforme une reconstruction en un envoi et un téléchargement à chaque exécution.

Skipbox garde les couches là où le build tourne. Vos tâches s'exécutent sur la machine dédiée à votre compte, qui garde les images, les couches et le cache de build de Docker entre les tâches, sur un disque de 80 Go sur S contre 14 Go sur l'exécuteur de GitHub. docker build et docker compose build réutilisent les couches du dernier build, et les images tirées par compose sont déjà sur le disque. setup-buildx-action fonctionne tel quel, et son builder retrouve lui aussi ces couches. Modifiez une ligne, runs-on: skipbox, pour un prix fixe de $39 par mois avec des minutes illimitées.

Pourquoi chaque build démarre à froid

  • Une nouvelle VM par tâche. La référence des exécuteurs de GitHub indique que chaque exécuteur hébergé par GitHub est une nouvelle machine virtuelle (VM) hébergée par GitHub. Rien de ce que la tâche précédente a construit ou tiré n'y figure.
  • Un builder vide. docker/setup-buildx-action crée et démarre par défaut un builder avec le driver docker-container, et son cleanup (activé par défaut) supprime le builder à la fin de la tâche.
  • 14 Go de disque. L'ubuntu-latest d'un dépôt privé a 2 CPU, 8 Go et 14 Go de SSD. Une grosse image, son cache de build et une archive de cache à décompresser peuvent manquer de place (« no space left on device »).

Les backends de cache de buildx, et ce que coûte chacun

D'après les backends de cache de Docker et sa gestion du cache avec GitHub Actions :

Quel que soit le backend choisi, ordonnez le Dockerfile pour que les couches qui changent le moins viennent en premier : copiez le lockfile et installez les dépendances avant de copier les sources. Sinon, chaque commit invalide la couche d'installation, et aucun cache ne la ramène.

mode=min, le mode par défaut, ne garde que les couches de l'image finale. mode=max garde les couches de chaque étape : un build multi-étapes trouve plus de couches en cache, et en envoie davantage.

Une configuration type=gha typique, avec un scope propre à chaque image :

- uses: docker/setup-buildx-action@v4
- uses: docker/build-push-action@v7
  with:
    context: .
    tags: app:ci
    load: true
    cache-from: type=gha,scope=app
    cache-to: type=gha,scope=app,mode=max

Les cache mounts ne survivent pas. RUN --mount=type=cache (le cache d'un gestionnaire de paquets à l'intérieur du build) n'est pas gardé par défaut dans le cache GitHub Actions ; la documentation de Docker renvoie vers buildkit-cache-dance pour le faire entrer dans actions/cache et l'en faire sortir, un téléchargement et un envoi de plus par exécution.

docker compose tire toutes les images, à chaque tâche

Les tests d'intégration qui démarrent Postgres, Redis et quelques services avec docker compose up tirent toutes les images à chaque tâche, car la VM est neuve. Sur les exécuteurs hébergés par GitHub, les options ne font que déplacer le téléchargement :

  • docker save des images dans un fichier tar, mise en cache avec actions/cache, et docker load dans la tâche suivante. Cela compte dans les 10 Go, et le chargement prend lui-même du temps.
  • Construire les images de service avec buildx et l'un des backends de cache ci-dessus, ce qui laisse quand même les images de base à tirer.

Quand la solution est une machine qui garde le cache de Docker

Chacun des backends ci-dessus existe parce que le builder oublie. Un démon Docker qui reste entre les tâches a déjà les couches du dernier build, ses cache mounts et chaque image qu'il a tirée, sur son propre disque. Rien à exporter, rien à importer, et pas de 10 Go à partager.

Skipbox garde le cache de Docker sur votre machine

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

  • docker build et docker compose build réutilisent les couches du dernier build, sans modifier le workflow.
  • Les images restent sur le disque. docker compose up trouve les images tirées la dernière fois ; docker compose pull ne récupère que les couches qui ont changé.
  • Les cache mounts restent avec le cache de build de Docker : RUN --mount=type=cache garde le cache du gestionnaire de paquets sans étape supplémentaire.
  • docker/setup-buildx-action fonctionne tel quel. Son builder démarre sur les couches que le dernier build de votre dépôt a laissées sur la machine, et vous pouvez retirer cache-from et cache-to. Lors de notre propre exécution de la CI d'un projet public sur une machine à 4 vCPU (19 novembre 2026, une exécution à chaque fois), l'étape de build de l'image a pris 177 s à la première exécution et 4 s à la relance, avec 31 étapes CACHED.
  • Disque : rien n'est supprimé tant que le disque n'est pas presque plein après une tâche. Ensuite, les images orphelines partent en premier, puis le cache de build le moins récemment utilisé.
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/setup-buildx-action@v4
      - uses: docker/build-push-action@v7
        with:
          context: .
          tags: app:ci
          load: true

Une tâche choisit sa taille par son label :

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

  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.

La première tâche construit chaque couche. La deuxième les trouve 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, tout comme ~/.docker/config.json : une connexion au registre ne passe pas à la tâche suivante. « 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 machine jetable, jamais sur la vôtre.

Les détails sont dans Comment les tâches sont isolées.

Essayez-le sur votre build Docker

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 votre build Docker sur runs-on: skipbox, exécutez-le deux fois et comparez l'étape de build de la deuxième exécution avec celle de GitHub.

FAQ

Pourquoi le cache de couches Docker est-il perdu à chaque exécution GitHub Actions ?

Parce que chaque tâche sur un exécuteur hébergé par GitHub démarre sur une nouvelle VM, sans cache de build ni image de la dernière exécution. docker/setup-buildx-action en rajoute : par défaut, il crée un builder docker-container qui démarre vide et est supprimé à la fin de la tâche. Chaque couche est donc reconstruite, sauf si vous exportez le cache avec cache-to et l'importez avec cache-from, ou si vous tournez sur une machine qui garde le cache de build de Docker.

Comment mettre en cache les couches Docker dans GitHub Actions ?

Sur les exécuteurs hébergés par GitHub, avec les exporteurs de cache de buildx : cache-from: type=gha et cache-to: type=gha,mode=max dans docker/build-push-action stockent les couches dans le cache Actions de GitHub (10 Go par dépôt, partagés avec tous les autres caches). type=registry les stocke comme une image à part dans votre registre, et type=local dans un répertoire que vous sauvegardez avec actions/cache. Donnez à chaque image son propre scope avec type=gha, car le scope par défaut est écrasé par chaque build. Sur une machine qui garde son disque, docker build réutilise les couches sans aucun exporteur.

Pourquoi buildx avec cache-to type=gha reste-t-il lent ?

Parce que les couches voyagent toujours. Avec mode=max, chaque exécution envoie chaque nouvelle couche de chaque étape, et une exécution suivante télécharge les couches dont elle a besoin. Le cache partage les 10 Go par dépôt de GitHub avec tout le reste, il est donc évincé, et l'API de cache de GitHub limite le débit d'un build qui fait trop de requêtes. Un builder qui a déjà les couches sur son disque évite les deux sens.

Comment empêcher docker compose de tirer les mêmes images à chaque tâche ?

Sur un exécuteur hébergé par GitHub, c'est impossible ; on peut seulement déplacer le téléchargement : docker save des images dans un fichier tar, mise en cache avec actions/cache, et docker load dans la tâche suivante. Cela compte dans les mêmes 10 Go, et c'est un téléchargement et un chargement à chaque exécution. Sur une machine qui garde son disque, les images tirées par compose la dernière fois sont déjà là, et docker compose pull ne récupère que les couches qui ont changé.

Faut-il modifier mon workflow pour garder le cache Docker sur Skipbox ?

Seulement runs-on : la machine de votre compte garde les images, les couches et le cache de build de Docker entre les tâches. docker build et docker compose build les réutilisent, et docker/setup-buildx-action fonctionne tel quel : son builder démarre sur les couches que le dernier build de votre dépôt a laissées sur la machine. Vous pouvez retirer cache-from et cache-to.

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 votre build Docker sur runs-on: skipbox, exécutez-le deux fois et comparez l'étape de build de la deuxième exécution avec celle de GitHub.

Mis à jour le 19 novembre 2026

Une CI/CD plus rapide, avec un cache toujours chaud

Votre exécuteur toujours chaud, à prix fixe

Nous les hébergeons. Vous changez une ligne. 1/12 du coût de GitHub à pleine charge. Prix fixe : faites-le tourner toute la journée. 7× l'espace de cache de GitHub.

  • Sans carte
  • Se connecter avec GitHub
  • Résiliable à tout moment