Aller au contenu principal

Matrix builds

Table des matières​

  1. Concept de matrix
  2. Syntaxe de base
  3. Configurations avancées
  4. Include et exclude
  5. Fail-fast et max-parallel
  6. Exercices pratiques

1 - Concept de matrix​

Pourquoi utiliser une matrix ?​

Cas d'utilisation​

ScénarioMatrix
Multi-versionNode 16, 18, 20
Multi-OSUbuntu, Windows, macOS
Multi-browserChrome, Firefox, Safari
Multi-databasePostgreSQL, MySQL

🔝 Retour à la table des matières​


2 - Syntaxe de base​

Matrix simple​

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node: [16, 18, 20]
    
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm test

Multi-dimensions​

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node: [16, 18, 20]
        os: [ubuntu-latest, windows-latest]
    
    # Total: 3 versions × 2 OS = 6 jobs
    runs-on: ${{ matrix.os }}
    
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm test

Avec des objets​

jobs:
  deploy:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        environment:
          - name: staging
            url: https://staging.example.com
          - name: production
            url: https://example.com
    
    steps:
      - run: |
          echo "Deploying to ${{ matrix.environment.name }}"
          echo "URL: ${{ matrix.environment.url }}"

Accès aux valeurs​

# Variable simple
${{ matrix.node }}

# Variable dans un objet
${{ matrix.environment.name }}

# Dans le nom du job
name: Test Node ${{ matrix.node }} on ${{ matrix.os }}

🔝 Retour à la table des matières​


3 - Configurations avancées​

Multi-OS avec ajustements​

jobs:
  build:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        include:
          - os: windows-latest
            shell: pwsh
          - os: ubuntu-latest
            shell: bash
          - os: macos-latest
            shell: bash
    
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: ${{ matrix.shell }}
    
    steps:
      - uses: actions/checkout@v4
      - run: echo "Running on ${{ matrix.os }}"

Matrix dynamique​

jobs:
  generate:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
      - id: set-matrix
        run: |
          echo "matrix={\"node\":[16,18,20]}" >> $GITHUB_OUTPUT

  build:
    needs: generate
    runs-on: ubuntu-latest
    strategy:
      matrix: ${{ fromJSON(needs.generate.outputs.matrix) }}
    steps:
      - run: echo "Node version: ${{ matrix.node }}"

Combinaisons complexes​

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [16, 18, 20]
        database: [postgres, mysql]
    
    # Total: 2 OS × 3 Node × 2 DB = 12 jobs
    
    runs-on: ${{ matrix.os }}
    services:
      db:
        image: ${{ matrix.database }}
    
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm test

🔝 Retour à la table des matières​


4 - Include et exclude​

exclude​

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [16, 18, 20]
        exclude:
          # Exclure Node 16 sur Windows
          - os: windows-latest
            node: 16
    
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}

include​

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest]
        node: [18]
        include:
          # Ajouter une configuration spécifique
          - os: ubuntu-latest
            node: 20
            experimental: true
          
          # Ajouter des variables à une combinaison existante
          - os: ubuntu-latest
            node: 18
            coverage: true
    
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      
      - run: npm test
      
      - name: Coverage
        if: matrix.coverage
        run: npm run coverage

Combinaison include/exclude​

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node: [16, 18, 20]
        exclude:
          # Pas de Node 16 sur macOS
          - os: macos-latest
            node: 16
        include:
          # Ajouter des variables spéciales
          - os: ubuntu-latest
            node: 20
            latest: true
    
    runs-on: ${{ matrix.os }}
    name: Node ${{ matrix.node }} on ${{ matrix.os }}${{ matrix.latest && ' (latest)' || '' }}

🔝 Retour à la table des matières​


5 - Fail-fast et max-parallel​

fail-fast​

jobs:
  test:
    strategy:
      fail-fast: true  # Défaut: true
      matrix:
        node: [16, 18, 20]
    
    # Si un job échoue, tous les autres sont annulés
jobs:
  test:
    strategy:
      fail-fast: false  # Continuer même si un job échoue
      matrix:
        node: [16, 18, 20]
    
    # Tous les jobs s'exécutent jusqu'au bout

max-parallel​

jobs:
  test:
    strategy:
      max-parallel: 2  # Maximum 2 jobs en parallèle
      matrix:
        node: [16, 18, 20]
        os: [ubuntu-latest, windows-latest]
    
    # 6 jobs mais seulement 2 à la fois

Combinaison​

jobs:
  test:
    strategy:
      fail-fast: false
      max-parallel: 4
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node: [16, 18, 20]
    
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm test

Continue on error par job​

jobs:
  test:
    strategy:
      matrix:
        include:
          - node: 18
            experimental: false
          - node: 21
            experimental: true
    
    runs-on: ubuntu-latest
    continue-on-error: ${{ matrix.experimental }}
    
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm test

🔝 Retour à la table des matières​


6 - Exercices pratiques​

Exercice 1 : Multi-version Node​

Testez sur Node 16, 18 et 20 :

Solution
name: Test Multi-Node

on: push

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node: [16, 18, 20]
    
    name: Node ${{ matrix.node }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm ci
      - run: npm test

Exercice 2 : Multi-OS et exclude​

Testez sur Ubuntu et Windows, mais excluez Node 16 sur Windows :

Solution
name: Cross-Platform

on: push

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [16, 18, 20]
        exclude:
          - os: windows-latest
            node: 16
    
    runs-on: ${{ matrix.os }}
    name: Node ${{ matrix.node }} on ${{ matrix.os }}
    
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: npm test

Quiz​

Q1. Combien de jobs génère une matrix 3×2×2 ?

Réponse

3 × 2 × 2 = 12 jobs

Q2. Comment exclure une combinaison spécifique ?

Réponse

Avec exclude dans la stratégie.

🔝 Retour à la table des matières​


Points clés à retenir​

  • Matrix = test multi-configurations en parallèle
  • Accès aux valeurs : ${{ matrix.variable }}
  • exclude pour retirer des combinaisons
  • include pour ajouter des configurations ou variables
  • fail-fast: false pour continuer malgré les échecs
  • max-parallel pour limiter la parallélisation
  • Matrix dynamique possible avec fromJSON()

🔝 Retour à la table des matières​

← Chapitre précédent | Chapitre suivant : Workflows réutilisables →