Aller au contenu

TP : Votre premier pipeline CI/CD avec Node.js

Ce TP a pour objectif de vous faire pratiquer la mise en place d'un pipeline d'intégration continue (CI) sur GitLab pour une application Node.js simple

Objectifs du TP

  • Comprendre la structure d'un fichier .gitlab-ci.yml
  • Initialiser un projet Node.js et son serveur Express
  • Configurer des étapes d'installation, de lint et de build automatisées
  • Distinguer le cache et les artifacts, puis optimiser le pipeline avec le cache
  • Diagnostiquer un job en échec à partir de ses logs

Étape 1 : Le "Hello World" de la CI

Avant de manipuler du code applicatif, nous allons valider que votre environnement GitLab fonctionne correctement

  1. Créez un fichier nommé .gitlab-ci.yml à la racine de votre dépôt
  2. Définissez une étape (stage) nommée test
  3. Créez un job nommé hello_job qui appartient à cette étape et dont le script affiche simplement "Hello World" dans les logs
  4. Commitez ce fichier et vérifiez dans l'interface GitLab (section Build > Pipelines) que votre job s'exécute avec succès

Étape 2 : Préparation de l'application Node.js

Nous allons maintenant créer une application web très simple avec le framework Express

  1. Initialisez un nouveau projet Node.js avec la commande npm init
  2. Installez la dépendance express
  3. Créez un fichier index.js qui démarre un serveur sur le port 3000 et répond "Hello World" sur la route racine /
  4. Testez votre application localement avec node index.js pour vous assurer qu'elle fonctionne
  5. Pensez à ajouter un fichier .gitignore pour ne pas envoyer le dossier node_modules sur votre dépôt Git

Étape 3 : Automatisation de l'installation et du build

Maintenant que l'application est prête, nous voulons que GitLab s'occupe de préparer l'environnement à chaque changement de code

  1. Modifiez votre fichier .gitlab-ci.yml pour utiliser l'image Docker node:24-alpine
  2. Définissez deux étapes : install et build
  3. Créez un job install_dependencies dans le stage install qui utilise la commande npm ci (plus rapide et stable que npm install dans un contexte CI), et transmettez le dossier node_modules/ au job suivant avec artifacts:paths
  4. Créez un job build_app dans le stage build qui exécute la commande de build de votre projet
    • Indice : Vous devrez probablement ajouter un script "build": "echo 'Building...'" dans votre package.json pour nous faciliter cette étape

Étape 4 : Qualité du code avec un linter

Un linter vérifie le code sans l'exécuter : variables inutilisées, erreurs de syntaxe, mauvaises pratiques. Placé juste après l'installation, il donne un retour en quelques secondes

  1. Installez et initialisez ESLint en local avec npm init @eslint/config@latest (répondez aux questions pour un projet JavaScript Node.js) : la commande génère un fichier eslint.config.mjs et ajoute ESLint à vos devDependencies
  2. Ajoutez un script "lint": "eslint ." dans votre package.json et vérifiez qu'il passe en local avec npm run lint
  3. Ajoutez un stage lint entre install et build dans votre .gitlab-ci.yml
  4. Créez un job lint_code dans ce stage qui exécute npm run lint : il réutilise le dossier node_modules/ transmis par l'artifact du job install_dependencies
  5. Déclarez volontairement une variable inutilisée dans index.js, poussez, et vérifiez que le job lint_code échoue et que le pipeline s'arrête avant le build
  6. Corrigez le code et vérifiez que le pipeline repasse au vert

Étape 5 : Optimisation avec le cache

Vous remarquerez que chaque job repart d'un environnement vide. Pour éviter de télécharger les dépendances à chaque fois, nous allons utiliser le cache

  1. Ajoutez une section cache globale dans votre configuration
  2. Configurez-la pour conserver le dossier de cache npm .npm/, et lancez l'installation avec npm ci --cache .npm --prefer-offline (npm ci supprime node_modules à chaque exécution : le mettre en cache n'accélérerait rien)
  3. Observez la différence de temps d'exécution sur vos prochains pipelines

Cache ou artifact ?

Le cache accélère les pipelines suivants, mais sans garantie : il peut être absent ou vidé, et le job doit fonctionner sans lui. L'artifact transmet de façon garantie un résultat aux jobs suivants du même pipeline : c'est le bon outil pour node_modules/ entre install et lint

Étape 6 : Débogage d'un pipeline en échec

Savoir lire un log de job est une compétence quotidienne : l'objectif est de remonter du symptôme à la cause, sans deviner

Pour chacun des cas suivants, provoquez l'erreur, retrouvez dans les logs la ligne qui donne la cause, puis corrigez et vérifiez que le pipeline repasse au vert :

  1. Image introuvable : remplacez l'image par node:24-alpinee (faute de frappe). Le job échoue avant même d'exécuter votre script : repérez le message du runner qui n'arrive pas à récupérer l'image
  2. YAML invalide : cassez l'indentation d'une clé de votre .gitlab-ci.yml. Le pipeline ne démarre pas du tout : ouvrez Build > Pipeline editor pour retrouver la ligne en cause
  3. Artifact oublié : supprimez la section artifacts du job install_dependencies. Le job lint_code échoue, car la commande eslint est introuvable : expliquez pourquoi le cache ne suffit pas à transmettre node_modules/
  4. Erreur de lint : réintroduisez une variable inutilisée et retrouvez dans le log le nom de la règle ESLint, le fichier et la ligne en cause

Pour chaque cas, notez dans votre README le symptôme, la cause et la correction : c'est exactement la démarche attendue face à un incident en production

Étape 7 : Bonus - Vérification des dépendances

Il est important de savoir si vos bibliothèques sont à jour pour éviter des failles de sécurité ou des bugs

  1. Ajoutez un job nommé check_updates dans un stage test (pensez à déclarer ce stage dans la liste stages)
  2. Utilisez la commande npm outdated pour l'exécuter
  3. Utilisez l'option allow_failure: true pour que votre pipeline ne soit pas bloqué si une mise à jour est disponible, car c'est une information informative pour ce TP