Dieses Dokument wurde mithilfe automatisierter maschineller Übersetzungstechnologie übersetzt. Wir bemühen uns um korrekte Übersetzungen, übernehmen jedoch keine Gewähr für die Vollständigkeit, Richtigkeit oder Zuverlässigkeit der übersetzten Inhalte. Im Falle von Abweichungen ist die englische Originalversion maßgebend und stellt den verbindlichen Text dar.

DNS

Die auf dieser Seite aufgeführten Befehle/Schritte können verwendet werden, um Probleme mit der Namensauflösung in Ihrem Cluster zu überprüfen.

Stellen Sie sicher, dass Sie die korrekte kubeconfig konfiguriert haben (zum Beispiel export KUBECONFIG=$PWD/kube_config_cluster.yml für Rancher HA) oder dass Sie das eingebettete kubectl über die Benutzeroberfläche verwenden.

Bevor Sie die DNS-Überprüfungen durchführen, stellen Sie sicher, dass das Overlay-Netzwerk korrekt funktioniert für Ihren DNS-Anbieter, da dies auch der Grund sein kann, warum die DNS-Auflösung (teilweise) fehlschlägt.

Überprüfen Sie, ob die DNS-Pods laufen.

kubectl -n kube-system get pods -l k8s-app=kube-dns

Beispielausgabe bei Verwendung von CoreDNS:

NAME                       READY   STATUS    RESTARTS   AGE
coredns-799dffd9c4-6jhlz   1/1     Running   0          76m

Beispielausgabe bei Verwendung von kube-dns:

NAME                        READY   STATUS    RESTARTS   AGE
kube-dns-5fd74c7488-h6f7n   3/3     Running   0          4m13s

Überprüfen Sie, ob der DNS-Dienst mit der korrekten Cluster-IP vorhanden ist.

kubectl -n kube-system get svc -l k8s-app=kube-dns
NAME               TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)         AGE
service/kube-dns   ClusterIP   10.43.0.10   <none>        53/UDP,53/TCP   4m13s

Überprüfen Sie, ob Domainnamen aufgelöst werden.

Überprüfen Sie, ob interne Clusternamen aufgelöst werden (in diesem Beispiel kubernetes.default), die IP, die nach Server: angezeigt wird, sollte die gleiche sein wie die CLUSTER-IP vom kube-dns Dienst.

kubectl run -it --rm --restart=Never busybox --image=busybox:1.28 -- nslookup kubernetes.default

Beispielausgabe:

Server:    10.43.0.10
Address 1: 10.43.0.10 kube-dns.kube-system.svc.cluster.local

Name:      kubernetes.default
Address 1: 10.43.0.1 kubernetes.default.svc.cluster.local
pod "busybox" deleted

Überprüfen Sie, ob externe Namen aufgelöst werden (in diesem Beispiel www.google.com).

kubectl run -it --rm --restart=Never busybox --image=busybox:1.28 -- nslookup www.google.com

Beispielausgabe:

Server:    10.43.0.10
Address 1: 10.43.0.10 kube-dns.kube-system.svc.cluster.local

Name:      www.google.com
Address 1: 2a00:1450:4009:80b::2004 lhr35s04-in-x04.1e100.net
Address 2: 216.58.211.100 ams15s32-in-f4.1e100.net
pod "busybox" deleted

Wenn Sie die Auflösung von Domainnamen auf allen Hosts überprüfen möchten, führen Sie die folgenden Schritte aus:

  1. Speichern Sie die folgende Datei als ds-dnstest.yml.

     apiVersion: apps/v1
 kind: DaemonSet
 metadata:
   name: dnstest
 spec:
   selector:
       matchLabels:
         name: dnstest
   template:
     metadata:
       labels:
         name: dnstest
     spec:
       tolerations:
       - operator: Exists
       containers:
       - image: busybox:1.28
         imagePullPolicy: Always
         name: alpine
         command: ["sleep", "infinity"]
         terminationMessagePath: /dev/termination-log

  2. Starten Sie sie mit kubectl create -f ds-dnstest.yml.

  3. Warten Sie, bis kubectl rollout status ds/dnstest -w folgendes Ergebnis anzeigt: daemon set "dnstest" successfully rolled out.

  4. Konfigurieren Sie die Umgebungsvariable DOMAIN auf einen vollständig qualifizierten Domainnamen (FQDN), den der Host auflösen können sollte (www.google.com wird als Beispiel verwendet) und führen Sie den folgenden Befehl aus, damit jeder Container auf jedem Host den konfigurierten Domainnamen auflösen kann (es ist ein einzeiliger Befehl).

     export DOMAIN=www.google.com; echo "=> Start DNS resolve test"; kubectl get pods -l name=dnstest --no-headers -o custom-columns=NAME:.metadata.name,HOSTIP:.status.hostIP | while read pod host; do kubectl exec $pod -- /bin/sh -c "nslookup $DOMAIN > /dev/null 2>&1"; RC=$?; if [ $RC -ne 0 ]; then echo $host cannot resolve $DOMAIN; fi; done; echo "=> End DNS resolve test"

  5. Wenn dieser Befehl abgeschlossen ist, ist die Ausgabe, die anzeigt, dass alles korrekt ist:

     => Start DNS resolve test
 => End DNS resolve test

Wenn in der Ausgabe ein Fehler angezeigt wird, bedeutet dies, dass der/die erwähnte(n) Host(s) den angegebenen FQDN nicht auflösen kann/können.

Beispiel für eine Fehlermeldung in einer Situation, in der der Host mit der IP 209.97.182.150 die UDP-Ports blockiert hatte.

=> Start DNS resolve test
command terminated with exit code 1
209.97.182.150 cannot resolve www.google.com
=> End DNS resolve test

Bereinigen Sie das alpine DaemonSet, indem Sie kubectl delete ds/dnstest ausführen.

CoreDNS-spezifisch

Überprüfen Sie die CoreDNS-Protokollierung

kubectl -n kube-system logs -l k8s-app=kube-dns

Überprüfen Sie die Konfiguration

Die CoreDNS-Konfiguration wird in der ConfigMap coredns im Namespace kube-system gespeichert.

kubectl -n kube-system get configmap coredns -o go-template={{.data.Corefile}}

Überprüfen Sie die Upstream-Namensserver in resolv.conf

Standardmäßig werden die konfigurierten Namensserver auf dem Host (in /etc/resolv.conf) als Upstream-Namensserver für CoreDNS verwendet. Sie können diese Datei auf dem Host überprüfen oder den folgenden Pod mit dnsPolicy auf Default setzen, der das /etc/resolv.conf vom Host erbt, auf dem er läuft.

kubectl run -i --restart=Never --rm test-${RANDOM} --image=ubuntu --overrides='{"kind":"Pod", "apiVersion":"v1", "spec": {"dnsPolicy":"Default"}}' -- sh -c 'cat /etc/resolv.conf'

Aktivieren Sie die Abfrageprotokollierung

Das Aktivieren der Abfrageprotokollierung kann durch Aktivieren des log Plugin in der Corefile-Konfiguration in der ConfigMap coredns erfolgen. Sie können dies tun, indem Sie kubectl -n kube-system edit configmap coredns verwenden oder den folgenden Befehl verwenden, um die Konfiguration direkt zu ersetzen:

kubectl get configmap -n kube-system coredns -o json | sed -e 's_loadbalance_log\\n    loadbalance_g' | kubectl apply -f -

Alle Abfragen werden jetzt protokolliert und können über den Befehl in Überprüfen Sie die CoreDNS-Protokollierung eingesehen werden.

kube-dns-spezifisch

Überprüfen Sie die Upstream-Namensserver im kubedns-Container

Standardmäßig werden die konfigurierten Namensserver auf dem Host (in /etc/resolv.conf) als Upstream-Namensserver für kube-dns verwendet. Manchmal führt der Host einen lokalen Caching-DNS-Namensserver aus, was bedeutet, dass die Adresse in /etc/resolv.conf auf eine Adresse im Loopback-Bereich (127.0.0.0/8) zeigt, die vom Container nicht erreichbar ist. Im Fall von Ubuntu 18.04 geschieht dies durch systemd-resolved. Wir erkennen, ob systemd-resolved läuft, und verwenden automatisch die /etc/resolv.conf-Datei mit den richtigen Upstream-Namensservern (die sich in /run/systemd/resolve/resolv.conf befindet).

Verwenden Sie den folgenden Befehl, um die von dem kubedns-Container verwendeten Upstream-Namensserver zu überprüfen:

kubectl -n kube-system get pods -l k8s-app=kube-dns --no-headers -o custom-columns=NAME:.metadata.name,HOSTIP:.status.hostIP | while read pod host; do echo "Pod ${pod} on host ${host}"; kubectl -n kube-system exec $pod -c kubedns cat /etc/resolv.conf; done

Beispielausgabe:

Pod kube-dns-667c7cb9dd-z4dsf on host x.x.x.x
nameserver 1.1.1.1
nameserver 8.8.4.4

Wenn die Ausgabe eine Adresse im Loopback-Bereich (127.0.0.0/8) anzeigt, können Sie dies auf zwei Arten korrigieren:

  • Stellen Sie sicher, dass die richtigen Namensserver in /etc/resolv.conf auf Ihren Knoten im Cluster aufgeführt sind. Bitte konsultieren Sie die Dokumentation Ihres Betriebssystems, um zu erfahren, wie dies erreicht wird. Stellen Sie sicher, dass Sie dies vor der Bereitstellung eines Clusters ausführen oder die Knoten nach der Änderung neu starten.

  • Konfigurieren Sie die kubelet so, dass eine andere Datei zur Namensauflösung verwendet wird, indem Sie extra_args wie unten gezeigt verwenden (wobei /run/resolvconf/resolv.conf die Datei mit den richtigen Namensservern ist).

services:
  kubelet:
    extra_args:
      resolv-conf: "/run/resolvconf/resolv.conf"

Da die kubelet in einem Container läuft, befinden sich die Pfade für Dateien, die in /etc und /usr gespeichert sind, in /host/etc und /host/usr innerhalb des kubelet-Containers.

Siehe "Cluster als YAML bearbeiten", um zu erfahren, wie Sie diese Änderung anwenden. Wenn die Bereitstellung des Clusters abgeschlossen ist, müssen Sie den kube-dns-Pod entfernen, um die neue Einstellung im Pod zu aktivieren:

kubectl delete pods -n kube-system -l k8s-app=kube-dns
pod "kube-dns-5fd74c7488-6pwsf" deleted

Versuchen Sie erneut, den Namen aufzulösen, indem Sie prüfen, ob Domainnamen aufgelöst werden.

Wenn Sie die kube-dns-Konfiguration in Ihrem Cluster überprüfen möchten (zum Beispiel, um zu überprüfen, ob unterschiedliche Upstream-Namensserver konfiguriert sind), können Sie den folgenden Befehl ausführen, um die kube-dns-Konfiguration aufzulisten:

kubectl -n kube-system get configmap kube-dns -o go-template='{{range $key, $value := .data}}{{ $key }}{{":"}}{{ $value }}{{"\n"}}{{end}}'

Beispielausgabe:

upstreamNameservers:["1.1.1.1"]