Azure DevOps

Esta guía muestra cómo iniciar una prueba JMeter de LoadFocus desde un pipeline de Azure DevOps, esperar a que termine y hacer fallar el pipeline cuando no se cumple un umbral. Usa el LoadFocus API Client (loadfocus-api, instalado desde npm). Primero crea y guarda la prueba en LoadFocus, consulta Cómo ejecutar una nueva prueba de carga con Apache JMeter; el pipeline inicia esa prueba guardada por su nombre, así que --name debe ser el nombre exacto de tu prueba guardada.

run-test inicia la prueba guardada, espera a que termine y comprueba los umbrales. Si no se cumple algún umbral, o la ejecución falla, el comando termina con código 1 y el paso falla. Los umbrales se comprueban para cada etiqueta de petición por separado, y errors es un recuento de peticiones fallidas, no un porcentaje. En los ejemplos siguientes, sustituye My_JMeter_Test por el nombre exacto de tu prueba guardada.

El archivo de salida empieza con algunas líneas de progreso antes del objeto JSON. Para obtener un JSON limpio, conserva solo las líneas desde la primera que contiene únicamente {: sed -n '/^{$/,$p' performance_results.json > results.json.

Pasos de Configuración

1. Almacenar Credenciales en Azure Key Vault

Para una gestión segura de credenciales, almacena tus credenciales de API de LoadFocus en Azure Key Vault:

Crea un Key Vault en Azure si no tienes uno
Agrega los siguientes secretos:
- loadfocus-api-key: Tu clave API de LoadFocus
- loadfocus-team-id: Tu ID de equipo de LoadFocus
Configura una conexión de servicio para acceder al Key Vault desde tu pipeline

2. Crear un Pipeline de Azure

Crea un nuevo archivo llamado azure-pipelines.yml en tu repositorio:

trigger:
  - main
  - develop

pool:
  vmImage: 'ubuntu-latest'

variables:
  - group: loadfocus-variables  # Grupo de variables que contiene referencias al Key Vault

stages:
  - stage: Build
    jobs:
      - job: BuildAndTest
        steps:
          # Tus pasos existentes de compilación y prueba...

  - 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:
          # Tus pasos de despliegue...

3. Configurar Grupo de Variables con Integración de Key Vault

Ve a Pipelines > Library > Variable Groups
Crea un nuevo Grupo de Variables llamado "loadfocus-variables"
Vincúlalo a tu Azure Key Vault
Agrega las siguientes variables, vinculándolas a los secretos de tu Key Vault:
- LOADFOCUS_API_KEY: Vinculado al secreto loadfocus-api-key
- LOADFOCUS_TEAM_ID: Vinculado al secreto loadfocus-team-id

Configuración Avanzada

Uso de Plantillas YAML

Para pasos de pruebas de rendimiento reutilizables, crea un archivo de plantilla 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

Luego en tu pipeline principal:

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

Ejecutar Múltiples Pruebas

Para ejecutar múltiples pruebas de rendimiento en secuencia:

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

    # Ejecutar prueba de UI
    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'

Integración con Azure Test Plans

Para integrar los resultados de pruebas de rendimiento con Azure Test Plans:

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

LoadFocus no ofrece un conversor a JUnit, así que debes convertir tú mismo la salida JSON a JUnit con un script como el convert-to-junit.js de abajo (quita primero las líneas de progreso, consulta la nota al principio de esta página):

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

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

Consejos para la Integración con Azure DevOps

Jobs en Paralelo: Si tienes múltiples pruebas de rendimiento, considera usar jobs en paralelo Tu plan de LoadFocus limita cuántas pruebas pueden ejecutarse a la vez; por encima de ese límite el cliente informa "Maximum number of parallel tests exceeded for your plan.":
```
jobs:
- job: API_Performance_Test
  steps:
    # Ejecutar prueba de rendimiento de API

- job: UI_Performance_Test
  steps:
    # Ejecutar prueba de rendimiento de UI
```

Puertas de Despliegue: Usa los resultados de pruebas de rendimiento como puerta de despliegue:

- job: DeploymentGate
  steps:
  - script: |
      # Verificar si las pruebas de rendimiento pasaron
      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

Panel Personalizado: Crea un panel personalizado para visualizar los resultados de pruebas de rendimiento a lo largo del tiempo.
Notificaciones: Azure DevOps no tiene una tarea de correo integrada para pipelines. Usa las notificaciones de compilaciones fallidas en Configuración del proyecto > Notificaciones, o añade una tarea de una extensión de tu elección, para avisar a tu equipo cuando falle el paso de rendimiento.

Para más información, consulta la documentación de Azure DevOps y la documentación del Cliente API de LoadFocus.