---
title: "Laboratorio: construye una red virtual en tu equipo"
domain: cloud-computing
level: intermediate
duration: "90 min"
cost: "gratis"
environment: "contenedores (Podman sin privilegios de root en un equipo Linux local)"
lang: es
source_hash: e5f0b827179b
---

# Laboratorio: construye una red virtual en tu equipo

## Objetivo
Construyes una VPC en miniatura con Podman: una subred "pública", una subred "privada" y un contenedor pasarela que enruta entre ellas, hace NAT para la subred privada y aplica reglas de tipo grupo de seguridad (con estado) y de tipo ACL de red (sin estado). La pruebas, la rompes de tres formas realistas y la diagnosticas con `curl`, `ping` y los contadores de paquetes del cortafuegos.

## Objetivos
- Construir subredes con rangos privados que no se solapen y darles rutas a través de una pasarela.
- Demostrar que una puerta de enlace NAT hace que funcionen las conexiones de salida y mantiene la subred privada inaccesible desde fuera.
- Escribir con nftables un conjunto de reglas con estado al estilo de un grupo de seguridad y otro sin estado al estilo de una ACL, y mostrar la diferencia con el tráfico de vuelta y los puertos efímeros.
- Demostrar que gana la primera regla de la ACL que coincide.
- Diagnosticar una ruta ausente, una regla NAT ausente y una regla de ACL ausente a partir de los síntomas y los contadores.

## Requisitos previos
- Un equipo Linux con **Podman 4 o posterior** ejecutándose **sin privilegios de root** (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 mostrar `netavark`.
- Acceso a Internet una sola vez, para descargar la imagen de Alpine Linux (unos 8 MB) y algunos paquetes (unos 18 MB en total). Después, nada del laboratorio necesita Internet.
- Unos 300 MB de espacio libre en disco.
- La [lección](lesson.es.md) de este módulo, [Redes 06 — Subnetting](../../networking/06-subnetting/README.es.md) y [Redes 10 — Fundamentos de enrutamiento](../../networking/10-routing-fundamentals/README.es.md). El laboratorio de enrutamiento de allí construía routers con espacios de nombres de red y `sudo`; aquí usas contenedores y no necesitas `sudo`.

> [!WARNING]
> Todo se ejecuta en tu propio equipo, en contenedores y redes cuyos nombres empiezan por `lab-vnet-`. Las tres redes se crean con `--internal`, así que nada del laboratorio puede llegar a tu red real ni a Internet, y nada puede llegar a él desde fuera. Las direcciones son rangos privados (`10.30.0.0/16`, RFC 1918) y el rango de documentación `198.51.100.0/24` (RFC 5737). Si tu propia red ya usa `10.30.1.0/24` o `10.30.2.0/24`, cambia de forma coherente el penúltimo número de todas las direcciones o elige un rango libre. El contenedor pasarela recibe la capacidad `NET_ADMIN`, que le permite cambiar su propia configuración de red; en Podman sin privilegios de root, ese poder se aplica solo dentro del espacio de nombres de tu usuario, no al equipo anfitrión. No reutilices estas opciones en contenedores que ejecuten software no confiable. Ejecuta la sección [Limpieza](#limpieza) al final.

## Arquitectura
![Tres redes internas de Podman confluyen en el contenedor pasarela lab-vnet-gw, que tiene las interfaces pub0 10.30.1.254, priv0 10.30.2.254 y out0 198.51.100.254, además de 198.51.100.50. La subred pública 10.30.1.0/24 contiene lab-vnet-bastion 10.30.1.10 con ruta por defecto vía 10.30.1.254. La subred privada 10.30.2.0/24 contiene lab-vnet-web 10.30.2.10 en tcp 8080 con ruta por defecto vía 10.30.2.254. La red exterior 198.51.100.0/24 contiene lab-vnet-internet 198.51.100.10 en tcp 8000, que representa Internet. La pasarela aplica tres tablas nftables: lab_nat, lab_sg y lab_acl.](../../../assets/diagrams/vnet-lab-architecture.es.svg)

*Figura 1. Un contenedor pasarela hace de router, puerta de enlace de Internet, puerta de enlace NAT y cortafuegos. "Internet" es un servidor web en una tercera red aislada.*

| Contenedor | Red y dirección | Papel en una VPC real |
|---|---|---|
| `lab-vnet-bastion` | `lab-vnet-public`, `10.30.1.10` | Una instancia en una subred pública, con una IP elástica |
| `lab-vnet-web` | `lab-vnet-private`, `10.30.2.10` | Una instancia en una subred privada, que sirve HTTP en TCP 8080 |
| `lab-vnet-internet` | `lab-vnet-outside`, `198.51.100.10` | Internet: un servidor web en TCP 8000 |
| `lab-vnet-gw` | `10.30.1.254`, `10.30.2.254`, `198.51.100.254` y `198.51.100.50` | Siguiente salto de las tablas de rutas, puerta de enlace de Internet, puerta de enlace NAT y cortafuegos |

> [!NOTE]
> Una nube real reparte el trabajo de la pasarela en varias piezas gestionadas y aplica filtros en cada interfaz. Aquí un solo contenedor lo hace todo, y el grupo de seguridad y la ACL son reglas de ese contenedor, escritas para un destino o una subred. El comportamiento que observas (enrutamiento, NAT, filtrado con estado frente a sin estado) es el real; el empaquetado es una simplificación. Ten en cuenta también que una subred "pública" y una "privada" son ambas redes `--internal`: lo que las hace públicas o privadas son las reglas de la pasarela, igual que en una VPC real lo son la tabla de rutas y la puerta de enlace.

Podman ejecuta un comando en un contenedor con `podman exec lab-vnet-<nombre> <comando>`. El laboratorio lo usa constantemente, así que cada comando se escribe completo.

## Pasos

### Paso 1 — Comprueba tus herramientas y crea una carpeta de trabajo (3 min)
Asegúrate de que Podman se ejecuta sin privilegios de root 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-vnet --format '{{.Names}}'
podman network ls --filter name=lab-vnet --format '{{.Name}}'
mkdir -p ~/vnet-lab && cd ~/vnet-lab
```

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

Los dos comandos `ls` no muestran nada. Si listan nombres `lab-vnet-`, ejecuta primero la [Limpieza](#limpieza). Todos los archivos y comandos siguientes asumen que estás en `~/vnet-lab`.

### Paso 2 — Construye la imagen de herramientas (5 min)
Alpine Linux es diminuta, pero no incluye las herramientas que necesitas. Construyes una imagen con `nftables` (el cortafuegos de Linux), `curl`, el comando `ip` completo y un pequeño servidor web (`httpd`, de `busybox-extras`). La etiqueta de la imagen está fijada a Alpine 3.20, así que obtienes el mismo resultado que en las salidas de más abajo.

```bash
cat > Containerfile <<'EOF'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache nftables curl iproute2 busybox-extras
EOF
podman build -t lab-vnet-tools:1 .
podman run --rm lab-vnet-tools:1 sh -c 'nft --version; curl --version | head -1; ip -V; cat /etc/alpine-release'
```

Salida esperada (el final de la construcción y las versiones; las versiones de los paquetes pueden variar ligeramente):
```text
OK: 18 MiB in 40 packages
COMMIT lab-vnet-tools:1
Successfully tagged localhost/lab-vnet-tools:1
nftables v1.0.9 (Old Doc Yak #3)
curl 8.14.1 (x86_64-alpine-linux-musl) libcurl/8.14.1 OpenSSL/3.3.7 zlib/1.3.2 brotli/1.1.0 zstd/1.5.6 c-ares/1.33.1 libidn2/2.3.7 libpsl/0.21.5 nghttp2/1.62.1
ip utility, iproute2-6.9.0
3.20.10
```

### Paso 3 — Crea las tres redes (4 min)
Cada red de Podman es una subred: un puente con su propio bloque CIDR. `--internal` significa que Podman no añade ninguna ruta hacia el exterior ni NAT hacia tu equipo, así que nada de dentro puede salir salvo por la pasarela que construyes. Dos subredes están dentro del rango de la VPC `10.30.0.0/16` y no se solapan. La tercera, del rango de documentación, representa Internet.

```bash
podman network create --internal --subnet 10.30.1.0/24 lab-vnet-public
podman network create --internal --subnet 10.30.2.0/24 lab-vnet-private
podman network create --internal --subnet 198.51.100.0/24 lab-vnet-outside
podman network inspect lab-vnet-public lab-vnet-private lab-vnet-outside \
  --format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
```

Salida esperada:
```text
lab-vnet-public
lab-vnet-private
lab-vnet-outside
lab-vnet-public subnet=10.30.1.0/24 internal=true
lab-vnet-private subnet=10.30.2.0/24 internal=true
lab-vnet-outside subnet=198.51.100.0/24 internal=true
```

### Paso 4 — Arranca la pasarela (6 min)
La pasarela tiene una interfaz en cada red, con una dirección fija: la última utilizable (`.254`) de cada subred, como la dirección del "router" de una nube. `interface_name` da nombres legibles a las interfaces. `--cap-add NET_ADMIN` le permite editar su propio cortafuegos y sus direcciones, y `--sysctl net.ipv4.ip_forward=1` la convierte en un router, como hiciste con los espacios de nombres en el laboratorio de enrutamiento. `sleep infinity` la mantiene en marcha.

```bash
podman run -d --name lab-vnet-gw \
  --network lab-vnet-public:ip=10.30.1.254,interface_name=pub0 \
  --network lab-vnet-private:ip=10.30.2.254,interface_name=priv0 \
  --network lab-vnet-outside:ip=198.51.100.254,interface_name=out0 \
  --cap-add NET_ADMIN --sysctl net.ipv4.ip_forward=1 \
  lab-vnet-tools:1 sleep infinity
podman exec lab-vnet-gw ip -br addr
podman exec lab-vnet-gw sysctl net.ipv4.ip_forward
podman exec lab-vnet-gw ip route
```

Salida esperada (el ID del contenedor, el orden de las interfaces, los números `@if` y las direcciones `fe80::` varían):
```text
aefbd0e9520a9e36dd5b2e54f5d4799ecc592e6ee97c80d9ff1663484a52dda8
lo               UNKNOWN        127.0.0.1/8 ::1/128 
priv0@if4        UP             10.30.2.254/24 fe80::e8e5:faff:fe8d:8e43/64 
out0@if6         UP             198.51.100.254/24 fe80::fc55:f5ff:fef6:ab65/64 
pub0@if8         UP             10.30.1.254/24 fe80::647e:b8ff:fe3d:9f28/64 
net.ipv4.ip_forward = 1
10.30.1.0/24 dev pub0 proto kernel scope link src 10.30.1.254 
10.30.2.0/24 dev priv0 proto kernel scope link src 10.30.2.254 
198.51.100.0/24 dev out0 proto kernel scope link src 198.51.100.254 
```

La tabla de rutas de la pasarela tiene solo las tres **rutas conectadas**, una por subred: el equivalente de la ruta local implícita. No tiene ruta por defecto y no la necesita: está conectada directamente a las tres redes.

La pasarela necesita además una segunda dirección pública, la "IP elástica" del bastión. La añades a la interfaz exterior:

```bash
podman exec lab-vnet-gw ip addr add 198.51.100.50/24 dev out0
podman exec lab-vnet-gw ip -br addr show out0
```

Salida esperada:
```text
out0@if6         UP             198.51.100.254/24 198.51.100.50/24 fe80::fc55:f5ff:fef6:ab65/64 
```

### Paso 5 — Lanza las instancias y dales rutas (6 min)
Cada instancia se une a una subred. Una red interna no da a un contenedor ninguna ruta por defecto, como una subred cuya tabla de rutas está vacía. Cada instancia añade una ruta por defecto a través de la pasarela (`ip route add default via ...`): esa es la tabla de rutas de su subred. `NET_ADMIN` hace falta en los contenedores que ejecutan el comando `ip route add`. El servidor web e "Internet" publican cada uno una página de una línea con el `httpd` integrado; `-v` hace que registre cada conexión en el registro del contenedor.

```bash
I=lab-vnet-tools:1
podman run -d --name lab-vnet-web --network lab-vnet-private:ip=10.30.2.10 --cap-add NET_ADMIN $I \
  sh -c 'ip route add default via 10.30.2.254; mkdir -p /www; echo "hello from the private web tier" > /www/index.html; exec httpd -f -v -p 8080 -h /www'
podman run -d --name lab-vnet-bastion --network lab-vnet-public:ip=10.30.1.10 --cap-add NET_ADMIN $I \
  sh -c 'ip route add default via 10.30.1.254; exec sleep infinity'
podman run -d --name lab-vnet-internet --network lab-vnet-outside:ip=198.51.100.10 $I \
  sh -c 'mkdir -p /www; echo "hello from the Internet" > /www/index.html; exec httpd -f -v -p 8000 -h /www'
podman ps --filter name=lab-vnet --format 'table {{.Names}}\t{{.Status}}'
```

Salida esperada (primero tres ID de contenedor; los tiempos varían):
```text
NAMES              STATUS
lab-vnet-gw        Up 8 seconds
lab-vnet-web       Up 1 second
lab-vnet-bastion   Up 1 second
lab-vnet-internet  Up 1 second
```

Ahora lee las "tablas de rutas":

```bash
podman exec lab-vnet-web ip route
podman exec lab-vnet-bastion ip route
podman exec lab-vnet-internet ip route
```

Salida esperada:
```text
default via 10.30.2.254 dev eth0 
10.30.2.0/24 dev eth0 proto kernel scope link src 10.30.2.10 
default via 10.30.1.254 dev eth0 
10.30.1.0/24 dev eth0 proto kernel scope link src 10.30.1.10 
198.51.100.0/24 dev eth0 proto kernel scope link src 198.51.100.10 
```

El host "Internet" no tiene ruta por defecto ni ruta hacia tus rangos privados: como la Internet real, no sabe nada de `10.30.0.0/16`, porque las direcciones de la RFC 1918 no se enrutan allí.

### Paso 6 — Solo enrutamiento: todo está abierto (8 min)
Con el reenvío activado y aún sin reglas de filtrado, la pasarela deja pasar todo entre las dos subredes privadas. Prueba desde el bastión:

```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-bastion ping -c 2 10.30.2.10 | tail -3
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:22; echo "rc=$?"
```

Salida esperada (los tiempos del ping varían):
```text
hello from the private web tier
--- 10.30.2.10 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.050/0.055/0.061 ms
curl: (7) Failed to connect to 10.30.2.10 port 22 after 0 ms: Could not connect to server
rc=7
```

Dos lecciones. El camino funciona porque la ruta del bastión envía `10.30.2.10` a la pasarela, que lo reenvía. Y nada detiene el puerto 22: falla solo porque **nada escucha** allí, y el host responde al instante con un rechazo (`rc=7`, "refused"). Recuérdalo: es lo contrario de un agotamiento de tiempo.

A continuación, el servidor web privado intenta llegar a Internet, y el bastión también:

```bash
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-bastion curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
```

Salida esperada (los tiempos en milisegundos pueden variar):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Ambos agotan el tiempo. Las peticiones llegan al host "Internet", pero este no puede responder: el origen es `10.30.2.10` o `10.30.1.10`, y el host de Internet no tiene ruta hacia esos rangos privados. La respuesta se descarta en silencio. Por eso las subredes privadas necesitan NAT.

### Paso 7 — La puerta de enlace NAT y la IP elástica (10 min)
Añades una tabla `nat` a la pasarela con el cortafuegos de Linux, **nftables**. Una regla de NAT de origen en el hook `postrouting` reescribe la dirección de origen de los paquetes que salen hacia "Internet":
- Toda la subred privada se **enmascara** (masquerade) con la propia dirección de la pasarela, `198.51.100.254`: NAT de muchos a uno, como funciona una puerta de enlace NAT. Las respuestas se traducen de vuelta automáticamente.
- El bastión recibe una dirección pública fija, `198.51.100.50`: una correspondencia uno a uno, como funciona una IP pública o elástica para una instancia.

Escribe las reglas en un archivo. Las dos primeras líneas hacen que sea seguro cargarlo de nuevo: crean la tabla si no existe y luego la borran, de modo que cada carga empieza limpia.

```bash
cat > nat.nft <<'EOF'
table ip lab_nat
delete table ip lab_nat
table ip lab_nat {
  chain postrouting {
    type nat hook postrouting priority srcnat; policy accept;
    ip saddr 10.30.1.10 ip daddr 198.51.100.0/24 counter snat to 198.51.100.50 comment "elastic IP of the bastion"
    ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter snat to 198.51.100.254 comment "NAT gateway for the private subnet"
  }
}
EOF
podman exec -i lab-vnet-gw nft -f - < nat.nft
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-bastion curl -sS -m 3 http://198.51.100.10:8000
```

`podman exec -i ... nft -f -` lee las reglas de la entrada estándar, así que el archivo se queda en tu equipo. La carga no muestra nada. Salida esperada de las dos peticiones:
```text
hello from the Internet
hello from the Internet
```

Ahora ambas funcionan. Mira el registro del servidor "Internet", que muestra quién cree que se conecta, y la tabla NAT y el seguimiento de conexiones de la pasarela:

```bash
podman logs lab-vnet-internet
podman exec lab-vnet-gw nft list table ip lab_nat
podman exec lab-vnet-gw sh -c "grep 198.51.100.10 /proc/net/nf_conntrack | sed 's/ \[ASSURED\].*//; s/^ipv4 *2 //'"
```

Salida esperada (los números de puerto varían):
```text
[::ffff:198.51.100.254]:52550: response:200
[::ffff:198.51.100.50]:43524: response:200
table ip lab_nat {
	chain postrouting {
		type nat hook postrouting priority srcnat; policy accept;
		ip saddr 10.30.1.10 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 snat to 198.51.100.50 comment "elastic IP of the bastion"
		ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 snat to 198.51.100.254 comment "NAT gateway for the private subnet"
	}
}
tcp      6 119 TIME_WAIT src=10.30.2.10 dst=198.51.100.10 sport=52550 dport=8000 src=198.51.100.10 dst=198.51.100.254 sport=8000 dport=52550
tcp      6 119 TIME_WAIT src=10.30.1.10 dst=198.51.100.10 sport=43524 dport=8000 src=198.51.100.10 dst=198.51.100.50 sport=8000 dport=43524
```

El servidor web registró `198.51.100.254` (la puerta de enlace NAT) para la instancia privada y `198.51.100.50` (la IP elástica) para el bastión. Ninguna dirección privada salió nunca. Cada línea de seguimiento muestra ambos sentidos: el original (`src=10.30.2.10`) y la respuesta que la pasarela espera (`dst=198.51.100.254`). Esa tabla es como la puerta de enlace NAT sabe adónde va cada respuesta, y por qué es solo de salida. Prueba ahora el sentido contrario, de "Internet" al servidor web privado:

```bash
podman exec lab-vnet-internet curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
```

Salida esperada:
```text
curl: (7) Failed to connect to 10.30.2.10 port 8080 after 0 ms: Could not connect to server
rc=7
```

Falla al instante: el host de Internet no tiene ruta hacia una dirección privada. Incluso con una ruta, la puerta de enlace NAT no tiene ninguna entrada de conexión para un flujo nuevo de entrada.

### Paso 8 — El grupo de seguridad: reglas con estado (12 min)
Un grupo de seguridad tiene estado y solo permite. En nftables obtienes el mismo comportamiento con el seguimiento de conexiones (`ct state`) y una política de **descarte por defecto** en el hook `forward`, el camino que sigue el tráfico a través de la pasarela. Las reglas son las del ejemplo práctico de la lección, reducidas a lo que necesita el laboratorio:

- La primera regla acepta los paquetes `established,related`: las respuestas de cualquier conexión que se permitió. Esa línea es la parte "con estado".
- `sg-web` acepta conexiones nuevas hacia `10.30.2.10` solo desde la subred pública, solo en TCP 8080, más ping.
- Ambas subredes pueden iniciar conexiones hacia "Internet".
- Todo lo demás llega a la última regla, que cuenta y descarta.

```bash
cat > sg.nft <<'EOF'
table ip lab_sg
delete table ip lab_sg
table ip lab_sg {
  chain forward {
    type filter hook forward priority 0; policy drop;
    ct state invalid drop
    ct state established,related counter accept comment "replies are automatic (stateful)"
    # sg-web, inbound: only the public subnet, only TCP 8080 and ping
    ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter accept comment "sg-web in: TCP 8080 from public"
    ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 icmp type echo-request counter accept comment "sg-web in: ping from public"
    # outbound to the Internet
    ip saddr 10.30.1.0/24 ip daddr 198.51.100.0/24 counter accept comment "public out: Internet"
    ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter accept comment "private out: Internet"
    counter drop comment "default deny"
  }
}
EOF
podman exec -i lab-vnet-gw nft -f - < sg.nft
```

Pruébalo. Las tres primeras están permitidas; las dos últimas deben fallar:

```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-bastion ping -c 2 10.30.2.10 | tail -3
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:22; echo "rc=$?"
podman exec lab-vnet-web ping -c 1 -W 2 10.30.1.10 | tail -2
```

Salida esperada (los tiempos del ping varían):
```text
hello from the private web tier
--- 10.30.2.10 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.082/0.088/0.094 ms
hello from the Internet
curl: (28) Connection timed out after 3002 milliseconds
rc=28
--- 10.30.1.10 ping statistics ---
1 packets transmitted, 0 packets received, 100% packet loss
```

Compara el puerto 22 con el Paso 6. Antes del cortafuegos era **rechazado** al instante (`rc=7`): el paquete llegaba. Ahora **agota el tiempo** (`rc=28`): la pasarela descartó el paquete sin ninguna respuesta. Y el servidor web privado, que podía responder al bastión, no puede iniciar una conexión hacia él: nada permite ese sentido.

Mira los contadores:

```bash
podman exec lab-vnet-gw nft list chain ip lab_sg forward
```

Salida esperada (los recuentos de paquetes difieren en tu equipo):
```text
table ip lab_sg {
	chain forward {
		type filter hook forward priority filter; policy drop;
		ct state invalid drop
		ct state established,related counter packets 25 bytes 2047 accept comment "replies are automatic (stateful)"
		ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter packets 1 bytes 60 accept comment "sg-web in: TCP 8080 from public"
		ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 icmp type echo-request counter packets 1 bytes 84 accept comment "sg-web in: ping from public"
		ip saddr 10.30.1.0/24 ip daddr 198.51.100.0/24 counter packets 0 bytes 0 accept comment "public out: Internet"
		ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 accept comment "private out: Internet"
		counter packets 4 bytes 264 drop comment "default deny"
	}
}
```

Cada conexión aceptada usó exactamente una regla "nueva", para su primer paquete (el SYN de TCP o la petición de ping). Todos los demás paquetes, en ambos sentidos, coincidieron con la línea `established,related`: las respuestas no necesitaron regla. La línea `drop` contó los paquetes SYN bloqueados (varios, porque `curl` reintentó) y el ping hacia el bastión.

> [!NOTE]
> El curl al puerto 22 se reintenta mientras espera, así que el contador de descartes sube más de uno. Las cifras exactas dependen del momento.

### Paso 9 — La ACL de red: reglas sin estado y ordenadas (12 min)
Ahora un segundo filtro para la **subred privada** `10.30.2.0/24`, en su propia tabla con una prioridad anterior (`-10`), de modo que se ejecute antes que el grupo de seguridad. Un paquete debe pasar por ambos. Esta ACL sigue las reglas de una ACL de red de nube:

- Nunca usa `ct state`: cada paquete se juzga por sí solo, así que no tiene estado.
- Las reglas van en orden y gana la primera coincidencia. Los comentarios muestran los números de regla "in 100", "out 100", etc.
- Tiene tanto permitir como denegar, con un `*` final de denegar en cada sentido.
- El tráfico de vuelta necesita reglas explícitas, con el **rango de puertos efímeros** `1024-65535`.

```bash
cat > acl.nft <<'EOF'
table ip lab_acl
delete table ip lab_acl
table ip lab_acl {
  chain forward {
    type filter hook forward priority -10; policy accept;
    # Network ACL of the private subnet 10.30.2.0/24: ordered, first match wins, no "ct state" anywhere
    # Inbound (packets entering the subnet)
    ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 tcp dport 8080 counter accept comment "in 100: TCP 8080 from public"
    ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 icmp type echo-request counter accept comment "in 110: ping from public"
    ip daddr 10.30.2.0/24 ip saddr 198.51.100.0/24 tcp dport 1024-65535 counter accept comment "in 120: replies from the Internet"
    ip daddr 10.30.2.0/24 counter drop comment "in *: deny"
    # Outbound (packets leaving the subnet)
    ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 tcp sport 8080 tcp dport 1024-65535 counter accept comment "out 100: replies to public"
    ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 icmp type echo-reply counter accept comment "out 110: ping replies"
    ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 tcp dport 8000 counter accept comment "out 120: HTTP to the Internet"
    ip saddr 10.30.2.0/24 counter drop comment "out *: deny"
  }
}
EOF
podman exec -i lab-vnet-gw nft -f - < acl.nft
```

Fíjate en el orden de los eventos dentro de la pasarela. Los paquetes de salida aún tienen su dirección de origen privada cuando se ejecuta el hook `forward`, porque el NAT de origen ocurre después, en `postrouting`. Las respuestas desde Internet ya han sido traducidas de vuelta a la dirección privada cuando llegan a `forward`. Así, la ACL ve siempre las direcciones privadas, y por eso sus reglas mencionan `10.30.2.0/24`.

Repite las pruebas:

```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:80; echo "rc=$?"
```

Salida esperada:
```text
hello from the private web tier
hello from the Internet
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Las dos primeras pasan ambos filtros. La tercera va al TCP 80 del host de Internet: el grupo de seguridad permite cualquier conexión nueva hacia Internet, pero la regla de salida 120 de la ACL solo permite TCP 8000, así que la ACL la descarta. Dos capas, y un paquete necesita pasar por las dos.

### Paso 10 — Sin estado frente a con estado: quita la regla de vuelta (10 min)
Este es el experimento de la lección. Quita la regla "out 100", la que deja volver a la subred pública las respuestas del servidor web. El grupo de seguridad sigue teniendo su regla con estado `established,related` y la regla de entrada de la ACL sigue dejando pasar la petición. Primero busca el handle de la regla (su número dentro de nftables):

```bash
podman exec lab-vnet-gw nft -a list chain ip lab_acl forward | grep -E "out 100|out \*"
```

Salida esperada (los números de handle pueden diferir):
```text
		ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 tcp sport 8080 tcp dport 1024-65535 counter packets 6 bytes 561 accept comment "out 100: replies to public" # handle 6
		ip saddr 10.30.2.0/24 counter packets 0 bytes 0 drop comment "out *: deny" # handle 9
```

Observa que "out 100" ya contó 6 paquetes: las respuestas de la petición HTTP del Paso 9. El denegar final contó 0. Ahora borra la regla usando su handle (aquí `6`; usa el tuyo) y repite la petición:

```bash
podman exec lab-vnet-gw nft delete rule ip lab_acl forward handle 6
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
podman exec lab-vnet-gw nft list chain ip lab_acl forward | grep "out \*"
podman exec lab-vnet-gw nft list chain ip lab_sg forward | grep "TCP 8080"
```

Salida esperada (los recuentos varían):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
		ip saddr 10.30.2.0/24 counter packets 4 bytes 240 drop comment "out *: deny"
		ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter packets 2 bytes 120 accept comment "sg-web in: TCP 8080 from public"
```

El servidor web recibió la petición y respondió, pero la respuesta es un paquete nuevo para la ACL sin estado, y `out *: deny` la descartó. El contador de descartes pasó de 0 a 4: la primera respuesta y sus retransmisiones. El grupo de seguridad, que tiene estado, no es el problema: la misma petición funcionaba antes. La regla que quitaste era el camino de vuelta que faltaba. Restaura la ACL cargando de nuevo el archivo (recrea la tabla con todas las reglas) y prueba:

```bash
podman exec -i lab-vnet-gw nft -f - < acl.nft
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
```

Salida esperada:
```text
hello from the private web tier
```

### Paso 11 — Orden de las reglas: gana la primera coincidencia (5 min)
Una ACL se evalúa en orden. Inserta una regla de denegar para el bastión **antes** de la regla "in 100". El comando `insert` coloca la regla al principio de la cadena:

```bash
podman exec lab-vnet-gw nft insert rule ip lab_acl forward ip saddr 10.30.1.10 ip daddr 10.30.2.0/24 counter drop comment \"in 90: deny bastion\"
podman exec lab-vnet-gw nft -a list chain ip lab_acl forward | sed -n 3,5p
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
```

Salida esperada (los números de handle y los contadores pueden diferir):
```text
		type filter hook forward priority filter - 10; policy accept;
		ip saddr 10.30.1.10 ip daddr 10.30.2.0/24 counter packets 0 bytes 0 drop comment "in 90: deny bastion" # handle 10
		ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 tcp dport 8080 counter packets 6 bytes 399 accept comment "in 100: TCP 8080 from public" # handle 2
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

La regla "in 100" sigue permitiendo TCP 8080 desde la subred pública, pero la regla de denegar va primero, y gana la primera coincidencia. Quítala con su handle (aquí `10`; usa el tuyo):

```bash
podman exec lab-vnet-gw nft delete rule ip lab_acl forward handle 10
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
```

Salida esperada:
```text
hello from the private web tier
```

> [!NOTE]
> Un grupo de seguridad no tiene ese orden: basta cualquier regla de permitir que coincida, y no hay reglas de denegar. Esa es una razón para usar grupos de seguridad para el control de acceso normal y ACL solo para bloqueos gruesos.

### Paso 12 — Rompe y arregla una ruta y una regla NAT (8 min)
Diagnosticar es leer síntomas. Provocas dos fallos y los comparas con los agotamientos de tiempo que ya has visto. Primero, borra la ruta por defecto del servidor web privado, como si su tabla de rutas hubiera perdido la ruta hacia la pasarela:

```bash
podman exec lab-vnet-web ip route del default
podman exec lab-vnet-web ip route
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-web ip route get 198.51.100.10; echo "rc=$?"
```

Salida esperada:
```text
10.30.2.0/24 dev eth0 proto kernel scope link src 10.30.2.10 
curl: (7) Failed to connect to 198.51.100.10 port 8000 after 0 ms: Could not connect to server
rc=7
RTNETLINK answers: Network unreachable
rc=2
```

El fallo es **inmediato** y `ip route get` dice "Network unreachable": ninguna ruta coincide, así que el paquete nunca sale de la instancia. Esa es la firma de un problema de enrutamiento, no de un filtro. Arréglalo y prueba de nuevo:

```bash
podman exec lab-vnet-web ip route add default via 10.30.2.254
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
```

Salida esperada:
```text
hello from the Internet
```

Ahora el segundo fallo: vacía la tabla NAT, como si la puerta de enlace NAT hubiera desaparecido o se hubiera eliminado su regla. Después mira los contadores de los filtros, que muestran que los paquetes sí salieron:

```bash
podman exec lab-vnet-gw nft flush chain ip lab_nat postrouting
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-gw nft list chain ip lab_sg forward | grep "private out"
```

Salida esperada (el contador varía):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
		ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 6 bytes 360 accept comment "private out: Internet"
```

Esta vez el síntoma es un **agotamiento de tiempo**, como un descarte de filtro. Pero los filtros aceptaron los paquetes (el contador "private out" subió), y ni el grupo de seguridad ni la ACL descartaron nada nuevo. Los paquetes salieron con la dirección de origen privada y la respuesta no pudo volver: el mismo fallo que en el Paso 6. Este es el método de la lección: un agotamiento de tiempo significa un descarte silencioso; mira los contadores de los filtros y, si aceptan el paquete, comprueba el camino de vuelta y el NAT. Arréglalo cargando de nuevo el archivo NAT:

```bash
podman exec -i lab-vnet-gw nft -f - < nat.nft
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
```

Salida esperada:
```text
hello from the Internet
```

### Paso 13 — Lee los contadores de descartes (4 min)
Cada regla de filtrado tiene un contador. Cuando un flujo no funciona, la forma más rápida de encontrar la capa es preguntar qué regla de descarte está contando. Lista todas las reglas de descarte con comentario:

```bash
podman exec lab-vnet-gw nft list ruleset | grep "drop comment" | sed 's/^\t*//'
```

Salida esperada (tus recuentos dependen de lo que hayas hecho, y son mayores si ejecutaste antes el script de verificación):
```text
counter packets 0 bytes 0 drop comment "default deny"
ip daddr 10.30.2.0/24 counter packets 9 bytes 540 drop comment "in *: deny"
ip saddr 10.30.2.0/24 counter packets 2 bytes 168 drop comment "out *: deny"
```

Los descartes de la ACL (`in *` y `out *`) han contado paquetes, pero el `default deny` del grupo de seguridad muestra 0 aquí. Eso se debe a que la ACL se ejecuta primero (prioridad `-10`) y descartó esos paquetes antes de que el grupo de seguridad los viera. Una regla que cuenta paquetes ha coincidido. Una regla de descarte que cuenta es la que te está bloqueando. Una regla que se queda en 0 no es la que se aplica.

## Verificación
Guarda este script y ejecútalo. Prueba seis comportamientos e imprime PASS o FAIL para cada uno:

```bash
cat > verify.sh <<'EOF'
#!/bin/sh
# Prints PASS or FAIL for each expected behaviour of the virtual network.
check() { # check <description> <expected: ok|fail> <command...>
  desc=$1; want=$2; shift 2
  if "$@" >/dev/null 2>&1; then got=ok; else got=fail; fi
  if [ "$got" = "$want" ]; then echo "PASS  $desc"; else echo "FAIL  $desc (expected $want, got $got)"; fi
}
check "bastion reaches the web tier on TCP 8080"        ok   podman exec lab-vnet-bastion curl -s -m 3 http://10.30.2.10:8080
check "bastion cannot reach the web tier on TCP 22"     fail podman exec lab-vnet-bastion curl -s -m 3 http://10.30.2.10:22
check "bastion can ping the web tier"                   ok   podman exec lab-vnet-bastion ping -c 1 -W 2 10.30.2.10
check "web tier reaches the Internet through NAT"       ok   podman exec lab-vnet-web curl -s -m 3 http://198.51.100.10:8000
check "web tier cannot start a connection to the bastion" fail podman exec lab-vnet-web ping -c 1 -W 2 10.30.1.10
check "the Internet cannot reach the web tier"          fail podman exec lab-vnet-internet curl -s -m 3 http://10.30.2.10:8080
EOF
sh verify.sh
```

Salida esperada:
```text
PASS  bastion reaches the web tier on TCP 8080
PASS  bastion cannot reach the web tier on TCP 22
PASS  bastion can ping the web tier
PASS  web tier reaches the Internet through NAT
PASS  web tier cannot start a connection to the bastion
PASS  the Internet cannot reach the web tier
```

Los seis deben pasar. El script tarda unos 10 segundos, porque las tres comprobaciones "fail" esperan un agotamiento de tiempo.

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `podman network create` falla con "subnet already used" o similar | Otra red de Podman o un intento anterior usa el mismo rango | Ejecuta `podman network ls`, elimina las redes `lab-vnet-` antiguas con la [Limpieza](#limpieza) o elige otro rango libre |
| `unknown flag` o se rechaza `interface_name` en el Paso 4 | Podman anterior a 4.x, o el backend CNI en lugar de netavark | Comprueba `podman --version` y `podman info --format '{{.Host.NetworkBackend}}'`; usa Podman 4+ con netavark |
| `nft` muestra `Operation not permitted` | La pasarela se arrancó sin `--cap-add NET_ADMIN` | Elimínala con `podman rm -f -t 0 lab-vnet-gw` y ejecuta de nuevo el Paso 4 |
| Todo agota el tiempo, incluso la primera prueba del Paso 6 | El reenvío IP está desactivado en la pasarela, o una instancia no tiene ruta por defecto | `podman exec lab-vnet-gw sysctl net.ipv4.ip_forward` debe mostrar `1`; comprueba `ip route` en la instancia |
| `podman build` no puede descargar paquetes | No hay acceso a Internet o hay un proxy | La construcción necesita Internet una vez; configura tu proxy para Podman o construye en un equipo conectado |
| `curl` en un contenedor dice `Could not resolve host` | Usaste un nombre en lugar de una dirección | El laboratorio no tiene DNS: usa siempre las direcciones IP de la tabla |
| Un paso funciona pero los contadores se quedan en 0 | El paquete coincidió con una regla anterior, o pasa por otra tabla | Lee la cadena desde arriba: las reglas se aplican en orden; el primer `accept` o `drop` la termina para esa tabla |
| `Error: No such file or directory` al cargar un archivo con `nft -f -` | Ejecutaste el comando fuera de `~/vnet-lab`, así que el shell no encuentra el archivo `.nft` | `cd ~/vnet-lab` y ejecútalo de nuevo |
| Los contenedores tardan en detenerse | `sleep infinity` ignora la señal de parada amable | Usa `podman rm -f -t 0 ...` como en la Limpieza |

## Reto (opcional)
Haz que el bastión sea accesible **desde Internet** en su IP elástica, como una instancia pública. Arranca un segundo servidor web en el bastión (`podman exec -d lab-vnet-bastion sh -c 'mkdir -p /srv && echo "hello from the bastion" > /srv/index.html && exec httpd -f -p 8081 -h /srv'`) y consigue que `podman exec lab-vnet-internet curl -sS -m 3 http://198.51.100.50:8081` muestre su página. Necesitas tres cosas, y cada una es un concepto de la lección:
1. Una regla de **NAT de destino** que traduzca `198.51.100.50` puerto 8081 a `10.30.1.10`. Usa una cadena nueva en `lab_nat` con `type nat hook prerouting priority dstnat; policy accept;`.
2. Una regla en `lab_sg` que permita la nueva conexión hacia `10.30.1.10` en TCP 8081. Debe ir antes del `drop` final: usa `nft insert rule` para ponerla al principio.
3. Una mirada a los contadores de paquetes, para ver si coincidieron tanto la traducción como el filtro.

Después comprueba que el servidor web privado sigue siendo inaccesible desde Internet. ¿Por qué lo es, aunque se use la misma pasarela?

## Limpieza
Esto elimina todos los contenedores, redes e imágenes del laboratorio, y la carpeta de trabajo. La opción `-t 0` omite la espera de parada.

```bash
podman rm -f -t 0 lab-vnet-gw lab-vnet-web lab-vnet-bastion lab-vnet-internet
podman network rm lab-vnet-public lab-vnet-private lab-vnet-outside
podman rmi lab-vnet-tools:1
cd ~ && rm -rf ~/vnet-lab
```

Comprueba que no queda nada. Los tres comandos no deben mostrar nada:

```bash
podman ps -a --filter name=lab-vnet --format '{{.Names}}'
podman network ls --filter name=lab-vnet --format '{{.Name}}'
podman images --filter reference='lab-vnet*' --format '{{.Repository}}'
```

`podman rmi` elimina solo la imagen que construiste. La imagen base de Alpine descargada se queda en tu caché, y otros contenedores pueden usarla. Si quieres borrarla, ejecuta `podman rmi docker.io/library/alpine:3.20.10`.

## Qué has aprendido
- Una VPC es un conjunto de subredes unidas por un router; una subred es pública o privada por sus rutas y las reglas de su pasarela, no por su rango de direcciones.
- Una puerta de enlace NAT reescribe el origen de las conexiones de salida y las registra, de modo que las respuestas vuelven y nada nuevo puede entrar; una IP pública o elástica es una correspondencia uno a uno.
- Un grupo de seguridad con estado solo necesita la regla que inicia la conexión; una ACL sin estado necesita reglas para ambos sentidos, incluidos los puertos efímeros.
- Las reglas de una ACL están ordenadas y gana la primera coincidencia; las reglas de un grupo de seguridad no están ordenadas.
- "Network unreachable" significa enrutamiento, "refused" significa que el host respondió, y un "timeout" es un descarte silencioso que puede venir de un filtro, de un camino de vuelta ausente o de la falta de NAT.
- Los contadores te dicen qué regla vio tu paquete.
