Pipelines avancés

Cache · Matrix builds · Artifacts · Workflows réutilisables · Deploy

Bootcode IWA-S04 — DevOps, Semaine 3, Jour 2

Objectifs de la leçon

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

Plan du cours

1

Les limites du CI de J1

Lent, répétitif, pas de cache — on réinstalle tout à chaque run

2

Cache npm & Docker

De 60s Ă  5s pour npm install

3

Matrix builds

Node 18 ET 20 en parallèle — détecter les incompatibilités

4

Artifacts

Passer le dist/ du job build au job docker sans reconstruire

5

Live coding + factorisation

Optimiser le pipeline de J1, puis reusable workflows & composite actions

Le cache : ne plus tout réinstaller

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') }}

Matrix builds : tester en parallèle

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.

Artifacts : partager des fichiers entre jobs

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

Steps et jobs conditionnels

# 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)

Factoriser : DRY pour le CI/CD

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 build + push GHCR dans le CI

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.

Pièges courants

❌ 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

Pipeline CI/CD avancé

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

  • âś… Cache npm activĂ© dans tous les jobs
  • âś… Matrix Node 18 & 20 avec fail-fast: false
  • âś… needs: [lint, test] pour le build
  • âś… Build uploadĂ© comme artifact
  • âś… Login GHCR via secrets.GITHUB_TOKEN
  • âś… Workflow vert sur une PR

Ă€ retenir !

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