---
title: "Laboratório: construir uma rede virtual no seu computador"
domain: cloud-computing
level: intermediate
duration: "90 min"
cost: "gratuito"
environment: "contentores (Podman sem privilégios de root num computador Linux local)"
lang: pt
source_hash: e5f0b827179b
---

# Laboratório: construir uma rede virtual no seu computador

## Objetivo
Constrói-se uma VPC em miniatura com Podman: uma sub-rede "pública", uma sub-rede "privada" e um contentor gateway que encaminha entre elas, faz NAT para a sub-rede privada e aplica regras do tipo grupo de segurança (com estado) e do tipo ACL de rede (sem estado). Testa-se, quebra-se de três formas realistas e diagnostica-se com `curl`, `ping` e os contadores de pacotes da firewall.

## Objetivos
- Construir sub-redes com intervalos privados que não se sobreponham e dar-lhes rotas através de um gateway.
- Demonstrar que um gateway NAT faz funcionar as ligações de saída e mantém a sub-rede privada inacessível a partir do exterior.
- Escrever com nftables um conjunto de regras com estado ao estilo de um grupo de segurança e outro sem estado ao estilo de uma ACL, e mostrar a diferença com o tráfego de regresso e as portas efémeras.
- Demonstrar que prevalece a primeira regra da ACL que corresponde.
- Diagnosticar uma rota em falta, uma regra NAT em falta e uma regra de ACL em falta a partir dos sintomas e dos contadores.

## Pré-requisitos
- Um computador Linux com **Podman 4 ou posterior** a correr **sem privilégios de root** (como utilizador normal; nunca é necessário `sudo`) e com o backend de rede netavark. Testado com Podman 5.8.7 em Fedora com o kernel 7.2. Verifica-se com `podman info --format '{{.Host.NetworkBackend}}'`: deve mostrar `netavark`.
- Acesso à Internet uma única vez, para descarregar a imagem do Alpine Linux (cerca de 8 MB) e alguns pacotes (cerca de 18 MB no total). Depois disso, nada no laboratório precisa da Internet.
- Cerca de 300 MB de espaço livre em disco.
- A [lição](lesson.pt.md) deste módulo, [Redes 06 — Subnetting](../../networking/06-subnetting/README.pt.md) e [Redes 10 — Fundamentos de encaminhamento](../../networking/10-routing-fundamentals/README.pt.md). O laboratório de encaminhamento aí descrito construía routers com espaços de nomes de rede e `sudo`; aqui usam-se contentores e não é necessário `sudo`.

> [!WARNING]
> Tudo corre no próprio computador, em contentores e redes cujos nomes começam por `lab-vnet-`. As três redes são criadas com `--internal`, pelo que nada no laboratório consegue alcançar a rede real nem a Internet, e nada consegue alcançá-lo a partir do exterior. Os endereços são intervalos privados (`10.30.0.0/16`, RFC 1918) e o intervalo de documentação `198.51.100.0/24` (RFC 5737). Se a rede própria já usar `10.30.1.0/24` ou `10.30.2.0/24`, deve alterar-se de forma coerente o penúltimo número de todos os endereços ou escolher um intervalo livre. O contentor gateway recebe a capacidade `NET_ADMIN`, que lhe permite alterar a sua própria configuração de rede; no Podman sem privilégios de root, esse poder aplica-se apenas dentro do espaço de nomes do utilizador, não ao anfitrião. Estas opções não devem ser reutilizadas em contentores que executem software não fiável. No final, deve executar-se a secção [Limpeza](#limpeza).

## Arquitetura
![Três redes internas do Podman encontram-se no contentor gateway lab-vnet-gw, que tem as interfaces pub0 10.30.1.254, priv0 10.30.2.254 e out0 198.51.100.254, além de 198.51.100.50. A sub-rede pública 10.30.1.0/24 contém lab-vnet-bastion 10.30.1.10 com rota predefinida via 10.30.1.254. A sub-rede privada 10.30.2.0/24 contém lab-vnet-web 10.30.2.10 em tcp 8080 com rota predefinida via 10.30.2.254. A rede exterior 198.51.100.0/24 contém lab-vnet-internet 198.51.100.10 em tcp 8000, que representa a Internet. O gateway aplica três tabelas nftables: lab_nat, lab_sg e lab_acl.](../../../assets/diagrams/vnet-lab-architecture.pt.svg)

*Figura 1. Um contentor gateway faz de router, gateway de Internet, gateway NAT e firewall. A "Internet" é um servidor web numa terceira rede isolada.*

| Contentor | Rede e endereço | Papel numa VPC real |
|---|---|---|
| `lab-vnet-bastion` | `lab-vnet-public`, `10.30.1.10` | Uma instância numa sub-rede pública, com um IP elástico |
| `lab-vnet-web` | `lab-vnet-private`, `10.30.2.10` | Uma instância numa sub-rede privada, que serve HTTP em TCP 8080 |
| `lab-vnet-internet` | `lab-vnet-outside`, `198.51.100.10` | A Internet: um servidor web em TCP 8000 |
| `lab-vnet-gw` | `10.30.1.254`, `10.30.2.254`, `198.51.100.254` e `198.51.100.50` | Próximo salto das tabelas de rotas, gateway de Internet, gateway NAT e firewall |

> [!NOTE]
> Uma cloud real reparte o trabalho do gateway por várias peças geridas e aplica filtros em cada interface. Aqui um único contentor faz tudo, e o grupo de segurança e a ACL são regras desse contentor, escritas para um destino ou uma sub-rede. O comportamento observado (encaminhamento, NAT, filtragem com estado versus sem estado) é o real; o empacotamento é uma simplificação. Note-se também que uma sub-rede "pública" e uma "privada" são ambas redes `--internal`: o que as torna públicas ou privadas são as regras do gateway, tal como numa VPC real são a tabela de rotas e o gateway.

O Podman executa um comando num contentor com `podman exec lab-vnet-<nome> <comando>`. O laboratório usa-o constantemente, pelo que cada comando é escrito por extenso.

## Passos

### Passo 1 — Verificar as ferramentas e criar uma pasta de trabalho (3 min)
Deve confirmar-se que o Podman corre sem privilégios de root e usa netavark, e que não restou nada de uma tentativa 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
```

Saída esperada (a versão pode diferir):
```text
podman version 5.8.7
netavark rootless=true
```

Os dois comandos `ls` não mostram nada. Se listarem nomes `lab-vnet-`, deve executar-se primeiro a [Limpeza](#limpeza). Todos os ficheiros e comandos seguintes pressupõem que se está em `~/vnet-lab`.

### Passo 2 — Construir a imagem de ferramentas (5 min)
O Alpine Linux é minúsculo, mas não inclui as ferramentas necessárias. Constrói-se uma imagem com `nftables` (a firewall do Linux), `curl`, o comando `ip` completo e um pequeno servidor web (`httpd`, de `busybox-extras`). A etiqueta da imagem está fixada no Alpine 3.20, pelo que se obtém o mesmo resultado das saídas abaixo.

```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'
```

Saída esperada (o fim da construção e as versões; as versões dos pacotes podem variar ligeiramente):
```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
```

### Passo 3 — Criar as três redes (4 min)
Cada rede do Podman é uma sub-rede: uma bridge com o seu próprio bloco CIDR. `--internal` significa que o Podman não acrescenta rota para o exterior nem NAT para o anfitrião, pelo que nada lá dentro consegue sair, exceto pelo gateway que se vai construir. Duas sub-redes estão dentro do intervalo da VPC `10.30.0.0/16` e não se sobrepõem. A terceira, do intervalo de documentação, representa a 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}}'
```

Saída 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
```

### Passo 4 — Arrancar o gateway (6 min)
O gateway tem uma interface em cada rede, com um endereço fixo: o último utilizável (`.254`) de cada sub-rede, como o endereço do "router" de uma cloud. `interface_name` atribui nomes legíveis às interfaces. `--cap-add NET_ADMIN` permite-lhe editar a sua própria firewall e endereços, e `--sysctl net.ipv4.ip_forward=1` transforma-o num router, como se fez com espaços de nomes no laboratório de encaminhamento. `sleep infinity` mantém-no em execução.

```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
```

Saída esperada (o ID do contentor, a ordem das interfaces, os números `@if` e os endereços `fe80::` variam):
```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 
```

A tabela de rotas do gateway tem apenas as três **rotas diretamente ligadas**, uma por sub-rede: o equivalente da rota local implícita. Não tem rota predefinida e não precisa de nenhuma: está diretamente ligado às três redes.

O gateway precisa também de um segundo endereço público, o "IP elástico" do bastião. Acrescenta-se à interface 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
```

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

### Passo 5 — Lançar as instâncias e dar-lhes rotas (6 min)
Cada instância junta-se a uma sub-rede. Uma rede interna não dá a um contentor nenhuma rota predefinida, como uma sub-rede cuja tabela de rotas está vazia. Cada instância acrescenta uma rota predefinida através do gateway (`ip route add default via ...`): essa é a tabela de rotas da sua sub-rede. `NET_ADMIN` é necessário nos contentores que executam o comando `ip route add`. O servidor web e a "Internet" publicam cada um uma página de uma linha com o `httpd` integrado; `-v` faz com que registe cada ligação no registo do contentor.

```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}}'
```

Saída esperada (primeiro três IDs de contentor; os tempos variam):
```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
```

Agora leem-se as "tabelas de rotas":

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

Saída 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 
```

O anfitrião "Internet" não tem rota predefinida nem rota para os intervalos privados: tal como a Internet real, não sabe nada de `10.30.0.0/16`, porque os endereços da RFC 1918 não são encaminhados aí.

### Passo 6 — Só encaminhamento: tudo aberto (8 min)
Com o reencaminhamento ativo e ainda sem regras de filtragem, o gateway deixa passar tudo entre as duas sub-redes privadas. Testa-se a partir do bastião:

```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=$?"
```

Saída esperada (os tempos do ping variam):
```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
```

Duas lições. O caminho funciona porque a rota do bastião envia `10.30.2.10` para o gateway, que o reencaminha. E nada impede a porta 22: falha apenas porque **nada escuta** aí, e o anfitrião responde de imediato com uma recusa (`rc=7`, "refused"). Convém fixar isto: é o oposto de um tempo limite excedido.

Seguidamente, o servidor web privado tenta alcançar a Internet, e o bastião também:

```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=$?"
```

Saída esperada (os tempos em milissegundos podem variar):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Ambos excedem o tempo limite. Os pedidos chegam ao anfitrião "Internet", mas este não consegue responder: a origem é `10.30.2.10` ou `10.30.1.10`, e o anfitrião da Internet não tem rota para esses intervalos privados. A resposta é descartada em silêncio. É por isso que as sub-redes privadas precisam de NAT.

### Passo 7 — O gateway NAT e o IP elástico (10 min)
Acrescenta-se uma tabela `nat` ao gateway com a firewall do Linux, **nftables**. Uma regra de NAT de origem no hook `postrouting` reescreve o endereço de origem dos pacotes que saem para a "Internet":
- Toda a sub-rede privada é **mascarada** (masquerade) com o endereço do próprio gateway, `198.51.100.254`: NAT de muitos para um, como funciona um gateway NAT. As respostas são traduzidas de volta automaticamente.
- O bastião recebe um endereço público fixo, `198.51.100.50`: um mapeamento um para um, como funciona um IP público ou elástico para uma instância.

As regras escrevem-se num ficheiro. As duas primeiras linhas tornam seguro carregá-lo de novo: criam a tabela se não existir e depois eliminam-na, de modo que cada carregamento começa limpo.

```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 -` lê as regras da entrada padrão, pelo que o ficheiro fica no computador. O carregamento não mostra nada. Saída esperada dos dois pedidos:
```text
hello from the Internet
hello from the Internet
```

Agora ambos funcionam. Veja-se o registo do servidor "Internet", que mostra quem ele julga estar a ligar-se, e a tabela NAT e o acompanhamento de ligações do gateway:

```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 //'"
```

Saída esperada (os números de porta variam):
```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
```

O servidor web registou `198.51.100.254` (o gateway NAT) para a instância privada e `198.51.100.50` (o IP elástico) para o bastião. Nenhum endereço privado chegou a sair. Cada linha de acompanhamento mostra os dois sentidos: o original (`src=10.30.2.10`) e a resposta que o gateway espera (`dst=198.51.100.254`). Essa tabela é como o gateway NAT sabe para onde vai cada resposta, e a razão de ser só de saída. Experimenta-se agora o sentido oposto, da "Internet" para o servidor web privado:

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

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

Falha de imediato: o anfitrião da Internet não tem rota para um endereço privado. Mesmo com uma rota, o gateway NAT não tem entrada de ligação para um fluxo novo de entrada.

### Passo 8 — O grupo de segurança: regras com estado (12 min)
Um grupo de segurança tem estado e só permite. Em nftables obtém-se o mesmo comportamento com o acompanhamento de ligações (`ct state`) e uma política de **descarte predefinido** no hook `forward`, o caminho que o tráfego segue através do gateway. As regras são as do exemplo prático da lição, reduzidas ao que o laboratório precisa:

- A primeira regra aceita os pacotes `established,related`: as respostas de qualquer ligação que tenha sido permitida. Essa linha é a parte "com estado".
- `sg-web` aceita novas ligações para `10.30.2.10` apenas a partir da sub-rede pública, apenas em TCP 8080, mais ping.
- Ambas as sub-redes podem iniciar ligações para a "Internet".
- Tudo o resto chega à última regra, que conta e 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
```

Testa-se. Os três primeiros são permitidos, os dois últimos têm de falhar:

```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
```

Saída esperada (os tempos do ping variam):
```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
```

Compare-se a porta 22 com o Passo 6. Antes da firewall era **recusada** de imediato (`rc=7`): o pacote chegava. Agora **excede o tempo limite** (`rc=28`): o gateway descartou o pacote sem qualquer resposta. E o servidor web privado, que conseguia responder ao bastião, não consegue iniciar uma ligação para ele: nada permite esse sentido.

Veem-se os contadores:

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

Saída esperada (as contagens de pacotes diferem no seu computador):
```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 ligação aceite usou exatamente uma regra "nova", para o seu primeiro pacote (o SYN do TCP ou o pedido de ping). Todos os outros pacotes, nos dois sentidos, corresponderam à linha `established,related`: as respostas não precisaram de regra. A linha `drop` contou os pacotes SYN bloqueados (vários, porque o `curl` repetiu a tentativa) e o ping para o bastião.

> [!NOTE]
> O curl para a porta 22 é repetido enquanto espera, pelo que o contador de descartes sobe mais do que um. Os números exatos dependem do momento.

### Passo 9 — A ACL de rede: regras sem estado e ordenadas (12 min)
Agora um segundo filtro para a **sub-rede privada** `10.30.2.0/24`, na sua própria tabela com uma prioridade anterior (`-10`), de modo que corra antes do grupo de segurança. Um pacote tem de passar por ambos. Esta ACL segue as regras de uma ACL de rede de cloud:

- Nunca usa `ct state`: cada pacote é avaliado isoladamente, pelo que não tem estado.
- As regras estão por ordem e prevalece a primeira correspondência. Os comentários mostram os números de regra "in 100", "out 100", etc.
- Tem permitir e negar, com um `*` final de negar em cada sentido.
- O tráfego de regresso precisa de regras explícitas, com o **intervalo de portas efémeras** `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
```

Atenção à ordem dos acontecimentos dentro do gateway. Os pacotes de saída ainda têm o endereço de origem privado quando o hook `forward` é executado, porque o NAT de origem acontece depois, em `postrouting`. As respostas vindas da Internet já foram traduzidas de volta para o endereço privado quando chegam a `forward`. Assim, a ACL vê sempre os endereços privados, e é por isso que as suas regras mencionam `10.30.2.0/24`.

Repetem-se os testes:

```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=$?"
```

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

Os dois primeiros passam por ambos os filtros. O terceiro vai para o TCP 80 do anfitrião da Internet: o grupo de segurança permite qualquer ligação nova para a Internet, mas a regra de saída 120 da ACL só permite TCP 8000, pelo que a ACL a descarta. Duas camadas, e um pacote precisa de passar por ambas.

### Passo 10 — Sem estado versus com estado: remover a regra de regresso (10 min)
Esta é a experiência da lição. Remove-se a regra "out 100", a que deixa as respostas do servidor web voltar à sub-rede pública. O grupo de segurança continua a ter a sua regra com estado `established,related` e a regra de entrada da ACL continua a deixar passar o pedido. Primeiro procura-se o handle da regra (o seu número dentro do nftables):

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

Saída esperada (os números de handle podem 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
```

Note-se que "out 100" já contou 6 pacotes: as respostas do pedido HTTP do Passo 9. O negar final contou 0. Agora elimina-se a regra usando o seu handle (aqui `6`; use-se o próprio) e repete-se o pedido:

```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"
```

Saída esperada (as contagens variam):
```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"
```

O servidor web recebeu o pedido e respondeu, mas a resposta é um pacote novo para a ACL sem estado, e `out *: deny` descartou-a. O contador de descartes passou de 0 para 4: a primeira resposta e as suas retransmissões. O grupo de segurança, que tem estado, não é o problema: o mesmo pedido funcionava antes. A regra removida era o caminho de regresso em falta. Restaura-se a ACL carregando de novo o ficheiro (recria a tabela com todas as regras) e testa-se:

```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
```

Saída esperada:
```text
hello from the private web tier
```

### Passo 11 — Ordem das regras: prevalece a primeira correspondência (5 min)
Uma ACL é avaliada por ordem. Insere-se uma regra de negar para o bastião **antes** da regra "in 100". O comando `insert` coloca a regra no início da cadeia:

```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=$?"
```

Saída esperada (os números de handle e os contadores podem 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
```

A regra "in 100" continua a permitir TCP 8080 a partir da sub-rede pública, mas a regra de negar vem primeiro, e prevalece a primeira correspondência. Remove-se com o seu handle (aqui `10`; use-se o próprio):

```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
```

Saída esperada:
```text
hello from the private web tier
```

> [!NOTE]
> Um grupo de segurança não tem essa ordem: basta qualquer regra de permitir que corresponda, e não há regras de negar. Essa é uma razão para usar grupos de segurança no controlo de acesso normal e ACL apenas para bloqueios grosseiros.

### Passo 12 — Quebrar e corrigir uma rota e uma regra NAT (8 min)
Diagnosticar é ler sintomas. Provocam-se duas falhas e comparam-se com os tempos limite excedidos já vistos. Primeiro, elimina-se a rota predefinida do servidor web privado, como se a sua tabela de rotas tivesse perdido a rota para o gateway:

```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=$?"
```

Saída 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
```

A falha é **imediata** e `ip route get` diz "Network unreachable": nenhuma rota corresponde, pelo que o pacote nunca sai da instância. Essa é a assinatura de um problema de encaminhamento, não de um filtro. Corrige-se e testa-se de novo:

```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
```

Saída esperada:
```text
hello from the Internet
```

Agora a segunda falha: esvazia-se a tabela NAT, como se o gateway NAT tivesse desaparecido ou a sua regra tivesse sido removida. Depois veem-se os contadores dos filtros, que mostram que os pacotes saíram de facto:

```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"
```

Saída esperada (o contador varia):
```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"
```

Desta vez o sintoma é um **tempo limite excedido**, como um descarte de filtro. Mas os filtros aceitaram os pacotes (o contador "private out" subiu), e nem o grupo de segurança nem a ACL descartaram nada de novo. Os pacotes saíram com o endereço de origem privado e a resposta não conseguiu voltar: a mesma falha do Passo 6. Este é o método da lição: um tempo limite excedido significa um descarte silencioso; verificam-se os contadores dos filtros e, se estes aceitarem o pacote, verifica-se o caminho de regresso e o NAT. Corrige-se carregando de novo o ficheiro 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
```

Saída esperada:
```text
hello from the Internet
```

### Passo 13 — Ler os contadores de descartes (4 min)
Cada regra de filtragem tem um contador. Quando um fluxo não funciona, a forma mais rápida de encontrar a camada é perguntar que regra de descarte está a contar. Listam-se todas as regras de descarte com comentário:

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

Saída esperada (as contagens dependem do que foi feito, e são mais altas se o script de verificação tiver sido executado antes):
```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"
```

Os descartes da ACL (`in *` e `out *`) contaram pacotes, mas o `default deny` do grupo de segurança mostra aqui 0. Isso deve-se a que a ACL corre primeiro (prioridade `-10`) e descartou esses pacotes antes de o grupo de segurança os ver. Uma regra que conta pacotes correspondeu. Uma regra de descarte que conta é a que está a bloquear. Uma regra que fica em 0 não é a que se aplica.

## Verificação
Guarda-se este script e executa-se. Testa seis comportamentos e imprime PASS ou FAIL para cada um:

```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
```

Saída 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
```

Os seis têm de passar. O script demora cerca de 10 segundos, porque as três verificações "fail" esperam por um tempo limite.

## Resolução de problemas
| Sintoma | Causa provável | Correção |
|---|---|---|
| `podman network create` falha com "subnet already used" ou semelhante | Outra rede do Podman ou uma tentativa anterior usa o mesmo intervalo | Executar `podman network ls`, remover as redes `lab-vnet-` antigas com a [Limpeza](#limpeza) ou escolher outro intervalo livre |
| `unknown flag` ou `interface_name` é rejeitado no Passo 4 | Podman anterior à versão 4.x, ou o backend CNI em vez de netavark | Verificar `podman --version` e `podman info --format '{{.Host.NetworkBackend}}'`; usar Podman 4+ com netavark |
| `nft` mostra `Operation not permitted` | O gateway foi iniciado sem `--cap-add NET_ADMIN` | Removê-lo com `podman rm -f -t 0 lab-vnet-gw` e executar de novo o Passo 4 |
| Tudo excede o tempo limite, mesmo o primeiro teste do Passo 6 | O reencaminhamento IP está desligado no gateway, ou uma instância não tem rota predefinida | `podman exec lab-vnet-gw sysctl net.ipv4.ip_forward` tem de mostrar `1`; verificar `ip route` na instância |
| `podman build` não consegue descarregar pacotes | Sem acesso à Internet ou com um proxy | A construção precisa da Internet uma vez; configurar o proxy para o Podman ou construir num computador ligado |
| `curl` num contentor diz `Could not resolve host` | Foi usado um nome em vez de um endereço | O laboratório não tem DNS: usar sempre os endereços IP da tabela |
| Um passo funciona mas os contadores ficam em 0 | O pacote correspondeu a uma regra anterior, ou passa por outra tabela | Ler a cadeia a partir do topo: as regras aplicam-se por ordem; o primeiro `accept` ou `drop` termina-a para essa tabela |
| `Error: No such file or directory` ao carregar um ficheiro com `nft -f -` | O comando foi executado fora de `~/vnet-lab`, pelo que a shell não encontra o ficheiro `.nft` | `cd ~/vnet-lab` e executar de novo |
| Os contentores demoram a parar | `sleep infinity` ignora o sinal de paragem cortês | Usar `podman rm -f -t 0 ...` como na Limpeza |

## Desafio (opcional)
Tornar o bastião acessível **a partir da Internet** no seu IP elástico, como uma instância pública. Arranca-se um segundo servidor web no bastião (`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'`) e faz-se com que `podman exec lab-vnet-internet curl -sS -m 3 http://198.51.100.50:8081` mostre a sua página. São necessárias três coisas, e cada uma é um conceito da lição:
1. Uma regra de **NAT de destino** que traduza `198.51.100.50` porta 8081 para `10.30.1.10`. Usar uma nova cadeia em `lab_nat` com `type nat hook prerouting priority dstnat; policy accept;`.
2. Uma regra em `lab_sg` que permita a nova ligação para `10.30.1.10` em TCP 8081. Tem de vir antes do `drop` final: usar `nft insert rule` para a colocar no topo.
3. Um olhar aos contadores de pacotes, para ver se a tradução e o filtro corresponderam ambos.

Depois, verificar que o servidor web privado continua inacessível a partir da Internet. Porque é que o é, apesar de se usar o mesmo gateway?

## Limpeza
Isto remove todos os contentores, redes e imagens do laboratório, e a pasta de trabalho. A opção `-t 0` dispensa a espera de paragem.

```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
```

Verifica-se que não restou nada. Os três comandos não devem 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` remove apenas a imagem construída. A imagem base do Alpine descarregada fica na cache, e outros contentores podem usá-la. Para a remover, executar `podman rmi docker.io/library/alpine:3.20.10`.

## O que aprendeu
- Uma VPC é um conjunto de sub-redes ligadas por um router; uma sub-rede é pública ou privada pelas suas rotas e pelas regras do seu gateway, não pelo seu intervalo de endereços.
- Um gateway NAT reescreve a origem das ligações de saída e acompanha-as, de modo que as respostas regressam e nada de novo pode entrar; um IP público ou elástico é um mapeamento um para um.
- Um grupo de segurança com estado só precisa da regra que inicia a ligação; uma ACL sem estado precisa de regras para os dois sentidos, incluindo as portas efémeras.
- As regras de uma ACL são ordenadas e prevalece a primeira correspondência; as regras de um grupo de segurança não são ordenadas.
- "Network unreachable" significa encaminhamento, "refused" significa que o anfitrião respondeu, e um "timeout" é um descarte silencioso que pode vir de um filtro, de um caminho de regresso em falta ou da falta de NAT.
- Os contadores indicam que regra viu o pacote.
