Constructions Matricielle GitHub Actions - Tests Parallèles

Introduction

Lors du développement de logiciels, il est crucial de s'assurer que votre code fonctionne correctement dans différents environnements. Par exemple, une bibliothèque Node.js doit être testée sur plusieurs versions de Node.js (par exemple, v18, v20, v22).

Au lieu de créer des tâches (jobs) distinctes pour chaque version, GitHub Actions fournit une Stratégie Matricielle (Matrix Strategy). Cela vous permet de définir un ensemble de variables, et GitHub Actions créera automatiquement une tâche pour chaque combinaison de ces variables.

Dans ce laboratoire, vous allez mettre à jour votre workflow pour exécuter vos tests en parallèle sur trois versions différentes de Node.js.

Ce laboratoire s'appuie sur le dépôt que vous avez créé lors des laboratoires précédents. Vous travaillerez avec le dépôt github-actions-demo.

Modifier le workflow pour inclure une matrice de stratégie

Le mot-clé strategy est utilisé pour configurer la matrice de construction (build matrix). Nous allons définir une matrice avec une seule clé : node-version.

Sur la page de votre dépôt GitHub pour github-actions-demo, cliquez sur le bouton vert Code.
Assurez-vous que l'onglet HTTPS est sélectionné et copiez l'URL. Elle devrait ressembler à https://github.com/your-username/github-actions-demo.git.
Ouvrez le terminal dans l'environnement LabEx. Le chemin par défaut est ~/project.
Utilisez la commande git clone pour télécharger le dépôt. Remplacez your-username par votre nom d'utilisateur GitHub réel.

cd ~/project
git clone https://github.com/your-username/github-actions-demo.git

Exemple de sortie :

Cloning into 'github-actions-demo'...
remote: Enumerating objects: X, done.
remote: Counting objects: 100% (X/X), done.
remote: Total X (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (X/X), done.

Naviguez dans le dépôt cloné :

cd ~/project/github-actions-demo

Créez un nouveau fichier de workflow .github/workflows/matrix-build.yml en utilisant l'éditeur WebIDE. Vous pouvez trouver le fichier dans l'explorateur de fichiers sur le côté gauche sous project/github-actions-demo/.github/workflows/.
Commencez par créer la structure de workflow de base. Ajoutez le nom du workflow et le déclencheur (trigger) :

name: Matrix Build

on: [push]

Ajoutez maintenant la section jobs avec une structure de job de construction de base :

jobs:
  build:
    runs-on: ubuntu-latest

Ajoutez la stratégie de matrice (strategy). C'est la partie clé qui permet d'exécuter le job avec plusieurs versions de Node.js :

strategy:
  matrix:
    node-version: [18, 20, 22]

Ceci définit une variable de matrice node-version avec trois valeurs. GitHub Actions créera un job séparé pour chaque valeur.

Ajoutez la section steps. D'abord, ajoutez l'étape de checkout :

steps:
  - uses: actions/checkout@v4

Ajoutez l'étape de configuration de Node.js. Remarquez comment nous utilisons ${{ matrix.node-version }} pour référencer la valeur actuelle de la matrice :

- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: ${{ matrix.node-version }}

Ajoutez l'étape pour installer les dépendances :

- name: Install dependencies
  run: npm install

Ajoutez l'étape de construction qui crée le répertoire d'artefact :

- name: Build project
  run: |
    mkdir dist
    echo "This is the build artifact" > dist/build.txt

Ajoutez l'étape de test :

- name: Run tests
  run: npm test

Enfin, ajoutez l'étape de téléchargement de l'artefact. Remarquez comment le nom de l'artefact inclut la version de la matrice pour rendre chaque artefact unique :

- name: Upload build artifact
  uses: actions/upload-artifact@v4
  with:
    name: build-assets-${{ matrix.node-version }}
    path: dist

Votre fichier complet devrait maintenant ressembler à ceci :

name: Matrix Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18, 20, 22]

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - name: Install dependencies
        run: npm install
      - name: Build project
        run: |
          mkdir dist
          echo "This is the build artifact" > dist/build.txt
      - name: Run tests
        run: npm test
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: build-assets-${{ matrix.node-version }}
          path: dist

Explication

strategy: Définit la stratégie de construction.
matrix: Définit les variables de la matrice.
node-version: C'est un nom de variable que nous avons choisi. Nous lui avons assigné un tableau de valeurs [18, 20, 22]. GitHub Actions exécutera le job build trois fois, une fois pour chaque valeur.
${{ matrix.node-version }}: Cette syntaxe vous permet d'accéder à la valeur actuelle de la matrice dans vos étapes.

Enregistrez le fichier (Ctrl+S ou Cmd+S) après avoir effectué les modifications.

Mise à jour de setup-node et du nom de l'artefact pour utiliser le contexte de la matrice

Définir la matrice n'est que la moitié du travail ; nous devons également indiquer aux étapes d'utiliser la valeur actuelle de la matrice. Nous y parvenons en utilisant le contexte ${{ matrix.node-version }}.

Nous devons également nous assurer que les artefacts téléchargés par chaque travail parallèle ont des noms uniques, sinon ils s'écraseront mutuellement.

Dans .github/workflows/matrix-build.yml, vérifiez que l'étape Use Node.js utilise la variable de matrice :

- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: ${{ matrix.node-version }}

Vérifiez que l'étape Upload build artifact inclut la version de la matrice dans le nom de l'artefact :

- name: Upload build artifact
  uses: actions/upload-artifact@v4
  with:
    name: build-assets-${{ matrix.node-version }}
    path: dist

Votre fichier de workflow complet devrait ressembler à ceci :

name: Matrix Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18, 20, 22]

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - name: Install dependencies
        run: npm install
      - name: Build project
        run: |
          mkdir dist
          echo "This is the build artifact" > dist/build.txt
      - name: Run tests
        run: npm test
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: build-assets-${{ matrix.node-version }}
          path: dist

Enregistrez le fichier (Ctrl+S ou Cmd+S).

Commit, pousser et observer les jobs parallèles

Voyons la matrice en action en committant vos modifications sur GitHub.

Assurez-vous d'être dans le répertoire du dépôt :

cd ~/project/github-actions-demo

Mettez les changements en zone de staging (stage the changes) :

git add .

Commitez les changements :

git commit -m "Add matrix strategy for Node.js versions"

Poussez les changements vers le dépôt distant sur GitHub :

git push

Note sur l'Authentification : Lorsque vous exécutez git push, le WebIDE vous invitera automatiquement à vous authentifier. Suivez ces étapes détaillées :

Une fenêtre contextuelle apparaîtra avec le message : "The extension 'GitHub' wants to sign in using GitHub." Cliquez sur Allow.
Une nouvelle notification apparaîtra. Cliquez sur "Copy&Continue to GitHub", puis cliquez sur "Open" dans l'invite suivante.
Connectez-vous à votre compte GitHub dans la fenêtre du navigateur qui s'ouvre, et entrez le code d'autorisation qui a été copié. Après avoir confirmé l'autorisation, la page se fermera automatiquement.
Attendez quelques secondes, et vous verrez le terminal terminer avec succès l'opération de push.

Note sur la Confidentialité : Le WebIDE demandera un accès complet à votre compte GitHub à des fins d'authentification. Vous n'avez pas à vous soucier des problèmes de confidentialité - la VM LabEx sera immédiatement détruite après avoir terminé le laboratoire actuel, et vos informations d'identification et d'autorisation ne seront pas conservées.

Ce processus d'authentification ne nécessite aucune configuration manuelle du nom d'utilisateur ou du Personal Access Token (Jeton d'Accès Personnel).

Vérification sur GitHub

Visitez votre dépôt sur GitHub dans un navigateur web.
Cliquez sur l'onglet Actions.
Cliquez sur la dernière exécution de workflow (workflow run).
Dans la barre latérale gauche (ou dans la vue graphique principale), vous verrez maintenant trois jobs distincts listés sous le groupe build :
- build (18)
- build (20)
- build (22)
Ils s'exécuteront en parallèle (ou presque). Vous pouvez cliquer sur chacun d'eux pour voir que Use Node.js a configuré la version spécifique demandée.

GitHub Actions matrix builds

Résumé

Dans ce laboratoire, vous avez appris à utiliser la Stratégie de Matrice (Matrix Strategy) dans GitHub Actions. Vous avez :

Défini une matrice avec plusieurs versions de Node.js en utilisant strategy: matrix.
Mis à jour vos étapes de workflow pour utiliser dynamiquement la version à partir du contexte de la matrice (${{ matrix.node-version }}).
Assuré que les noms des artefacts étaient uniques pour chaque tâche de la matrice.

Cette fonctionnalité puissante vous permet de valider votre projet sur un large éventail de configurations avec très peu de duplication de code.

Constructions Matricielle (Matrix Builds) GitHub Actions