GitHub Actions

Diese Anleitung erklärt, wie Sie den LoadFocus JMeter API Client mit GitHub Actions für automatisierte Leistungstests integrieren.

Einrichtungsschritte

1. Anmeldedaten als GitHub Secrets speichern

Speichern Sie zunächst Ihre LoadFocus API-Zugangsdaten als GitHub-Repository-Secrets:

  1. Gehen Sie zu Ihrem GitHub-Repository
  2. Navigieren Sie zu Settings > Secrets and variables > Actions
  3. Fügen Sie folgende Repository-Secrets hinzu:
    • LOADFOCUS_API_KEY: Ihr LoadFocus API-Schlüssel
    • LOADFOCUS_TEAM_ID: Ihre LoadFocus Team-ID

2. GitHub Actions-Workflow erstellen

Erstellen Sie eine neue Datei in Ihrem Repository unter .github/workflows/performance-test.yml:

name: Performance Tests


on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  # Optional: Run on a schedule
  schedule:
    - cron: '0 0 * * 1'  # Run at midnight every Monday


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. Leistungstests zum Deployment-Workflow hinzufügen

Um das Deployment von den Leistungstestergebnissen abhängig zu machen:

name: Build, Test, and Deploy


on:
  push:
    branches: [ main ]


jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # Your build steps...


  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:
      # Your deployment steps...

Erweiterte Konfiguration

Matrix-Tests für mehrere Umgebungen

Tests gegen mehrere Umgebungen oder Konfigurationen ausführen:

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


    steps:
      # Setup steps...


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


          # Adjust thresholds based on environment
          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"

Leistungstest-Berichte erstellen

HTML-Berichte aus JSON-Ergebnissen generieren:

- name: Generate HTML Report
  run: |
    # Install report generator
    npm install -g performance-report-generator


    # Generate HTML report
    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


# Optional: Publish to 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

Testergebnisse als PR-Kommentar

Leistungstestergebnisse als Kommentar zu Pull Requests hinzufügen:

- 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
      });

Wiederverwendbarer Workflow

Erstellen Sie einen wiederverwendbaren Workflow für Leistungstests:

# .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

Dann aus einem anderen Workflow aufrufen:

# .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 }}

Tipps für die GitHub Actions-Integration

  1. Caching: npm-Abhängigkeiten cachen, um Workflow-Läufe zu beschleunigen:

    - 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. Parallelitätskontrolle: Gleichzeitige Leistungstests begrenzen:

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

  3. Umgebungsspezifische Tests: GitHub-Environments für verschiedene Testkonfigurationen verwenden:

    jobs:
      performance-test:
        runs-on: ubuntu-latest
        environment: staging
        # Environment-specific variables are available here

  4. Bedingte Tests: Leistungstests nur ausführen, wenn bestimmte Dateien geändert werden:

    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]')

Weitere Informationen finden Sie in der GitHub Actions-Dokumentation und der LoadFocus API Client-Dokumentation.

Zurück
CircleCI
Weiter
GitLab CI/CD