NGINX Rate Limiting: La guía completa
Este artículo es una traducción del original en inglés.
Si ha experimentado una avalancha de solicitudes que satura su servidor, sabe lo crítico que es el rate limiting. Ya se trate de un ataque DDoS, de un rastreador con comportamiento anómalo o de demasiados usuarios accediendo a su API al mismo tiempo, el rate limiting de NGINX ofrece una solución elegante mediante el algoritmo de leaky bucket.
En esta guía aprenderá cómo funciona el rate limiting de NGINX, cómo configurarlo correctamente y qué errores comunes evitar.
¿Qué es el rate limiting?
El rate limiting controla cuántas solicitudes puede realizar un cliente dentro de un período de tiempo. Piense en ello como un portero que solo deja entrar a cierta cantidad de personas por minuto.
NGINX implementa el rate limiting mediante el algoritmo de leaky bucket. Imagine un balde con un pequeño orificio en el fondo:
- El agua (las solicitudes) entra a velocidades variables
- El agua sale a una velocidad constante (su límite configurado)
- Si el balde se desborda, el exceso de agua se descarta (se rechazan las solicitudes)
Este enfoque suaviza las ráfagas de tráfico mientras mantiene un flujo constante hacia su backend.
¿Por qué usar el rate limiting de NGINX?
El rate limiting cumple múltiples propósitos:
- Protección DDoS: mitigue los ataques de denegación de servicio limitando las tasas por IP
- Protección de API: evite el abuso de los endpoints de su API
- Conservación de recursos: proteja los servidores backend de la sobrecarga
- Uso justo: garantice que ningún cliente monopolice los recursos
- Mitigación de bots: ralentice los rastreadores y scrapers agresivos
- Protección del inicio de sesión: prevenga los ataques de fuerza bruta contra contraseñas
Para una protección avanzada contra bots, considere implementar un sistema honeypot junto con el rate limiting.
Configuración básica del rate limiting
Paso 1: definir la zona de rate limit
Primero, defina una zona de memoria compartida en el bloque http:
http {
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
}
Desglosemos cada componente:
$binary_remote_addr: la clave de seguimiento (IP del cliente en formato binario)zone=mylimit:10m: crea una zona de memoria compartida de 10 megabytesrate=10r/s: permite 10 solicitudes por segundo
Sugerencia sobre memoria: 1 megabyte almacena aproximadamente 16.000 direcciones IP. Para la mayoría de los sitios, 10m es suficiente.
Paso 2: aplicar el rate limit
Aplique el rate limit en un bloque location o server:
server {
location /api/ {
limit_req zone=mylimit;
proxy_pass http://backend;
}
}
Las solicitudes que superen las 10 por segundo desde la misma IP reciben 503 Service Unavailable.
Entender el parámetro burst
El límite básico anterior es bastante estricto. Si un cliente envía 2 solicitudes a la vez, la segunda se rechaza. El leaky bucket solo permite 1 solicitud cada 100 ms (1/10 de segundo).
El parámetro burst proporciona un margen para los picos de tráfico:
location /api/ {
limit_req zone=mylimit burst=20;
proxy_pass http://backend;
}
Con burst=20:
- 1 solicitud se procesa de inmediato (la asignación de tasa)
- Hasta 20 solicitudes adicionales se ponen en cola en el bucket de burst
- Las solicitudes en cola se liberan al ritmo del rate limit (una cada 100 ms)
- Las solicitudes que superan el burst se rechazan
Importante: las solicitudes de burst se retrasan, no se procesan de inmediato. Una ráfaga de 20 solicitudes tarda 2 segundos en procesarse por completo.
El parámetro nodelay
Para procesar las solicitudes de burst de inmediato sin ponerlas en cola, use nodelay:
location /api/ {
limit_req zone=mylimit burst=20 nodelay;
proxy_pass http://backend;
}
Con burst=20 nodelay:
- Hasta 21 solicitudes (1 de tasa + 20 de burst) se procesan de inmediato
- Los espacios de burst se rellenan al ritmo del rate limit (un espacio cada 100 ms)
- Una vez agotados los espacios, se rechazan las solicitudes excedentes
- Ninguna solicitud se retrasa
Cuándo usar nodelay: cuando el tiempo de respuesta importa más que un suavizado estricto. Perfecto para API que necesitan respuestas inmediatas.
El parámetro delay (enfoque híbrido)
NGINX 1.15.7 introdujo el parámetro delay como término medio:
location /api/ {
limit_req zone=mylimit burst=20 delay=10;
proxy_pass http://backend;
}
Con burst=20 delay=10:
- Las primeras 11 solicitudes (1 de tasa + 10 de delay) se procesan de inmediato
- Las siguientes 10 solicitudes (el burst restante) se retrasan
- Las solicitudes que superan burst=20 se rechazan
Esto permite algunas ráfagas y, a la vez, suaviza los picos más grandes.
Códigos de respuesta del rate limiting
De forma predeterminada, las solicitudes limitadas por tasa reciben HTTP 503. Para las API, 429 (Too Many Requests) es más apropiado:
location /api/ {
limit_req zone=mylimit burst=20 nodelay;
limit_req_status 429;
proxy_pass http://backend;
}
También puede personalizar la página de error:
error_page 429 /rate_limited.html;
location = /rate_limited.html {
internal;
return 429 '{"error": "Rate limit exceeded. Please slow down."}';
add_header Content-Type application/json;
}
Registro de solicitudes limitadas por tasa
Controle cómo se registran las solicitudes limitadas por tasa:
location /api/ {
limit_req zone=mylimit burst=20 nodelay;
limit_req_log_level warn;
proxy_pass http://backend;
}
Niveles de registro disponibles: info, notice, warn (recomendado), error (predeterminado).
Las entradas del registro muestran información útil:
2026/01/22 12:34:56 [warn] limiting requests, excess: 20.500 by zone "mylimit", client: 192.168.1.100
El valor excess muestra cuánto excede el cliente el límite.
Múltiples zonas de rate limit
Aplique varios rate limits para una protección por capas:
http {
# Per-IP rate limit
limit_req_zone $binary_remote_addr zone=perip:10m rate=10r/s;
# Per-server rate limit (global)
limit_req_zone $server_name zone=perserver:10m rate=1000r/s;
server {
location /api/ {
limit_req zone=perip burst=20 nodelay;
limit_req zone=perserver burst=100 nodelay;
proxy_pass http://backend;
}
}
}
Ambos límites deben cumplirse. Una sola IP no puede superar 10r/s Y el servidor no puede superar 1000r/s en conjunto.
Rate limiting por URI
Limite endpoints específicos de forma más agresiva:
http {
limit_req_zone $binary_remote_addr zone=login:10m rate=1r/s;
limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;
server {
location /login {
limit_req zone=login burst=5 nodelay;
limit_req_status 429;
}
location /api/ {
limit_req zone=api burst=20 nodelay;
limit_req_status 429;
}
}
}
Rate limit por URI de la solicitud
Limite URIs específicas independientemente de la IP del cliente:
limit_req_zone $request_uri zone=peruri:10m rate=100r/s;
location /expensive-endpoint {
limit_req zone=peruri burst=50 nodelay;
}
Esto garantiza que ningún endpoint reciba más de 100 solicitudes por segundo.
Inclusión de IP de confianza en la lista blanca
Exima a las IP de confianza del rate limiting:
http {
geo $rate_limit_exempt {
default 1;
127.0.0.1 0;
10.0.0.0/8 0;
192.168.0.0/16 0;
}
map $rate_limit_exempt $rate_limit_key {
0 "";
1 $binary_remote_addr;
}
limit_req_zone $rate_limit_key zone=mylimit:10m rate=10r/s;
}
Cuando $rate_limit_key está vacío, el rate limit no se aplica.
Rate limiting detrás de un balanceador de carga
Detrás de un balanceador de carga o una CDN, $binary_remote_addr muestra la IP del balanceador de carga. Use el módulo real IP:
http {
set_real_ip_from 10.0.0.0/8;
real_ip_header X-Forwarded-For;
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
}
Con Cloudflare:
http {
set_real_ip_from 173.245.48.0/20;
set_real_ip_from 103.21.244.0/22;
set_real_ip_from 103.22.200.0/22;
# ... add all Cloudflare IP ranges
real_ip_header CF-Connecting-IP;
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
}
Rate limiting por minuto
Para límites menos agresivos, use solicitudes por minuto:
limit_req_zone $binary_remote_addr zone=perminute:10m rate=30r/m;
Esto permite 30 solicitudes por minuto (1 cada 2 segundos). Útil para operaciones costosas como el restablecimiento de contraseñas.
Para ventanas de tiempo aún más largas, el NGINX estándar limita rate= a solicitudes por minuto. Para configurar NGINX limit_req por hora, día, semana o mes, necesita la directiva limit_req extendida que se distribuye con NGINX-MOD.
Configuración completa para producción
A continuación se muestra una configuración completa lista para producción:
http {
# Rate limit zones
limit_req_zone $binary_remote_addr zone=general:10m rate=10r/s;
limit_req_zone $binary_remote_addr zone=api:10m rate=30r/s;
limit_req_zone $binary_remote_addr zone=login:10m rate=1r/s;
limit_req_zone $binary_remote_addr zone=static:10m rate=50r/s;
# Whitelist trusted IPs
geo $rate_limit_exempt {
default 1;
127.0.0.1 0;
10.0.0.0/8 0;
}
map $rate_limit_exempt $rate_limit_key {
0 "";
1 $binary_remote_addr;
}
# Recreate zones with whitelist-aware key
limit_req_zone $rate_limit_key zone=general_wl:10m rate=10r/s;
server {
listen 80;
server_name example.com;
# General rate limit for most requests
limit_req zone=general burst=20 nodelay;
limit_req_status 429;
limit_req_log_level warn;
# Login endpoint - very strict
location /login {
limit_req zone=login burst=5;
limit_req_status 429;
proxy_pass http://backend;
}
# API endpoints - more generous
location /api/ {
limit_req zone=api burst=50 nodelay;
limit_req_status 429;
proxy_pass http://api_backend;
}
# Static files - liberal rate limit
location /static/ {
limit_req zone=static burst=100 nodelay;
root /var/www;
}
# Health check - no rate limit
location /health {
limit_req off;
return 200 'OK';
}
}
}
Cómo funciona el algoritmo de leaky bucket
Comprender el funcionamiento interno ayuda a configurar el rate limiting. NGINX almacena dos valores por cada clave de seguimiento:
- excess: nivel actual de agua en el balde (en unidades de mili-solicitud)
- last: marca de tiempo de la última solicitud
Cuando llega una solicitud:
- Calcule el tiempo transcurrido desde la última solicitud
- Drene el balde:
excess = excess - (rate × elapsed_time) - Agregue la nueva solicitud:
excess = excess + 1 - SI
excess > burst: rechace la solicitud - S I
excess > delay: retrase la solicitud - En caso contrario: procésela de inmediato
Este algoritmo solo requiere dos valores por clave, lo que lo hace eficiente en memoria para millones de IP.
Errores comunes que debe evitar
Error 1: olvidar el parámetro burst
# Too strict - rejects all but 1 request per 100ms
limit_req zone=mylimit;
# Mejor: permite ráfagas razonables
limit_req zone=mylimit burst=20 nodelay;
Error 2: Zonas de memoria de tamaño insuficiente
# Demasiado pequeño para sitios de alto tráfico
limit_req_zone $binary_remote_addr zone=small:1m rate=10r/s;
# Adecuado para la mayoría de los casos de uso
limit_req_zone $binary_remote_addr zone=adequate:10m rate=10r/s;
Error 3: No usar 429 para las API
# El 503 predeterminado confunde a los clientes de API
limit_req zone=api;
# Semántica HTTP adecuada
limit_req zone=api;
limit_req_status 429;
Error 4: Limitar las comprobaciones de estado
location /health {
limit_req off; # Importante para los sistemas de monitoreo
return 200 'OK';
}
Probar su configuración de limitación de velocidad
Después de configurar, pruebe con una herramienta de pruebas de carga:
# Enviar 10 solicitudes rápidas
for i in {1..10}; do
curl -s -o /dev/null -w "%{http_code}n" http://localhost/api/test &
done
wait
Para una prueba exhaustiva, utilice Apache Benchmark:
ab -n 100 -c 50 http://localhost/api/test
Revise el registro de errores para ver las entradas de limitación de velocidad:
tail -f /var/log/nginx/error.log | grep "limiting"
Bloqueo automático de IP con Fail2ban
Aunque la limitación de velocidad de NGINX rechaza las solicitudes excesivas, los abusadores persistentes siguen consumiendo recursos. Fail2ban puede bloquear automáticamente a los reincidentes a nivel del firewall.
Fail2ban incluye un filtro integrado nginx-limit-req que analiza los registros de errores de NGINX en busca de mensajes de limitación de velocidad. Actívelo en /etc/fail2ban/jail.local:
[nginx-limit-req]
enabled = true
filter = nginx-limit-req
logpath = /var/log/nginx/error.log
findtime = 600
maxretry = 10
bantime = 24h
Esta configuración:
- Supervisa el registro de errores de NGINX en busca de infracciones de limitación de velocidad
- Bloquea las IP que activan la limitación de velocidad 10 veces en 10 minutos
- Las bloquea en el firewall durante 24 horas
El filtro nginx-limit-req coincide con entradas de registro como:
limiting requests, excess: 20.500 by zone "mylimit", client: 192.168.1.100
Para que esto funcione de manera efectiva, asegúrese de que su limitación de velocidad de NGINX utilice limit_req_log_level warn o un nivel inferior para generar entradas de registro.
Instale fail2ban en sistemas basados en RHEL:
dnf install epel-release
dnf install fail2ban
systemctl enable --now fail2ban
Compruebe las IP bloqueadas:
fail2ban-client status nginx-limit-req
Esto crea una potente defensa de dos niveles: NGINX gestiona la lógica de limitación de velocidad mientras que fail2ban escala a los abusadores persistentes a bloqueos a nivel del firewall.
Módulos avanzados de limitación de velocidad
El módulo integrado limit_req cubre la mayoría de los casos de uso, pero el GetPageSpeed Premium Repository proporciona módulos NGINX adicionales, y una compilación de NGINX parcheada, para escenarios que el NGINX estándar no puede manejar. Habilite primero el repositorio:
dnf install https://extras.getpagespeed.com/release-latest.rpm
Limitación de velocidad por hora, día o semana (NGINX-MOD)
El NGINX estándar solo entiende dos unidades de velocidad: r/s (por segundo) y r/m (por minuto). Escribir rate=10r/h falla en la prueba de configuración con invalid rate "rate=10r/h". Cuando necesite una cuota estricta por hora, por día o por semana, instale NGINX-MOD, la compilación de NGINX drop-in de GetPageSpeed que añade cinco unidades adicionales (r/h, r/d, r/w, r/M, r/Y):
dnf config-manager --set-enabled getpagespeed-extras-nginx-mod
dnf install nginx-mod
NGINX-MOD es un reemplazo directo del binario nginx estándar, por lo que toda configuración existente de r/s y r/m sigue funcionando sin cambios. Con él activo, la configuración por hora previamente rechazada se analiza y aplica correctamente:
limit_req_zone $binary_remote_addr zone=hourly:10m rate=10r/h;
server {
location = /password/reset {
limit_req zone=hourly burst=2 nodelay;
limit_req_status 429;
}
}
Enviar diez solicitudes paralelas a ese endpoint devuelve exactamente tres respuestas 200 (una ranura de velocidad constante más la cola burst=2) y siete rechazos 429. Para cada unidad hasta 1r/Y, las advertencias sobre el dimensionamiento de zonas y las recetas de producción, consulte NGINX limit_req per hour, day, week, month with NGINX-MOD.
Limitación de velocidad distribuida con Redis
Para entornos con balanceo de carga donde los límites de velocidad deben compartirse entre múltiples instancias de NGINX, utilice nginx-module-redis-rate-limit:
dnf install nginx-module-redis-rate-limit
Este módulo utiliza el Generic Cell Rate Algorithm (GCRA) respaldado por Redis:
load_module modules/ngx_http_rate_limit_module.so;
upstream redis {
server 127.0.0.1:6379;
keepalive 1024;
}
location /api/ {
rate_limit $remote_addr requests=15 period=1m burst=20;
rate_limit_pass redis;
}
Bloqueo dinámico de IP
El nginx-module-dynamic-limit-req amplía el limitador de velocidad estándar para bloquear dinámicamente las IP abusivas:
dnf install nginx-module-dynamic-limit-req
Este módulo puede funcionar con RedisPushIptables para enviar automáticamente reglas de bloqueo a iptables para la protección a nivel de red.
Limitación de velocidad de ancho de banda
Para limitar la velocidad de descarga (no la tasa de solicitudes), utilice nginx-module-limit-traffic-rate:
dnf install nginx-module-limit-traffic-rate
load_module modules/ngx_http_limit_traffic_rate_filter_module.so;
http {
limit_traffic_rate_zone rate $remote_addr 32m;
location /downloads/ {
limit_traffic_rate rate 100k; # 100 KB/s por IP
}
}
A diferencia de limit_rate que limita la velocidad por conexión, esto limita el ancho de banda total por IP en todas las conexiones.
Protección de la carga del sistema
El módulo nginx-module-sysguard protege automáticamente su servidor cuando la carga del sistema, la memoria o los tiempos de respuesta superan los umbrales:
dnf install nginx-module-sysguard
load_module modules/ngx_http_sysguard_module.so;
server {
sysguard on;
sysguard_load load=10.5 action=/loadlimit;
sysguard_mem free=100M action=/memlimit;
sysguard_rt rt=0.5 period=5s action=/slowlimit;
location /loadlimit { return 503; }
location /memlimit { return 503; }
location /slowlimit { return 503; }
}
Mitigación de bots con desafíos de cookies
Para una protección sofisticada contra bots, nginx-module-testcookie utiliza desafíos de cookies de JavaScript:
dnf install nginx-module-testcookie
Este módulo emite desafíos de cookies cifradas que requieren la ejecución de JavaScript, bloqueando la mayoría de las herramientas automatizadas mientras permite los navegadores reales.
Limitación de velocidad basada en Lua
Para la máxima flexibilidad, lua-resty-limit-traffic proporciona limitación de velocidad basada en Lua que funciona en cualquier punto del ciclo de vida de la solicitud:
dnf install lua5.1-resty-limit-traffic
access_by_lua_block {
local limit_req = require "resty.limit.req"
local lim = limit_req.new("my_limit_store", 200, 100)
local delay, err = lim:incoming(ngx.var.binary_remote_addr, true)
if not delay and err == "rejected" then
return ngx.exit(429)
end
if delay >= 0.001 then
ngx.sleep(delay)
end
}
Esto proporciona características como la combinación de múltiples limitadores, claves personalizadas y limitación de velocidad en el momento del handshake SSL.
Seguridad más allá de la limitación de velocidad
La limitación de velocidad es una capa de defensa. Para un análisis exhaustivo de la seguridad de NGINX, utilice gixy, un analizador estático que detecta configuraciones incorrectas:
- Vulnerabilidades de Server-Side Request Forgery (SSRF)
- Ataques de división HTTP
- Problemas de path traversal
- Configuraciones SSL/TLS débiles
- Encabezados de seguridad faltantes
Instale gixy en sistemas basados en RHEL:
dnf install https://extras.getpagespeed.com/release-latest.rpm
dnf install gixy
Ejecute el análisis:
gixy /etc/nginx/nginx.conf
Para una protección adicional de la aplicación web, considere desplegar ModSecurity with OWASP rules.
Consideraciones de rendimiento
La limitación de velocidad tiene un impacto mínimo en el rendimiento:
- Las zonas de memoria compartida se almacenan en RAM con un tiempo de acceso O(1)
- El cálculo del leaky bucket es aritmética simple
- La búsqueda en el árbol rojo-negro es O(log n) para encontrar las claves rastreadas
Para sitios de alto tráfico, considere:
- Zonas de memoria más grandes para evitar la expiración prematura
- Limitación de velocidad en el borde (nivel de CDN) para una mejor escalabilidad
- Limitación de conexiones (
limit_conn) como complemento
Para un rendimiento óptimo de NGINX, asegúrese también de un ajuste adecuado de los procesos worker.
Conclusión
La limitación de velocidad de NGINX protege los servidores del abuso. Al comprender el algoritmo del leaky bucket y configurar correctamente las zonas, los parámetros de burst y los códigos de respuesta, usted construye aplicaciones resilientes.
Puntos clave:
- Incluya siempre un parámetro
burstpara una limitación de velocidad realista - Utilice
nodelaycuando el tiempo de respuesta sea importante - Devuelva el estado 429 para los endpoints de API
- Incluya en la lista blanca las IP de confianza para el monitoreo y los servicios internos
- Combine múltiples límites de velocidad para una defensa en profundidad
- Utilice fail2ban para bloquear automáticamente a los abusadores persistentes
- Pruebe exhaustivamente antes de desplegar en producción
- Considere módulos avanzados para una limitación de velocidad distribuida o especializada
La limitación de velocidad funciona mejor como parte de una estrategia de seguridad integral. Combínela con reglas de firewall, fail2ban y analizadores de seguridad como gixy para una protección completa.
Las opciones de limitación de velocidad distribuida, por hora y de ancho de banda descritas anteriormente se incluyen en el GetPageSpeed Premium Repository. Una sola suscripción desbloquea todos los módulos de NGINX y la compilación NGINX-MOD en todos sus servidores.
Limitación de velocidad más monitoreo continuo. Una limit_req_zone solo es efectiva mientras la directiva limit_req que la utiliza siga estando en el location correcto. GetPageSpeed Amplify ejecuta análisis programados de gixy en cada host y vincula los hallazgos con las métricas en tiempo real de NGINX. Compatible como reemplazo directo del obsoleto nginx-amplify-agent (fin de vida en enero de 2026).