Una prueba de carga muestra cuántas peticiones por segundo puede servir tu web y a partir de qué carga las respuestas se vuelven lentas o se convierten en errores 502 y 504. Basta con una herramienta gratuita (k6, wrk, hey, Locust), un escenario corto que suba la carga por escalones y tres cifras en los resultados: RPS, p95 y tasa de errores. Prueba solo tu propia web y, a ser posible, después de avisar a tu proveedor de hosting.
Cómo lo probamos
El 10 de noviembre de 2026 en un banco de pruebas: contenedor Ubuntu 24.04.5 (2 vCPU, 8 GB de RAM), nginx 1.24.0, PHP-FPM 8.3.6, MariaDB 10.11.14, WordPress 6.4.3 con el tema Twenty Twenty-Four y 13 entradas (portada de 103.728 bytes de HTML). Cargamos la web con siete herramientas (ab, wrk, hey, oha, k6, siege, Locust) en ejecuciones de 10 a 20 segundos: de 5 a 200 peticiones simultáneas, sin caché y con nginx fastcgi_cache, con 4 y 16 workers de PHP-FPM. El generador de carga funcionaba en la misma máquina, que otras tareas usaban a la vez (load average de 0,5 a 13), así que las cifras tienen cierta dispersión. Son datos del banco de pruebas, no de los servidores de RichHost. La documentación de k6, wrk2, oha y web.dev se comprobó el mismo día.
Primero la seguridad: qué puedes probar y qué no
Técnicamente, una prueba de carga apenas se diferencia de un pequeño ataque DDoS, así que las reglas son estrictas:
- Solo tu propia web. Probar la web de otra persona puede infringir la ley y las condiciones del proveedor. Lo mismo vale para los recursos de terceros de tu página: pasarelas de pago, analítica, CDN.
- Avisa a tu hosting. En un hosting compartido tu web comparte servidor con otros clientes. No empieces sin respuesta del soporte: envía la URL, tu dirección IP, la hora y la carga máxima. El soporte de RichHost trabaja de 10:00 a 20:00, hora de Kyiv, y responde en unos 30 minutos, así que acuerda la prueba con antelación.
- Las protecciones pueden bloquearte. Un WAF, la limitación de peticiones o fail2ban bloquean una IP que envía cientos de peticiones. Las respuestas 403 o 429 significan que estás probando la protección, no la web.
- Empieza poco a poco y fija una condición de parada. Primero de 1 a 5 peticiones simultáneas, escalones de 30 a 60 segundos, y para cuando los errores superen el 1 % o el p95 pase de tu umbral. Los escenarios de carrito y formularios, ejecútalos en una copia de la web.
Nuestro banco incumple a propósito otra regla: el generador de carga no debería ejecutarse en el servidor de la web, porque le quita CPU. Para una prueba real, usa una máquina aparte en otro centro de datos o un servicio en la nube. Por ejemplo, el plan gratuito de Loader.io, según su página de precios, ofrece hasta 10.000 clientes, pruebas de 1 minuto y 1 host de destino (comprobado el 10.11.2026).
Herramientas: la misma web, cifras distintas
Una URL, 10 conexiones simultáneas: una página sin caché (cada petición ejecuta PHP y consulta la base de datos) y la misma página detrás de nginx fastcgi_cache.
| Herramienta y modo | Sin caché, RPS | Sin caché, p95 | Con caché, RPS |
|---|---|---|---|
ab -c 10 |
10,1 | 1294 ms | 13.587 |
ab -k -c 10 (keep-alive) |
8,3 | 1479 ms | 12.498 |
wrk -t2 -c10 |
12,2 | no da (p99 1570 ms) | 16.809 |
hey -c 10 |
10,7 | 1263 ms | 8.596 |
oha -c 10 |
13,6 | 1123 ms | 13.597 |
| k6, 10 usuarios virtuales | 14,9 | 942 ms | 4.147 |
| siege con la configuración por defecto | 116,6 «transacciones» | media 80 ms | 3.961 |
siege -b --no-parser |
16,8 | media 580 ms | 4.578 |
| Locust, FastHttpUser | 16,8 | 820 ms | 3.057 |
| Locust, HttpUser | 16,0 | 870 ms | 1.158 |
- Cuando el cuello de botella es el servidor, las herramientas coinciden más o menos: de 10 a 17 peticiones por segundo, y la mayor parte de esa diferencia era ruido en la máquina.
- Cuando el servidor es rápido, mides el generador. En la página con caché, wrk y Locust se diferenciaron 14 veces: las herramientas en Python y JavaScript gastan más CPU por petición que wrk u oha.
- Por defecto, siege prueba lo que no debe. Analiza el HTML y descarga CSS, JS e imágenes: 1463 de 1672 «transacciones» eran archivos estáticos, así que el resultado parece 7 veces mejor que la realidad. Para páginas, ejecútalo con
--no-parser. - El keep-alive de ab a menudo no funciona. ab habla HTTP/1.0, mientras que WordPress envía la página sin Content-Length, así que nginx cierra la conexión después de cada respuesta: “Keep-Alive requests: 0”.
- wrk no muestra el p95, solo los percentiles 50, 75, 90 y 99.
Modelo cerrado y modelo abierto: cómo una herramienta puede ocultar un problema
ab, wrk, hey y k6 con usuarios virtuales siguen un modelo cerrado: cada conexión envía su siguiente petición solo cuando ha recibido la respuesta a la anterior. Cuando el servidor se ralentiza, el generador también, y los periodos lentos entran en las estadísticas con muy pocas peticiones. La documentación de k6 lo llama coordinated omission. Los visitantes reales llegan sin importar si el servidor ha respondido ya a los anteriores. Ese es el modelo abierto, que reproducen wrk2 con -R, oha con -q y --latency-correction, y ejecutores de k6 como constant-arrival-rate.
Simulamos una caída, como la que provoca una copia de seguridad pesada: en el segundo 8 de una ejecución de 20 segundos congelamos todos los workers de PHP-FPM durante 4 segundos. wrk2 no se pudo instalar en el banco (la red del banco bloquea la descarga de su código fuente), así que reprodujimos su método con la corrección de latencia de oha:
| Ejecución | Peticiones | p50 | p90 | p99 |
|---|---|---|---|---|
| wrk, sin parada (referencia) | 483 | 406 ms | 508 ms | 705 ms |
| wrk, parada de 4 s, timeout por defecto de 2 s | 372 | 404 ms | 537 ms | 762 ms |
wrk, parada de 4 s, --timeout 10s |
365 | 453 ms | 2,17 s | 4,39 s |
oha -q 8 --latency-correction, parada de 4 s |
160 | 87 ms | 2,90 s | 4,10 s |
| k6 constant-arrival-rate 8 por segundo, parada de 4 s | 161 | 80 ms | no da (p95 3,41 s) | 4,01 s |
Con la configuración por defecto, wrk apenas notó una caída de cuatro segundos: el p99 subió de 705 a 762 ms, y las 10 peticiones que esperaron más de 2 segundos fueron a la línea “Socket errors: timeout 10” y nunca entraron en las estadísticas de latencia. En el modelo abierto llegaban 8 peticiones nuevas cada segundo durante la parada, una quinta parte de todas las peticiones se vio afectada y el p95 mostró de 3,4 a 3,5 segundos. Eso es lo que habrían visto los visitantes. Conclusión: busca el RPS máximo con un modelo cerrado (wrk, hey), valora la experiencia de los visitantes con un nivel de tráfico concreto con uno abierto y revisa siempre la línea de timeouts.
Prueba por escalones: encontrar el punto de inflexión
Después subimos la concurrencia de 5 a 200 (hey, 15 segundos por escalón, keep-alive activado) en tres configuraciones:
| Peticiones simultáneas | 4 workers PHP, sin caché: RPS / p95 | 16 workers, sin caché | 4 workers, fastcgi_cache |
|---|---|---|---|
| 5 | 23,5 / 0,36 s | 30,3 / 0,22 s | 14.118 / 1,0 ms |
| 10 | 23,9 / 0,71 s | 28,6 / 0,47 s | 15.980 / 2,0 ms |
| 25 | 26,8 / 1,45 s | 22,2 / 1,70 s | 16.943 / 4,7 ms |
| 50 | 28,3 / 2,08 s | 29,3 / 1,91 s | 9.498 / 12,3 ms |
| 100 | 26,6 / 4,68 s | 29,0 / 3,72 s | 9.974 / 27,3 ms |
| 200 | 28,3 / 7,92 s | 27,9 / 7,53 s | 13.041 / 30,3 ms |
| Load average durante la serie | 3,1 a 4,8 | 4,4 a 13,6 | 6,0 a 12,5 |
No hubo errores, pero la web sin caché dejó de escalar con 5 a 10 peticiones simultáneas: el RPS se quedó en 24 a 28, y cada usuario adicional solo alargaba la cola. Es la ley de Little: el tiempo de respuesta es aproximadamente el número de peticiones simultáneas dividido entre el rendimiento. 200 entre 28 por segundo da 7,1 segundos, y la prueba mostró una mediana de 6,6 y un p95 de 7,9 segundos. Una serie repetida 20 minutos después dio de 16 a 28 RPS: los procesos vecinos influyen en el resultado, igual que los vecinos en un hosting compartido.

16 workers de PHP-FPM en lugar de 4 apenas aportaron nada: los dos núcleos ya estaban ocupados, la cola simplemente pasó del socket de PHP-FPM a la cola de ejecución de la CPU, el load average subió a 13 y los workers ocuparon unos 650 MB de RAM. Más workers tienen sentido cuando esperan a la base de datos o a API externas. Una caché de páginas lo cambió todo: miles de peticiones por segundo con latencias de milisegundos, y el límite pasó a ser el propio generador. Qué más alivia a PHP además de la caché lo explicamos en nuestra guía sobre cómo acelerar WordPress.
Dónde empiezan los errores 502 y 504
200 peticiones simultáneas pasaron sin errores solo porque la cola de PHP-FPM es larga y el timeout por defecto de nginx es de 60 segundos. Para ver errores en ejecuciones cortas, bajamos los límites:
| Ajuste | Simultáneas | Correctas | Errores |
|---|---|---|---|
fastcgi_read_timeout 5s |
25 | 277 | 0 |
fastcgi_read_timeout 5s |
50 | 55 | 146 × 504 (73 %) |
fastcgi_read_timeout 5s |
200 | 0 | 600 × 504 |
| 60 s por defecto y cola del socket | 600 | 230 | 466 timeouts del cliente (30 s) |
listen.backlog = 64 |
50 | 237 | 0 |
listen.backlog = 64 |
100 | 127 | 113.347 × 502 |
Los resultados coinciden con nuestro análisis de las causas del error 502 Bad Gateway. Un 504 aparece cuando una petición espera en la cola más que el timeout, y entonces todo se desploma: nginx ya ha devuelto 504 al cliente, pero PHP-FPM sigue generando la petición abandonada, de modo que con 200 peticiones simultáneas no salió bien ni una. En el log de nginx se ve “upstream timed out (110: Connection timed out)”; más detalles en nuestro artículo sobre el error 504 Gateway Timeout. Un 502 aparece al instante cuando se desborda la cola del socket: “connect() to unix:…php-fpm.sock failed (11: Resource temporarily unavailable)”. Y la lección más importante para leer informes: con una cola pequeña, hey mostró 7.038 peticiones por segundo con un p95 de 7,8 ms, porque el 99,9 % de las respuestas eran 502 rápidos. Sin una columna de códigos de estado, parece un récord.
En un hosting compartido, en lugar de un 502 o un 504 puedes recibir un error 508 Resource Limit Is Reached: han saltado los límites de procesos o de CPU del plan.
Métricas: qué significa cada una y qué es normal
| Métrica | Qué significa | Normal para una web |
|---|---|---|
| RPS (peticiones por segundo) | Cuántas respuestas devuelve el servidor por segundo | No hay una norma universal. Regla práctica: al menos el doble de tu pico en la analítica, y siempre junto con la tasa de errores |
| p50 (mediana) | Tiempo por debajo del cual responde la mitad de las peticiones | Cerca del tiempo de una petición aislada sin carga (62 ms en el banco). Varias veces más: las peticiones hacen cola |
| p95, p99 | La cola de la distribución: una de cada 20 y una de cada 100 peticiones son más lentas | Para HTML en el pico esperado, hasta 0,8 s. Por encima de 1,8 s es malo (umbrales TTFB de web.dev) |
| Tasa de errores | Respuestas 5xx y 4xx y timeouts del cliente | 0 con la carga esperada, 1 % como condición de parada (ejemplo de la documentación de k6). Revisa los timeouts aparte: wrk los deja fuera de la latencia |
| Aciertos de caché (X-Cache: HIT) | Cuántas páginas se sirvieron sin PHP | Casi todo HIT en las páginas para visitantes anónimos. MISS en cada petición: la caché no funciona |
| Load average, CPU, RAM del servidor | Si el servidor llega a sus límites de recursos | Load average no por encima del número de núcleos de forma sostenida, sin 508 ni mensajes OOM en los logs |
Los umbrales de web.dev (0,8 y 1,8 segundos) están definidos para el tiempo hasta el primer byte, pero sirven como referencia práctica para HTML bajo carga.
Un escenario de k6 seguro, probado en el banco
El script usa el modelo abierto: el ritmo de peticiones crece de 2 a 40 por segundo, y los umbrales (thresholds) con abortOnFail detienen la prueba por sí solos cuando el p95 supera 800 ms o los errores el 1 %. Pon en PAGES páginas reales de tu web, incluidas las que la caché no cubre: búsqueda, carrito, filtros.
import http from 'k6/http';
import { check } from 'k6';
const BASE = __ENV.BASE || 'https://example.com';
const STEP = __ENV.STEP || '30s';
const PAGES = ['/', '/bench-post-3-about-load/', '/?s=load'];
export const options = {
scenarios: {
ramp: {
executor: 'ramping-arrival-rate',
startRate: 2, timeUnit: '1s',
preAllocatedVUs: 20, maxVUs: 200,
stages: [
{ target: 5, duration: STEP },
{ target: 10, duration: STEP },
{ target: 20, duration: STEP },
{ target: 40, duration: STEP },
],
},
},
thresholds: {
http_req_failed: [{ threshold: 'rate<0.01', abortOnFail: true, delayAbortEval: '5s' }],
http_req_duration: [{ threshold: 'p(95)<800', abortOnFail: true, delayAbortEval: '5s' }],
},
};
export default function () {
const url = BASE + PAGES[Math.floor(Math.random() * PAGES.length)];
const res = http.get(url, { timeout: '30s' });
check(res, { 'status 200': (r) => r.status === 200 });
}
En el banco lo ejecutamos con escalones más cortos:
k6 run -e BASE=http://127.0.0.1:8161 -e STEP=8s k6_ramp.js
...
http_req_duration
✗ 'p(95)<800' p(95)=886.27ms
http_req_failed
✓ 'rate<0.01' rate=0.00%
level=error msg="thresholds on metrics 'http_req_duration' were crossed; at least one has abortOnFail enabled, stopping test prematurely"
La prueba se detuvo sola en el segundo 30, cuando el ritmo objetivo se acercaba a 35 peticiones por segundo, justo por encima del límite de la web sin caché (código de salida 99: umbrales no cumplidos). Mientras tanto, vigila el log de errores en un segundo terminal:
tail -f /var/log/nginx/error.log | grep -E "upstream timed out|Resource temporarily|Connection refused"
En el panel de control, los logs están en la sección del dominio; qué buscar en ellos lo explicamos en nuestra guía de logs de acceso y errores del servidor. Repite la prueba 2 o 3 veces y quédate con la mediana.
Cómo leer los resultados: si pasa X, haz Y
| Qué ves | Qué significa | Qué hacer |
|---|---|---|
| RPS plano, el p95 crece con el número de usuarios | El servidor está saturado, las peticiones hacen cola | Caché de páginas, menos plugins pesados. Más workers de PHP no ayudarán si la CPU está al 100 % |
| RPS de repente cientos de veces mayor, latencia minúscula | Errores rápidos, normalmente 502 | Revisa los códigos de estado y el log de nginx antes de sacar conclusiones |
| 504 siempre tras el mismo número de segundos | La petición esperó más que el timeout | Busca código lento y consultas lentas a la base de datos en lugar de subir el timeout |
| 508 o un mensaje de límite de recursos | Han saltado los límites del plan de hosting compartido | Caché, optimización y, después, otro plan |
| CPU de la máquina generadora al 100 % | Estás midiendo la herramienta, no la web | Una herramienta más ligera (wrk, oha) o varias máquinas |
| Las ejecuciones difieren más de un 20 a 30 % | Ruido: vecinos, red, generador | 3 repeticiones, mediana, prueba a la misma hora del día |
Si tu web ya va lenta, empieza por el diagnóstico de problemas de hosting. Si la caché ya está configurada y tu pico de tráfico sigue tocando los límites, compara los planes de hosting por recursos.
Preguntas frecuentes
¿Puedo hacer una prueba de carga en un hosting compartido?
Solo tras acordarlo con el soporte y con una carga moderada: una prueba agresiva perjudica a tus vecinos de servidor, y la protección del proveedor puede bloquear tu dirección IP.
¿Cuántos visitantes aguanta mi web si la prueba dio 25 RPS?
El RPS no es el número de personas conectadas. Si un visitante abre una página nueva cada 20 segundos de media, 25 peticiones por segundo equivalen a unas 500 personas a la vez. Esta estimación solo vale para páginas HTML: los archivos estáticos, el carrito y la búsqueda cargan el servidor de otra manera.
¿Qué herramienta elijo?
Para comprobar rápido una URL, hey o wrk; para un escenario con varias páginas, umbrales y modelo abierto, k6; Locust encaja con equipos que trabajan en Python. Compara solo ejecuciones de la misma herramienta con la misma configuración.
¿Por qué la portada aguanta miles de peticiones y la web se cae durante las rebajas?
La portada sale de la caché, mientras que el carrito, la búsqueda y la cuenta de cliente no. En el banco, la página con caché aguantó más de 9.000 peticiones por segundo; sin caché, de 24 a 28. Prueba por separado las páginas sin caché.



