Artifacts vs Cache : faire le bon choix

Votre workflow CI prend 8 minutes. À chaque run, il télécharge les mêmes dépendances, reconstruit les mêmes fichiers… Pourquoi recommencer à zéro alors que rien n’a changé ?

GitHub Actions propose deux mécanismes pour éviter ce gaspillage : le cache et les artifacts. Ils semblent similaires, mais ont des usages très différents. Choisir le bon mécanisme au bon moment peut diviser par deux le temps de vos workflows.

La différence en une phrase

Règle d’or

• Cache = réutiliser des fichiers entre les runs (même workflow, runs différents)
• Artifacts = partager des fichiers entre les jobs (même run, jobs différents)

Analogie : le restaurant

Imaginez un restaurant :

• Le cache, c’est le garde-manger : vous y stockez des ingrédients (farine, épices, conserves) que vous réutilisez pour plusieurs services. Ils ne sont pas spécifiques à un plat.

• Les artifacts, c’est le passe-plat : les plats préparés en cuisine passent par là pour arriver en salle. Ils sont spécifiques à une commande.

Dans GitHub Actions :

• Le cache stocke les dépendances (node_modules, pip packages) réutilisées entre les runs
• Les artifacts transportent les résultats (build, rapports) entre les jobs d’un même run

Comparaison rapide

Aspect	Cache	Artifacts
Objectif	Accélérer les builds répétitifs	Partager des résultats
Portée	Entre runs (workflow répété)	Entre jobs (même run)
Durée de vie	7 jours sans accès	Configurable (1-90 jours)
Visible dans l’UI	Non (interne)	Oui (téléchargeable)
Taille max	10 GB par repo (total)	10 GB par artifact
Cas d’usage	node_modules, .cache/pip	Builds, rapports, binaires

Guide de décision

Accélérer les installations

→ Cache

Dépendances npm, pip, Maven, Gradle…

Guide complet du cache

Partager entre jobs

→ Artifacts

Builds, résultats de compilation, rapports…

Guide complet des artifacts

Situations courantes

✅ Utiliser le cache

• Accélérer npm ci / pip install / mvn install
• Réutiliser les dépendances entre runs
• Cacher les binaires téléchargés (Terraform, kubectl…)
• Accélérer les builds incrémentaux

Exemple : Vous pushez 3 commits successifs → le cache des dépendances est réutilisé pour les 3 runs.

✅ Utiliser les artifacts

• Partager le build entre les jobs test et deploy
• Garder les rapports de tests / couverture
• Télécharger les binaires depuis l’interface GitHub
• Conserver les logs de debug en cas d’échec

Exemple : Un job build crée dist/, les jobs test et deploy le réutilisent sans rebuild.

Erreurs à éviter

❌ Cache pour partager entre jobs

# ❌ NE FONCTIONNE PAS de manière fiable
jobs:
  build:
    steps:
      - run: npm run build
      - uses: actions/cache/save@...
        with:
          path: dist/
          key: build-${{ github.sha }}

  deploy:
    needs: build
    steps:
      - uses: actions/cache/restore@...
        # Peut échouer ! Le cache n'est pas garanti

Pourquoi ? Le cache est conçu pour les runs, pas les jobs.

Solution : Utilisez un artifact.

❌ Artifacts pour les dépendances

# ❌ Gaspillage : vous uploadez node_modules à chaque run
- uses: actions/upload-artifact@...
  with:
    path: node_modules/

# ✅ Utilisez le cache
- uses: actions/setup-node@...
  with:
    cache: 'npm'

Pourquoi ? Les dépendances sont réutilisables entre runs → cache.

Le pattern complet : cache + artifacts

Dans un workflow réel, vous utilisez les deux :

name: CI/CD

jobs:
  build:
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      # CACHE : accélérer npm ci
      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: '20'
          cache: 'npm'

      - run: npm ci
      - run: npm run build

      # ARTIFACT : partager le build
      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        with:
          name: dist
          path: dist/
          retention-days: 1

  deploy:
    needs: build
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
        with:
          name: dist

      - run: ./deploy.sh

Ce qui se passe :

1. Le cache accélère npm ci (dépendances réutilisées entre runs)
2. L’artifact transporte le build vers le job deploy
3. On ne rebuild qu’une seule fois

À retenir

Cache = entre runs

Pour les fichiers réutilisables qui accélèrent les builds répétitifs.

Artifacts = entre jobs

Pour les fichiers produits à partager ou télécharger.

Les deux sont complémentaires

Un workflow optimisé utilise le cache ET les artifacts.

Checklist :

1. ✅ Dépendances → Cache
2. ✅ Résultats de build → Artifacts
3. ✅ Partage entre jobs → Artifacts + needs:
4. ✅ Logs de debug → Artifacts avec if: failure()

Guides détaillés

Pour aller plus loin :

• Accélérer avec le cache — Clés, restore-keys, stratégies avancées
• Partager entre jobs (Artifacts) — Upload, download, optimisations

×

📖 Voir la documentation →