Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang A: Spickzettel

Die wichtigsten Befehle und Schnipsel aus allen Tagen, nach Lehrplanbereich geordnet. Die Tage stehen in Klammern. Platzhalter in spitzen Klammern ersetzt du; IPs sind die des Labors (cp1 172.16.0.126, worker1 .228, worker2 .83, router .123, west .182).

Prüfungshandwerk (Tag 0, 1)

source <(kubectl completion bash)
alias k=kubectl
complete -o default -F __start_kubectl k
export do="--dry-run=client -o yaml"         # YAML erzeugen statt anlegen
export now="--force --grace-period=0"        # sofort löschen
source <(cilium completion bash)
source <(hubble completion bash)
k config use-context <kontext>                # erste Aktion jeder Aufgabe
k config set-context --current --namespace=<ns>
k config view --minify -o jsonpath='{..namespace}'; echo
ssh [email protected]                        # Node-Arbeit, am Ende exit

cilium-dbg immer im Agenten des betroffenen Nodes – ds/cilium trifft einen zufälligen:

CP=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=<node> -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg status --brief
N=$(k get pod <pod> -o jsonpath='{.spec.nodeName}')   # Node eines Pods
hubble status -P --port-forward-port 0        # -P: Port-Forward zum Relay je Aufruf

Linux-Werkzeuge (Tag 1, 4)

ip -br link
ip -br addr show cilium_host
ip route
ip route get 10.0.2.248                       # welche Route nimmt diese IP?
sudo ss -tlnp '( sport = :6443 or sport = :10250 or sport = :4240 or sport = :4244 )'
sudo iptables-save | grep -c KUBE-SVC         # 0 = kein kube-proxy
sudo nft list tables
sudo tcpdump -i any -nn -c 4 host 10.0.2.248 and tcp port 80
sudo tcpdump -l -i eth0 -nn udp port 8472     # VXLAN zwischen Nodes
sudo tcpdump -nn -e -i eth0 -c 2 tcp port 30707   # -e zeigt MAC-Adressen (DSR)

In das Netz eines Pods (auf dem Node des Pods):

sudo crictl pods --namespace <ns> --name <pod>
ID=$(sudo crictl ps --name <container> -q --label io.kubernetes.pod.namespace=<ns>)
P=$(sudo crictl inspect -o go-template --template '{{.info.pid}}' $ID)
sudo nsenter -t $P -n ip -br addr
sudo nsenter -t $P -n ip route
sudo nsenter -t $P -n ss -tlnp
sudo nsenter -t $P -n tcpdump -i eth0 -nn -c 2 icmp
ip -o link | awk -F': ' '$1==33{print $2}'    # Host-Ende zu eth0@if33

kubectl debug mit netshoot, ohne SSH:

k debug <pod> -it --image=nicolaka/netshoot:v0.16 --target=<container> \
  --profile=netadmin                          # ephemerer Container im Pod-netns
k debug node/worker2 -it --image=nicolaka/netshoot:v0.16 --profile=netadmin
# danach den Pod node-debugger-worker2-… löschen, er bleibt liegen
k run c1 --image=nicolaka/netshoot:v0.16 \
  --overrides='{"spec":{"nodeName":"worker1"}}' -- sleep infinity

Core Infrastructure and CNI (Tag 2–5)

CNI auf dem Node (Tag 2):

sudo ls -la /etc/cni/net.d                    # drwx------, nur mit sudo
sudo cat /etc/cni/net.d/05-cilium.conflist
ls /opt/cni/bin
sudo crictl info | jq '.cniconfig | {PluginConfDir, PluginDirs, PluginMaxConfNum}'
sudo journalctl -u containerd --since -1min | grep -m1 'reload cni'
cilium config view | grep -E '^cni-|write-cni'
k -n kube-system get cm cilium-config -o jsonpath='{.data.cni-exclusive}'; echo
P=$(sudo crictl pods --name <pod> --namespace <ns> -q)
sudo crictl inspectp $P | jq -c '.info.cniResult.Interfaces.eth0.IPConfigs'
  • Fehlt 05-cilium.conflist, schreibt der Agent sie neu (Wrote CNI im Log).
  • Mit cni.exclusive=true benennt Cilium fremde Dateien in *.cilium_bak um.

Helm-Werte ändern (Muster für jeden Tag)

helm get values cilium -n kube-system -o yaml > values-vorher.yaml   # zuerst sichern
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
  --reuse-values --set <schluessel>=<wert>    # ohne --reuse-values: alles zurück
k -n kube-system rollout restart ds/cilium    # bei Operator-Werten auch
k -n kube-system rollout restart deploy/cilium-operator
k -n kube-system rollout status ds/cilium
cilium status --wait
cilium config view | grep <schluessel>        # Ergebnis in der ConfigMap
helm get values cilium -n kube-system --all | grep -A13 '^cni:'   # inkl. Defaults
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
  -f values-vorher.yaml                       # Rückweg
diff values-vorher.yaml <(helm get values cilium -n kube-system -o yaml) && echo GLEICH
  • cilium config set debug true --restart=false ändert nur die ConfigMap – Drift, die Helm 4 beim Rollback als Konflikt meldet (helm rollback … --force-conflicts).
  • Werte aus einer Datei: helm upgrade … --reuse-values -f datei.yaml.
Helm-Wert Wirkung Tag
debug.enabled=true Debug-Logs im Agenten 2
ipam.operator.clusterPoolIPv4PodCIDRList Pod-Pool, nur erweitern 3
cni.exclusive=false fremde CNI-Dateien dulden (Multus) 5
routingMode=native, autoDirectNodeRoutes=true Native Routing 7
ipv4NativeRoutingCIDR=10.0.0.0/16 Netz ohne Masquerading 7
loadBalancer.mode=dsr, loadBalancer.algorithm=maglev DSR, Maglev 7
gatewayAPI.enabled=true Gateway-Controller 10
encryption.enabled=true, encryption.type=wireguard WireGuard 13
encryption.nodeEncryption=true auch Node-zu-Node 13
authentication.mutual.spire.enabled=true Mutual Auth mit SPIRE 14
bgpControlPlane.enabled=true BGP Control Plane 15
egressGateway.enabled=true, bpf.masquerade=true Egress-Gateway 16
cluster.name=ost, cluster.id=1 Voraussetzung ClusterMesh 17
clustermesh.mcsapi.enabled=true MCS-API 17
hubble.export.dynamic.enabled=true Flow-Logs in Datei 20

Werte pro Node (Tag 21, Runde 1) – CiliumNodeConfig überschreibt die ConfigMap:

k get ciliumnodeconfigs -A                    # spec.nodeSelector + spec.defaults
k -n kube-system logs $CP -c config | grep 'Got configuration'   # gelesene Quellen
  • cilium config view liest nur die ConfigMap und zeigt den Override nicht.

IPAM (Tag 3)

cilium config view | grep -E '^ipam |cluster-pool'
k get ciliumnodes -o custom-columns='NAME:.metadata.name,PODCIDRS:.spec.ipam.podCIDRs'
k get ciliumnodes -o jsonpath=\
'{range .items[*]}{.metadata.name}{"\t"}{.status.ipam.operator-status}{"\n"}{end}'
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg status --all-addresses \
  | sed -n '/^IPAM/,/^IPv4 BIG/p'
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf ipcache get <ip>
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg ip get -v <ip>/32
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values \
  --set ipam.operator.clusterPoolIPv4PodCIDRList='{10.0.0.0/16,10.2.0.0/16}'
k -n kube-system rollout restart deployment cilium-operator
  • node.spec.podCIDR ist nur im IPAM-Modus kubernetes gefüllt – bei cluster-pool zählt die CiliumNode.
  • CiliumPodIPPool plus Annotation ipam.cilium.io/ip-pool wirkt nur mit ipam.mode=multi-pool (im Labor angelegt, aber ohne Wirkung).

Pod-Konnektivität debuggen (Tag 4)

Reihenfolge: Pod Ready? → Pod-IP direkt → EndpointSlices → DNS im Pod → Drops.

k get pods -o wide
k exec c1 -- curl -s -o /dev/null -w '%{remote_ip} %{http_code}\n' http://<pod-ip>
k exec c1 -- traceroute -n -w 1 -q 1 <pod-ip>
k get endpointslices
k describe svc <svc> | grep -E 'Selector|Endpoints'
k get pods --show-labels
k exec c1 -- cat /etc/resolv.conf
k exec c1 -- nslookup web
hubble observe -P --port-forward-port 0 --pod <ns>/c1 --tcp-flags SYN --last 2
cilium config view | grep -E '^routing-mode|^tunnel-protocol|^auto-direct'
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg endpoint list
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg monitor --related-to <ep-id>
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg identity get <id>
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg node list
cilium connectivity test --test-namespace tag04-ct --test no-policies
k set selector svc web-sel app=web                                        # Reparatur
k patch svc api -p '{"spec":{"ports":[{"port":80,"targetPort":"web"}]}}'  # Portname
  • Kein Flow in Hubble = kein Backend; RST = falscher Port; 0/1 Ready = Probe.

Multus (Tag 5)

apiVersion: k8s.cni.cncf.io/v1
kind: NetworkAttachmentDefinition
metadata:
  name: macvlan-lab
spec:
  config: |
    {"cniVersion": "0.3.1", "type": "macvlan", "master": "eth0", "mode": "bridge",
     "capabilities": {"ips": true}, "ipam": {"type": "static"}}
k get net-attach-def -A
NET1='[{"name":"macvlan-lab","ips":["192.168.77.11/24"]}]'
k run m1 --image=nicolaka/netshoot:v0.16 \
  --annotations=k8s.v1.cni.cncf.io/networks="$NET1" -- sleep infinity
k exec m1 -- ip -br addr                      # eth0 = Cilium, net1 = Multus
k get pod m1 \
  -o jsonpath='{.metadata.annotations.k8s\.v1\.cni\.cncf\.io/network-status}'; echo
  • JSON-Form der Annotation: name, interface, ips; Kurzform nur der Name. 00-multus.conf muss die erste Datei in /etc/cni/net.d sein. net1 läuft an Cilium vorbei: keine Policy, kein Hubble.

Service Networking and DNS (Tag 6–9, 17)

Services auf L4 (Tag 6):

k expose deployment echo --port=80 --target-port=8080
k expose deployment echo --name=echo-np --type=NodePort --port=80 --target-port=8080
k patch svc echo-np -p '{"spec":{"ports":[{"port":80,"nodePort":30080}]}}'
k expose deployment echo --name=echo-lb --type=LoadBalancer --port=80 \
  --target-port=8080
k expose deployment echo --name=echo-hl --cluster-ip=None --port=8080
k create service externalname docs --external-name=kubernetes.io
k patch svc echo -p '{"spec":{"sessionAffinity":"ClientIP"}}'
k patch svc echo-np -p '{"spec":{"externalTrafficPolicy":"Local"}}'
k patch svc echo -p '{"spec":{"internalTrafficPolicy":"Local"}}'
k get svc echo-lb -o jsonpath='{.spec.healthCheckNodePort}'   # bei ETP Local

Service ohne Selector mit eigener EndpointSlice:

k create service clusterip router --tcp=80:8000 $do > router-svc.yaml
sed -i '/selector:/,+1d' router-svc.yaml
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
  name: router-1
  labels:
    kubernetes.io/service-name: router
    endpointslice.kubernetes.io/managed-by: tag06.example.com
addressType: IPv4
ports:
- name: 80-8000                               # gleicher Name wie im Service-Port
  protocol: TCP
  port: 8000
endpoints:
- addresses:
  - 172.16.0.123
  • externalTrafficPolicy wirkt nur auf NodePort/LoadBalancer, internalTrafficPolicy nur auf Verkehr aus dem Cluster; Local ohne lokales Backend = keine Antwort.

kube-proxy und Cilium-KPR (Tag 0, 7)

k -n kube-system get cm kube-proxy            # NotFound = kein kube-proxy
k get pods -A -l k8s-app=kube-proxy
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status \
  | grep KubeProxyReplacement
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg status --verbose \
  | sed -n '/KubeProxyReplacement Details/,/HostPort/p'
CIP=$(k get svc echo -o jsonpath='{.spec.clusterIP}')
X="kubectl -n kube-system exec $CP -c cilium-agent --"   # kubectl, kein Alias
$X cilium-dbg service list | grep -A1 "$CIP:"
$X cilium-dbg bpf lb list | grep "$CIP:80"
$X cilium-dbg map list | grep -E '^Name|lb4_'
$X cilium-dbg bpf lb maglev list | cut -c1-60
cilium config view | grep -E '^bpf-lb-mode |^bpf-lb-algorithm '
k annotate svc echo-np service.cilium.io/lb-algorithm=maglev   # pro Service
  • kube-proxy-Modi: iptables, nftables, ipvs (Feld mode in seiner ConfigMap).
  • DSR braucht Native Routing (oder Geneve); autoDirectNodeRoutes nur im selben L2-Netz, sonst BGP.

CoreDNS (Tag 4, 8)

k -n kube-system get cm coredns -o yaml > coredns-vorher.yaml      # sichern
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}' > Corefile
vim Corefile
coredns -conf Corefile 2>&1 | tail -1         # Syntax lokal prüfen (Binary Tag 8)
k -n kube-system create configmap coredns --from-file=Corefile $do | k replace -f -
k -n kube-system edit cm coredns              # Alternative in der Prüfung
k -n kube-system logs -l k8s-app=kube-dns -f --tail=0 --prefix   # Reloading complete
k -n kube-system rollout restart deploy coredns                  # wenn es eilt
sudo grep -A1 -E 'clusterDNS|clusterDomain|resolvConf' /var/lib/kubelet/config.yaml

Blöcke im Corefile – log und hosts/rewrite in den Block .:53 (unter ready), die Stub-Domain als eigener Server-Block ans Ende:

    log
    hosts {
       172.16.0.123 router.lab.local
       fallthrough
    }
    rewrite name exact notes.lab.local web.tag08.svc.cluster.local

lab.intern:53 {
    errors
    cache 30
    forward . 172.16.0.123
}
  • Ohne fallthrough beantwortet hosts alle anderen Namen mit NXDOMAIN.
  • Ein fehlendes } lässt CoreDNS die alte Konfiguration behalten ([ERROR] im Log).

Namen testen – dig nutzt die Suchliste nur mit +search:

k exec client -- dig +short web.tag08.svc.cluster.local          # Service
k exec client -- dig +short web-hl.tag08.svc.cluster.local       # headless: Pod-IPs
k exec client -- dig +short +search web
k exec client -- dig +short SRV _http._tcp.web.tag08.svc.cluster.local
k exec client -- dig +short @<coredns-pod-ip> test.lab.local     # Pod direkt fragen

dnsPolicy und dnsConfig im Pod:

spec:
  dnsConfig:
    options:
    - name: ndots
      value: "1"
---
spec:
  dnsPolicy: None                             # nur, was in dnsConfig steht
  dnsConfig:
    nameservers: ["1.1.1.1"]
    searches: ["example.org"]
  • Pod-Name im DNS (db.web-hl.tag08.svc…): hostname + subdomain = headless Service (Tag 8).

EndpointSlices und Verfügbarkeit (Tag 9)

JP='{range .items[*].endpoints[*]}{.targetRef.name}{" r="}{.conditions.ready}'\
'{" s="}{.conditions.serving}{" t="}{.conditions.terminating}{"\n"}{end}'
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath="$JP"
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath=\
'{.items[*].endpoints[?(@.conditions.ready==false)].targetRef.name}'; echo
k expose deployment web --name=web-peers --cluster-ip=None --port=8080 \
  $do > web-peers.yaml
sed -i '/^  clusterIP: None/a\  publishNotReadyAddresses: true' web-peers.yaml
k label node worker1 topology.kubernetes.io/zone=zone-a
k patch svc web -p '{"spec":{"trafficDistribution":"PreferSameZone"}}'
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath=\
'{range .items[*].endpoints[*]}{.nodeName} {.zone} {.hints}{"\n"}{end}'
k create pdb web --selector=app=web --min-available=1
k get pdb web -o jsonpath='{.status.disruptionsAllowed}'; echo
  • Die Spalte ENDPOINTS verschweigt unbereite Pods – Conditions lesen. Cilium zeigt sie in cilium-dbg service list als maintenance bzw. terminating.
  • trafficDistribution: PreferSameZone, PreferSameNode, PreferClose (alter Name); Zonen-Hints nur mit Label topology.kubernetes.io/zone an den Nodes.

ClusterMesh (Tag 17)

k --context ost -n kube-system get secret cilium-ca \
  -o jsonpath='{.data.ca\.crt}'               # gemeinsame CA für west
cilium config view --context west | grep -E '^cluster-(name|id) '
cilium clustermesh enable --context ost --service-type NodePort
cilium clustermesh enable --context west --service-type NodePort
cilium clustermesh connect --context ost --destination-context west
cilium clustermesh status --context ost --wait
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status | grep ClusterMesh

Annotationen am Service (gleicher Name und Namespace in beiden Clustern):

k annotate svc echo service.cilium.io/global="true"
k --context west annotate svc echo service.cilium.io/global="true"
k annotate svc echo service.cilium.io/affinity=local   # lokal zuerst, sonst remote
k --context west annotate svc echo service.cilium.io/shared="false"   # nicht teilen
k annotate svc echo service.cilium.io/affinity-                      # entfernen
CIP=$(k get svc echo -o jsonpath='{.spec.clusterIP}')
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
  --clustermesh-affinity | grep -A1 $CIP

Policy über Clustergrenzen – ohne Cluster-Label gilt fromEndpoints nur lokal:

  ingress:
  - fromEndpoints:
    - matchLabels:
        run: client
        io.cilium.k8s.policy.cluster: ost

MCS-API (clustermesh.mcsapi.enabled=true, in west zusätzlich clustermesh.mcsapi.corednsAutoConfigure.enabled=true); den Service exportiert ein ServiceExport (multicluster.x-k8s.io/v1beta1) mit Name und Namespace des Service (Tag 17):

k --context west get serviceexport,serviceimport,svc
k --context west exec client -- curl -s echo.tag17.svc.clusterset.local/hostname

Advanced Traffic Management (Tag 10, 11, 15, 16, 18)

Gateway API einschalten (Tag 10):

GWAPI=https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.6.3
k apply --server-side -f $GWAPI/standard-install.yaml
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
  --reuse-values --set gatewayAPI.enabled=true
k -n kube-system rollout restart deployment/cilium-operator
k -n kube-system rollout restart ds/cilium
k get gatewayclass
k explain httproute.spec.rules                # kein k create für Gateway-Objekte

Gateway als NodePort statt LoadBalancer (ohne LB-IPAM bleibt es sonst nicht Programmed): eine CiliumGatewayClassConfig (cilium.io/v2alpha1) mit spec.service.type: NodePort und eine eigene GatewayClass – vollständig in Tag 10:

apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: tag10-nodeport
spec:
  controllerName: io.cilium/gateway-controller
  parametersRef:
    group: cilium.io
    kind: CiliumGatewayClassConfig
    name: nodeport
    namespace: tag10

HTTPRoute mit Header, Pfad und Gewicht:

spec:                                         # HTTPRoute match (Tag 10)
  parentRefs:
  - name: web
  hostnames:
  - shop.example.com
  rules:
  - matches:
    - headers:
      - name: x-version
        value: v2
    backendRefs:
    - name: echo-v2
      port: 8080
  - matches:
    - path:
        type: PathPrefix                      # oder Exact
        value: /api/v1
    backendRefs:
    - name: echo-v1
      port: 8080
  - backendRefs:                              # Canary 90/10
    - name: echo-v1
      port: 8080
      weight: 90
    - name: echo-v2
      port: 8080
      weight: 10

Filter (je unter rules[].filters; URLRewrite und RequestMirror: Tag 10):

- type: RequestRedirect
  requestRedirect:
    path:
      type: ReplacePrefixMatch
      replacePrefixMatch: /new
    statusCode: 301
- type: RequestHeaderModifier
  requestHeaderModifier:
    add:
    - name: x-team
      value: blue                             # daneben set: und remove:

ReferenceGrant im Namespace des Ziels (Route in tag10, Service in tag10-backend):

spec:                                         # ReferenceGrant in tag10-backend
  from:
  - group: gateway.networking.k8s.io
    kind: HTTPRoute
    namespace: tag10
  to:
  - group: ""
    kind: Service

Status lesen und testen:

NP=$(k get svc cilium-gateway-web -o jsonpath='{.spec.ports[0].nodePort}')
G=172.16.0.228:$NP
curl -s -H 'Host: shop.example.com' http://$G/v2/cart
k get gateway web -o jsonpath=\
'{range .status.conditions[*]}{.type}={.status} {.reason}: {.message}{"\n"}{end}'
RC='{range .status.parents[*].conditions[*]}{.type}={.status} '\
'{.reason}: {.message}{"\n"}{end}'
k get httproute billing -o jsonpath="$RC"     # Accepted, ResolvedRefs
k get gateway web -o jsonpath='{.status.listeners[0].attachedRoutes}{"\n"}'
  • GRPCRoute: Service-Port mit appProtocol: kubernetes.io/h2c, Match über matches[].method.service.

TLS am Gateway (Tag 11)

Das Certificate (cert-manager) schreibt das Secret shop-tls, der HTTPS-Listener verweist darauf:

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: web
spec:
  gatewayClassName: tag11-nodeport
  listeners:
  - name: http
    protocol: HTTP
    port: 80
  - name: https-shop
    protocol: HTTPS
    port: 443
    hostname: shop.example.com
    tls:
      mode: Terminate
      certificateRefs:
      - name: shop-tls                        # anderer Namespace: namespace: …
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: to-https
spec:
  parentRefs:
  - name: web
    sectionName: http                         # Route an einen Listener hängen
  rules:
  - filters:
    - type: RequestRedirect
      requestRedirect:
        scheme: https
        statusCode: 301

Secret in fremdem Namespace: ReferenceGrant dort, from = Gateway (Gruppe gateway.networking.k8s.io, Namespace tag11), to = Secret (Gruppe "").

k wait --for=condition=Ready certificate shop
k get secret shop-tls -o jsonpath='{.data.ca\.crt}' | base64 -d > ca.crt
NPS=$(k get svc cilium-gateway-web -o jsonpath='{.spec.ports[?(@.port==443)].nodePort}')
R="--resolve shop.example.com:$NPS:172.16.0.228"
curl -s $R --cacert ca.crt https://shop.example.com:$NPS/
k get secret shop-tls -o jsonpath='{.data.tls\.crt}' | base64 -d \
  | openssl x509 -noout -ext subjectAltName   # Namen im Zertifikat
cmctl renew shop
cmctl status certificate shop

BackendTLSPolicy – TLS vom Gateway bis zum Pod:

apiVersion: gateway.networking.k8s.io/v1
kind: BackendTLSPolicy
metadata:
  name: secure
spec:
  targetRefs:
  - group: ""
    kind: Service
    name: secure
  validation:
    caCertificateRefs:
    - group: ""
      kind: ConfigMap                         # k create configmap lab-ca --from-file
      name: lab-ca
    hostname: secure.tag11.svc
  • Annotation cert-manager.io/cluster-issuer: tag11-ca am Gateway lässt cert-manager das Zertifikat für den Listener selbst anlegen.

LB-IPAM und BGP (Tag 15)

Vier Objekte, eine Kette: ClusterConfig → PeerConfig per Name, PeerConfig → Advertisement per Label, Advertisement → Service per Label; der Pool wählt per Namespace. Pool (CiliumLoadBalancerIPPool) und ClusterConfig nur mit spec:

spec:                                         # CiliumLoadBalancerIPPool
  blocks:
  - cidr: 10.50.0.0/24
  serviceSelector:
    matchLabels:
      io.kubernetes.service.namespace: tag15
---
spec:                                         # CiliumBGPClusterConfig
  nodeSelector:
    matchLabels:
      kubernetes.io/os: linux
  bgpInstances:
  - name: ost
    localASN: 65010
    peers:
    - name: router
      peerASN: 65000
      peerAddress: 172.16.0.123
      peerConfigRef:
        name: tag15-peer
---
spec:                                         # CiliumBGPPeerConfig tag15-peer
  families:
  - afi: ipv4
    safi: unicast
    advertisements:
      matchLabels:
        advertise: tag15                      # muss das Advertisement treffen
---
apiVersion: cilium.io/v2
kind: CiliumBGPAdvertisement
metadata:
  name: tag15-lb
  labels:
    advertise: tag15
spec:
  advertisements:
  - advertisementType: Service
    service:
      addresses:
      - LoadBalancerIP                        # oder ClusterIP
    selector:
      matchLabels:
        bgp: "on"
  - advertisementType: PodCIDR
k get ippools                                 # CiliumLoadBalancerIPPools
k label svc echo-lb bgp=on
k annotate svc echo-fix lbipam.cilium.io/ips=10.50.0.50   # feste LB-IP
cilium bgp peers                              # established, Advertised > 0
cilium bgp routes advertised ipv4 unicast --node worker1
k get ciliumbgpnodeconfigs
k patch ciliumbgppeerconfig tag15-peer --type=merge \
  -p '{"spec":{"timers":{"holdTimeSeconds":9,"keepAliveTimeSeconds":3}}}'
ssh [email protected] "sudo vtysh -c 'show bgp summary'"
ssh [email protected] "sudo vtysh -c 'show bgp ipv4 unicast'"
ssh [email protected] "ip route | grep proto.bgp"
  • Advertised 0 bei stehender Sitzung: Label-Selector der PeerConfig trifft kein CiliumBGPAdvertisement, oder dessen Service-Selector keinen Service.

Egress-Gateway (Tag 16)

Voraussetzung: egressGateway.enabled=true, bpf.masquerade=true, KPR.

spec:                                         # CiliumEgressGatewayPolicy tag16-egw
  selectors:
  - podSelector:
      matchLabels:
        app: egress-demo
        io.kubernetes.pod.namespace: tag16
  destinationCIDRs:
  - 172.16.0.123/32
  egressGateway:
    nodeSelector:
      matchLabels:
        egress-node: "true"
k label node worker1 egress-node=true
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf egress list  # Gateway-Node
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status \
  | grep Masquerading                         # BPF statt iptables
k patch cegp tag16-egw --type=merge \
  -p '{"spec":{"egressGateway":{"egressIP":"172.16.0.228"}}}'
k patch cegp tag16-egw --type=merge -p \
  '{"spec":{"destinationCIDRs":["172.16.0.0/24"],"excludedCIDRs":["172.16.0.123/32"]}}'
hubble observe -P --port-forward-port 0 --from-pod tag16/app \
  --to-ip 172.16.0.123 --last 2 --print-node-name
  • Statt podSelector geht namespaceSelector mit kubernetes.io/metadata.name.
  • Leere Map = Selector trifft nicht; Gateway IP Not Found = kein Node mit Label.

LLM-Traffic (Tag 18)

    backendRefs:                              # in der HTTPRoute
    - group: inference.networking.k8s.io
      kind: InferencePool
      name: chat
  • Cilium kann kein InferencePool und meldet an der Route InvalidKind; im Buch übernimmt agentgateway. endpointPickerRef.failureMode: FailOpen oder FailClose (Tag 18).

Network Security and Policy (Tag 12–14)

Default Deny (podSelector: {}, policyTypes: [Ingress, Egress], keine Regeln) mit DNS-Ausnahme (Tag 12):

spec:
  podSelector: {}
  policyTypes: [Ingress, Egress]
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - protocol: UDP
      port: 53
    - protocol: TCP
      port: 53
from:                           from:
- namespaceSelector: {...}      - namespaceSelector: {...}
- podSelector: {...}              podSelector: {...}
  -> ODER (zwei Einträge)         -> UND (ein Eintrag)

ipBlock mit Ausnahme und Portbereich:

  egress:
  - to:
    - ipBlock:
        cidr: 172.16.0.0/24
        except:
        - 172.16.0.123/32
  - to:
    - ipBlock:
        cidr: 172.16.0.123/32
    ports:
    - protocol: TCP
      port: 20
      endPort: 23
k -n tag12 describe networkpolicy api-ingress \
  | sed -n '/Allowing ingress/,/Not affecting/p'
k -n tag12 get cnp                            # Kurzform; clusterweit: k get ccnp
k -n tag12 get cep                            # CiliumEndpoints mit Identität
  • Ports in Policies sind Container-Ports (8080), nicht Service-Ports (80).
  • Unter Cilium trifft ipBlock keine Node-IPs (Identitäten host, remote-node) – dafür toEntities.

CiliumNetworkPolicy: Entities, DNS-Sicht, FQDN, L7:

spec:                                         # CNP client-fqdn
  endpointSelector:
    matchLabels:
      app: client
  egress:
  - toEndpoints:
    - matchLabels:
        k8s:io.kubernetes.pod.namespace: kube-system
        k8s:k8s-app: kube-dns
    toPorts:
    - ports:
      - port: "53"
        protocol: ANY
      rules:
        dns:
        - matchPattern: "*"                   # Pflicht für toFQDNs
  - toFQDNs:
    - matchName: example.com
    - matchPattern: "*.kubernetes.io"         # trifft nicht kubernetes.io selbst
    toPorts:
    - ports:
      - port: "443"
        protocol: TCP
---
spec:                                         # CNP notes-api
  endpointSelector:
    matchLabels:
      app: notes-api
  ingress:
  - fromEndpoints:
    - matchLabels:
        app: client
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP
      rules:
        http:
        - method: GET
          path: "/(version|healthz)"          # Pfad ist ein Regex
  • Weitere HTTP-Regel: method, path und headers: ["X-API-Key: lab-key-123"].

Deny schlägt Allow (Tag 12: neben einer ingress-Regel mit fromEntities: cluster); clusterweit per Namespace-Label:

spec:                                         # CNP notes-api-deny
  endpointSelector:
    matchLabels:
      app: notes-api
  ingressDeny:
  - fromEndpoints:
    - matchLabels:
        k8s:io.kubernetes.pod.namespace: tag12-other
        run: bad
---
spec:                                         # CCNP tag12-no-router-ssh
  endpointSelector:
    matchLabels:
      k8s:io.cilium.k8s.namespace.labels.ckne: tag12
  enableDefaultDeny:                          # sonst sperrt das Deny alles andere
    egress: false
    ingress: false
  egressDeny:
  - toCIDR:
    - 172.16.0.123/32
    toPorts:
    - ports:
      - port: "22"
        protocol: TCP
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg policy get \
  k8s:io.cilium.k8s.policy.name=notes-api k8s:io.cilium.k8s.policy.namespace=tag12
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg fqdn cache list
cilium config view | grep '^enable-policy '
  • L7-Nein = 403 Access denied, L3/L4-Nein = Timeout (Drop in Hubble).

Verschlüsselung mit WireGuard (Tag 13)

helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values \
  --set encryption.enabled=true --set encryption.type=wireguard
k -n kube-system rollout restart ds/cilium
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg status | grep Encryption
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg encrypt status
ssh [email protected] "ip -d link show cilium_wg0 | head -3"
ssh [email protected] "sudo timeout 7 tcpdump -nn -i eth0 -A \
  'host 172.16.0.83 and (udp port 8472 or udp port 51871)'"
cilium config view | grep node-encryption-opt-out-labels   # Control Plane ausgenommen
  • Peers in Encryption = Anzahl der anderen Nodes. Mit WireGuard UDP 51871 statt Klartext in VXLAN (UDP 8472).

Identitäten und Mutual Auth (Tag 14)

k get cep -o custom-columns=NAME:.metadata.name,ID:.status.identity.id
k get ciliumidentity <id> -o yaml | sed -n '/security-labels/,$p'
k label pod frontend team=blue                # neues Label = neue Identität
  ingress:
  - authentication:
      mode: required                          # Höhe von fromEndpoints
    fromEndpoints:
    - matchLabels:
        io.cilium.k8s.policy.serviceaccount: frontend
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP
      rules:
        http:
        - method: GET
          path: /notes
S="kubectl -n cilium-spire exec spire-server-0 -c spire-server -- \
  /opt/spire/bin/spire-server"
$S healthcheck
$S entry show -spiffeID spiffe://spiffe.cilium/identity/<id>
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf auth list
k explain cnp.spec.ingress.authentication.mode
  • Drop-Grund Authentication required. Authentifiziert heißt nicht verschlüsselt.

Observability (Tag 19, 20)

Hubble-Filter (Tag 4, 12, 20) – alle hubble-Befehle mit -P --port-forward-port 0 (startet den Port-Forward selbst), hier der Kürze halber weggelassen:

hubble observe -n <ns> --verdict DROPPED --last 5
hubble observe --pod <ns>/<pod> --protocol http --last 4      # beide Richtungen
hubble observe --from-pod <ns>/<pod> --to-port 53 --last 2    # nur eine Richtung
hubble observe --to-pod <ns>/<pod> --verdict DROPPED --last 2
hubble observe --to-namespace <ns> --to-label version=v2 --type l7 --last 2
hubble observe --to-ip 172.16.0.123 --print-node-name --last 2
hubble observe --http-status 4+ --since 5m
hubble observe --verdict DROPPED --drop-reason-desc POLICY_DENIED --last 5   # Tag 21
hubble observe --http-path '/customer' --protocol http --last 2
hubble observe --trace-id <trace-id> --type l7 --last 50
hubble observe --from-cluster ost --to-port 8080 --last 1     # ClusterMesh
hubble observe -f --pod <ns>/<pod> --type l7                  # live folgen
hubble observe -P --port-forward-port 0 --kube-context west -n tag17 --last 1
hubble list nodes

JSON auswerten, Mitschnitt offline filtern:

hubble observe --to-pod <ns>/<pod> --verdict DROPPED --last 1 -o json \
  | jq -c '{src: .flow.source.pod_name, dst: .flow.destination.pod_name,
  port: .flow.l4.TCP.destination_port, drop: .flow.drop_reason_desc}'
hubble observe -n tag20 --last 300 -o jsonpb > mitschnitt.json
hubble observe --input-file mitschnitt.json --pod tag20/customer --protocol http
  • Keine L7-Flows ohne L7-Regel: rules: http: [{}] bzw. dns in einer CNP macht den Verkehr sichtbar, ohne etwas zu sperren.

Flow-Logs in eine Datei (Helm-Werte, mit --reuse-values -f flowlog.yaml):

hubble:
  export:
    dynamic:
      enabled: true
      config:
        content:
        - name: tag20
          filePath: /var/run/cilium/hubble/tag20.log
          includeFilters:
          - source_pod: ["tag20/"]
          - destination_pod: ["tag20/"]
          fileMaxSizeMb: 5
          fileMaxBackups: 2
cilium config view | grep flowlogs
N=$(k get pod <pod> -o jsonpath='{.status.hostIP}')   # Node-IP des Pods
ssh ubuntu@$N "sudo cat /var/run/cilium/hubble/tag20.log" > w2.log
jq -r '.flow.verdict' w2.log | sort | uniq -c
jq -r 'select(.flow.verdict=="DROPPED") | .flow.drop_reason_desc' w2.log | uniq -c

Metriken (Tag 19)

Helm-Werte (Tag 19, per -f): prometheus.enabled und .serviceMonitor.enabled, hubble.metrics.enabled als Liste (dns, drop, tcp, flow, port-distribution, httpV2:labelsContext=source_namespace,source_workload,…) und hubble.metrics.serviceMonitor.enabled.

cilium config view | grep -E 'hubble-metrics |prometheus-serve-addr'
curl -s localhost:9962/metrics | grep '^cilium_drop_count_total'   # Agent, je Node
curl -s localhost:9965/metrics | grep '^hubble_drop_total'         # Hubble, je Node
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg metrics list \
  -p drop_count
k -n kube-system get servicemonitors

PromQL (im Buch per promtool query instant im Prometheus-Pod):

count by (job) (up{job=~"cilium.*|hubble.*"})
sum by (reason, node) (rate(hubble_drop_total[5m]))
sum by (rcode) (rate(hubble_dns_responses_total[1m]))
sum by (status) (rate(hubble_http_requests_total{destination_namespace="tag19"}[1m]))
histogram_quantile(0.95, sum by (le, destination_workload)
  (rate(hubble_http_request_duration_seconds_bucket[5m])))

Alarm als PrometheusRule (spec.groups[].rules[] mit alert, expr, for; Tag 19):

expr: sum by (node) (rate(hubble_drop_total{reason="POLICY_DENIED"}[1m])) > 0.2
  • Drop-Gründe heißen in hubble_drop_total knapp (POLICY_DENIED), in cilium_drop_count_total ausgeschrieben (Policy denied).
  • DNS- und HTTP-Metriken gibt es nur für Verkehr mit L7-Regel.

Symptom und erster Befehl

Symptom Erster Befehl
Node NotReady, „cni plugin not initialized“ /etc/cni/net.d, Agent-Pod
Wer setzt Services um? cilium-dbg status, Zeile KubeProxyReplacement
Service antwortet nicht k get endpointslices -l kubernetes.io/service-name=…
Endpunkte leer Selector gegen --show-labels, targetPort gegen Container
Pod bekommt RST cilium-dbg service list: Backend-Port
Name nicht auflösbar cat /etc/resolv.conf im Pod, dig mit vollem Namen
Corefile-Änderung ohne Wirkung CoreDNS-Logs: Reloading complete oder [ERROR]
Verbindung hängt (Timeout) hubble observe --verdict DROPPED
403 Access denied L7-Regel der CNP (Methode, Pfad, Header)
toFQDNs sperrt alles DNS-Regel mit dns: matchPattern fehlt
LoadBalancer <pending> k get ippools, serviceSelector
Gateway nicht Programmed Gateway-Conditions, Service-Typ (NodePort-Klasse)
Route nicht Accepted Route-Conditions: sectionName, allowedRoutes
ResolvedRefs=False Service-Name, ReferenceGrant im Ziel-Namespace
TLS-Listener fällt aus .status.listeners[*].conditions: Secret-Name
BGP-Route fehlt am Router cilium bgp peers: Advertised, Labels
Egress-Gateway ohne Wirkung cilium-dbg bpf egress list auf dem Gateway-Node
WireGuard gesetzt, Encryption: Disabled rollout restart ds/cilium
Cluster sehen sich nicht cilium clustermesh status, cluster-name/-id
Keine Hubble-Metrik cilium config view: hubble-metrics, Port 9965
Keine L7-Flows in Hubble CNP mit http: [{}] bzw. dns

Doku-Stellen

Die Seiten, die in den Prüfungstipps der Tage stehen, nach Bereich:

  • Handwerk: kubernetes.io „Debug Running Pods“; docs.cilium.io „Troubleshooting“, „Command Cheatsheet“
  • CNI, IPAM: kubernetes.io „Network Plugins“; docs.cilium.io „Installation using Helm“, „Upgrade Guide“, „IP Address Management (IPAM)“
  • Multus: github.com/k8snetworkplumbingwg/multus-cni („Quickstart“, „How to use“)
  • Services: kubernetes.io „Service“, „Service Internal Traffic Policy“, „Create an External Load Balancer“, „Virtual IPs and Service Proxies“
  • kube-proxy-Ersatz: docs.cilium.io „Kubernetes Without kube-proxy“, „Routing“
  • DNS: kubernetes.io „Customizing DNS Service“, „DNS for Services and Pods“, „Debugging DNS Resolution“; coredns.io/plugins
  • Endpunkte: kubernetes.io „EndpointSlices“, „Traffic Distribution“, „Specifying a Disruption Budget for your Application“
  • Gateway API: gateway-api.sigs.k8s.io „Guides“, „TLS“, „BackendTLSPolicy“; cert-manager.io „Gateway“; docs.cilium.io „Gateway API – HTTPS Example“
  • BGP, LB-IPAM: docs.cilium.io „BGP Control Plane“, „LoadBalancer IP Address Management (LB IPAM)“, „L2 Announcements“
  • Egress: docs.cilium.io „Egress Gateway“
  • ClusterMesh: docs.cilium.io „Setting up Cluster Mesh“, „Load-balancing & Service Discovery“
  • LLM-Traffic: gateway-api-inference-extension.sigs.k8s.io „API Overview“, „Implementations“
  • Policies: kubernetes.io „Network Policies“; docs.cilium.io „Layer 3/4/7 Examples“, „DNS based“, „Deny Policies“
  • Verschlüsselung, Auth: docs.cilium.io „WireGuard Transparent Encryption“, „Mutual Authentication (Beta)“
  • Observability: docs.cilium.io „Monitoring & Metrics“, „Inspecting Network Flows with the CLI“, „Configuring Hubble exporter“, „Layer 7 Protocol Visibility“

Welche dieser Seiten in der Prüfung geöffnet werden dürfen, steht in den aktuellen Prüfungshinweisen der Linux Foundation.