Azure DevOps

Diese Anleitung zeigt, wie Sie einen LoadFocus-JMeter-Test aus einer Azure-DevOps-Pipeline starten, auf sein Ende warten und die Pipeline fehlschlagen lassen, wenn ein Schwellenwert verfehlt wird. Sie nutzt den LoadFocus API Client (loadfocus-api, über npm installiert). Legen Sie den Test zuerst in LoadFocus an und speichern Sie ihn, siehe So führen Sie einen neuen Apache JMeter-Lasttest durch; die Pipeline startet diesen gespeicherten Test über seinen Namen, daher muss --name der exakte Name Ihres gespeicherten Tests sein.

run-test startet den gespeicherten Test, wartet auf sein Ende und prüft die Schwellenwerte. Wird ein Schwellenwert verfehlt oder schlägt der Lauf fehl, beendet sich der Befehl mit Code 1 und der Schritt schlägt fehl. Schwellenwerte werden für jedes Request-Label einzeln geprüft, und errors ist eine Anzahl fehlgeschlagener Requests, keine Prozentzahl. Ersetzen Sie in den folgenden Beispielen My_JMeter_Test durch den exakten Namen Ihres gespeicherten Tests.

Die Ausgabedatei beginnt mit einigen Fortschrittszeilen vor dem JSON-Objekt. Für eine saubere JSON-Datei behalten Sie nur die Zeilen ab der ersten Zeile, die nur { enthält: sed -n '/^{$/,$p' performance_results.json > results.json.

Einrichtungsschritte

1. Anmeldedaten in Azure Key Vault speichern

Für eine sichere Verwaltung der Anmeldedaten speichern Sie Ihre LoadFocus API-Zugangsdaten in Azure Key Vault:

Erstellen Sie einen Key Vault in Azure, falls Sie noch keinen haben
Fügen Sie folgende Secrets hinzu:
- loadfocus-api-key: Ihr LoadFocus API-Schlüssel
- loadfocus-team-id: Ihre LoadFocus Team-ID
Richten Sie eine Service-Verbindung ein, um von Ihrer Pipeline auf den Key Vault zuzugreifen

2. Azure Pipeline erstellen

Erstellen Sie eine neue Datei namens azure-pipelines.yml in Ihrem Repository:

trigger:
  - main
  - develop

pool:
  vmImage: 'ubuntu-latest'

variables:
  - group: loadfocus-variables  # Variable group containing Key Vault references

stages:
  - stage: Build
    jobs:
      - job: BuildAndTest
        steps:
          # Your existing build and test steps...

  - stage: PerformanceTest
    dependsOn: Build
    condition: succeeded()
    jobs:
      - job: RunPerformanceTests
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: '16.x'
            displayName: 'Install Node.js'

          - script: |
              npm install -g @loadfocus/loadfocus-api-client
            displayName: 'Install LoadFocus JMeter API Client'

          - script: |
              loadfocus-api config set --apikey $(LOADFOCUS_API_KEY) --teamid $(LOADFOCUS_TEAM_ID)
            displayName: 'Configure LoadFocus API Client'

          - script: |
              loadfocus-api jmeter run-test \
                --name "My_JMeter_Test" \
                --thresholds "avgresponse<=200,errors==0,p95<=250" \
                --format json > $(Build.ArtifactStagingDirectory)/performance_results.json
            displayName: 'Run Performance Tests'
            continueOnError: false

          - task: PublishBuildArtifacts@1
            inputs:
              pathtoPublish: '$(Build.ArtifactStagingDirectory)'
              artifactName: 'performance-test-results'
            displayName: 'Publish Performance Test Results'

  - stage: Deploy
    dependsOn: PerformanceTest
    condition: succeeded()
    jobs:
      - job: DeployApplication
        steps:
          # Your deployment steps...

3. Variable Group mit Key Vault-Integration einrichten

Gehen Sie zu Pipelines > Library > Variable Groups
Erstellen Sie eine neue Variable Group namens "loadfocus-variables"
Verknüpfen Sie sie mit Ihrem Azure Key Vault
Fügen Sie folgende Variablen hinzu und verknüpfen Sie sie mit Ihren Key Vault-Secrets:
- LOADFOCUS_API_KEY: Verknüpfung mit dem Secret loadfocus-api-key
- LOADFOCUS_TEAM_ID: Verknüpfung mit dem Secret loadfocus-team-id

Erweiterte Konfiguration

YAML-Templates verwenden

Für wiederverwendbare Leistungstestschritte erstellen Sie eine Template-Datei performance-test-template.yml:

parameters:
  testName: 'My_JMeter_Test'
  thresholds: 'avgresponse<=200,errors==0,p95<=250'
  waitTimeout: 1800

steps:
- script: |
    loadfocus-api jmeter run-test \
      --name "${{ parameters.testName }}" \
      --thresholds "${{ parameters.thresholds }}" \
      --wait-timeout ${{ parameters.waitTimeout }} \
      --format json > $(Build.ArtifactStagingDirectory)/performance_results.json
  displayName: 'Run Performance Tests'
  continueOnError: false

Dann in Ihrer Hauptpipeline:

- template: performance-test-template.yml
  parameters:
    testName: 'My_JMeter_Test'
    thresholds: 'avgresponse<=150,errors==0,p95<=200'
    waitTimeout: 2400

Mehrere Tests ausführen

Um mehrere Leistungstests nacheinander auszuführen:

- script: |
    # Run API test
    loadfocus-api jmeter run-test \
      --name "API_Test" \
      --thresholds "avgresponse<=200,errors==0" \
      --format json > $(Build.ArtifactStagingDirectory)/api_test_results.json

    # Run UI test
    loadfocus-api jmeter run-test \
      --name "UI_Test" \
      --thresholds "avgresponse<=500,errors==0" \
      --format json > $(Build.ArtifactStagingDirectory)/ui_test_results.json
  displayName: 'Run Multiple Performance Tests'

Integration mit Azure Test Plans

Um Leistungstestergebnisse mit Azure Test Plans zu integrieren:

- task: PublishTestResults@2
  inputs:
    testResultsFormat: 'JUnit'
    testResultsFiles: '$(Build.ArtifactStagingDirectory)/test-results.xml'
    testRunTitle: 'Performance Tests'
  displayName: 'Publish Test Results'
  condition: succeededOrFailed()

LoadFocus bietet keinen JUnit-Konverter, Sie müssen die JSON-Ausgabe daher selbst mit einem Skript wie dem untenstehenden convert-to-junit.js in JUnit umwandeln (entfernen Sie zuerst die Fortschrittszeilen, siehe den Hinweis oben auf dieser Seite):

- script: |
    # Run performance test
    loadfocus-api jmeter run-test \
      --name "My_JMeter_Test" \
      --thresholds "avgresponse<=200,errors==0" \
      --format json > $(Build.ArtifactStagingDirectory)/performance_results.json

    # Convert JSON to JUnit format (using a custom script)
    node convert-to-junit.js \
      $(Build.ArtifactStagingDirectory)/performance_results.json \
      $(Build.ArtifactStagingDirectory)/test-results.xml
  displayName: 'Run Performance Tests and Convert Results'

Tipps für die Azure DevOps-Integration

Parallele Jobs: Wenn Sie mehrere Leistungstests haben, erwägen Sie parallele Jobs Ihr LoadFocus-Tarif begrenzt, wie viele Tests gleichzeitig laufen können; darüber meldet der Client "Maximum number of parallel tests exceeded for your plan.":
```
jobs:
- job: API_Performance_Test
  steps:
    # Run API performance test

- job: UI_Performance_Test
  steps:
    # Run UI performance test
```

Deployment Gates: Verwenden Sie Leistungstestergebnisse als Deployment-Gate:

- job: DeploymentGate
  steps:
  - script: |
      # Check if performance tests passed
      if grep -q '"overallResult": "FAILED"' $(Build.ArtifactStagingDirectory)/performance_results.json; then
        echo "##vso[task.logissue type=error]Performance tests failed"
        echo "##vso[task.complete result=Failed;]"
      fi

Benutzerdefiniertes Dashboard: Erstellen Sie ein benutzerdefiniertes Dashboard zur Visualisierung von Leistungstestergebnissen im Zeitverlauf.
Benachrichtigungen: Azure DevOps hat keine eingebaute E-Mail-Aufgabe für Pipelines. Nutzen Sie die Benachrichtigungen bei fehlgeschlagenen Builds unter Projekteinstellungen > Benachrichtigungen oder fügen Sie eine Aufgabe aus einer Erweiterung Ihrer Wahl hinzu, um Ihr Team zu informieren, wenn der Performance-Schritt fehlschlägt.

Weitere Informationen finden Sie in der Azure DevOps-Dokumentation und der LoadFocus API Client-Dokumentation.