Cache · Matrix builds · Artifacts · Workflows réutilisables · Deploy
Bootcode IWA-S04 — DevOps, Semaine 3, Jour 2
1. Le cache
Cacher npm et les layers Docker pour des pipelines jusqu'Ă 10Ă— plus rapides
2. Les matrix builds
Tester sur plusieurs versions de Node.js et OS en parallèle
3. Les artifacts
Partager des fichiers entre jobs — le build d'un job sert au suivant
4. Steps conditionnels
if: — exécuter un step seulement dans certaines conditions
5. Factoriser le YAML
Reusable workflows et composite actions — le DRY appliqué au CI/CD
Les limites du CI de J1
Lent, répétitif, pas de cache — on réinstalle tout à chaque run
Cache npm & Docker
De 60s Ă 5s pour npm install
Matrix builds
Node 18 ET 20 en parallèle — détecter les incompatibilités
Artifacts
Passer le dist/ du job build au job docker sans reconstruire
Live coding + factorisation
Optimiser le pipeline de J1, puis reusable workflows & composite actions
Sans cache, npm ci télécharge tout node_modules à chaque run : ~60s perdues.
La clé, c'est la clé
La key est hashée sur package-lock.json — elle change dès qu'une dépendance change, sinon le cache est réutilisé.
⚠️ Mauvaise clé = cache jamais utilisé
Si la clé est constante (key: npm), le premier cache est figé pour toujours.
- uses: actions/setup-node@v4
with:
node-version: 20
cache: 'npm'
# ou actions/cache explicite :
- uses: actions/cache@v4
with:
path: ~/.npm
key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
La strategy.matrix lance le même job N fois avec des variables différentes — en parallèle.
Pourquoi tester Node 18 ET 20 ?
Une dépendance peut être compatible avec une version et casser sur l'autre. La matrix détecte ça immédiatement.
fail-fast: false
Par défaut, si un job de la matrix échoue, GitHub annule tous les autres. false laisse tout tourner pour voir le tableau complet.
test:
strategy:
fail-fast: false
matrix:
node: [18, 20]
runs-on: ubuntu-latest
steps:
- uses: actions/setup-node@v4
with:
node-version: ${{ matrix.node }}
# → 2 jobs : "test (18)" + "test (20)"
Garder des matrices raisonnables : 5 OS × 5 versions = 25 jobs à chaque push — coûteux et lent.
Chaque job tourne dans un conteneur frais. Pour passer dist/ du job build au job docker, on l'upload comme artifact.
Artifact ≠Cache
Cache : accélérer entre les runs (deps).
Artifact : partager un résultat entre jobs du même run (build output).
⏳ Expiration : 90 jours
Les artifacts expirent — ce n'est pas du stockage d'artefacts de release permanent.
# dans le job build :
- uses: actions/upload-artifact@v4
with:
name: dist
path: dist/
# dans le job docker (needs: build) :
- uses: actions/download-artifact@v4
with:
name: dist
# ne déployer que sur main
deploy:
if: github.ref == 'refs/heads/main'
# notifier seulement en cas d'échec
- name: Notify failure
if: failure()
# contextes disponibles : github.ref, matrix.node,
# success(), failure(), cancelled(), always()
if: github.ref == ...
Filtrer par branche ou tag — deploy uniquement depuis main
if: failure()
Notification, upload des logs, nettoyage quand le job échoue
if: always()
S'exécute même si les jobs précédents ont échoué (cleanup)
Reusable workflow
Un workflow entier appelé comme une fonction depuis un autre repo ou fichier.
uses: org/repo/.github/workflows/ci.yml@main
Idéal pour : le même pipeline de qualité sur 10 microservices — un seul fichier à maintenir.
Composite action
Plusieurs steps regroupés en une action réutilisable (un "sous-programme").
uses: ./.github/actions/setup-app
Idéal pour : le bloc checkout + setup-node + cache + install répété dans chaque job.
jobs:
call-ci:
uses: ./.github/workflows/ci-reusable.yml
secrets: inherit
docker:
needs: build
runs-on: ubuntu-latest
permissions:
packages: write
steps:
- uses: docker/login-action@v3
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- uses: docker/build-push-action@v5
with:
push: true
tags: ghcr.io/${{ github.repository }}:latest
GITHUB_TOKEN automatique
GitHub le fournit dans chaque run — pas besoin de créer un secret. Il expire à la fin du job.
Docker layer caching
cache-from/cache-to: type=gha sur build-push-action réutilise les layers entre runs.
❌ Clé de cache statique
key: npm → le premier cache est réutilisé pour toujours, même si les deps ont changé. Toujours hasher package-lock.json.
❌ Confondre cache et artifacts
Le cache accélère entre les runs. L'artifact transmet un résultat entre jobs. Utiliser le cache pour le build output ne fonctionne pas fiablement.
❌ Matrix démesurée
5 OS × 5 versions = 25 jobs par push. Chaque job coûte des minutes CI — rester sur les versions/OS réellement supportés.
❌ Croire les artifacts permanents
Ils expirent après 90 jours par défaut (configurable avec retention-days) — pas un artefact store.
Exercice E3.2 — ~4h
Cache npm, matrix Node 18/20, build Docker et push sur GitHub Container Registry.
Architecture cible
PR → [lint] + [test 18] + [test 20]
↓ (tous OK)
[build] → artifact dist/
↓
[docker] → build + push ghcr.io
Checklist
fail-fast: falseneeds: [lint, test] pour le buildsecrets.GITHUB_TOKEN⚡ Cache = rapidité
cache: 'npm' dans setup-node peut passer l'install de 60s Ă 5s.
🔀 Matrix = couverture
Tester Node 18 ET 20 en parallèle — les incompatibilités de version sont détectées tout de suite.
📦 Artifacts = transmission
Chaque job démarre vide : upload-artifact / download-artifact fait circuler le build.
♻️ Factoriser = maintenabilité
Reusable workflows et composite actions évitent le copier-coller entre repos.