Wie installiere ich NodeLocalDNS in meinem EKS-Cluster und behebe Probleme?

Lesedauer: 8 Minute

Ich möchte NodeLocalDNS in meinem Amazon Elastic Kubernetes Service (Amazon EKS)-Cluster installieren und Probleme beheben.

Lösung

Voraussetzungen:

Stelle sicher, dass du kubectl so konfiguriert hast, dass es auf deinen Amazon EKS-Cluster zugreifen kann.
Stelle sicher, dass CoreDNS in deinem Cluster ausgeführt wird.

NodeLocalDNS installieren

NodeLocalDNS verwendet eine Link-Local-IP-Adresse, um DNS-Caching auf jedem Knoten bereitzustellen. Link-Local-Adressen sind IP-Adressen im Bereich 169.254.0.0/16, die nur innerhalb des Netzwerksegments gültig sind.

Hinweis: Die Standard-Link-Local-IP-Adresse für NodeLocalDNS ist 169.254.20.10. Ändere diesen Wert nicht, es sei denn, es gibt einen spezifischen Konflikt in deiner Umgebung.

Um NodeLocalDNS in deinem Amazon EKS-Cluster zu installieren, führe die folgenden Schritte aus:

Führe den folgenden curl-Befehl aus, um das NodeLocalDNS-Manifest aus dem Kubernetes-Repository herunterzuladen:

curl -Lo nodelocaldns.yaml.template https://raw.githubusercontent.com/kubernetes/kubernetes/master/cluster/addons/dns/nodelocaldns/nodelocaldns.yaml

Um die kube-dns-Service-IP-Adresse deines Clusters abzurufen, führe den folgenden Befehl aus:

kubectl get svc kube-dns -n kube-system -o jsonpath='{.spec.clusterIP}'

Hinweis: Notiere die IP-Adresse aus der Ausgabe.

Um die Domain deines Clusters abzurufen, führe den folgenden Befehl aus:

kubectl get configmap coredns -n kube-system -o yaml | grep 'kubernetes'

Die Ausgabe zeigt die Domain deines Clusters.

Um den kube-proxy-Modus zu bestimmen, führe den folgenden Befehl aus:

kubectl get configmap kube-proxy-config -n kube-system -o yaml | grep mode

Die Ausgabe zeigt entweder iptables oder ipvs als Moduswert.

Bearbeite das NodeLocalDNS-Manifest basierend auf deinem kube-proxy-Modus.

Für den iptables-Modus bearbeite das Manifest mit den folgenden Befehlen:

# Set environment variables for node-local-dns
kubedns=$(kubectl get svc kube-dns -n kube-system -o jsonpath={.spec.clusterIP})
domain=cluster.local
localdns=`169.254.20.10`

# Update the manifest with your cluster's specific values:
sed "s/__PILLAR__LOCAL__DNS__/$localdns/g; s/__PILLAR__DNS__DOMAIN__/$domain/g; s/__PILLAR__DNS__SERVER__/$kubedns/g" nodelocaldns.yaml.template > nodelocaldns.yaml

Für den IPVS-Modus bearbeite das Manifest mit den folgenden Befehlen:

# Set environment variables for node-local-dns
kubedns=$(kubectl get svc kube-dns -n kube-system -o jsonpath={.spec.clusterIP})
domain=cluster.local
localdns=169.254.20.10

# Update the manifest with your cluster's specific values:
sed "s/__PILLAR__LOCAL__DNS__/$localdns/g; s/__PILLAR__DNS__DOMAIN__/$domain/g; s/,__PILLAR__DNS__SERVER__//g; s/__PILLAR__CLUSTER__DNS__/$kubedns/g" nodelocaldns.yaml.template > nodelocaldns.yaml

Hinweis: Ersetze cluster.local durch deine Cluster-Domain aus Schritt 3, wenn dein Cluster eine andere Domain verwendet. Ersetze 169.254.20.10 durch die Link-Local-IP-Adresse deines Clusters, falls diese sich unterscheidet. Im IPVS-Modus musst du Pods so konfigurieren, dass sie NodeLocalDNS verwenden. Siehe den Abschnitt „Pods für die Verwendung von NodeLocalDNS konfigurieren (nur IPVS-Modus)“.

Um das NodeLocalDNS-Manifest anzuwenden, führe den folgenden Befehl aus:

kubectl apply -f nodelocaldns.yaml

Um zu überprüfen, dass NodeLocalDNS-Pods den Status Läuft haben, führe den folgenden Befehl aus:

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

Pods für die Verwendung von NodeLocalDNS konfigurieren (nur IPVS-Modus)

Wichtig: Dieser Abschnitt gilt nur, wenn dein Cluster den IPVS-Modus für kube-proxy verwendet. Wenn dein Cluster den iptables-Modus verwendet, wird der DNS-Traffic automatisch zu NodeLocalDNS umgeleitet.

Für Cluster im IPVS-Modus musst du Pods manuell so konfigurieren, dass sie NodeLocalDNS verwenden. Um deine Pods auf NodeLocalDNS umzuleiten, kannst du einzelne Pods konfigurieren oder Cluster mit kubelet konfigurieren.

Einzelne Pods konfigurieren

Um einzelne Pods zu konfigurieren, füge die folgende Konfiguration zu deiner Pod-Spezifikation hinzu:

spec:
  dnsPolicy: "None"
  dnsConfig:
    nameservers:
      - [169.254.20.10]
    searches:
      - default.svc.cluster.local
      - svc.cluster.local
      - cluster.local
    options:
      - name: ndots
        value: "5"

Hinweis: Ersetze 169.254.20.10 durch die Link-Locale-IP-Adresse deines Clusters. Ersetze cluster.local durch deine Cluster-Domain, wenn dein Cluster eine andere Domain verwendet.

Cluster mit kubelet konfigurieren

Im IPVS-Modus lauscht NodeLocalDNS nur auf der Link-Local-Adresse 169.254.20.10. Du musst die kubelet-Konfiguration so ändern, dass sie auf diese Link-Local-Adresse verweist.

Um alle Pods in deinem Cluster so zu konfigurieren, dass sie NodeLocalDNS verwenden, und die kubelet-Konfiguration auf jedem Knoten zu ändern, führe die folgenden Schritte aus:

Bearbeite die kubelet-Konfigurationsdatei. Füge die folgende Konfiguration hinzu:
```
{  "clusterDNS": ["169.254.20.10"],
  "clusterDomain": "cluster.local"
}
```
Hinweis: Ersetze 169.254.20.10 durch die Link-Locale-IP-Adresse deines Clusters. Ersetze cluster.local durch deine Cluster-Domain, wenn dein Cluster eine andere Domain verwendet.
Um den kubelet-Dienst auf jedem Knoten neu zu starten, führe den folgenden sudo-Befehl aus:
```
sudo systemctl restart kubelet
```

Um die kubelet-Konfiguration zu überprüfen, führe den folgenden Befehl aus:

cat /etc/kubernetes/kubelet/config.json | grep clusterDNS

Hinweis: Die Ausgabe zeigt 169.254.20.10 als NodeLocalDNS-Link-Local-IP-Adresse.

Hinweis: Für automatisierte Bereitstellungen kannst du die kubelet-Konfiguration im Abschnitt userdata deiner Startvorlage ändern. Weitere Informationen findest du unter Wie verwende ich benutzerdefinierte Benutzerdaten mit AL2023 Amazon EKS-Knoten?

Überprüfen, ob du NodeLocalDNS korrekt installiert hast

Um zu überprüfen, dass NodeLocalDNS korrekt funktioniert, führe die folgenden Schritte aus:

Um einen Test-Pod zu erstellen, führe den folgenden Befehl aus:

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

Wenn NodeLocalDNS-Pods den Status CrashLoopBackOff mit Fehlern haben, die darauf hinweisen, dass Port 53 bereits verwendet wird. Überprüfe dann die Ausgabe, um sicherzustellen, dass die DNS-Abfrage korrekt aufgelöst wurde.

Um zu überprüfen, dass DNS-Abfragen NodeLocalDNS verwenden, führe den folgenden Befehl aus:

kubectl logs -n kube-system -l k8s-app=node-local-dns --tail=50

Die Protokolle zeigen, dass DNS-Abfragen von NodeLocalDNS verarbeitet werden.

Hinweis: Standardmäßig ist die Protokollierung in NodeLocalDNS nicht aktiviert. Um die Protokolle anzuzeigen, aktiviere Protokollierung in der node-local-dns ConfigMap.

# kubectl edit configmaps -n kube-system node-local-dns
apiVersion: v1
kind: ConfigMap
metadata:
  name: node-local-dns
  namespace: kube-system
data:
  Corefile: |
    cluster.local:53 {
       log  # Enable logging
       errors
       cache 30
       ...
    }

Fehlerbehebung für NodeLocalDNS-Probleme

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version der AWS CLI verwendest.

CrashLoopBackOff-Fehler beheben, die durch Portkonflikte verursacht werden

Wenn NodeLocalDNS-Pods den Status CrashLoopBackOff mit Port-53-Fehlern erreichen, liegt das daran, dass Amazon EKS Auto-Mode-Knoten für Port 53 reserviert. Um dieses Problem zu beheben, wähle eine der folgenden Methoden aus:

Methode 1: Füge Node-Affinity-Regeln hinzu, um Auto-Mode-Knoten auszuschließen

Führe die folgenden Schritte aus:

Bearbeite das NodeLocalDNS-daemonset:

kubectl edit daemonset node-local-dns -n kube-system

Füge die folgende Affinity-Konfiguration unter spec.template.spec hinzu:

affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: eks.amazonaws.com/compute-type
          operator: NotIn
          values:
          - auto

Speichere die Änderungen und stelle dann sicher, dass die Pods erfolgreich neu starten.

Methode 2: Ändere die NodeLocalDNS-ConfigMap, um den Zustandsprüfungs-Port zu ändern

Führe die folgenden Schritte aus:

Um die aktuelle NodeLocalDNS-ConfigMap anzuzeigen, führe den folgenden Befehl aus:

kubectl get configmap node-local-dns -n kube-system -o yaml

Um die ConfigMap zu bearbeiten und den Zustandsprüfungs-Port zu ändern, führe den folgenden Befehl aus:

kubectl edit configmap node-local-dns -n kube-system

Suche in der ConfigMap die Konfiguration des Zustands-Plugins und ändere den Port. Die ConfigMap-Struktur sieht wie folgt aus:

apiVersion: v1
kind: ConfigMap
metadata:
  name: node-local-dns
  namespace: kube-system
data:
  Corefile: |
    cluster.local:53 {
       errors
       cache {
          success 9984 30
          denial 9984 5
       }
       reload
       loop
       bind IP_ADDRESS
       forward. __PILLAR__CLUSTER__DNS__ {
          force_tcp
       }
       prometheus :9253
       health 169.254.20.10:8081
    }

Hinweis: Ersetze den Port in der health-Zeile von 8081 durch den gewünschten Port. Ersetze 169.254.20.10 durch die Link-Local-IP-Adresse deines Clusters, falls diese sich unterscheidet.

Speichere die Änderungen.

Um die NodeLocalDNS-Pods neu zu starten, führe den folgenden Befehl aus:

kubectl rollout restart daemonset node-local-dns -n kube-system

Um die Zustandsprüfungs-Konfiguration des daemonsets an den neuen Port anzupassen, führe den folgenden Befehl aus:

kubectl edit daemonset node-local-dns -n kube-system

Suche die Abschnitte livenessProbe und readinessProbe und aktualisiere den Port entsprechend deinem neuen Zustandsprüfungs-Port.

DNS-Abfrage-Timeout-Fehler beheben

Wenn deine Pods DNS-Abfrage-Timeouts haben, stelle sicher, dass deine Sicherheitsgruppen und Netzwerk-Zugriffssteuerungslisten TCP- und UDP-Traffic auf Port 53 zulassen. Dieser Traffic ist für die Pod-zu-Pod-Kommunikation erforderlich.

Führe die folgenden Schritte aus:

Um die Sicherheitsgruppen zu identifizieren, die an deine Knoten angehängt sind, führe den folgenden AWS-CLI-Befehl describe-instances aus:

aws ec2 describe-instances --filters "Name=tag:eks:cluster-name,Values=YOUR-CLUSTER-NAME" --query "Reservations[*].Instances[*].SecurityGroups[*].[GroupId,GroupName]" --output table

Hinweis: Ersetze YOUR-CLUSTER-NAME durch den Namen deines Amazon EKS-Clusters.

Öffne die Amazon-EC2-Konsole.
Wähle im Navigationsbereich Sicherheitsgruppen aus.
Wähle die Sicherheitsgruppe aus, die in Schritt 1 dieses Abschnitts identifiziert wurde.
Wähle die Registerkarte Regeln für eingehenden Datenverkehr aus.
Stelle sicher, dass Regeln vorhanden sind, die TCP- und UDP-Traffic auf Port 53 aus dem Pod-CIDR-Bereich zulassen.
Hinweis: Wenn die Regeln nicht vorhanden sind, wähle Regeln für eingehenden Datenverkehr bearbeiten aus. Füge dann Regeln für TCP und UDP auf Port 53 hinzu, wobei die Quelle auf deinen Pod-CIDR-Bereich festgelegt ist.

„Connection refused“-Fehlermeldungen beheben

Wenn du „Connection refused“-Fehlermeldungen erhältst, wenn Pods versuchen, NodeLocalDNS zu verwenden, stelle sicher, dass mindestens ein CoreDNS-Pod ausgeführt wird.

Um den Status der CoreDNS-Pods zu überprüfen, führe den folgenden Befehl aus:

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

Wenn keine CoreDNS-Pods ausgeführt werden oder sich Pods in einem fehlerhaften Zustand befinden, starte die CoreDNS-Bereitstellung neu. Um die Bereitstellung neu zu starten, führe den folgenden Befehl aus:

kubectl rollout restart deployment coredns -n kube-system

Um zu überprüfen, dass CoreDNS-Pods ausgeführt werden, führe den folgenden Befehl aus:

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

Nachdem CoreDNS-Pods ausgeführt werden, starte das NodeLocalDNS-daemonset neu, indem du den folgenden Befehl ausführst:

kubectl rollout restart daemonset node-local-dns -n kube-system

Relevanter Inhalt

Wie konfiguriere ich den Modus „ipvs kube-proxy“ in Amazon EKS?
AWS OFFICIALAktualisiert vor 2 Jahren
Wie behebe ich Berechtigungsprobleme für den Amazon EKS-Add-On-Manager, wenn ich den EBS-CSI-Treiber installiere?
AWS OFFICIALAktualisiert vor 10 Monaten
Wie behebe ich Probleme mit Container Insights für meine Amazon-EKS-Cluster?
AWS OFFICIALAktualisiert vor einem Jahr
Wie installiere ich benutzerdefinierte Pakete in meiner Amazon MWAA-Umgebung?
AWS OFFICIALAktualisiert vor 3 Jahren

Wie installiere ich NodeLocalDNS in meinem EKS-Cluster und behebe Probleme?

Lösung

NodeLocalDNS installieren

Pods für die Verwendung von NodeLocalDNS konfigurieren (nur IPVS-Modus)

Überprüfen, ob du NodeLocalDNS korrekt installiert hast

Fehlerbehebung für NodeLocalDNS-Probleme

Ähnliche Informationen

Relevanter Inhalt