El 15 de septiembre de 2026, el ingeniero SRE Daniil Romashov (@mwgtd) abrió el archivo waf.tf y dejó un comentario breve al inicio: «Un cliente quedó atrapado en un bucle sobre la ruta de tokens, envía unas 20 peticiones por segundo y se come todo el presupuesto». Así empezó una batalla de 16 días ajustando límites en producción, que el autor detalló en HackerNoon.
La cadena es sencilla: la petición de un access token pasa por Amazon CloudFront hacia API Gateway y de ahí a AWS Lambda. La función tiene un tope estricto de reserved concurrency: máximo 30 instancias simultáneas por región. Un cliente en bucle ocupa los 30 espacios, los demás reciben 429 desde Lambda y, sin token, nada funciona en la aplicación. Este tráfico debe frenarse en el borde, en CloudFront (edge rate limiting), antes de que las peticiones sobrantes lleguen a API Gateway y al backend.
Cómo nació la frontera entre usuarios legítimos y bots a partir de logs semanales
El número no se eligió a ojo. Daniil recopiló los logs de CloudFront de siete días (del 8 al 15 de septiembre de 2026), con 8,921 IP de clientes, y calculó para cada una el pico de peticiones a la ruta de tokens en ventanas de cinco minutos.
El mayor temor era la dirección NAT compartida del renderizado en servidor del panel europeo: detrás de ella están todos los usuarios de Europa, así que el ingeniero esperaba una cifra altísima. En la práctica, el pico resultó sorprendentemente bajo y apareció una brecha limpia entre el cliente normal más activo y el infractor más discreto.
Picos de peticiones a la ruta de tokens en 5 minutos según logs de CloudFront
El límite elegido, equivalente a una petición por segundo sostenida, quedó justo en medio de la brecha: ningún cliente normal lo alcanza y cualquier infractor lo supera con holgura. Ni siquiera pusieron en el gráfico al cliente más agresivo para no aplastar la escala: generaba 7,383 peticiones en cinco minutos (hasta 3,888 en un minuto). El límite y la ventana se guardaron en locals justo junto al comentario extraído de los logs.
El ingeniero se saltó a propósito dos pasos «de manual». Primero, no dejó la regla una semana en modo COUNT (donde WAF solo cuenta coincidencias sin bloquear) y desplegó directo block con 429, confiando en los registros. Eso sí, si en tu sistema no hay una brecha tan clara o miles de personas comparten un NAT corporativo, conviene no arriesgarse y probar un par de días en COUNT. Segundo, no activó los logs completos de WAF (aws_wafv2_web_acl_logging_configuration), quedándose solo con las métricas de CloudWatch y el muestreo de peticiones (sampled_requests_enabled = true).
Anatomía de la regla en Terraform y la trampa en CloudWatch Alarm
La regla se definió en Terraform mediante aws_wafv2_web_acl con scope = "CLOUDFRONT": un Web ACL así debe vivir en us-east-1 y asociarse a la distribución con web_acl_id.
Por dentro opera una regla rate-based de AWS WAF. Las ventanas válidas de evaluation_window_sec son 60, 120, 300 (por defecto) o 600 segundos. La clave IP toma la dirección real que ve CloudFront, sin depender de X-Forwarded-For. Para no contar todo el sitio, scope_down_statement limita el filtro a peticiones GET sobre la ruta del token en minúsculas y excluye el IP set del runner de QA; todo lo demás pasa por default_action = allow. Además, reemplazaron el 403 por defecto de WAF usando custom_response para devolver 429 sin cuerpo, igual que una Lambda saturada.
# Regla principal: bloquea a todos menos al IP set del runner de QA
rule {
name = "rate-limit-token"
priority = 10
action {
block {
# Cambiamos el 403 por defecto al 429 habitual sin cuerpo
custom_response { response_code = 429 }
}
}
statement {
rate_based_statement {
limit = local.waf_token_rate_limit # 300
evaluation_window_sec = local.waf_token_rate_window # 300
aggregate_key_type = "IP"
scope_down_statement {
and_statement {
# uri_path EXACTLY <token path>, LOWERCASE
# method EXACTLY "GET"
# not_statement { ip_set_reference_statement { QA } }
}
}
}
}
visibility_config {
cloudwatch_metrics_enabled = true
metric_name = "acl-rate-limit-token"
sampled_requests_enabled = true
}
}
Veintidós minutos después de la regla añadieron la alerta en CloudWatch: BlockedRequests en AWS/WAFV2, Sum cada 300 segundos, 1 periodo, umbral > 0. Incluso una sola petición bloqueada dispara el aviso a SNS; al volver a cero se resuelve con ok_actions, y missing data se trata como estado normal. La gran trampa: en la dimensión Rule hay que poner metric_name de visibility_config y no el name de la regla, o la alarma nunca se disparará y permanecerá en silencio.
# Alarma ante cualquier bloqueo en una ventana de 5 minutos
resource "aws_cloudwatch_metric_alarm" "waf_token_blocked" {
alarm_name = "waf-token-rate-limit-blocked"
namespace = "AWS/WAFV2"
metric_name = "BlockedRequests"
statistic = "Sum"
period = 300
evaluation_periods = 1
threshold = 0
comparison_operator = "GreaterThanThreshold"
treat_missing_data = "notBreaching"
dimensions = {
WebACL = aws_wafv2_web_acl.prod.name
# Aquí va metric_name, ¡NO rule.name!
Rule = "acl-rate-limit-token"
}
}
El despliegue de ese día (que arrancó a las 14:05) tomó dos horas. Siete segundos después del commit de la alarma hubo que tocar otro repositorio para añadir sns:Publish a cloudwatch.amazonaws.com con la condición aws:SourceAccount en la política de SNS. Luego falló el plan en CI: quitaron la búsqueda data del tópico SNS, dejaron el ARN fijo como texto y asignaron al usuario de CI 11 permisos de wafv2 y 6 de cloudwatch.
16 días en producción: caída de pruebas E2E, regla gemela y una segunda ruta
El 24 de septiembre fallaron las pruebas E2E (navegador y Node.js) tanto en stage como en producción: todas las ejecuciones salen desde la misma IP del runner de QA y una página de prueba solicita tokens desde varios web workers a la vez.
En vez de abrir una lista blanca sin tope, Daniil creó una regla gemela con prioridad 20: la regla principal excluye el IP set del runner con not_statement, mientras la vecina cuenta únicamente ese conjunto con un límite de 3,000 en 5 minutos (10 veces mayor). Los contadores no se mezclan y ni siquiera un runner roto podrá bombardear producción sin fin.
# Regla gemela: tope separado de 3000 para el runner de QA
rule {
name = "rate-limit-token-qa"
priority = 20
action {
block {
custom_response { response_code = 429 }
}
}
statement {
rate_based_statement {
limit = local.waf_token_qa_limit # 3000
evaluation_window_sec = local.waf_token_rate_window # 300
aggregate_key_type = "IP"
scope_down_statement {
and_statement {
# uri_path EXACTLY <token path>, LOWERCASE
# method EXACTLY "GET"
# ip_set_reference_statement { QA }
}
}
}
}
visibility_config {
cloudwatch_metrics_enabled = true
metric_name = "acl-rate-limit-token-qa"
sampled_requests_enabled = true
}
}
Un compañero llevó la regla a stage sin alertas porque ahí ya estaban cazando un bug conocido de frontend y los avisos solo generarían ruido. El 30 de septiembre cerraron una segunda ruta (GET del perfil del marketplace) según los logs del 23 al 30 de septiembre (pico de 60 en prod, 126 en stage y 113 del runner de QA): pusieron los mismos 300 y 3,000 junto con la segunda alarma en producción. En total quedaron cuatro reglas en cada uno de los dos ACL (prioridades 10, 20, 30 y 40): 8 reglas rate-based y 2 IP sets.
Puedes probar en el simulador cómo se comportan la regla principal, la gemela y el acceso directo saltándose CloudFront.
Simulador AWS WAF: límite 300, regla gemela 3000 y bypass de CloudFront
El tercer modo del simulador muestra la grieta clásica de cualquier defensa en el borde: si un cliente apunta directo a API Gateway saltándose CloudFront, los límites perimetrales no sirven de nada.
Blindaje por la retaguardia y lista honesta de puntos ciegos
En stage, el acceso directo saltándose CloudFront lo cerró un compañero del autor: CloudFront añade una cabecera secreta a cada petición enviada al origen, y el WAF regional en API Gateway solo deja pasar GET al token si esa cabecera está presente.
Terraform genera el secreto (random_password, 44 caracteres sin símbolos especiales) y lo guarda en AWS SSM como parámetro cifrado SecureString. Al recurso le añadieron lifecycle { ignore_changes = [value] }: sin eso, el siguiente terraform apply revertiría en silencio una clave rotada a mano. La rotación sigue tres pasos: escribir el nuevo valor en SSM, actualizar el WAF regional y desplegar ambos servicios. Para CI tuvieron que sumar 7 permisos de SSM más ssm:DescribeParameters (y el 22 de septiembre, permisos para ACL regionales y su asociación a stages de API Gateway).
También destaca la lista honesta de «puntos ciegos» del propio autor: los logs crudos y scripts de cálculo no están en el repositorio, no revisó el historial de CloudWatch para contar cuántas veces saltaron las alarmas, no comprobó si desaparecieron los 429 de Lambda para todos los usuarios, no sabe quiénes eran los infractores de septiembre y tampoco miró el historial del pipeline E2E en el proyecto vecino tras subir el límite a 3,000.
Aun así, millones de peticiones sobrantes se quedaron frenadas en CloudFront y el umbral de 300 jamás hizo falta cambiarlo. Los primeros en caer bloqueados fueron los de casa: un bug de frontend en stage y el runner de QA; una vez corregidos, el WAF solo salta ante DDoS reales. Como resume Daniil Romashov, un límite con alerta de bloqueos no solo atrapa ataques sino también tus propios bugs, así que antes de declarar un DDoS revisa de quién es esa IP.

