Zum Inhalt springen
Trainingslager IT-Trainingslager

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 ConfigMap coredns.
  • Das kubelet schreibt jedem Pod nameserver 10.96.0.10, die Suchliste und ndots:5 in /etc/resolv.conf.
  • Änderungen am Corefile lädt das Plugin reload ohne 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-dns

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

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

Erwartet:

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 web

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

Erwartet:

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

Erwartet:

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}'; echo

Erwartet: 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/tag08

Erwartet:

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 Corefile

Erwartet:

.: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 --prefix

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

Erwartet:

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.com

Erwartet:

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
exit

Erwartet (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}'; echo

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

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

Erwartet:

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: TCP

Danach 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

  1. Zeige Cluster-DNS-IP und Cluster-Domain, die das kubelet auf cp1 an Pods gibt. Zeitziel: 20 s
  2. Starte in tag08 den Pod fqdn (netshoot) mit ndots:2. Zeitziel: 2 min
  3. Löse den Pod-DNS-Namen eines web-Pods auf. Zeitziel: 1 min
  4. Zeige, an welche Upstream-Server CoreDNS externe Namen weitergibt. Zeitziel: 1 min
  5. Prüfe aus Cilium-Sicht, ob kube-dns Backends 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.yaml

Unter 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.local

Erwartet: 172.16.0.123

k -n tag08 exec client -- dig +short notes.lab.local

Erwartet: die ClusterIP von web (hier 10.109.153.18).

k -n tag08 exec client -- dig +short db.lab.intern

Erwartet: 10.20.30.40

k -n tag08 exec client-ndots -- grep options /etc/resolv.conf

Erwartet: options ndots:1

k -n kube-system get pods -l k8s-app=kube-dns -o wide

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

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

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

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

Erwartet:

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.com

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

Erwartet: 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 auf Reloading complete achten – oder k -n kube-system rollout restart deploy coredns, wenn die Zeit drängt.
  • Immer mit einem Pod testen und dig den 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 upgrade migriert die ConfigMap, Distributionen und Managed-Angebote überschreiben sie teils – dort gibt es eigene Erweiterungspunkte (etwa eine zusätzliche coredns-custom-ConfigMap).
  • CoreDNS mit HPA oder cluster-proportional-autoscaler skalieren, mit PDB und harter Verteilung über Zonen; ndots pro 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_total nach rcode, coredns_reload_failed_total) gehören ins Monitoring – ein hoher NXDOMAIN-Anteil deutet auf ndots-Suchketten.
  • log erzeugt in Produktion große Logmengen: nur gezielt und befristet einschalten, oder mit Klassen filtern (log . { class denial error }).