Algolia

    GitLab CI/CD

    Esta guía explica cómo integrar el Cliente API de JMeter de LoadFocus con GitLab CI/CD para pruebas de rendimiento automatizadas.

    Pasos de Configuración

    1. Almacenar Credenciales como Variables de GitLab CI/CD

    Primero, almacena tus credenciales de API de LoadFocus como variables de GitLab CI/CD:

    1. Ve a tu proyecto de GitLab
    2. Navega a Settings > CI/CD > Variables
    3. Agrega las siguientes variables:
      • LOADFOCUS_API_KEY: Tu clave API de LoadFocus (marca como "Masked")
      • LOADFOCUS_TEAM_ID: Tu ID de equipo de LoadFocus

    2. Crear un Pipeline de GitLab CI/CD

    Crea o actualiza tu archivo .gitlab-ci.yml en tu repositorio:

    stages:
      - build
      - test
      - performance
      - deploy
    

    variables:
      NODE_VERSION: "16"
    

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

        # Configurar Cliente API de LoadFocus
        - loadfocus-api config set apikey $LOADFOCUS_API_KEY
        - loadfocus-api config set teamid $LOADFOCUS_TEAM_ID
    

        # Ejecutar Pruebas de Rendimiento
        - |
          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
      artifacts:
        paths:
          - performance_results.json
        expire_in: 1 week
        when: always
      # Opcional: Solo ejecutar en ramas específicas
      only:
        - main
        - develop
    

    deploy:
      stage: deploy
      script:
        - echo "Deploying application..."
      only:
        - main
      # Solo desplegar si todas las etapas anteriores tuvieron éxito
      when: on_success

    3. Ver Resultados de Pruebas

    Después de que el pipeline se ejecute:

    1. Ve a tu proyecto de GitLab
    2. Navega a CI/CD > Pipelines
    3. Encuentra tu pipeline y haz clic en él
    4. Ve al job "performance_test"
    5. Haz clic en "Browse" en la barra lateral derecha para ver los artefactos
    6. Descarga y visualiza el archivo performance_results.json

    Configuración Avanzada

    Pruebas Específicas por Entorno

    Ejecuta diferentes pruebas de rendimiento para diferentes entornos:

    .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
        - loadfocus-api config set 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

    Pruebas en Paralelo

    Ejecuta múltiples pruebas de rendimiento en paralelo:

    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
        - loadfocus-api config set 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
        - loadfocus-api config set 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

    Luego crea un horario de pipeline en GitLab:

    1. Ve a tu proyecto de GitLab
    2. Navega a CI/CD > Schedules
    3. Haz clic en "New schedule"
    4. Configura un horario (por ejemplo, todos los días a medianoche)

    Crear Informes de Rendimiento

    Genera informes HTML a partir de resultados JSON:

    performance_test:
      stage: performance
      image: node:${NODE_VERSION}
      script:
        # Ejecutar prueba de rendimiento
        - npm install -g @loadfocus/loadfocus-api-client
        - loadfocus-api config set apikey $LOADFOCUS_API_KEY
        - loadfocus-api config set 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
    

        # Generar informe HTML
        - npm install -g performance-report-generator  # Reemplazar con el generador de informes real
        - performance-report-generator --input performance_results.json --output performance_report.html
      artifacts:
        paths:
          - performance_results.json
          - performance_report.html
        expire_in: 1 week
        when: always
      # Opcional: Publicar informe como GitLab Pages
      pages:
        stage: deploy
        dependencies:
          - performance_test
        script:
          - mkdir -p public/performance-reports
          - cp performance_report.html public/performance-reports/index.html
        artifacts:
          paths:
            - public
        only:
          - main

    Integración con Funcionalidades de GitLab

    Widgets de Merge Request

    Muestra los resultados de pruebas de rendimiento en merge requests usando la funcionalidad de informes JUnit de GitLab:

    performance_test:
      stage: performance
      image: node:${NODE_VERSION}
      script:
        # Ejecutar prueba de rendimiento
        - npm install -g @loadfocus/loadfocus-api-client
        - loadfocus-api config set apikey $LOADFOCUS_API_KEY
        - loadfocus-api config set 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 a formato JUnit (usando un script personalizado)
        - 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étricas de GitLab

    Usa la funcionalidad de métricas de GitLab para rastrear el rendimiento a lo largo del tiempo:

    performance_test:
      stage: performance
      image: node:${NODE_VERSION}
      script:
        # Ejecutar prueba de rendimiento
        - npm install -g @loadfocus/loadfocus-api-client
        - loadfocus-api config set apikey $LOADFOCUS_API_KEY
        - loadfocus-api config set 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
    

        # Extraer métricas e informarlas a GitLab
        - |
          # Analizar JSON y extraer métricas
          RESPONSE_TIME=$(jq '.labels[0].metrics.avgresponse' performance_results.json)
          ERROR_RATE=$(jq '.labels[0].metrics.errors' performance_results.json)
    

          # Informar métricas
          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

    Entornos de GitLab

    Asocia pruebas de rendimiento con entornos específicos:

    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
        - loadfocus-api config set 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

    Consejos para la Integración con GitLab CI/CD

    1. Caché: Almacena en caché las dependencias de npm para acelerar las ejecuciones del 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
          # Resto del script...

    2. Configuración de Tiempo de Espera: Establece tiempos de espera para pruebas de rendimiento de larga duración:

      performance_test:
        stage: performance
        image: node:${NODE_VERSION}
        timeout: 2h  # Establecer un tiempo de espera de 2 horas
        script:
          # Script de prueba de rendimiento...

    3. Disparadores Manuales: Permite que las pruebas de rendimiento se disparen manualmente:

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

    4. Configuración Dinámica de Pruebas: Usa variables predefinidas de GitLab para configurar pruebas dinámicamente:

      performance_test:
        stage: performance
        image: node:${NODE_VERSION}
        script:
          - |
            # Establecer umbrales según la rama
            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

    5. Notificaciones: Envía notificaciones cuando fallen las pruebas de rendimiento:

      performance_test:
        stage: performance
        image: node:${NODE_VERSION}
        script:
          # Script de prueba de rendimiento...
        after_script:
          - |
            if [ $? -ne 0 ]; then
              # Enviar notificación usando curl, API de GitLab u otro método
              curl -X POST -H "Content-Type: application/json" \
                -d "{\"text\":\"Performance test failed for ${CI_PROJECT_NAME}\"}" \
                $WEBHOOK_URL
            fi

    Para más información, consulta la documentación de GitLab CI/CD y la documentación del Cliente API de LoadFocus.

    Anterior
    GitHub Actions
    Siguiente
    Jenkins