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
- Copia la plantilla en el espacio de documentación del equipo y asigna un responsable de la prueba antes de rellenar nada más.
- Rellena primero la sección 1; si no puedes enunciar el objetivo en una frase, la prueba aún no está lista.
- Reserva la ventana del entorno y avisa a todos los equipos de la fila de interesados.
- Ejecuta la sección 5 paso a paso durante la prueba; no improvises el orden.
- Registra los resultados en la sección 6 mientras corre la prueba, no de memoria después.
- Convierte cada umbral fallido en un hallazgo de la sección 7 con responsable y fecha límite.
- Presenta los resultados en la Plantilla de Informe de Pruebas de Carga y archiva ambos documentos donde el equipo realmente los consulta durante incidentes.
- 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”.
| Campo | Descripción | Ejemplo |
|---|---|---|
| ID de prueba | Identificador único | LT-2026-Q3-001 |
| Sistema bajo prueba | Aplicación o servicio | API de checkout |
| Fecha de la prueba | Cuándo se ejecuta | 2026-06-27 |
| Responsable | Ingeniero responsable | Equipo de rendimiento |
| Interesados | Equipos a notificar | SRE, backend, plataforma, producto |
| Objetivo | Por qué se ejecuta | Validar que checkout aguanta 10x tráfico en el lanzamiento |
| Alcance | Qué se incluye | Endpoints de API, base de datos, caché, cola |
| Fuera de alcance | Qué no se prueba | Procesador 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.
| ID | Descripción | Endpoint / Flujo | Usuarios Virtuales | Ramp Up | Duración | Think Time |
|---|---|---|---|---|---|---|
| S01 | Navegar catálogo | GET /products | 500 | 2 min | 10 min | 1-3 s |
| S02 | Añadir al carrito | POST /cart/items | 300 | 2 min | 10 min | 1-3 s |
| S03 | Checkout | POST /orders | 200 | 2 min | 10 min | 2-5 s |
| S04 | Búsqueda | GET /search?q=... | 400 | 2 min | 10 min | 1-2 s |
| S05 | Pico combinado | Todos los endpoints | 2000 | 5 min | 15 min | 0-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étrica | Línea base | Objetivo | No debe superar | Notas |
|---|---|---|---|---|
| Latencia p50 | 45 ms | < 60 ms | 80 ms | Respuestas de API |
| Latencia p95 | 120 ms | < 150 ms | 200 ms | Respuestas de API |
| Latencia p99 | 300 ms | < 400 ms | 600 ms | Respuestas de API |
| Tasa de errores | 0,01 % | < 0,1 % | 0,5 % | HTTP 5xx y timeouts |
| Throughput | 1000 RPS | > 2000 RPS | - | Pedidos por segundo |
| Uso de CPU | 40 % | < 70 % | 80 % | Por nodo de aplicación |
| Uso de memoria | 50 % | < 70 % | 85 % | Por nodo de aplicación |
| Conexiones a BD | 80 | < 150 | 200 | Conexiones activas |
| Profundidad de cola | 10 | < 50 | 100 | Trabajos 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.
| Recurso | dev/test | producción | Notas |
|---|---|---|---|
| Nodos de aplicación | 2 | 6 | Mismo tamaño de instancia |
| Balanceador de carga | 1 | 2 | Misma configuración |
| Base de datos | Instancia única | Clúster multi-AZ | Misma versión mayor |
| Caché | 1 nodo | 3 nodos | Misma versión de motor |
| Cola de mensajes | 1 nodo | 3 nodos | Misma configuración |
| Generador de carga | 4 inyectores | N/A | Instancias cloud o contenedores |
| Red | VPC aislada | VPC de producción | Replicar latencia y topología |
| Volumen de datos | 10 % de producción | Producción completa | Usar 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.
| Paso | Acción | Responsable | Momento |
|---|---|---|---|
| 1 | Verificar entorno y monitorización | SRE | T-30 min |
| 2 | Reiniciar el entorno a estado conocido | SRE | T-20 min |
| 3 | Desplegar scripts y datos de prueba | Equipo de rendimiento | T-15 min |
| 4 | Ejecutar prueba base a baja carga | Equipo de rendimiento | T-10 min |
| 5 | Ejecutar escenarios S01-S04 | Equipo de rendimiento | T0 |
| 6 | Ejecutar escenario pico S05 | Equipo de rendimiento | T+15 min |
| 7 | Monitorizar el sistema y recoger métricas | SRE | T+15 a T+30 min |
| 8 | Reducir la carga gradualmente y parar | Equipo de rendimiento | T+30 min |
| 9 | Exportar resultados y logs | Equipo de rendimiento | T+35 min |
| 10 | Restaurar el entorno | SRE | T+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”.
| Escenario | UV máx. | RPS pico | Latencia p95 | Latencia p99 | Tasa de errores | CPU media | Memoria media | Resultado |
|---|---|---|---|---|---|---|---|---|
| S01 | 500 | 1200 | 55 ms | 180 ms | 0,01 % | 45 % | 60 % | Pasa |
| S02 | 300 | 800 | 90 ms | 250 ms | 0,02 % | 55 % | 65 % | Pasa |
| S03 | 200 | 450 | 140 ms | 380 ms | 0,05 % | 60 % | 70 % | Pasa |
| S04 | 400 | 950 | 70 ms | 210 ms | 0,01 % | 50 % | 62 % | Pasa |
| S05 | 2000 | 3400 | 220 ms | 700 ms | 0,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.
| ID | Descripción | Severidad | Recomendación | Responsable | Fecha límite |
|---|---|---|---|---|---|
| LT-001 | Pool de conexiones a la base de datos agotado en el pico | Alta | Ampliar el pool y añadir reintentos de conexión | Equipo backend | 2026-07-04 |
| LT-002 | La tasa de aciertos de caché cae bajo carga de búsqueda | Media | Cachear resultados de búsqueda y ajustar TTL | Equipo backend | 2026-07-11 |
| LT-003 | La cola crece cuando el ritmo de pedidos supera a los consumidores | Media | Escalar los workers en horizontal | Equipo plataforma | 2026-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:
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 -ny 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
- Plantilla de Plan de Pruebas de Carga — los objetivos, recorridos y umbrales contra los que se ejecuta este plan.
- Plantilla de Informe de Pruebas de Carga — donde se archivan los hallazgos y la remediación.
- Plantilla de Pronóstico de Planificación de Capacidad — convierte los límites medidos en un pronóstico de crecimiento.
- Documentación de k6 — referencia de scripting, thresholds y tipos de ejecutor.
- Manual de usuario de Apache JMeter — la referencia de los planes de prueba y listeners de JMeter.
- Archivos complementarios — la plantilla de ejecución rellenable y un script de k6 ejecutable de este recurso.
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.
Recursos Relacionados
Plantilla de Plan de Pruebas de Carga
Plantilla rellenable de plan de pruebas de carga: escenarios, perfiles de ramp-up, umbrales de éxito, monitoreo y scripts listos para k6, JMeter y Locust.
DocInforme de Pruebas de Carga: Plantilla de Benchmarks
Una plantilla estandarizada para documentar resultados de pruebas de carga: throughput, percentiles de latencia, tasas de error, cuellos de botella con evidencia y acciones — con ejemplo k6 resuelto.
DocPlantilla de Pronóstico de Capacidad
Una plantilla estructurada para pronosticar el crecimiento de infraestructura, identificar cuellos de botella y planificar la capacidad antes de que los picos de tráfico causen interrupciones.
DocPlantilla de Política de Monitoreo y Alertas
Una plantilla de política que define cómo se configuran, enrutan, escalan y revisan las alertas en servicios e infraestructura.
DocPlantilla de Runbook
Una plantilla reutilizable para runbooks operacionales: respuesta a incidentes, procedimientos de deployment y tareas rutinarias.
GuideGuía de Optimización de Performance Web
manual detallado para optimizar el rendimiento de aplicaciones web con mejores Core Web Vitals y experiencia de usuario.