GitLab CI/CD

Ce guide montre comment lancer un test JMeter LoadFocus depuis un pipeline GitLab CI/CD, attendre sa fin et faire échouer le pipeline 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 pipeline lance ce test enregistré par son nom.

Étapes de configuration

1. Stocker les identifiants en tant que variables GitLab CI/CD

Tout d'abord, stockez vos identifiants API LoadFocus en tant que variables GitLab CI/CD :

Accédez à votre projet GitLab
Allez dans Settings > CI/CD > Variables
Ajoutez les variables suivantes :
- LOADFOCUS_API_KEY : Votre clé API LoadFocus (marquez comme "Masked")
- 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 pipeline GitLab CI/CD

Créez ou mettez à jour votre fichier .gitlab-ci.yml dans votre dépôt :

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:
    # Installer le client API JMeter de LoadFocus
    - npm install -g @loadfocus/loadfocus-api-client

    # Configurer le client API LoadFocus
    - loadfocus-api config set --apikey $LOADFOCUS_API_KEY --teamid $LOADFOCUS_TEAM_ID

    # Exécuter les tests de performance. --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
  artifacts:
    paths:
      - performance_results.json
    expire_in: 1 week
    when: always
  # Optionnel : Executer uniquement sur des branches specifiques
  only:
    - main
    - develop

deploy:
  stage: deploy
  script:
    - echo "Deploying application..."
  only:
    - main
  # Deployer uniquement si toutes les etapes precedentes ont reussi
  when: on_success

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 le job échoue, donc l'étape deploy ne s'exécute pas. 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 GitLab_... 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. Consulter les résultats des tests

Après l'exécution du pipeline :

Accédez à votre projet GitLab
Allez dans CI/CD > Pipelines
Trouvez votre pipeline et cliquez dessus
Allez au job "performance_test"
Cliquez sur "Browse" dans la barre latérale droite pour consulter les artefacts
Téléchargez et consultez le fichier performance_results.json

Configuration avancée

Tests spécifiques à l'environnement

Exécutez différents tests de performance pour différents environnements :

.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

Tests parallèles

Exécutez plusieurs tests de performance en parallèle :

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

Les jobs d'une même étape s'exécutent en parallèle, et chaque test qu'ils lancent compte dans la limite de tests parallèles de votre forfait. Pour exécuter ces tests sur un minuteur plutôt qu'à chaque push, créez une planification de pipeline dans GitLab :

Accédez à votre projet GitLab
Allez dans CI/CD > Schedules
Cliquez sur "New schedule"
Configurez un planning (par exemple, chaque jour à minuit)

Intégration avec les fonctionnalités GitLab

Widgets de merge request

Affichez les résultats des tests de performance dans les merge requests en utilisant la fonctionnalité de rapport JUnit de GitLab :

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Executer le test de performance
    - 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

    # Convertir au format JUnit (en utilisant un script personnalise)
    - 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

Métriques GitLab

Utilisez la fonctionnalité de métriques de GitLab pour suivre les performances au fil du temps :

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Executer le test de performance
    - 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

    # Extraire les metriques et les rapporter a GitLab
    - |
      # Analyser le JSON et extraire les metriques
      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')

      # Rapporter les metriques
      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

Environnements GitLab

Associez les tests de performance à des environnements spécifiques :

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

Conseils pour l'intégration GitLab CI/CD

Mise en cache : Mettez en cache les dépendances npm pour accélérer les exécutions du pipeline :

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
    # Reste du script...

Paramètres de délai d'attente : Définissez des délais pour les tests de performance de longue durée :

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  timeout: 2h  # Definir un delai de 2 heures
  script:
    # Script de test de performance...

Déclenchements manuels : Permettez le déclenchement manuel des tests de performance :

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

Configuration dynamique des tests : Utilisez les variables prédéfinies de GitLab pour configurer dynamiquement les tests :

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    - |
      # Definir les seuils en fonction de la branche
      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

Notifications : Envoyez des notifications en cas d'échec des tests de performance :

performance_test:
  stage: performance
  image: node:${NODE_VERSION}
  script:
    # Script de test de performance...
  after_script:
    - |
      if [ "$CI_JOB_STATUS" = "failed" ]; then
        # Envoyer une notification via curl, l'API GitLab ou une autre methode
        curl -X POST -H "Content-Type: application/json" \
          -d "{\"text\":\"Performance test failed for ${CI_PROJECT_NAME}\"}" \
          $WEBHOOK_URL
      fi

Pour plus d'informations, consultez la documentation GitLab CI/CD et la documentation du client API LoadFocus.

CircleCI

Jenkins