GuíaBásico
Guía de Performance y Load Testing con k6
Aprende la diferencia entre "¿funciona?" y "¿aguanta bajo carga?" con performance y load testing usando k6, la herramienta estándar de la industria. Cubres los tipos de prueba (smoke, load, stress, spike, soak), la anatomía de un script k6 y su modelo de VUs (usuarios virtuales), las métricas que importan de verdad (latencia p95/p99, throughput/RPS, tasa de error — y por qué el promedio miente), los perfiles de carga con `stages`, y los thresholds: umbrales que hacen PASAR o FALLAR una prueba automáticamente, como un quality gate de rendimiento. El caso de estudio es una API de Reservo (`GET /rooms`, `POST /quote`, `POST /book`) corriendo en local: como k6 no está instalado en el entorno de la guía, sus scripts y su salida se muestran como contenido claramente rotulado y verificado contra la documentación oficial, mientras que las métricas reales (p95, RPS, tasa de error) se calculan de verdad con un generador de carga en Python que golpea la API. Cierra con un proyecto final: una prueba de carga completa smoke → load → stress, con thresholds, checks del flujo de negocio (cotizar → reservar) y el pipeline de CI.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Distinguir "¿funciona?" (testing funcional) de "¿aguanta?" (testing de carga) y reconocer los tipos de prueba: smoke, load, stress, spike y soak
- Leer y escribir la anatomía de un script k6: la función `default`, `http.get`/`post`, `check()`, `sleep()`, y el modelo de VUs (usuarios virtuales concurrentes)
- Interpretar las métricas clave de una prueba de carga: percentiles de latencia (p90/p95/p99, y por qué el promedio miente), throughput/RPS, y tasa de error
- Modelar perfiles de carga realistas con `stages` (ramp-up, steady, ramp-down) y distinguir executors por VUs vs. por tasa de llegada
- Definir thresholds (SLOs) que hacen PASAR o FALLAR una prueba de carga como un quality gate de rendimiento, y elegir el umbral correcto
- Usar `check()` y `group()` para verificar la corrección de las respuestas bajo carga, parametrizar datos y correlacionar un flujo completo (cotizar → reservar)
- Analizar resultados, exportar métricas, detectar una regresión de rendimiento entre corridas, y correr una prueba de carga en CI como gate del pipeline
- Diseñar una prueba de carga completa de una API real: smoke → load → stress, con thresholds, checks del flujo de negocio, y el pipeline de CI
Antes de empezar
Qué necesitas traer
Es para ti si...
- Backend devs que necesitan saber si su API aguanta tráfico real antes de que lo descubra un usuario en producción
- Equipos que quieren poner umbrales de rendimiento (SLOs) que bloqueen un deploy automáticamente, no solo revisarlos a ojo
- Devs que confunden "anduvo en mi máquina" con "aguanta bajo carga concurrente" y quieren medir en vez de suponer
- Equipos evaluando adoptar k6 como herramienta de carga y quieren entender su modelo antes de instalarlo en CI
Requisitos y materiales
- Conocimientos básicos de HTTP (métodos, códigos de estado, JSON) y de una API REST simple
- Python 3.14 instalado localmente (el generador de carga usa `threading`/`concurrent.futures`/`statistics` de la librería estándar)
- No hace falta tener k6 instalado — la guía lo trata como contenido; opcionalmente se puede instalar para correr los scripts reales
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Presentación del módulo: dos preguntas distintas
- 2. Funcional vs carga: dos preguntas distintas
- 3. Las preguntas que responde una prueba de carga
- 4. Los tipos: smoke, load, stress, spike, soak
- 5. Qué es k6 y su runtime
- 6. La API de Reservo y verla responder
- 7. Primer contacto: un script k6 y un generador en Python
- 8. Mini-proyecto: tu primera medición de carga
- 1. Presentación del módulo: el script y el usuario virtual
- 2. La función `default` y el bucle del VU
- 3. `http.get` y `http.post` con cuerpo y headers
- 4. `check()`: verificar la respuesta
- 5. `sleep()` y el *think time*
- 6. `options`: `vus` y `duration`
- 7. VUs vs iteraciones y leer el resumen de k6
- 8. Mini-proyecto: un script k6 y su modelo en Python
- 1. Presentación del módulo: el tablero de la prueba
- 2. Latencia: qué es y por qué percentiles, no promedio
- 3. p50/p90/p95/p99 con `statistics.quantiles`
- 4. Throughput/RPS y su relación con los VUs
- 5. La tasa de error y por qué importa
- 6. Leer el resumen de `k6 run`
- 7. Promedio vs p95 sobre una distribución con cola
- 8. Mini-proyecto: mide las métricas de Reservo
- 1. Presentación del módulo: dar forma a la carga
- 2. Por qué una carga constante no basta
- 3. Los stages: ramp-up, steady, ramp-down
- 4. Las formas: constante, rampa y spike
- 5. Los executors: constant-vus vs ramping-vus
- 6. constant-arrival-rate: carga por tasa de llegada
- 7. Elegir el perfil según la pregunta
- 8. Mini-proyecto: un perfil de carga por etapas
- 1. Presentación del módulo: de medir a juzgar
- 2. Qué es un threshold y el pasa/falla
- 3. Los thresholds de k6: p95, error y checks
- 4. El exit code ≠ 0 que hace fallar el CI
- 5. SLO/SLA: elegir el umbral con criterio
- 6. El gate de rendimiento, como los coverage gates
- 7. `abortOnFail` y thresholds por escenario
- 8. Mini-proyecto: un gate de rendimiento
- 1. Presentación del módulo: de golpear una ruta a un escenario
- 2. `check()` para la corrección bajo carga
- 3. Un check que falla vs un threshold que aborta
- 4. `group()` para organizar los pasos (contenido)
- 5. Parametrizar datos: no golpear una ruta caliente
- 6. Correlación: extraer y reusar (cotizar → reservar)
- 7. Think time realista con jitter
- 8. Mini-proyecto: un escenario realista de Reservo
- 1. Presentación del módulo: de medir a analizar y automatizar
- 2. Leer el resumen y la métrica de tendencia
- 3. Exportar resultados (JSON/CSV) y por qué
- 4. Detectar una regresión de rendimiento
- 5. Encontrar el cuello de botella (app, BD, red)
- 6. Correr k6 en CI: el `load.yml` y el gate
- 7. Cuándo correr la prueba de carga
- 8. Mini-proyecto: exportar y detectar una regresión
- 1. Presentación del módulo: ensamblar la prueba completa
- 2. El escenario cotizar→reservar con checks
- 3. El perfil smoke→load→stress con stages
- 4. Los thresholds ligados al SLO
- 5. La corrida y las métricas (p95/RPS/error)
- 6. El gate de threshold y exportar a JSON
- 7. El `load.yml` de CI como contenido
- 8. Proyecto: la prueba de carga completa de Reservo
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!