Tag 0: Trainingsgelände
Ziel: Ein kubeadm-Cluster v1.37.2 mit drei Nodes läuft ohne kube-proxy, Cilium übernimmt Pod-Netz, Services und Hubble. · Dauer: ca. 90 min · Voraussetzung: drei VMs mit Ubuntu 24.04, eine vierte für die Rolle
router
Briefing
Die CKNE prüft Kubernetes-Netzwerk auf fertigen Clustern. Hier baust du einen eigenen, bewusst ohne kube-proxy: Cilium ersetzt ihn per eBPF (Kube-Proxy-Replacement, kurz KPR). Pod-IPs vergibt Cilium selbst aus 10.0.0.0/16, Pakete zwischen Nodes laufen durch einen VXLAN-Tunnel. Lehrplanbezug: Grundlage für „CKNE: Core Infrastructure and CNI“.
cp1 .126 worker1 .228 worker2 .83
control-plane, kubectl, worker worker
helm, cilium, hubble
4 vCPU / 11 GB 2 vCPU / 3 GB 2 vCPU / 3 GB
|________________________|_______________________|______ router .123
172.16.0.0/24 · Pods 10.0.0.0/16 (Cilium, VXLAN) (prod, externer
Services 10.96.0.0/12 · kein kube-proxy Client/Server ab
Tag 0, BGP ab Tag 15)
Ersetze die IPs durch deine eigenen. Zwischen den VMs gibt es keine
Namensauflösung, deshalb stehen überall IPs. Drill 1 bis 3 laufen auf
cp1, worker1 und worker2, der Rest auf
cp1.
Drill 1: Kernel vorbereiten
Alle Downloads im Buch fragen die Architektur ab
(dpkg --print-architecture). Auf einem Mac mit Apple
Silicon (etwa VMs per multipass) ist das arm64 – die
Befehle bleiben gleich, nur die Ausgaben im Buch zeigen
amd64.
printf 'overlay\nbr_netfilter\n' | sudo tee /etc/modules-load.d/k8s.conf
sudo modprobe overlay
sudo modprobe br_netfilter
cat <<'EOF' | sudo tee /etc/sysctl.d/k8s.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
sudo sysctl --system >/dev/null
sysctl net.ipv4.ip_forward net.bridge.bridge-nf-call-iptables
swapon --show | wc -lErwartet:
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
0
Zeigt swapon etwas an: sudo swapoff -a und
die Swap-Zeile in /etc/fstab auskommentieren. Warum
ip_forward? Ohne Weiterleitung im Kernel kommt kein Paket
von einem Pod über den Node hinaus.
Fortschritt speichern? Kostenlos registrieren
Drill 2: containerd und runc
Beides direkt vom Projekt, jeweils mit Prüfsumme:
cd /tmp
V=2.4.2
U=https://github.com/containerd/containerd/releases/download/v$V
ARCH=$(dpkg --print-architecture)
curl -sSLO $U/containerd-$V-linux-${ARCH}.tar.gz
curl -sSLO $U/containerd-$V-linux-${ARCH}.tar.gz.sha256sum
sha256sum -c containerd-$V-linux-${ARCH}.tar.gz.sha256sum
sudo tar Cxzf /usr/local containerd-$V-linux-${ARCH}.tar.gz
sudo mkdir -p /usr/local/lib/systemd/system
sudo curl -sSL -o /usr/local/lib/systemd/system/containerd.service \
https://raw.githubusercontent.com/containerd/containerd/v$V/containerd.service
R=1.5.3
U=https://github.com/opencontainers/runc/releases/download/v$R
curl -sSLO $U/runc.${ARCH}
curl -sSLO $U/runc.sha256sum
grep " runc.${ARCH}$" runc.sha256sum | sha256sum -c
sudo install -m 755 runc.${ARCH} /usr/local/sbin/runc
runc --version | head -1Erwartet:
containerd-2.4.2-linux-amd64.tar.gz: OK
runc.amd64: OK
runc version 1.5.3
Konfiguration erzeugen und auf den systemd-Cgroup-Treiber umstellen (wie das kubelet):
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml >/dev/null
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
grep -n SystemdCgroup /etc/containerd/config.toml
sudo systemctl daemon-reload
sudo systemctl enable --now containerd
containerd --versionErwartet:
89: SystemdCgroup = true
containerd github.com/containerd/containerd/v2 v2.4.2 b7a25261e029...
Fortschritt speichern? Kostenlos registrieren
Drill 3: kubeadm, kubelet, kubectl in v1.37.2
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg jq
sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.37/deb/Release.key \
| sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
K=/etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo "deb [signed-by=$K] https://pkgs.k8s.io/core:/stable:/v1.37/deb/ /" \
| sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
apt-cache madison kubeadm | head -2
sudo apt-get install -y kubelet=1.37.2-1.1 kubeadm=1.37.2-1.1 kubectl=1.37.2-1.1 \
cri-tools
sudo apt-mark hold kubelet kubeadm kubectl
printf 'runtime-endpoint: unix:///run/containerd/containerd.sock\n' \
| sudo tee /etc/crictl.yaml
printf 'image-endpoint: unix:///run/containerd/containerd.sock\n' \
| sudo tee -a /etc/crictl.yaml
kubeadm version -o short
sudo crictl versionErwartet (gekürzt):
kubeadm | 1.37.2-1.1 | https://pkgs.k8s.io/core:/stable:/v1.37/deb Packages
kubeadm | 1.37.1-1.1 | https://pkgs.k8s.io/core:/stable:/v1.37/deb Packages
...
kubelet set on hold.
kubeadm set on hold.
kubectl set on hold.
...
v1.37.2
RuntimeName: containerd
RuntimeVersion: v2.4.2
hold verhindert, dass ein apt upgrade die
Cluster-Version nebenbei ändert. Das Paket kubernetes-cni
kommt als Abhängigkeit mit – es legt Standard-Plugins nach
/opt/cni/bin, die Cilium nicht braucht (mehr dazu in Tag
2).
Fortschritt speichern? Kostenlos registrieren
Drill 4: Control Plane ohne kube-proxy
Auf cp1. --skip-phases=addon/kube-proxy
lässt das kube-proxy-DaemonSet weg. Ein --pod-network-cidr
fehlt absichtlich: Mit IPAM cluster-pool verteilt Cilium
die Pod-Netze selbst, und der kube-controller-manager soll keine zweite,
abweichende Zuteilung in node.spec.podCIDR schreiben.
sudo kubeadm init --kubernetes-version=v1.37.2 \
--apiserver-advertise-address=172.16.0.126 --skip-phases=addon/kube-proxy
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
mkdir -p ~/ckne/tag00
kubectl get nodes
kubectl -n kube-system get ds
kubectl -n kube-system get cm kubeadm-config \
-o jsonpath='{.data.ClusterConfiguration}' | grep -A1 '^proxy'Erwartet (gekürzt):
Your Kubernetes control-plane has initialized successfully!
...
NAME STATUS ROLES AGE VERSION
cp1 NotReady control-plane 64s v1.37.2
No resources found in kube-system namespace.
proxy:
disabled: true
NotReady ist richtig: Ohne CNI bekommt kein Pod eine IP.
Kein DaemonSet heißt: kein kube-proxy. proxy.disabled: true
merkt sich kubeadm, damit auch kubeadm upgrade ihn nicht
nachinstalliert.
Die Prüfungs-Grundausstattung für die Shell auf cp1
(Vervollständigung für kubectl, cilium und hubble greift ab Drill
5):
cat <<'EOF' >> ~/.bashrc
source <(kubectl completion bash)
alias k=kubectl
complete -o default -F __start_kubectl k
export do="--dry-run=client -o yaml"
export now="--force --grace-period=0"
source <(cilium completion bash)
source <(hubble completion bash)
EOF
cat <<'EOF' >> ~/.vimrc
set expandtab
set tabstop=2
set shiftwidth=2
EOF$do erzeugt YAML, ohne etwas anzulegen;
$now löscht ohne Wartezeit. Die .vimrc sorgt
für Leerzeichen statt Tabulatoren im YAML. Tag 1 vertieft das.
source ~/.bashrc erst nach Drill 5, sonst fehlen
cilium und hubble noch.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Helm, cilium CLI und hubble CLI
Drei Werkzeuge auf cp1, alle mit Prüfsumme.
--no-same-owner sorgt dafür, dass die Dateien root gehören
und nicht der Benutzer-ID aus dem Archiv:
cd /tmp
ARCH=$(dpkg --print-architecture)
H=v4.3.2
curl -sSLO https://get.helm.sh/helm-$H-linux-${ARCH}.tar.gz
curl -sSLO https://get.helm.sh/helm-$H-linux-${ARCH}.tar.gz.sha256sum
sha256sum -c helm-$H-linux-${ARCH}.tar.gz.sha256sum
tar xzf helm-$H-linux-${ARCH}.tar.gz
sudo install -m 755 linux-${ARCH}/helm /usr/local/bin/helm
C=v0.20.3
U=https://github.com/cilium/cilium-cli/releases/download/$C
curl -sSLO $U/cilium-linux-${ARCH}.tar.gz
curl -sSLO $U/cilium-linux-${ARCH}.tar.gz.sha256sum
sha256sum -c cilium-linux-${ARCH}.tar.gz.sha256sum
sudo tar xzf cilium-linux-${ARCH}.tar.gz -C /usr/local/bin --no-same-owner
HV=v1.20.4
U=https://github.com/cilium/hubble/releases/download/$HV
curl -sSLO $U/hubble-linux-${ARCH}.tar.gz
curl -sSLO $U/hubble-linux-${ARCH}.tar.gz.sha256sum
sha256sum -c hubble-linux-${ARCH}.tar.gz.sha256sum
sudo tar xzf hubble-linux-${ARCH}.tar.gz -C /usr/local/bin --no-same-owner
source ~/.bashrc
helm version --short
cilium version --client
hubble versionErwartet:
helm-v4.3.2-linux-amd64.tar.gz: OK
cilium-linux-amd64.tar.gz: OK
hubble-linux-amd64.tar.gz: OK
v4.3.2+g8346aaa
cilium-cli: v0.20.3 compiled with go1.27.3 on linux/amd64
cilium image (default): v1.20.3
cilium image (stable): v1.20.5
hubble v1.20.4@HEAD-3e268bb compiled with go1.27.3 on linux/amd64
Die cilium CLI würde von sich aus 1.20.3 installieren. Wir installieren Cilium deshalb per Helm mit fester Version – so, wie es auch in Produktion läuft:
helm repo add cilium https://helm.cilium.io/
helm repo update
helm search repo cilium/cilium --versions | head -3Erwartet:
NAME CHART VERSION APP VERSION DESCRIPTION
cilium/cilium 1.20.5 1.20.5 eBPF-based Networking, Security, and ...
cilium/cilium 1.20.4 1.20.4 eBPF-based Networking, Security, and ...
Fortschritt speichern? Kostenlos registrieren
Drill 6: Cilium installieren und Worker aufnehmen
Ohne kube-proxy kennt noch niemand die Service-IP 10.96.0.1 des
API-Servers. Deshalb bekommt Cilium dessen echte Adresse
(k8sServiceHost/k8sServicePort) mit:
helm install cilium cilium/cilium --version 1.20.5 -n kube-system \
--set kubeProxyReplacement=true \
--set k8sServiceHost=172.16.0.126 --set k8sServicePort=6443 \
--set ipam.mode=cluster-pool \
--set ipam.operator.clusterPoolIPv4PodCIDRList=10.0.0.0/16 \
--set ipam.operator.clusterPoolIPv4MaskSize=24 \
--set routingMode=tunnel --set tunnelProtocol=vxlan \
--set hubble.enabled=true --set hubble.relay.enabled=true \
--set operator.replicas=1
kubeadm token create --print-join-commandErwartet (gekürzt):
STATUS: deployed
...
You have successfully installed Cilium with Hubble Relay.
WARNINGS:
- WARNING: TLS is not enabled for the Hubble Relay server ...
Your release version is 1.20.5.
kubeadm join 172.16.0.126:6443 --token ... --discovery-token-ca-cert-hash sha256:...
Warum 10.0.0.0/16? Der Chart-Standard 10.0.0.0/8 würde das
Service-Netz 10.96.0.0/12 einschließen. Ein /16 mit /24 pro Node reicht
für 256 Nodes; Cluster west bekommt in Tag 17 10.1.0.0/16.
Die TLS-Warnung zu Hubble Relay nimmst du im Labor hin.
Die ausgegebene kubeadm join-Zeile mit sudo
auf worker1 und worker2 ausführen. Dann wieder
auf cp1:
cilium status --wait
k get nodes -o wide
k get ciliumnodes -o custom-columns=NAME:.metadata.name,PODCIDRS:.spec.ipam.podCIDRs
k get nodes -o custom-columns=NAME:.metadata.name,CIDR:.spec.podCIDRErwartet (gekürzt):
Cilium: OK
Operator: OK
Envoy DaemonSet: OK
Hubble Relay: OK
ClusterMesh: disabled
DaemonSet cilium Desired: 3, Ready: 3/3, Available: 3/3
...
NAME STATUS ROLES AGE VERSION INTERNAL-IP ...
cp1 Ready control-plane 7m53s v1.37.2 172.16.0.126 ...
worker1 Ready <none> 2m1s v1.37.2 172.16.0.228 ...
worker2 Ready <none> 109s v1.37.2 172.16.0.83 ...
NAME PODCIDRS
cp1 [10.0.0.0/24]
worker1 [10.0.1.0/24]
worker2 [10.0.2.0/24]
NAME CIDR
cp1 <none>
worker1 <none>
worker2 <none>
Die Pod-Netze stehen in den CiliumNode-Objekten, nicht
am Node – genau so gewollt.
Achtung:
cilium status --waitdirekt nachhelm install, solange nurcp1im Cluster ist, läuft nach 5 Minuten in einen Timeout: Hubble Relay toleriert den Taint der Control Plane nicht und bleibtPending. Erst die Worker aufnehmen, dann warten.
SSH von cp1 zu den anderen VMs
Spätere Tage springen von cp1 per ssh auf
die Worker und auf router. Auf cp1 ein
Lab-Schlüssel ohne Passphrase:
ssh-keygen -t ed25519 -N '' -f ~/.ssh/id_ed25519 -C ubuntu@cp1Erwartet (gekürzt):
Your identification has been saved in /home/ubuntu/.ssh/id_ed25519
Your public key has been saved in /home/ubuntu/.ssh/id_ed25519.pub
ssh-copy-id hilft nicht, weil die VMs keine
Passwort-Anmeldung erlauben. Den Public Key verteilt dein eigener
Rechner, der per Schlüssel auf alle VMs kommt:
ssh [email protected] cat .ssh/id_ed25519.pub \
| ssh [email protected] 'cat >> .ssh/authorized_keys'
ssh [email protected] cat .ssh/id_ed25519.pub \
| ssh [email protected] 'cat >> .ssh/authorized_keys'
ssh [email protected] cat .ssh/id_ed25519.pub \
| ssh [email protected] 'cat >> .ssh/authorized_keys'Zurück auf cp1. accept-new speichert den
Host-Key beim ersten Kontakt ohne Rückfrage:
ssh -o StrictHostKeyChecking=accept-new [email protected] hostname
ssh -o StrictHostKeyChecking=accept-new [email protected] hostname
ssh -o StrictHostKeyChecking=accept-new [email protected] hostnameErwartet:
Warning: Permanently added '172.16.0.228' (ED25519) to the list of known hosts.
worker1
Warning: Permanently added '172.16.0.83' (ED25519) to the list of known hosts.
worker2
Warning: Permanently added '172.16.0.123' (ED25519) to the list of known hosts.
prod
Die VM für die Rolle router heißt im Labor
prod – im Buch steht immer „router“. Sie bekommt heute nur
aktuelle Paketlisten, FRR installiert Tag 15:
ssh [email protected] 'sudo apt-get update -qq && lsb_release -ds'Erwartet:
Ubuntu 24.04.5 LTS
Ab jetzt laufen alle Befehle im Buch auf cp1, sofern
nichts anderes dasteht.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Kube-Proxy-Replacement nachweisen
KPR heißt: Cilium übersetzt Service-IPs und NodePorts per eBPF direkt
im Kernel – beim connect() eines Pods (Socket-LB) und an
der Netzwerkkarte für Verkehr von außen. Es gibt keine iptables-Ketten
pro Service mehr. Drei Nachweise:
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status \
| grep -E 'KubeProxyReplacement|IPAM|Routing|Hubble:'
k get pods -A -l k8s-app=kube-proxy
sudo iptables-save | grep -c KUBE-SVC
ssh [email protected] 'sudo iptables-save | grep -c KUBE-SVC'Erwartet (gekürzt):
KubeProxyReplacement: True [eth0 172.16.0.126 ... (Direct Routing)]
IPAM: IPv4: 4/254 allocated from 10.0.0.0/24,
Routing: Network: Tunnel [vxlan] Host: Legacy
Hubble: Ok Current/Max Flows: 3182/4095 (77.70%), ...
No resources found
0
0
True plus das Gerät eth0 heißt: KPR ist
aktiv und hängt an dieser Karte. Mit kube-proxy fände grep
hier Dutzende KUBE-SVC-…-Ketten (Tag 7 vergleicht
beides).
Welche Funktionen KPR übernimmt, zeigt die ausführliche Ausgabe:
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status --verbose \
| grep -A16 'KubeProxyReplacement Details'Erwartet (gekürzt):
KubeProxyReplacement Details:
Status: True
Socket LB: Enabled
...
Mode: SNAT
Backend Selection: Random
...
- ClusterIP: Enabled
- NodePort: Enabled (Range: 30000-32767)
- LoadBalancer: Enabled
Hubble testen: Die hubble CLI spricht mit Hubble Relay, das im
Cluster läuft. -P (--port-forward) baut für
genau diesen Aufruf einen Port-Forward zum Relay auf und beendet ihn
danach. --port-forward-port 0 wählt dafür einen freien
lokalen Port – so stören sich parallele Aufrufe (etwa ein
hubble observe -f im zweiten Terminal) nicht. Diese Form
nutzt das ganze Buch, ein Port-Forward im Hintergrund ist nicht
nötig:
hubble status -P --port-forward-port 0
hubble list nodes -P --port-forward-port 0Erwartet (gekürzt, der lokale Port wechselt bei jedem Aufruf):
Healthcheck (via 127.0.0.1:36225): Ok
Current/Max Flows: 3,967/12,285 (32.29%)
Connected Nodes: 3/3
NAME STATUS AGE FLOWS/S CURRENT/MAX-FLOWS
cp1 Connected 4m44s 11.73 3369/4095 ( 82.27%)
worker1 Connected 1m10s 5.03 376/4095 ( 9.18%)
worker2 Connected 1m5s 3.17 226/4095 ( 5.52%)
Zum Schluss der große Selbsttest von Cilium. Er legt eigene Namespaces an, prüft gut 80 Szenarien (Pod-zu-Pod, Services, Policies, DNS) und dauert rund 20 Minuten:
cilium connectivity testErwartet (gekürzt, ohne die Symbole der CLI, kann je nach Netz abweichen):
[kubernetes] Creating namespace cilium-test-1 for connectivity check...
...
[cilium-test-1] Running 138 tests ...
...
Test Report [cilium-test-1]
1/82 tests failed (3/708 actions), 56 tests skipped, 0 scenarios skipped:
Test [no-unexpected-packet-drops]:
no-unexpected-packet-drops/no-unexpected-packet-drops:kubernetes/worker2: ...
"reason": "VLAN traffic disallowed by VLAN filter"
Im Labor des Autors schlug genau ein Test fehl: Der Router im
Heimnetz schickt VLAN-markierte Broadcasts (mDNS) an alle VMs, und
Cilium verwirft fremde VLAN-Frames an eth0. Das ist kein
Fehler im Cluster. Ob es bei dir genauso ist, zeigt
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg monitor --type drop
(Abbruch mit Strg+C). Alle anderen Tests müssen grün sein. Danach
aufräumen:
k delete ns cilium-test-1 cilium-test-ccnp1 cilium-test-ccnp2Tipp: Der Test sucht Hubble Relay fest unter
localhost:4245. Ohne Port-Forward im Hintergrund überspringt er die Flow-Prüfungen („Unable to contact Hubble Relay“) – daher die vielen übersprungenen Tests. Für den Funktionstest reicht das. Wer die Flow-Prüfungen will, startet vorhercilium hubble port-forward &und beendet ihn danach mitpkill -f '^cilium hubble port-forward'– die einzige Stelle im Buch mit einem Port-Forward im Hintergrund.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Add-ons und notes-api
metrics-server braucht im Labor --kubelet-insecure-tls,
weil die kubelet-Zertifikate selbst signiert sind. local-path wird die
Default-StorageClass:
M=https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.9.1
k apply -f $M/components.yaml
k -n kube-system patch deployment metrics-server --type=json -p \
'[{"op":"add","path":"/spec/template/spec/containers/0/args/-",
"value":"--kubelet-insecure-tls"}]'
L=https://raw.githubusercontent.com/rancher/local-path-provisioner/v0.0.37
k apply -f $L/deploy/local-path-storage.yaml
k patch storageclass local-path -p \
'{"metadata":{"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
k get storageclassErwartet (gekürzt):
NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE
local-path (default) rancher.io/local-path Delete WaitForFirstConsumer
Jetzt die Beispielanwendung. NOTES_API_KEY ist Pflicht –
ohne startet notes-api nicht. Deshalb kommt die Variable ins Manifest,
bevor es den Cluster erreicht:
cd ~/ckne/tag00
k create namespace tag00
k -n tag00 create deployment notes-api \
--image=ghcr.io/thomaszachmann/notes-api:0.5.1 --replicas=2 --port=8080 \
$do > notes-api.yaml
k set env --local -f notes-api.yaml NOTES_API_KEY=lab-key-123 -o yaml \
> notes-api-env.yaml
k apply -f notes-api-env.yaml
k -n tag00 expose deployment notes-api --type=NodePort --port=80 --target-port=8080
k -n tag00 rollout status deployment notes-api
k -n tag00 get pods,svc -o wideErwartet (gekürzt):
deployment "notes-api" successfully rolled out
NAME READY STATUS RESTARTS AGE IP NODE
pod/notes-api-665494b9df-2j5pr 1/1 Running 0 2s 10.0.2.78 worker2
pod/notes-api-665494b9df-2zhdp 1/1 Running 0 1s 10.0.1.1 worker1
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/notes-api NodePort 10.104.115.17 <none> 80:31368/TCP 1s
Die Pod-IPs stammen aus den /24-Netzen ihrer Nodes. Der NodePort wird zufällig vergeben, deshalb in Variablen:
CIP=$(k -n tag00 get svc notes-api -o jsonpath='{.spec.clusterIP}')
NP=$(k -n tag00 get svc notes-api -o jsonpath='{.spec.ports[0].nodePort}')
curl -s http://$CIP/version
curl -s -X POST -H 'X-API-Key: lab-key-123' -d '{"text":"Tag 0 steht"}' \
http://$CIP/notes
curl -s -o /dev/null -w '%{http_code}\n' -X POST -d '{"text":"x"}' http://$CIP/notes
for ip in 172.16.0.126 172.16.0.228 172.16.0.83; do
curl -s -o /dev/null -w "$ip:$NP %{http_code}\n" http://$ip:$NP/healthz
done
ssh [email protected] "curl -s -o /dev/null -w '%{http_code}\n' \
http://172.16.0.126:$NP/healthz"Erwartet:
0.5.1
{"id":"3dd797ea-1fe4-4c2b-843c-dc729071b672","text":"Tag 0 steht"}
401
172.16.0.126:31368 200
172.16.0.228:31368 200
172.16.0.83:31368 200
200
Ohne Schlüssel antwortet notes-api mit 401. Der NodePort antwortet
auf allen Nodes – auch auf cp1, wo gar kein notes-api-Pod
läuft – und von router aus, also von außerhalb des
Clusters. Das erledigt allein Cilium. Woher es die Ziele kennt, zeigt
seine Service-Tabelle (eine eBPF-Map):
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
| grep -A1 -E "$CIP|:$NP/"Erwartet:
23 0.0.0.0:31368/TCP NodePort 1 => 10.0.1.1:8080/TCP (active)
2 => 10.0.2.78:8080/TCP (active)
25 10.104.115.17:80/TCP ClusterIP 1 => 10.0.1.1:8080/TCP (active)
2 => 10.0.2.78:8080/TCP (active)
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeige, ob Cilium kube-proxy ersetzt. Zeitziel: 20 s
- Zeige die Pod-Netze, die Cilium den Nodes zugeteilt hat. Zeitziel: 20 s
- Zeige die Helm-Werte, mit denen Cilium installiert ist. Zeitziel: 10 s
- Zeige die letzten Flows zu Port 8080 im Namespace
tag00. Zeitziel: 30 s
Lösung
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status \
| grep KubeProxyReplacement
k get ciliumnodes -o custom-columns=NAME:.metadata.name,PODCIDRS:.spec.ipam.podCIDRs
helm get values cilium -n kube-system
hubble observe -P --port-forward-port 0 -n tag00 --protocol tcp --to-port 8080 \
--last 3Erwartet (gekürzt):
KubeProxyReplacement: True [eth0 172.16.0.126 ... (Direct Routing)]
NAME PODCIDRS
cp1 [10.0.0.0/24]
worker1 [10.0.1.0/24]
worker2 [10.0.2.0/24]
USER-SUPPLIED VALUES:
hubble:
enabled: true
relay:
enabled: true
ipam:
mode: cluster-pool
...
kubeProxyReplacement: true
...
10.0.0.88:54736 (world) -> tag00/notes-api-...-2zhdp:8080 (ID:25180) to-endpoint ...
10.0.0.88:54736 (world) -> tag00/notes-api-...-2zhdp:8080 (ID:25180) to-endpoint ...
10.0.0.88:54736 (world) -> tag00/notes-api-...-2zhdp:8080 (ID:25180) to-overlay ...
(Zeitstempel vor jeder Flow-Zeile hier weggelassen.)
10.0.0.88 ist die cilium_host-Adresse von
cp1: Dein curl vom Node aus geht durch den
Tunnel.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
k get nodes -o wideErwartet: drei Nodes Ready,
v1.37.2, containerd://2.4.2.
k get pods -A --field-selector=status.phase!=RunningErwartet: No resources found
cilium statusErwartet: Cilium: OK,
Operator: OK, Envoy DaemonSet: OK,
Hubble Relay: OK, DaemonSet cilium mit
Ready: 3/3.
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status \
| grep KubeProxyReplacementErwartet:
KubeProxyReplacement: True [eth0 …]
sudo iptables-save | grep -c KUBE-SVCErwartet: 0
helm list -AErwartet: genau ein Release cilium in
kube-system, Chart cilium-1.20.5,
deployed.
k top nodesErwartet: CPU- und Speicherwerte für
cp1, worker1, worker2.
ssh [email protected] hostnameErwartet: prod – ohne Rückfrage nach
Passwort oder Host-Key.
Challenge
Finde heraus, auf welchem Node der notes-api-Pod mit der IP aus
10.0.2.0/24 läuft, und zeige im Cilium-Agenten
dieses Nodes seinen Endpoint samt
Security-Identity.
Hinweis:
--field-selector spec.nodeName=… findet den passenden
Cilium-Pod, cilium-dbg endpoint list den Endpoint.
Lösung
k -n tag00 get pods -o wide
CP=$(k -n kube-system get pod -l k8s-app=cilium \
--field-selector spec.nodeName=worker2 -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg endpoint list \
| grep -E 'ENDPOINT|notes-api'
k get ciliumendpoints -n tag00Erwartet (gekürzt):
ENDPOINT POLICY (ingress) POLICY (egress) IDENTITY LABELS ... IPv4
1887 Disabled Disabled 25180 k8s:app=notes-api 10.0.2.78
NAME SECURITY IDENTITY ENDPOINT STATE IPV4
notes-api-665494b9df-2j5pr 25180 ready 10.0.2.78
notes-api-665494b9df-2zhdp 25180 ready 10.0.1.1
cilium-dbg zeigt nur die Endpoints des eigenen Nodes;
ds/cilium landet in irgendeinem Agenten. Beide Pods teilen
die Identity 25180, weil sie dieselben Labels tragen – darauf bauen die
Policies ab Tag 12 auf.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
k delete namespace tag00Cilium, metrics-server und local-path bleiben für alle weiteren Tage.
Prüfungstipp
- In der CKNE baust du keinen Cluster, musst aber erkennen, wer
Services umsetzt: kube-proxy-Pods vorhanden?
cilium-dbg status | grep KubeProxyReplacement? cilium-dbgwirkt nur im Agenten des betroffenen Nodes – mit--field-selector spec.nodeName=…den richtigen Pod wählen.- Doku-Stellen: docs.cilium.io „Kubernetes Without kube-proxy“ und kubernetes.io „Creating a cluster with kubeadm“.
Enterprise-Notiz
- Produktive Cluster kommen aus Managed-Angeboten oder Distributionen; viele bringen Cilium inzwischen mit (GKE Dataplane V2, AKS mit Cilium, RKE2, Talos).
- Cilium läuft per Helm mit versionierten Values aus Git (GitOps), Upgrades nach Pre-Flight-Check (Upgrade Guide) und Release-Notes.
k8sServiceHostzeigt in Produktion auf einen Load Balancer oder eine VIP vor mehreren API-Servern, nie auf eine einzelne Node-IP.- Hubble Relay mit TLS (
hubble.tls,hubble.relay.tls.server.enabled), metrics-server ohne--kubelet-insecure-tls. - Pod-CIDRs werden zentral geplant: keine Überschneidung mit Service-Netz, VPN, anderen Clustern (ClusterMesh) oder Firmennetzen.