---
title: "Laboratorio: limitar la tasa de un servidor web bajo una inundación simulada"
domain: cybersecurity
level: intermediate
duration: "50 min"
cost: "gratuito"
environment: "contenedores (Podman sin privilegios en una máquina Linux local)"
lang: es
source_hash: 8ef7469ed99c
---

# Laboratorio: limitar la tasa de un servidor web bajo una inundación simulada

## Objetivo
Arrancas un pequeño servidor web, lo inundas desde dos contenedores «bot» en una red aislada y ves cómo un usuario normal se queda atascado. Localizas a los atacantes en el registro de acceso. Después activas la limitación de tasa, repites la inundación y ves cómo las peticiones sobrantes se rechazan con el estado HTTP 429 mientras el usuario normal se sigue atendiendo a toda velocidad.

## Objetivos
- Medir la latencia normal de un servidor web (línea base) y su latencia bajo una inundación.
- Detectar la inundación contando las peticiones por dirección de cliente y por código de estado en el registro de acceso.
- Activar la limitación de tasa (`limit_req`) y la limitación de conexiones (`limit_conn`) de nginx y recargarlo sin tiempo de inactividad.
- Demostrar que el límite rechaza la inundación (estado 429) pero sigue atendiendo a un cliente normal (estado 200).
- Leer el ajuste de SYN cookies del equipo anfitrión y de un contenedor, y explicar qué hace.

## Requisitos previos
- Una máquina Linux con **Podman 4 o posterior** ejecutándose **sin privilegios** (*rootless*: como usuario normal; nunca necesitas `sudo`) y con el backend de red netavark. Probado con Podman 5.8.7 en Fedora con el kernel 7.2. Compruébalo con `podman info --format '{{.Host.NetworkBackend}}'`: debe imprimir `netavark`.
- Acceso a Internet una vez, para descargar las imágenes de nginx y de Alpine Linux (unas pocas decenas de MB en total) y dos paquetes pequeños (unos 8 MB). Después, nada del laboratorio necesita Internet.
- Unos 400 MB de espacio libre en disco y al menos 2 núcleos de CPU.
- La [lección](lesson.es.md) de este módulo. Las técnicas con Podman son las del [laboratorio de seguridad de red](../06-network-security/lab.es.md): redes `--internal`, imágenes fijadas, contenedores sin privilegios.

> [!WARNING]
> **Autorización y ética.** Inundar un sistema que no es tuyo, o que no tienes autorización expresa por escrito para probar, es ilegal en la mayoría de los países y perjudica a otras personas aunque lo llames prueba. En este laboratorio el «ataque» se produce solo entre cuatro contenedores que creas tú mismo, en una red creada con `--internal` (nada sale de tu máquina). La carga es modesta y está acotada por tiempo (15 segundos) y por número de workers. No apuntes nunca las herramientas de este laboratorio a nada más, ni siquiera a tu propio servidor en un proveedor de alojamiento, sin leer antes las normas del proveedor sobre pruebas de carga.

## Arquitectura
![Una red interna de Podman, lab-ddos-net, 10.60.0.0/24. El contenedor del servidor web lab-ddos-web está en 10.60.0.10, tcp 80, ejecuta nginx 1.31.6-alpine con un límite de CPU de 0,5 y un límite de memoria de 128 MB, y sirve /report.html, una página que nginx comprime con gzip de nivel 9 en cada petición. Su limits.conf empieza vacío y después se rellena con limit_req de 5 peticiones por segundo con una ráfaga de 10, limit_conn de 10 por dirección y estado 429 cuando se supera. Dos contenedores bot, lab-ddos-bot1 en 10.60.0.20 y lab-ddos-bot2 en 10.60.0.21, ejecutan cada uno hey durante 15 segundos con 25 workers concurrentes y envían una inundación de peticiones al servidor web por líneas rojas gruesas. Un contenedor de usuario normal, lab-ddos-user en 10.60.0.30, envía una petición normal con curl por una línea verde fina. A la izquierda, la carpeta ~/ddos-lab de tu equipo contiene nginx.conf, conf/limits.conf y www/report.html, montados en modo de solo lectura en el contenedor web. La red es interna: nada sale de tu máquina.](../../../assets/diagrams/ddos-lab-architecture.es.svg)

*Figura 1. Dos bots y un usuario normal comparten un pequeño servidor web. Al principio nada limita a los bots; más adelante lo hace `limits.conf`.*

| Contenedor | Dirección | Función |
|---|---|---|
| `lab-ddos-web` | `10.60.0.10`, TCP 80 | nginx, limitado a media CPU y 128 MB, que sirve `/report.html` |
| `lab-ddos-bot1` | `10.60.0.20` | Un «bot»: inunda el servidor web con `hey` |
| `lab-ddos-bot2` | `10.60.0.21` | Un segundo bot (para que el ataque venga de más de una dirección) |
| `lab-ddos-user` | `10.60.0.30` | Un usuario normal: unas pocas peticiones con `curl` |

**Por qué esta página es «cara».** nginx sirve un archivo estático pequeño casi gratis, y ningún laboratorio diminuto podría inundarlo. Así que `/report.html` es un archivo de texto grande (unos 900 KB) que nginx debe **comprimir con gzip en cada petición**, lo que consume tiempo de procesador real. El contenedor web solo puede usar media CPU y nginx ejecuta un proceso worker. Eso da al servidor una capacidad de unas 20 peticiones por segundo, fácil de superar en un laboratorio, y representa cualquier página costosa de generar (una búsqueda, un informe, una consulta a una base de datos).

> [!NOTE]
> Una sola dirección que inunda un servidor es, en sentido estricto, un ataque DoS. El laboratorio usa dos contenedores bot para mostrar que los límites se aplican por dirección y para que pienses qué ocurre con miles. Las conclusiones son las mismas.

## Pasos

### Paso 1 — Comprueba tus herramientas y crea una carpeta de trabajo (3 min)
Asegúrate de que Podman funciona sin privilegios y usa netavark, y de que no queda nada de un intento anterior.

```bash
podman --version
podman info --format '{{.Host.NetworkBackend}} rootless={{.Host.Security.Rootless}}'
podman ps -a --filter name=lab-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
mkdir -p ~/ddos-lab && cd ~/ddos-lab
```

Salida esperada (tu versión puede diferir):
```text
podman version 5.8.7
netavark rootless=true
```

Los dos comandos `ls` no imprimen nada. Si listan nombres `lab-ddos-`, ejecuta antes la [Limpieza](#limpieza). Todos los comandos siguientes suponen que estás en `~/ddos-lab`. Si abres un terminal nuevo, ejecuta `cd ~/ddos-lab` otra vez.

### Paso 2 — Construye la imagen de herramientas (4 min)
Los bots y el usuario necesitan dos herramientas: `curl` (una petición, con medición de tiempos) y `hey` (un generador de carga HTTP: muchas peticiones a la vez, con un resumen). Alpine Linux empaqueta ambas. La etiqueta está fijada a Alpine 3.20.10.

```bash
cat > Containerfile <<'EOT'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache hey curl
EOT
podman build -t lab-ddos-tools:1 . 2>&1 | tail -4
podman run --rm lab-ddos-tools:1 sh -c 'cat /etc/alpine-release; apk list -I 2>/dev/null | grep -E "^(hey|curl)-"'
```

Salida esperada (el ID de la imagen y las versiones de los paquetes pueden diferir ligeramente):
```text
COMMIT lab-ddos-tools:1
--> 5b5d9cc480f1
Successfully tagged localhost/lab-ddos-tools:1
5b5d9cc480f1dd3f292ce2e615536cf0b39fcbd2c72460b0be3b8fc2e8c51b88
3.20.10
curl-8.14.1-r2 x86_64 {curl} (curl) [installed]
hey-0.1.4-r26 x86_64 {hey} (Apache-2.0) [installed]
```

La construcción usa tu red normal una vez, para descargar los paquetes. Los contenedores del laboratorio no tendrán ninguna red exterior.

### Paso 3 — Escribe los archivos del servidor web (5 min)
nginx necesita tres archivos, que se guardan en tu equipo y se montan en el contenedor. Esto es lo que hace cada uno:

- `www/report.html` es la página costosa: 150 000 líneas de números.
- `nginx.conf` es toda la configuración del servidor. Activa gzip de nivel 9 (la parte costosa), envía el registro de acceso a la salida estándar para que puedas leerlo con `podman logs`, y **define** dos contadores por dirección de cliente (`limit_req_zone`, `limit_conn_zone`). Definirlos todavía no limita nada.
- `conf/limits.conf` lo incluye el bloque server. Por ahora está vacío. En el Paso 8 pondrás en él los límites.

```bash
mkdir -p conf www
seq 1 150000 > www/report.html
echo '# no limits yet' > conf/limits.conf
cat > nginx.conf <<'EOT'
worker_processes 1;
error_log /dev/stderr notice;
pid /tmp/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    access_log /dev/stdout;

    # An "expensive" page: nginx compresses it on every request, which costs CPU.
    gzip on;
    gzip_comp_level 9;

    # Two counters, one per client address. They do nothing until limits.conf uses them.
    limit_req_zone $binary_remote_addr zone=perip:1m rate=5r/s;
    limit_conn_zone $binary_remote_addr zone=connperip:1m;

    server {
        listen 80;
        root /usr/share/nginx/html;

        location /report.html {
            alias /srv/www/report.html;
        }

        include /etc/nginx/lab/limits.conf;
    }
}
EOT
wc -lc www/report.html
```

Salida esperada:
```text
  150000  938895 www/report.html
```

El archivo tiene 150 000 líneas y 938 895 bytes (unos 0,9 MB). `rate=5r/s` es el límite que activarás más adelante: cinco peticiones por segundo por dirección de cliente.

### Paso 4 — Crea la red aislada y los cuatro contenedores (5 min)
Una red de Podman es todo el laboratorio. `--internal` significa que Podman no añade ninguna ruta al mundo exterior ni NAT hacia tu equipo, así que nada puede salir de tu máquina. `10.60.0.0/24` es un rango privado ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).

El contenedor web recibe `--cpus 0.5` y `--memory 128m`: puede usar como máximo media CPU, así que es fácil de sobrecargar y nunca puede dañar tu máquina. `:ro,Z` monta los archivos en solo lectura (la etiqueta `Z` los hace legibles en sistemas con SELinux, como Fedora, y no hace nada en los demás). La etiqueta de la imagen está fijada a una versión exacta. Los otros tres contenedores solo ejecutan `sleep infinity`; ejecutas comandos en ellos con `podman exec`.

```bash
podman network create --internal --subnet 10.60.0.0/24 lab-ddos-net
podman network inspect lab-ddos-net --format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
podman run -d --name lab-ddos-web --network lab-ddos-net:ip=10.60.0.10 --cpus 0.5 --memory 128m \
  -v ~/ddos-lab/nginx.conf:/etc/nginx/nginx.conf:ro,Z \
  -v ~/ddos-lab/conf:/etc/nginx/lab:ro,Z \
  -v ~/ddos-lab/www:/srv/www:ro,Z \
  docker.io/library/nginx:1.31.6-alpine
podman run -d --name lab-ddos-bot1 --network lab-ddos-net:ip=10.60.0.20 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-bot2 --network lab-ddos-net:ip=10.60.0.21 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-user --network lab-ddos-net:ip=10.60.0.30 lab-ddos-tools:1 sleep infinity
podman ps --filter name=lab-ddos --format 'table {{.Names}}\t{{.Status}}'
podman exec lab-ddos-web nginx -v
```

Salida esperada (los cuatro ID largos de contenedor varían; la primera ejecución descarga la imagen de nginx):
```text
lab-ddos-net
lab-ddos-net subnet=10.60.0.0/24 internal=true
e296e3434133eb65348ff7d7faddaf2d1ef80540dde41d434314abaab37b7fb4
8dbf7b4179c98cbd8c67e41f33c93215f78b912f4e397d48016d7a14a584be7d
1c262b3347113f409267c40260d01089054015daad18efbe960669ee88773df1
24f0c870b1f753edee63a94317a8c675d407a974608211a5982aca0caed2af03
NAMES          STATUS
lab-ddos-web   Up Less than a second
lab-ddos-bot1  Up Less than a second
lab-ddos-bot2  Up Less than a second
lab-ddos-user  Up Less than a second
nginx version: nginx/1.31.6
```

Ahora comprueba el aislamiento. El contenedor de usuario tiene una sola ruta, solo hacia la red del laboratorio, y una conexión a una dirección exterior (`192.0.2.1` es una dirección de documentación, [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)) falla al instante porque no hay ruta:

```bash
podman exec lab-ddos-user ip route
podman exec lab-ddos-user curl -sS -m 3 -o /dev/null http://192.0.2.1/ ; echo "curl exit code: $?"
```

Salida esperada:
```text
10.60.0.0/24 dev eth0 scope link  src 10.60.0.30 
curl: (7) Failed to connect to 192.0.2.1 port 80 after 0 ms: Could not connect to server
curl exit code: 7
```

El código de salida 7 significa «no se pudo conectar». Las herramientas de ataque no pueden llegar a nada salvo al servidor web.

### Paso 5 — Línea base: ¿a qué velocidad responde el servidor cuando nadie ataca? (5 min)
Antes de un ataque necesitas saber cómo es lo normal. Esta es tu **línea base**. Primero, una petición del usuario normal, con su medición de tiempo (`--compressed` pide gzip, como hace todo navegador, de modo que el servidor hace el trabajo costoso). Después, 30 peticiones una tras otra (`-c 1` significa de una en una), con `hey`.

```bash
podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
podman exec lab-ddos-user hey -n 30 -c 1 http://10.60.0.10/report.html 2>&1 | grep -E 'Total:|Average:|Slowest:|Requests/sec|^  \[[0-9]+\]'
```

Salida esperada (los tiempos varían; lo que importa es el orden de magnitud):
```text
status=200 time=0.030266s
  Total:	1.6079 secs
  Slowest:	0.1015 secs
  Average:	0.0536 secs
  Requests/sec:	18.6580
  [200]	30 responses
```

Cómo leerlo: `status=200` es «OK». Una petición tarda entre 30 y 50 milisegundos (ms), por la compresión. Las 30 obtuvieron `[200]`. El servidor atiende unas **18 peticiones por segundo** cuando un cliente pide de una en una, que es su capacidad aproximada. Anota la línea base: **unos 0,03 segundos para un usuario normal**.

### Paso 6 — Inunda el servidor y mira qué ve un usuario normal (8 min)
Ahora, el «ataque». Cada bot ejecuta `hey` durante 15 segundos (`-z 15s`) con 25 workers (`-c 25`), y cada worker intenta 20 peticiones por segundo (`-q 20`): unas 500 peticiones por segundo por bot, 1000 en total, contra un servidor que puede responder a unas 18. Los dos comandos `hey` se ejecutan en segundo plano (`&`). Tres segundos después, el usuario normal pide la misma página una vez. `wait` se bloquea hasta que los bots terminan. Tu shell puede imprimir líneas de trabajos como `[1] 12345`; son inofensivas.

```bash
for b in bot1 bot2; do
  podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood1-$b.txt 2>&1 &
done
sleep 3
podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^  \[[0-9]+\]' flood1-$b.txt; done
```

Salida esperada (tarda unos 20 segundos; **los números varían, la imagen general no**):
```text
status=200 time=14.640884s
== bot1
  Total:	17.6109 secs
  Average:	16.4463 secs
  Requests/sec:	1.4764
  [200]	26 responses
== bot2
  Total:	16.5475 secs
  Average:	1.3776 secs
  Requests/sec:	17.2232
  [200]	285 responses
```

Léelo con atención:

- El usuario normal pidió la página una vez y **esperó unos 15 segundos** (en tu ejecución: muchos segundos, no milisegundos) una respuesta que antes tardaba 0,03 segundos. No se hackeó nada y no se perdió ningún dato, y sin embargo el servicio está, en la práctica, caído. Esto es una denegación de servicio.
- Cada bot intentó miles de peticiones, pero el servidor completó solo unas 300 en total en 15 segundos, que es su capacidad. El resto quedó en cola o agotó su tiempo de espera.
- Un bot consiguió la mayoría de las respuestas (aquí `bot2`: 285 frente a 26). Cuál de ellos varía; nginx no reparte de forma equitativa. Es normal.

### Paso 7 — Detéctalo: lee el registro de acceso (5 min)
El registro de acceso es tu primera herramienta de detección. nginx escribe en su salida estándar una línea por cada petición **completada**, y `podman logs` la muestra. Este comando se queda con las líneas de peticiones reales (`GET`) en un archivo y las cuenta: la primera columna es la dirección del cliente y la novena es el estado HTTP.

```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' > access-all.txt
wc -l < access-all.txt
awk '{print $1, $9}' access-all.txt | sort | uniq -c | sort -rn
```

Salida esperada (los recuentos varían ligeramente):
```text
343
    285 10.60.0.21 200
     32 10.60.0.30 200
     26 10.60.0.20 200
```

El programa `awk` imprime la dirección y el estado de cada línea, `sort | uniq -c` cuenta los pares iguales y `sort -rn` pone el mayor arriba. Cómo leer la tabla:

- Las dos direcciones `10.60.0.20` y `10.60.0.21` son los **mayores emisores** entre los clientes que lograron pasar y, en realidad, intentaron muchas más peticiones. El usuario normal `10.60.0.30` aparece con las 32 peticiones de la línea base y la única petición que esperó.
- Fíjate en una limitación de este método: **el registro lista solo las peticiones que el servidor completó**. La sobrecarga hizo que el servidor respondiera a menos, no a más, así que el registro subestima el ataque. Una detección real necesita además contadores a nivel de red (paquetes y conexiones por segundo), carga, latencia y tasa de errores de la monitorización. En el registro, la señal es que unas pocas direcciones concentran la mayor parte del tráfico.

### Paso 8 — Activa la limitación de tasa y recarga (5 min)
Ahora, la defensa. El archivo `conf/limits.conf` recibe cuatro líneas:

- `limit_req zone=perip burst=10 nodelay;` aplica el contador `perip`: cada dirección de cliente puede hacer **5 peticiones por segundo** (definido en `nginx.conf`) y puede superarlas con una **ráfaga** de 10 peticiones extra. `nodelay` atiende la ráfaga de inmediato en lugar de ralentizarla. Las peticiones por encima de eso se rechazan.
- `limit_req_status 429;` hace que el rechazo tenga el estado HTTP `429 Too Many Requests` (por defecto es 503).
- `limit_conn connperip 10;` permite a cada dirección como máximo **10 conexiones con una petición en curso** al mismo tiempo. Ayuda cuando cada petición tarda mucho en servirse (una base de datos lenta, una subida grande). nginx empieza a contar una petición solo cuando sus cabeceras han llegado por completo.
- `limit_conn_status 429;` le da el mismo estado.

```bash
cat > conf/limits.conf <<'EOT'
# At most 5 requests per second per client address, with a burst of 10 extra requests
limit_req zone=perip burst=10 nodelay;
limit_req_status 429;

# At most 10 simultaneous connections per client address
limit_conn connperip 10;
limit_conn_status 429;
EOT
podman exec lab-ddos-web nginx -t
podman exec lab-ddos-web nginx -s reload
```

Salida esperada (la línea `notice` muestra la hora de tu recarga):
```text
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
2026/11/07 20:08:04 [notice] 28#28: signal process started
```

`nginx -t` prueba primero la configuración (hazlo siempre) y `nginx -s reload` hace que nginx arranque nuevos workers con las reglas nuevas y retire los antiguos sin cortar conexiones. Si la prueba falla, no se recarga nada y siguen activas las reglas antiguas.

### Paso 9 — Inunda de nuevo, con el límite activado (8 min)
El mismo ataque, los mismos comandos. Esta vez el usuario normal pide la página tres veces, con un segundo de diferencia, como una persona que recarga la página.

```bash
for b in bot1 bot2; do
  podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood2-$b.txt 2>&1 &
done
sleep 3
for i in 1 2 3; do
  podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
  sleep 1
done
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^  \[[0-9]+\]' flood2-$b.txt; done
```

Salida esperada (los recuentos varían unos pocos; la imagen general no):
```text
status=200 time=0.030948s
status=200 time=0.029585s
status=200 time=0.029022s
== bot1
  Total:	15.0048 secs
  Average:	0.0193 secs
  Requests/sec:	431.1286
  [200]	81 responses
  [429]	6388 responses
== bot2
  Total:	15.0118 secs
  Average:	0.0201 secs
  Requests/sec:	442.9185
  [200]	85 responses
  [429]	6564 responses
```

Compara con el Paso 6:

| | Paso 6: sin límite | Paso 9: con límite |
|---|---|---|
| Espera del usuario normal | unos 15 segundos | unos 0,03 segundos, como en la línea base |
| Respuestas que recibió cada bot | un bot unos cientos, el otro casi ninguna | unas 85 cada uno |
| Rechazos (estado 429) | ninguno | unos 6400 por bot |
| Tiempo medio por petición de un bot | segundos | unos 0,02 segundos |

Fíjate en dos cosas. Primera, el **usuario normal se atiende a velocidad normal**: el límite es por dirección y la dirección del usuario está muy por debajo de él. Segunda, cada bot recibió solo unas 85 respuestas. No es casualidad: `10 + 5 × 15 = 85`, la ráfaga más 5 peticiones por segundo durante 15 segundos. Todo lo demás se rechazó con una minúscula respuesta `429` que cuesta casi nada producir, por eso el servidor vuelve a estar libre.

### Paso 10 — Detéctalo y demuéstralo en el registro (4 min)
El mismo análisis del registro que en el Paso 7, ahora solo sobre las líneas escritas desde la instantánea del Paso 7 (`tail -n +N` imprime desde la línea N en adelante). Después mira una petición rechazada y el registro de errores del propio nginx.

```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' | tail -n +$(( $(wc -l < access-all.txt) + 1 )) > access-flood2.txt
wc -l < access-flood2.txt
awk '{print $1, $9}' access-flood2.txt | sort | uniq -c | sort -rn
grep ' 429 ' access-flood2.txt | head -1
podman logs lab-ddos-web 2>&1 | grep 'limiting requests' | head -1
podman logs lab-ddos-web 2>&1 | grep -c 'limiting requests'
```

Salida esperada (los recuentos varían):
```text
13121
   6564 10.60.0.21 429
   6388 10.60.0.20 429
     85 10.60.0.21 200
     81 10.60.0.20 200
      3 10.60.0.30 200
10.60.0.21 - - [07/Nov/2026:20:08:05 +0000] "GET /report.html HTTP/1.1" 429 169 "-" "hey/0.0.1"
2026/11/07 20:08:05 [error] 29#29: *54 limiting requests, excess: 10.815 by zone "perip", client: 10.60.0.21, server: , request: "GET /report.html HTTP/1.1", host: "10.60.0.10"
12952
```

Ahora el registro cuenta la historia con claridad: 13 121 peticiones en 15 segundos, casi todas `429` de dos direcciones, y el usuario normal con tres `200`. Esta es la señal que usaría un sistema de detección. Dos observaciones más:

- El número de líneas `limiting requests` del registro de errores (12 952) es igual al número de 429 del registro de acceso (6388 + 6564 = 12 952): cada rechazo queda registrado. En un sistema real, darías una alerta ante un número alto de 429 de las mismas direcciones y podrías pasar esas direcciones a un firewall o al proveedor.
- `limit_conn` nunca se activó. Aquí nginx sirve cada petición en una ráfaga rápida, así que una dirección nunca tiene más de una petición en curso, y las rechazadas se responden al instante. `limit_conn` compensa cuando las peticiones permanecen en curso durante mucho tiempo, y no es una defensa contra los ataques lentos que nunca terminan sus cabeceras (mira el reto).

### Paso 11 — Lee el ajuste de SYN cookies (4 min)
Los límites vistos hasta ahora son para inundaciones HTTP (capa 7). Contra una inundación SYN (capa 4, mira la lección) el kernel de Linux tiene su propia defensa, las SYN cookies. Solo **lees** el ajuste, tanto en tu máquina como dentro del contenedor web, y los contadores del kernel. No necesitas cambiar nada, y una inundación SYN requiere paquetes en bruto, que este laboratorio deliberadamente no usa.

```bash
cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web awk '/^TcpExt:/ { if (!h) { split($0, n); h = 1 } else { split($0, v); for (i = 2; i <= NF; i++) if (n[i] ~ /^(SyncookiesSent|SyncookiesRecv|SyncookiesFailed|ListenOverflows|ListenDrops)$/) print n[i], v[i] } }' /proc/net/netstat
```

Salida esperada:
```text
1
1
SyncookiesSent 0
SyncookiesRecv 0
SyncookiesFailed 0
ListenOverflows 0
ListenDrops 0
```

Cómo leerlo:

- Los valores de `net.ipv4.tcp_syncookies` significan: `0` cookies desactivadas, `1` cookies **solo cuando se desborda la cola de conexiones semiabiertas** (el valor por defecto habitual), `2` cookies siempre. Ves `1` en ambos sitios: tu sistema está protegido contra las inundaciones SYN de fábrica. El contenedor tiene su propia copia del ajuste, dentro de su propio espacio de nombres de red, y empieza con el mismo valor.
- Los contadores del último comando son el registro propio del kernel para la red del contenedor: `SyncookiesSent` cuenta las cookies enviadas, y `ListenOverflows` y `ListenDrops` cuentan los intentos de conexión perdidos porque la cola estaba llena. Todos valen `0`: la inundación HTTP abrió conexiones completas, no llenó la cola de semiabiertas, así que las SYN cookies nunca tuvieron que actuar. Esa es la razón de clasificar: la defensa correcta depende de la clase de ataque, y un ajuste de SYN cookies no habría salvado al servidor de esta inundación, pero el límite de tasa sí.

> [!NOTE]
> Tus contadores pueden no ser exactamente cero si algo más de tu máquina usó la red del contenedor. El significado es el mismo: solo aumentan cuando se desborda una cola de semiabiertas.

## Verificación
Comprueba estos resultados; cada uno debe cumplirse en tu ejecución:

| Comprobación | Resultado esperado |
|---|---|
| Línea base (Paso 5) | Una petición normal responde `200` en decenas de milisegundos |
| Inundación sin límite (Paso 6) | El usuario normal esperó varios segundos, no milisegundos |
| Registro de acceso (Paso 7) | Las dos direcciones de los bots concentran la mayoría de las líneas |
| Inundación con límite (Paso 9) | El usuario normal obtuvo `200` en unos 0,03 s; los bots recibieron sobre todo `429` y unos 85 `200` cada uno |
| Registro de acceso (Paso 10) | Líneas `429` solo para las dos direcciones de los bots; `200` para `10.60.0.30` |
| SYN cookies (Paso 11) | `net.ipv4.tcp_syncookies` vale `1` en el equipo anfitrión y en el contenedor |

Ejecuta esta última prueba para demostrar de nuevo que el usuario normal se atiende mientras los límites están activados:

```bash
for i in 1 2 3; do podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w '%{http_code}\n' http://10.60.0.10/report.html; done
```

Salida esperada:
```text
200
200
200
```

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `Error: ... cpu ... controller` o `--cpus` no está soportado al arrancar `lab-ddos-web` | El controlador de CPU no está delegado a tu usuario (sistemas antiguos o cgroup v1) | Quita `--cpus 0.5` y haz la página más pesada: `seq 1 600000 > www/report.html`. El efecto de la inundación en el Paso 6 puede ser menor; usa `-c 50` en el comando de los bots |
| `podman run` falla con `permission denied` en los archivos montados | Etiqueta de SELinux o ruta equivocada | Comprueba que estás en `~/ddos-lab` y que los archivos existen; conserva las opciones `:Z`; no montes archivos que estén fuera de tu carpeta personal |
| El Paso 6 no muestra ralentización para el usuario normal (unos 0,03 s) | El servidor es más rápido de lo esperado, o la inundación no empezó | Comprueba que `flood1-bot1.txt` tiene líneas `[200]` y ningún error; usa una página mayor (`seq 1 600000`) o `-c 50` |
| `hey: not found` o `curl: not found` | Ejecutaste el comando en tu equipo o en el contenedor de nginx | Antepón `podman exec lab-ddos-user` (o `-bot1`, `-bot2`), que tienen la imagen de herramientas |
| Tras la recarga todas las respuestas siguen siendo `200` (Paso 9) | `limits.conf` no se actualizó o la recarga falló | `podman exec lab-ddos-web cat /etc/nginx/lab/limits.conf` muestra el archivo que ve nginx; ejecuta `nginx -t` y lee la línea de la que se queja |
| `nginx -t` dice `unknown directive` o `invalid parameter` | Una errata en `limits.conf` | Compáralo con el texto del Paso 8; nginx conserva las reglas antiguas hasta que la prueba pasa |
| El usuario normal también recibe `429` | El usuario pidió más de 5 veces por segundo más la ráfaga | Espera unos segundos y pide de nuevo, despacio. Es la regla funcionando: un límite también puede afectar a usuarios reales que sean muy rápidos o que compartan dirección |
| `Error: ... name "lab-ddos-web" is already in use` | Existe un contenedor de un intento anterior | Ejecuta la [Limpieza](#limpieza) y empieza de nuevo |
| Los recuentos de tus tablas difieren de los de esta página | El tiempo, la velocidad de CPU y la planificación son distintos en cada máquina | Compara la *imagen general*: segundos frente a milisegundos, y miles de `429` frente a unos 85 `200` por bot |

## Reto (opcional)
Sin ayuda paso a paso, prueba uno o más de estos retos y después restaura los archivos del Paso 8:

1. **Un ataque lento.** Los ataques de tipo Slowloris abren una conexión y envían una cabecera de petición muy despacio, sin terminarla nunca. Desde `lab-ddos-bot1`, usa `nc` para abrir una conexión a `10.60.0.10`, puerto 80, y envía solo la primera línea de una petición; después espera. ¿Qué ajuste de nginx acaba cerrando una conexión así (busca `client_header_timeout` en la documentación de nginx)? ¿Por qué no la ve `limit_conn`?
2. **Un límite global.** Añade un segundo contador con clave `$server_name` y una tasa de 30 peticiones por segundo, y aplícalo a `/report.html`. ¿Qué le pasa ahora al usuario normal durante una inundación? ¿Qué te enseña esto sobre los límites por dirección frente a una botnet de miles de direcciones?
3. **Páginas más baratas.** Guarda en caché la página comprimida: busca `gzip_static` o `proxy_cache` en la documentación de nginx y mide cómo cambia la capacidad del servidor en la línea base. ¿A qué capa de la figura de defensa de la lección corresponde esto?

## Limpieza
Elimina todos los recursos que creó el laboratorio. `-t 0` se salta la espera de 10 segundos de los contenedores que ignoran la señal de parada.

```bash
podman rm -f -t 0 lab-ddos-web lab-ddos-bot1 lab-ddos-bot2 lab-ddos-user
podman network rm lab-ddos-net
podman rmi lab-ddos-tools:1
cd ~ && rm -rf ~/ddos-lab
podman ps -a --filter name=lab-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
```

Los dos últimos comandos no imprimen nada cuando todo ha desaparecido. Las imágenes descargadas `docker.io/library/nginx:1.31.6-alpine` y `alpine:3.20.10` permanecen en tu almacén de imágenes (se comparten con otros trabajos); elimínalas con `podman rmi` si quieres recuperar el espacio.

## Qué has aprendido
- Una inundación no necesita ser enorme para hacer daño: un servidor con capacidad limitada convirtió un conjunto de peticiones de aspecto inofensivo en una espera de 15 segundos para un usuario normal.
- Una línea base de latencia y tráfico normales te dice al instante que algo va mal, y el registro de acceso, contado por dirección y por estado, muestra quién es el responsable.
- Un límite de tasa por dirección (`limit_req`, estado 429) rechaza el exceso a bajo coste, mantiene el servidor receptivo y deja pasar a los usuarios normales; las peticiones rechazadas cuestan casi nada de responder.
- La aritmética de un límite es predecible: ráfaga más tasa por tiempo, aquí `10 + 5 × 15 = 85` respuestas por bot. Frente a miles de direcciones, la suma es grande, así que también necesitas capas aguas arriba.
- Las SYN cookies protegen frente a otra clase (agotamiento de estado): el ajuste vale `1` por defecto en Linux, y aquí no importó porque la inundación era una inundación HTTP.
