Algolia

    Jenkins

    Este guia explica como integrar o Cliente API JMeter do LoadFocus com o Jenkins para testes de desempenho automatizados.

    Passos de Configuracao

    1. Armazenar Credenciais no Jenkins

    Primeiro, armazene as suas credenciais da API do LoadFocus de forma segura no Jenkins:

    1. Navegue ate Jenkins Dashboard > Manage Jenkins > Manage Credentials
    2. Selecione o dominio de credenciais apropriado (por exemplo, global)
    3. Clique em "Add Credentials"
    4. Adicione as seguintes credenciais:
      • Kind: Secret text
      • Scope: Global
      • Secret: A sua API key do LoadFocus
      • ID: loadfocus-api-key
      • Description: LoadFocus API Key
    5. Repita para o seu team ID com ID: loadfocus-team-id

    2. Criar um Pipeline Jenkins

    Crie um Jenkinsfile no seu 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 {
                    // Your build steps
                    sh 'npm install'
                    sh 'npm run build'
                }
            }
    

            stage('Test') {
                steps {
                    // Your test steps
                    sh 'npm test'
                }
            }
    

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

                    // Configure LoadFocus API Client
                    sh 'loadfocus-api config set apikey $LOADFOCUS_API_KEY'
                    sh 'loadfocus-api config set teamid $LOADFOCUS_TEAM_ID'
    

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

                    // Archive the results
                    archiveArtifacts artifacts: 'performance_results.json', fingerprint: true
                }
            }
    

            stage('Deploy') {
                when {
                    expression {
                        return currentBuild.resultIsBetterOrEqualTo('SUCCESS')
                    }
                }
                steps {
                    // Your deployment steps
                    echo 'Deploying...'
                }
            }
        }
    

        post {
            always {
                // Clean up workspace
                cleanWs()
            }
        }
    }

    3. Configurar o Job Jenkins

    1. Crie um novo job Pipeline no Jenkins
    2. Configure o Pipeline para utilizar o seu Jenkinsfile
    3. Configure a configuracao SCM apropriada para obter o seu repositorio

    Configuracao Avancada

    Pipeline Declarativo com Testes Paralelos

    Execute multiplos testes de desempenho em paralelo:

    pipeline {
        agent any
    

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

        stages {
            // Previous stages...
    

            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
                        }
                    }
                }
            }
    

            // Next stages...
        }
    }

    Pipeline Scripted

    Para maior flexibilidade, utilize um pipeline scripted:

    node {
        def performanceTestPassed = false
    

        stage('Checkout') {
            checkout scm
        }
    

        stage('Build & Test') {
            // Your build and test steps
        }
    

        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
                        '''
    

                        // Check if test passed by examining the 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!"
                            // Optional: Fail the build
                            // 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...'
                // Your deployment steps
            } else {
                echo 'Skipping deployment due to performance test failure'
            }
        }
    }

    Biblioteca Partilhada

    Crie uma biblioteca partilhada para testes de desempenho reutilizaveis:

    // 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
    

                // Return the test results
                def testResults = readJSON file: resultsFile
                return testResults
            }
        }
    }

    Depois no seu 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"
                        }
                    }
                }
            }
        }
    }

    Integracao com Plugins Jenkins

    Plugin Performance

    Utilize o Jenkins Performance Plugin para visualizar os resultados dos testes:

    1. Instale o Performance Plugin no Jenkins
    2. Converta os resultados do LoadFocus para um formato suportado pelo plugin (JMeter CSV ou JUnit XML)
    3. Configure o seu pipeline:
    stage('Performance Test') {
        steps {
            // Run LoadFocus test
            sh '''
                loadfocus-api jmeter run-test \
                  --name "Jenkins_${JOB_NAME}_${BUILD_NUMBER}" \
                  --thresholds "avgresponse<=200,errors==0,p95<=250" \
                  --format json > performance_results.json
    

                # Convert to JMeter CSV format (using a custom script)
                node convert-to-jmeter.js performance_results.json performance_results.csv
            '''
    

            // Use Performance Plugin
            perfReport sourceDataFiles: 'performance_results.csv',
                       errorFailedThreshold: 0,
                       errorUnstableThreshold: 0,
                       errorUnstableResponseTimeThreshold: '200'
        }
    }

    Notificacao por Email

    Envie notificacoes por email com os resultados dos testes:

    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}"
    

                    // Create email body
                    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'
                    )
                }
            }
        }
    }

    Dicas para Integracao com Jenkins

    1. Gestao de Timeout: Defina timeouts para testes de desempenho de longa duracao:

      stage('Performance Test') {
          options {
              timeout(time: 60, unit: 'MINUTES')
          }
          steps {
              // Performance test steps
          }
      }

    2. Execucao Condicional: Execute testes de desempenho apenas em branches especificos:

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

    3. Testes Agendados: Execute testes de desempenho com agendamento:

      pipeline {
          agent any
      

          triggers {
              cron('0 0 * * *')  // Run at midnight every day
          }
      

          stages {
              // Pipeline stages
          }
      }

    4. Testes Parametrizados: Permita a personalizacao dos parametros de teste:

      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 {
                      // Run test with parameters
                      sh """
                          loadfocus-api jmeter run-test \\
                            --name "${params.TEST_NAME}" \\
                            --thresholds "${params.THRESHOLDS}" \\
                            --waitTimeout ${params.WAIT_TIMEOUT} \\
                            --format json > performance_results.json
                      """
                  }
              }
          }
      }

    Para mais informacoes, consulte a documentacao do Jenkins e a documentacao do Cliente API do LoadFocus.

    Anterior
    GitLab CI/CD
    Seguinte
    Integrar o Cliente API JMeter com Pipelines CI/CD