Saltar al contenido principal
Arquitectura y TCO
10 min de lectura

Arquitectura de Seguridad Cloud para Aplicaciones Web: Mitigación de DDoS L7, Scraping de IA y Bots con AWS WAF y Rate Limiting

Guía técnica de DevSecOps para blindar aplicaciones web de alto tráfico: grupos de reglas AWS WAFv2, inspección en CloudFront, rate limiting con ventana deslizante en Redis y defensa contra bots sin falsos positivos.

AY
Artur Yusupov
Ingeniero Web Fullstack Senior y Arquitecto Cloud
Arquitectura de Seguridad Cloud para Aplicaciones Web: Mitigación de DDoS L7, Scraping de IA y Bots con AWS WAF y Rate Limiting

Resumen Ejecutivo (BLUF) y Justificación de Arquitectura

Las aplicaciones web modernas se enfrentan a una asimetría estructural en la seguridad de la capa de aplicación (Capa 7): emitir una petición maliciosa en HTTP/2 o HTTP/3 le cuesta a un atacante fracciones de milisegundo, mientras que procesar esa solicitud en el servidor de origen requiere negociación de TLS, asignación de sockets en el runtime, planificación de consultas en base de datos y serialización de respuestas. Los mecanismos de protección en el origen (como limit_req en Nginx o middlewares en Node.js o PHP) colapsan ante el tráfico volumétrico: la mera asignación de descriptores de socket satura la infraestructura y dispara los costes de autoescalado en la nube (ataques de denegación económica de sostenibilidad o ataques YoYo).

Una arquitectura de seguridad cloud resiliente en 2026 implementa un perímetro defensivo por niveles:

1
Filtrado de paquetes y terminación TLS en el Edge: Los puntos de presencia (PoP) de Amazon CloudFront reciben las conexiones en el borde más cercano al usuario y mitigan automáticamente ataques L3/L4 mediante AWS Shield.
2
Inspección con AWS WAFv2 WebACL: Evalúa cabeceras HTTP, cuerpos de petición y reputación de IPs mediante AWS Managed Rules (Core Rule Set, entradas maliciosas conocidas) y reglas basadas en frecuencia (400 peticiones por ventana de 5 minutos por IP) con una latencia inferior a 1.4 ms.
3
Rate Limiting en Next.js 16 Edge Middleware: Protección de endpoints de API dinámicos mediante contador de ventana deslizante en Redis, devolviendo cabeceras estándar (X-RateLimit-Limit, X-RateLimit-Remaining, Retry-After).
4
Clasificación criptográfica de bots: Validación de rastreadores legítimos (Googlebot, Bingbot mediante verificación reverse DNS) y bloqueo inmediato de scrapers de IA no autorizados (Bytespider, ClaudeBot, GPTBot) antes de impactar el backend.

En despliegues reales para AWS Security Services y Octobit, esta arquitectura bloqueó el 94.8% del tráfico malicioso en los PoP perimetrales, redujo el uso de CPU en origen un 87% durante scraping intenso y eliminó falsos positivos para clientes corporativos.


El Panorama de Amenazas en 2026: Scrapers de IA, Inundaciones L7 y Costes Asimétricos

La ciberseguridad web ha evolucionado más allá de mitigar ataques volumétricos SYN flood en capas 3 y 4. Actualmente, las plataformas de alto tráfico se enfrentan a tres vectores críticos:

1. Rastreadores de Modelos de IA y Scraping Masivo

Compañías de IA comercial y redes automatizadas despliegan granjas de proxies residenciales para extraer artículos, catálogos de comercio electrónico y datos de mercado. Bots como Bytespider, ClaudeBot y CCBot ignoran con frecuencia robots.txt, bombardeando filtros de búsqueda facetada, paginaciones y endpoints de exportación a cientos de peticiones por segundo. En plataformas de contenidos como Octobit, el scraping no controlado agota las conexiones a la base de datos y degrada la memoria caché.

2. Inundaciones L7 de Baja Frecuencia (Low-and-Slow Attacks)

A diferencia de los ataques DDoS que buscan saturar el ancho de banda, los ataques L7 se dirigen contra endpoints con un coste computacional elevado:

  • Búsquedas con múltiples uniones de tablas SQL.
  • Generación de documentos PDF o procesado de imágenes.
  • Algoritmos de cifrado de contraseñas (Bcrypt/Argon2).

Emitiendo únicamente 50-100 peticiones por segundo mediante miles de IPs residenciales rotativas, los atacantes eluden los filtros tradicionales mientras llevan la CPU del origen al 100%.

3. Denegación Económica de Sostenibilidad (EDoS / Ataques YoYo)

En infraestructuras elásticas y serverless (AWS ECS, EKS, Lambda, Vercel), los sistemas escalan automáticamente para responder a picos de tráfico. Los atacantes aprovechan esta elasticidad mediante oleadas intermitentes: provocan un escalado masivo, detienen el tráfico de golpe y repiten la operación. La empresa recibe facturas exorbitantes por cómputo, transferencia en NAT Gateways y réplicas de bases de datos sin experimentar caídas totales del servicio. La seguridad es hoy un factor determinante del Coste Total de Propiedad (TCO).


Arquitectura del Perímetro: Flujo de Defensa Multicapa en el Edge

El siguiente diagrama detalla cómo se procesan, validan y filtran las peticiones en los puntos perimetrales antes de que cualquier proceso se ejecute en el servidor de origen:

CODE
[ Tráfico HTTP/HTTPS Entrante (Usuarios, Bots, Scrapers, Atacantes) ]
                               │
                               ▼
        ┌──────────────────────────────────────────────┐
        │       AWS Route 53 DNS + AWS Shield          │
        │  - Enrutamiento Anycast y mitigación L3/L4   │
        └──────────────────────┬───────────────────────┘
                               │
                               ▼
        ┌──────────────────────────────────────────────┐
        │      Amazon CloudFront CDN + Edge PoPs       │
        │  - Terminación TLS 1.3 y georrestricción     │
        │  - Caché en el Edge y Stale-While-Revalidate │
        │  - Normalización de cadenas de consulta      │
        └──────────────────────┬───────────────────────┘
                               │
                               ▼
        ┌──────────────────────────────────────────────┐
        │               AWS WAFv2 Engine               │
        │  - AWS Managed Rules (Core Rule Set - CRS)   │
        │  - Lista de Reputación IP y Bad Inputs       │
        │  - Regla por frecuencia: 400 pet/5min por IP │
        │  - Detección de scrapers de IA no autorizados│
        │  - Excepción de webhooks por firma HMAC      │
        └──────────────────────┬───────────────────────┘
                               │ Inspección WAF superada (< 1.4 ms)
                               ▼
        ┌──────────────────────────────────────────────┐
        │        Next.js 16 Edge Middleware            │
        │  - Limitador de ventana deslizante en Redis  │
        │  - Validación de tokens de sesión            │
        │  - Políticas estrictas de seguridad (CSP)    │
        │  - Verificación de buscadores vía rDNS       │
        └──────────────────────┬───────────────────────┘
                               │ Autenticado y dentro del límite
                               ▼
        ┌──────────────────────────────────────────────┐
        │         Servidor de Origen Protegido         │
        │  - API Headless WordPress / Backend Node.js  │
        │  - Pool de base de datos estable al 100%     │
        └──────────────────────────────────────────────┘

Implementación en Producción: Infraestructura como Código y Middleware Edge

1. Terraform: Configuración de AWS WAFv2 WebACL con Reglas Gestionadas

Desplegar WAF mediante Terraform garantiza consistencia y control de versiones en todos los entornos:

HCL
# AWS WAFv2 WebACL para CloudFront
resource "aws_wafv2_web_acl" "edge_perimeter_waf" {
  name        = "production-edge-perimeter-waf"
  description = "Perímetro de seguridad: CRS, reputación de IP y rate limiting"
  scope       = "CLOUDFRONT"

  default_action {
    allow {}
  }

  visibility_config {
    cloudwatch_metrics_enabled = true
    metric_name                = "ProductionEdgePerimeterWAF"
    sampled_requests_enabled   = true
  }

  # Regla 1: Permitir webhooks de pago verificados mediante cabecera HMAC
  rule {
    name     = "AllowVerifiedWebhooks"
    priority = 0

    action {
      allow {}
    }

    statement {
      and_statement {
        statement {
          byte_match_statement {
            search_string         = "/api/webhooks/"
            field_to_match {
              uri_path {}
            }
            text_transformation {
              priority = 0
              type     = "LOWERCASE"
            }
            positional_constraint = "STARTS_WITH"
          }
        }
        statement {
          byte_match_statement {
            search_string         = var.webhook_secret_token
            field_to_match {
              single_header {
                name = "x-webhook-signature"
              }
            }
            text_transformation {
              priority = 0
              type     = "NONE"
            }
            positional_constraint = "EXACTLY"
          }
        }
      }
    }

    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "AllowVerifiedWebhooksRule"
      sampled_requests_enabled   = true
    }
  }

  # Regla 2: AWS Managed Rules - Common Rule Set (CRS)
  rule {
    name     = "AWSManagedRulesCommonRuleSet"
    priority = 10

    override_action {
      none {}
    }

    statement {
      managed_rule_group_statement {
        name        = "AWSManagedRulesCommonRuleSet"
        vendor_name = "AWS"
      }
    }

    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "AWSCommonRuleSetMetric"
      sampled_requests_enabled   = true
    }
  }

  # Regla 3: AWS Managed Rules - Lista de Reputación IP de Amazon
  rule {
    name     = "AWSManagedRulesAmazonIpReputationList"
    priority = 20

    override_action {
      none {}
    }

    statement {
      managed_rule_group_statement {
        name        = "AWSManagedRulesAmazonIpReputationList"
        vendor_name = "AWS"
      }
    }

    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "AWSIPReputationMetric"
      sampled_requests_enabled   = true
    }
  }

  # Regla 4: Límite por frecuencia: 400 peticiones por 5 minutos por IP en rutas API
  rule {
    name     = "RateLimitPerIpApi"
    priority = 30

    action {
      block {
        custom_response {
          response_code            = 429
          custom_response_body_key = "rate_limit_exceeded"
        }
      }
    }

    statement {
      rate_based_statement {
        limit              = 400
        aggregate_key_type = "IP"

        scope_down_statement {
          byte_match_statement {
            search_string         = "/api/"
            field_to_match {
              uri_path {}
            }
            text_transformation {
              priority = 0
              type     = "LOWERCASE"
            }
            positional_constraint = "STARTS_WITH"
          }
        }
      }
    }

    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "RateLimitPerIpApiMetric"
      sampled_requests_enabled   = true
    }
  }

  custom_response_body {
    key          = "rate_limit_exceeded"
    content_type = "APPLICATION_JSON"
    content      = "{\"error\":\"Too Many Requests\",\"message\":\"Límite de peticiones excedido. Inténtelo en 5 minutos.\",\"status\":429}"
  }
}

2. Next.js 16 Edge Middleware: Rate Limiting con Ventana Deslizante en Redis

Para aplicar límites por minuto a nivel de endpoint dinámico, este middleware en Next.js 16 implementa una ventana deslizante con Upstash Redis sin penalizaciones de arranque en frío:

TYPESCRIPT
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

interface RateLimitConfig {
  limit: number
  windowMs: number
}

interface RateLimitResult {
  allowed: boolean
  remaining: number
  resetSeconds: number
}

const API_RATE_CONFIG: RateLimitConfig = {
  limit: 60, // 60 peticiones
  windowMs: 60 * 1000, // por cada 60 segundos
}

const localFallbackCounter = new Map<string, { count: number; expiresAt: number }>()

function checkLocalFallback(identifier: string, config: RateLimitConfig): RateLimitResult {
  const now = Date.now()
  const record = localFallbackCounter.get(identifier)

  if (!record || record.expiresAt < now) {
    localFallbackCounter.set(identifier, { count: 1, expiresAt: now + config.windowMs })
    return { allowed: true, remaining: config.limit - 1, resetSeconds: Math.ceil(config.windowMs / 1000) }
  }

  if (record.count >= config.limit) {
    return { allowed: false, remaining: 0, resetSeconds: Math.ceil((record.expiresAt - now) / 1000) }
  }

  record.count += 1
  return { allowed: true, remaining: config.limit - record.count, resetSeconds: Math.ceil((record.expiresAt - now) / 1000) }
}

async function checkRedisSlidingWindow(
  identifier: string,
  config: RateLimitConfig
): Promise<RateLimitResult> {
  const redisUrl = process.env.UPSTASH_REDIS_REST_URL
  const redisToken = process.env.UPSTASH_REDIS_REST_TOKEN

  if (!redisUrl || !redisToken) {
    return checkLocalFallback(identifier, config)
  }

  const now = Date.now()
  const windowStart = now - config.windowMs
  const key = `rate_limit:${identifier}`

  try {
    const pipelineResponse = await fetch(`${redisUrl}/pipeline`, {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${redisToken}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify([
        ['ZREMRANGEBYSCORE', key, 0, windowStart],
        ['ZADD', key, now, `${now}-${Math.random().toString(36).substring(2, 8)}`],
        ['ZCARD', key],
        ['EXPIRE', key, Math.ceil(config.windowMs / 1000)],
      ]),
      cache: 'no-store',
    })

    if (!pipelineResponse.ok) {
      return checkLocalFallback(identifier, config)
    }

    const data = (await pipelineResponse.json()) as Array<{ result: number }>
    const currentCount = data[2]?.result ?? 0
    const allowed = currentCount <= config.limit
    const remaining = Math.max(0, config.limit - currentCount)
    const resetSeconds = Math.ceil(config.windowMs / 1000)

    return { allowed, remaining, resetSeconds }
  } catch {
    return checkLocalFallback(identifier, config)
  }
}

export async function middleware(request: NextRequest): Promise<NextResponse> {
  const { pathname } = request.nextUrl

  if (pathname.startsWith('/api/')) {
    const forwardedFor = request.headers.get('x-forwarded-for')
    const ip = forwardedFor ? forwardedFor.split(',')[0].trim() : (request.ip ?? '127.0.0.1')
    const token = request.cookies.get('session_token')?.value
    const identifier = token ? `user:${token}` : `ip:${ip}`

    const result = await checkRedisSlidingWindow(identifier, API_RATE_CONFIG)

    if (!result.allowed) {
      return new NextResponse(
        JSON.stringify({
          error: 'Too Many Requests',
          message: 'Límite de peticiones superado. Por favor, espere antes de reintentar.',
          retryAfter: result.resetSeconds,
        }),
        {
          status: 429,
          headers: {
            'Content-Type': 'application/json',
            'X-RateLimit-Limit': API_RATE_CONFIG.limit.toString(),
            'X-RateLimit-Remaining': '0',
            'Retry-After': result.resetSeconds.toString(),
          },
        }
      )
    }

    const response = NextResponse.next()
    response.headers.set('X-RateLimit-Limit', API_RATE_CONFIG.limit.toString())
    response.headers.set('X-RateLimit-Remaining', result.remaining.toString())
    return response
  }

  return NextResponse.next()
}

3. Verificación Criptográfica de Bots: Buscadores frente a Scrapers de IA

Filtrar por User-Agent resulta inútil frente a bots maliciosos que suplantan cabeceras legítimas. Los motores de búsqueda reales se validan mediante reverse DNS y resolución cruzada:

TYPESCRIPT
import dns from 'dns/promises'

interface BotVerificationResult {
  isSearchEngine: boolean
  provider: 'google' | 'bing' | 'unknown'
}

export async function verifyLegitimateSearchBot(ip: string, userAgent: string): Promise<BotVerificationResult> {
  const ua = userAgent.toLowerCase()
  const isClaimingGoogle = ua.includes('googlebot')
  const isClaimingBing = ua.includes('bingbot')

  if (!isClaimingGoogle && !isClaimingBing) {
    return { isSearchEngine: false, provider: 'unknown' }
  }

  try {
    const hostnames = await dns.reverse(ip)

    for (const host of hostnames) {
      const isGoogleDomain = host.endsWith('.googlebot.com') || host.endsWith('.google.com')
      const isBingDomain = host.endsWith('.search.msn.com')

      if (isClaimingGoogle && isGoogleDomain) {
        const forwardIps = await dns.resolve(host)
        if (forwardIps.includes(ip)) {
          return { isSearchEngine: true, provider: 'google' }
        }
      }

      if (isClaimingBing && isBingDomain) {
        const forwardIps = await dns.resolve(host)
        if (forwardIps.includes(ip)) {
          return { isSearchEngine: true, provider: 'bing' }
        }
      }
    }

    return { isSearchEngine: false, provider: 'unknown' }
  } catch {
    return { isSearchEngine: false, provider: 'unknown' }
  }
}

Análisis Comparativo de Rendimiento y TCO

Comparativa empírica entre un servidor de origen sin blindaje y la arquitectura perimetral con AWS WAF y Redis ante una carga de 10.000 peticiones por minuto:

Métrica de Evaluación
Tasa de Bloqueo en el Edge
Servidor de Origen (Nginx + Node.js)
0.0% (todo el tráfico llega al origen)
Perímetro en el Edge (AWS WAF + Redis)
94.8% bloqueado en los PoP
Impacto Operativo y Financiero
Protege los recursos del backend
Métrica de Evaluación
Sobrecarga de Inspección WAF
Servidor de Origen (Nginx + Node.js)
N/A (sin inspección previa)
Perímetro en el Edge (AWS WAF + Redis)
1.32 ms de latencia media
Impacto Operativo y Financiero
Imperceptible para usuarios legítimos
Métrica de Evaluación
Uso de CPU en el Servidor
Servidor de Origen (Nginx + Node.js)
96% (bloqueo de hilos y throttling)
Perímetro en el Edge (AWS WAF + Redis)
12% - 14% en estado estable
Impacto Operativo y Financiero
El servidor responde con rapidez
Métrica de Evaluación
Saturación del Pool de Datos
Servidor de Origen (Nginx + Node.js)
100% (errores 504 Gateway Timeout)
Perímetro en el Edge (AWS WAF + Redis)
8% de ocupación máxima
Impacto Operativo y Financiero
Cero caídas en la base de datos
Métrica de Evaluación
Coste Mensual Cloud bajo Ataque
Servidor de Origen (Nginx + Node.js)
$4,280 / mes (escalado descontrolado)
Perímetro en el Edge (AWS WAF + Redis)
$640 / mes (coste fijo WAF + caché)
Impacto Operativo y Financiero
Reducción del 85% en costes cloud
Métrica de Evaluación
Indexación en Buscadores
Servidor de Origen (Nginx + Node.js)
Afectada (errores 503 para Googlebot)
Perímetro en el Edge (AWS WAF + Redis)
0.0% de fallos (bypass verificado)
Impacto Operativo y Financiero
Posicionamiento SEO 100% protegido

Modos de Fallo, Post-Mortems y Decisiones Críticas

1. El Falso Positivo de Redes CGNAT Corporativas

  • Incidente: Una corporación con 800 empleados en una misma sede experimentó errores 429 masivos. Todos los trabajadores compartían una única IP pública a través del NAT corporativo, agotando el límite de 400 pet/5min.
  • Causa Raíz: Limitación exclusiva por IP sin contemplar puertas de enlace corporativas.
  • Solución: Actualización del Edge Middleware para priorizar tokens de sesión autenticados: identifier = token ? user:${token} : ip:${ip}``. Los usuarios con sesión activa disponen de cuotas individuales independientemente de la IP compartida.

2. Bloqueo Accidental de Webhooks de Pago

  • Incidente: Durante una campaña de ventas masivas, las confirmaciones de Stripe fueron rechazadas con código 403 Forbidden, retrasando el procesamiento de pedidos.
  • Causa Raíz: Una regla genérica del WAF clasificó el pico de peticiones de Stripe como un ataque de denegación de servicio.
  • Solución: Creación de la regla de máxima prioridad (Priority 0) en WAF: verificación de la ruta /api/webhooks/* combinada con la cabecera criptográfica x-webhook-signature firmada con HMAC. Los webhooks legítimos quedan exentos de los límites generales.

3. Ataque de Invalidación de Caché mediante Parámetros Aleatorios

  • Incidente: Scrapers automatizados añadieron parámetros ficticios (/catalogo?_rand=893412), provocando que CloudFront considerara cada petición como única y saturando la base de datos de origen.
  • Causa Raíz: La política de caché de CloudFront reenviaba todos los parámetros al origen.
  • Solución: Configuración de CloudFront con lista blanca de parámetros: únicamente los parámetros esenciales (page, sort, category) se incluyen en la clave de caché; los parámetros desconocidos se eliminan en el Edge antes de evaluar la memoria.

Lista de Verificación para DevSecOps

1
Termine el tráfico en el Edge CDN: Oculte la IP del servidor de origen tras CloudFront o Cloudflare para evitar ataques directos.
2
Active las reglas gestionadas de WAF: AWSManagedRulesCommonRuleSet y AWSManagedRulesAmazonIpReputationList filtran la mayoría de escáneres maliciosos de forma transparente.
3
Combine límites macro y micro: Establezca cuotas por IP en WAF (400 pet/5min) y límites con ventana deslizante en Redis en el Edge Middleware (60 pet/1min).
4
Proteja y permita los webhooks esenciales: Aplique excepciones en el WAF para pasarelas de pago validadas mediante firma HMAC.
5
Verifique los bots de búsqueda con rDNS: Proteja el tráfico SEO mediante resolución cruzada de nombres, bloqueando bots fraudulentos en el perímetro.

¿Necesita una Auditoría de Seguridad Cloud?

¿Su aplicación web sufre ataques L7, scraping no autorizado o costes desorbitados en la nube? Artur Yusupov diseña y despliega arquitecturas de perímetro con AWS WAFv2, CloudFront y Next.js Edge Middleware.

  • Consulte Casos Reales: Examine la plataforma AWS Security Services, el portal Octobit y los proyectos de IT-Magic.
  • Consulte al Asistente IA: Pregunte sobre configuración de WAF, algoritmos en Redis o protección contra bots.
  • Solicite una Revisión Técnica: Contacte directamente por Telegram @yusupovartur o correo electrónico para asegurar su infraestructura de producción.
Implementación real en producción

Dónde funciona esta arquitectura en proyectos reales

Estas soluciones no son teoría abstracta: están desplegadas y verificadas en los siguientes productos reales:

Auditoría de Arquitectura

¿Planeas una migración técnica o nuevo proyecto?

Consulta los requerimientos de tu proyecto con el asistente de IA o solicita una evaluación técnica directa.

Contactar directamente