GitLab CI/CD

Diese Anleitung zeigt, wie Sie einen LoadFocus-JMeter-Test aus einer GitLab-CI/CD-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.

Einrichtungsschritte

1. Anmeldedaten als GitLab CI/CD-Variablen speichern

Speichern Sie zunächst Ihre LoadFocus API-Zugangsdaten als GitLab CI/CD-Variablen:

Gehen Sie zu Ihrem GitLab-Projekt
Navigieren Sie zu Settings > CI/CD > Variables
Fügen Sie folgende Variablen hinzu:
- LOADFOCUS_API_KEY: Ihr LoadFocus API-Schlüssel (als "Masked" markieren)
- LOADFOCUS_TEAM_ID: Ihre LoadFocus Team-ID

Beides finden Sie auf der Seite API-Schlüssel in den Einstellungen Ihres LoadFocus-Kontos.

2. GitLab CI/CD-Pipeline erstellen

Erstellen oder aktualisieren Sie Ihre .gitlab-ci.yml-Datei in Ihrem Repository:

stages:
  - build
  - test
  - performance
  - deploy

variables:
  NODE_VERSION: "20"

build:
  stage: build
  image: node:${NODE_VERSION}
  script:
    - npm install
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 week

test:
  stage: test
  image: node:${NODE_VERSION}
  script:
    - npm install
    - npm test

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Install LoadFocus JMeter API Client
    - npm install -g @loadfocus/loadfocus-api-client

    # Configure LoadFocus API Client
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID

    # Performance-Tests ausführen. --name ist der exakte Name eines in LoadFocus gespeicherten Tests.
    - |
      loadfocus-api jmeter run-test \
        --name "My_JMeter_Test" \
        --thresholds "avgresponse<=200,errors==0,p95<=250" \
        --format json > performance_results.json
  artifacts:
    paths:
      - performance_results.json
    expire_in: 1 week
    when: always
  # Optional: Only run on specific branches
  only:
    - main
    - develop

deploy:
  stage: deploy
  script:
    - echo "Deploying application..."
  only:
    - main
  # Only deploy if all previous stages succeeded
  when: on_success

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 Job schlägt fehl, sodass die Stufe deploy nicht läuft. Schwellenwerte werden für jedes Request-Label einzeln geprüft, ein langsamer Request genügt also, damit der Lauf fehlschlägt. errors ist eine Anzahl fehlgeschlagener Requests, keine Prozentzahl. Ersetzen Sie in den folgenden Beispielen die Namen GitLab_... 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.

3. Testergebnisse anzeigen

Nachdem die Pipeline ausgeführt wurde:

Gehen Sie zu Ihrem GitLab-Projekt
Navigieren Sie zu CI/CD > Pipelines
Finden Sie Ihre Pipeline und klicken Sie darauf
Gehen Sie zum Job "performance_test"
Klicken Sie auf "Browse" in der rechten Seitenleiste, um Artefakte anzuzeigen
Laden Sie die Datei performance_results.json herunter und sehen Sie sie ein

Erweiterte Konfiguration

Umgebungsspezifische Tests

Verschiedene Leistungstests für verschiedene Umgebungen ausführen:

.performance_test_template: &performance_test_definition
  stage: performance
  image: node:${NODE_VERSION}
  script:
    - npm install -g @loadfocus/loadfocus-api-client
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID
    - |
      loadfocus-api jmeter run-test \
        --name "${TEST_NAME}" \
        --thresholds "${THRESHOLDS}" \
        --format json > performance_results.json
  artifacts:
    paths:
      - performance_results.json
    expire_in: 1 week
    when: always

performance_test_develop:
  <<: *performance_test_definition
  variables:
    TEST_NAME: "API_Test_Develop"
    THRESHOLDS: "avgresponse<=300,errors==0,p95<=500"
  only:
    - develop

performance_test_staging:
  <<: *performance_test_definition
  variables:
    TEST_NAME: "API_Test_Staging"
    THRESHOLDS: "avgresponse<=250,errors==0,p95<=350"
  only:
    - staging

performance_test_production:
  <<: *performance_test_definition
  variables:
    TEST_NAME: "API_Test_Production"
    THRESHOLDS: "avgresponse<=200,errors==0,p95<=250"
  only:
    - main

Parallele Tests

Mehrere Leistungstests parallel ausführen:

performance_test_api:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    - npm install -g @loadfocus/loadfocus-api-client
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID
    - |
      loadfocus-api jmeter run-test \
        --name "API_Performance_Test" \
        --thresholds "avgresponse<=150,errors==0" \
        --format json > api_performance_results.json
  artifacts:
    paths:
      - api_performance_results.json
    expire_in: 1 week

performance_test_ui:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    - npm install -g @loadfocus/loadfocus-api-client
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID
    - |
      loadfocus-api jmeter run-test \
        --name "UI_Performance_Test" \
        --thresholds "avgresponse<=300,errors==0" \
        --format json > ui_performance_results.json
  artifacts:
    paths:
      - ui_performance_results.json
    expire_in: 1 week

Jobs derselben Stufe laufen parallel, und jeder Test, den sie starten, zählt auf das Limit paralleler Tests Ihres Tarifs. Um diese Tests nach einem Zeitplan statt bei jedem Push auszuführen, erstellen Sie einen Pipeline-Zeitplan in GitLab:

Gehen Sie zu Ihrem GitLab-Projekt
Navigieren Sie zu CI/CD > Schedules
Klicken Sie auf "New schedule"
Richten Sie einen Zeitplan ein (z. B. täglich um Mitternacht)

Integration mit GitLab-Funktionen

Merge-Request-Widgets

Zeigen Sie Performance-Testergebnisse in Merge Requests mit der JUnit-Report-Funktion von GitLab an:

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Run performance test
    - npm install -g @loadfocus/loadfocus-api-client
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID
    - |
      loadfocus-api jmeter run-test \
        --name "GitLab_${CI_PROJECT_NAME}_${CI_COMMIT_REF_NAME}" \
        --thresholds "avgresponse<=200,errors==0,p95<=250" \
        --format json > performance_results.json

    # Convert to JUnit format (using a custom script)
    - node convert-to-junit.js performance_results.json junit-report.xml
  artifacts:
    reports:
      junit: junit-report.xml
    paths:
      - performance_results.json
    expire_in: 1 week

GitLab-Metriken

Nutzen Sie die Metrik-Funktion von GitLab, um die Performance im Zeitverlauf zu verfolgen:

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Run performance test
    - npm install -g @loadfocus/loadfocus-api-client
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID
    - |
      loadfocus-api jmeter run-test \
        --name "GitLab_${CI_PROJECT_NAME}_${CI_COMMIT_REF_NAME}" \
        --thresholds "avgresponse<=200,errors==0,p95<=250" \
        --format json > performance_results.json

    # Extract metrics and report them to GitLab
    - |
      # Parse JSON and extract metrics
      RESPONSE_TIME=$(sed -n '/^{$/,$p' performance_results.json | jq '.labels[0].metrics.avgresponse')
      ERROR_RATE=$(sed -n '/^{$/,$p' performance_results.json | jq '.labels[0].metrics.errors')

      # Report metrics
      echo "performance_avg_response_time ${RESPONSE_TIME}" >> metrics.txt
      echo "performance_error_rate ${ERROR_RATE}" >> metrics.txt
  artifacts:
    reports:
      metrics: metrics.txt
    paths:
      - performance_results.json
    expire_in: 1 week

GitLab-Umgebungen

Ordnen Sie Performance-Tests bestimmten Umgebungen zu:

performance_test_staging:
  stage: performance
  image: node:${NODE_VERSION}
  environment:
    name: staging
  script:
    - npm install -g @loadfocus/loadfocus-api-client
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID
    - |
      loadfocus-api jmeter run-test \
        --name "Staging_Performance_Test" \
        --thresholds "avgresponse<=250,errors==0" \
        --format json > performance_results.json
  artifacts:
    paths:
      - performance_results.json
    expire_in: 1 week
  only:
    - staging

Tipps für die GitLab CI/CD-Integration

Caching: npm-Abhängigkeiten cachen, um Pipeline-Läufe zu beschleunigen:

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  cache:
    key: ${CI_COMMIT_REF_SLUG}
    paths:
      - node_modules/
  script:
    - npm install -g @loadfocus/loadfocus-api-client
    # Rest of the script...

Timeout-Einstellungen: Timeouts für lang laufende Leistungstests festlegen:

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  timeout: 2h  # Set a 2-hour timeout
  script:
    # Performance test script...

Manuelle Auslöser: Leistungstests manuell auslösen lassen:

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Performance test script...
  when: manual

Dynamische Testkonfiguration: Nutzen Sie die vordefinierten GitLab-Variablen, um Tests dynamisch zu konfigurieren:

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    - |
      # Set thresholds based on branch
      if [ "$CI_COMMIT_REF_NAME" = "main" ]; then
        THRESHOLDS="avgresponse<=200,errors==0,p95<=250"
      else
        THRESHOLDS="avgresponse<=300,errors==0,p95<=500"
      fi

      loadfocus-api jmeter run-test \
        --name "GitLab_${CI_PROJECT_NAME}_${CI_COMMIT_REF_NAME}" \
        --thresholds "$THRESHOLDS" \
        --format json > performance_results.json

Benachrichtigungen: Senden Sie Benachrichtigungen, wenn Performance-Tests fehlschlagen:

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Performance test script...
  after_script:
    - |
      if [ "$CI_JOB_STATUS" = "failed" ]; then
        # Send notification using curl, GitLab API, or other method
        curl -X POST -H "Content-Type: application/json" \
          -d "{\"text\":\"Performance test failed for ${CI_PROJECT_NAME}\"}" \
          $WEBHOOK_URL
      fi

Weitere Informationen finden Sie in der GitLab CI/CD-Dokumentation und der LoadFocus API Client-Dokumentation.