← volver

k6 + Prometheus: pruebas de carga como código con SLOs y gates en CI/CD

Por · · [DevOps] · lectura estimada: ~5 min

Las pruebas de carga suelen ser el eslabón olvidado del pipeline. Se ejecutan manualmente, sus resultados quedan en un informe PDF que nadie lee y, cuando el sistema se cae en producción bajo tráfico real, todos miran al equipo de SRE con cara de sorpresa. La propuesta de este artículo es distinta: tratar la carga como código versionado, expresar la calidad con SLOs medibles y convertir esos SLOs en gates que bloquean el despliegue si no se cumplen. La combinación de k6 y Prometheus hace esto posible sin reinventar la rueda.

Por qué k6 y no otra herramienta

k6 es un runner de pruebas de carga escrito en Go que ejecuta scripts JavaScript (ES6+). Su gran ventaja frente a JMeter o Locust en un contexto DevOps es que está diseñado desde el principio para ser scriptable, tener una CLI limpia y exponer métricas en formatos que los sistemas de observabilidad ya entienden. No necesitas abrir una GUI ni mantener archivos XML gigantes: un script de 60 líneas puede describir un escenario completo con thresholds.

Además, k6 incluye algo que muchas herramientas tratan como ciudadano de segunda clase: los thresholds. Un threshold es una expresión que se evalúa al final de la prueba y determina si pasa o falla. Ese binomio pass/fail es exactamente lo que necesita un gate en CI/CD.

Un script de k6 con SLOs explícitos

Antes de hablar de Prometheus, veamos cómo se expresan los SLOs dentro del propio script. La idea es que el mismo archivo que define la carga defina el contrato de calidad:

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

const errorRate = new Rate(‘errors’); const checkoutLatency = new Trend(‘checkout_latency’, true);

export const options = { scenarios: { checkout: { executor: ‘ramping-vus’, startVUs: 0, stages: [ { duration: ‘2m’, target: 50 }, { duration: ‘5m’, target: 200 }, { duration: ‘2m’, target: 0 }, ], }, }, thresholds: { // SLO 1: 99% de peticiones por debajo de 500 ms ‘http_req_duration{scenario:checkout}’: [‘p(99)<500’], // SLO 2: tasa de error global inferior al 1% ‘errors’: [‘rate<0.01’], // SLO 3: latencia específica del checkout por debajo de 800 ms ‘checkout_latency’: [‘p(95)<800’], }, };

export default function () { const res = http.post(‘https://api.example.com/checkout’, JSON.stringify({ sku: ‘A-42’ }), { headers: { ‘Content-Type’: ‘application/json’ }, });

checkoutLatency.add(res.timings.duration); errorRate.add(res.status >= 400);

check(res, { ‘status 2xx’: (r) => r.status >= 200 && r.status < 300 }); sleep(1); }

Los thresholds son el corazón del asunto. Si cualquiera se incumple, k6 devuelve un exit code 99, que es exactamente lo que un runner de CI necesita para marcar el job como fallido. No hace falta parsear JSON ni escribir scripts de validación externos.

Exportar métricas a Prometheus

k6 puede enviar sus métricas a un backend remoto mediante la salida experimental prometheus-rw o, en despliegues clásicos, escribiendo a InfluxDB o a un pushgateway. La forma más limpia hoy es usar el remote write directamente contra Prometheus, aunque también puedes usar el operador k6-operator en Kubernetes, que levanta Prometheus y Grafana automáticamente para cada TestRun.

Ejemplo de ejecución local enviando métricas a un Prometheus con remote write habilitado:

K6_PROMETHEUS_RW_SERVER_URL=http://prometheus:9090/api/v1/write \
K6_PROMETHEUS_RW_TREND_AS_NATIVE_HISTOGRAM=true \
k6 run --out experimental-prometheus-rw script.js

Con TREND_AS_NATIVE_HISTOGRAM=true los percentiles se calculan del lado del servidor, lo que evita el clásico problema de que k6 agregue todos los datos en memoria. Cada serie lleva etiquetas como scenario, testid o group, lo que permite segmentar por entorno, rama o commit.

Consultas PromQL para verificar SLOs

Una vez las métricas están en Prometheus, los SLOs se vuelven consultas. Por ejemplo, para comprobar que el p99 del escenario checkout del test con ID abc123 se mantiene bajo 500 ms:

histogram_quantile(0.99,
  sum(rate(k6_http_req_duration_seconds_bucket{testid="abc123",scenario="checkout"}[1m])) by (le)
)

Y para la tasa de error:

sum(rate(k6_errors_total{testid="abc123"}[1m]))
/
sum(rate(k6_http_reqs_total{testid="abc123"}[1m]))

Estas expresiones se pueden guardar como recording rules en Prometheus y alimentar tanto alertas como dashboards de Grafana. El mismo dato que bloquea un despliegue es el que se ve en el panel de operaciones, lo cual elimina la desconexión típica entre performance testing y monitoring.

El gate en CI/CD

El pipeline ideal tiene tres etapas diferenciadas. Primero un smoke test de 1 minuto con 10 VUs en cada pull request: rápido, barato y suficiente para detectar regresiones groseras. Después, en la rama principal, un test completo con rampas de carga y thresholds estrictos. Y finalmente, en el entorno de staging previo a producción, una prueba de soak de varias horas con validación continua contra Prometheus.

Un job de GitHub Actions para el segundo caso podría verse así:

- name: Run k6 load test
  run: |
    k6 run \
      --out experimental-prometheus-rw \
      -e BASE_URL=${{ vars.STAGING_URL }} \
      -e TEST_ID=${{ github.sha }} \
      tests/load/checkout.js
  env:
    K6_PROMETHEUS_RW_SERVER_URL: ${{ secrets.PROM_RW_URL }}
  • name: Verify SLOs in Prometheus run: | ./scripts/check-slo.sh ${{ github.sha }}

El segundo paso es clave: aunque k6 ya valida thresholds localmente, contrastar contra Prometheus añade una capa de verdad independiente. El script check-slo.sh puede usar promtool query instant o simplemente curl contra la API HTTP de Prometheus y fallar con exit 1 si alguna expresión supera el umbral. Este doble gate evita que un fallo en el envío de métricas pase desapercibido.

Buenas prácticas para no ahogarte en ruido

  • Un test, un objetivo. No mezcles escenarios de login, búsqueda y checkout en el mismo archivo. Cada uno merece su propio gate.
  • Etiqueta todo. Añade testid, commit, branch y env a las métricas. Sin etiquetas, Prometheus se convierte en un vertedero.
  • Retención corta. Las métricas de carga son voluminosas. Configura retention de 15 días y baja el scrape interval solo para los jobs relevantes.
  • SLOs con margen. Si tu SLO real es p99 < 500 ms, pon el threshold en 450 ms. El colchón absorbe la variabilidad del entorno de CI.
  • Falla rápido. Usa --throw en k6 para que el script aborte ante errores de setup, no al final tras 20 minutos de carga inútil.

Conclusiones

Tratar las pruebas de carga como código no es solo una moda: es la única forma de que la performance deje de ser un acto de fe. Con k6 defines la carga y los SLOs en el mismo archivo versionado, con Prometheus obtienes una fuente de verdad compartida con operaciones, y con los gates en CI/CD evitas que una regresión de latencia llegue a producción un viernes por la tarde. El coste es bajo: un par de archivos YAML, un script de 60 líneas y disciplina para no saltarse los thresholds cuando el pipeline se pone rojo. El beneficio, en cambio, es dormir tranquilo.

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal