---
title: "Laboratório: conceber e validar um plano de endereçamento"
domain: networking
level: intermediate
duration: "60 min"
cost: "gratuito"
environment: "máquina local com Python 3 (qualquer sistema operativo); opcional: máquina Linux ou VM com sudo para o Passo 8"
lang: pt
source_hash: 65c96f2cb08f
---

# Laboratório: conceber e validar um plano de endereçamento

## Objetivo
Concebe-se o plano de endereçamento IPv4 de uma empresa fictícia com três sedes, usando VLSM dentro do bloco privado `10.20.0.0/16`. Depois, o plano é verificado com um pequeno script em Python que deteta sobreposições, sub-redes subdimensionadas e prefixos desalinhados, e corrige-se um plano com erros.

## Objetivos
- Dimensionar cada segmento de rede com o prefixo mais longo que cubra o seu número de hosts.
- Atribuir um plano VLSM por sede, da sub-rede maior para a menor, em limites alinhados.
- Escolher um bloco por sede de modo que cada sede possa ser anunciada como uma única rota sumária.
- Validar um plano automaticamente (contenção, sobreposições, capacidade, espaço livre) e corrigir as falhas encontradas.
- (Opcional) Observar em Linux como uma máscara de sub-rede errada compromete a acessibilidade.

## Pré-requisitos
- Python 3.8 ou posterior (usa-se apenas a biblioteca padrão). Verifique com `python3 --version`; no Windows, use `py` em vez de `python3`.
- Um editor de texto e um terminal.
- A [lição](lesson.pt.md) deste módulo, sobretudo VLSM e a sumarização de rotas.
- Apenas para o Passo 8 opcional: uma máquina Linux ou VM onde seja possível usar `sudo`, com iproute2 (`ip`) e `ping` instalados.

> [!WARNING]
> Os Passos 1–7 apenas criam ficheiros numa pasta do diretório pessoal. O Passo 8 cria namespaces de rede e necessita de `sudo`: execute-o numa máquina de testes ou numa VM, não num servidor de produção. Usa o intervalo de documentação `198.51.100.0/24` (RFC 5737) e não toca nas interfaces de rede reais. Execute sempre a secção de [Limpeza](#limpeza) no fim.

## Arquitetura
A Example Corp tem uma sede (HQ) e duas filiais (BR1, BR2), ligadas por ligações WAN ponto a ponto. Possui o bloco RFC 1918 `10.20.0.0/16` para todo o seu endereçamento interno.

![Example Corp: a sede HQ com os segmentos Colaboradores, Voz, Visitas, Servidores e Gestão, as filiais BR1 e BR2 com os seus segmentos, unidas por ligações WAN /31, com BR1 a BR2 como reserva](../../../assets/diagrams/subnetting-lab-sites.pt.svg)

*Figura 1. As sedes da Example Corp e os segmentos de que cada uma precisa. As três ligações WAN são redes ponto a ponto /31.*

Os requisitos, em hosts necessários hoje, incluindo o crescimento:

| Local | Segmento | Hosts |
|---|---|---|
| HQ | Staff (colaboradores) | 900 |
| HQ | Voice (voz) | 400 |
| HQ | Guest (visitas) | 250 |
| HQ | Servers (servidores) | 200 |
| HQ | Management (gestão) | 40 |
| BR1 | Staff | 120 |
| BR1 | Voice | 60 |
| BR1 | Guest | 50 |
| BR1 | Management | 10 |
| BR2 | Staff | 55 |
| BR2 | Voice | 25 |
| BR2 | Management | 6 |
| WAN | HQ-BR1, HQ-BR2, BR1-BR2 | 2 cada |

Regras de conceção:
1. Cada sede recebe **um bloco alinhado**, para que o resto da rede lhe possa chegar com uma única rota sumária.
2. Todas as ligações WAN saem de um bloco de infraestrutura, `10.20.255.0/24`, e usam prefixos /31 (RFC 3021).
3. Dentro de cada sede, os segmentos são atribuídos do maior para o menor, a começar no início do bloco da sede.

## Passos

### Passo 1 — Criar um espaço de trabalho
Mantenha todos os ficheiros deste laboratório numa só pasta, para que a limpeza seja um único comando.

```bash
mkdir -p ~/subnet-lab
cd ~/subnet-lab
python3 --version
```

Resultado esperado (serve qualquer versão a partir da 3.8):
```text
Python 3.14.7
```

### Passo 2 — Dimensionar cada segmento
Antes de mexer em qualquer endereço, decida o comprimento do prefixo de cada segmento. Use a tabela de potências de dois da lição: encontre o prefixo mais longo cujos hosts utilizáveis (2<sup>bits de host</sup> − 2) cubram a necessidade.

Preencha esta tabela em papel ou num ficheiro de texto:

| Local | Segmento | Hosts | Prefixo | Dimensão do bloco |
|---|---|---|---|---|
| HQ | Staff | 900 | ? | ? |
| HQ | Voice | 400 | ? | ? |
| … | … | … | … | … |

<details>
<summary>Mostrar as dimensões</summary>

| Local | Segmento | Hosts | Prefixo | Utilizáveis | Dimensão do bloco |
|---|---|---|---|---|---|
| HQ | Staff | 900 | /22 | 1022 | 1024 |
| HQ | Voice | 400 | /23 | 510 | 512 |
| HQ | Guest | 250 | /24 | 254 | 256 |
| HQ | Servers | 200 | /24 | 254 | 256 |
| HQ | Management | 40 | /26 | 62 | 64 |
| BR1 | Staff | 120 | /25 | 126 | 128 |
| BR1 | Voice | 60 | /26 | 62 | 64 |
| BR1 | Guest | 50 | /26 | 62 | 64 |
| BR1 | Management | 10 | /28 | 14 | 16 |
| BR2 | Staff | 55 | /26 | 62 | 64 |
| BR2 | Voice | 25 | /27 | 30 | 32 |
| BR2 | Management | 6 | /29 | 6 | 8 |
| WAN | cada ligação | 2 | /31 | 2 | 2 |

</details>

### Passo 3 — Escolher um bloco por sede
Some as dimensões dos blocos de cada sede e arredonde para a potência de dois seguinte. Esse é o menor bloco que contém toda a sede e que ainda pode ser sumarizado numa só rota.

- HQ: 1024 + 512 + 256 + 256 + 64 = 2112 endereços. A potência de dois seguinte é 4096, um **/20**.
- BR1: 128 + 64 + 64 + 16 = 272 endereços. A potência de dois seguinte é 512, um **/23**.
- BR2: 64 + 32 + 8 = 104 endereços. O mínimo é um /25 (128). Esta conceção arredonda-o para um **/24** para deixar margem de crescimento.

Coloquem-se também os blocos das sedes do maior para o menor, cada um no seu próprio limite. Uma escolha válida:

| Local | Bloco | Porque é válido |
|---|---|---|
| HQ | `10.20.0.0/20` | Começa em 0, múltiplo de 16 no terceiro octeto. |
| BR1 | `10.20.16.0/23` | 16 é múltiplo de 2. |
| BR2 | `10.20.18.0/24` | Segue diretamente a BR1. |
| WAN | `10.20.255.0/24` | Definido pelas regras de conceção; longe das sedes para que possam crescer. |

> [!TIP]
> Se preferir outros blocos de sede, não há problema, desde que cada um esteja alinhado e que não se sobreponham. O resultado do Passo 6 será então diferente do apresentado, mas deve continuar a terminar em `PASS`.

### Passo 4 — Atribuir os segmentos e escrever o plano
Agora coloquem-se os segmentos dentro de cada bloco de sede, do maior para o menor. Em HQ, Staff (/22) começa em `10.20.0.0`, pelo que termina em `10.20.3.255`. Voice (/23) começa no endereço seguinte, `10.20.4.0`, e assim sucessivamente.

Escreva o plano como um ficheiro de valores separados por vírgulas (CSV, comma-separated values) chamado `plan.csv`, com uma linha por segmento e uma linha `BLOCK` por sede:

```text
site,segment,prefix,hosts
HQ,BLOCK,10.20.0.0/20,
HQ,Staff,10.20.0.0/22,900
...
```

As colunas são:
- `site`: o nome da sede (`HQ`, `BR1`, `BR2` ou `WAN`).
- `segment`: o nome do segmento, ou `BLOCK` para o bloco sumário da sede.
- `prefix`: a rede em notação CIDR.
- `hosts`: hosts necessários (deixe vazio nas linhas `BLOCK`).

Tente primeiro sozinho e depois compare com o plano de referência.

<details>
<summary>Mostrar o plano de referência</summary>

```bash
cat > plan.csv <<'EOF'
site,segment,prefix,hosts
HQ,BLOCK,10.20.0.0/20,
HQ,Staff,10.20.0.0/22,900
HQ,Voice,10.20.4.0/23,400
HQ,Guest,10.20.6.0/24,250
HQ,Servers,10.20.7.0/24,200
HQ,Management,10.20.8.0/26,40
BR1,BLOCK,10.20.16.0/23,
BR1,Staff,10.20.16.0/25,120
BR1,Voice,10.20.16.128/26,60
BR1,Guest,10.20.16.192/26,50
BR1,Management,10.20.17.0/28,10
BR2,BLOCK,10.20.18.0/24,
BR2,Staff,10.20.18.0/26,55
BR2,Voice,10.20.18.64/27,25
BR2,Management,10.20.18.96/29,6
WAN,BLOCK,10.20.255.0/24,
WAN,HQ-BR1,10.20.255.0/31,2
WAN,HQ-BR2,10.20.255.2/31,2
WAN,BR1-BR2,10.20.255.4/31,2
EOF
```

</details>

### Passo 5 — Criar o validador
Verificar um plano à mão é lento e sujeito a erros. Este script usa o módulo `ipaddress` da biblioteca padrão do Python para verificar todas as regras da lição:

- cada prefixo é um endereço de rede real (sem bits de host ativos, ou seja, está alinhado),
- tudo está dentro de `10.20.0.0/16`, e cada segmento está dentro do bloco da sua sede,
- os blocos de sede não se sobrepõem, e os segmentos não se sobrepõem,
- cada segmento tem endereços utilizáveis suficientes (/31 = 2, /32 = 1, caso contrário dimensão do bloco − 2).

Também imprime o plano como uma tabela com a máscara, o intervalo de hosts e os endereços livres de cada segmento.

```bash
cat > validate_plan.py <<'EOF'
#!/usr/bin/env python3
"""Validate an IPv4 addressing plan stored in a CSV file (site,segment,prefix,hosts)."""
import csv
import ipaddress
import sys

TOP_BLOCK = ipaddress.ip_network("10.20.0.0/16")


def usable(net):
    """Usable host addresses: /32 = 1, /31 = 2 (RFC 3021), otherwise all minus network and broadcast."""
    if net.prefixlen == 32:
        return 1
    if net.prefixlen == 31:
        return 2
    return net.num_addresses - 2


def host_range(net):
    if net.prefixlen >= 31:
        return f"{net[0]} - {net[-1]}"
    return f"{net[1]} - {net[-2]}"


def main(path):
    errors = []
    sites, segments = {}, []
    with open(path, newline="") as f:
        for row in csv.DictReader(f):
            site, name, prefix = row["site"].strip(), row["segment"].strip(), row["prefix"].strip()
            try:
                net = ipaddress.ip_network(prefix)  # strict: host bits must be zero
            except ValueError:
                fixed = ipaddress.ip_network(prefix, strict=False)
                errors.append(f"{site}/{name}: {prefix} is not a network address (did you mean {fixed}?)")
                continue
            if not net.subnet_of(TOP_BLOCK):
                errors.append(f"{site}/{name}: {net} is outside {TOP_BLOCK}")
            if name == "BLOCK":
                sites[site] = net
            else:
                segments.append((site, name, net, int(row["hosts"])))

    # Site blocks must not overlap each other.
    names = sorted(sites)
    for i, a in enumerate(names):
        for b in names[i + 1:]:
            if sites[a].overlaps(sites[b]):
                errors.append(f"site blocks overlap: {a} {sites[a]} and {b} {sites[b]}")

    print(f"{'Site':<6} {'Segment':<12} {'Prefix':<17} {'Mask':<16} {'Host range':<29} {'Usable':>6} {'Need':>5} {'Spare':>6}")
    total_need = total_alloc = 0
    for site, name, net, need in sorted(segments, key=lambda s: s[2]):
        spare = usable(net) - need
        total_need += need
        total_alloc += net.num_addresses
        print(f"{site:<6} {name:<12} {str(net):<17} {str(net.netmask):<16} {host_range(net):<29} {usable(net):>6} {need:>5} {spare:>6}")
        if spare < 0:
            errors.append(f"{site}/{name}: {net} has {usable(net)} usable addresses but needs {need}")
        if site not in sites:
            errors.append(f"{site}/{name}: site {site} has no BLOCK row")
        elif not net.subnet_of(sites[site]):
            errors.append(f"{site}/{name}: {net} is outside its site block {sites[site]}")

    # No two segments may overlap.
    for i, (s1, n1, a, _) in enumerate(segments):
        for s2, n2, b, _ in segments[i + 1:]:
            if a.overlaps(b):
                errors.append(f"overlap: {s1}/{n1} {a} and {s2}/{n2} {b}")

    print()
    print(f"Addresses allocated to segments: {total_alloc} of {TOP_BLOCK.num_addresses} in {TOP_BLOCK}")
    print(f"Hosts required: {total_need}; spare addresses inside segments: {total_alloc - total_need}")
    print("Summary routes (one per site):", ", ".join(f"{s} {sites[s]}" for s in names))
    print()
    if errors:
        print(f"FAIL: {len(errors)} problem(s)")
        for err in errors:
            print("  -", err)
        return 1
    print("PASS: no overlaps, every segment fits its site block and its host count")
    return 0


if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit("usage: python3 validate_plan.py <plan.csv>")
    sys.exit(main(sys.argv[1]))
EOF
```

> [!NOTE]
> «Endereços livres dentro dos segmentos» (`Spare`) conta todos os endereços das sub-redes atribuídas que não são hosts necessários, incluindo os endereços de rede e de broadcast. Mede a margem de crescimento (ou o desperdício) do plano, não quantos hosts ainda se podem acrescentar.

### Passo 6 — Validar o plano
Execute o validador sobre o plano:

```bash
python3 validate_plan.py plan.csv
```

Resultado esperado para o plano de referência:
```text
Site   Segment      Prefix            Mask             Host range                    Usable  Need  Spare
HQ     Staff        10.20.0.0/22      255.255.252.0    10.20.0.1 - 10.20.3.254         1022   900    122
HQ     Voice        10.20.4.0/23      255.255.254.0    10.20.4.1 - 10.20.5.254          510   400    110
HQ     Guest        10.20.6.0/24      255.255.255.0    10.20.6.1 - 10.20.6.254          254   250      4
HQ     Servers      10.20.7.0/24      255.255.255.0    10.20.7.1 - 10.20.7.254          254   200     54
HQ     Management   10.20.8.0/26      255.255.255.192  10.20.8.1 - 10.20.8.62            62    40     22
BR1    Staff        10.20.16.0/25     255.255.255.128  10.20.16.1 - 10.20.16.126        126   120      6
BR1    Voice        10.20.16.128/26   255.255.255.192  10.20.16.129 - 10.20.16.190       62    60      2
BR1    Guest        10.20.16.192/26   255.255.255.192  10.20.16.193 - 10.20.16.254       62    50     12
BR1    Management   10.20.17.0/28     255.255.255.240  10.20.17.1 - 10.20.17.14          14    10      4
BR2    Staff        10.20.18.0/26     255.255.255.192  10.20.18.1 - 10.20.18.62          62    55      7
BR2    Voice        10.20.18.64/27    255.255.255.224  10.20.18.65 - 10.20.18.94         30    25      5
BR2    Management   10.20.18.96/29    255.255.255.248  10.20.18.97 - 10.20.18.102         6     6      0
WAN    HQ-BR1       10.20.255.0/31    255.255.255.254  10.20.255.0 - 10.20.255.1          2     2      0
WAN    HQ-BR2       10.20.255.2/31    255.255.255.254  10.20.255.2 - 10.20.255.3          2     2      0
WAN    BR1-BR2      10.20.255.4/31    255.255.255.254  10.20.255.4 - 10.20.255.5          2     2      0

Addresses allocated to segments: 2494 of 65536 in 10.20.0.0/16
Hosts required: 2122; spare addresses inside segments: 372
Summary routes (one per site): BR1 10.20.16.0/23, BR2 10.20.18.0/24, HQ 10.20.0.0/20, WAN 10.20.255.0/24

PASS: no overlaps, every segment fits its site block and its host count
```

Leia o resultado como o faria um revisor:
- **Rotas sumárias.** O resto da rede só precisa de quatro rotas para chegar a todas as sub-redes da Example Corp.
- **Coluna Spare.** BR2 Management tem 0 endereços livres: o sétimo dispositivo obrigará a renumerar. Num projeto real, provavelmente atribuir-se-ia um /28. Há espaço livre logo a seguir em `10.20.18.0/24`.
- **Margem de crescimento.** HQ usa 2112 dos 4096 endereços do seu /20, pelo que de `10.20.8.64` a `10.20.15.255` continua livre para novos segmentos de HQ.

### Passo 7 — Encontrar e corrigir as falhas de um plano com erros
Um colega enviou este plano. Tem várias das falhas da lição. Guarde-o e execute o validador:

```bash
cat > broken.csv <<'EOF'
site,segment,prefix,hosts
HQ,BLOCK,10.20.0.0/20,
HQ,Staff,10.20.0.0/22,900
HQ,Voice,10.20.4.0/24,400
HQ,Guest,10.20.6.0/23,250
HQ,Servers,10.20.7.0/24,200
HQ,Management,10.20.8.0/26,40
BR1,BLOCK,10.20.16.0/23,
BR1,Staff,10.20.16.0/25,120
BR1,Voice,10.20.16.128/26,60
BR1,Guest,10.20.16.192/26,50
BR1,Management,10.20.18.0/28,10
BR2,BLOCK,10.20.18.0/24,
BR2,Staff,10.20.18.0/26,55
BR2,Voice,10.20.18.70/27,25
BR2,Management,10.20.18.96/29,6
WAN,BLOCK,10.20.255.0/24,
WAN,HQ-BR1,10.20.255.0/31,2
WAN,HQ-BR2,10.20.255.2/31,2
WAN,BR1-BR2,10.20.255.4/31,2
EOF
python3 validate_plan.py broken.csv
echo "exit code: $?"
```

Resultado esperado (o final):
```text
FAIL: 5 problem(s)
  - BR2/Voice: 10.20.18.70/27 is not a network address (did you mean 10.20.18.64/27?)
  - HQ/Voice: 10.20.4.0/24 has 254 usable addresses but needs 400
  - BR1/Management: 10.20.18.0/28 is outside its site block 10.20.16.0/23
  - overlap: HQ/Guest 10.20.6.0/23 and HQ/Servers 10.20.7.0/24
  - overlap: BR1/Management 10.20.18.0/28 and BR2/Staff 10.20.18.0/26
exit code: 1
```

Copie o ficheiro (`cp broken.csv fixed.csv`), edite `fixed.csv` até `python3 validate_plan.py fixed.csv` imprimir `PASS` e, para cada falha, anote que regra da lição infringe. Altere o menor número de linhas possível.

> [!TIP]
> Cinco mensagens nem sempre significam cinco falhas. Uma linha errada pode quebrar duas regras ao mesmo tempo.

<details>
<summary>Mostrar as correções</summary>

Há quatro linhas erradas:

| Linha | Falha | Correção |
|---|---|---|
| `HQ,Voice,10.20.4.0/24,400` | Subdimensionada: um /24 tem 254 hosts utilizáveis e são precisos 400. | `10.20.4.0/23` |
| `HQ,Guest,10.20.6.0/23,250` | Sobredimensionada: o /23 cobre `10.20.6.0`–`10.20.7.255` e sobrepõe-se a Servers. | `10.20.6.0/24` |
| `BR1,Management,10.20.18.0/28,10` | Fora do bloco de BR1 (está no de BR2), pelo que se sobrepõe a BR2 Staff e quebra a rota sumária de BR1. | `10.20.17.0/28` |
| `BR2,Voice,10.20.18.70/27,25` | Não alinhada: 70 não é múltiplo de 32. | `10.20.18.64/27` |

Depois destas quatro alterações, `fixed.csv` é idêntico ao `plan.csv` de referência, e pode verificá-lo com:

```bash
diff fixed.csv plan.csv && echo "identical"
```

</details>

### Passo 8 (opcional, Linux, requer sudo) — Ver como uma máscara errada compromete a acessibilidade
O validador deteta erros no papel. Este passo mostra o aspeto do mesmo erro numa rede real. Criam-se dois **namespaces de rede** (pilhas de rede isoladas numa mesma máquina Linux), ligam-se com um cabo Ethernet virtual (veth) e atribui-se a um dos lados uma máscara errada.

Ambos os hosts deviam estar em `198.51.100.0/26`. O host B recebe `/28` por engano, pelo que julga que a sua sub-rede é `198.51.100.32/28` (`.33`–`.46`).

![Dois namespaces de rede unidos por um par veth: lab-a com 198.51.100.10/26 e lab-b com 198.51.100.40/28. Uma régua de .0 a .63 mostra que A considera local de .0 a .63, enquanto B considera local apenas de .32 a .47, pelo que o endereço .10 de A fica fora da sub-rede de B](../../../assets/diagrams/subnetting-lab-netns.pt.svg)

*Figura 2. O mesmo cabo, duas visões diferentes da sub-rede. A consegue chegar a B, mas B trata o endereço de A como remoto e não tem rota para responder.*

Crie os namespaces, o cabo e os endereços:

```bash
sudo ip netns add lab-a
sudo ip netns add lab-b
sudo ip link add veth-a type veth peer name veth-b
sudo ip link set veth-a netns lab-a
sudo ip link set veth-b netns lab-b
sudo ip -n lab-a addr add 198.51.100.10/26 dev veth-a
sudo ip -n lab-b addr add 198.51.100.40/28 dev veth-b
sudo ip -n lab-a link set veth-a up
sudo ip -n lab-b link set veth-b up
sudo ip -n lab-b route
```

Resultado esperado (a tabela de rotas de `lab-b`):
```text
198.51.100.32/28 dev veth-b proto kernel scope link src 198.51.100.40
```

O host B só considera local `198.51.100.32/28`. `198.51.100.10` fica fora, e B não tem nenhuma outra rota.

Faça ping nos dois sentidos:

```bash
sudo ip netns exec lab-a ping -c 2 198.51.100.40
sudo ip netns exec lab-b ping -c 2 198.51.100.10
```

Resultado esperado (os tempos variam):
```text
PING 198.51.100.40 (198.51.100.40) 56(84) bytes of data.
From 198.51.100.10 icmp_seq=1 Destination Host Unreachable
From 198.51.100.10 icmp_seq=2 Destination Host Unreachable

--- 198.51.100.40 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1026ms
pipe 2
ping: connect: Network is unreachable
```

Os dois lados falham de forma diferente:
- **A partir de A**, `.40` parece local (a máscara de A está correta), pelo que A envia um pedido ARP. B não responde, porque não tem rota de regresso para `198.51.100.10`. Sem resposta ARP, A indica `Destination Host Unreachable`.
- **A partir de B**, `.10` fica fora do seu `/28` e não há rota predefinida, pelo que o kernel se recusa a enviar fosse o que fosse: `Network is unreachable`.

Agora tente dar a B um gateway predefinido que esteja fora da sua sub-rede (errada):

```bash
sudo ip -n lab-b route add default via 198.51.100.1
```

Resultado esperado:
```text
Error: Nexthop has invalid gateway.
```

O Linux recusa um gateway que não está numa sub-rede diretamente ligada. É a falha do «gateway fora da sub-rede» da lição.

Corrija a máscara e teste de novo:

```bash
sudo ip -n lab-b addr del 198.51.100.40/28 dev veth-b
sudo ip -n lab-b addr add 198.51.100.40/26 dev veth-b
sudo ip netns exec lab-a ping -c 2 198.51.100.40
```

Resultado esperado (os tempos variam):
```text
PING 198.51.100.40 (198.51.100.40) 56(84) bytes of data.
64 bytes from 198.51.100.40: icmp_seq=1 ttl=64 time=0.040 ms
64 bytes from 198.51.100.40: icmp_seq=2 ttl=64 time=0.047 ms

--- 198.51.100.40 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1034ms
rtt min/avg/max/mdev = 0.040/0.043/0.047/0.003 ms
```

> [!NOTE]
> Os resultados acima provêm de iproute2 6.17 e iputils 20250605. Outras versões redigem as mensagens de forma ligeiramente diferente, e uma configuração regional que não seja inglês traduz-as; execute os comandos com `LC_ALL=C` para obter o resultado em inglês. O comportamento do encaminhamento é o mesmo.

## Verificação
O laboratório está concluído quando:

1. O seu próprio plano passa:
   ```bash
   python3 validate_plan.py plan.csv; echo "exit code: $?"
   ```
   O resultado termina com `PASS: ...` e `exit code: 0`.
2. A sua versão corrigida do plano com erros passa:
   ```bash
   python3 validate_plan.py fixed.csv; echo "exit code: $?"
   ```
   O resultado termina com `PASS: ...` e `exit code: 0`.
3. Sabe indicar a regra da lição por trás de cada uma das quatro falhas do Passo 7.
4. (Passo 8 opcional) Com a máscara corrigida, `sudo ip netns exec lab-a ping -c 2 198.51.100.40` mostra `0% packet loss`.

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| `KeyError: 'segment'` (ou `'site'`, `'prefix'`, `'hosts'`) | A linha de cabeçalho do CSV falta ou está mal escrita. | Faça com que a primeira linha seja exatamente `site,segment,prefix,hosts`. |
| `ValueError: invalid literal for int() with base 10: ''` | Uma linha de segmento tem a coluna `hosts` vazia. | Apenas as linhas `BLOCK` podem deixar `hosts` vazio. |
| `... is not a network address (did you mean ...?)` | O prefixo tem bits de host ativos: não começa no seu próprio limite. | Use a rede sugerida e volte a verificar que não se sobrepõe a uma vizinha. |
| `... is outside its site block ...` | Um segmento foi colocado no bloco de outra sede, ou o bloco da sede é demasiado pequeno. | Mova o segmento para o seu próprio bloco, ou escolha um bloco de sede alinhado maior. |
| `RTNETLINK answers: Operation not permitted` | Executou sem `sudo` um comando `ip` que altera a rede. | Anteponha `sudo` ao comando. |
| `Cannot open network namespace "lab-a": No such file or directory` | O namespace não existe (um passo foi saltado ou a limpeza já foi executada). | Execute `ip netns list` e repita os comandos de criação do Passo 8. |
| `File exists` ao criar um namespace ou o par veth | Restos de uma tentativa anterior. | Execute os comandos de [Limpeza](#limpeza) e recomece o Passo 8. |

## Desafio (opcional)
A Example Corp abre uma terceira filial, BR3, com Staff (200 hosts), Voice (100) e Management (10), mais uma ligação WAN a HQ. Acrescente-a ao plano sem renumerar nada. Depois, torne o plano ainda mais arrumado: escolha o bloco de BR3 de modo que **todas as filiais** em conjunto (BR1, BR2 e BR3) possam ser anunciadas a HQ como uma única rota sumária. Qual é essa rota e que margem deixa para futuras filiais? Confirme com o validador.

## Limpeza
Remova os ficheiros do laboratório:

```bash
cd ~
rm -r ~/subnet-lab
```

Se realizou o Passo 8, elimine os dois namespaces. Eliminar um namespace elimina também a interface veth que contém, e eliminar uma extremidade de um par veth elimina a outra.

```bash
sudo ip netns del lab-a
sudo ip netns del lab-b
ip netns list
```

Resultado esperado: `ip netns list` não imprime nada (ou não lista `lab-a` nem `lab-b`).

## O que aprendeu
- Primeiro dimensionar e depois colocar: o prefixo de cada segmento resulta do seu número de hosts, e o bloco de cada sede da soma dos seus segmentos, arredondada para uma potência de dois.
- Atribuir do maior para o menor em limites alinhados empacota as sub-redes sem lacunas e mantém cada sede sumarizável numa só rota.
- As sobreposições, as sub-redes subdimensionadas e os prefixos desalinhados são fáceis de ignorar à vista e fáceis de detetar com um script.
- Num host real, uma máscara errada compromete a acessibilidade de forma assimétrica, e o Linux recusa um gateway predefinido fora da sub-rede do host.
