---
title: "Laboratorium: zbuduj sieć wirtualną na swoim komputerze"
domain: cloud-computing
level: intermediate
duration: "90 min"
cost: "bezpłatne"
environment: "kontenery (Podman w trybie rootless na lokalnym komputerze z Linuxem)"
lang: pl
source_hash: e5f0b827179b
---

# Laboratorium: zbuduj sieć wirtualną na swoim komputerze

## Cel
Budujesz miniaturowe VPC (Virtual Private Cloud) za pomocą Podmana: „publiczną" podsieć, „prywatną" podsieć i kontener-bramę, który trasuje ruch między nimi, wykonuje NAT (Network Address Translation) dla podsieci prywatnej oraz wymusza reguły podobne do grup zabezpieczeń (stanowe) i do sieciowych list ACL (Access Control List, bezstanowe). Testujesz ją, psujesz na trzy realistyczne sposoby i diagnozujesz za pomocą `curl`, `ping` i liczników pakietów zapory.

## Cele nauki
- Zbudować podsieci z nienakładającymi się zakresami prywatnymi i nadać im trasy przez bramę.
- Wykazać, że brama NAT sprawia, iż połączenia wychodzące działają, a podsieć prywatna pozostaje nieosiągalna z zewnątrz.
- Napisać za pomocą nftables stanowy zestaw reguł w stylu grupy zabezpieczeń i bezstanowy zestaw reguł w stylu ACL oraz pokazać różnicę na przykładzie ruchu zwrotnego i portów efemerycznych.
- Wykazać, że wygrywa pierwsza pasująca reguła ACL.
- Zdiagnozować brakującą trasę, brakującą regułę NAT i brakującą regułę ACL na podstawie objawów i liczników.

## Wymagania wstępne
- Komputer z Linuxem z **Podmanem w wersji 4 lub nowszej** działającym w trybie **rootless** (jako zwykły użytkownik; nigdy nie potrzebujesz `sudo`) i z backendem sieciowym netavark. Przetestowano na Podmanie 5.8.7 w Fedorze z jądrem 7.2. Sprawdź poleceniem `podman info --format '{{.Host.NetworkBackend}}'`: powinno wypisać `netavark`.
- Dostęp do Internetu jednorazowo, aby pobrać obraz Alpine Linux (około 8 MB) i kilka pakietów (łącznie około 18 MB). Potem laboratorium nie potrzebuje już Internetu.
- Około 300 MB wolnego miejsca na dysku.
- [Lekcja](lesson.pl.md) z tego modułu, [Sieci 06 — Podział na podsieci](../../networking/06-subnetting/README.pl.md) i [Sieci 10 — Podstawy routingu](../../networking/10-routing-fundamentals/README.pl.md). Laboratorium routingu z tamtego modułu budowało routery z przestrzeni nazw sieci (network namespaces) z użyciem `sudo`; tutaj używasz kontenerów i nie potrzebujesz `sudo`.

> [!WARNING]
> Wszystko działa na Twoim własnym komputerze, w kontenerach i sieciach, których nazwy zaczynają się od `lab-vnet-`. Wszystkie trzy sieci są tworzone z opcją `--internal`, więc nic w laboratorium nie może dotrzeć do Twojej prawdziwej sieci ani do Internetu i nic nie może dotrzeć do laboratorium z zewnątrz. Adresy pochodzą z zakresów prywatnych (`10.30.0.0/16`, RFC 1918) i z zakresu dokumentacyjnego `198.51.100.0/24` (RFC 5737). Jeśli Twoja własna sieć używa już `10.30.1.0/24` lub `10.30.2.0/24`, zmień przedostatnią liczbę we wszystkich adresach w spójny sposób albo wybierz wolny zakres. Kontener-brama dostaje uprawnienie (capability) `NET_ADMIN`, które pozwala mu zmieniać własne ustawienia sieciowe; w Podmanie rootless ta moc obowiązuje tylko w przestrzeni nazw Twojego użytkownika, a nie na hoście. Nie używaj tych opcji dla kontenerów uruchamiających niezaufane oprogramowanie. Na końcu wykonaj sekcję [Sprzątanie](#sprzątanie).

## Architektura
![Trzy wewnętrzne sieci Podmana spotykają się w kontenerze-bramie lab-vnet-gw, który ma interfejsy pub0 10.30.1.254, priv0 10.30.2.254 i out0 198.51.100.254 oraz 198.51.100.50. Podsieć publiczna 10.30.1.0/24 zawiera lab-vnet-bastion 10.30.1.10 z trasą domyślną przez 10.30.1.254. Podsieć prywatna 10.30.2.0/24 zawiera lab-vnet-web 10.30.2.10 na tcp 8080 z trasą domyślną przez 10.30.2.254. Sieć zewnętrzna 198.51.100.0/24 zawiera lab-vnet-internet 198.51.100.10 na tcp 8000, który reprezentuje Internet. Brama stosuje trzy tabele nftables: lab_nat, lab_sg i lab_acl.](../../../assets/diagrams/vnet-lab-architecture.pl.svg)

*Rysunek 1. Jeden kontener-brama pełni role routera, bramy internetowej, bramy NAT i zapory. „Internet" to serwer WWW w trzeciej, izolowanej sieci.*

| Kontener | Sieć i adres | Rola w prawdziwym VPC |
|---|---|---|
| `lab-vnet-bastion` | `lab-vnet-public`, `10.30.1.10` | Instancja w podsieci publicznej, z elastycznym adresem IP (elastic IP) |
| `lab-vnet-web` | `lab-vnet-private`, `10.30.2.10` | Instancja w podsieci prywatnej, obsługująca HTTP na TCP 8080 |
| `lab-vnet-internet` | `lab-vnet-outside`, `198.51.100.10` | Internet: serwer WWW na TCP 8000 |
| `lab-vnet-gw` | `10.30.1.254`, `10.30.2.254`, `198.51.100.254` i `198.51.100.50` | Następny przeskok z tabel tras, brama internetowa, brama NAT i zapora |

> [!NOTE]
> Prawdziwa chmura dzieli pracę bramy na kilka zarządzanych elementów i stosuje filtry na każdym interfejsie. Tutaj robi wszystko jeden kontener, a grupa zabezpieczeń i ACL to reguły na tym kontenerze, napisane dla jednego celu lub jednej podsieci. Zachowanie, które obserwujesz (routing, NAT, filtrowanie stanowe i bezstanowe), jest prawdziwe; uproszczone jest tylko opakowanie. Zauważ też, że podsieć „publiczna" i „prywatna" to w obu przypadkach sieci `--internal`: o tym, czy są publiczne, czy prywatne, decydują reguły bramy, tak jak w prawdziwym VPC decyduje o tym tabela tras i brama.

Podman uruchamia polecenie w kontenerze przez `podman exec lab-vnet-<name> <command>`. Laboratorium robi to cały czas, dlatego każde polecenie jest zapisane w pełnej postaci.

## Kroki

### Krok 1 — Sprawdź narzędzia i utwórz folder roboczy (3 min)
Upewnij się, że Podman działa w trybie rootless i używa netavark oraz że nic nie zostało po wcześniejszej próbie.

```bash
podman --version
podman info --format '{{.Host.NetworkBackend}} rootless={{.Host.Security.Rootless}}'
podman ps -a --filter name=lab-vnet --format '{{.Names}}'
podman network ls --filter name=lab-vnet --format '{{.Name}}'
mkdir -p ~/vnet-lab && cd ~/vnet-lab
```

Oczekiwany wynik (Twoja wersja może się różnić):
```text
podman version 5.8.7
netavark rootless=true
```

Dwa polecenia `ls` nic nie wypisują. Jeśli pokażą nazwy z `lab-vnet-`, najpierw wykonaj [Sprzątanie](#sprzątanie). Wszystkie pliki i polecenia poniżej zakładają, że jesteś w `~/vnet-lab`.

### Krok 2 — Zbuduj obraz z narzędziami (5 min)
Alpine Linux jest malutki, ale nie zawiera potrzebnych Ci narzędzi. Budujesz jeden obraz z `nftables` (zapora Linuksa), `curl`, pełnym poleceniem `ip` i małym serwerem WWW (`httpd`, z pakietu `busybox-extras`). Tag obrazu jest przypięty do Alpine 3.20, dzięki czemu otrzymasz ten sam wynik co w poniższych danych wyjściowych.

```bash
cat > Containerfile <<'EOF'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache nftables curl iproute2 busybox-extras
EOF
podman build -t lab-vnet-tools:1 .
podman run --rm lab-vnet-tools:1 sh -c 'nft --version; curl --version | head -1; ip -V; cat /etc/alpine-release'
```

Oczekiwany wynik (koniec budowania i wersje; wersje pakietów mogą się nieznacznie różnić):
```text
OK: 18 MiB in 40 packages
COMMIT lab-vnet-tools:1
Successfully tagged localhost/lab-vnet-tools:1
nftables v1.0.9 (Old Doc Yak #3)
curl 8.14.1 (x86_64-alpine-linux-musl) libcurl/8.14.1 OpenSSL/3.3.7 zlib/1.3.2 brotli/1.1.0 zstd/1.5.6 c-ares/1.33.1 libidn2/2.3.7 libpsl/0.21.5 nghttp2/1.62.1
ip utility, iproute2-6.9.0
3.20.10
```

### Krok 3 — Utwórz trzy sieci (4 min)
Każda sieć Podmana to podsieć: mostek (bridge) z własnym blokiem CIDR. `--internal` oznacza, że Podman nie dodaje trasy do świata zewnętrznego ani NAT do Twojego hosta, więc nic wewnątrz nie wyjdzie na zewnątrz inaczej niż przez bramę, którą zbudujesz. Dwie podsieci leżą w zakresie VPC `10.30.0.0/16` i nie nakładają się na siebie. Trzecia, z zakresu dokumentacyjnego, reprezentuje Internet.

```bash
podman network create --internal --subnet 10.30.1.0/24 lab-vnet-public
podman network create --internal --subnet 10.30.2.0/24 lab-vnet-private
podman network create --internal --subnet 198.51.100.0/24 lab-vnet-outside
podman network inspect lab-vnet-public lab-vnet-private lab-vnet-outside \
  --format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
```

Oczekiwany wynik:
```text
lab-vnet-public
lab-vnet-private
lab-vnet-outside
lab-vnet-public subnet=10.30.1.0/24 internal=true
lab-vnet-private subnet=10.30.2.0/24 internal=true
lab-vnet-outside subnet=198.51.100.0/24 internal=true
```

### Krok 4 — Uruchom bramę (6 min)
Brama ma po jednym interfejsie w każdej sieci, ze stałym adresem: ostatnim używalnym (`.254`) w każdej podsieci, jak „adres routera" w chmurze. `interface_name` nadaje interfejsom czytelne nazwy. `--cap-add NET_ADMIN` pozwala jej edytować własną zaporę i adresy, a `--sysctl net.ipv4.ip_forward=1` zamienia ją w router, tak jak w laboratorium routingu z przestrzeniami nazw. `sleep infinity` utrzymuje ją przy życiu.

```bash
podman run -d --name lab-vnet-gw \
  --network lab-vnet-public:ip=10.30.1.254,interface_name=pub0 \
  --network lab-vnet-private:ip=10.30.2.254,interface_name=priv0 \
  --network lab-vnet-outside:ip=198.51.100.254,interface_name=out0 \
  --cap-add NET_ADMIN --sysctl net.ipv4.ip_forward=1 \
  lab-vnet-tools:1 sleep infinity
podman exec lab-vnet-gw ip -br addr
podman exec lab-vnet-gw sysctl net.ipv4.ip_forward
podman exec lab-vnet-gw ip route
```

Oczekiwany wynik (identyfikator kontenera, kolejność interfejsów, numery `@if` i adresy `fe80::` są różne):
```text
aefbd0e9520a9e36dd5b2e54f5d4799ecc592e6ee97c80d9ff1663484a52dda8
lo               UNKNOWN        127.0.0.1/8 ::1/128 
priv0@if4        UP             10.30.2.254/24 fe80::e8e5:faff:fe8d:8e43/64 
out0@if6         UP             198.51.100.254/24 fe80::fc55:f5ff:fef6:ab65/64 
pub0@if8         UP             10.30.1.254/24 fe80::647e:b8ff:fe3d:9f28/64 
net.ipv4.ip_forward = 1
10.30.1.0/24 dev pub0 proto kernel scope link src 10.30.1.254 
10.30.2.0/24 dev priv0 proto kernel scope link src 10.30.2.254 
198.51.100.0/24 dev out0 proto kernel scope link src 198.51.100.254 
```

Tabela tras bramy zawiera tylko trzy **trasy bezpośrednio podłączone** (connected routes), po jednej na podsieć: to odpowiednik niejawnej trasy lokalnej. Nie ma trasy domyślnej i nie jest ona potrzebna: brama jest bezpośrednio podłączona do wszystkich trzech sieci.

Brama potrzebuje też drugiego adresu publicznego, „elastycznego adresu IP" bastionu. Dodajesz go do interfejsu zewnętrznego:

```bash
podman exec lab-vnet-gw ip addr add 198.51.100.50/24 dev out0
podman exec lab-vnet-gw ip -br addr show out0
```

Oczekiwany wynik:
```text
out0@if6         UP             198.51.100.254/24 198.51.100.50/24 fe80::fc55:f5ff:fef6:ab65/64 
```

### Krok 5 — Uruchom instancje i nadaj im trasy (6 min)
Każda instancja dołącza do jednej podsieci. Sieć wewnętrzna nie daje kontenerowi trasy domyślnej, jak podsieć z pustą tabelą tras. Każda instancja dodaje jedną trasę domyślną przez bramę (`ip route add default via ...`): to tabela tras jej podsieci. `NET_ADMIN` jest potrzebne w kontenerach, które wykonują polecenie `ip route add`. Serwer WWW i „Internet" publikują jednowierszową stronę za pomocą wbudowanego `httpd`; `-v` sprawia, że każde połączenie trafia do logu kontenera.

```bash
I=lab-vnet-tools:1
podman run -d --name lab-vnet-web --network lab-vnet-private:ip=10.30.2.10 --cap-add NET_ADMIN $I \
  sh -c 'ip route add default via 10.30.2.254; mkdir -p /www; echo "hello from the private web tier" > /www/index.html; exec httpd -f -v -p 8080 -h /www'
podman run -d --name lab-vnet-bastion --network lab-vnet-public:ip=10.30.1.10 --cap-add NET_ADMIN $I \
  sh -c 'ip route add default via 10.30.1.254; exec sleep infinity'
podman run -d --name lab-vnet-internet --network lab-vnet-outside:ip=198.51.100.10 $I \
  sh -c 'mkdir -p /www; echo "hello from the Internet" > /www/index.html; exec httpd -f -v -p 8000 -h /www'
podman ps --filter name=lab-vnet --format 'table {{.Names}}\t{{.Status}}'
```

Oczekiwany wynik (najpierw trzy identyfikatory kontenerów; czasy są różne):
```text
NAMES              STATUS
lab-vnet-gw        Up 8 seconds
lab-vnet-web       Up 1 second
lab-vnet-bastion   Up 1 second
lab-vnet-internet  Up 1 second
```

Teraz odczytaj „tabele tras":

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

Oczekiwany wynik:
```text
default via 10.30.2.254 dev eth0 
10.30.2.0/24 dev eth0 proto kernel scope link src 10.30.2.10 
default via 10.30.1.254 dev eth0 
10.30.1.0/24 dev eth0 proto kernel scope link src 10.30.1.10 
198.51.100.0/24 dev eth0 proto kernel scope link src 198.51.100.10 
```

Host „Internet" nie ma trasy domyślnej ani trasy do Twoich zakresów prywatnych: jak prawdziwy Internet nie wie nic o `10.30.0.0/16`, ponieważ adresy RFC 1918 nie są tam trasowane.

### Krok 6 — Sam routing: wszystko jest otwarte (8 min)
Przy włączonym forwardingu i bez żadnych reguł filtrowania brama przepuszcza wszystko między dwiema podsieciami prywatnymi. Przetestuj z bastionu:

```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-bastion ping -c 2 10.30.2.10 | tail -3
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:22; echo "rc=$?"
```

Oczekiwany wynik (czasy ping są różne):
```text
hello from the private web tier
--- 10.30.2.10 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.050/0.055/0.061 ms
curl: (7) Failed to connect to 10.30.2.10 port 22 after 0 ms: Could not connect to server
rc=7
```

Dwie lekcje. Ścieżka działa, ponieważ trasa bastionu kieruje `10.30.2.10` do bramy, która przekazuje pakiet dalej. A port 22 nic nie blokuje: połączenie kończy się niepowodzeniem tylko dlatego, że **nic tam nie nasłuchuje**, a host od razu odpowiada odmową (`rc=7`, „refused"). Zapamiętaj to: to przeciwieństwo przekroczenia czasu (timeoutu).

Następnie prywatny serwer WWW próbuje dotrzeć do Internetu, a bastion robi to samo:

```bash
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-bastion curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
```

Oczekiwany wynik (czasy w milisekundach mogą się różnić):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Oba kończą się timeoutem. Żądania docierają do hosta „Internet", ale ten nie może odpowiedzieć: źródłem jest `10.30.2.10` lub `10.30.1.10`, a host Internet nie ma trasy do tych zakresów prywatnych. Odpowiedź jest po cichu odrzucana. Dlatego podsieci prywatne potrzebują NAT.

### Krok 7 — Brama NAT i elastyczny adres IP (10 min)
Dodajesz do bramy tabelę `nat` za pomocą zapory Linuksa, **nftables**. Reguła source NAT w haku `postrouting` zamienia adres źródłowy pakietów wychodzących w stronę „Internetu":
- Cała podsieć prywatna jest **maskowana** (masquerade) do własnego adresu bramy `198.51.100.254`: NAT wiele-do-jednego, tak jak działa brama NAT. Odpowiedzi są tłumaczone z powrotem automatycznie.
- Bastion dostaje stały adres publiczny `198.51.100.50`: mapowanie jeden-do-jednego, tak jak działa publiczny lub elastyczny adres IP instancji.

Zapisz reguły do pliku. Pierwsze dwa wiersze sprawiają, że plik można bezpiecznie załadować ponownie: tworzą tabelę, jeśli nie istnieje, a następnie ją usuwają, dzięki czemu każde ładowanie zaczyna się od czystego stanu.

```bash
cat > nat.nft <<'EOF'
table ip lab_nat
delete table ip lab_nat
table ip lab_nat {
  chain postrouting {
    type nat hook postrouting priority srcnat; policy accept;
    ip saddr 10.30.1.10 ip daddr 198.51.100.0/24 counter snat to 198.51.100.50 comment "elastic IP of the bastion"
    ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter snat to 198.51.100.254 comment "NAT gateway for the private subnet"
  }
}
EOF
podman exec -i lab-vnet-gw nft -f - < nat.nft
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-bastion curl -sS -m 3 http://198.51.100.10:8000
```

`podman exec -i ... nft -f -` czyta reguły ze standardowego wejścia, więc plik zostaje na Twoim komputerze. Ładowanie niczego nie wypisuje. Oczekiwany wynik dwóch żądań:
```text
hello from the Internet
hello from the Internet
```

Teraz oba działają. Spójrz na log serwera „Internet", który pokazuje, kto według niego się łączy, oraz na tabelę NAT i śledzenie połączeń (connection tracking) bramy:

```bash
podman logs lab-vnet-internet
podman exec lab-vnet-gw nft list table ip lab_nat
podman exec lab-vnet-gw sh -c "grep 198.51.100.10 /proc/net/nf_conntrack | sed 's/ \[ASSURED\].*//; s/^ipv4 *2 //'"
```

Oczekiwany wynik (numery portów są różne):
```text
[::ffff:198.51.100.254]:52550: response:200
[::ffff:198.51.100.50]:43524: response:200
table ip lab_nat {
	chain postrouting {
		type nat hook postrouting priority srcnat; policy accept;
		ip saddr 10.30.1.10 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 snat to 198.51.100.50 comment "elastic IP of the bastion"
		ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 snat to 198.51.100.254 comment "NAT gateway for the private subnet"
	}
}
tcp      6 119 TIME_WAIT src=10.30.2.10 dst=198.51.100.10 sport=52550 dport=8000 src=198.51.100.10 dst=198.51.100.254 sport=8000 dport=52550
tcp      6 119 TIME_WAIT src=10.30.1.10 dst=198.51.100.10 sport=43524 dport=8000 src=198.51.100.10 dst=198.51.100.50 sport=8000 dport=43524
```

Serwer WWW zapisał `198.51.100.254` (bramę NAT) dla instancji prywatnej i `198.51.100.50` (elastyczny adres IP) dla bastionu. Żaden adres prywatny nigdy nie wyszedł na zewnątrz. Każdy wiersz śledzenia pokazuje oba kierunki: oryginalny (`src=10.30.2.10`) i odpowiedź, której brama oczekuje (`dst=198.51.100.254`). Ta tabela pozwala bramie NAT wiedzieć, dokąd skierować każdą odpowiedź, i dlatego działa ona tylko w kierunku wychodzącym. Spróbuj teraz przeciwnego kierunku, z „Internetu" do prywatnego serwera WWW:

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

Oczekiwany wynik:
```text
curl: (7) Failed to connect to 10.30.2.10 port 8080 after 0 ms: Could not connect to server
rc=7
```

Kończy się to od razu niepowodzeniem: host Internet nie ma trasy do adresu prywatnego. Nawet gdyby trasa istniała, brama NAT nie ma wpisu połączenia dla nowego przepływu przychodzącego.

### Krok 8 — Grupa zabezpieczeń: reguły stanowe (12 min)
Grupa zabezpieczeń jest stanowa i tylko zezwalająca. W nftables to samo zachowanie uzyskujesz dzięki śledzeniu połączeń (`ct state`) i **domyślnej polityce drop** w haku `forward`, czyli na ścieżce, którą ruch przechodzi przez bramę. Reguły pochodzą z przykładu praktycznego z lekcji, zredukowanego do tego, czego potrzebuje laboratorium:

- Pierwsza reguła przepuszcza pakiety `established,related`: odpowiedzi na każde dozwolone połączenie. Ten jeden wiersz to część „stanowa".
- `sg-web` przepuszcza nowe połączenia do `10.30.2.10` tylko z podsieci publicznej, tylko na TCP 8080, plus ping.
- Obie podsieci mogą inicjować połączenia do „Internetu".
- Wszystko inne trafia na ostatnią regułę, która liczy i odrzuca.

```bash
cat > sg.nft <<'EOF'
table ip lab_sg
delete table ip lab_sg
table ip lab_sg {
  chain forward {
    type filter hook forward priority 0; policy drop;
    ct state invalid drop
    ct state established,related counter accept comment "replies are automatic (stateful)"
    # sg-web, inbound: only the public subnet, only TCP 8080 and ping
    ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter accept comment "sg-web in: TCP 8080 from public"
    ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 icmp type echo-request counter accept comment "sg-web in: ping from public"
    # outbound to the Internet
    ip saddr 10.30.1.0/24 ip daddr 198.51.100.0/24 counter accept comment "public out: Internet"
    ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter accept comment "private out: Internet"
    counter drop comment "default deny"
  }
}
EOF
podman exec -i lab-vnet-gw nft -f - < sg.nft
```

Przetestuj. Pierwsze trzy są dozwolone, ostatnie dwa muszą się nie udać:

```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-bastion ping -c 2 10.30.2.10 | tail -3
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:22; echo "rc=$?"
podman exec lab-vnet-web ping -c 1 -W 2 10.30.1.10 | tail -2
```

Oczekiwany wynik (czasy ping są różne):
```text
hello from the private web tier
--- 10.30.2.10 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.082/0.088/0.094 ms
hello from the Internet
curl: (28) Connection timed out after 3002 milliseconds
rc=28
--- 10.30.1.10 ping statistics ---
1 packets transmitted, 0 packets received, 100% packet loss
```

Porównaj port 22 z Krokiem 6. Przed zaporą połączenie zostało od razu **odrzucone** (`rc=7`): pakiet dotarł. Teraz następuje **timeout** (`rc=28`): brama odrzuciła pakiet bez żadnej odpowiedzi. A prywatny serwer WWW, który mógł odpowiedzieć bastionowi, nie może zainicjować połączenia do niego: żadna reguła nie zezwala na ten kierunek.

Spójrz na liczniki:

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

Oczekiwany wynik (liczby pakietów na Twoim komputerze będą inne):
```text
table ip lab_sg {
	chain forward {
		type filter hook forward priority filter; policy drop;
		ct state invalid drop
		ct state established,related counter packets 25 bytes 2047 accept comment "replies are automatic (stateful)"
		ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter packets 1 bytes 60 accept comment "sg-web in: TCP 8080 from public"
		ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 icmp type echo-request counter packets 1 bytes 84 accept comment "sg-web in: ping from public"
		ip saddr 10.30.1.0/24 ip daddr 198.51.100.0/24 counter packets 0 bytes 0 accept comment "public out: Internet"
		ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 accept comment "private out: Internet"
		counter packets 4 bytes 264 drop comment "default deny"
	}
}
```

Każde zaakceptowane połączenie użyło dokładnie jednej reguły „new", dla swojego pierwszego pakietu (TCP SYN lub żądanie ping). Każdy inny pakiet, w obu kierunkach, pasował do wiersza `established,related`: odpowiedzi nie potrzebowały reguły. Wiersz `drop` policzył zablokowane pakiety SYN (kilka, bo `curl` ponawiał próby) oraz ping do bastionu.

> [!NOTE]
> Połączenie curl z portem 22 jest ponawiane w trakcie oczekiwania, dlatego licznik drop rośnie o więcej niż jeden. Dokładne liczby zależą od czasu.

### Krok 9 — Sieciowa ACL: bezstanowe, uporządkowane reguły (12 min)
Teraz drugi filtr dla **podsieci prywatnej** `10.30.2.0/24`, we własnej tabeli o wcześniejszym priorytecie (`-10`), więc działa przed grupą zabezpieczeń. Pakiet musi przejść oba. Ta ACL podlega zasadom sieciowej ACL w chmurze:

- Nigdy nie używa `ct state`: każdy pakiet jest oceniany osobno, więc jest **bezstanowa**.
- Reguły są uporządkowane i wygrywa pierwsze dopasowanie. Komentarze pokazują numery reguł „in 100", „out 100" itd.
- Ma zarówno reguły zezwalające, jak i odrzucające, z końcowym odrzuceniem `*` w każdym kierunku.
- Ruch zwrotny wymaga jawnych reguł, z **zakresem portów efemerycznych** `1024-65535`.

```bash
cat > acl.nft <<'EOF'
table ip lab_acl
delete table ip lab_acl
table ip lab_acl {
  chain forward {
    type filter hook forward priority -10; policy accept;
    # Network ACL of the private subnet 10.30.2.0/24: ordered, first match wins, no "ct state" anywhere
    # Inbound (packets entering the subnet)
    ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 tcp dport 8080 counter accept comment "in 100: TCP 8080 from public"
    ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 icmp type echo-request counter accept comment "in 110: ping from public"
    ip daddr 10.30.2.0/24 ip saddr 198.51.100.0/24 tcp dport 1024-65535 counter accept comment "in 120: replies from the Internet"
    ip daddr 10.30.2.0/24 counter drop comment "in *: deny"
    # Outbound (packets leaving the subnet)
    ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 tcp sport 8080 tcp dport 1024-65535 counter accept comment "out 100: replies to public"
    ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 icmp type echo-reply counter accept comment "out 110: ping replies"
    ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 tcp dport 8000 counter accept comment "out 120: HTTP to the Internet"
    ip saddr 10.30.2.0/24 counter drop comment "out *: deny"
  }
}
EOF
podman exec -i lab-vnet-gw nft -f - < acl.nft
```

Zwróć uwagę na kolejność zdarzeń wewnątrz bramy. Pakiety wychodzące mają jeszcze swój prywatny adres źródłowy, gdy działa hak `forward`, ponieważ source NAT następuje później, w `postrouting`. Odpowiedzi z Internetu są już przetłumaczone z powrotem na adres prywatny, gdy docierają do `forward`. Dlatego ACL zawsze widzi adresy prywatne, i dlatego jej reguły wspominają o `10.30.2.0/24`.

Powtórz testy:

```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:80; echo "rc=$?"
```

Oczekiwany wynik:
```text
hello from the private web tier
hello from the Internet
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Pierwsze dwa przechodzą przez oba filtry. Trzecie idzie na TCP 80 hosta Internet: grupa zabezpieczeń zezwala na każde nowe połączenie do Internetu, ale reguła wychodząca 120 ACL zezwala tylko na TCP 8000, więc ACL je odrzuca. Dwie warstwy, a pakiet potrzebuje obu.

### Krok 10 — Stanowość kontra bezstanowość: usuń regułę zwrotną (10 min)
To eksperyment z lekcji. Usuń regułę „out 100", tę, która pozwala odpowiedziom serwera WWW wracać do podsieci publicznej. Grupa zabezpieczeń nadal ma swoją stanową regułę `established,related`, a reguła przychodząca ACL nadal wpuszcza żądanie. Najpierw znajdź uchwyt (handle) reguły, czyli jej numer wewnątrz nftables:

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

Oczekiwany wynik (numery uchwytów mogą być inne):
```text
		ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 tcp sport 8080 tcp dport 1024-65535 counter packets 6 bytes 561 accept comment "out 100: replies to public" # handle 6
		ip saddr 10.30.2.0/24 counter packets 0 bytes 0 drop comment "out *: deny" # handle 9
```

Zauważ, że „out 100" policzyła już 6 pakietów: odpowiedzi na żądanie HTTP z Kroku 9. Końcowe odrzucenie policzyło 0. Teraz usuń regułę, używając jej uchwytu (tutaj `6`; użyj swojego), i powtórz żądanie:

```bash
podman exec lab-vnet-gw nft delete rule ip lab_acl forward handle 6
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
podman exec lab-vnet-gw nft list chain ip lab_acl forward | grep "out \*"
podman exec lab-vnet-gw nft list chain ip lab_sg forward | grep "TCP 8080"
```

Oczekiwany wynik (liczby są różne):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
		ip saddr 10.30.2.0/24 counter packets 4 bytes 240 drop comment "out *: deny"
		ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter packets 2 bytes 120 accept comment "sg-web in: TCP 8080 from public"
```

Serwer WWW odebrał żądanie i odpowiedział, ale odpowiedź jest dla bezstanowej ACL nowym pakietem, a `out *: deny` ją odrzuciło. Licznik deny wzrósł z 0 do 4: pierwsza odpowiedź i jej retransmisje. Grupa zabezpieczeń, która jest stanowa, nie jest problemem: to samo żądanie działało wcześniej. Usunięta reguła była brakującą ścieżką zwrotną. Przywróć ACL, ładując plik ponownie (odtwarza tabelę ze wszystkimi regułami), i przetestuj:

```bash
podman exec -i lab-vnet-gw nft -f - < acl.nft
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
```

Oczekiwany wynik:
```text
hello from the private web tier
```

### Krok 11 — Kolejność reguł: wygrywa pierwsze dopasowanie (5 min)
ACL jest oceniana po kolei. Wstaw regułę odrzucającą dla bastionu **przed** regułą „in 100". Polecenie `insert` umieszcza regułę na początku łańcucha:

```bash
podman exec lab-vnet-gw nft insert rule ip lab_acl forward ip saddr 10.30.1.10 ip daddr 10.30.2.0/24 counter drop comment \"in 90: deny bastion\"
podman exec lab-vnet-gw nft -a list chain ip lab_acl forward | sed -n 3,5p
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
```

Oczekiwany wynik (numery uchwytów i liczniki mogą być inne):
```text
		type filter hook forward priority filter - 10; policy accept;
		ip saddr 10.30.1.10 ip daddr 10.30.2.0/24 counter packets 0 bytes 0 drop comment "in 90: deny bastion" # handle 10
		ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 tcp dport 8080 counter packets 6 bytes 399 accept comment "in 100: TCP 8080 from public" # handle 2
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Reguła „in 100" nadal zezwala na TCP 8080 z podsieci publicznej, ale reguła odrzucająca jest pierwsza, a wygrywa pierwsze dopasowanie. Usuń ją za pomocą jej uchwytu (tutaj `10`; użyj swojego):

```bash
podman exec lab-vnet-gw nft delete rule ip lab_acl forward handle 10
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
```

Oczekiwany wynik:
```text
hello from the private web tier
```

> [!NOTE]
> Grupa zabezpieczeń nie ma takiej kolejności: wystarczy dowolna pasująca reguła zezwalająca i nie ma reguł odrzucających. To jeden z powodów, by używać grup zabezpieczeń do zwykłej kontroli dostępu, a ACL tylko do zgrubnych blokad.

### Krok 12 — Zepsuj i napraw trasę oraz regułę NAT (8 min)
Diagnozowanie to czytanie objawów. Wywołujesz dwie usterki i porównujesz je z timeoutami z poprzednich kroków. Najpierw usuń trasę domyślną prywatnego serwera WWW, jakby jego tabela tras straciła trasę do bramy:

```bash
podman exec lab-vnet-web ip route del default
podman exec lab-vnet-web ip route
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-web ip route get 198.51.100.10; echo "rc=$?"
```

Oczekiwany wynik:
```text
10.30.2.0/24 dev eth0 proto kernel scope link src 10.30.2.10 
curl: (7) Failed to connect to 198.51.100.10 port 8000 after 0 ms: Could not connect to server
rc=7
RTNETLINK answers: Network unreachable
rc=2
```

Niepowodzenie jest **natychmiastowe**, a `ip route get` mówi „Network unreachable": żadna trasa nie pasuje, więc pakiet nigdy nie opuszcza instancji. To znak rozpoznawczy problemu z routingiem, a nie z filtrem. Napraw to i przetestuj ponownie:

```bash
podman exec lab-vnet-web ip route add default via 10.30.2.254
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
```

Oczekiwany wynik:
```text
hello from the Internet
```

Teraz druga usterka: opróżnij tabelę NAT, jakby brama NAT zniknęła albo jej regułę usunięto. Następnie spójrz na liczniki filtrów, które pokazują, że pakiety wyszły:

```bash
podman exec lab-vnet-gw nft flush chain ip lab_nat postrouting
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-gw nft list chain ip lab_sg forward | grep "private out"
```

Oczekiwany wynik (licznik jest różny):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
		ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 6 bytes 360 accept comment "private out: Internet"
```

Tym razem objawem jest **timeout**, jak przy odrzuceniu przez filtr. Ale filtry zaakceptowały pakiety (licznik „private out" wzrósł), a ani SG, ani ACL nie odrzuciły niczego nowego. Pakiety wyszły z prywatnym adresem źródłowym i odpowiedź nie mogła wrócić: ta sama usterka co w Kroku 6. Oto metoda z lekcji: timeout oznacza ciche odrzucenie; sprawdź liczniki filtrów, a jeśli akceptują pakiet, sprawdź ścieżkę zwrotną i NAT. Napraw to, ładując plik NAT ponownie:

```bash
podman exec -i lab-vnet-gw nft -f - < nat.nft
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
```

Oczekiwany wynik:
```text
hello from the Internet
```

### Krok 13 — Odczytaj liczniki odrzuceń (4 min)
Każda reguła filtrująca ma licznik. Gdy przepływ nie działa, najszybszym sposobem na znalezienie warstwy jest zapytanie, która reguła odrzucająca liczy. Wypisz wszystkie reguły drop z komentarzem:

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

Oczekiwany wynik (Twoje liczby zależą od wcześniejszych działań i są wyższe, jeśli skrypt weryfikacyjny został uruchomiony jako pierwszy):
```text
counter packets 0 bytes 0 drop comment "default deny"
ip daddr 10.30.2.0/24 counter packets 9 bytes 540 drop comment "in *: deny"
ip saddr 10.30.2.0/24 counter packets 2 bytes 168 drop comment "out *: deny"
```

Odrzucenia ACL (`in *` i `out *`) policzyły pakiety, ale `default deny` grupy zabezpieczeń pokazuje tu 0. To dlatego, że ACL działa pierwsza (priorytet `-10`) i odrzuciła te pakiety, zanim zobaczyła je grupa zabezpieczeń. Reguła, która liczy pakiety, pasowała. Reguła drop, która liczy, to ta, która Cię blokuje. Reguła, która zostaje na 0, nie jest tą, która obowiązuje.

## Weryfikacja
Zapisz ten skrypt i uruchom go. Testuje sześć zachowań i dla każdego wypisuje PASS lub FAIL:

```bash
cat > verify.sh <<'EOF'
#!/bin/sh
# Prints PASS or FAIL for each expected behaviour of the virtual network.
check() { # check <description> <expected: ok|fail> <command...>
  desc=$1; want=$2; shift 2
  if "$@" >/dev/null 2>&1; then got=ok; else got=fail; fi
  if [ "$got" = "$want" ]; then echo "PASS  $desc"; else echo "FAIL  $desc (expected $want, got $got)"; fi
}
check "bastion reaches the web tier on TCP 8080"        ok   podman exec lab-vnet-bastion curl -s -m 3 http://10.30.2.10:8080
check "bastion cannot reach the web tier on TCP 22"     fail podman exec lab-vnet-bastion curl -s -m 3 http://10.30.2.10:22
check "bastion can ping the web tier"                   ok   podman exec lab-vnet-bastion ping -c 1 -W 2 10.30.2.10
check "web tier reaches the Internet through NAT"       ok   podman exec lab-vnet-web curl -s -m 3 http://198.51.100.10:8000
check "web tier cannot start a connection to the bastion" fail podman exec lab-vnet-web ping -c 1 -W 2 10.30.1.10
check "the Internet cannot reach the web tier"          fail podman exec lab-vnet-internet curl -s -m 3 http://10.30.2.10:8080
EOF
sh verify.sh
```

Oczekiwany wynik:
```text
PASS  bastion reaches the web tier on TCP 8080
PASS  bastion cannot reach the web tier on TCP 22
PASS  bastion can ping the web tier
PASS  web tier reaches the Internet through NAT
PASS  web tier cannot start a connection to the bastion
PASS  the Internet cannot reach the web tier
```

Wszystkie sześć musi przejść. Skrypt trwa około 10 sekund, ponieważ trzy testy „fail" czekają na timeout.

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `podman network create` kończy się błędem „subnet already used" lub podobnym | Inna sieć Podmana lub wcześniejsza próba używa tego samego zakresu | Uruchom `podman network ls`, usuń stare sieci `lab-vnet-` według sekcji [Sprzątanie](#sprzątanie) albo wybierz inny wolny zakres |
| `unknown flag` lub odrzucenie `interface_name` w Kroku 4 | Podman starszy niż 4.x albo backend CNI zamiast netavark | Sprawdź `podman --version` i `podman info --format '{{.Host.NetworkBackend}}'`; użyj Podmana 4+ z netavark |
| `nft` wypisuje `Operation not permitted` | Brama została uruchomiona bez `--cap-add NET_ADMIN` | Usuń ją poleceniem `podman rm -f -t 0 lab-vnet-gw` i wykonaj Krok 4 jeszcze raz |
| Wszystko kończy się timeoutem, nawet pierwszy test z Kroku 6 | Forwarding IP jest wyłączony w bramie albo instancja nie ma trasy domyślnej | `podman exec lab-vnet-gw sysctl net.ipv4.ip_forward` musi wypisać `1`; sprawdź `ip route` w instancji |
| `podman build` nie może pobrać pakietów | Brak dostępu do Internetu lub serwer proxy | Budowanie wymaga Internetu jednorazowo; skonfiguruj proxy dla Podmana albo zbuduj obraz na komputerze z dostępem do sieci |
| `curl` w kontenerze mówi `Could not resolve host` | Użyto nazwy zamiast adresu | Laboratorium nie ma DNS: zawsze używaj adresów IP z tabeli |
| Krok działa, ale liczniki zostają na 0 | Pakiet pasował do wcześniejszej reguły albo przechodzi przez inną tabelę | Czytaj łańcuch od góry: reguły działają po kolei; pierwszy `accept` lub `drop` kończy sprawę dla tej tabeli |
| `Error: No such file or directory` przy ładowaniu pliku przez `nft -f -` | Polecenie uruchomiono poza `~/vnet-lab`, więc powłoka nie znajduje pliku `.nft` | Wykonaj `cd ~/vnet-lab` i uruchom polecenie ponownie |
| Kontenery zatrzymują się wolno | `sleep infinity` ignoruje uprzejmy sygnał zatrzymania | Użyj `podman rm -f -t 0 ...` jak w sekcji Sprzątanie |

## Wyzwanie (opcjonalne)
Spraw, by bastion był osiągalny **z Internetu** pod swoim elastycznym adresem IP, tak jak instancja publiczna. Uruchom w bastionie drugi serwer WWW (`podman exec -d lab-vnet-bastion sh -c 'mkdir -p /srv && echo "hello from the bastion" > /srv/index.html && exec httpd -f -p 8081 -h /srv'`) i sprawdź, czy `podman exec lab-vnet-internet curl -sS -m 3 http://198.51.100.50:8081` wypisuje jego stronę. Potrzebujesz trzech rzeczy, a każda z nich to pojęcie z lekcji:
1. Reguły **destination NAT**, która tłumaczy `198.51.100.50` port 8081 na `10.30.1.10`. Użyj nowego łańcucha w `lab_nat` z `type nat hook prerouting priority dstnat; policy accept;`.
2. Reguły w `lab_sg`, która zezwala na nowe połączenie do `10.30.1.10` na TCP 8081. Musi stać przed końcowym `drop`: użyj `nft insert rule`, aby umieścić ją na początku.
3. Spojrzenia na liczniki pakietów, aby sprawdzić, czy pasowało i tłumaczenie, i filtr.

Następnie sprawdź, że prywatny serwer WWW nadal jest nieosiągalny z Internetu. Dlaczego tak jest, skoro używana jest ta sama brama?

## Sprzątanie
To usuwa wszystkie kontenery, sieci i obrazy z laboratorium oraz folder roboczy. Opcja `-t 0` pomija opóźnienie zatrzymania.

```bash
podman rm -f -t 0 lab-vnet-gw lab-vnet-web lab-vnet-bastion lab-vnet-internet
podman network rm lab-vnet-public lab-vnet-private lab-vnet-outside
podman rmi lab-vnet-tools:1
cd ~ && rm -rf ~/vnet-lab
```

Sprawdź, czy nic nie zostało. Trzy polecenia powinny niczego nie wypisać:

```bash
podman ps -a --filter name=lab-vnet --format '{{.Names}}'
podman network ls --filter name=lab-vnet --format '{{.Name}}'
podman images --filter reference='lab-vnet*' --format '{{.Repository}}'
```

`podman rmi` usuwa tylko obraz zbudowany w tym laboratorium. Pobrany bazowy obraz Alpine zostaje w Twojej pamięci podręcznej, a mogą go używać inne kontenery. Jeśli chcesz go usunąć, uruchom `podman rmi docker.io/library/alpine:3.20.10`.

## Co już umiesz
- VPC to zbiór podsieci połączonych routerem; podsieć jest publiczna lub prywatna ze względu na swoje trasy i reguły bramy, a nie zakres adresów.
- Brama NAT zamienia źródło połączeń wychodzących i je śledzi, dzięki czemu odpowiedzi wracają, a nic nowego nie może wejść; publiczny lub elastyczny adres IP to mapowanie jeden-do-jednego.
- Stanowa grupa zabezpieczeń potrzebuje tylko reguły, która rozpoczyna połączenie; bezstanowa ACL potrzebuje reguł dla obu kierunków, łącznie z portami efemerycznymi.
- Reguły ACL są uporządkowane i wygrywa pierwsze dopasowanie; reguły grupy zabezpieczeń nie są uporządkowane.
- „Network unreachable" oznacza problem z routingiem, „refused" oznacza, że host odpowiedział, a „timeout" to ciche odrzucenie, które może pochodzić od filtra, z braku ścieżki zwrotnej lub z braku NAT.
- Liczniki mówią, która reguła zobaczyła Twój pakiet.
