Introducción

Los ataques DDoS (Distributed Denial of Service) pueden tumbar tu aplicación en segundos. Yo ya lo sufrí: un ataque coordinado consumió memoria, bloqueó el proxy y dejó la infraestructura indisponible. La diferencia entre perder el acceso SSH o recuperarte en minutos está en 6 medidas específicas de prevención que muestro en este artículo.

Este tutorial cubre las técnicas que he comprobado en producción: desde configurar Cloudflare correctamente hasta ajustar el kernel Linux para resistir millones de peticiones. Aprenderás a implementar cada una de ellas con ejemplos prácticos, sin teoría vaga.

Comparativa: servidor bajo DDoS sin protección frente a infraestructura protegida con las 6 medidas

⚠️ Atención: Este artículo se basa en un incidente real de DDoS. Las medidas aquí descritas son preventivas. Si estás bajo un ataque activo, usa este checklist en paralelo con el soporte de tu proveedor CDN (Cloudflare, Akamai, etc.).

Requisitos previos

Para implementar las medidas de este artículo, necesitas:

  • Acceso root o sudo en la VPS/servidor
  • Docker y Docker Compose instalados
  • Conocimientos básicos de Linux (edición de archivos, comandos de kernel)
  • Una cuenta de Cloudflare configurada como reverse proxy/CDN
  • Un proxy inverso en producción (Traefik, Nginx, HAProxy)
  • Herramientas de monitorización (Prometheus, Grafana o similar)

Si todavía no tienes un proxy inverso en producción, empieza con Traefik em Docker (portugués) o Nginx.

1. Desactivar el Auto-Update del Proxy en Producción

Las versiones nuevas de proxy (Traefik, Nginx) pueden contener bugs que solo se manifiestan bajo carga alta. Lo descubrí por las malas: una actualización automática de Traefik a una versión menor introdujo un memory leak que triplicó el consumo de RAM durante un ataque.

El problema: si el proxy cae bajo DDoS, el atacante ya ha ganado.

Implementación en Docker Compose

Congela la versión de tu proxy y revisa las actualizaciones manualmente antes de aplicarlas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
version: '3.9'

services:
  traefik:
    image: traefik:v3.0.0  # ❌ NO uses 'latest' ni 'v3'
    # Usa una versión específica (major.minor.patch)
    restart: unless-stopped
    environment:
      - TRAEFIK_LOG_LEVEL=WARN
      - TRAEFIK_ACCESSLOG=true
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik-config.yaml:/etc/traefik/traefik.yaml:ro
    networks:
      - frontend

  app:
    image: seu-app:1.2.3  # Fija también tu aplicación
    restart: unless-stopped

Proceso de Actualización Seguro

  1. Revisa el changelog antes de actualizar
  2. Prueba en staging con tráfico real
  3. Aplica en horario de poco tráfico
  4. Ten el rollback listo: docker-compose up con la imagen anterior
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Prueba la nueva versión sin sustituir producción
docker pull traefik:v3.1.0
docker run --rm traefik:v3.1.0 version

# Si pasó las pruebas, actualiza el archivo compose
# sed -i 's/traefik:v3.0.0/traefik:v3.1.0/g' docker-compose.yml

# Deploy controlado
docker-compose down
docker-compose up -d
docker-compose logs -f traefik  # Observa durante 5 minutos

ℹ️ Información: Traefik v3.0.0 a v3.2.x recibió parches de seguridad. Si estás en v2.10.x, actualiza solo si lo probaste en staging. Las versiones antiguas tienen CVE, pero las actualizaciones apresuradas bajo ataque provocan fallos.

2. Activar “Under Attack Mode” en Cloudflare

Cloudflare ofrece un modo específico para DDoS: Under Attack Mode. Aumenta el nivel de desafío (CAPTCHAs, validación del navegador) para bloquear bots mientras deja pasar a los usuarios legítimos.

Configuración Manual en el Panel de Cloudflare

Sigue este paso a paso en el panel de Cloudflare:

  1. Inicia sesión en el panel de Cloudflare
  2. Selecciona el sitio que quieres configurar
  3. Haz clic en Security en el menú lateral
  4. Haz clic en DDoS Protection
  5. Localiza la sección Managed DDoS Protection
  6. Haz clic en Configure junto a Under Attack Mode

La transición es inmediata. Los usuarios legítimos reciben un desafío de 5-10 segundos; los bots automatizados tienden a ser bloqueados.

Si “Under Attack” no aparece en tu panel

En algunos planes/cuentas, el interruptor puede no estar visible en el lugar esperado. En ese caso, aplica un desafío global temporal:

  1. Accede a Security → WAF → Custom Rules
  2. Crea una regla con la expresión true
  3. Define la acción como Managed Challenge (o JS Challenge, si lo prefieres)
  4. Coloca la regla en primer lugar y publícala

No es idéntico a “Under Attack”, pero ofrece una mitigación rápida durante el incidente, con un efecto similar para bloquear tráfico automatizado masivo.

Automatización: Activar vía API

Si quieres activar el modo automáticamente al detectar anomalías, usa la API de Cloudflare:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#!/bin/bash
# Script: activar-under-attack.sh

ZONE_ID="seu-zone-id"  # Encuéntralo en Domain → Overview → Zone ID
API_KEY="sua-api-key"  # Créala en My Profile → API Tokens
EMAIL="[email protected]"

# Activar Under Attack Mode
curl -X PATCH "https://api.cloudflare.com/client/v4/zones/$ZONE_ID/settings/security_level" \
  -H "X-Auth-Email: $EMAIL" \
  -H "X-Auth-Key: $API_KEY" \
  -H "Content-Type: application/json" \
  --data '{"value":"under_attack"}'

echo "Under Attack Mode ativado"

Integración con la Monitorización

Disparo automático cuando la tasa de peticiones supere 10.000/min:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Pseudocódigo para una alerta de Prometheus
groups:
  - name: DDoS Detection
    rules:
      - alert: UnderDDoSAttack
        expr: rate(http_requests_total[1m]) > 10000
        for: 1m
        annotations:
          summary: "Ativando Under Attack Mode"
        actions:
          - webhook: "http://localhost:5000/enable-under-attack"

ℹ️ Información: “Under Attack Mode” bloquea ~80% de los bots automáticos, reduciendo los falsos positivos de seguridad. El coste es latencia adicional para los usuarios legítimos (5-10s), aceptable en situación de crisis.

3. Cambiar la Dirección IP Real del Servidor

Si el atacante descubrió la IP real de tu VPS (a través de registros DNS históricos, whois o ingeniería social), puede saltarse Cloudflare y atacar directamente.

Escenario: el atacante hace un WHOIS del dominio, encuentra una IP antigua y envía peticiones directamente a ella, ignorando Cloudflare.

Pasos para Cambiar la IP

  1. Reserva una nueva IP con tu proveedor de VPS

    • En Hetzner, DigitalOcean o Hostinger es gratis y tarda 5 minutos
    • Puedes tener varias IPs por VPS
  2. Configura la nueva IP en el servidor

1
2
3
4
5
6
7
8
# Listar las IPs actuales
ip addr show

# Añadir una nueva IP (ejemplo en Ubuntu/Debian)
sudo ip addr add 203.0.113.50/24 dev eth0

# Para que persista tras reiniciar, edita /etc/netplan/ o /etc/network/interfaces
sudo nano /etc/netplan/01-netcfg.yaml

Ejemplo de /etc/netplan/01-netcfg.yaml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
network:
  version: 2
  ethernets:
    eth0:
      addresses:
        - 198.51.100.10/24
        - 203.0.113.50/24  # Nueva IP
      gateway4: 198.51.100.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]
  1. Actualiza el DNS para apuntar a la nueva IP solo en tu infraestructura interna

    • Cloudflare sigue apuntando a la IP anterior (o a una que controlas)
    • El DNS interno apunta a la nueva IP
    • Cambia /etc/hosts de los servidores internos si es necesario
  2. Mantén la IP antigua “atrapada” en Cloudflare, apuntando a un bloqueo genérico

1
2
3
# No Cloudflare DNS:
example.com  → CNAME → proxy.example.com (Cloudflare)
old-ip-server → (não existe, ou aponta para black hole)

Validar el Cambio de IP

1
2
3
4
5
6
# Confirma que la nueva IP está activa
curl -I http://203.0.113.50

# Prueba desde fuera con traceroute
traceroute example.com  # Debe pasar por Cloudflare
traceroute 203.0.113.50  # Tu servidor está aislado

⚠️ Atención: Cambiar la IP es disruptivo. Ten un plan de rollback. Si usas HTTPS pinning o certificados específicos por IP, actualízalos también.

4. Configurar Límites de File Descriptors en Docker y Podman

Cada conexión TCP abierta consume un file descriptor (FD). Bajo DDoS, miles de conexiones quedan pendientes, agotando la cuota del sistema y bloqueando la aplicación.

Síntoma: “Too many open files” o timeouts de SSH durante el ataque.

Entender los File Descriptors

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# Ver el límite actual
ulimit -n
# Salida típica: 1024

# Ver el límite hard (máximo)
ulimit -Hn
# Salida típica: 65536

# Ver cuántos FDs están en uso
lsof | wc -l

Configuración en Docker Compose

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
version: '3.9'

services:
  traefik:
    image: traefik:v3.0.0
    restart: unless-stopped
    ulimits:
      nofile:
        soft: 65000  # Para aplicaciones normales
        hard: 65536  # Máximo del sistema
    # Alternativa (notación corta, no recomendada)
    # ulimits: 65000:65536
    networks:
      - frontend

  app:
    image: seu-app:1.2.3
    ulimits:
      nofile:
        soft: 32000  # Menos agresivo para la app
        hard: 65536

Si usas Nginx en lugar de Traefik, la configuración queda así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
version: '3.9'

services:
  nginx:
    image: nginx:1.27-alpine
    restart: unless-stopped
    ulimits:
      nofile:
        soft: 65000
        hard: 65536
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro

  app:
    image: seu-app:1.2.3
    ulimits:
      nofile:
        soft: 32000
        hard: 65536

Configuración en Podman

En Podman, puedes aplicar el mismo límite con --ulimit:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Ejemplo con Nginx
podman run -d --name nginx \
  --ulimit nofile=65000:65536 \
  -p 80:80 -p 443:443 \
  nginx:1.27-alpine

# Ejemplo con Traefik
podman run -d --name traefik \
  --ulimit nofile=65000:65536 \
  -p 80:80 -p 443:443 \
  traefik:v3.0.0

Si usas podman-compose, mantén la clave ulimits en el YAML, igual que en Docker Compose.

Aumentar Globalmente en el Host

Si varios contenedores necesitan límites altos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# Editar /etc/security/limits.conf
sudo nano /etc/security/limits.conf

# Añadir:
# *               soft    nofile          65000
# *               hard    nofile          65536
# root            soft    nofile          65536
# root            hard    nofile          65536

# Recargar
sudo sysctl -p

# Verificar
ulimit -n

Prueba de Carga

Simula conexiones pendientes para validar el límite:

1
2
3
4
5
# Usar ab (Apache Bench) o hey
ab -n 100000 -c 10000 http://127.0.0.1:80/

# Monitorizar FDs en tiempo real (ajusta el proceso: traefik o nginx)
watch -n 1 'lsof | grep -E "traefik|nginx" | wc -l'

ℹ️ Información: Un límite de 65.000 file descriptors permite ~60.000 conexiones simultáneas (contando los FDs de logs, sockets internos, etc.). En la práctica, ajústalo al 80-90% del límite hard.

5. Habilitar TCP Cookies en el Kernel

TCP SYN Flood es un ataque sencillo: el atacante envía paquetes SYN (inicio de conexión TCP) sin responder al SYN-ACK, haciendo que el servidor reserve memoria para conexiones incompletas (SYN backlog).

TCP Syncookies lo resuelve sin aceptar la conexión: el servidor incorpora información en el SYN-ACK de forma que la memoria solo se reserva DESPUÉS de validar al cliente.

Habilitar en Linux

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# Verificar el estado actual
sysctl net.ipv4.tcp_syncookies
# Salida: net.ipv4.tcp_syncookies = 0  (desactivado) o = 1 (activado)

# Activar de inmediato
sudo sysctl -w net.ipv4.tcp_syncookies=1

# Persistir tras reiniciar
echo "net.ipv4.tcp_syncookies = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Configuraciones Complementarias (kernel hardening)

Ya que estás en ello, activa otras protecciones:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# Descartar paquetes SYN con IP inválida
echo "net.ipv4.tcp_syncookies = 1" | sudo tee -a /etc/sysctl.conf

# Limitar el backlog de SYN (conexiones incompletas)
echo "net.ipv4.tcp_max_syn_backlog = 4096" | sudo tee -a /etc/sysctl.conf

# Aumentar el tamaño del backlog de listen (aplicaciones que aceptan muchas conexiones)
echo "net.core.somaxconn = 4096" | sudo tee -a /etc/sysctl.conf

# Protección contra IP spoofing (reverse path filter)
echo "net.ipv4.conf.all.rp_filter = 1" | sudo tee -a /etc/sysctl.conf

# Recargar
sudo sysctl -p

Validar la Configuración

1
2
3
4
5
# Comprobar si TCP Syncookies está funcionando
sudo cat /proc/net/netstat | grep -i sync

# Salida esperada (con syncookies activo):
# TcpExt: SyncookiesSent SyncookiesRecv SyncookiesFailed ...

📝 Ejemplo: En un DDoS típico con 500.000 SYN/segundo, sin syncookies el servidor reserva 5 GB de memoria en segundos. Con syncookies activado, el consumo se mantiene < 100 MB.

6. Implementar una Monitorización Adecuada con Alertas

Monitorizar es prevenir. Si detectas anomalías (picos de peticiones, consumo anormal de memoria) en 1 minuto, puedes activar las defensas antes de perder el SSH.

Métricas Críticas para DDoS

Monitoriza estas 5 métricas con alertas en tiempo real:

MétricaAlertaAcción
Tasa de peticiones/min> 10.000Activar Under Attack Mode
Conexiones TCP pendientes> 50.000Aumentar tcp_max_syn_backlog
Consumo de memoria (proxy)> 80%Reiniciar contenedor, activar Under Attack
Procesos acumulados (zombie)> 100Investigar leak, reiniciar app
Latencia P99> 5sIndicio de cuello de botella o ataque lento

Configuración con Prometheus + Alertmanager

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'traefik'
    static_configs:
      - targets: ['localhost:8080']  # Métricas de Traefik

  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']  # Node Exporter (métricas del host)

# Archivo: alert_rules.yml
groups:
  - name: ddos_alerts
    interval: 30s
    rules:
      - alert: HighRequestRate
        expr: rate(http_requests_total[1m]) > 10000
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Taxa alta de requisições: {{ $value }} req/s"
          description: "Possível DDoS. Ativar Under Attack Mode no Cloudflare."

      - alert: HighTCPConnections
        expr: node_sockstat_TCP_inuse > 50000
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "{{ $value }} conexões TCP pendentes"

      - alert: HighMemoryUsage
        expr: container_memory_usage_bytes{name="traefik"} / 1073741824 > 0.8
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Memória do Traefik em {{ $value }}%"

Script de Monitorización Simple (sin Prometheus)

Si no tienes un stack de monitorización instalado, usa este script bash:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/bin/bash
# File: ddos-monitor.sh

THRESHOLD_REQUESTS=10000
THRESHOLD_MEMORY=80
THRESHOLD_TCP=50000

while true; do
  # Tasa de peticiones (logs de Traefik)
  REQ_RATE=$(tail -10000 /var/log/traefik/access.log | wc -l)
  
  # Consumo de memoria de Traefik
  MEM_USAGE=$(docker stats traefik --no-stream --format "{{.MemPerc}}" | sed 's/%//')
  
  # Conexiones TCP
  TCP_CONNS=$(netstat -an | grep ESTABLISHED | wc -l)

  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Req/min: $REQ_RATE | Mem: ${MEM_USAGE}% | TCP: $TCP_CONNS"

  if (( $(echo "$REQ_RATE > $THRESHOLD_REQUESTS" | bc -l) )); then
    echo "⚠️ ALERTA: Taxa de requisições alta!"
    # Llamar a un webhook o enviar una notificación
    curl -X POST http://alertmanager:9093/api/v1/alerts \
      -H "Content-Type: application/json" \
      --data '{"alerts":[{"labels":{"alertname":"HighRequestRate"}}]}'
  fi

  sleep 60
done

Ejecútalo en segundo plano:

1
nohup ./ddos-monitor.sh > ddos-monitor.log 2>&1 &

📝 Ejemplo: Un cliente mío detectó un DDoS en 2 minutos gracias a las alertas. Activó Under Attack Mode y aumentó los file descriptors. El sitio siguió online con una latencia aceptable. Sin alertas, la caída habría durado horas.

7. Ejemplo Práctico: Configuración Completa para Producción

Aquí tienes una configuración completa de Docker Compose con todas las medidas aplicadas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
version: '3.9'

services:
  traefik:
    image: traefik:v3.0.0  # Versión fija, sin auto-update
    container_name: traefik
    restart: unless-stopped
    
    # File descriptors altos
    ulimits:
      nofile:
        soft: 65000
        hard: 65536
    
    environment:
      # Logs para monitorización
      - TRAEFIK_LOG_LEVEL=WARN
      - TRAEFIK_ACCESSLOG=true
      - TRAEFIK_ACCESSLOG_FILEPATH=/var/log/traefik/access.log
      - TRAEFIK_ACCESSLOG_FORMAT=json
      
      # Métricas
      - TRAEFIK_METRICS_PROMETHEUS=true
      - TRAEFIK_METRICS_PROMETHEUS_ADDENTRYPOINTSLABELS=true
    
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"  # Dashboard (protégelo con auth)
    
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik-config.yaml:/etc/traefik/traefik.yaml:ro
      - ./certs:/certs:ro
      - /var/log/traefik:/var/log/traefik
    
    networks:
      - frontend

  app:
    image: seu-app:1.2.3  # Versión fija
    container_name: app
    restart: unless-stopped
    
    ulimits:
      nofile:
        soft: 32000
        hard: 65536
    
    environment:
      - ENVIRONMENT=production
    
    labels:
      # Auto-discovery de Traefik
      - "traefik.enable=true"
      - "traefik.http.routers.app.rule=Host(`example.com`)"
      - "traefik.http.services.app.loadbalancer.server.port=3000"
    
    networks:
      - frontend

networks:
  frontend:
    driver: bridge

Archivo traefik-config.yaml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
global:
  checkNewVersion: false  # No comprobar actualizaciones
  sendAnonymousUsage: false

entryPoints:
  web:
    address: ":80"
    http:
      maxRequestBodyBytes: 2500000  # Limitar payload (anti-upload bomb)
  websecure:
    address: ":443"
    http:
      maxRequestBodyBytes: 2500000

api:
  insecure: false  # Protege el dashboard
  dashboard: true

log:
  level: WARN

accessLog: {}

metrics:
  prometheus:
    entryPoint: metrics
    service: prometheus

providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
    watch: true

Si usas Nginx en lugar de Traefik, este es un ejemplo equivalente para producción:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
version: '3.9'

services:
  nginx:
    image: nginx:1.27-alpine  # Versión fija, sin auto-update
    container_name: nginx
    restart: unless-stopped

    ulimits:
      nofile:
        soft: 65000
        hard: 65536

    ports:
      - "80:80"
      - "443:443"

    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/conf.d:/etc/nginx/conf.d:ro
      - ./certs:/etc/nginx/certs:ro
      - /var/log/nginx:/var/log/nginx

    networks:
      - frontend

  app:
    image: seu-app:1.2.3
    container_name: app
    restart: unless-stopped

    ulimits:
      nofile:
        soft: 32000
        hard: 65536

    environment:
      - ENVIRONMENT=production

    expose:
      - "3000"

    networks:
      - frontend

networks:
  frontend:
    driver: bridge

Archivo nginx/nginx.conf (base para un alto volumen de conexiones):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
user nginx;
worker_processes auto;
pid /var/run/nginx.pid;

events {
  worker_connections 8192;
  use epoll;
  multi_accept on;
}

http {
  sendfile on;
  tcp_nopush on;
  tcp_nodelay on;
  keepalive_timeout 30;
  keepalive_requests 1000;
  types_hash_max_size 2048;
  server_tokens off;

  # Límites para reducir el impacto de un flood básico
  client_max_body_size 2m;
  client_body_timeout 10s;
  client_header_timeout 10s;

  log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                  '$status $body_bytes_sent "$http_referer" '
                  '"$http_user_agent" "$http_x_forwarded_for"';

  access_log /var/log/nginx/access.log main;
  error_log /var/log/nginx/error.log warn;

  include /etc/nginx/mime.types;
  default_type application/octet-stream;

  upstream app_backend {
    server app:3000;
    keepalive 64;
  }

  server {
    listen 80;
    server_name _;

    location / {
      proxy_http_version 1.1;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;
      proxy_set_header Connection "";
      proxy_pass http://app_backend;
    }
  }
}

Consejos y Buenas Prácticas

  • 1. Rate Limiting en Cloudflare: Configura un límite de 100 peticiones/IP/minuto. Esto bloquea automáticamente a los bots agresivos antes de que lleguen a tu servidor.

  • 2. Mantener Logs de Tráfico: Archiva los accesos en JSON para el análisis posterior al ataque. Identifica patrones (IP de origen, endpoint objetivo, user-agent) para refinar reglas futuras.

  • 3. Prueba tus Defensas con Regularidad: Una vez al mes, simula un DDoS ligero (con una herramienta como locust o ab) y valida que las alertas funcionen. Descubrir brechas en producción sale caro.

  • 4. Redundancia Geográfica: Si es posible, distribuye tu app en varios datacenters. Un único DDoS no lo tumba todo. Cloudflare ofrece load balancing geográfico.

  • 5. Comunicación con el Proveedor: Si contratas soporte premium (Cloudflare Pro/Business), avisa de tu plan de mitigación. Pueden activar protecciones extra más rápido.

Resumen Objetivo

  • TCP Syncookies — habilitarlo en el kernel con sysctl net.ipv4.tcp_syncookies=1 para bloquear SYN Flood sin reservar memoria de forma indiscriminada.

  • File Descriptors en Docker — definir ulimits.nofile.soft: 65000 en docker-compose.yml para aceptar hasta 60.000 conexiones simultáneas durante un ataque.

  • Under Attack Mode (Cloudflare) — activarlo manualmente en Security → Overview o vía API para forzar CAPTCHA a los bots, bloqueando ~80% del tráfico malicioso.

  • Versión Fija del Proxy — usar image: traefik:v3.0.0 en lugar de latest para evitar que bugs introducidos por actualizaciones automáticas tumben la aplicación bajo carga.

  • Nueva Dirección IP — añadir una IP secundaria a la VPS y usarla exclusivamente de forma interna, dejando la antigua “atrapada” en Cloudflare para aislarla del atacante.

  • Monitorización con Alertas — rastrear la tasa de peticiones, conexiones TCP, memoria y procesos con Prometheus o un script bash sencillo; el umbral crítico es > 10.000 req/min o > 50.000 conexiones TCP.

Lee También

Referencias