# docker compose tire toutes les images à chaque tâche GitHub Actions : comment ne plus tirer les mêmes images

> Chaque tâche GitHub Actions démarre sur une nouvelle VM sans aucune image Docker : docker compose up tire donc de nouveau Postgres, Redis et toutes les autres images de service. docker save avec actions/cache ne fait que déplacer le téléchargement, dans les 10 Go de GitHub. Sur un exécuteur qui garde son disque, les images sont déjà là. Skipbox est cet exécuteur, pour un prix fixe de $39 par mois : modifiez une ligne runs-on.

`docker compose up` tire toutes les images à chaque tâche GitHub Actions parce que chaque tâche sur un exécuteur hébergé par GitHub démarre sur une nouvelle VM. Postgres, Redis, le broker de messages, vos propres images de service : aucune n'est sur le disque, et Compose les télécharge et les décompresse toutes avant le premier test. Pour ne plus tirer les mêmes images, exécutez la tâche sur une machine qui les a encore.

Skipbox est cette machine. 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. `docker compose up` trouve ce qu'il a tiré la dernière fois et démarre les conteneurs. Modifiez une ligne, `runs-on: skipbox`, pour un prix fixe de $39 par mois avec des minutes illimitées.

- GitHub : une nouvelle VM par tâche, donc chaque image de votre fichier compose est tirée de nouveau, à chaque tâche
- Skipbox : les images restent sur le disque de votre machine, et seules les couches modifiées sont téléchargées
- 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-docker-compose-pull-slow-github-actions-fr)

## Pourquoi chaque tâche tire les images

- **Une nouvelle VM par tâche.** La [référence des exécuteurs](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) de GitHub, lue le 14 novembre 2026, 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 tiré n'y figure.
- **Compose tire ce qui manque.** Le [`pull_policy`](https://docs.docker.com/reference/compose-file/services/) par défaut est `missing` : Compose ne tire l'image que si elle n'est pas disponible dans le cache de la plateforme. Sur une nouvelle VM, toutes les images manquent.
- **Tirer, c'est télécharger et décompresser.** Chaque couche est téléchargée, décompressée et écrite sur le disque de la VM. L'`ubuntu-latest` d'un dépôt privé dispose pour cela de 2 CPU et de 14 Go de SSD.

Le temps avant votre premier test, c'est donc la taille de votre fichier compose, payée en entier à chaque push.

## Ce que vous pouvez faire sur un exécuteur hébergé par GitHub

Les options déplacent le téléchargement ; aucune ne le supprime.

| Option | Ce que chaque tâche fait encore | Limite |
|---|---|---|
| `docker save` + actions/cache + `docker load` | Télécharge l'archive, puis charge chaque image dans Docker | Compte dans les 10 Go par dépôt de GitHub, partagés avec tous les autres caches |
| Des images plus petites (`-alpine`, `-slim`) | Les tire toutes, plus vite | Seulement dans la mesure où chaque image a une petite variante |
| Moins de services par tâche | Tire moins d'images | Les tests qui ont besoin de toute la stack la tirent quand même |

Chacune est une façon de faire oublier un peu moins une machine qui oublie tout. Le téléchargement ne disparaît que quand la machine se souvient.

## Skipbox garde les images sur votre machine

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

- **Les images restent sur le disque.** `docker compose up` trouve les images tirées la dernière fois et passe directement au démarrage des conteneurs.
- **Seules les modifications sont téléchargées.** `docker compose pull` récupère les couches qui ont changé et réutilise le reste.
- **Vos propres images de service se construisent depuis le cache.** `docker compose build` réutilise les couches du dernier build, sans `cache-from` ni `cache-to`.
- **Un départ propre à chaque tâche.** Après chaque tâche, Skipbox supprime tous les conteneurs et efface la connexion au registre (`~/.docker/config.json`). La tâche suivante démarre ses services à neuf, à partir d'images déjà sur le disque.
- **De la place pour elles.** Le disque fait 80 Go sur S, contre 14 Go sur l'exécuteur de GitHub. 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é.

Le workflow ne change pas, à part son `runs-on` :

```yaml
jobs:
  integration:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: docker compose up -d --wait
      - run: npm ci && npm run test:integration
```

Si vous sauvegardiez les images avec actions/cache et `docker load`, supprimez ces étapes. La première tâche sur Skipbox tire chaque image une fois. La deuxième les trouve sur la machine.

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 |

## Les mêmes minutes, à prix fixe

Les tests d'intégration sont les tâches longues : ce sont elles qui font grossir une facture à la minute. Sur Skipbox, les minutes sont illimitées :

| 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** |

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

## 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` sur la tâche de tests d'intégration et faites un push.

Vous construisez des images dans le même workflow ? [Le cache de couches Docker dans GitHub Actions](https://skipbox.dev/fr/guides/docker-layer-cache-github-actions) couvre `docker build` et buildx.

## 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](https://docs.skipbox.dev/fr/isolation).

## Essayez-le sur vos tests d'intégration

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 sur `runs-on: skipbox`, exécutez-la deux fois et comparez le `docker compose up` de la deuxième exécution avec celui de GitHub.

## FAQ

### Nos tests d'intégration basés sur docker compose dans GitHub Actions passent l'essentiel de leur temps à tirer des images. Comment éviter de tirer les mêmes images à chaque tâche ?

Exécutez la tâche sur une machine qui garde son disque. Un exécuteur hébergé par GitHub est une nouvelle VM pour chaque tâche : aucune image ne survit et compose les tire toutes de nouveau. Sur Skipbox, la tâche s'exécute sur la machine dédiée à votre compte, qui garde les images Docker entre les tâches : docker compose up trouve les images tirées la dernière fois et démarre les conteneurs. La modification tient en une ligne, runs-on: skipbox, pour un prix fixe de $39 par mois avec des minutes illimitées.

### Pourquoi docker compose tire-t-il de nouveau les images à chaque tâche GitHub Actions ?

Parce que Compose tire une image quand elle n'est pas sur la machine, et sur un exécuteur hébergé par GitHub, elle n'y est jamais. La référence des exécuteurs de GitHub indique que chaque exécuteur hébergé par GitHub est une nouvelle machine virtuelle ; rien de ce que la tâche précédente a tiré n'y figure. Le pull_policy par défaut de Compose, missing, sauterait le téléchargement si l'image était là.

### Puis-je mettre en cache les images docker compose avec actions/cache ?

Oui, mais cela ne fait que déplacer le téléchargement. docker save écrit les images dans un fichier tar, actions/cache le stocke, et la tâche suivante le restaure et lance docker load. Chaque tâche télécharge toujours toute l'archive et la charge dans Docker, et l'archive compte dans les 10 Go de cache par dépôt de GitHub, partagés avec vos caches de dépendances. Sur une machine qui garde son disque, il n'y a rien à sauvegarder ni à charger.

### Skipbox garde-t-il les images Docker entre les tâches ?

Oui. Chaque forfait comprend la machine dédiée à votre compte, conservée entre les tâches, qui garde les images, les couches et le cache de build de Docker sur son disque : 80 Go sur S, 160 Go sur M et 320 Go sur L. Après chaque tâche, les conteneurs sont supprimés et la connexion au registre est effacée ; les images restent.

### Que se passe-t-il quand une image de mon fichier compose change ?

Seules les couches qui ont changé sont téléchargées. Ajoutez docker compose pull avant docker compose up si vous voulez que chaque tâche vérifie le registre : Docker récupère les nouvelles couches et réutilise celles déjà sur le disque de la machine. Les images que vous construisez vous-même avec docker compose build réutilisent de la même façon les couches du dernier build.

### 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 tâche de tests d'intégration sur runs-on: skipbox, exécutez-la deux fois et comparez le docker compose up de la deuxième exécution avec celui de GitHub.

Mis à jour le 2026-11-19 · https://skipbox.dev/fr/guides/docker-compose-pull-slow-github-actions
