Implementando Pruebas de Carga Automatizadas en Pipelines CI/CD con k6

🚀 Introducción a las Pruebas de Carga en CI/CD

En el desarrollo de software moderno, la velocidad de entrega no debe comprometer la estabilidad del sistema. A menudo, las pruebas de rendimiento y carga se realizan de forma manual y tardía, justo antes de un despliegue importante en producción. Esto suele resultar en cuellos de botella no detectados, caídas de servicios y una mala experiencia para el usuario final. Integrar pruebas de carga automatizadas en tu ciclo de vida de desarrollo de software (SDLC) a través de un pipeline de CI/CD es la solución definitiva para mantener la salud de tus aplicaciones.

En este tutorial exhaustivo, exploraremos cómo utilizar Grafana k6, una herramienta moderna de pruebas de carga escrita en Go y con soporte para scripts en JavaScript, combinada con un pipeline de CI/CD en GitHub Actions. Analizaremos desde la creación del script base hasta la automatización completa y la definición de umbrales estrictos.

🛠️ ¿Qué es k6 y por qué usarlo?

k6 es una herramienta de pruebas de carga de código abierto desarrollada por Grafana Labs. Está diseñada específicamente para desarrolladores y equipos de DevOps, permitiendo definir pruebas de rendimiento utilizando código y tratándolas de la misma manera que el código fuente de la aplicación.

Características Principales de k6

• Scripts basados en JavaScript (ES6+): Escribe tus escenarios de prueba con una sintaxis moderna y familiar.
• Alto rendimiento: Escrito en Go, es capaz de generar una enorme cantidad de carga con un consumo mínimo de recursos.
• Thresholds (Umbrales): Permite definir criterios de éxito y fallo basados en métricas (ej. el percentil 95 de latencia debe ser menor a 200ms).
• Integración nativa: Se conecta fácilmente con sistemas de monitoreo como Prometheus, Grafana, Datadog y plataformas de CI/CD.

📋 Requisitos Previos y Configuración del Entorno

Antes de sumergirnos en la implementación del pipeline, asegúrate de contar con los siguientes elementos:

• Una cuenta de GitHub y un repositorio configurado.
• Conocimientos básicos de JavaScript y Git.
• Un servicio o aplicación web de prueba (puede ser una API REST local desplegada en Docker).
• k6 instalado localmente para pruebas previas (brew install k6 en macOS o winget install k6 en Windows).

📝 Creación de tu Primer Script de Prueba en k6

Comenzaremos creando un archivo llamado load-test.js en la raíz de tu proyecto. Este archivo contendrá la lógica de simulación de usuarios concurrentes, las peticiones HTTP y las validaciones de rendimiento.

Crea el archivo load-test.js con el siguiente contenido:

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

export const options = {
  stages: [
    { duration: '30s', target: 20 }, // Simula un incremento de carga hasta 20 usuarios en 30 segundos
    { duration: '1m', target: 20 },  // Mantiene 20 usuarios durante 1 minuto
    { duration: '10s', target: 0 },  // Reduce la carga a 0 usuarios (rampa de bajada)
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // El 95% de las peticiones deben responder en menos de 500ms
    http_req_failed: ['rate<0.01'],   // La tasa de errores debe ser inferior al 1%
  },
};

export default function () {
  const res = http.get('https://test-api.k6.io/public/crocodiles/');
  
  check(res,
    { 
      'status es 200': (r) => r.status === 200,
      'tiempo de respuesta < 300ms': (r) => r.timings.duration < 300 
    }
  );

  sleep(1);
}

⚙️ Integración con GitHub Actions

Ahora que tenemos nuestro script listo y probado localmente, es momento de automatizar su ejecución dentro de un pipeline de integración continua.

Crea un directorio en tu repositorio llamado .github/workflows/ y dentro de él un archivo llamado load-tests.yml. Este archivo definirá el disparador del pipeline y los pasos necesarios para instalar k6 y ejecutar las pruebas.

Añade la siguiente configuración al archivo load-tests.yml:

name: Pruebas de Carga Automatizadas con k6

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  workflow_dispatch:

jobs:
  k6-load-test:
    name: Ejecutar Pruebas de Carga k6
    runs-on: ubuntu-latest

    steps:
      - name: Checkout del repositorio
        uses: actions/checkout@v4

      - name: Configurar entorno de Node (opcional si usas dependencias)
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Instalar k6
        run: |
          sudo gpg -k
          sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C047C0FA1A
          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

      - name: Ejecutar Script de k6
        run: |
          k6 run load-test.js

Desglose de los Pasos del Pipeline

📊 Análisis de Resultados y Reportes

Una vez que el pipeline se ejecuta en GitHub Actions, obtendrás una salida detallada en la consola con métricas clave. k6 muestra un resumen completo que incluye:

export K6_CLOUD_TOKEN="tu-token-de-grafana"
k6 run load-test.js --out cloud

💡 Buenas Prácticas para Pruebas de Carga en CI/CD

Para maximizar el valor de tus pruebas automatizadas de rendimiento y evitar falsos positivos o caídas innecesarias en tus entornos, ten en cuenta las siguientes recomendaciones:

1. Aísla el entorno: Nunca ejecutes pruebas de carga pesadas directamente sobre tu entorno de producción sin una planificación rigurosa. Utiliza un entorno dedicado de Staging o Performance que imite fielmente a la producción.
2. Empieza pequeño: Introduce escenarios de carga ligeros (smoke tests) en cada Pull Request y reserva las pruebas de estrés o picos de tráfico para ejecuciones nocturnas o despliegues programados a producción.
3. Monitorea los recursos del servidor: Acompaña las métricas de k6 con herramientas de observabilidad (como Prometheus y Grafana) para observar el uso de CPU, memoria y E/S de disco en tus servidores de aplicación durante la prueba.
4. Versiona tus scripts: Trata los scripts de k6 como código de producción. Realiza revisiones de código (Code Reviews) cada vez que modifiques los perfiles de carga o los umbrales.

🏁 Conclusión

La integración de pruebas de carga automatizadas con k6 en pipelines de CI/CD representa un cambio cultural y técnico fundamental hacia la verdadera ingeniería de fiabilidad del software (SRE). Al detectar regresiones de rendimiento de forma temprana, proteges la experiencia del usuario final y aseguras que tu infraestructura escale de manera predecible.

Ya estás listo para implementar esta estrategia en tus propios proyectos. Comienza con pruebas ligeras, ajusta tus umbrales de éxito y escala gradualmente la complejidad de tus escenarios de prueba.

Nivel: Intermedio DevOps / CI/CD Grafana k6