GitHub Actions

Esta guía muestra cómo iniciar una prueba JMeter de LoadFocus desde un workflow de GitHub Actions, esperar a que termine y hacer fallar el workflow 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 workflow inicia esa prueba guardada por su nombre.

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

Ambas están en la página Claves API de la configuración de tu cuenta 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 }} --teamid ${{ secrets.LOADFOCUS_TEAM_ID }}

    - name: Run Performance Tests
      run: |
        # --name es el nombre exacto de una prueba guardada en LoadFocus
        loadfocus-api jmeter run-test \
          --name "My_JMeter_Test" \
          --thresholds "avgresponse<=200,errors==0,p95<=250" \
          --format json > performance_results.json

    - name: Upload Performance Test Results
      if: always()
      uses: actions/upload-artifact@v4
      with:
        name: performance-test-results
        path: performance_results.json

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, así que basta una petición lenta para que la ejecución falle. errors es un recuento de peticiones fallidas, no un porcentaje. En los ejemplos siguientes, sustituye los nombres de prueba 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.

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 }} --teamid ${{ secrets.LOADFOCUS_TEAM_ID }}

      - name: Run Performance Tests
        run: |
          loadfocus-api jmeter run-test \
            --name "My_JMeter_Test" \
            --thresholds "avgresponse<=200,errors==0,p95<=250" \
            --format json > performance_results.json

      - name: Upload Performance Test Results
        if: always()
        uses: actions/upload-artifact@v4
        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"

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: always() && github.event_name == 'pull_request'
  with:
    github-token: ${{ secrets.GITHUB_TOKEN }}
    script: |
      const fs = require('fs');
      const raw = fs.readFileSync('performance_results.json', 'utf8');
      // the file starts with progress lines; the JSON begins at the first line that is only {
      const results = JSON.parse(raw.slice(raw.search(/^\{$/m)));

      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 }} --teamid ${{ secrets.LOADFOCUS_TEAM_ID }}

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

      - name: Upload Performance Test Results
        if: always()
        uses: actions/upload-artifact@v4
        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.