TL;DR

  • k6 es una herramienta de load testing moderna y amigable — escribe tests en JavaScript
  • Instala con brew/apt/docker, escribe scripts, corre desde CLI
  • Define thresholds para criterios pass/fail: tiempo de respuesta, tasa de error
  • Métricas integradas: http_req_duration, http_reqs, iterations, vus
  • Integra con CI/CD, Grafana Cloud, InfluxDB para dashboards

Ideal para: Desarrolladores, DevOps, equipos que quieren tests de performance como código Omite si: Necesitas diseño GUI o protocolos exóticos (usa JMeter)

k6 es una herramienta de load testing open-source moderna con más de 20,000 estrellas en GitHub, diseñada para flujos de trabajo de desarrolladores e integración con CI/CD. Según el State of DevOps Report 2024, el 34% de las organizaciones ya tratan el performance testing como parte obligatoria de sus pipelines de CI. A diferencia de los test plans XML de JMeter, k6 usa JavaScript — los tests son legibles, versionables y revisables en pull requests. Una sola instancia de k6 puede generar miles de usuarios virtuales con overhead mínimo de memoria. Este tutorial cubre k6 desde la instalación hasta la integración avanzada con CI/CD: scripting en JavaScript, definición de thresholds, parametrización con variables de entorno y visualización de resultados en Grafana Cloud.

Tu equipo quiere tests de performance en CI/CD. Los archivos XML de JMeter son difíciles de revisar en PRs. Los tests necesitan correr headless en contenedores.

k6 resuelve esto. Los tests son código JavaScript — legibles, versionables, revisables. Corre desde CLI, integra con todo, reporta en tiempo real.

¿Qué es k6?

k6 es una herramienta de load testing open-source construida para workflows de desarrollo modernos. Tests en JavaScript, ejecución en Go (rápido), y resultados integran con herramientas de observabilidad.

Por qué k6:

  • Tests en JavaScript — usa un lenguaje real, no XML
  • Developer experience — excelente CLI, output claro
  • Alto performance — una máquina maneja miles de VUs
  • Nativo CI/CD — corre en contenedores
  • Extensible — JavaScript APIs, extensiones, protocolos

Instalación 

# macOS
brew install k6

# Ubuntu/Debian
sudo apt update && sudo apt install k6

# Docker
docker run --rm -i grafana/k6 run - <script.js

Tu Primer Test k6

Crea script.js:

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

export const options = {
  vus: 10,           // 10 usuarios virtuales
  duration: '30s',   // correr por 30 segundos
};

export default function () {
  const res = http.get('https://test.k6.io');

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });

  sleep(1);
}

Ejecutar:

k6 run script.js

Conceptos k6

Virtual Users (VUs)

VUs son ejecutores paralelos corriendo tu función de test.

export const options = {
  vus: 100,        // usuarios concurrentes
  duration: '5m',  // duración del test
};

Stages (Ramp-up/down)

Aumentar y disminuir carga gradualmente.

export const options = {
  stages: [
    { duration: '2m', target: 100 },  // ramp a 100 usuarios
    { duration: '5m', target: 100 },  // mantener 100
    { duration: '2m', target: 200 },  // ramp a 200
    { duration: '2m', target: 0 },    // ramp down
  ],
};

Thresholds

Define criterios pass/fail.

export const options = {
  thresholds: {
    http_req_duration: ['p(95)<500'],     // 95% requests < 500ms
    http_req_failed: ['rate<0.01'],       // tasa error < 1%
    checks: ['rate>0.99'],                // 99% checks pasan
  },
};

HTTP Requests

GET Request 

import http from 'k6/http';

export default function () {
  // GET simple
  const res = http.get('https://api.example.com/users');

  // GET con parámetros
  const res2 = http.get('https://api.example.com/users?page=1&limit=10');

  // GET con headers
  const res3 = http.get('https://api.example.com/users', {
    headers: {
      'Authorization': 'Bearer token123',
      'Accept': 'application/json',
    },
  });
}

POST Request 

import http from 'k6/http';

export default function () {
  const payload = JSON.stringify({
    name: 'John Doe',
    email: 'john@example.com',
  });

  const params = {
    headers: {
      'Content-Type': 'application/json',
    },
  };

  const res = http.post('https://api.example.com/users', payload, params);
}

Otros Métodos 

// PUT
http.put(url, payload, params);

// PATCH
http.patch(url, payload, params);

// DELETE
http.del(url, params);

// Batch requests (paralelo)
const responses = http.batch([
  ['GET', 'https://api.example.com/users'],
  ['GET', 'https://api.example.com/products'],
  ['GET', 'https://api.example.com/orders'],
]);

Checks y Assertions 

import { check } from 'k6';

export default function () {
  const res = http.get('https://api.example.com/users');

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response has users': (r) => r.json().length > 0,
    'response time OK': (r) => r.timings.duration < 500,
    'content-type is JSON': (r) =>
      r.headers['Content-Type'].includes('application/json'),
  });
}

Datos de Test

Variables de Entorno 

const baseUrl = __ENV.BASE_URL || 'https://test.k6.io';

export default function () {
  http.get(`${baseUrl}/api/users`);
}

k6 run -e BASE_URL=https://staging.example.com script.js

Archivo JSON 

import { SharedArray } from 'k6/data';

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

export default function () {
  const user = users[Math.floor(Math.random() * users.length)];
  // usar user.username, user.password
}

Scenarios

Patrones de ejecución avanzados.

export const options = {
  scenarios: {
    // Carga constante
    constant_load: {
      executor: 'constant-vus',
      vus: 50,
      duration: '5m',
    },

    // Carga con ramp
    ramping_load: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 100 },
        { duration: '5m', target: 100 },
        { duration: '2m', target: 0 },
      ],
    },

    // Arrival rate constante
    constant_rate: {
      executor: 'constant-arrival-rate',
      rate: 100,
      timeUnit: '1s',
      duration: '5m',
      preAllocatedVUs: 50,
    },
  },
};

Métricas y Output

Métricas Integradas

MétricaDescripción
http_reqsTotal de HTTP requests
http_req_durationDuración del request
http_req_failedTasa de requests fallidos
iterationsIteraciones completadas
vusUsuarios virtuales actuales
data_receivedDatos recibidos
data_sentDatos enviados

Métricas Custom 

import { Counter, Trend, Rate, Gauge } from 'k6/metrics';

const orderCounter = new Counter('orders_created');
const orderDuration = new Trend('order_duration');
const orderSuccess = new Rate('order_success_rate');

export default function () {
  const start = Date.now();
  const res = http.post('https://api.example.com/orders', orderPayload);

  orderCounter.add(1);
  orderDuration.add(Date.now() - start);
  orderSuccess.add(res.status === 201);
}

Output a InfluxDB + Grafana 

# Output JSON
k6 run --out json=results.json script.js

# Output a InfluxDB
k6 run --out influxdb=http://localhost:8086/k6 script.js

Integración CI/CD

GitHub Actions 

name: Load Test

on:
  push:
    branches: [main]

jobs:
  k6-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run k6 test
        uses: grafana/k6-action@v0.3.1
        with:
          filename: tests/load-test.js
          flags: --out json=results.json

      - name: Upload results
        uses: actions/upload-artifact@v4
        with:
          name: k6-results
          path: results.json

Docker 

FROM grafana/k6

COPY ./tests /tests

ENTRYPOINT ["k6", "run", "/tests/script.js"]

docker build -t my-k6-tests .
docker run my-k6-tests

IA en k6 Testing

Las herramientas de IA pueden ayudar a escribir y optimizar tests k6.

Lo que la IA hace bien:

  • Generar scripts de test desde specs de API
  • Crear datos de test realistas
  • Sugerir valores de thresholds
  • Explicar métricas y resultados

Lo que aún necesita humanos:

  • Entender arquitectura del sistema
  • Establecer objetivos de carga realistas
  • Interpretar resultados en contexto
  • Debuggear fallos de performance

Prompt útil:

Genera un script de k6 load test para una REST API con endpoints: GET /users, POST /users, GET /users/{id}. Incluye stages para ramp-up a 100 VUs, thresholds para p(95) response time bajo 500ms y error rate menor a 1%, checks para status codes y validación de respuesta JSON.

“k6 cambió cómo pensamos el performance testing. Cuando los tests son código JavaScript, los desarrolladores los escriben y mantienen. Pasamos de ‘alguien debería ejecutar un load test’ a gates de performance en cada PR.” — Yuri Kan, Senior QA Lead

References: Documentación k6 | Grafana Cloud k6

FAQ

¿Qué es k6?

k6 es una herramienta de load testing moderna y open-source diseñada para desarrolladores. Escribes tests en JavaScript, los corres desde línea de comandos y obtienes métricas de performance detalladas. Construido por Grafana Labs, k6 se enfoca en developer experience, integración CI/CD y alto performance.

¿k6 es gratis?

Sí, k6 open-source (k6 OSS) es completamente gratis. Grafana Cloud k6 ofrece ejecución de tests hosteada, almacenamiento cloud y features adicionales con tiers gratis y pagos. Para la mayoría de casos, la versión open-source provee todo lo necesario.

¿k6 vs JMeter — cuál es mejor?

k6 es mejor para desarrolladores y workflows CI/CD — tests como código (JavaScript), ejecución rápida e integra bien con tooling moderno. JMeter es mejor para diseño de tests basado en GUI y soporta más protocolos out of the box. k6 es generalmente más fácil de aprender y mantener para equipos familiarizados con JavaScript.

¿Puede k6 testear interacciones de browser?

Sí, k6 tiene un módulo browser experimental que permite testing real con Chromium. Sin embargo, la fortaleza de k6 es testing a nivel protocolo (HTTP, WebSocket, gRPC) que es mucho más eficiente para load testing. Usa el módulo browser cuando necesites testear páginas renderizadas con JavaScript o interacciones complejas de browser.

¿Cómo ejecutar k6 en Docker?

Usa la imagen oficial de Grafana k6: docker run --rm -i grafana/k6 run - <script.js. Para scripts locales, monta tu directorio de tests: docker run --rm -v $(pwd):/scripts grafana/k6 run /scripts/test.js. Docker es la forma más fácil de ejecutar k6 en pipelines CI/CD sin instalar nada en la máquina host.

¿Qué métricas rastrea k6 por defecto?

k6 rastrea automáticamente http_reqs (total de requests), http_req_duration (tiempo de respuesta), http_req_failed (tasa de error), iterations (iteraciones completadas), vus (usuarios virtuales activos), data_received y data_sent. Puedes crear métricas custom usando tipos Counter, Trend, Rate y Gauge para mediciones específicas del negocio como órdenes creadas o tasa de éxito de login.

Ver También