GitHub Actions

Ce guide explique comment integrer le client API JMeter de LoadFocus avec GitHub Actions pour les tests de performance automatises.

Etapes de configuration

1. Stocker les identifiants en tant que secrets GitHub

Tout d'abord, stockez vos identifiants API LoadFocus en tant que secrets de depot GitHub :

  1. Accedez a votre depot GitHub
  2. Allez dans Settings > Secrets and variables > Actions
  3. Ajoutez les secrets de depot suivants :
    • LOADFOCUS_API_KEY : Votre cle API LoadFocus
    • LOADFOCUS_TEAM_ID : Votre ID d'equipe LoadFocus

2. Creer un workflow GitHub Actions

Creez un nouveau fichier dans votre depot a .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 }}
        loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


    - name: Run Performance Tests
      run: |
        loadfocus-api jmeter run-test \
          --name "GitHub_${{ github.repository_owner }}_${{ github.repository }}_${{ github.ref_name }}" \
          --thresholds "avgresponse<=200,errors==0,p95<=250" \
          --format json > performance_results.json


    - name: Upload Performance Test Results
      uses: actions/upload-artifact@v3
      with:
        name: performance-test-results
        path: performance_results.json

3. Ajouter les tests de performance a votre workflow de deploiement

Pour rendre le deploiement dependant des resultats 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 }}
          loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


      - name: Run Performance Tests
        run: |
          loadfocus-api jmeter run-test \
            --name "GitHub_${{ github.repository }}_${{ github.ref_name }}" \
            --thresholds "avgresponse<=200,errors==0,p95<=250" \
            --format json > performance_results.json


      - name: Upload Performance Test Results
        uses: actions/upload-artifact@v3
        with:
          name: performance-test-results
          path: performance_results.json


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

Configuration avancee

Tests matriciels pour plusieurs environnements

Executez 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"

Creation de rapports de tests de performance

Generez des rapports HTML a partir des resultats JSON :

- name: Generate HTML Report
  run: |
    # Installer le generateur de rapports
    npm install -g performance-report-generator


    # Generer le rapport HTML
    performance-report-generator \
      --input performance_results.json \
      --output performance_report.html


- name: Upload HTML Report
  uses: actions/upload-artifact@v3
  with:
    name: performance-test-report
    path: performance_report.html


# Optionnel : Publier sur GitHub Pages
- name: Publish to GitHub Pages
  uses: peaceiris/actions-gh-pages@v3
  with:
    github_token: ${{ secrets.GITHUB_TOKEN }}
    publish_dir: ./reports
    destination_dir: performance-reports

Commenter les resultats des tests sur les PR

Ajoutez les resultats des tests de performance en commentaire sur les pull requests :

- name: Comment PR
  uses: actions/github-script@v6
  if: github.event_name == 'pull_request'
  with:
    github-token: ${{ secrets.GITHUB_TOKEN }}
    script: |
      const fs = require('fs');
      const results = JSON.parse(fs.readFileSync('performance_results.json', 'utf8'));


      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 reutilisable

Creez un workflow reutilisable 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 }}
          loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


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


      - name: Upload Performance Test Results
        uses: actions/upload-artifact@v3
        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'integration GitHub Actions

  1. Mise en cache : Mettez en cache les dependances npm pour accelerer les executions 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. Controle de la concurrence : Limitez les tests de performance simultanes :

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

  3. Tests specifiques a l'environnement : Utilisez les environnements GitHub pour differentes configurations de test :

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

  4. Tests conditionnels : Executez les tests de performance uniquement lorsque des fichiers specifiques 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
CircleCI
Suivant
GitLab CI/CD