StackPractices
intermediate Por Mathias Paulenko

Plantilla de Plan de Ejecución de Pruebas de Carga

Una plantilla para planificar, ejecutar y documentar pruebas de carga que miden el comportamiento del sistema bajo tráfico realista o pico.

Descripción General

Un plan de pruebas de carga define qué medir. Un plan de ejecución define quién ejecuta qué, en qué entorno, en qué orden y qué hacer cuando los números salen mal. Los equipos que se saltan la segunda mitad acaban repitiendo la misma prueba tres veces: una porque el entorno no se reinició, otra porque nadie guardó la configuración y otra porque el umbral nunca se escribió.

Esta plantilla es el runbook del día de la prueba. Complementa a la Plantilla de Plan de Pruebas de Carga, que define los objetivos, recorridos de usuario y umbrales que este documento ejecuta, y a la Plantilla de Informe de Pruebas de Carga, que recoge los hallazgos después.

Cuándo Usar

  • Antes de un lanzamiento, campaña de marketing o evento estacional que multiplique el tráfico.
  • Tras una migración, un cambio de escala o una refactorización de arquitectura que haya que validar bajo carga.
  • Cuando las cifras de capacidad salieron de una hoja de cálculo y nadie se las cree.
  • Como runbook repetible de una suite de regresión de rendimiento trimestral o por release.
  • Cuando hay que verificar con mediciones una promesa de proveedor, plataforma o SLA, no con marketing.

No la uses para microbenchmarks a nivel de unidad, pruebas de humo de un solo endpoint o perfilado de una función lenta: eso necesita un profiler, no un plan.

Cómo Usar Esta Plantilla

  1. Copia la plantilla en el espacio de documentación del equipo y asigna un responsable de la prueba antes de rellenar nada más.
  2. Rellena primero la sección 1; si no puedes enunciar el objetivo en una frase, la prueba aún no está lista.
  3. Reserva la ventana del entorno y avisa a todos los equipos de la fila de interesados.
  4. Ejecuta la sección 5 paso a paso durante la prueba; no improvises el orden.
  5. Registra los resultados en la sección 6 mientras corre la prueba, no de memoria después.
  6. Convierte cada umbral fallido en un hallazgo de la sección 7 con responsable y fecha límite.
  7. Presenta los resultados en la Plantilla de Informe de Pruebas de Carga y archiva ambos documentos donde el equipo realmente los consulta durante incidentes.
  8. Repite la prueba cuando aterrice cada corrección: un hallazgo sin re-test es una suposición.

1. Objetivos y Alcance de la Prueba

Una línea por fila. Si un campo no aplica, escribe N/A en lugar de dejarlo en blanco: los campos vacíos se leen como “olvidó rellenarlo”.

CampoDescripciónEjemplo
ID de pruebaIdentificador únicoLT-2026-Q3-001
Sistema bajo pruebaAplicación o servicioAPI de checkout
Fecha de la pruebaCuándo se ejecuta2026-06-27
ResponsableIngeniero responsableEquipo de rendimiento
InteresadosEquipos a notificarSRE, backend, plataforma, producto
ObjetivoPor qué se ejecutaValidar que checkout aguanta 10x tráfico en el lanzamiento
AlcanceQué se incluyeEndpoints de API, base de datos, caché, cola
Fuera de alcanceQué no se pruebaProcesador de pagos, integraciones de terceros

2. Escenarios de Prueba

Pondera cada escenario según su cuota de tráfico real, no por lo fácil que sea de programar. Saca la mezcla de los logs de acceso de producción o del desglose de endpoints de tu APM, y mantén al menos un recorrido con mucha escritura: las pruebas de solo lectura esconden los fallos que de verdad duelen.

IDDescripciónEndpoint / FlujoUsuarios VirtualesRamp UpDuraciónThink Time
S01Navegar catálogoGET /products5002 min10 min1-3 s
S02Añadir al carritoPOST /cart/items3002 min10 min1-3 s
S03CheckoutPOST /orders2002 min10 min2-5 s
S04BúsquedaGET /search?q=...4002 min10 min1-2 s
S05Pico combinadoTodos los endpoints20005 min15 min0-1 s

3. Criterios de Éxito

Tres columnas importan: Línea base es lo que mediste en la última ejecución o en producción, Objetivo es lo que el negocio necesita, y No debe superar es la condición de aborto. Si una métrica cruza la línea de aborto a mitad de prueba, detenla: una prueba que tumba el checkout no es un dato, es un incidente.

MétricaLínea baseObjetivoNo debe superarNotas
Latencia p5045 ms< 60 ms80 msRespuestas de API
Latencia p95120 ms< 150 ms200 msRespuestas de API
Latencia p99300 ms< 400 ms600 msRespuestas de API
Tasa de errores0,01 %< 0,1 %0,5 %HTTP 5xx y timeouts
Throughput1000 RPS> 2000 RPS-Pedidos por segundo
Uso de CPU40 %< 70 %80 %Por nodo de aplicación
Uso de memoria50 %< 70 %85 %Por nodo de aplicación
Conexiones a BD80< 150200Conexiones activas
Profundidad de cola10< 50100Trabajos en segundo plano

4. Preparación del Entorno

Cuanto más se parezca el entorno a producción, más valen los resultados. Un entorno a un cuarto de escala puede validar regresiones relativas, pero anota el factor de escala para que nadie compare después las cifras directamente con producción.

Recursodev/testproducciónNotas
Nodos de aplicación26Mismo tamaño de instancia
Balanceador de carga12Misma configuración
Base de datosInstancia únicaClúster multi-AZMisma versión mayor
Caché1 nodo3 nodosMisma versión de motor
Cola de mensajes1 nodo3 nodosMisma configuración
Generador de carga4 inyectoresN/AInstancias cloud o contenedores
RedVPC aisladaVPC de producciónReplicar latencia y topología
Volumen de datos10 % de producciónProducción completaUsar datos anonimizados

5. Plan de Ejecución

T0 es cuando arranca el primer escenario real. Todo lo anterior existe para garantizar que la prueba mide el sistema, no el estado residual de la ejecución anterior.

PasoAcciónResponsableMomento
1Verificar entorno y monitorizaciónSRET-30 min
2Reiniciar el entorno a estado conocidoSRET-20 min
3Desplegar scripts y datos de pruebaEquipo de rendimientoT-15 min
4Ejecutar prueba base a baja cargaEquipo de rendimientoT-10 min
5Ejecutar escenarios S01-S04Equipo de rendimientoT0
6Ejecutar escenario pico S05Equipo de rendimientoT+15 min
7Monitorizar el sistema y recoger métricasSRET+15 a T+30 min
8Reducir la carga gradualmente y pararEquipo de rendimientoT+30 min
9Exportar resultados y logsEquipo de rendimientoT+35 min
10Restaurar el entornoSRET+45 min

6. Resultados y Análisis

Rellena esta tabla durante la prueba, con los dashboards abiertos. Las cifras reconstruidas de memoria una semana después tienden a redondearse hacia “aprobado”.

EscenarioUV máx.RPS picoLatencia p95Latencia p99Tasa de erroresCPU mediaMemoria mediaResultado
S01500120055 ms180 ms0,01 %45 %60 %Pasa
S0230080090 ms250 ms0,02 %55 %65 %Pasa
S03200450140 ms380 ms0,05 %60 %70 %Pasa
S0440095070 ms210 ms0,01 %50 %62 %Pasa
S0520003400220 ms700 ms0,8 %85 %88 %Falla

7. Hallazgos y Remediación

Cada Falla de la sección 6 genera una fila aquí. Un hallazgo sin responsable ni fecha límite es un comentario, no una remediación.

IDDescripciónSeveridadRecomendaciónResponsableFecha límite
LT-001Pool de conexiones a la base de datos agotado en el picoAltaAmpliar el pool y añadir reintentos de conexiónEquipo backend2026-07-04
LT-002La tasa de aciertos de caché cae bajo carga de búsquedaMediaCachear resultados de búsqueda y ajustar TTLEquipo backend2026-07-11
LT-003La cola crece cuando el ritmo de pedidos supera a los consumidoresMediaEscalar los workers en horizontalEquipo plataforma2026-07-11

Explicación

El plan responde a “qué probamos y cómo se ve un buen resultado”. El plan de ejecución responde a las preguntas operativas que el plan no puede: quién está al mando durante la prueba, en qué entorno, en qué orden, cuándo abortar y dónde quedan las evidencias. Mantenerlos separados importa porque cambian a ritmos distintos: el plan se revisa cuando cambian los requisitos; el plan de ejecución, cuando cambian el entorno o el equipo.

El ciclo de vida es este:

Ciclo de vida de la ejecución de una prueba de carga, desde la verificación del entorno hasta la remediación y la repetición

Ejemplo de Script de Load Test con k6

El script de abajo escala hasta los 2.000 usuarios virtuales del escenario S05, etiqueta cada petición con un ID de correlación y registra una tasa de fallos personalizada como métrica Rate para que pueda frenar la ejecución en thresholds. Una sola llamada a check por respuesta: llamar a check() dos veces sobre la misma respuesta la cuenta dos veces en las métricas internas de k6.

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

const failureRate = new Rate('check_failure_rate');

export const options = {
  stages: [
    { duration: '2m', target: 100 },
    { duration: '5m', target: 100 },
    { duration: '2m', target: 300 },
    { duration: '5m', target: 300 },
    { duration: '2m', target: 500 },
    { duration: '5m', target: 500 },
    { duration: '2m', target: 2000 },
    { duration: '5m', target: 2000 },
    { duration: '5m', target: 0 },
  ],
  thresholds: {
    http_req_duration: ['p(95)<500', 'p(99)<1000'],
    http_req_failed: ['rate<0.01'],
    check_failure_rate: ['rate<0.05'],
  },
};

export default function () {
  const headers = {
    'X-Correlation-Id': `corr_${__VU}_${__ITER}`,
    'Content-Type': 'application/json',
  };

  const loginRes = http.post('https://api.example.com/auth/login', JSON.stringify({
    username: `user_${__VU % 100}`,
    password: 'test-password',
  }), { headers });

  const loginOk = check(loginRes, {
    'login status 200': (r) => r.status === 200,
    'login has token': (r) => r.json('token') !== undefined,
  });
  failureRate.add(!loginOk);

  sleep(Math.random() * 2 + 1);

  const listRes = http.get('https://api.example.com/orders', {
    headers: { ...headers, Authorization: `Bearer ${loginRes.json('token')}` },
  });

  const ordersOk = check(listRes, {
    'orders status 200': (r) => r.status === 200,
    'orders has items': (r) => r.json('items').length > 0,
  });
  failureRate.add(!ordersOk);

  sleep(Math.random() * 3 + 1);
}

Variantes

  • Plan de spike test: ráfaga repentina de tráfico para comprobar si el sistema sobrevive y se recupera limpiamente.
  • Plan de stress test: subir la carga más allá del límite esperado hasta que aparezca el modo de fallo.
  • Plan de endurance test: carga moderada durante horas o días para sacar a la luz fugas de memoria y deriva.
  • Plan de soak test: carga similar a producción durante una ventana larga para validar estabilidad, no capacidad.
  • Plan de prueba de escalabilidad: aumentar la carga añadiendo recursos para medir qué tan bien escala el sistema.
  • Plan de prueba con navegador real: sesiones de navegador reales para medir frontend y API a la vez.

Lo Que Funciona

  • Probar en un entorno similar a producción con datos y patrones de tráfico representativos.
  • Escribir los criterios de éxito antes de la ejecución, cuando nadie tiene un resultado que defender.
  • Empezar con una base a baja carga y escalar gradualmente: la carga máxima instantánea no dice nada.
  • Monitorizar las métricas de infraestructura junto a las de aplicación; una gráfica de CPU en rojo es un hallazgo.
  • Repetir la prueba para confirmar que el resultado es reproducible antes de informarlo.
  • Incluir métricas de negocio como tasa de conversión o pedidos por segundo, no solo latencia.
  • Dar a cada hallazgo un responsable y una fecha límite antes de cerrar la prueba.
  • Automatizar las pruebas de regresión en CI para los recorridos críticos entre ejecuciones completas.

Errores Comunes

  • Ejecutar la prueba contra producción sin aislamiento, flags ni plan de rollback.
  • Programar tráfico sintético que no coincide con la mezcla real de peticiones de los logs.
  • Probar un solo endpoint en lugar del recorrido completo: el cuello de botella vive entre medias.
  • Ignorar el calentamiento: cachés frías y pools de conexiones vacíos sesgan los primeros minutos.
  • Saltarse el reinicio del entorno, con lo que la prueba mide el estado residual de ayer.
  • Dejar que el generador de carga se convierta en el cuello de botella: vigila también su CPU y su red.
  • Marcar un umbral fallido como “pasa, problema del entorno” sin una repetición que lo confirme.
  • Declarar éxito sin registrar la configuración, de modo que nadie pueda reproducirlo después.

Troubleshooting

  • El generador de carga se satura antes que el sistema: los inyectores llegan a su propio techo de CPU o de red y el servidor parece ir bien. Vigila las métricas del generador, reparte la carga entre más inyectores y comprueba la omisión coordinada: k6 y JMeter encolan las peticiones que no pueden enviar, así que las tasas de llegada reportadas mienten.
  • Los resultados varían mucho entre ejecuciones: el entorno tiene vecinos ruidosos, el autoescalado se activó a mitad de prueba o no se limpiaron los datos de la ejecución anterior. Bloquea la ventana, desactiva el escalado durante la prueba y reinicia siempre a un estado conocido.
  • La tasa de errores se dispara solo con muchos usuarios virtuales: revisa los límites de descriptores de archivo y de puertos del generador antes de culpar a la aplicación; el ulimit -n y el agotamiento de puertos efímeros simulan fallos del servidor.
  • Los umbrales fallan el primer día pero el sistema está sano: los objetivos se extrapolaron en vez de medirse. Recalcula la línea base con datos reales de producción antes de repetir.
  • El p99 se ve bien pero los usuarios se quejan: los percentiles ocultan una respuesta bimodal: un porcentaje pequeño de peticiones agota el timeout o reintenta. Mira el máximo y la tasa de errores, no solo los percentiles de cola.

Ver También

Preguntas frecuentes

¿Qué herramientas se usan habitualmente para las pruebas de carga?

k6, Apache JMeter, Gatling, Locust y Artillery cubren la mayoría de casos. Elige según el soporte de protocolos, el lenguaje en que programe tu equipo y cómo alimentan los resultados a tus dashboards.

¿Cómo simulamos un comportamiento de usuario realista?

Modela la mezcla de peticiones desde los logs de producción, añade think time entre peticiones, varía los datos de entrada y mantén una proporción realista de lecturas y escrituras. El tráfico aleatorio uniforme encuentra problemas aleatorios uniformes.

¿Deberíamos ejecutar pruebas de carga en producción?

Solo con tráfico sintético, feature flags y un plan de aborto, y solo cuando no haya otra forma de obtener la respuesta. Para todo lo demás, un entorno similar a producción es la opción correcta.

¿Cómo correlacionamos los resultados con las métricas de infraestructura?

Captura las métricas de infraestructura (CPU, memoria, red, E/S de disco) junto a las de aplicación durante la ejecución, en un dashboard que superponga ambas. Después de la prueba, identifica qué componente llegó primero a su techo y si el cuello de botella fue cómputo, conexiones o E/S.

¿Cuál es la diferencia entre spike, stress y endurance testing?

Un spike test golpea el sistema con una ráfaga repentina para ver si sobrevive y se recupera. Un stress test sigue añadiendo carga hasta que algo se rompe para ver el modo de fallo. Un endurance test mantiene carga moderada durante horas para cazar fugas de memoria y deriva. Una estrategia de rendimiento seria ejecuta las tres.

¿Qué hacemos si la prueba de carga falla?

No la repitas de inmediato: averigua primero el porqué. Identifica el escenario y el umbral que fallaron, revisa las métricas de infraestructura buscando el cuello de botella y separa un problema real de rendimiento de uno del entorno. Registra el hallazgo con responsable y corrección, y repite la prueba para confirmar que funcionó.

¿Con qué frecuencia deberíamos ejecutar pruebas de carga?

Pruebas completas antes de cada release importante, regresiones en CI sobre los recorridos críticos, endurance tests cada trimestre y spike tests antes de eventos de tráfico previstos. Repite tras cambios importantes de infraestructura: nuevos tipos de instancia, upgrades de base de datos o una arquitectura reescrita invalidan las cifras anteriores.