Ir al contenido
Correo Panel de control Elegir plan

Prueba de carga de una web: herramientas, métricas y plan seguro

Prueba de carga de una web: herramientas, métricas y plan seguro

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.

Gráfico del banco de pruebas: sin caché el RPS se queda entre 23 y 28 mientras el tiempo de respuesta p95 pasa de 0,36 s con 5 peticiones simultáneas a 7,92 s con 200

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é.

Más sobre este tema

Todos los artículos
Vecinos en hosting compartido: cómo afectan a tu web y cómo verlo
Hosting compartido23.04.2026

Vecinos en hosting compartido: cómo afectan a tu web y cómo verlo

Cómo influyen los vecinos de un hosting compartido en la velocidad y el correo de tu web: prueba con dos pools de…

La conexión no es privada: cómo solucionar errores NET::ERR_CERT
Solución de problemas de hosting05.04.2026

La conexión no es privada: cómo solucionar errores NET::ERR_CERT

Por qué el navegador muestra «La conexión no es privada» y qué significan NET::ERR_CERT_DATE_INVALID, COMMON_NAME_INVALID y AUTHORITY_INVALID: probado en un banco de…

Error 500 Internal Server Error: encuentra la causa en el log
Solución de problemas de hosting03.04.2026

Error 500 Internal Server Error: encuentra la causa en el log

Error 500 Internal Server Error: qué ve el visitante, qué línea buscar en el log de errores y cómo corregir la causa.…