Zum Inhalt springen
Trainingslager IT-Trainingslager

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

Erwartet:

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

Erwartet:

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

Erwartet:

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 version

Erwartet (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 version

Erwartet:

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

Erwartet:

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

Erwartet (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.podCIDR

Erwartet (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 --wait direkt nach helm install, solange nur cp1 im Cluster ist, läuft nach 5 Minuten in einen Timeout: Hubble Relay toleriert den Taint der Control Plane nicht und bleibt Pending. 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@cp1

Erwartet (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] hostname

Erwartet:

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 0

Erwartet (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 test

Erwartet (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-ccnp2

Tipp: 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 vorher cilium hubble port-forward & und beendet ihn danach mit pkill -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 storageclass

Erwartet (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 wide

Erwartet (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

  1. Zeige, ob Cilium kube-proxy ersetzt. Zeitziel: 20 s
  2. Zeige die Pod-Netze, die Cilium den Nodes zugeteilt hat. Zeitziel: 20 s
  3. Zeige die Helm-Werte, mit denen Cilium installiert ist. Zeitziel: 10 s
  4. 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 3

Erwartet (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 wide

Erwartet: drei Nodes Ready, v1.37.2, containerd://2.4.2.

k get pods -A --field-selector=status.phase!=Running

Erwartet: No resources found

cilium status

Erwartet: 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 KubeProxyReplacement

Erwartet: KubeProxyReplacement: True [eth0 …]

sudo iptables-save | grep -c KUBE-SVC

Erwartet: 0

helm list -A

Erwartet: genau ein Release cilium in kube-system, Chart cilium-1.20.5, deployed.

k top nodes

Erwartet: CPU- und Speicherwerte für cp1, worker1, worker2.

ssh [email protected] hostname

Erwartet: 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 tag00

Erwartet (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 tag00

Cilium, 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-dbg wirkt 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.
  • k8sServiceHost zeigt 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.