Tag 8: CoreDNS anpassen
Ziel: Du liest und änderst das Corefile sicher, verstehst Service- und Pod-Namen, ndots und dnsConfig und findest DNS-Fehler schnell. · Dauer: ca. 90 min · Voraussetzung: Tag 6
Briefing
- Lehrplan: „CKNE: Service Networking and DNS“ (Customizing CoreDNS) und „Troubleshooting Pod Connectivity“ (DNS).
- CoreDNS ist ein ganz normales Deployment hinter dem Service
kube-dns(10.96.0.10); seine Konfiguration steht in der ConfigMapcoredns. - Das kubelet schreibt jedem Pod
nameserver 10.96.0.10, die Suchliste undndots:5in/etc/resolv.conf. - Änderungen am Corefile lädt das Plugin
reloadohne Pod-Neustart – ein Tippfehler kann trotzdem den Cluster-DNS lahmlegen. Deshalb heute: erst prüfen, dann einspielen.
Pod (resolv.conf: 10.96.0.10, ndots:5)
| Cilium Socket-LB: 10.96.0.10:53 -> CoreDNS-Pod
v
CoreDNS (ConfigMap coredns, Corefile)
|-- cluster.local -> kubernetes-Plugin (Services, Pods)
|-- lab.intern -> forward 172.16.0.123 (router, Drill 6)
'-- alles andere -> forward /etc/resolv.conf des Nodes
Drill 1: CoreDNS-Aufbau lesen
Zuerst sicherst du die Original-ConfigMap – am Tagesende spielst du genau diese zurück.
mkdir -p ~/ckne/tag08 && cd ~/ckne/tag08
k -n kube-system get cm coredns -o yaml > ~/ckne/tag08/coredns-vorher.yaml
k -n kube-system get deploy,svc,endpointslices -l k8s-app=kube-dnsErwartet (gekürzt):
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/coredns 2/2 2 2 41m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kube-dns ClusterIP 10.96.0.10 <none> 53/UDP,53/TCP,9153/TCP 41m
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
kube-dns-jjx5f IPv4 53,53,9153 10.0.0.219,10.0.0.71 41m
Der Service heißt aus historischen Gründen kube-dns,
dahinter läuft CoreDNS. Woher kennt ein Pod die IP? Aus der
kubelet-Konfiguration:
sudo grep -A1 -E 'clusterDNS|clusterDomain|resolvConf' /var/lib/kubelet/config.yaml
grep -v '^#' /run/systemd/resolve/resolv.confErwartet (gekürzt):
clusterDNS:
- 10.96.0.10
clusterDomain: cluster.local
resolvConf: /run/systemd/resolve/resolv.conf
nameserver 172.16.0.15
nameserver 8.8.8.8
nameserver 1.1.1.1
search localdomain
resolvConf ist die Datei, die Pods mit
dnsPolicy: Default bekommen – auch CoreDNS selbst
(k -n kube-system get deploy coredns -o jsonpath='{..dnsPolicy}'
→ Default). Daraus stammen die Upstream-Server für externe
Namen. Jetzt das Corefile:
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}'Erwartet:
.:53 {
errors
health {
lameduck 5s
}
ready
kubernetes cluster.local in-addr.arpa ip6.arpa {
pods insecure
fallthrough in-addr.arpa ip6.arpa
ttl 30
}
prometheus :9153
forward . /etc/resolv.conf {
max_concurrent 1000
}
cache 30 {
disable success cluster.local
disable denial cluster.local
}
loop
reload
loadbalance
}
| Plugin | Aufgabe |
|---|---|
errors, log |
Fehler bzw. jede Anfrage ins Container-Log |
health, ready |
Liveness (:8080) und Readiness (:8181) des Pods |
kubernetes |
beantwortet cluster.local und Reverse-Zonen aus der
API |
forward |
alles andere an Upstream-Server |
cache, loop, reload,
loadbalance |
Cache, Schleifenschutz, Neuladen, Rotation |
.:53 ist ein Server-Block für die Root-Zone, also für
alle Namen. Die Reihenfolge der Plugins im Block spielt keine Rolle –
CoreDNS arbeitet sie in einer fest einkompilierten Reihenfolge ab. Zum
Schluss ein Testgelände:
k create namespace tag08
k -n tag08 create deployment web --image=nginx:1.29 --replicas=2
k -n tag08 expose deployment web --port=80
k -n tag08 expose deployment web --name=web-hl --cluster-ip=None --port=80
k -n tag08 run client --image=nicolaka/netshoot:v0.16 -- sleep infinity
k -n tag08 wait --for=condition=Ready pod --all --timeout=120s
k -n tag08 exec client -- cat /etc/resolv.confErwartet:
search tag08.svc.cluster.local svc.cluster.local cluster.local localdomain
nameserver 10.96.0.10
options ndots:5
Fortschritt speichern? Kostenlos registrieren
Drill 2: Service- und Pod-Namen
k -n tag08 get pods,svc -o wide
k -n tag08 exec client -- dig +short web.tag08.svc.cluster.local
k -n tag08 exec client -- dig +short web-hl.tag08.svc.cluster.local
k -n tag08 exec client -- dig +short web
k -n tag08 exec client -- dig +short +search webErwartet (gekürzt):
pod/client 1/1 Running 0 48s 10.0.2.84 worker2
pod/web-689b9bdbdd-c2t4c 1/1 Running 0 49s 10.0.1.121 worker1
pod/web-689b9bdbdd-ch5rc 1/1 Running 0 49s 10.0.2.231 worker2
service/web ClusterIP 10.109.153.18 <none> 80/TCP 49s app=web
service/web-hl ClusterIP None <none> 80/TCP 0s app=web
10.109.153.18
10.0.2.231
10.0.1.121
10.109.153.18
Normaler Service → eine A-Antwort mit der ClusterIP; headless → die
Pod-IPs. dig web bleibt leer: dig ignoriert die
Suchliste, nur mit +search (oder in
nslookup, curl, Anwendungen) wird
web zu web.tag08.svc.cluster.local.
SRV-Records gibt es nur für benannte Ports.
expose vergibt keinen Namen, also nachrüsten:
k -n tag08 patch svc web --type=json \
-p '[{"op":"add","path":"/spec/ports/0/name","value":"http"}]'
k -n tag08 exec client -- dig +short SRV _http._tcp.web.tag08.svc.cluster.local
k -n tag08 exec client -- dig +short 10-0-1-121.tag08.pod.cluster.local
k -n tag08 exec client -- dig +short -x 10.109.153.18
k -n tag08 exec client -- dig +short -x 10.0.1.121Erwartet:
0 100 80 web.tag08.svc.cluster.local.
10.0.1.121
web.tag08.svc.cluster.local.
10-0-1-121.web.tag08.svc.cluster.local.
10-0-1-121.web-hl.tag08.svc.cluster.local.
Pod-A-Records
(<ip-mit-bindestrichen>.<ns>.pod.cluster.local)
liefert CoreDNS wegen pods insecure für jede IP, ohne zu
prüfen, ob der Pod existiert. Stabile Pod-Namen bekommst du über
hostname und subdomain plus headless
Service:
k -n tag08 apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: db
labels:
app: web
spec:
hostname: db
subdomain: web-hl
containers:
- name: nginx
image: nginx:1.29
EOF
k -n tag08 wait --for=condition=Ready pod/db --timeout=60s
k -n tag08 exec client -- dig +short db.web-hl.tag08.svc.cluster.local
k -n tag08 exec db -- hostname -fErwartet:
10.0.1.198
db.web-hl.tag08.svc.cluster.local
So bekommen auch StatefulSet-Pods ihre Namen
(web-0.<service>…): subdomain muss dem
Namen eines headless Service entsprechen, der den Pod selektiert.
Fortschritt speichern? Kostenlos registrieren
Drill 3: log-Plugin und reload beobachten
Bevor du das Corefile änderst, holst du dir CoreDNS als Binary auf
cp1 – in derselben Version wie das Image. Damit prüfst du
die Syntax, bevor der Cluster sie sieht. Erst die Version aus dem
Deployment lesen:
k -n kube-system get deploy coredns -o jsonpath='{..image}'; echoErwartet:
registry.k8s.io/coredns/coredns:v1.14.6 – daraus
V=1.14.6:
cd /tmp
V=1.14.6
ARCH=$(dpkg --print-architecture)
U=https://github.com/coredns/coredns/releases/download/v$V
curl -sSLO $U/coredns_${V}_linux_${ARCH}.tgz
curl -sSLO $U/coredns_${V}_linux_${ARCH}.tgz.sha256
sha256sum -c coredns_${V}_linux_${ARCH}.tgz.sha256
sudo tar xzf coredns_${V}_linux_${ARCH}.tgz --no-same-owner -C /usr/local/bin
coredns -version
cd ~/ckne/tag08Erwartet:
coredns_1.14.6_linux_amd64.tgz: OK
CoreDNS-1.14.6
linux/amd64, go1.26.5, 424d125
Corefile holen, log hinter errors einfügen,
prüfen:
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}' > Corefile
sed -i 's/^ errors$/ errors\n log/' Corefile
head -3 Corefile
coredns -conf CorefileErwartet:
.:53 {
errors
log
maxprocs: Leaving GOMAXPROCS=4: CPU quota undefined
plugin/kubernetes: unable to load in-cluster configuration, KUBERNETES_SERVICE_HOST and
KUBERNETES_SERVICE_PORT must be defined
Diese Meldung ist hier das gute Ergebnis: Das
Corefile ist syntaktisch in Ordnung, nur das kubernetes-Plugin findet
außerhalb des Clusters keine API. Ein Tippfehler sähe so aus:
Corefile:13 - Error during parsing: Unknown directive 'forwrd'.
Grenze: Fehler in Plugins, die CoreDNS erst nach kubernetes
einrichtet (etwa Argumente von forward), fallen hier nicht
auf.
Einspielen und das Neuladen beobachten:
k -n kube-system create configmap coredns --from-file=Corefile $do | k replace -f -
date +%T
k -n kube-system logs -l k8s-app=kube-dns -f --tail=0 --prefixErwartet (gekürzt, nach ca. 1 min, Abbruch mit Strg+C):
configmap/coredns replaced
23:19:45
[pod/coredns-559f6c778d-nz7t6/coredns] [INFO] Reloading
[pod/coredns-559f6c778d-nz7t6/coredns] [INFO] plugin/reload: Running configuration
SHA512 = 2dd49c56b94cd567...
[pod/coredns-559f6c778d-nz7t6/coredns] [INFO] Reloading complete
[pod/coredns-559f6c778d-nz7t6/coredns] [INFO] 127.0.0.1:43758 - 562 "HINFO IN
4160184936247868763.2761932811795487505. udp 57 false 512" NXDOMAIN ...
Warum dauert das bis zu einer Minute? Das kubelet aktualisiert
gemountete ConfigMaps verzögert, und reload prüft die Datei
standardmäßig alle 30 s (mit Zufallsanteil). Jeder Pod lädt für
sich – kurz antworten beide Replikas unterschiedlich. Die
HINFO-Anfrage stammt vom loop-Plugin, das nach jedem Laden
auf Schleifen testet. Die kubectl edit cm coredns-Variante
wirkt genauso, nur ohne Syntaxprüfung vorher.
Fortschritt speichern? Kostenlos registrieren
Drill 4: ndots, dnsPolicy und dnsConfig
Mit log siehst du jetzt, was ein harmloses
curl http://example.com kostet:
CLIENT_IP=$(k -n tag08 get pod client -o jsonpath='{.status.podIP}')
k -n tag08 exec client -- curl -s -o /dev/null -w '%{http_code}\n' http://example.com
k -n kube-system logs -l k8s-app=kube-dns --since=20s --tail=-1 \
| grep "$CLIENT_IP" | grep '"A IN'Erwartet (gekürzt):
200
[INFO] 10.0.2.84:53716 - 59923 "A IN example.com.tag08.svc.cluster.local. ..." NXDOMAIN
[INFO] 10.0.2.84:53716 - 33823 "A IN example.com.svc.cluster.local. ..." NXDOMAIN
[INFO] 10.0.2.84:53716 - 64596 "A IN example.com.cluster.local. ..." NXDOMAIN
[INFO] 10.0.2.84:53716 - 4669 "A IN example.com.localdomain. ..." NXDOMAIN
[INFO] 10.0.2.84:53716 - 2726 "A IN example.com. udp 40 false 1232" NOERROR ...
example.com hat weniger als 5 Punkte
(ndots:5), also probiert der Resolver zuerst alle vier
Suchdomains – mit AAAA sind das 10 Anfragen statt 2.
--tail=-1 ist nötig, weil logs -l sonst nur 10
Zeilen pro Pod zeigt. Gegenmittel pro Pod: dnsConfig.
cat > client-ndots.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: client-ndots
spec:
dnsConfig:
options:
- name: ndots
value: "1"
containers:
- name: netshoot
image: nicolaka/netshoot:v0.16
command: ["sleep", "infinity"]
EOF
cat > client-none.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: client-none
spec:
dnsPolicy: None
dnsConfig:
nameservers: ["1.1.1.1"]
searches: ["example.org"]
containers:
- name: netshoot
image: nicolaka/netshoot:v0.16
command: ["sleep", "infinity"]
EOF
k -n tag08 apply -f client-ndots.yaml -f client-none.yaml
k -n tag08 wait --for=condition=Ready pod/client-ndots pod/client-none
k -n tag08 exec client-ndots -- cat /etc/resolv.conf
k -n tag08 exec client-none -- cat /etc/resolv.confErwartet:
search tag08.svc.cluster.local svc.cluster.local cluster.local localdomain
nameserver 10.96.0.10
options ndots:1
search example.org
nameserver 1.1.1.1
dnsConfig wird mit der dnsPolicy
zusammengeführt; nur bei None zählt allein
dnsConfig. Die Folgen im Log:
NIP=$(k -n tag08 get pod client-ndots -o jsonpath='{.status.podIP}')
k -n tag08 exec client-ndots -- curl -s -o /dev/null -w '%{http_code}\n' \
http://example.com
k -n tag08 exec client-ndots -- curl -s -o /dev/null -w '%{http_code}\n' \
http://web.tag08
k -n kube-system logs -l k8s-app=kube-dns --since=20s --tail=-1 \
| grep "$NIP" | grep '"A IN'
k -n tag08 exec client-none -- curl -s -m 5 http://web.tag08.svc.cluster.local
echo $?Erwartet (gekürzt):
200
200
[INFO] 10.0.1.178:58941 - 17739 "A IN example.com. ..." NOERROR qr,rd,ra 83 0.0104s
[INFO] 10.0.1.178:52099 - 48594 "A IN web.tag08. ..." NXDOMAIN qr,rd,ra 102 0.4078s
[INFO] 10.0.1.178:52099 - 7446 "A IN web.tag08.tag08.svc.cluster.local. ..." NXDOMAIN
[INFO] 10.0.1.178:52099 - 51482 "A IN web.tag08.svc.cluster.local. ..." NOERROR
command terminated with exit code 6
6
example.com geht mit ndots:1 sofort raus.
Der Preis: web.tag08 hat jetzt auch einen Punkt, wird
zuerst als absoluter Name ins Internet gefragt (0,4 s bis NXDOMAIN) und
erst dann über die Suchliste gefunden. client-none kennt
den Cluster-DNS gar nicht (curl-Exit 6 = Name nicht auflösbar). Ohne
Pod-Änderung hilft ein Punkt am Ende:
curl http://example.com. erzeugt genau eine A-Anfrage.
Fortschritt speichern? Kostenlos registrieren
Drill 5: hosts und rewrite
Zwei typische Prüfungswünsche: ein fester Name für eine IP außerhalb
des Clusters und ein Alias auf einen Service. Öffne das Corefile
(vim Corefile) und füge unter ready ein:
hosts {
172.16.0.123 router.lab.local
fallthrough
}
rewrite name exact notes.lab.local web.tag08.svc.cluster.local
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}' | diff - Corefile
coredns -conf Corefile 2>&1 | tail -1
k -n kube-system create configmap coredns --from-file=Corefile $do | k replace -f -Erwartet (gekürzt):
7a8,12
> hosts {
> 172.16.0.123 router.lab.local
> fallthrough
> }
> rewrite name exact notes.lab.local web.tag08.svc.cluster.local
plugin/kubernetes: unable to load in-cluster configuration, ...
configmap/coredns replaced
Nach etwa einer Minute (Log: Reloading complete für
beide Pods):
k -n tag08 exec client -- dig +short router.lab.local
k -n tag08 exec client -- dig +short -x 172.16.0.123
k -n tag08 exec client -- dig notes.lab.local | grep -A1 'ANSWER SECTION'
k -n tag08 exec client -- curl -s -o /dev/null -w '%{http_code}\n' \
http://notes.lab.local
k -n tag08 exec client -- dig +short example.comErwartet:
172.16.0.123
router.lab.local.
;; ANSWER SECTION:
notes.lab.local. 30 IN A 10.109.153.18
200
172.66.147.243
104.20.23.154
hosts erzeugt auch den PTR-Record. rewrite
schreibt die Frage um, bevor das kubernetes-Plugin sie sieht, und die
Antwort zurück – der Client sieht weiter notes.lab.local.
Ohne fallthrough beantwortet
hosts jeden anderen Namen mit SERVFAIL (das testest du in
der Challenge, nicht am Cluster-DNS).
Fortschritt speichern? Kostenlos registrieren
Drill 6: Stub-Domain zum router
Firmennetze haben eigene Zonen, die nur ein interner DNS-Server
kennt. Auf dem router spielst du diesen Server – mit
demselben CoreDNS-Binary:
ssh [email protected]
cd /tmp
V=1.14.6
ARCH=$(dpkg --print-architecture)
U=https://github.com/coredns/coredns/releases/download/v$V
curl -sSLO $U/coredns_${V}_linux_${ARCH}.tgz
curl -sSLO $U/coredns_${V}_linux_${ARCH}.tgz.sha256
sha256sum -c coredns_${V}_linux_${ARCH}.tgz.sha256
sudo tar xzf coredns_${V}_linux_${ARCH}.tgz --no-same-owner -C /usr/local/bin
sudo mkdir -p /etc/coredns
cat <<'EOF' | sudo tee /etc/coredns/Corefile
lab.intern:53 {
bind 172.16.0.123
hosts {
172.16.0.123 router.lab.intern
10.20.30.40 db.lab.intern
}
log
errors
}
EOF
sudo systemd-run --unit=tag08-dns /usr/local/bin/coredns -conf /etc/coredns/Corefile
sudo ss -lunp | grep coredns
exitErwartet (gekürzt):
coredns_1.14.6_linux_amd64.tgz: OK
Running as unit: tag08-dns.service; invocation ID: 4ea3e335ed444ec5a3759c0995aea187
UNCONN 0 0 172.16.0.123:53 0.0.0.0:* users:(("coredns",...))
bind 172.16.0.123 ist nötig, weil
systemd-resolved schon auf 127.0.0.53:53 lauscht.
systemd-run startet eine flüchtige Unit, die du später mit
einem Befehl stoppst. Zurück auf cp1: vorher/nachher.
dig +short @172.16.0.123 db.lab.intern
k -n tag08 exec client -- dig db.lab.intern | grep status
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}' > Corefile
cat >> Corefile <<'EOF'
lab.intern:53 {
errors
cache 30
forward . 172.16.0.123
}
EOF
coredns -conf Corefile 2>&1 | tail -1
k -n kube-system create configmap coredns --from-file=Corefile $do | k replace -f -Erwartet (gekürzt):
10.20.30.40
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 36252
plugin/kubernetes: unable to load in-cluster configuration, ...
configmap/coredns replaced
Nach dem Reload:
k -n tag08 exec client -- dig db.lab.intern | grep -A1 -E 'status|ANSWER SEC'
k -n tag08 exec client -- dig +short router.lab.intern
ssh [email protected] "sudo journalctl -u tag08-dns --no-pager | tail -2"Erwartet (gekürzt):
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 6996
;; flags: qr aa rd; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
;; ANSWER SECTION:
db.lab.intern. 30 IN A 10.20.30.40
172.16.0.123
... coredns[3576]: [INFO] 172.16.0.126:50139 - 35812 "A IN db.lab.intern. ..." NOERROR
... coredns[3576]: [INFO] 172.16.0.126:50139 - 9092 "A IN router.lab.intern. ..." ...
Der längste passende Server-Block gewinnt: lab.intern
geht an den router, alles andere weiter durch .:53. Der
router sieht als Absender die Node-IP (hier cp1), weil
Cilium Pod-Traffic nach außen maskiert. Das ist die Corefile-Form der
„stub domain“; dieselbe Zeile forward . <IP> im Block
.:53 würde alle externen Namen umleiten
(„upstream nameserver“).
Fortschritt speichern? Kostenlos registrieren
Drill 7: CoreDNS skalieren, Anti-Affinity
k -n kube-system get pods -l k8s-app=kube-dns -o wide
k -n kube-system get deploy coredns -o jsonpath='{.spec.template.spec.affinity}'; echoErwartet (gekürzt):
NAME READY STATUS RESTARTS AGE IP NODE
coredns-559f6c778d-nz7t6 1/1 Running 0 48m 10.0.0.71 cp1
coredns-559f6c778d-vwrtf 1/1 Running 0 48m 10.0.0.219 cp1
{"podAntiAffinity":{"preferredDuringSchedulingIgnoredDuringExecution":[{"podAffinityTer
m":{"labelSelector":...,"topologyKey":"kubernetes.io/hostname"},"weight":100}]}}
Beide Replikas auf cp1: Sie entstanden vor dem Join der
Worker, und die Anti-Affinity ist nur preferred. Fällt
cp1 aus, ist DNS weg. Skalieren verteilt neu:
k -n kube-system scale deployment coredns --replicas=3
k -n kube-system rollout status deployment coredns
k -n kube-system get pods -l k8s-app=kube-dns -o wide
k -n kube-system scale deployment coredns --replicas=2
k -n kube-system get pods -l k8s-app=kube-dns -o wideErwartet (gekürzt):
coredns-559f6c778d-6png2 1/1 Running 0 6s 10.0.1.49 worker1
coredns-559f6c778d-nz7t6 1/1 Running 0 48m 10.0.0.71 cp1
coredns-559f6c778d-vwrtf 1/1 Running 0 48m 10.0.0.219 cp1
deployment.apps/coredns scaled
coredns-559f6c778d-6png2 1/1 Running 0 15s 10.0.1.49 worker1
coredns-559f6c778d-vwrtf 1/1 Running 0 48m 10.0.0.219 cp1
Beim Herunterskalieren löscht der ReplicaSet-Controller bevorzugt
Pods auf Nodes mit mehreren Replikas – jetzt sind sie verteilt. Der neue
Pod liest das aktuelle Corefile; lameduck 5s lässt den
gelöschten Pod laufende Anfragen noch beantworten. Für harte Verteilung:
requiredDuringScheduling… oder
topologySpreadConstraints, dazu ein
PodDisruptionBudget.
Fortschritt speichern? Kostenlos registrieren
Drill 8: NodeLocal DNSCache und Cilium
NodeLocal DNSCache (kubernetes.io: „Using NodeLocal DNSCache in Kubernetes Clusters“) ist ein DaemonSet mit einem CoreDNS-Cache auf jedem Node. Klassisch lauscht er auf einer Link-Local-IP (169.254.20.10) und fängt per iptables auch Pakete an die kube-dns-IP ab. Vorteile: weniger Latenz, keine conntrack-Probleme mit UDP, weniger Last auf CoreDNS.
Mit Cilium-KPR greift dieser Trick nicht: Der Socket-LB übersetzt
10.96.0.10 schon beim connect() im Pod in eine
CoreDNS-Pod-IP, die iptables-Regeln sehen die Service-IP nie.
docs.cilium.io beschreibt deshalb unter „Local Redirect Policy“ →
„Node-local DNS cache“ einen eigenen Weg: node-local-dns als normaler
Pod (hostNetwork: false, -setupiptables=false)
plus eine CiliumLocalRedirectPolicy, die den Service
kube-dns auf den Cache-Pod desselben Nodes
umleitet. Voraussetzung ist der Helm-Wert
localRedirectPolicies.enabled=true – in diesem Labor
aus:
cilium config view | grep -ci redirect
k get crd | grep -c ciliumlocalredirectpoliciesErwartet:
0
0
Die Policy aus dem Cilium-Beispiel
(examples/kubernetes-local-redirect/) sieht so aus – nur
lesen, nicht anwenden:
apiVersion: cilium.io/v2
kind: CiliumLocalRedirectPolicy
metadata:
name: nodelocaldns
namespace: kube-system
spec:
redirectFrontend:
serviceMatcher:
serviceName: kube-dns
namespace: kube-system
redirectBackend:
localEndpointSelector:
matchLabels:
k8s-app: node-local-dns
toPorts:
- port: "53"
name: dns
protocol: UDP
- port: "53"
name: dns-tcp
protocol: TCPDanach zeigt cilium-dbg service list für 10.96.0.10 den
Typ LocalRedirect mit nur noch lokalen Backends. Fehlt der
Cache-Pod, fällt Cilium auf die normalen CoreDNS-Backends zurück.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeige Cluster-DNS-IP und Cluster-Domain, die das kubelet auf
cp1an Pods gibt. Zeitziel: 20 s - Starte in
tag08den Podfqdn(netshoot) mitndots:2. Zeitziel: 2 min - Löse den Pod-DNS-Namen eines web-Pods auf. Zeitziel: 1 min
- Zeige, an welche Upstream-Server CoreDNS externe Namen weitergibt. Zeitziel: 1 min
- Prüfe aus Cilium-Sicht, ob
kube-dnsBackends hat. Zeitziel: 30 s
Lösung
sudo grep -A1 -E 'clusterDNS|clusterDomain' /var/lib/kubelet/config.yaml
k -n tag08 run fqdn --image=nicolaka/netshoot:v0.16 $do -- sleep infinity > fqdn.yaml
vim fqdn.yamlUnter dnsPolicy: ClusterFirst ergänzen:
dnsConfig:
options:
- name: ndots
value: "2"k apply -f fqdn.yaml
k -n tag08 exec fqdn -- grep options /etc/resolv.conf
P=$(k -n tag08 get pod -l app=web,pod-template-hash \
-o jsonpath='{.items[0].status.podIP}')
k -n tag08 exec client -- dig +short ${P//./-}.tag08.pod.cluster.local
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}' | grep forward
sudo grep resolvConf /var/lib/kubelet/config.yaml
grep ^nameserver /run/systemd/resolve/resolv.conf
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
| grep -A2 '10.96.0.10:53/UDP'Erwartet (gekürzt):
clusterDNS:
- 10.96.0.10
clusterDomain: cluster.local
options ndots:2
10.0.1.121
forward . /etc/resolv.conf {
resolvConf: /run/systemd/resolve/resolv.conf
nameserver 172.16.0.15
nameserver 8.8.8.8
nameserver 1.1.1.1
5 10.96.0.10:53/UDP ClusterIP 1 => 10.0.0.219:53/UDP (active)
2 => 10.0.1.49:53/UDP (active)
/etc/resolv.conf im forward-Eintrag ist die
Datei im CoreDNS-Pod – wegen
dnsPolicy: Default die resolvConf-Datei des
Nodes. Bei Netzwerkproblemen direkt einen CoreDNS-Pod fragen
(dig @10.0.0.219 …), um Service-Weg und CoreDNS zu
trennen.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}' \
| grep -E 'log|hosts|rewrite|lab.intern'Erwartet: die Zeilen log,
hosts {, rewrite name exact … und
lab.intern:53 {.
k -n tag08 exec client -- dig +short router.lab.localErwartet: 172.16.0.123
k -n tag08 exec client -- dig +short notes.lab.localErwartet: die ClusterIP von web (hier
10.109.153.18).
k -n tag08 exec client -- dig +short db.lab.internErwartet: 10.20.30.40
k -n tag08 exec client-ndots -- grep options /etc/resolv.confErwartet: options ndots:1
k -n kube-system get pods -l k8s-app=kube-dns -o wideErwartet: zwei CoreDNS-Pods Running auf
verschiedenen Nodes.
Challenge
Eine Kopie von CoreDNS (dns-test in tag08)
startet nach einem Neustart nicht mehr, und selbst repariert beantwortet
sie keine externen Namen. Bring sie zum Laufen, ohne den Cluster-DNS
anzufassen: test.lab.local → 10.20.30.40,
example.com auflösbar. Vorbereitung (erst die
funktionierende Kopie, dann die kaputte Konfiguration):
cat > dns-test.Corefile <<'EOF'
.:53 {
errors
log
health {
lameduck 5s
}
ready
hosts {
10.20.30.40 test.lab.local
fallthrough
}
forward . /etc/resolv.conf
cache 30
reload
}
EOF
k -n tag08 create configmap dns-test --from-file=Corefile=dns-test.Corefile
cat > dns-test.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: dns-test
spec:
replicas: 1
selector:
matchLabels:
app: dns-test
template:
metadata:
labels:
app: dns-test
spec:
containers:
- name: coredns
image: registry.k8s.io/coredns/coredns:v1.14.6
args: ["-conf", "/etc/coredns/Corefile"]
readinessProbe:
httpGet:
path: /ready
port: 8181
volumeMounts:
- name: config
mountPath: /etc/coredns
volumes:
- name: config
configMap:
name: dns-test
EOF
k -n tag08 apply -f dns-test.yaml
k -n tag08 rollout status deploy dns-test
cat > kaputt.Corefile <<'EOF'
.:53 {
errors
log
health {
lameduck 5s
ready
hosts {
10.20.30.40 test.lab.local
}
forward . /etc/resolv.conf
cache 30
reload
}
EOF
k -n tag08 create configmap dns-test --from-file=Corefile=kaputt.Corefile $do \
| k replace -f -Warte etwa zwei Minuten, dann
k -n tag08 rollout restart deployment dns-test.
Hinweis: Erst die Logs des alten Pods lesen, dann
coredns -conf auf die Datei loslassen – und danach mit
dig @<Pod-IP> beide Namen testen.
Lösung
k -n tag08 logs deploy/dns-test | grep -E 'Reload|\[ERROR\]'
k -n tag08 get pods -l app=dns-test
coredns -conf kaputt.Corefile 2>&1 | tail -1Erwartet (gekürzt):
[INFO] Reloading
[ERROR] Restart failed: plugin/health: /etc/coredns/Corefile:6 - Error during parsing:
unknown property 'ready'
[ERROR] plugin/reload: Corefile changed but reload failed: ...
NAME READY STATUS RESTARTS AGE
dns-test-57c59bdf4b-w9hsg 0/1 CrashLoopBackOff 2 (19s ago) 40s
dns-test-7b85dbcd85-z47s8 1/1 Running 0 3m14s
plugin/health: kaputt.Corefile:6 - Error during parsing: unknown property 'ready'
Der laufende Pod hat das kaputte Corefile abgelehnt
und arbeitet mit der alten Konfiguration weiter – deshalb fällt der
Fehler oft erst beim nächsten Neustart oder Node-Ausfall auf. Der neue
Pod crasht, das Rolling Update hält den alten am Leben. Die schließende
Klammer nach lameduck 5s fehlt:
sed -i 's/^ lameduck 5s$/&\n }/' kaputt.Corefile
coredns -conf kaputt.Corefile 2>&1 | tail -1
k -n tag08 create configmap dns-test --from-file=Corefile=kaputt.Corefile $do \
| k replace -f -
k -n tag08 rollout status deploy dns-test --timeout=180s
IP=$(k -n tag08 get pod -l app=dns-test -o jsonpath='{.items[0].status.podIP}')
k -n tag08 exec client -- dig +short @$IP test.lab.local
k -n tag08 exec client -- dig @$IP example.com | grep statusErwartet (gekürzt):
Listen: listen tcp :53: bind: permission denied
configmap/dns-test replaced
deployment "dns-test" successfully rolled out
10.20.30.40
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 44441
permission denied heißt: Syntax in Ordnung, nur Port 53
braucht root. Bleibt der zweite Fehler: hosts ohne
fallthrough gibt nichts an forward weiter.
sed -i 's/^ 10.20.30.40 test.lab.local$/&\n fallthrough/' kaputt.Corefile
k -n tag08 create configmap dns-test --from-file=Corefile=kaputt.Corefile $do \
| k replace -f -
k -n tag08 logs deploy/dns-test -f --tail=0
k -n tag08 exec client -- dig +short @$IP example.comErwartet (gekürzt, logs -f nach
Reloading complete mit Strg+C beenden):
[INFO] Reloading
[INFO] Reloading complete
172.66.147.243
104.20.23.154
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Original-Corefile exakt zurückspielen (resourceVersion
entfernen, sonst lehnt replace die alte Version ab) und
vergleichen:
grep -v 'resourceVersion:' ~/ckne/tag08/coredns-vorher.yaml | k replace -f -
diff <(k -n kube-system get cm coredns -o jsonpath='{.data}') \
<(k create -f ~/ckne/tag08/coredns-vorher.yaml $do -o jsonpath='{.data}') \
&& echo IDENTISCHErwartet:
configmap/coredns replaced
IDENTISCH
Nach ca. einer Minute haben beide Pods wieder einen anderen Hash als nach Drill 3 (den des Original-Corefiles):
k -n kube-system logs -l k8s-app=kube-dns --since=3m --tail=-1 --prefix | grep SHA512
k -n tag08 exec client -- dig +short db.lab.intern web.tag08.svc.cluster.local \
example.comErwartet (gekürzt; db.lab.intern
liefert nichts mehr):
[pod/coredns-559f6c778d-vwrtf/coredns] [INFO] plugin/reload: Running configuration
SHA512 = 1b226df79860026c...
[pod/coredns-559f6c778d-6png2/coredns] [INFO] plugin/reload: Running configuration
SHA512 = 1b226df79860026c...
10.109.153.18
172.66.147.243
104.20.23.154
DNS-Server auf dem router entfernen, Namespace löschen:
ssh [email protected] "sudo systemctl stop tag08-dns"
ssh [email protected] "sudo rm -rf /etc/coredns /usr/local/bin/coredns"
dig +short +time=2 +tries=1 @172.16.0.123 db.lab.intern
k delete namespace tag08Erwartet: connection refused vom
router, namespace "tag08" deleted. Die Unit
tag08-dns verschwindet beim Stoppen von selbst. Das Binary
coredns auf cp1 bleibt als Prüfwerkzeug; die
verteilten CoreDNS-Replikas aus Drill 7 auch.
Prüfungstipp
- Corefile ändern heißt in der Prüfung meist
k -n kube-system edit cm coredns. Danach ca. 1 min warten und in den Logs aufReloading completeachten – oderk -n kube-system rollout restart deploy coredns, wenn die Zeit drängt. - Immer mit einem Pod testen und
digden vollen Namen geben (dig nutzt die Suchliste nicht). Erst direkt einen CoreDNS-Pod fragen, dann 10.96.0.10. - Doku: kubernetes.io „Customizing DNS Service“ (stub domains, upstream) und „DNS for Services and Pods“ (Namen, dnsPolicy, dnsConfig); coredns.io/plugins für Optionen.
Enterprise-Notiz
- Das Corefile gehört in Git;
kubeadm upgrademigriert die ConfigMap, Distributionen und Managed-Angebote überschreiben sie teils – dort gibt es eigene Erweiterungspunkte (etwa eine zusätzlichecoredns-custom-ConfigMap). - CoreDNS mit HPA oder cluster-proportional-autoscaler skalieren, mit
PDB und harter Verteilung über Zonen;
ndotspro Anwendung senken spart oft die Hälfte der Last. - NodeLocal DNSCache (mit Cilium per Local Redirect Policy) ist in großen Clustern Standard – weniger Latenz, kein UDP-conntrack-Engpass.
- Metriken auf :9153 (
coredns_dns_responses_totalnach rcode,coredns_reload_failed_total) gehören ins Monitoring – ein hoher NXDOMAIN-Anteil deutet auf ndots-Suchketten. logerzeugt in Produktion große Logmengen: nur gezielt und befristet einschalten, oder mit Klassen filtern (log . { class denial error }).