---
title: "Laboratório: três routers com rotas estáticas e, depois, OSPF"
domain: networking
level: intermediate
duration: "75 min"
cost: "gratuito"
environment: "máquina Linux local ou VM com sudo (espaços de nomes de rede); parte opcional com contentores Podman ou Docker"
lang: pt
source_hash: efae97614681
---

# Laboratório: três routers com rotas estáticas e, depois, OSPF

## Objetivo
Constrói-se numa única máquina Linux a rede do [exemplo prático](lesson.pt.md#exemplo-prático) da lição: dois anfitriões e três routers em linha, cada um um espaço de nomes de rede. Faz-se funcionar com rotas estáticas e predefinidas, estraga-se de formas realistas e diagnostica-se com `ping`, `ip route get` e `traceroute`. Numa parte opcional, as rotas estáticas são substituídas por OSPF a correr em contentores FRRouting.

## Objetivos
- Transformar um espaço de nomes de rede do Linux num router ao ativar o encaminhamento IP.
- Configurar rotas estáticas e predefinidas para que o tráfego funcione nos dois sentidos.
- Diagnosticar uma rota de retorno em falta, uma rota de ida em falta e um salto de traceroute sem resposta com `ip route get` e `traceroute`.
- Observar a correspondência do prefixo mais longo a escolher entre uma rota predefinida, uma `/24` e uma `/32`.
- (Opcional) Executar OSPF entre três routers FRRouting, ler os vizinhos e as rotas que constrói, e observar como reage à falha de uma ligação.

## Pré-requisitos
- Uma máquina Linux ou VM onde seja possível usar `sudo`. O laboratório foi testado em Fedora com o kernel 7.2.
- iproute2 (o comando `ip`), 5.0 ou posterior. Verifica-se com `ip -V` (testado com 6.17).
- `ping` (iputils) e `traceroute` (testado com "Modern traceroute for Linux" 2.1.6). Se faltar o `traceroute`, instala-se com `sudo dnf install traceroute` ou `sudo apt install traceroute`.
- A [lição](lesson.pt.md) deste módulo e [06 — Subnetting](../06-subnetting/README.pt.md) para os prefixos.
- Apenas para a parte opcional: Podman 4 ou posterior (testado com 5.8) ou Docker 24 ou posterior, e acesso à Internet para descarregar a imagem do FRRouting (cerca de 95 MB). A parte A demora cerca de 50 minutos e a parte B cerca de 25.

> [!WARNING]
> Este laboratório só deve ser executado na própria máquina ou numa VM sob controlo de quem o faz, nunca num servidor partilhado ou de produção. Tudo acontece dentro de espaços de nomes de rede e contentores criados no próprio laboratório: este não altera as interfaces nem as rotas reais e não envia tráfego para nenhum outro sistema. Os endereços são intervalos privados da RFC 1918 (`10.0.0.0/8`) mais o intervalo de documentação `198.51.100.0/24` (RFC 5737). Se a rede em uso já utilizar `10.1.1.0/24`, `10.3.3.0/24`, `10.0.12.0/24` ou `10.0.23.0/24`, o laboratório continua a funcionar, porque os espaços de nomes são isolados, mas as redes de contentores opcionais podem entrar em conflito: ver [Resolução de problemas](#resolução-de-problemas). A secção de [Limpeza](#limpeza) deve ser sempre executada no final.

## Arquitetura
Cinco **espaços de nomes de rede** fazem de cinco dispositivos. Cada espaço de nomes tem as suas próprias interfaces, endereços, tabela de encaminhamento e definições, tal como uma máquina separada. Os pares Ethernet virtuais (veth) funcionam como cabos entre eles.

![Cinco espaços de nomes de rede em linha, unidos por pares veth. O lab-h1 tem eth0 10.1.1.10/24 e rota predefinida via 10.1.1.1. O lab-r1 tem to-h1 10.1.1.1/24 e to-r2 10.0.12.1/30. O lab-r2 tem to-r1 10.0.12.2/30 e to-r3 10.0.23.1/30. O lab-r3 tem to-r2 10.0.23.2/30 e to-h2 10.3.3.1/24. O lab-h2 tem eth0 10.3.3.10/24 e rota predefinida via 10.3.3.1. As redes são 10.1.1.0/24, 10.0.12.0/30, 10.0.23.0/30 e 10.3.3.0/24. Os três routers têm o encaminhamento IP ativado](../../../assets/diagrams/routing-lab-architecture.pt.svg)

*Figura 1. A topologia do laboratório. Os nomes das interfaces indicam para onde vai cada cabo: `to-r2` no `lab-r1` conduz ao `lab-r2`.*

| Espaço de nomes | Função | Interface → endereço |
|---|---|---|
| `lab-h1` | Anfitrião | `eth0` → `10.1.1.10/24` |
| `lab-r1` | Router | `to-h1` → `10.1.1.1/24`, `to-r2` → `10.0.12.1/30` |
| `lab-r2` | Router | `to-r1` → `10.0.12.2/30`, `to-r3` → `10.0.23.1/30` |
| `lab-r3` | Router | `to-r2` → `10.0.23.2/30`, `to-h2` → `10.3.3.1/24` |
| `lab-h2` | Anfitrião | `eth0` → `10.3.3.10/24` |

Dois comandos executam coisas dentro de um espaço de nomes:
- `sudo ip -n <espaço-de-nomes> <comando ip>` executa nele um comando `ip`, por exemplo `sudo ip -n lab-r1 route`.
- `sudo ip netns exec <espaço-de-nomes> <comando>` executa nele qualquer outro comando, por exemplo `ping` ou `sysctl`.

`<espaço-de-nomes>` é um dos cinco nomes da tabela.

## Passos

### Parte A — Encaminhamento estático
Constrói-se a rede, faz-se funcionar com rotas estáticas e predefinidas, e depois estraga-se e corrige-se. Esta parte demora cerca de 50 minutos.

### Passo 1 — Verifique as ferramentas (2 min)
Deve confirmar-se que os comandos existem antes de construir seja o que for, e que não restam espaços de nomes com estes nomes de uma tentativa anterior.

```bash
ip -V
traceroute --version
ip netns list
```

Saída esperada (as versões podem diferir):
```text
ip utility, iproute2-6.17.0, libbpf 1.6.3
Modern traceroute for Linux, version 2.1.6
Copyright (c) 2016  Dmitry Butskoy,   License: GPL v2 or any later
```

`ip netns list` não deve imprimir nada. Se listar `lab-h1` ou qualquer outro espaço de nomes `lab-`, executa-se primeiro a [Limpeza](#limpeza).

> [!TIP]
> Se o idioma do sistema não for o inglês, algumas mensagens aparecem traduzidas. O seu significado é o mesmo das saídas aqui mostradas.

### Passo 2 — Crie os cinco espaços de nomes (2 min)
Cada espaço de nomes começa vazio, apenas com uma interface de loopback que está desativada. Ativa-se o loopback para que as ferramentas locais se comportem normalmente.

```bash
for ns in lab-h1 lab-r1 lab-r2 lab-r3 lab-h2; do
  sudo ip netns add $ns
  sudo ip -n $ns link set lo up
done
ip netns list
```

Saída esperada (a ordem pode diferir):
```text
lab-h2
lab-r3
lab-r2
lab-r1
lab-h1
```

### Passo 3 — Ligue os dispositivos por cabo e atribua endereços (6 min)
Cada par veth é criado com uma extremidade em cada espaço de nomes. Depois, cada interface recebe o endereço da tabela e é ativada.

```bash
# Cables: one veth pair per link
sudo ip link add eth0  netns lab-h1 type veth peer name to-h1 netns lab-r1
sudo ip link add to-r2 netns lab-r1 type veth peer name to-r1 netns lab-r2
sudo ip link add to-r3 netns lab-r2 type veth peer name to-r2 netns lab-r3
sudo ip link add to-h2 netns lab-r3 type veth peer name eth0  netns lab-h2

# Addresses
sudo ip -n lab-h1 addr add 10.1.1.10/24  dev eth0
sudo ip -n lab-r1 addr add 10.1.1.1/24   dev to-h1
sudo ip -n lab-r1 addr add 10.0.12.1/30  dev to-r2
sudo ip -n lab-r2 addr add 10.0.12.2/30  dev to-r1
sudo ip -n lab-r2 addr add 10.0.23.1/30  dev to-r3
sudo ip -n lab-r3 addr add 10.0.23.2/30  dev to-r2
sudo ip -n lab-r3 addr add 10.3.3.1/24   dev to-h2
sudo ip -n lab-h2 addr add 10.3.3.10/24  dev eth0

# Bring every interface up
sudo ip -n lab-h1 link set eth0 up
sudo ip -n lab-r1 link set to-h1 up
sudo ip -n lab-r1 link set to-r2 up
sudo ip -n lab-r2 link set to-r1 up
sudo ip -n lab-r2 link set to-r3 up
sudo ip -n lab-r3 link set to-r2 up
sudo ip -n lab-r3 link set to-h2 up
sudo ip -n lab-h2 link set eth0 up

sudo ip -n lab-r2 -br addr
```

Saída esperada (os números `@if` e os endereços de ligação local `fe80::` serão diferentes):
```text
lo               UNKNOWN        127.0.0.1/8 ::1/128
to-r1@if3        UP             10.0.12.2/30 fe80::9c1d:9ff:fee0:e853/64
to-r3@if2        UP             10.0.23.1/30 fe80::508d:83ff:fecf:55ce/64
```

As duas interfaces do `lab-r2` estão `UP` com os endereços corretos.

### Passo 4 — Leia as rotas diretamente ligadas (4 min)
Acrescentar um endereço cria uma rota diretamente ligada para a respetiva sub-rede. É tudo o que cada dispositivo conhece por agora.

```bash
sudo ip -n lab-h1 route
sudo ip -n lab-r2 route
```

Saída esperada:
```text
10.1.1.0/24 dev eth0 proto kernel scope link src 10.1.1.10
10.0.12.0/30 dev to-r1 proto kernel scope link src 10.0.12.2
10.0.23.0/30 dev to-r3 proto kernel scope link src 10.0.23.1
```

O `h1` só conhece a sua própria LAN, e o `r2` só conhece as suas duas ligações. Testa-se um vizinho na mesma sub-rede e depois o anfitrião distante:

```bash
sudo ip netns exec lab-h1 ping -c 2 10.1.1.1
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Saída esperada (os tempos variam):
```text
PING 10.1.1.1 (10.1.1.1) 56(84) bytes of data.
64 bytes from 10.1.1.1: icmp_seq=1 ttl=64 time=0.047 ms
64 bytes from 10.1.1.1: icmp_seq=2 ttl=64 time=0.028 ms

--- 10.1.1.1 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1035ms
rtt min/avg/max/mdev = 0.028/0.037/0.047/0.009 ms
ping: connect: Network is unreachable
```

O vizinho funciona: está numa rede diretamente ligada. Para `10.3.3.10`, o `h1` não tem nenhuma rota correspondente nem rota predefinida, pelo que o kernel recusa-se mesmo a enviar o pacote.

### Passo 5 — Transforme três espaços de nomes em routers (2 min)
Uma máquina Linux só encaminha pacotes destinados a outros anfitriões quando o encaminhamento IP está ativado. Por predefinição está desativado, e cada espaço de nomes tem a sua própria definição.

```bash
sudo ip netns exec lab-r1 sysctl net.ipv4.ip_forward
for r in lab-r1 lab-r2 lab-r3; do
  sudo ip netns exec $r sysctl -w net.ipv4.ip_forward=1
done
```

Saída esperada:
```text
net.ipv4.ip_forward = 0
net.ipv4.ip_forward = 1
net.ipv4.ip_forward = 1
net.ipv4.ip_forward = 1
```

A primeira linha mostra o valor predefinido, 0. A definição vive dentro de cada espaço de nomes, pelo que a definição de encaminhamento do próprio anfitrião não muda.

### Passo 6 — Dê aos anfitriões um gateway predefinido (4 min)
Os anfitriões enviam tudo o que sai da sua sub-rede para o gateway predefinido. Aponta-se cada anfitrião ao router da sua LAN.

```bash
sudo ip -n lab-h1 route add default via 10.1.1.1
sudo ip -n lab-h2 route add default via 10.3.3.1
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Saída esperada:
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
From 10.1.1.1 icmp_seq=1 Destination Net Unreachable
From 10.1.1.1 icmp_seq=2 Destination Net Unreachable

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1006ms
```

Progresso: o pacote já sai do `h1` e chega ao `r1`. O `r1` não tem rota para `10.3.3.0/24`, pelo que descarta o pacote e devolve ICMP *Destination Unreachable*. Confirma-se do ponto de vista do `r1`:

```bash
sudo ip -n lab-r1 route get 10.3.3.10
```

Saída esperada:
```text
RTNETLINK answers: Network is unreachable
```

O `ip route get` pergunta ao kernel que rota usaria. "Network is unreachable" significa que nenhuma rota corresponde, nem sequer uma predefinida.

### Passo 7 — Acrescente o caminho de ida (4 min)
Dá-se a cada router do caminho para `10.3.3.0/24` uma rota para ela. O `r3` não precisa de nenhuma, porque `10.3.3.0/24` está diretamente ligada a ele.

```bash
sudo ip -n lab-r1 route add 10.3.3.0/24 via 10.0.12.2
sudo ip -n lab-r2 route add 10.3.3.0/24 via 10.0.23.2
sudo ip netns exec lab-h1 ping -c 2 -W 1 10.3.3.10
```

Saída esperada:
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1062ms
```

Continua a haver 100 % de perda, mas desta vez *sem* qualquer mensagem de erro. Algo está a descartar pacotes em silêncio. `-W 1` faz com que o `ping` espere apenas um segundo por cada resposta.

### Passo 8 — Encontre e corrija a rota de retorno em falta (8 min)
Segue-se o caminho salto a salto com `ip route get`, primeiro em direção ao destino e depois de volta à origem.

```bash
sudo ip -n lab-r2 route get 10.3.3.10
sudo ip -n lab-r3 route get 10.3.3.10
sudo ip -n lab-r3 route get 10.1.1.10
```

Saída esperada:
```text
10.3.3.10 via 10.0.23.2 dev to-r3 src 10.0.23.1 uid 0
    cache
10.3.3.10 dev to-h2 src 10.3.3.1 uid 0
    cache
RTNETLINK answers: Network is unreachable
```

O caminho de ida está completo: o `r2` envia para o `r3`, e o `r3` entrega diretamente por `to-h2`. Os echo request chegam ao `h2`, e o `h2` responde ao seu gateway `r3`. Mas o `r3` não tem rota para `10.1.1.10`, pelo que descarta todas as respostas.

![O Echo Request de h1 (10.1.1.10) passa por R1, R2 e R3, cada um com uma rota para 10.3.3.0/24, e chega a h2 (10.3.3.10). O Echo Reply para 10.1.1.10 volta a R3, que não tem rota para 10.1.1.0/24 e o descarta](../../../assets/diagrams/routing-lab-asymmetric.pt.svg)

*Figura 2. Os pedidos chegam; as respostas morrem no primeiro router sem rota de retorno. Do ponto de vista do `h1`, parece apenas silêncio.*

O `r3` é um router stub com uma única saída, pelo que a correção adequada é uma rota predefinida para o `r2`:

```bash
sudo ip -n lab-r3 route add default via 10.0.23.1
sudo ip netns exec lab-h1 ping -c 2 -W 1 10.3.3.10
```

Saída esperada:
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1039ms
```

Continua a falhar. Segue-se o caminho de retorno: a resposta já chega ao `r2`.

```bash
sudo ip -n lab-r2 route get 10.1.1.10
```

Saída esperada:
```text
RTNETLINK answers: Network is unreachable
```

O `r2` está no meio, pelo que precisa de uma rota específica de volta à LAN do `h1`:

```bash
sudo ip -n lab-r2 route add 10.1.1.0/24 via 10.0.12.1
sudo ip netns exec lab-h1 ping -c 3 10.3.3.10
```

Saída esperada (os tempos variam):
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
64 bytes from 10.3.3.10: icmp_seq=1 ttl=61 time=0.068 ms
64 bytes from 10.3.3.10: icmp_seq=2 ttl=61 time=0.052 ms
64 bytes from 10.3.3.10: icmp_seq=3 ttl=61 time=0.054 ms

--- 10.3.3.10 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2064ms
rtt min/avg/max/mdev = 0.052/0.058/0.068/0.007 ms
```

Funciona. `ttl=61` confirma o caminho: o `h2` enviou a resposta com TTL 64, e três routers decrementaram-no uma vez cada um. O `r1` já conhece `10.1.1.0/24`, porque está diretamente ligada.

### Passo 9 — Trace o caminho e explique um salto silencioso (7 min)
O traceroute mostra cada router do caminho de ida.

```bash
sudo ip netns exec lab-h1 traceroute -n 10.3.3.10
```

Saída esperada:
```text
traceroute to 10.3.3.10 (10.3.3.10), 30 hops max, 60 byte packets
 1  10.1.1.1  0.022 ms  0.005 ms  0.005 ms
 2  10.0.12.2  0.017 ms  0.006 ms  0.007 ms
 3  * * *
 4  10.3.3.10  0.013 ms  0.009 ms  0.009 ms
```

`-n` mostra endereços sem tentar resolver nomes. O salto 4, o destino, responde, pelo que o salto 3 (`r3`) encaminha tráfego. Porque é que o `r3` não responde por si próprio? As suas mensagens *Time Exceeded* saem do seu endereço na ligação ao `r2`, `10.0.23.2`. Verifica-se se o `r1` conhece o caminho de volta a esse endereço:

```bash
sudo ip -n lab-r1 route get 10.0.23.2
sudo ip netns exec lab-r1 sysctl net.ipv4.conf.to-r2.rp_filter
```

Saída esperada:
```text
RTNETLINK answers: Network is unreachable
net.ipv4.conf.to-r2.rp_filter = 2
```

O `r1` tem rotas para `10.1.1.0/24`, `10.0.12.0/30` e `10.3.3.0/24`, mas não para a ligação `10.0.23.0/30`. O seu **filtro de caminho inverso** (`rp_filter`, a forma Linux do uRPF da lição) verifica o endereço de origem de cada pacote recebido. No modo permissivo (`2`), descarta pacotes de uma origem que a tabela de encaminhamento não consegue alcançar de todo. Assim, as mensagens do `r3` morrem no `r1`.

> [!NOTE]
> A maioria das distribuições define `rp_filter` como 2 (permissivo) por predefinição, e os novos espaços de nomes herdam-no. Se o do leitor mostrar `0` (desativado), o `r1` encaminha as mensagens do `r3` na mesma. Chegam então ao `h1` e o salto 3 já mostra `10.0.23.2`. Convém ler a explicação na mesma e aplicar a correção: um router sem rota de retorno para parte da rede é um problema real, mesmo que um filtro não o revele.

Tal como o `r3`, o `r1` é um router stub. Dá-se-lhe uma rota predefinida para o `r2`, como no desenho da lição:

```bash
sudo ip -n lab-r1 route add default via 10.0.12.2
sudo ip netns exec lab-h1 traceroute -n 10.3.3.10
```

Saída esperada:
```text
traceroute to 10.3.3.10 (10.3.3.10), 30 hops max, 60 byte packets
 1  10.1.1.1  0.040 ms  0.006 ms  0.004 ms
 2  10.0.12.2  0.015 ms  0.008 ms  0.006 ms
 3  10.0.23.2  0.018 ms  0.008 ms  0.007 ms
 4  10.3.3.10  0.019 ms  0.010 ms *
```

Agora respondem os quatro saltos. Um único `*` entre as respostas (como o último aqui) é normal: o Linux limita o débito dos erros ICMP que envia (`net.ipv4.icmp_ratelimit`), pelo que, se o traceroute for executado várias vezes seguidas, algumas sondas ficam sem resposta. Convém esperar uns segundos entre execuções.

### Passo 10 — Observe a correspondência do prefixo mais longo a decidir (6 min)
O `r1` tem agora uma rota `/24` e uma rota predefinida que apontam para o mesmo lado. Acrescenta-se uma terceira rota, mais específica, para ver que vence a correspondência mais longa, seja qual for a ordem em que as rotas foram acrescentadas.

```bash
sudo ip -n lab-r1 route
sudo ip -n lab-r1 route get 10.3.3.10
sudo ip -n lab-r1 route get 198.51.100.7
```

Saída esperada:
```text
default via 10.0.12.2 dev to-r2
10.0.12.0/30 dev to-r2 proto kernel scope link src 10.0.12.1
10.1.1.0/24 dev to-h1 proto kernel scope link src 10.1.1.1
10.3.3.0/24 via 10.0.12.2 dev to-r2
10.3.3.10 via 10.0.12.2 dev to-r2 src 10.0.12.1 uid 0
    cache
198.51.100.7 via 10.0.12.2 dev to-r2 src 10.0.12.1 uid 0
    cache
```

`10.3.3.10` corresponde à `/24` e `198.51.100.7` (um endereço de documentação) corresponde apenas à rota predefinida. Ambos vão para `10.0.12.2`, pelo que ainda não se distinguem. Acrescenta-se agora uma rota **prohibit** para exatamente um endereço. É uma rota que rejeita pacotes em vez de os encaminhar, o que torna visível a vencedora:

```bash
sudo ip -n lab-r1 route add prohibit 10.3.3.10/32
sudo ip -n lab-r1 route get 10.3.3.10
sudo ip -n lab-r1 route get 10.3.3.20
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Saída esperada:
```text
RTNETLINK answers: Permission denied
10.3.3.20 via 10.0.12.2 dev to-r2 src 10.0.12.1 uid 0
    cache
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
From 10.1.1.1 icmp_seq=1 Packet filtered
From 10.1.1.1 icmp_seq=2 Packet filtered

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1061ms
```

Para `10.3.3.10`, a `/32` vence a `/24` e a rota predefinida. O kernel rejeita o pacote e o `r1` envia ICMP *administratively prohibited*, que o `ping` mostra como `Packet filtered`. O seu vizinho `10.3.3.20` só corresponde à `/24`, pelo que continua a ir para o `r2`. Remove-se a rota de teste:

```bash
sudo ip -n lab-r1 route del prohibit 10.3.3.10/32
```

Não há saída quando tem êxito.

### Passo 11 — Estrague uma rota de ida e localize a falha (5 min)
Um colega "limpa" o `r2` e apaga a sua rota para `10.3.3.0/24`. Faz-se de colega e depois diagnostica-se como se não se soubesse.

```bash
sudo ip -n lab-r2 route del 10.3.3.0/24
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Saída esperada:
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
From 10.0.12.2 icmp_seq=1 Destination Net Unreachable
From 10.0.12.2 icmp_seq=2 Destination Net Unreachable

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1064ms
```

O erro aponta o culpado: `10.0.12.2` é o `r2`. O traceroute mostra o mesmo:

```bash
sudo ip netns exec lab-h1 traceroute -n 10.3.3.10
```

Saída esperada:
```text
traceroute to 10.3.3.10 (10.3.3.10), 30 hops max, 60 byte packets
 1  10.1.1.1  0.026 ms  0.005 ms  0.004 ms
 2  10.0.12.2  0.010 ms !N  0.006 ms !N *
```

`!N` significa *network unreachable*: o salto 2 respondeu que não tem rota. Compare-se com o Passo 7: uma rota de *ida* em falta costuma produzir um erro do router que não a tem, enquanto uma rota de *retorno* em falta produz silêncio. Confirma-se no `r2` e corrige-se:

```bash
sudo ip -n lab-r2 route get 10.3.3.10
sudo ip -n lab-r2 route add 10.3.3.0/24 via 10.0.23.2
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Saída esperada:
```text
RTNETLINK answers: Network is unreachable
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
64 bytes from 10.3.3.10: icmp_seq=1 ttl=61 time=0.073 ms
64 bytes from 10.3.3.10: icmp_seq=2 ttl=61 time=0.045 ms

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1056ms
rtt min/avg/max/mdev = 0.045/0.059/0.073/0.014 ms
```

> [!NOTE]
> As saídas da parte A provêm de uma execução real com iproute2 6.17, iputils 20250605 e traceroute 2.1.6 em Linux 7.2. Foi executada num espaço de nomes de utilizador e de rede sem privilégios (`unshare -rn`) em vez de com `sudo`, o que não altera o comportamento do encaminhamento. Outras versões podem redigir as mensagens de forma ligeiramente diferente.

### Parte B (opcional) — Substitua as rotas estáticas por OSPF
Na parte A foram escritas sete rotas e localizadas três falhas à mão. Aqui, três routers aprendem as mesmas redes por si próprios com OSPF. Executa-se o **FRRouting** (FRR), um conjunto de encaminhamento de código aberto, em três contentores. Esta parte é opcional e demora cerca de 25 minutos.

![Parte opcional: três contentores FRRouting na área 0 do OSPF. O lab-ospf-r1 (router ID 10.255.0.1) tem eth0 10.1.1.11 na ospf-lan1 (10.1.1.0/24) e eth1 10.0.12.11 na ospf-r1r2 (10.0.12.0/24). O lab-ospf-r2 (10.255.0.2) tem eth0 10.0.12.12 e eth1 10.0.23.12 na ospf-r2r3 (10.0.23.0/24). O lab-ospf-r3 (10.255.0.3) tem eth0 10.3.3.13 na ospf-lan3 (10.3.3.0/24) e eth1 10.0.23.13. Os hello do OSPF são enviados a cada 10 segundos para 224.0.0.5 em cada interface OSPF](../../../assets/diagrams/routing-lab-ospf.pt.svg)

*Figura 3. A mesma linha de três routers, agora como contentores. As redes dos contentores reutilizam os prefixos da parte A, mas as ligações são /24 e os routers usam os números de anfitrião 11, 12 e 13.*

> [!NOTE]
> Os motores de contentores reservam o primeiro endereço de cada rede (`.1`) para a sua própria bridge, pelo que os routers usam `.11`, `.12` e `.13`. Os comandos foram testados com Podman 5.8 sem privilégios (rootless) e a imagem `quay.io/frrouting/frr:10.7.1`. O Docker usa os mesmos comandos, mas não foram testados com Docker para este laboratório. Com o Docker, pode ser necessário `sudo` ou pertencer ao grupo `docker`.

### Passo 12 — Prepare a configuração do FRR (5 min)
Cada router precisa de três ficheiros na sua própria pasta: `daemons` (que daemons do FRR arrancar), `vtysh.conf` (definições da shell de comandos do FRR) e `frr.conf` (a configuração de encaminhamento). Primeiro escolhe-se o motor de contentores e obtém-se da imagem o ficheiro `daemons` predefinido:

```bash
CT=podman          # or: CT=docker
IMG=quay.io/frrouting/frr:10.7.1
mkdir -p ~/ospf-lab && cd ~/ospf-lab
$CT run --rm --entrypoint cat $IMG /etc/frr/daemons > daemons.orig
for n in 1 2 3; do
  mkdir -p r$n
  sed 's/^ospfd=no/ospfd=yes/' daemons.orig > r$n/daemons
  echo 'service integrated-vtysh-config' > r$n/vtysh.conf
done
grep '^ospfd' r1/daemons
```

Saída esperada (após as mensagens de transferência da imagem):
```text
ospfd=yes
ospfd_options="  -A 127.0.0.1"
```

`CT` guarda o motor de contentores e `IMG` a imagem exata. O comando `sed` ativa o daemon do OSPF, que a imagem traz desativado. Escreve-se agora a configuração OSPF de cada router. Uma instrução `network` ativa o OSPF na área 0 em todas as interfaces cujo endereço caia dentro desse prefixo, e anuncia o prefixo.

```bash
cat > r1/frr.conf <<'EOF'
frr defaults traditional
hostname r1
!
router ospf
 ospf router-id 10.255.0.1
 network 10.1.1.0/24 area 0
 network 10.0.12.0/24 area 0
!
EOF
cat > r2/frr.conf <<'EOF'
frr defaults traditional
hostname r2
!
router ospf
 ospf router-id 10.255.0.2
 network 10.0.12.0/24 area 0
 network 10.0.23.0/24 area 0
!
EOF
cat > r3/frr.conf <<'EOF'
frr defaults traditional
hostname r3
!
router ospf
 ospf router-id 10.255.0.3
 network 10.0.23.0/24 area 0
 network 10.3.3.0/24 area 0
!
EOF
```

Não há saída. O **router ID** é um número de 32 bits, escrito como um endereço IPv4, que dá nome a cada router na LSDB. Tem de ser único.

### Passo 13 — Crie as redes e arranque os routers (4 min)
Cada ligação passa a ser uma rede de contentores interna (sem acesso à Internet). Cada router arranca numa rede e depois é ligado à segunda.

```bash
$CT network create --internal --subnet 10.1.1.0/24  ospf-lan1
$CT network create --internal --subnet 10.0.12.0/24 ospf-r1r2
$CT network create --internal --subnet 10.0.23.0/24 ospf-r2r3
$CT network create --internal --subnet 10.3.3.0/24  ospf-lan3

for spec in "r1 ospf-lan1 10.1.1.11" "r2 ospf-r1r2 10.0.12.12" "r3 ospf-lan3 10.3.3.13"; do
  set -- $spec
  $CT run -d --name lab-ospf-$1 --hostname $1 \
    --network $2 --ip $3 \
    --cap-add NET_ADMIN --cap-add NET_RAW --cap-add SYS_ADMIN \
    --sysctl net.ipv4.ip_forward=1 \
    -v "$PWD/$1:/etc/frr:Z" $IMG
done

$CT network connect --ip 10.0.12.11 ospf-r1r2 lab-ospf-r1
$CT network connect --ip 10.0.23.12 ospf-r2r3 lab-ospf-r2
$CT network connect --ip 10.0.23.13 ospf-r2r3 lab-ospf-r3
$CT ps --filter name=lab-ospf --format '{{.Names}} {{.Status}}'
```

Saída esperada (os nomes das redes, depois três IDs longos de contentores e a seguir):
```text
lab-ospf-r1 Up Less than a second
lab-ospf-r2 Up Less than a second
lab-ospf-r3 Up Less than a second
```

O que fazem as opções:
- `--cap-add NET_ADMIN` permite ao FRR instalar rotas na tabela de encaminhamento do contentor e `NET_RAW` permite-lhe enviar pacotes OSPF (protocolo IP 89). `SYS_ADMIN` também é necessária: os daemons do FRR pedem-na ao arrancar (é usada para o suporte de espaços de nomes de rede) e, sem ela, param com `privs_init: initial cap_set_proc failed: Operation not permitted`.

> [!WARNING]
> `SYS_ADMIN` é a capacidade mais abrangente do Linux. Deve concedê-la-se apenas a estes contentores do laboratório, que estão em redes internas sem acesso à Internet, e preferir o Podman sem privilégios (rootless): aí a capacidade aplica-se dentro do espaço de nomes de utilizador, não ao anfitrião. Nunca se devem reutilizar estas opções em contentores que executem software não fidedigno.
- `--sysctl net.ipv4.ip_forward=1` transforma cada contentor num router, como no Passo 5.
- `-v "$PWD/$1:/etc/frr:Z"` monta a pasta de configuração do router. `:Z` volta a etiquetá-la para o SELinux, onde este esteja ativado.

### Passo 14 — Observe os vizinhos a subir (4 min)
Os routers OSPF encontram-se uns aos outros com hello a cada 10 segundos. Numa rede do tipo Ethernet, esperam ainda até 40 segundos para eleger um router designado antes de sincronizarem. Espera-se cerca de um minuto e observa-se o `r2`, que tem dois vizinhos:

```bash
sleep 60
$CT exec lab-ospf-r2 vtysh -c 'show ip ospf neighbor'
```

Saída esperada (os tempos variam):
```text
Neighbor ID     Pri State           Up Time         Dead Time Address         Interface                        RXmtL RqstL DBsmL
10.255.0.1        1 Full/Backup     10.206s           39.735s 10.0.12.11      eth0:10.0.12.12                      0     0     0
10.255.0.3        1 Full/DR         10.108s           39.894s 10.0.23.13      eth1:10.0.23.12                      0     0     0
```

Os dois vizinhos estão em **Full**: as suas bases de dados estão sincronizadas. `DR` e `Backup` indicam que router foi eleito router designado e de reserva em cada ligação. Se se observar demasiado cedo, vêem-se estados como `Init` ou `2-Way`.

### Passo 15 — Leia as rotas que o OSPF construiu (5 min)
Observa-se a tabela de encaminhamento do `r1` no FRR e depois no kernel do Linux:

```bash
$CT exec lab-ospf-r1 vtysh -c 'show ip route'
$CT exec lab-ospf-r1 ip route
```

Saída esperada (após uma legenda de códigos de rota; os tempos variam):
```text
IPv4 unicast VRF default:
C>* 10.0.12.0/24 is directly connected, eth1, weight 1, 00:00:50
L>* 10.0.12.11/32 is directly connected, eth1, weight 1, 00:00:50
O>* 10.0.23.0/24 [110/20] via 10.0.12.12, eth1, weight 1, 00:00:05
C>* 10.1.1.0/24 is directly connected, eth0, weight 1, 00:00:50
L>* 10.1.1.11/32 is directly connected, eth0, weight 1, 00:00:50
O>* 10.3.3.0/24 [110/30] via 10.0.12.12, eth1, weight 1, 00:00:05
10.0.12.0/24 dev eth1 proto kernel scope link src 10.0.12.11
10.0.23.0/24 nhid 10 via 10.0.12.12 dev eth1 proto ospf metric 20
10.1.1.0/24 dev eth0 proto kernel scope link src 10.1.1.11
10.3.3.0/24 nhid 10 via 10.0.12.12 dev eth1 proto ospf metric 20
```

Como ler:
- `O` marca as rotas aprendidas por OSPF, `C` as rotas diretamente ligadas e `L` os endereços do próprio router. `>*` significa "selecionada e instalada".
- `[110/30]` é *[distância administrativa/métrica]*. O FRR atribui ao OSPF uma distância de 110, como o Cisco IOS. O custo até `10.3.3.0/24` é 30: três interfaces com um custo de 10 cada (`r1`→`r2`, `r2`→`r3` e a LAN do `r3`).
- Na tabela do kernel, as mesmas rotas aparecem com `proto ospf`. O kernel do Linux não tem distância administrativa, pelo que o FRR escolhe ele próprio a melhor rota e instala apenas essa.

Nunca se escreveu uma rota, mas o `r1` conhece `10.3.3.0/24` e a ligação `10.0.23.0/24`, pelo que os problemas de caminho de retorno e de salto silencioso da parte A não podem acontecer aqui.

### Passo 16 — Faça falhar uma ligação e observe a reação do OSPF (4 min)
Desliga-se o `r2` da ligação `r2`–`r3`, como se alguém desligasse o cabo:

```bash
$CT network disconnect ospf-r2r3 lab-ospf-r2
sleep 3
$CT exec lab-ospf-r1 vtysh -c 'show ip route ospf'
$CT exec lab-ospf-r1 ping -c 2 -W 1 10.3.3.13
```

Saída esperada:
```text
PING 10.3.3.13 (10.3.3.13): 56 data bytes
ping: sendto: Network unreachable
```

`show ip route ospf` não imprime nada: em poucos segundos, o `r2` difundiu a alteração e o `r1` retirou as duas rotas que estavam depois da ligação interrompida. O `ping` dentro do contentor é o do BusyBox, que redige o erro de forma diferente da parte A. Volta-se a ligar o cabo e espera-se pela adjacência:

```bash
$CT network connect --ip 10.0.23.12 ospf-r2r3 lab-ospf-r2
sleep 60
$CT exec lab-ospf-r1 vtysh -c 'show ip route ospf'
```

Saída esperada (após a legenda; os tempos variam):
```text
IPv4 unicast VRF default:
O>* 10.0.23.0/24 [110/20] via 10.0.12.12, eth1, weight 1, 00:00:50
O>* 10.3.3.0/24 [110/30] via 10.0.12.12, eth1, weight 1, 00:00:39
```

As rotas voltaram sem que ninguém as escrevesse. Com um único caminho, o OSPF não consegue contornar a falha, mas retira as rotas mortas e restaura-as automaticamente. Com uma ligação redundante, passaria para o outro caminho. Esse é o desafio abaixo.

> [!NOTE]
> As saídas da parte B provêm de uma execução real com Podman 5.8.7 sem privilégios (rootless) e FRR 10.7.1 (`quay.io/frrouting/frr:10.7.1`, cerca de 94 MB comprimidos). Não foi testada com Docker.

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

1. Os dois anfitriões se alcançam através de três routers:
   ```bash
   sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
   sudo ip netns exec lab-h2 ping -c 2 10.1.1.10
   ```
   Ambos mostram `0% packet loss` e `ttl=61`.
2. O traçado inverso lista todos os routers:
   ```bash
   sudo ip netns exec lab-h2 traceroute -n 10.1.1.10
   ```
   Saída esperada (os tempos variam):
   ```text
   traceroute to 10.1.1.10 (10.1.1.10), 30 hops max, 60 byte packets
    1  10.3.3.1  0.042 ms  0.006 ms  0.005 ms
    2  10.0.23.1  0.018 ms  0.008 ms  0.006 ms
    3  10.0.12.1  0.017 ms  0.008 ms  0.007 ms
    4  10.1.1.10  0.017 ms  0.010 ms  0.009 ms
   ```
3. É possível explicar, para cada um destes sintomas, que rota estava em falta e em que router: `Destination Net Unreachable` vindo de `10.1.1.1` (Passo 6), perda de 100 % em silêncio (Passos 7–8), `* * *` no salto 3 (Passo 9) e `!N` no salto 2 (Passo 11).
4. (Parte B opcional) `show ip ospf neighbor` no `lab-ospf-r2` mostra dois vizinhos no estado `Full`, e o `r1` tem rotas `O` para `10.0.23.0/24` e `10.3.3.0/24`.

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| `RTNETLINK answers: Operation not permitted` | Foi executado sem `sudo` um comando que altera a rede. | Prefixar o comando com `sudo`. |
| `Cannot open network namespace "lab-r1": No such file or directory` | O espaço de nomes não existe: foi saltado um passo, há um erro de escrita ou a limpeza já foi executada. | Executar `ip netns list` e criar o que falta (Passo 2). |
| `RTNETLINK answers: File exists` | A rota, o endereço ou a interface já existe, por exemplo por ter executado um passo duas vezes. | Verificar com `ip -n <espaço-de-nomes> route`. Usar `ip route replace` para alterar uma rota, ou apagá-la primeiro. |
| `Error: Nexthop has invalid gateway.` | O próximo salto não está numa sub-rede diretamente ligada desse router, muitas vezes por erro de escrita ou por usar o router errado. | Usar o endereço do vizinho na ligação partilhada, como `10.0.12.2` a partir do `r1`. |
| O ping ao vizinho de um router funciona, mas para lá dele há 100 % de perda sem erro e o traceroute mostra `* * *` a partir do salto seguinte | O encaminhamento IP está desativado nesse router (`sysctl net.ipv4.ip_forward` mostra 0). Descarta os pacotes sem qualquer mensagem ICMP. | Repetir o Passo 5 para esse router. |
| 100 % de perda sem erro, com o encaminhamento ativado | Falta uma rota de retorno nalgum ponto do caminho de volta. | Executar `ip route get <endereço de origem>` em cada router, do destino para trás (Passo 8). |
| `From <router> Destination Net Unreachable` ou `!N` no traceroute | Esse router não tem rota para o destino. | Acrescentar a rota de ida nesse router (Passos 7 e 11). |
| `traceroute: command not found` | O pacote `traceroute` não está instalado. | Instalá-lo (ver Pré-requisitos) ou usar `tracepath -n`, que faz parte do iputils. |
| (Parte B) `Error: ... subnet ... is already used` ou `Pool overlaps with other one on this address space` | Outra rede de contentores ou uma rota do anfitrião já usa uma das sub-redes. | Remover a rede em conflito, ou alterar os prefixos de forma coerente nos comandos de rede e nos ficheiros `frr.conf`. |
| (Parte B) Vizinhos presos em `Init` ou `2-Way`, ou sem rotas `O` | Observou-se antes de terminar a espera de 40 segundos, ou a configuração tem um erro. | Esperar um minuto e verificar de novo. Ler o registo com `$CT logs lab-ospf-r2` e verificar as instruções `network` e os router IDs. |

## Desafio (opcional)
1. **Rota estática flutuante.** No `lab-h1`, acrescentar uma segunda rota predefinida com uma métrica superior (`metric 200`) através do endereço de um router que ainda não existe. Prever que rota usa `ip route get 198.51.100.7`, verificar, e depois apagar a rota predefinida principal para ver a de reserva assumir.
2. **Caminho OSPF redundante.** Na parte B, criar uma quinta rede `ospf-r1r3` (`10.0.13.0/24`), ligar a ela o `r1` e o `r3` e acrescentá-la à respetiva configuração OSPF (`network 10.0.13.0/24 area 0`; recarregar com `$CT restart`). Que caminho usa agora o `r1` para `10.3.3.0/24`, e com que custo? Desligar a nova ligação e medir quanto tempo o `r1` demora a voltar ao caminho anterior.
3. **Proteger o OSPF.** Ativar a autenticação criptográfica do OSPF numa ligação, recorrendo à documentação do FRR sobre `ip ospf authentication message-digest` ou chaveiros (key chains). Configurá-la primeiro apenas de um lado e observar a adjacência a cair.

## Limpeza
Eliminam-se os cinco espaços de nomes. Eliminar um espaço de nomes elimina também as interfaces veth que contém, e eliminar uma extremidade de um par veth elimina a outra.

```bash
for ns in lab-h1 lab-r1 lab-r2 lab-r3 lab-h2; do
  sudo ip netns del $ns
done
ip netns list
```

Saída esperada: `ip netns list` não imprime nada (ou, pelo menos, nenhum espaço de nomes `lab-`).

Se a parte B foi feita, removem-se os contentores, as redes, a pasta de configuração e a imagem. Define-se `CT` de novo se tiver sido aberto um novo terminal.

```bash
CT=podman          # or: CT=docker
$CT rm -f lab-ospf-r1 lab-ospf-r2 lab-ospf-r3
$CT network rm ospf-lan1 ospf-r1r2 ospf-r2r3 ospf-lan3
$CT rmi quay.io/frrouting/frr:10.7.1
cd ~ && rm -r ~/ospf-lab
$CT ps -a --filter name=lab-ospf
$CT network ls --filter name=ospf-
```

Saída esperada: os dois últimos comandos listam apenas as linhas de cabeçalho, sem contentores `lab-ospf` nem redes `ospf-`.

## O que aprendeu
- Um espaço de nomes de rede do Linux com `net.ipv4.ip_forward=1` é um router. A sua tabela de encaminhamento começa apenas com rotas diretamente ligadas.
- O encaminhamento funciona em cada sentido separadamente: uma rota de ida em falta produz um erro ICMP do router que não a tem, enquanto uma rota de retorno em falta produz muitas vezes silêncio.
- `ip route get` em cada salto, em direção ao destino e de volta à origem, encontra rapidamente o router a que falta a rota.
- Um salto `* * *` pode continuar a encaminhar tráfego. Aqui as suas respostas eram descartadas por um filtro de caminho inverso, porque um router não tinha rota de retorno para parte da rede.
- A correspondência do prefixo mais longo escolhe a rota mais específica, seja qual for a ordem em que as rotas foram acrescentadas.
- (Opcional) O OSPF constrói automaticamente as mesmas rotas a partir de hello e de uma base de dados partilhada, mostra-as com distância 110 e uma métrica de custo, e retira-as e restaura-as quando uma ligação falha.
