Algolia

    Jenkins

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

    Pasos de Configuración

    1. Almacenar Credenciales en Jenkins

    Primero, almacena tus credenciales de API de LoadFocus de forma segura en Jenkins:

    1. Navega a Jenkins Dashboard > Manage Jenkins > Manage Credentials
    2. Selecciona el dominio de credenciales apropiado (por ejemplo, global)
    3. Haz clic en "Add Credentials"
    4. Agrega las siguientes credenciales:
      • Kind: Secret text
      • Scope: Global
      • Secret: Tu clave API de LoadFocus
      • ID: loadfocus-api-key
      • Description: LoadFocus API Key
    5. Repite el proceso para tu ID de equipo con ID: loadfocus-team-id

    2. Crear un Pipeline de Jenkins

    Crea un Jenkinsfile en tu repositorio:

    pipeline {
        agent {
            docker {
                image 'node:16-alpine'
            }
        }
    

        environment {
            LOADFOCUS_API_KEY = credentials('loadfocus-api-key')
            LOADFOCUS_TEAM_ID = credentials('loadfocus-team-id')
        }
    

        stages {
            stage('Build') {
                steps {
                    // Tus pasos de compilación
                    sh 'npm install'
                    sh 'npm run build'
                }
            }
    

            stage('Test') {
                steps {
                    // Tus pasos de prueba
                    sh 'npm test'
                }
            }
    

            stage('Performance Test') {
                steps {
                    // Instalar Cliente API de JMeter de LoadFocus
                    sh 'npm install -g @loadfocus/loadfocus-api-client'
    

                    // Configurar Cliente API de LoadFocus
                    sh 'loadfocus-api config set apikey $LOADFOCUS_API_KEY'
                    sh 'loadfocus-api config set teamid $LOADFOCUS_TEAM_ID'
    

                    // Ejecutar Pruebas de Rendimiento
                    sh '''
                        loadfocus-api jmeter run-test \
                          --name "Jenkins_${JOB_NAME}_${BUILD_NUMBER}" \
                          --thresholds "avgresponse<=200,errors==0,p95<=250" \
                          --format json > performance_results.json
                    '''
    

                    // Archivar los resultados
                    archiveArtifacts artifacts: 'performance_results.json', fingerprint: true
                }
            }
    

            stage('Deploy') {
                when {
                    expression {
                        return currentBuild.resultIsBetterOrEqualTo('SUCCESS')
                    }
                }
                steps {
                    // Tus pasos de despliegue
                    echo 'Deploying...'
                }
            }
        }
    

        post {
            always {
                // Limpiar espacio de trabajo
                cleanWs()
            }
        }
    }

    3. Configurar el Job de Jenkins

    1. Crea un nuevo job de Pipeline en Jenkins
    2. Configura el Pipeline para usar tu Jenkinsfile
    3. Configura la configuración SCM apropiada para obtener tu repositorio

    Configuración Avanzada

    Pipeline Declarativo con Pruebas en Paralelo

    Ejecuta múltiples pruebas de rendimiento en paralelo:

    pipeline {
        agent any
    

        environment {
            LOADFOCUS_API_KEY = credentials('loadfocus-api-key')
            LOADFOCUS_TEAM_ID = credentials('loadfocus-team-id')
        }
    

        stages {
            // Etapas anteriores...
    

            stage('Performance Tests') {
                parallel {
                    stage('API Performance') {
                        agent {
                            docker {
                                image 'node:16-alpine'
                            }
                        }
                        steps {
                            sh 'npm install -g @loadfocus/loadfocus-api-client'
                            sh 'loadfocus-api config set apikey $LOADFOCUS_API_KEY'
                            sh 'loadfocus-api config set teamid $LOADFOCUS_TEAM_ID'
                            sh '''
                                loadfocus-api jmeter run-test \
                                  --name "API_Performance_Test" \
                                  --thresholds "avgresponse<=150,errors==0" \
                                  --format json > api_performance_results.json
                            '''
                            archiveArtifacts artifacts: 'api_performance_results.json', fingerprint: true
                        }
                    }
    

                    stage('UI Performance') {
                        agent {
                            docker {
                                image 'node:16-alpine'
                            }
                        }
                        steps {
                            sh 'npm install -g @loadfocus/loadfocus-api-client'
                            sh 'loadfocus-api config set apikey $LOADFOCUS_API_KEY'
                            sh 'loadfocus-api config set teamid $LOADFOCUS_TEAM_ID'
                            sh '''
                                loadfocus-api jmeter run-test \
                                  --name "UI_Performance_Test" \
                                  --thresholds "avgresponse<=300,errors==0" \
                                  --format json > ui_performance_results.json
                            '''
                            archiveArtifacts artifacts: 'ui_performance_results.json', fingerprint: true
                        }
                    }
                }
            }
    

            // Siguientes etapas...
        }
    }

    Pipeline con Script

    Para mayor flexibilidad, usa un pipeline con script:

    node {
        def performanceTestPassed = false
    

        stage('Checkout') {
            checkout scm
        }
    

        stage('Build & Test') {
            // Tus pasos de compilación y prueba
        }
    

        stage('Performance Test') {
            docker.image('node:16-alpine').inside {
                withCredentials([
                    string(credentialsId: 'loadfocus-api-key', variable: 'LOADFOCUS_API_KEY'),
                    string(credentialsId: 'loadfocus-team-id', variable: 'LOADFOCUS_TEAM_ID')
                ]) {
                    sh 'npm install -g @loadfocus/loadfocus-api-client'
                    sh 'loadfocus-api config set apikey $LOADFOCUS_API_KEY'
                    sh 'loadfocus-api config set teamid $LOADFOCUS_TEAM_ID'
    

                    try {
                        sh '''
                            loadfocus-api jmeter run-test \
                              --name "Jenkins_${JOB_NAME}_${BUILD_NUMBER}" \
                              --thresholds "avgresponse<=200,errors==0,p95<=250" \
                              --format json > performance_results.json
                        '''
    

                        // Verificar si la prueba pasó examinando el JSON
                        def testResults = readJSON file: 'performance_results.json'
                        if (testResults.overallResult == 'PASSED') {
                            performanceTestPassed = true
                            echo "Performance test passed!"
                        } else {
                            echo "Performance test failed to meet thresholds!"
                            // Opcional: Fallar la compilación
                            // error "Performance test failed"
                        }
                    } catch (Exception e) {
                        echo "Error running performance test: ${e.message}"
                    }
    

                    archiveArtifacts artifacts: 'performance_results.json', fingerprint: true
                }
            }
        }
    

        stage('Deploy') {
            if (performanceTestPassed) {
                echo 'Deploying...'
                // Tus pasos de despliegue
            } else {
                echo 'Skipping deployment due to performance test failure'
            }
        }
    }

    Biblioteca Compartida

    Crea una biblioteca compartida para pruebas de rendimiento reutilizables:

    // vars/performanceTest.groovy
    def call(Map config = [:]) {
        def testName = config.testName ?: "Jenkins_${env.JOB_NAME}_${env.BUILD_NUMBER}"
        def thresholds = config.thresholds ?: "avgresponse<=200,errors==0,p95<=250"
        def waitTimeout = config.waitTimeout ?: 1800
        def resultsFile = config.resultsFile ?: "performance_results.json"
    

        docker.image('node:16-alpine').inside {
            withCredentials([
                string(credentialsId: 'loadfocus-api-key', variable: 'LOADFOCUS_API_KEY'),
                string(credentialsId: 'loadfocus-team-id', variable: 'LOADFOCUS_TEAM_ID')
            ]) {
                sh 'npm install -g @loadfocus/loadfocus-api-client'
                sh 'loadfocus-api config set apikey $LOADFOCUS_API_KEY'
                sh 'loadfocus-api config set teamid $LOADFOCUS_TEAM_ID'
    

                sh """
                    loadfocus-api jmeter run-test \\
                      --name "${testName}" \\
                      --thresholds "${thresholds}" \\
                      --waitTimeout ${waitTimeout} \\
                      --format json > ${resultsFile}
                """
    

                archiveArtifacts artifacts: resultsFile, fingerprint: true
    

                // Devolver los resultados de la prueba
                def testResults = readJSON file: resultsFile
                return testResults
            }
        }
    }

    Luego en tu Jenkinsfile:

    @Library('my-shared-library') _
    

    pipeline {
        agent any
    

        stages {
            stage('Performance Test') {
                steps {
                    script {
                        def results = performanceTest(
                            testName: "API_Performance_Test",
                            thresholds: "avgresponse<=150,errors==0"
                        )
    

                        if (results.overallResult != 'PASSED') {
                            error "Performance test failed"
                        }
                    }
                }
            }
        }
    }

    Integración con Plugins de Jenkins

    Plugin de Rendimiento

    Usa el Plugin de Rendimiento de Jenkins para visualizar los resultados de las pruebas:

    1. Instala el Plugin de Rendimiento en Jenkins
    2. Convierte los resultados de LoadFocus a un formato compatible con el plugin (CSV de JMeter o XML de JUnit)
    3. Configura tu pipeline:
    stage('Performance Test') {
        steps {
            // Ejecutar prueba de LoadFocus
            sh '''
                loadfocus-api jmeter run-test \
                  --name "Jenkins_${JOB_NAME}_${BUILD_NUMBER}" \
                  --thresholds "avgresponse<=200,errors==0,p95<=250" \
                  --format json > performance_results.json
    

                # Convertir a formato CSV de JMeter (usando un script personalizado)
                node convert-to-jmeter.js performance_results.json performance_results.csv
            '''
    

            // Usar Plugin de Rendimiento
            perfReport sourceDataFiles: 'performance_results.csv',
                       errorFailedThreshold: 0,
                       errorUnstableThreshold: 0,
                       errorUnstableResponseTimeThreshold: '200'
        }
    }

    Notificación por Correo Electrónico

    Envía notificaciones por correo electrónico con los resultados de las pruebas:

    post {
        always {
            script {
                if (fileExists('performance_results.json')) {
                    def results = readJSON file: 'performance_results.json'
                    def resultStatus = results.overallResult == 'PASSED' ? 'SUCCESS' : 'FAILURE'
                    def subject = "Performance Test ${resultStatus}: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
    

                    // Crear cuerpo del correo
                    def body = """
                    <h2>Performance Test Results</h2>
                    <p><strong>Overall Result:</strong> ${results.overallResult}</p>
                    <h3>Results by Label</h3>
                    <table border="1">
                    <tr><th>Label</th><th>Result</th><th>Avg Response</th><th>Errors</th></tr>
                    """
    

                    results.labels.each { label ->
                        body += """
                        <tr>
                            <td>${label.label}</td>
                            <td>${label.result}</td>
                            <td>${label.metrics.avgresponse}ms</td>
                            <td>${label.metrics.errors}</td>
                        </tr>
                        """
                    }
    

                    body += "</table>"
    

                    emailext (
                        subject: subject,
                        body: body,
                        to: 'team@example.com',
                        attachmentsPattern: 'performance_results.json',
                        mimeType: 'text/html'
                    )
                }
            }
        }
    }

    Consejos para la Integración con Jenkins

    1. Manejo de Tiempo de Espera: Establece tiempos de espera para pruebas de rendimiento de larga duración:

      stage('Performance Test') {
          options {
              timeout(time: 60, unit: 'MINUTES')
          }
          steps {
              // Pasos de prueba de rendimiento
          }
      }

    2. Ejecución Condicional: Ejecuta pruebas de rendimiento solo en ramas específicas:

      stage('Performance Test') {
          when {
              anyOf {
                  branch 'main'
                  branch 'develop'
                  tag pattern: "v\\d+\\.\\d+\\.\\d+", comparator: "REGEXP"
              }
          }
          steps {
              // Pasos de prueba de rendimiento
          }
      }

    3. Pruebas Programadas: Ejecuta pruebas de rendimiento según un horario:

      pipeline {
          agent any
      

          triggers {
              cron('0 0 * * *')  // Ejecutar a medianoche todos los días
          }
      

          stages {
              // Etapas del pipeline
          }
      }

    4. Pruebas Parametrizadas: Permite la personalización de parámetros de prueba:

      pipeline {
          agent any
      

          parameters {
              string(name: 'TEST_NAME', defaultValue: 'API_Performance_Test', description: 'Name of the LoadFocus test to run')
              string(name: 'THRESHOLDS', defaultValue: 'avgresponse<=200,errors==0', description: 'Performance thresholds')
              string(name: 'WAIT_TIMEOUT', defaultValue: '1800', description: 'Maximum wait time in seconds')
          }
      

          stages {
              stage('Performance Test') {
                  steps {
                      // Ejecutar prueba con parámetros
                      sh """
                          loadfocus-api jmeter run-test \\
                            --name "${params.TEST_NAME}" \\
                            --thresholds "${params.THRESHOLDS}" \\
                            --waitTimeout ${params.WAIT_TIMEOUT} \\
                            --format json > performance_results.json
                      """
                  }
              }
          }
      }

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

    Anterior
    GitLab CI/CD
    Siguiente
    Integrar el Cliente API de JMeter con Pipelines de CI/CD