GitHub Actions

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

Pasos de Configuración

1. Almacenar Credenciales como Secretos de GitHub

Primero, almacena tus credenciales de API de LoadFocus como secretos del repositorio de GitHub:

  1. Ve a tu repositorio de GitHub
  2. Navega a Settings > Secrets and variables > Actions
  3. Agrega los siguientes secretos del repositorio:
    • LOADFOCUS_API_KEY: Tu clave API de LoadFocus
    • LOADFOCUS_TEAM_ID: Tu ID de equipo de LoadFocus

2. Crear un Flujo de Trabajo de GitHub Actions

Crea un nuevo archivo en tu repositorio en .github/workflows/performance-test.yml:

name: Performance Tests


on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  # Opcional: Ejecutar según un horario
  schedule:
    - cron: '0 0 * * 1'  # Ejecutar a medianoche todos los lunes


jobs:
  performance-test:
    runs-on: ubuntu-latest


    steps:
    - uses: actions/checkout@v3


    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '16'


    - name: Install LoadFocus JMeter API Client
      run: npm install -g @loadfocus/loadfocus-api-client


    - name: Configure LoadFocus API Client
      run: |
        loadfocus-api config set apikey ${{ secrets.LOADFOCUS_API_KEY }}
        loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


    - name: Run Performance Tests
      run: |
        loadfocus-api jmeter run-test \
          --name "GitHub_${{ github.repository_owner }}_${{ github.repository }}_${{ github.ref_name }}" \
          --thresholds "avgresponse<=200,errors==0,p95<=250" \
          --format json > performance_results.json


    - name: Upload Performance Test Results
      uses: actions/upload-artifact@v3
      with:
        name: performance-test-results
        path: performance_results.json

3. Agregar Pruebas de Rendimiento a tu Flujo de Trabajo de Despliegue

Para hacer que el despliegue dependa de los resultados de las pruebas de rendimiento:

name: Build, Test, and Deploy


on:
  push:
    branches: [ main ]


jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # Tus pasos de compilación...


  performance-test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3


      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'


      - name: Install LoadFocus JMeter API Client
        run: npm install -g @loadfocus/loadfocus-api-client


      - name: Configure LoadFocus API Client
        run: |
          loadfocus-api config set apikey ${{ secrets.LOADFOCUS_API_KEY }}
          loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


      - name: Run Performance Tests
        run: |
          loadfocus-api jmeter run-test \
            --name "GitHub_${{ github.repository }}_${{ github.ref_name }}" \
            --thresholds "avgresponse<=200,errors==0,p95<=250" \
            --format json > performance_results.json


      - name: Upload Performance Test Results
        uses: actions/upload-artifact@v3
        with:
          name: performance-test-results
          path: performance_results.json


  deploy:
    needs: performance-test
    runs-on: ubuntu-latest
    steps:
      # Tus pasos de despliegue...

Configuración Avanzada

Pruebas Matriciales para Múltiples Entornos

Ejecuta pruebas contra múltiples entornos o configuraciones:

jobs:
  performance-test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        environment: [dev, staging, production]
        test-type: [api, frontend]


    steps:
      # Pasos de configuración...


      - name: Run Performance Tests
        run: |
          TEST_NAME="${{ matrix.test-type }}_test_${{ matrix.environment }}"


          # Ajustar umbrales según el entorno
          if [ "${{ matrix.environment }}" == "production" ]; then
            THRESHOLDS="avgresponse<=150,errors==0,p95<=200"
          else
            THRESHOLDS="avgresponse<=300,errors==0,p95<=500"
          fi


          loadfocus-api jmeter run-test \
            --name "$TEST_NAME" \
            --thresholds "$THRESHOLDS" \
            --format json > "performance_results_${{ matrix.environment }}_${{ matrix.test-type }}.json"

Crear Informes de Pruebas de Rendimiento

Genera informes HTML a partir de resultados JSON:

- name: Generate HTML Report
  run: |
    # Instalar generador de informes
    npm install -g performance-report-generator


    # Generar informe HTML
    performance-report-generator \
      --input performance_results.json \
      --output performance_report.html


- name: Upload HTML Report
  uses: actions/upload-artifact@v3
  with:
    name: performance-test-report
    path: performance_report.html


# Opcional: Publicar en GitHub Pages
- name: Publish to GitHub Pages
  uses: peaceiris/actions-gh-pages@v3
  with:
    github_token: ${{ secrets.GITHUB_TOKEN }}
    publish_dir: ./reports
    destination_dir: performance-reports

Comentar Resultados de Pruebas en PRs

Agrega los resultados de pruebas de rendimiento como comentario en pull requests:

- name: Comment PR
  uses: actions/github-script@v6
  if: github.event_name == 'pull_request'
  with:
    github-token: ${{ secrets.GITHUB_TOKEN }}
    script: |
      const fs = require('fs');
      const results = JSON.parse(fs.readFileSync('performance_results.json', 'utf8'));


      let comment = '## Performance Test Results\n\n';
      comment += `**Overall Result:** ${results.overallResult}\n\n`;


      comment += '### Results by Label\n\n';
      for (const label of results.labels) {
        comment += `#### ${label.label}\n`;
        comment += `- **Result:** ${label.result}\n`;
        comment += `- **Samples:** ${label.metrics.samples}\n`;
        comment += `- **Avg Response:** ${label.metrics.avgresponse}ms\n`;
        comment += `- **Error Rate:** ${label.metrics.errors}\n\n`;
      }


      github.rest.issues.createComment({
        issue_number: context.issue.number,
        owner: context.repo.owner,
        repo: context.repo.repo,
        body: comment
      });

Flujo de Trabajo Reutilizable

Crea un flujo de trabajo reutilizable para pruebas de rendimiento:

# .github/workflows/reusable-performance-test.yml
name: Reusable Performance Test


on:
  workflow_call:
    inputs:
      test-name:
        required: true
        type: string
      thresholds:
        required: false
        type: string
        default: "avgresponse<=200,errors==0,p95<=250"
      wait-timeout:
        required: false
        type: number
        default: 1800
    secrets:
      LOADFOCUS_API_KEY:
        required: true
      LOADFOCUS_TEAM_ID:
        required: true


jobs:
  performance-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3


      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'


      - name: Install LoadFocus JMeter API Client
        run: npm install -g @loadfocus/loadfocus-api-client


      - name: Configure LoadFocus API Client
        run: |
          loadfocus-api config set apikey ${{ secrets.LOADFOCUS_API_KEY }}
          loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}


      - name: Run Performance Tests
        run: |
          loadfocus-api jmeter run-test \
            --name "${{ inputs.test-name }}" \
            --thresholds "${{ inputs.thresholds }}" \
            --waitTimeout ${{ inputs.wait-timeout }} \
            --format json > performance_results.json


      - name: Upload Performance Test Results
        uses: actions/upload-artifact@v3
        with:
          name: performance-test-results
          path: performance_results.json

Luego llámalo desde otro flujo de trabajo:

# .github/workflows/main.yml
jobs:
  call-performance-test:
    uses: ./.github/workflows/reusable-performance-test.yml
    with:
      test-name: "API_Performance_Test"
      thresholds: "avgresponse<=150,errors==0"
    secrets:
      LOADFOCUS_API_KEY: ${{ secrets.LOADFOCUS_API_KEY }}
      LOADFOCUS_TEAM_ID: ${{ secrets.LOADFOCUS_TEAM_ID }}

Consejos para la Integración con GitHub Actions

  1. Caché: Almacena en caché las dependencias de npm para acelerar las ejecuciones del flujo de trabajo:

    - name: Cache Node modules
      uses: actions/cache@v3
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
        restore-keys: |
          ${{ runner.os }}-node-

  2. Control de Concurrencia: Limita las pruebas de rendimiento concurrentes:

    concurrency:
      group: performance-test-${{ github.ref }}
      cancel-in-progress: false

  3. Pruebas Específicas por Entorno: Usa entornos de GitHub para diferentes configuraciones de prueba:

    jobs:
      performance-test:
        runs-on: ubuntu-latest
        environment: staging
        # Las variables específicas del entorno están disponibles aquí

  4. Pruebas Condicionales: Ejecuta pruebas de rendimiento solo cuando cambien archivos específicos:

    jobs:
      performance-test:
        if: |
          contains(github.event.pull_request.labels.*.name, 'performance-test') ||
          github.event_name == 'schedule' ||
          contains(github.event.head_commit.message, '[perf-test]')

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

Anterior
CircleCI
Siguiente
GitLab CI/CD