Performance Testing con k6: Guía Completa para Principiantes

El performance testing es una disciplina crítica en el desarrollo de software moderno. En este artículo, te guiaré a través de los fundamentos de k6, una herramienta moderna y poderosa para testing de performance.

¿Qué es k6?

k6 es una herramienta de testing de performance desarrollada por Grafana Labs. A diferencia de herramientas tradicionales como JMeter, k6 está diseñado para desarrolladores y utiliza JavaScript como lenguaje de scripting.

Ventajas de k6:

• Scripts en JavaScript: Fácil de aprender y mantener
• Alto rendimiento: Capaz de generar miles de usuarios virtuales
• Integración con CI/CD: Perfecto para automatización
• Métricas detalladas: Reportes completos y visualizaciones

Configuración Inicial

Instalación

# Instalación en macOS
brew install k6

# Instalación en Windows
choco install k6

# Instalación en Linux
sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6

Tu Primer Script

import http from 'k6/http';
import { check } from 'k6';

export let options = {
  stages: [
    { duration: '2m', target: 100 }, // Ramp up
    { duration: '5m', target: 100 }, // Stay at 100 users
    { duration: '2m', target: 0 },   // Ramp down
  ],
};

export default function () {
  let response = http.get('https://httpbin.org/get');
  
  check(response, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
}

Configuración Avanzada

Escenarios de Carga

export let options = {
  scenarios: {
    load_test: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 10 },
        { duration: '1m', target: 50 },
        { duration: '30s', target: 0 },
      ],
    },
    stress_test: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 100 },
        { duration: '5m', target: 100 },
        { duration: '2m', target: 200 },
        { duration: '5m', target: 200 },
        { duration: '2m', target: 0 },
      ],
    },
  },
};

Manejo de Datos

import { SharedArray } from 'k6/data';

const testData = new SharedArray('users', function () {
  return JSON.parse(open('./users.json'));
});

export default function () {
  const user = testData[Math.floor(Math.random() * testData.length)];
  
  let response = http.post('https://api.example.com/login', {
    username: user.username,
    password: user.password,
  });
}

Mejores Prácticas

1. Configuración de Thresholds

export let options = {
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.1'],
    http_reqs: ['rate>100'],
  },
};

2. Manejo de Errores

export default function () {
  let response = http.get('https://api.example.com/data');
  
  if (response.status !== 200) {
    console.error(`Error: ${response.status} - ${response.body}`);
    return;
  }
  
  // Procesar respuesta exitosa
  let data = response.json();
  check(data, {
    'data is valid': (d) => d.id !== undefined,
  });
}

3. Autenticación y Sesiones

export default function () {
  // Login
  let loginResponse = http.post('https://api.example.com/login', {
    username: 'testuser',
    password: 'testpass',
  });
  
  let token = loginResponse.json('token');
  
  // Usar token en requests posteriores
  let headers = {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json',
  };
  
  let dataResponse = http.get('https://api.example.com/data', { headers });
}

Integración con CI/CD

GitHub Actions

name: Performance Tests
on: [push, pull_request]

jobs:
  performance:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run k6 tests
        run: |
          k6 run --out json=results.json tests/load-test.js
      - name: Upload results
        uses: actions/upload-artifact@v2
        with:
          name: k6-results
          path: results.json

Métricas y Reportes

k6 proporciona métricas detalladas que puedes usar para análisis:

• http_req_duration: Tiempo de respuesta de requests
• http_req_failed: Tasa de fallos
• http_reqs: Requests por segundo
• vus: Usuarios virtuales activos
• iterations: Número de iteraciones completadas

Conclusión

k6 es una herramienta poderosa y moderna para performance testing. Su enfoque en JavaScript y la facilidad de integración con CI/CD lo convierten en una excelente opción para equipos de desarrollo modernos.

En próximos artículos, profundizaré en temas más avanzados como:

• Testing de APIs REST y GraphQL
• Integración con herramientas de monitoreo
• Optimización de scripts para máximo rendimiento
• Casos de estudio reales

¿Te interesa algún tema específico? ¡Déjame saber en los comentarios!

---

¿Necesitas ayuda con performance testing en tu proyecto? Contáctame y trabajemos juntos para optimizar tu aplicación.