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.

Ce que vous allez apprendre

• Distinguer le cache des artifacts en une phrase
• Choisir le bon mécanisme selon votre besoin
• Repérer les deux erreurs classiques de confusion entre les deux
• Combiner cache et artifacts dans un même workflow

La différence en une phrase

Cache et artifacts répondent à deux besoins distincts. La règle d'or tient en deux lignes, gardez-la en tête, elle tranche la plupart des cas.

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)

Comparaison rapide

Ce tableau met les deux mécanismes face à face sur les critères qui comptent au moment de choisir : portée, durée de vie, visibilité et cas d'usage.

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

Glissez pour voir

Guide de décision

Partez de votre objectif : voulez-vous accélérer une installation, ou faire circuler un résultat d'un job à l'autre ? Chacun mène à un mécanisme.

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

Voici les cas concrets qui reviennent le plus souvent, classés selon le mécanisme adapté.

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

Quand 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

Deux confusions reviennent sans cesse. Les reconnaître évite des workflows instables ou inutilement lents.

Cache pour partager entre jobs

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

  deploy:
    needs: build
    steps:
      - uses: actions/cache/restore@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
        # 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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
  with:
    path: node_modules/

# ✅ Utilisez le cache
- uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
  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

on:
  push:
    branches: [main]

# Aucun droit par défaut : chaque job demande le minimum
permissions: {}

jobs:
  build:
    runs-on: ubuntu-24.04
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false

      # CACHE : accélérer npm ci
      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
        with:
          node-version: '20'
          cache: 'npm'

      - run: npm ci
      - run: npm run build

      # ARTIFACT : partager le build
      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: dist
          path: dist/
          retention-days: 1

  deploy:
    needs: build
    runs-on: ubuntu-24.04
    permissions:
      contents: read
    steps:
      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.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

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À 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()

Pour aller plus loin

• Cache Node.js : La déclinaison npm, yarn et pnpm de l'arbitrage vu ici, avec les clés qui marchent vraiment.
• Cache Java : Le cas Maven et Gradle, où le volume du dépôt local rend le choix cache contre artifact encore plus tranché.
• Concurrency : L'autre levier de temps, qui annule les runs obsolètes au lieu de recalculer ce qui est déjà en cache.

×

📖 Voir la documentation →