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 exitcilium-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 AufrufLinux-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@if33kubectl 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 infinityCore 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 CNIim Log). - Mit
cni.exclusive=truebenennt Cilium fremde Dateien in*.cilium_bakum.
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 GLEICHcilium 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 Quellencilium config viewliest 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-operatornode.spec.podCIDRist nur im IPAM-Moduskubernetesgefüllt – beicluster-poolzählt die CiliumNode.CiliumPodIPPoolplus Annotationipam.cilium.io/ip-poolwirkt nur mitipam.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.confmuss die erste Datei in/etc/cni/net.dsein.net1lä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 LocalService ohne Selector mit eigener EndpointSlice:
k create service clusterip router --tcp=80:8000 $do > router-svc.yaml
sed -i '/selector:/,+1d' router-svc.yamlapiVersion: 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.123externalTrafficPolicywirkt nur auf NodePort/LoadBalancer,internalTrafficPolicynur auf Verkehr aus dem Cluster;Localohne 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(Feldmodein seiner ConfigMap). - DSR braucht Native Routing (oder Geneve);
autoDirectNodeRoutesnur 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.yamlBlö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
fallthroughbeantwortethostsalle 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 fragendnsPolicy 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
ENDPOINTSverschweigt unbereite Pods – Conditions lesen. Cilium zeigt sie incilium-dbg service listalsmaintenancebzw.terminating. trafficDistribution:PreferSameZone,PreferSameNode,PreferClose(alter Name); Zonen-Hints nur mit Labeltopology.kubernetes.io/zonean 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 ClusterMeshAnnotationen 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 $CIPPolicy über Clustergrenzen – ohne Cluster-Label gilt
fromEndpoints nur lokal:
ingress:
- fromEndpoints:
- matchLabels:
run: client
io.cilium.k8s.policy.cluster: ostMCS-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/hostnameAdvanced 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-ObjekteGateway 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: tag10HTTPRoute 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: 10Filter (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: ServiceStatus 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 übermatches[].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: 301Secret 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 shopBackendTLSPolicy – 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-caam 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: PodCIDRk 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 0bei stehender Sitzung: Label-Selector der PeerConfig trifft keinCiliumBGPAdvertisement, 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
podSelectorgehtnamespaceSelectormitkubernetes.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:FailOpenoderFailClose(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: 53from: 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: 23k -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
ipBlockkeine Node-IPs (Identitätenhost,remote-node) – dafürtoEntities.
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,pathundheaders: ["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: TCPk -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: /notesS="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 nodesJSON 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.dnsin 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: 2cilium 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 -cMetriken (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 servicemonitorsPromQL (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_totalknapp (POLICY_DENIED), incilium_drop_count_totalausgeschrieben (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.