---
title: "Laboratorium: projektowanie i walidacja planu adresacji"
domain: networking
level: intermediate
duration: "60 min"
cost: "bezpłatnie"
environment: "maszyna lokalna z Pythonem 3 (dowolny system); opcjonalnie: maszyna z Linuksem lub VM z sudo do Kroku 8"
lang: pl
source_hash: 65c96f2cb08f
---

# Laboratorium: projektowanie i walidacja planu adresacji

## Cel
Projektujesz plan adresacji IPv4 dla fikcyjnej firmy z trzema lokalizacjami, używając VLSM w prywatnym bloku `10.20.0.0/16`. Potem sprawdzasz go małym skryptem w Pythonie, który wychwytuje nakładanie się, zbyt małe podsieci i niewyrównane prefiksy, i naprawiasz wadliwy plan.

## Cele
- Dobrać rozmiar każdego segmentu sieci za pomocą najdłuższego prefiksu, który pokrywa jego liczbę hostów.
- Przydzielić plan VLSM dla każdej lokalizacji, od największej podsieci, na wyrównanych granicach.
- Wybrać jeden blok na lokalizację tak, aby każdą lokalizację można było ogłosić jako jedną trasę zbiorczą.
- Zwalidować plan automatycznie (zawieranie, nakładanie, pojemność, wolne miejsce) i naprawić znalezione błędy.
- (Opcjonalnie) Zaobserwować w Linuksie, jak błędna maska podsieci psuje osiągalność.

## Wymagania wstępne
- Python 3.8 lub nowszy (używana jest tylko biblioteka standardowa). Sprawdź przez `python3 --version`; w Windows użyj `py` zamiast `python3`.
- Edytor tekstu i terminal.
- [Lekcja](lesson.pl.md) z tego modułu, zwłaszcza VLSM i podsumowywanie tras.
- Tylko do opcjonalnego Kroku 8: maszyna z Linuksem lub VM, na której możesz używać `sudo`, z zainstalowanymi iproute2 (`ip`) i `ping`.

> [!WARNING]
> Kroki 1–7 tworzą tylko pliki w folderze w twoim katalogu domowym. Krok 8 tworzy przestrzenie nazw sieci (network namespaces) i wymaga `sudo`: uruchom go na maszynie testowej lub w VM, nie na serwerze produkcyjnym. Używa zakresu dokumentacyjnego `198.51.100.0/24` (RFC 5737) i nie dotyka twoich rzeczywistych interfejsów sieciowych. Zawsze wykonaj na końcu sekcję [Sprzątanie](#sprzątanie).

## Architektura
Example Corp ma centralę (HQ) i dwa oddziały (BR1, BR2), połączone łączami WAN punkt-punkt. Posiada blok RFC 1918 `10.20.0.0/16` na całą swoją wewnętrzną adresację.

![Example Corp: centrala HQ z segmentami Pracownicy, Głos, Goście, Serwery i Zarządzanie, oddziały BR1 i BR2 z ich segmentami, połączone łączami WAN /31, z BR1–BR2 jako zapasowym](../../../assets/diagrams/subnetting-lab-sites.pl.svg)

*Rysunek 1. Lokalizacje Example Corp i segmenty, których potrzebuje każda z nich. Trzy łącza WAN to sieci punkt-punkt /31.*

Wymagania, w hostach potrzebnych dziś wraz z zapasem na rozwój:

| Lokalizacja | Segment | Hosty |
|---|---|---|
| HQ | Staff (pracownicy) | 900 |
| HQ | Voice (głos) | 400 |
| HQ | Guest (goście) | 250 |
| HQ | Servers (serwery) | 200 |
| HQ | Management (zarządzanie) | 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 | po 2 |

Zasady projektowe:
1. Każda lokalizacja dostaje **jeden wyrównany blok**, aby reszta sieci mogła do niej dotrzeć jedną trasą zbiorczą.
2. Wszystkie łącza WAN pochodzą z jednego bloku infrastruktury, `10.20.255.0/24`, i używają prefiksów /31 (RFC 3021).
3. W każdej lokalizacji przydzielaj segmenty od największego, zaczynając od początku bloku lokalizacji.

## Kroki

### Krok 1 — Utwórz przestrzeń roboczą
Trzymaj wszystkie pliki tego laboratorium w jednym folderze, aby sprzątanie było jednym poleceniem.

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

Oczekiwany wynik (działa każda wersja od 3.8):
```text
Python 3.14.7
```

### Krok 2 — Dobierz rozmiar każdego segmentu
Zanim dotkniesz jakiegokolwiek adresu, zdecyduj o długości prefiksu każdego segmentu. Użyj tabeli potęg dwójki z lekcji: znajdź najdłuższy prefiks, którego użyteczne hosty (2<sup>bity hosta</sup> − 2) pokrywają potrzebę.

Wypełnij tę tabelę na papierze lub w pliku tekstowym:

| Lokalizacja | Segment | Hosty | Prefiks | Rozmiar bloku |
|---|---|---|---|---|
| HQ | Staff | 900 | ? | ? |
| HQ | Voice | 400 | ? | ? |
| … | … | … | … | … |

<details>
<summary>Pokaż rozmiary</summary>

| Lokalizacja | Segment | Hosty | Prefiks | Użyteczne | Rozmiar bloku |
|---|---|---|---|---|---|
| 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 | każde łącze | 2 | /31 | 2 | 2 |

</details>

### Krok 3 — Wybierz jeden blok na lokalizację
Zsumuj rozmiary bloków każdej lokalizacji i zaokrąglij w górę do następnej potęgi dwójki. To najmniejszy blok, który mieści całą lokalizację i nadal można go podsumować w jedną trasę.

- HQ: 1024 + 512 + 256 + 256 + 64 = 2112 adresów. Następna potęga dwójki to 4096, czyli **/20**.
- BR1: 128 + 64 + 64 + 16 = 272 adresy. Następna potęga dwójki to 512, czyli **/23**.
- BR2: 64 + 32 + 8 = 104 adresy. Minimum to /25 (128). Ten projekt zaokrągla je do **/24**, aby zostawić zapas na rozwój.

Bloki lokalizacji też ułóż od największego, każdy na własnej granicy. Jeden poprawny wybór:

| Lokalizacja | Blok | Dlaczego jest poprawny |
|---|---|---|
| HQ | `10.20.0.0/20` | Zaczyna się od 0, wielokrotności 16 w trzecim oktecie. |
| BR1 | `10.20.16.0/23` | 16 jest wielokrotnością 2. |
| BR2 | `10.20.18.0/24` | Następuje bezpośrednio po BR1. |
| WAN | `10.20.255.0/24` | Wynika z zasad projektowych; daleko od lokalizacji, aby mogły rosnąć. |

> [!TIP]
> Jeśli chcesz innych bloków lokalizacji, nie ma problemu, o ile każdy jest wyrównany i nie nakładają się na siebie. Twój wynik w Kroku 6 będzie się wtedy różnił od pokazanego, ale nadal musi kończyć się na `PASS`.

### Krok 4 — Przydziel segmenty i zapisz plan
Teraz umieść segmenty w każdym bloku lokalizacji, od największego. W HQ Staff (/22) zaczyna się od `10.20.0.0`, więc kończy na `10.20.3.255`. Voice (/23) zaczyna się od następnego adresu, `10.20.4.0`, i tak dalej.

Zapisz plan jako plik wartości rozdzielanych przecinkami (CSV, comma-separated values) o nazwie `plan.csv`, z jednym wierszem na segment i jednym wierszem `BLOCK` na lokalizację:

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

Kolumny to:
- `site`: nazwa lokalizacji (`HQ`, `BR1`, `BR2` lub `WAN`).
- `segment`: nazwa segmentu albo `BLOCK` dla bloku zbiorczego lokalizacji.
- `prefix`: sieć w notacji CIDR.
- `hosts`: potrzebne hosty (w wierszach `BLOCK` zostaw puste).

Najpierw spróbuj samodzielnie, potem porównaj z planem wzorcowym.

<details>
<summary>Pokaż plan wzorcowy</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>

### Krok 5 — Utwórz walidator
Sprawdzanie planu ręcznie jest powolne i podatne na błędy. Ten skrypt używa modułu `ipaddress` z biblioteki standardowej Pythona, by sprawdzić każdą regułę z lekcji:

- każdy prefiks jest prawdziwym adresem sieci (żadne bity hosta nie są ustawione, więc jest wyrównany),
- wszystko leży w `10.20.0.0/16`, a każdy segment leży w bloku swojej lokalizacji,
- bloki lokalizacji nie nakładają się, a segmenty nie nakładają się,
- każdy segment ma dość użytecznych adresów (/31 = 2, /32 = 1, w pozostałych przypadkach rozmiar bloku − 2).

Drukuje też plan jako tabelę z maską, zakresem hostów i wolnymi adresami każdego segmentu.

```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]
> „Wolne adresy w segmentach” (`Spare`) liczą wszystkie adresy w przydzielonych podsieciach, które nie są wymaganymi hostami, łącznie z adresami sieci i broadcast. Pokazują, ile zapasu na rozwój (lub marnotrawstwa) ma plan, a nie ile hostów możesz jeszcze dodać.

### Krok 6 — Zwaliduj swój plan
Uruchom walidator na swoim planie:

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

Oczekiwany wynik dla planu wzorcowego:
```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
```

Czytaj wynik jak recenzent:
- **Trasy zbiorcze.** Reszta sieci potrzebuje tylko czterech tras, by dotrzeć do wszystkich podsieci Example Corp.
- **Kolumna Spare.** BR2 Management ma 0 wolnych adresów: siódme urządzenie wymusi przenumerowanie. W prawdziwym projekcie prawdopodobnie dałbyś mu /28. Zaraz za nim jest wolne miejsce w `10.20.18.0/24`.
- **Zapas na rozwój.** HQ zajmuje 2112 z 4096 adresów swojego /20, więc `10.20.8.64`–`10.20.15.255` jest nadal wolne dla nowych segmentów HQ.

### Krok 7 — Znajdź i napraw błędy w wadliwym planie
Kolega przysłał ci ten plan. Zawiera kilka błędów z lekcji. Zapisz go i uruchom walidator:

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

Oczekiwany wynik (końcówka):
```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
```

Skopiuj plik (`cp broken.csv fixed.csv`), edytuj `fixed.csv`, aż `python3 validate_plan.py fixed.csv` wypisze `PASS`, i dla każdego błędu zapisz, którą regułę z lekcji łamie. Zmień jak najmniej wierszy.

> [!TIP]
> Pięć komunikatów nie zawsze oznacza pięć błędów. Jeden błędny wiersz może łamać dwie reguły naraz.

<details>
<summary>Pokaż poprawki</summary>

Są cztery błędne wiersze:

| Wiersz | Błąd | Poprawka |
|---|---|---|
| `HQ,Voice,10.20.4.0/24,400` | Za mała: /24 ma 254 użyteczne hosty, a potrzeba 400. | `10.20.4.0/23` |
| `HQ,Guest,10.20.6.0/23,250` | Za duża: /23 obejmuje `10.20.6.0`–`10.20.7.255` i nakłada się na Servers. | `10.20.6.0/24` |
| `BR1,Management,10.20.18.0/28,10` | Poza blokiem BR1 (leży w bloku BR2), więc nakłada się na BR2 Staff i psuje trasę zbiorczą BR1. | `10.20.17.0/28` |
| `BR2,Voice,10.20.18.70/27,25` | Niewyrównana: 70 nie jest wielokrotnością 32. | `10.20.18.64/27` |

Po tych czterech zmianach `fixed.csv` jest identyczny z wzorcowym `plan.csv` i możesz to sprawdzić poleceniem:

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

</details>

### Krok 8 (opcjonalny, Linux, wymaga sudo) — Zobacz, jak błędna maska psuje osiągalność
Walidator wychwytuje błędy na papierze. Ten krok pokazuje, jak ten sam błąd wygląda w działającej sieci. Tworzysz dwie **przestrzenie nazw sieci** (network namespaces, izolowane stosy sieciowe na jednej maszynie z Linuksem), łączysz je wirtualnym kablem Ethernet (veth) i jednej stronie dajesz błędną maskę.

Oba hosty powinny być w `198.51.100.0/26`. Host B dostaje przez pomyłkę `/28`, więc myśli, że jego podsieć to `198.51.100.32/28` (`.33`–`.46`).

![Dwie przestrzenie nazw sieci połączone parą veth: lab-a z 198.51.100.10/26 i lab-b z 198.51.100.40/28. Linijka od .0 do .63 pokazuje, że A uważa za lokalne od .0 do .63, a B tylko od .32 do .47, więc adres .10 hosta A leży poza podsiecią B](../../../assets/diagrams/subnetting-lab-netns.pl.svg)

*Rysunek 2. Ten sam kabel, dwa różne widoki podsieci. A może dotrzeć do B, ale B traktuje adres A jako zdalny i nie ma trasy, by odpowiedzieć.*

Utwórz przestrzenie nazw, kabel i adresy:

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

Oczekiwany wynik (tablica routingu `lab-b`):
```text
198.51.100.32/28 dev veth-b proto kernel scope link src 198.51.100.40
```

Host B uważa za lokalne tylko `198.51.100.32/28`. `198.51.100.10` leży poza nim, a B nie ma żadnej innej trasy.

Wykonaj ping w obu kierunkach:

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

Oczekiwany wynik (czasy się różnią):
```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
```

Obie strony zawodzą inaczej:
- **Z A** adres `.40` wygląda na lokalny (maska A jest poprawna), więc A wysyła zapytanie ARP. B nie odpowiada, bo nie ma trasy powrotnej do `198.51.100.10`. Bez odpowiedzi ARP A zgłasza `Destination Host Unreachable`.
- **Z B** adres `.10` leży poza jego `/28` i nie ma trasy domyślnej, więc jądro w ogóle odmawia wysłania: `Network is unreachable`.

Teraz spróbuj nadać B bramę domyślną leżącą poza jego (błędną) podsiecią:

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

Oczekiwany wynik:
```text
Error: Nexthop has invalid gateway.
```

Linux odrzuca bramę, która nie leży w bezpośrednio podłączonej podsieci. To błąd „brama poza podsiecią” z lekcji.

Popraw maskę i przetestuj ponownie:

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

Oczekiwany wynik (czasy się różnią):
```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]
> Powyższe wyniki pochodzą z iproute2 6.17 i iputils 20250605. Inne wersje formułują komunikaty nieco inaczej, a ustawienia regionalne inne niż angielskie je tłumaczą; uruchamiaj polecenia z `LC_ALL=C`, aby uzyskać wynik po angielsku. Zachowanie routingu jest takie samo.

## Weryfikacja
Laboratorium jest ukończone, gdy:

1. Twój własny plan przechodzi:
   ```bash
   python3 validate_plan.py plan.csv; echo "exit code: $?"
   ```
   Wynik kończy się `PASS: ...` i `exit code: 0`.
2. Twoja poprawiona wersja wadliwego planu przechodzi:
   ```bash
   python3 validate_plan.py fixed.csv; echo "exit code: $?"
   ```
   Wynik kończy się `PASS: ...` i `exit code: 0`.
3. Potrafisz wskazać regułę z lekcji stojącą za każdym z czterech błędów z Kroku 7.
4. (Opcjonalny Krok 8) Po poprawieniu maski `sudo ip netns exec lab-a ping -c 2 198.51.100.40` pokazuje `0% packet loss`.

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `KeyError: 'segment'` (lub `'site'`, `'prefix'`, `'hosts'`) | Brakuje wiersza nagłówka CSV albo jest błędnie napisany. | Niech pierwszy wiersz brzmi dokładnie `site,segment,prefix,hosts`. |
| `ValueError: invalid literal for int() with base 10: ''` | Wiersz segmentu ma pustą kolumnę `hosts`. | Tylko wiersze `BLOCK` mogą mieć puste `hosts`. |
| `... is not a network address (did you mean ...?)` | Prefiks ma ustawione bity hosta: nie zaczyna się na własnej granicy. | Użyj sugerowanej sieci, potem sprawdź ponownie, czy nie nakłada się na sąsiednią. |
| `... is outside its site block ...` | Segment umieszczono w bloku innej lokalizacji albo blok lokalizacji jest za mały. | Przenieś segment do jego własnego bloku lub wybierz większy wyrównany blok lokalizacji. |
| `RTNETLINK answers: Operation not permitted` | Uruchomiono bez `sudo` polecenie `ip` zmieniające sieć. | Poprzedź polecenie `sudo`. |
| `Cannot open network namespace "lab-a": No such file or directory` | Przestrzeń nazw nie istnieje (pominięto krok albo sprzątanie już wykonano). | Uruchom `ip netns list`, potem powtórz polecenia tworzenia z Kroku 8. |
| `File exists` przy tworzeniu przestrzeni nazw lub pary veth | Pozostałości po wcześniejszej próbie. | Uruchom polecenia z sekcji [Sprzątanie](#sprzątanie), potem zacznij Krok 8 od nowa. |

## Wyzwanie (opcjonalne)
Example Corp otwiera trzeci oddział, BR3, z Staff (200 hostów), Voice (100) i Management (10), plus łączem WAN do HQ. Dodaj go do swojego planu bez przenumerowywania czegokolwiek. Potem uporządkuj plan jeszcze bardziej: wybierz blok BR3 tak, aby **wszystkie oddziały** razem (BR1, BR2 i BR3) można było ogłosić do HQ jako jedną trasę zbiorczą. Jaka to trasa i ile miejsca zostawia na przyszłe oddziały? Potwierdź walidatorem.

## Sprzątanie
Usuń pliki laboratorium:

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

Jeśli wykonałeś Krok 8, usuń obie przestrzenie nazw. Usunięcie przestrzeni nazw usuwa też znajdujący się w niej interfejs veth, a usunięcie jednego końca pary veth usuwa drugi.

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

Oczekiwany wynik: `ip netns list` nic nie wypisuje (albo nie wymienia `lab-a` ani `lab-b`).

## Co już umiesz
- Najpierw dobór rozmiaru, potem rozmieszczenie: prefiks każdego segmentu wynika z jego liczby hostów, a blok każdej lokalizacji z sumy jej segmentów zaokrąglonej do potęgi dwójki.
- Przydzielanie od największego na wyrównanych granicach upakowuje podsieci bez luk i sprawia, że każdą lokalizację można podsumować jedną trasą.
- Nakładanie, zbyt małe podsieci i niewyrównane prefiksy łatwo przeoczyć gołym okiem i łatwo wychwycić skryptem.
- Na działającym hoście błędna maska psuje osiągalność asymetrycznie, a Linux odrzuca bramę domyślną leżącą poza podsiecią hosta.
