GitHub Actions

Ce guide montre comment lancer un test JMeter LoadFocus depuis un workflow GitHub Actions, attendre sa fin et faire échouer le workflow quand un seuil n'est pas respecté. Il utilise le LoadFocus API Client (loadfocus-api, installé depuis npm). Créez et enregistrez d'abord le test dans LoadFocus, voir Comment exécuter un nouveau test de charge Apache JMeter ; le workflow lance ce test enregistré par son nom.

Étapes de configuration

1. Stocker les identifiants en tant que secrets GitHub

Tout d'abord, stockez vos identifiants API LoadFocus en tant que secrets de dépôt GitHub :

  1. Accédez à votre dépôt GitHub
  2. Allez dans Settings > Secrets and variables > Actions
  3. Ajoutez les secrets de dépôt suivants :
    • LOADFOCUS_API_KEY : Votre clé API LoadFocus
    • LOADFOCUS_TEAM_ID : Votre ID d'équipe LoadFocus

Les deux se trouvent sur la page Clés API des paramètres de votre compte LoadFocus.

2. Créer un workflow GitHub Actions

Créez un nouveau fichier dans votre dépôt à .github/workflows/performance-test.yml :

name: Performance Tests


on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  # Optionnel : Executer selon un planning
  schedule:
    - cron: '0 0 * * 1'  # Executer a minuit chaque lundi


jobs:
  performance-test:
    runs-on: ubuntu-latest


    steps:
    - uses: actions/checkout@v3


    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '16'


    - name: Install LoadFocus JMeter API Client
      run: npm install -g @loadfocus/loadfocus-api-client


    - name: Configure LoadFocus API Client
      run: |
        loadfocus-api config set --apikey ${{ secrets.LOADFOCUS_API_KEY }} --teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


    - name: Run Performance Tests
      run: |
        # --name est le nom exact d'un test enregistré dans LoadFocus
        loadfocus-api jmeter run-test \
          --name "My_JMeter_Test" \
          --thresholds "avgresponse<=200,errors==0,p95<=250" \
          --format json > performance_results.json


    - name: Upload Performance Test Results
      if: always()
      uses: actions/upload-artifact@v4
      with:
        name: performance-test-results
        path: performance_results.json

run-test lance le test enregistré, attend sa fin et vérifie les seuils. Si un seuil n'est pas respecté, ou si l'exécution échoue, la commande se termine avec le code 1 et l'étape échoue. Les seuils sont vérifiés séparément pour chaque libellé de requête : une seule requête lente suffit à faire échouer l'exécution. errors est un nombre de requêtes en échec, pas un pourcentage. Dans les exemples ci-dessous, remplacez les noms de test par le nom exact de votre test enregistré.

Le fichier de sortie commence par quelques lignes de progression avant l'objet JSON. Pour obtenir un JSON propre, ne gardez que les lignes à partir de la première qui ne contient que { : sed -n '/^{$/,$p' performance_results.json > results.json.

3. Ajouter les tests de performance à votre workflow de déploiement

Pour rendre le déploiement dépendant des résultats des tests de performance :

name: Build, Test, and Deploy


on:
  push:
    branches: [ main ]


jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # Vos etapes de build...


  performance-test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3


      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'


      - name: Install LoadFocus JMeter API Client
        run: npm install -g @loadfocus/loadfocus-api-client


      - name: Configure LoadFocus API Client
        run: |
          loadfocus-api config set --apikey ${{ secrets.LOADFOCUS_API_KEY }} --teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


      - name: Run Performance Tests
        run: |
          loadfocus-api jmeter run-test \
            --name "My_JMeter_Test" \
            --thresholds "avgresponse<=200,errors==0,p95<=250" \
            --format json > performance_results.json


      - name: Upload Performance Test Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: performance-test-results
          path: performance_results.json


  deploy:
    needs: performance-test
    runs-on: ubuntu-latest
    steps:
      # Vos etapes de deploiement...

Configuration avancée

Tests matriciels pour plusieurs environnements

Exécutez des tests sur plusieurs environnements ou configurations :

jobs:
  performance-test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        environment: [dev, staging, production]
        test-type: [api, frontend]


    steps:
      # Etapes de configuration...


      - name: Run Performance Tests
        run: |
          TEST_NAME="${{ matrix.test-type }}_test_${{ matrix.environment }}"


          # Ajuster les seuils en fonction de l'environnement
          if [ "${{ matrix.environment }}" == "production" ]; then
            THRESHOLDS="avgresponse<=150,errors==0,p95<=200"
          else
            THRESHOLDS="avgresponse<=300,errors==0,p95<=500"
          fi


          loadfocus-api jmeter run-test \
            --name "$TEST_NAME" \
            --thresholds "$THRESHOLDS" \
            --format json > "performance_results_${{ matrix.environment }}_${{ matrix.test-type }}.json"

Commenter les résultats des tests sur les PR

Ajoutez les résultats des tests de performance en commentaire sur les pull requests :

- name: Comment PR
  uses: actions/github-script@v6
  if: always() && github.event_name == 'pull_request'
  with:
    github-token: ${{ secrets.GITHUB_TOKEN }}
    script: |
      const fs = require('fs');
      const raw = fs.readFileSync('performance_results.json', 'utf8');
      // the file starts with progress lines; the JSON begins at the first line that is only {
      const results = JSON.parse(raw.slice(raw.search(/^\{$/m)));


      let comment = '## Performance Test Results\n\n';
      comment += `**Overall Result:** ${results.overallResult}\n\n`;


      comment += '### Results by Label\n\n';
      for (const label of results.labels) {
        comment += `#### ${label.label}\n`;
        comment += `- **Result:** ${label.result}\n`;
        comment += `- **Samples:** ${label.metrics.samples}\n`;
        comment += `- **Avg Response:** ${label.metrics.avgresponse}ms\n`;
        comment += `- **Error Rate:** ${label.metrics.errors}\n\n`;
      }


      github.rest.issues.createComment({
        issue_number: context.issue.number,
        owner: context.repo.owner,
        repo: context.repo.repo,
        body: comment
      });

Workflow réutilisable

Créez un workflow réutilisable pour les tests de performance :

# .github/workflows/reusable-performance-test.yml
name: Reusable Performance Test


on:
  workflow_call:
    inputs:
      test-name:
        required: true
        type: string
      thresholds:
        required: false
        type: string
        default: "avgresponse<=200,errors==0,p95<=250"
      wait-timeout:
        required: false
        type: number
        default: 1800
    secrets:
      LOADFOCUS_API_KEY:
        required: true
      LOADFOCUS_TEAM_ID:
        required: true


jobs:
  performance-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3


      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'


      - name: Install LoadFocus JMeter API Client
        run: npm install -g @loadfocus/loadfocus-api-client


      - name: Configure LoadFocus API Client
        run: |
          loadfocus-api config set --apikey ${{ secrets.LOADFOCUS_API_KEY }} --teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


      - name: Run Performance Tests
        run: |
          loadfocus-api jmeter run-test \
            --name "${{ inputs.test-name }}" \
            --thresholds "${{ inputs.thresholds }}" \
            --wait-timeout ${{ inputs.wait-timeout }} \
            --format json > performance_results.json


      - name: Upload Performance Test Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: performance-test-results
          path: performance_results.json

Puis appelez-le depuis un autre workflow :

# .github/workflows/main.yml
jobs:
  call-performance-test:
    uses: ./.github/workflows/reusable-performance-test.yml
    with:
      test-name: "API_Performance_Test"
      thresholds: "avgresponse<=150,errors==0"
    secrets:
      LOADFOCUS_API_KEY: ${{ secrets.LOADFOCUS_API_KEY }}
      LOADFOCUS_TEAM_ID: ${{ secrets.LOADFOCUS_TEAM_ID }}

Conseils pour l'intégration GitHub Actions

  1. Mise en cache : Mettez en cache les dépendances npm pour accélérer les exécutions de workflow :

    - name: Cache Node modules
      uses: actions/cache@v3
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
        restore-keys: |
          ${{ runner.os }}-node-

  2. Contrôle de la concurrence : Limitez les tests de performance simultanés :

    concurrency:
      group: performance-test-${{ github.ref }}
      cancel-in-progress: false

  3. Tests spécifiques à l'environnement : Utilisez les environnements GitHub pour différentes configurations de test :

    jobs:
      performance-test:
        runs-on: ubuntu-latest
        environment: staging
        # Les variables specifiques a l'environnement sont disponibles ici

  4. Tests conditionnels : Exécutez les tests de performance uniquement lorsque des fichiers spécifiques changent :

    jobs:
      performance-test:
        if: |
          contains(github.event.pull_request.labels.*.name, 'performance-test') ||
          github.event_name == 'schedule' ||
          contains(github.event.head_commit.message, '[perf-test]')

Pour plus d'informations, consultez la documentation GitHub Actions et la documentation du client API LoadFocus.

Précédent
Azure DevOps
Suivant
CircleCI