---
title: "Laboratorium: budowa przełącznika obsługującego VLAN-y z przestrzeniami nazw Linuksa"
domain: networking
level: beginner
duration: "60 min"
cost: "bezpłatnie"
environment: "lokalna maszyna z Linuksem lub VM z sudo (przestrzenie nazw sieci, most Linux)"
lang: pl
source_hash: 14b155c590c5
---

# Laboratorium: budowa przełącznika obsługującego VLAN-y z przestrzeniami nazw Linuksa

## Cel
Budujesz małą sieć przełączaną na jednej maszynie z Linuksem: most Linux z obsługą VLAN-ów pełni rolę przełącznika, a przestrzenie nazw sieci (network namespaces) odgrywają rolę trzech komputerów i routera. Obserwujesz, jak przełącznik uczy się adresów MAC i zalewa nieznane ramki, dzielisz komputery na dwa VLAN-y, przenosisz oba VLAN-y trunkiem, oglądasz znaczniki 802.1Q w zrzucie ruchu i routujesz między VLAN-ami za pomocą router-on-a-stick.

## Cele
- Zaobserwować uczenie się adresów MAC i zalewanie w bazie przekazywania przełącznika.
- Skonfigurować porty access w dwóch VLAN-ach i pokazać, że hosty w różnych VLAN-ach nie mogą się połączyć w warstwie 2, nawet w tej samej podsieci.
- Skonfigurować port trunk przenoszący VLAN-y 10 i 20 ze znacznikami i odczytać znaczniki 802.1Q w zrzucie pakietów.
- Routować między VLAN-ami za pomocą router-on-a-stick zbudowanego z podinterfejsów VLAN.

## Wymagania wstępne
- Maszyna z Linuksem lub VM, na której możesz używać `sudo`. Działa każda aktualna dystrybucja (testowano na Fedorze z Linuksem 6.x).
- iproute2 w wersji 5.0 lub nowszej, który dostarcza polecenia `ip` i `bridge` (testowano z 6.17). Sprawdź przez `ip -V`.
- tcpdump w wersji 4.9 lub nowszej (testowano z 4.99.6). Zainstaluj go menedżerem pakietów, jeśli `tcpdump --version` zawodzi, np. `sudo dnf install tcpdump` lub `sudo apt install tcpdump`.
- Dwa okna terminala: w drugim uruchamiasz przechwytywanie.
- [Lekcja](lesson.pl.md) z tego modułu, zwłaszcza uczenie się adresów MAC, porty access i trunk oraz router-on-a-stick.

> [!WARNING]
> Uruchamiaj to laboratorium wyłącznie na własnej maszynie lub VM, nad którą masz kontrolę, najlepiej testowej, a nie na serwerze produkcyjnym. Wszystko dzieje się w nowych przestrzeniach nazw sieci, więc Twoje prawdziwe interfejsy, adresy i trasy nie są ruszane. Laboratorium używa zakresu prywatnego `192.168.0.0/16` (RFC 1918) wewnątrz przestrzeni nazw; nawet jeśli Twoja sieć domowa używa tych samych adresów, nie ma konfliktu, bo przestrzenie nazw są od niej odizolowane. Zawsze wykonaj na końcu sekcję [Sprzątanie](#sprzątanie).

## Architektura
**Przestrzeń nazw sieci (network namespace)** to osobna kopia stosu sieciowego Linuksa, z własnymi interfejsami, adresami i tablicą routingu. Tworzysz pięć takich przestrzeni. Jedna, `sw1`, zawiera przełącznik: most Linux o nazwie `br0` z włączonym filtrowaniem VLAN. Pozostałe to hosty. Każdy host jest połączony z portem mostu za pomocą **pary veth**, wirtualnego kabla Ethernet, którego oba końce mogą leżeć w różnych przestrzeniach nazw.

![Architektura laboratorium: przestrzeń nazw sw1 zawiera br0, most Linux z vlan_filtering 1. Przestrzeń pc1 (eth0, 00:00:5e:00:53:01, 192.168.10.11/24) łączy się z portem p1, portem access w VLAN 10. Przestrzeń pc2 (eth0, 00:00:5e:00:53:02, 192.168.20.12/24) łączy się z p2, portem access w VLAN 20. Przestrzeń pc3 (eth0, 00:00:5e:00:53:03, 192.168.10.13/24) łączy się z p3, portem access w VLAN 10. Przestrzeń r1 (eth0, 00:00:5e:00:53:fe) łączy się z p4, trunkiem ze znacznikami VLAN 10 i 20, i routuje między nimi przez podinterfejsy eth0.10 (192.168.10.1/24) i eth0.20 (192.168.20.1/24)](../../../assets/diagrams/vlan-lab-architecture.pl.svg)

*Rysunek 1. Gotowe laboratorium. Niebieskie łącza to VLAN 10, pomarańczowe to VLAN 20, a zielony trunk przenosi oba. pc2 zaczyna w `192.168.10.0/24` i w Kroku 8 przechodzi do `192.168.20.0/24`.*

Hosty używają adresów MAC z bloku dokumentacyjnego RFC 7042 (`00:00:5e:00:53:xx`), więc wyniki, które zobaczysz, zgadzają się z tym przewodnikiem.

| Przestrzeń nazw | Rola | Interfejs | MAC | Adres IP (końcowy) | Port mostu |
|---|---|---|---|---|---|
| `pc1` | Host, VLAN 10 | `eth0` | `00:00:5e:00:53:01` | `192.168.10.11/24` | `p1`, access VLAN 10 |
| `pc2` | Host, VLAN 20 | `eth0` | `00:00:5e:00:53:02` | `192.168.20.12/24` | `p2`, access VLAN 20 |
| `pc3` | Host, VLAN 10 | `eth0` | `00:00:5e:00:53:03` | `192.168.10.13/24` | `p3`, access VLAN 10 |
| `r1` | Router-on-a-stick | `eth0`, `eth0.10`, `eth0.20` | `00:00:5e:00:53:fe` | `192.168.10.1/24`, `192.168.20.1/24` | `p4`, trunk 10, 20 |
| `sw1` | Przełącznik | `br0`, `p1`–`p4` | losowy | brak | — |

## Kroki

> [!NOTE]
> Każde polecenie wykonuj w pierwszym terminalu, chyba że krok mówi „terminal 2”. Pokazane wyniki pochodzą z iproute2 6.17, tcpdump 4.99.6 i iputils 20250605. Znaczniki czasu, czasy i numery indeksów interfejsów (takie jak `@if4`) będą na Twojej maszynie inne. Ustawienia regionalne inne niż angielskie tłumaczą niektóre komunikaty: uruchom oba terminale z `export LC_ALL=C`, aby uzyskać takie samo brzmienie jak w tym przewodniku.

### Krok 1 — Sprawdź narzędzia
Upewnij się, że polecenia istnieją i są dostatecznie nowe, zanim cokolwiek zbudujesz.

```bash
ip -V
bridge -V
tcpdump --version
```

Oczekiwane wyjście (Twoje wersje mogą być nowsze):
```text
ip utility, iproute2-6.17.0, libbpf 1.6.3
bridge utility, 6.17.0
tcpdump version 4.99.6
libpcap version 1.10.7 (64-bit time_t, with TPACKET_V3)
...
```

### Krok 2 — Utwórz przestrzenie nazw
Każda przestrzeń nazw to jedno urządzenie Twojej sieci: przełącznik, trzy komputery i router. Wyłączasz w nich też IPv6. Nie jest to potrzebne, by VLAN-y działały, ale powstrzymuje hosty przed wysyłaniem komunikatów wykrywania IPv6, więc tablica MAC i zrzuty pokazują tylko ruch, który sam generujesz.

```bash
for ns in sw1 pc1 pc2 pc3 r1; do
  sudo ip netns add $ns
  sudo ip netns exec $ns sysctl -qw net.ipv6.conf.all.disable_ipv6=1 net.ipv6.conf.default.disable_ipv6=1
done
ip netns list
```

Oczekiwane wyjście:
```text
r1
pc3
pc2
pc1
sw1
```

### Krok 3 — Utwórz przełącznik
**Most (bridge)** Linux to programowy przełącznik: uczy się adresów MAC i przekazuje ramki dokładnie tak, jak opisuje lekcja. Z `vlan_filtering 1` śledzi też VLAN-y na portach, jak zarządzalny przełącznik. Tworzysz go wewnątrz `sw1` z opcją `-n sw1`, która wykonuje polecenie `ip` lub `bridge` w tej przestrzeni nazw.

```bash
sudo ip -n sw1 link add br0 type bridge vlan_filtering 1
sudo ip -n sw1 link set br0 up
sudo ip -n sw1 -d link show br0 | grep -o -E 'vlan_filtering [0-9]+|ageing_time [0-9]+'
sudo bridge -n sw1 vlan show
```

Oczekiwane wyjście:
```text
ageing_time 30000
vlan_filtering 1
port              vlan-id  
br0               1 PVID Egress Untagged
```

- `ageing_time 30000` to czas wygasania tablicy MAC w setnych częściach sekundy: 300 sekund, popularna wartość domyślna z lekcji.
- `bridge vlan show` wypisuje VLAN-y każdego portu. Na razie istnieje tylko sam `br0`, w VLAN 1. **PVID** (port VLAN ID) to VLAN, do którego dołączają przychodzące ramki bez znacznika, a **Egress Untagged** oznacza, że ramki tego VLAN-u opuszczają port bez znacznika. Razem sprawiają, że port jest portem access dla tego VLAN-u.

### Krok 4 — Podłącz trzy komputery
Teraz podłączasz komputery do przełącznika. Dla każdego komputera jedno polecenie tworzy parę veth: koniec o nazwie `p1` (lub `p2`, `p3`) zostaje w `sw1`, a koniec o nazwie `eth0` trafia do przestrzeni nazw komputera. Następnie ustawiasz adres MAC komputera, podłączasz koniec po stronie przełącznika do `br0` i włączasz oba końce. Na początku wszystkie trzy komputery dzielą jedną podsieć, `192.168.10.0/24`.

```bash
for i in 1 2 3; do
  sudo ip -n sw1 link add p$i type veth peer name eth0 netns pc$i
  sudo ip -n pc$i link set eth0 address 00:00:5e:00:53:0$i
  sudo ip -n sw1 link set p$i master br0
  sudo ip -n sw1 link set p$i up
  sudo ip -n pc$i link set eth0 up
done
sudo ip -n pc1 addr add 192.168.10.11/24 dev eth0
sudo ip -n pc2 addr add 192.168.10.12/24 dev eth0
sudo ip -n pc3 addr add 192.168.10.13/24 dev eth0
sudo bridge -n sw1 vlan show
sudo ip -n pc2 -br addr
```

Oczekiwane wyjście:
```text
port              vlan-id  
br0               1 PVID Egress Untagged
p1                1 PVID Egress Untagged
p2                1 PVID Egress Untagged
p3                1 PVID Egress Untagged
lo               DOWN           
eth0@if4         UP             192.168.10.12/24 
```

Każdy nowy port dołącza do VLAN 1 jako port access, tak jak nowy przełącznik sprzętowy. Wszystkie trzy komputery są w jednej domenie rozgłoszeniowej.


### Krok 5 — Obserwuj, jak przełącznik uczy się i zalewa
Najpierw zajrzyj do **bazy przekazywania** (FDB, forwarding database) przełącznika, czyli tak Linux nazywa tablicę adresów MAC. Słowo kluczowe `dynamic` pokazuje tylko poznane wpisy i ukrywa stałe wpisy samego mostu.

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Oczekiwane wyjście: nic. Żaden komputer nie wysłał jeszcze ramki, więc przełącznik niczego się nie nauczył.

> [!TIP]
> Jeśli Twoje polecenie `bridge` nie przyjmuje `dynamic`, uruchom zamiast tego `sudo bridge -n sw1 fdb show br br0 | grep -v permanent`.

Teraz uruchom przechwytywanie na pc3, który nie bierze udziału w rozmowie, którą zaraz zaczniesz. W **terminalu 2**:

```bash
sudo ip netns exec pc3 tcpdump -e -n -i eth0 arp or icmp
```

`ip netns exec pc3` uruchamia tcpdump wewnątrz pc3. `-e` wypisuje adresy MAC każdej ramki, `-n` wyłącza rozwiązywanie nazw, a `arp or icmp` pokazuje tylko ruch ARP i ping.

W **terminalu 1** wykonaj ping z pc1 do pc2:

```bash
sudo ip netns exec pc1 ping -c 2 192.168.10.12
```

Oczekiwane wyjście (czasy się różnią):
```text
PING 192.168.10.12 (192.168.10.12) 56(84) bytes of data.
64 bytes from 192.168.10.12: icmp_seq=1 ttl=64 time=0.054 ms
64 bytes from 192.168.10.12: icmp_seq=2 ttl=64 time=0.056 ms

--- 192.168.10.12 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1037ms
rtt min/avg/max/mdev = 0.054/0.055/0.056/0.001 ms
```

Zatrzymaj przechwytywanie w terminalu 2 przez Ctrl+C. Oczekiwane wyjście w terminalu 2:
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
22:16:36.485926 00:00:5e:00:53:01 > Broadcast, ethertype ARP (0x0806), length 42: Request who-has 192.168.10.12 tell 192.168.10.11, length 28
^C
1 packet captured
1 packet received by filter
0 packets dropped by kernel
```

pc3 zobaczył dokładnie jedną ramkę: zapytanie ARP od pc1, wysłane na adres broadcast i dlatego zalane na wszystkie porty. **Nie** zobaczył odpowiedzi ARP ani czterech pakietów ping. Gdy pc2 odpowiedział, przełącznik znał już port pc1 (poznany ze źródła zapytania ARP), więc przekazał odpowiedź tylko do `p1` i z niej poznał port pc2.

Sprawdź tablicę jeszcze raz:

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Oczekiwane wyjście:
```text
00:00:5e:00:53:01 dev p1 vlan 1 master br0 
00:00:5e:00:53:02 dev p2 vlan 1 master br0 
```

Przełącznik poznał pc1 na `p1` i pc2 na `p2`, oba w VLAN 1. pc3 nic nie wysłał, więc nie ma go jeszcze w tablicy.

### Krok 6 — Podziel komputery na dwa VLAN-y
Teraz robisz z `p1` i `p3` porty access w VLAN 10, a z `p2` port access w VLAN 20. `pvid untagged` czyni VLAN VLAN-em dostępowym portu. Potem usuwasz VLAN 1 z trzech portów, tak by każdy port należał do dokładnie jednego VLAN-u.

```bash
sudo bridge -n sw1 vlan add dev p1 vid 10 pvid untagged
sudo bridge -n sw1 vlan add dev p3 vid 10 pvid untagged
sudo bridge -n sw1 vlan add dev p2 vid 20 pvid untagged
sudo bridge -n sw1 vlan del dev p1 vid 1
sudo bridge -n sw1 vlan del dev p2 vid 1
sudo bridge -n sw1 vlan del dev p3 vid 1
sudo bridge -n sw1 vlan show
```

Oczekiwane wyjście:
```text
port              vlan-id  
br0               1 PVID Egress Untagged
p1                10 PVID Egress Untagged
p2                20 PVID Egress Untagged
p3                10 PVID Egress Untagged
```

pc2 nadal ma adres `192.168.10.12/24`, w tej samej podsieci co pc1. Wyczyść pamięć podręczną ARP na pc1, żeby musiał zapytać ponownie, a następnie wykonaj ping do pc3 (ten sam VLAN) i pc2 (inny VLAN):

```bash
sudo ip -n pc1 neigh flush all
sudo ip netns exec pc1 ping -c 2 192.168.10.13
sudo ip netns exec pc1 ping -c 2 192.168.10.12
sudo ip -n pc1 neigh show
```

Oczekiwane wyjście (czasy się różnią):
```text
PING 192.168.10.13 (192.168.10.13) 56(84) bytes of data.
64 bytes from 192.168.10.13: icmp_seq=1 ttl=64 time=0.038 ms
64 bytes from 192.168.10.13: icmp_seq=2 ttl=64 time=0.051 ms

--- 192.168.10.13 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1009ms
rtt min/avg/max/mdev = 0.038/0.044/0.051/0.006 ms
PING 192.168.10.12 (192.168.10.12) 56(84) bytes of data.

--- 192.168.10.12 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1019ms

192.168.10.12 dev eth0 FAILED 
192.168.10.13 dev eth0 lladdr 00:00:5e:00:53:03 REACHABLE 
```

pc1 i pc2 mają adresy w tej samej podsieci, a mimo to pc1 nie potrafi nawet rozwiązać adresu MAC pc2: wpis ARP ma stan `FAILED`. Przełącznik zatrzymuje broadcast pc1 wewnątrz VLAN 10, więc nigdy nie dociera on do portu pc2. To granica VLAN-u w działaniu. Ta sama podsieć czy nie, różne VLAN-y to różne domeny rozgłoszeniowe.

Spójrz na tablicę jeszcze raz:

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Oczekiwane wyjście:
```text
00:00:5e:00:53:01 dev p1 vlan 10 master br0 
00:00:5e:00:53:03 dev p3 vlan 10 master br0 
00:00:5e:00:53:02 dev p2 vlan 20 master br0 
```

Wpisy zawierają teraz VLAN: przełącznik prowadzi jedną tablicę na VLAN. Usunięcie VLAN 1 z portów usunęło też ich dawne wpisy z VLAN 1. Wiersz pc2 w VLAN 20 pojawia się dopiero, gdy pc2 wyśle ramkę w swoim nowym VLAN-ie (np. sondę ARP); jeśli go nie ma na Twojej maszynie, to w porządku.

### Krok 7 — Dodaj port trunk dla routera
Router musi dotrzeć do obu VLAN-ów jednym kablem, więc jego port na przełączniku to trunk. Dodaj czwartą parę veth: `p4` w przełączniku, `eth0` w `r1`. Następnie uczyń `p4` oznakowanym członkiem VLAN-ów 10 i 20. Bez słów kluczowych `pvid untagged` ramki tych VLAN-ów opuszczają `p4` ze znacznikiem 802.1Q. Usunięcie VLAN 1 oznacza, że `p4` nie ma VLAN-u natywnego: ramki bez znacznika, które na niego przychodzą, są odrzucane.

```bash
sudo ip -n sw1 link add p4 type veth peer name eth0 netns r1
sudo ip -n r1 link set eth0 address 00:00:5e:00:53:fe
sudo ip -n sw1 link set p4 master br0
sudo ip -n sw1 link set p4 up
sudo bridge -n sw1 vlan add dev p4 vid 10
sudo bridge -n sw1 vlan add dev p4 vid 20
sudo bridge -n sw1 vlan del dev p4 vid 1
sudo bridge -n sw1 vlan show dev p4
```

Oczekiwane wyjście:
```text
port              vlan-id  
p4                10
                  20
```

Brak `PVID` i brak `Egress Untagged`: `p4` przenosi oba VLAN-y, ze znacznikami. To jest trunk.


### Krok 8 — Skonfiguruj router-on-a-stick
W `r1` tworzysz po jednym **podinterfejsie VLAN** na VLAN nad `eth0`. `eth0.10` wysyła i odbiera ramki ze znacznikiem VLAN 10, a `eth0.20` ramki ze znacznikiem VLAN 20. Każdy dostaje adres bramy swojego VLAN-u. Włączenie przekazywania IP sprawia, że `r1` routuje między nimi.

```bash
sudo ip -n r1 link set eth0 up
sudo ip -n r1 link add link eth0 name eth0.10 type vlan id 10
sudo ip -n r1 link add link eth0 name eth0.20 type vlan id 20
sudo ip -n r1 addr add 192.168.10.1/24 dev eth0.10
sudo ip -n r1 addr add 192.168.20.1/24 dev eth0.20
sudo ip -n r1 link set eth0.10 up
sudo ip -n r1 link set eth0.20 up
sudo ip netns exec r1 sysctl -w net.ipv4.ip_forward=1
sudo ip -n r1 -d link show eth0.20 | grep -o 'vlan protocol [^ ]* id [0-9]*'
sudo ip -n r1 -br addr
```

Oczekiwane wyjście:
```text
net.ipv4.ip_forward = 1
vlan protocol 802.1Q id 20
lo               DOWN           
eth0@if6         UP             
eth0.10@eth0     UP             192.168.10.1/24 
eth0.20@eth0     UP             192.168.20.1/24 
```

Sam `eth0` nie ma adresu: jest tylko fizycznym łączem, które przenosi ramki ze znacznikami.

Teraz nadaj pc2 adres w podsieci VLAN 20 i dodaj każdemu komputerowi bramę domyślną w jego własnym VLAN-ie:

```bash
sudo ip -n pc2 addr flush dev eth0
sudo ip -n pc2 addr add 192.168.20.12/24 dev eth0
sudo ip -n pc1 route add default via 192.168.10.1
sudo ip -n pc3 route add default via 192.168.10.1
sudo ip -n pc2 route add default via 192.168.20.1
sudo ip -n pc1 route
```

Oczekiwane wyjście:
```text
default via 192.168.10.1 dev eth0 
192.168.10.0/24 dev eth0 proto kernel scope link src 192.168.10.11 
```

### Krok 9 — Zobacz znaczniki 802.1Q na trunku
Przechwytuj ruch na porcie trunk `p4`, wewnątrz przełącznika, gdy pc1 pinguje pc2 między VLAN-ami. W **terminalu 2**:

```bash
sudo ip netns exec sw1 tcpdump -e -n -i p4 -c 8 vlan
```

Filtr `vlan` zostawia tylko ramki ze znacznikiem, a `-c 8` zatrzymuje się po ośmiu pakietach.

W **terminalu 1**:

```bash
sudo ip netns exec pc1 ping -c 1 192.168.20.12
```

Oczekiwane wyjście w terminalu 1 (czasy się różnią):
```text
PING 192.168.20.12 (192.168.20.12) 56(84) bytes of data.
64 bytes from 192.168.20.12: icmp_seq=1 ttl=63 time=0.082 ms

--- 192.168.20.12 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.082/0.082/0.082/0.000 ms
```

Oczekiwane wyjście w terminalu 2:
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on p4, link-type EN10MB (Ethernet), snapshot length 262144 bytes
22:16:53.622170 00:00:5e:00:53:01 > Broadcast, ethertype 802.1Q (0x8100), length 46: vlan 10, p 0, ethertype ARP (0x0806), Request who-has 192.168.10.1 tell 192.168.10.11, length 28
22:16:53.622187 00:00:5e:00:53:fe > 00:00:5e:00:53:01, ethertype 802.1Q (0x8100), length 46: vlan 10, p 0, ethertype ARP (0x0806), Reply 192.168.10.1 is-at 00:00:5e:00:53:fe, length 28
22:16:53.622198 00:00:5e:00:53:01 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 102: vlan 10, p 0, ethertype IPv4 (0x0800), 192.168.10.11 > 192.168.20.12: ICMP echo request, id 29489, seq 1, length 64
22:16:53.622204 00:00:5e:00:53:fe > Broadcast, ethertype 802.1Q (0x8100), length 46: vlan 20, p 0, ethertype ARP (0x0806), Request who-has 192.168.20.12 tell 192.168.20.1, length 28
22:16:53.622214 00:00:5e:00:53:02 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 46: vlan 20, p 0, ethertype ARP (0x0806), Reply 192.168.20.12 is-at 00:00:5e:00:53:02, length 28
22:16:53.622216 00:00:5e:00:53:fe > 00:00:5e:00:53:02, ethertype 802.1Q (0x8100), length 102: vlan 20, p 0, ethertype IPv4 (0x0800), 192.168.10.11 > 192.168.20.12: ICMP echo request, id 29489, seq 1, length 64
22:16:53.622224 00:00:5e:00:53:02 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 102: vlan 20, p 0, ethertype IPv4 (0x0800), 192.168.20.12 > 192.168.10.11: ICMP echo reply, id 29489, seq 1, length 64
22:16:53.622226 00:00:5e:00:53:fe > 00:00:5e:00:53:01, ethertype 802.1Q (0x8100), length 102: vlan 10, p 0, ethertype IPv4 (0x0800), 192.168.20.12 > 192.168.10.11: ICMP echo reply, id 29489, seq 1, length 64
8 packets captured
8 packets received by filter
0 packets dropped by kernel
```

Przeczytaj je linia po linii. To Rysunek 4 z lekcji, przechwycony na żywo:

- `ethertype 802.1Q (0x8100)` to TPID; `vlan 10` to VID; `p 0` to priorytet PCP. Potem następuje prawdziwy EtherType danych.
- **Linie 1–3, VLAN 10:** pc1 pyta o MAC swojej bramy (ARP), r1 odpowiada z `eth0.10`, a pc1 wysyła ping na MAC routera r1.
- **Linie 4–6, VLAN 20:** r1 routuje pakiet. Pyta o MAC hosta pc2 w VLAN 20 i wysyła ping tym samym kablem, teraz ze znacznikiem 20, z własnego MAC na MAC hosta pc2.
- **Linie 7–8:** odpowiedź idzie odwrotną drogą.
- `ttl=63` w pingu w terminalu 1 (zamiast 64) pokazuje, że pakiet obsłużył jeden router.

Adresy IP (`192.168.10.11 > 192.168.20.12`) nigdy się nie zmieniają. Zmieniają się adresy MAC i znacznik VLAN. pc1 i pc2 nigdy nie widziały znacznika: most dodawał je i zdejmował na `p4`.

Na koniec zajrzyj do tablicy przełącznika:

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Oczekiwane wyjście:
```text
00:00:5e:00:53:01 dev p1 vlan 10 master br0 
00:00:5e:00:53:02 dev p2 vlan 20 master br0 
00:00:5e:00:53:03 dev p3 vlan 10 master br0 
00:00:5e:00:53:fe dev p4 vlan 20 master br0 
00:00:5e:00:53:fe dev p4 vlan 10 master br0 
```

MAC routera r1 pojawia się dwa razy na porcie trunk, raz na VLAN, bo każdy VLAN ma własną tablicę.

## Weryfikacja
Laboratorium jest ukończone, gdy wszystkie poniższe warunki są spełnione:

1. `sudo bridge -n sw1 vlan show` wypisuje `p1` i `p3` jako `10 PVID Egress Untagged`, `p2` jako `20 PVID Egress Untagged` oraz `p4` z `10` i `20` bez `PVID`.
2. Ten sam VLAN, bezpośrednio: `sudo ip netns exec pc1 ping -c 1 192.168.10.13` zgłasza `1 received`.
3. Różne VLAN-y, przez router: `sudo ip netns exec pc1 ping -c 1 192.168.20.12` i `sudo ip netns exec pc3 ping -c 1 192.168.20.12` zgłaszają oba `1 received`, z `ttl=63`.
4. Ścieżka prowadzi przez r1:
   ```bash
   sudo ip netns exec pc1 tracepath -n 192.168.20.12
   ```
   Oczekiwane wyjście (czasy się różnią; `tracepath` jest częścią iputils):
   ```text
    1?: [LOCALHOST]                      pmtu 1500
    1:  192.168.10.1                                          0.104ms 
    1:  192.168.10.1                                          0.022ms 
    2:  192.168.20.12                                         0.020ms reached
        Resume: pmtu 1500 hops 2 back 2 
   ```
5. Potrafisz wyjaśnić na podstawie zrzutu z Kroku 9, gdzie znacznik jest dodawany i zdejmowany oraz dlaczego adresy MAC zmieniają się na r1.

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `RTNETLINK answers: Operation not permitted` lub `mkdir /var/run/netns failed: Permission denied` | Uruchomiono polecenie zmieniające sieć bez `sudo`. | Poprzedź polecenie `sudo`. |
| `RTNETLINK answers: File exists` lub `Cannot create namespace file "/var/run/netns/sw1": File exists` | Pozostałości po wcześniejszej próbie. | Wykonaj [Sprzątanie](#sprzątanie), a potem zacznij od Kroku 2. |
| `Cannot open network namespace "pc1": No such file or directory` | Pominięto krok albo sprzątanie już wykonano. | Uruchom `ip netns list` i powtórz brakujące polecenia tworzenia. |
| Pingi w tym samym VLAN-ie nie działają po Kroku 6 | Port nadal jest w VLAN 1 albo jego VLAN nie ma `pvid untagged`. | Porównaj `sudo bridge -n sw1 vlan show` z punktem 1 Weryfikacji i popraw port przez `bridge vlan add` / `del`. |
| Pingi między VLAN-ami nie działają, ale pingi wewnątrz każdego VLAN-u tak | Przekazywanie IP jest wyłączone na r1, podinterfejs jest wyłączony, komputer nie ma trasy domyślnej albo na `p4` brakuje VLAN-u. | Sprawdź `sudo ip netns exec r1 sysctl net.ipv4.ip_forward` (musi być `1`), `sudo ip -n r1 -br addr` (oba podinterfejsy `UP`), `sudo ip -n pc2 route` i `sudo bridge -n sw1 vlan show dev p4`. |
| Zrzut z Kroku 9 niczego nie pokazuje | Przechwytywano na złym interfejsie lub w złej przestrzeni nazw albo wpisy ARP były już w pamięci podręcznej i ominęły Cię pierwsze pakiety. | Przechwytuj z `-i p4` wewnątrz `sw1`, uruchom tcpdump przed pingiem i wykonaj `sudo ip -n pc1 neigh flush all` oraz `sudo ip -n r1 neigh flush all`, by znów zobaczyć wymianę ARP. |
| `tcpdump: command not found` | tcpdump nie jest zainstalowany. | Zainstaluj go (`sudo dnf install tcpdump` lub `sudo apt install tcpdump`). |
| `bridge fdb show ... dynamic` kończy się błędem składni lub użycia | Starszy iproute2 bez słowa kluczowego `dynamic`. | Użyj `sudo bridge -n sw1 fdb show br br0 \| grep -v permanent`. |

## Wyzwanie (opcjonalne)
Zbuduj pętlę przełączania i pozwól Spanning Tree ją przerwać. Utwórz drugą przestrzeń nazw przełącznika `sw2` z własnym mostem i połącz `sw1` i `sw2` **dwiema** parami veth. Zanim podłączysz drugi kabel, włącz STP na obu mostach (`ip link set br0 type bridge stp_state 1`). Poczekaj około 30 sekund (dwa opóźnienia przekazywania po 15 sekund), a potem użyj `bridge -n sw2 link show`, by znaleźć port w stanie `blocking`. Który przełącznik został root bridge i dlaczego? (Wskazówka: `ip -d link show br0` pokazuje `root_id` i `bridge_id`.) Co się zmieni, jeśli obniżysz priorytet `sw2` poleceniem `ip link set br0 type bridge priority 4096`?

> [!NOTE]
> Most w jądrze Linuksa implementuje klasyczny STP 802.1D, dlatego trwa to około 30 sekund. RSTP w Linuksie wymaga osobnego demona w przestrzeni użytkownika (np. `mstpd`), co wykracza poza to laboratorium. Wykonuj wyzwanie wyłącznie wewnątrz przestrzeni nazw, nigdy nie spinając mostem swoich prawdziwych interfejsów sieciowych: pętla w prawdziwej sieci może ją położyć.

## Sprzątanie
Usuń most, a potem wszystkie przestrzenie nazw. Usunięcie przestrzeni nazw usuwa też wszystkie interfejsy w niej, a usunięcie jednego końca pary veth usuwa także drugi koniec, więc żaden veth nie zostaje.

```bash
sudo ip -n sw1 link del br0
for ns in sw1 pc1 pc2 pc3 r1; do sudo ip netns del $ns; done
sudo ip netns del sw2 2>/dev/null   # only if you did the challenge
ip netns list
```

Oczekiwane wyjście: `ip netns list` nic nie wypisuje (albo przynajmniej nie wymienia `sw1`, `sw2`, `pc1`, `pc2`, `pc3` ani `r1`).

Nic innego na Twojej maszynie nie zostało zmienione: ustawienia IPv6 i przekazywania IP, które zmieniono, żyły wewnątrz przestrzeni nazw i zniknęły razem z nimi.

## Co już umiesz
- Przełącznik uczy się adresów MAC ze źródła każdej ramki, zalewa broadcasty i przekazuje znany unicast tylko jednym portem, więc inne hosty nigdy go nie widzą.
- VLAN-y dzielą jeden przełącznik na osobne domeny rozgłoszeniowe: hosty w różnych VLAN-ach nie mogą rozmawiać w warstwie 2, nawet z adresami w tej samej podsieci.
- Port access przenosi jeden VLAN bez znacznika; port trunk przenosi kilka VLAN-ów ze znacznikami 802.1Q (`ethertype 802.1Q (0x8100)`, `vlan <id>`), które można odczytać w zrzucie ruchu.
- Router-on-a-stick routuje między VLAN-ami jednym trunkiem z użyciem podinterfejsów VLAN; każdy trasowany pakiet dwa razy przechodzi przez trunk, z nowym nagłówkiem MAC i innym znacznikiem.
- Przełącznik prowadzi osobną tablicę MAC dla każdego VLAN-u, więc ten sam MAC może występować w kilku VLAN-ach na jednym porcie trunk.
