Kubernetes ist ein Open-Source-Tool, das eine entscheidende Rolle bei der Container-Orchestrierung spielt. Kubernetes hilft bei der Orchestrierung und Verwaltung von Clustern in großem Maßstab über verschiedene Cloud-Umgebungen oder sogar On-Premise-Server hinweg. Ein Cluster ist eine Gruppe von Hosts, die für die Ausführung von containerisierten Anwendungen und Diensten gedacht sind. Ein Cluster benötigt mindestens zwei Nodes, um zu funktionieren – einen Master-Node und einen Worker-Node. Sie können Ihre Kubernetes-Infrastruktur skalieren, indem Sie weitere Worker-Nodes hinzufügen. Ein Master-Node und seine Worker-Nodes müssen über ein Netzwerk kommunizieren können, damit die Infrastruktur funktioniert. Für eine Übersicht über die wichtigsten Funktionen von Kubernetes folgen Sie bitte unserem Tutorial zu Kubernetes kennenlernen.
In diesem Tutorial zeigen wir Ihnen verschiedene Tools und Techniken, die bei der Überprüfung und Fehlerbehebung des Kubernetes-Networkings helfen.
Voraussetzungen
-
Um diesem Tutorial zu folgen, sollten Sie über ein Kubernetes-Cluster verfügen. Wir haben ein Tutorial, das erklärt, Wie man Kubernetes auf Ubuntu 20.04 installiert und verwendet, das Sie durch die Einrichtung eines einfachen Clusters für die Demonstration führen kann.
-
Sie sollten außerdem kubectl lokal installiert haben. Folgen Sie je nach Ihrer lokalen Umgebung der offiziellen Dokumentation zur Installation von Kubernetes-Tools. Das kubectl sollte so konfiguriert sein, dass es eine Verbindung zu Ihrem Cluster herstellt. Wir werden dies im folgenden Abschnitt näher erläutern.
Wir werden mehrere Befehle sowohl lokal als auch auf dem Kubernetes-Node ausführen. Fangen wir an!
Konfigurieren von lokalem kubectl zur Verbindung mit einem Remote-Kubernetes-Cluster
Beginnen wir mit der Installation von kubectl. Unsere lokale Umgebung läuft mit Ubuntu, folgen Sie diesem Link, wenn Sie eine andere lokale Umgebung verwenden. Um kubectl-Tools auf einer lokalen Ubuntu/Debian-Umgebung mit dem Paketmanager apt zu installieren, führen Sie die folgenden Befehle aus, um das apt-Repository zu aktualisieren und die erforderlichen Pakete zu installieren:
|
1 2 |
sudo apt-get update sudo apt-get install -y apt-transport-https ca-certificates curl |
Führen Sie als Nächstes den folgenden Befehl aus, um den öffentlichen Signierschlüssel von Google Cloud herunterzuladen:
|
1 |
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg |
Fügen Sie dann das Kubernetes- apt-Repository hinzu:
|
1 |
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list |
Aktualisieren Sie danach den apt-Index und installieren Sie kubectl mit dem folgenden Befehl:
|
1 2 |
sudo apt-get update sudo apt-get install -y kubectl |
Überprüfen Sie anschließend, ob kubectl installiert ist, indem Sie die Version mit dem folgenden Befehl überprüfen:
|
1 |
kubectl version |
Hier ist die Ausgabe, wenn Sie kubectl gerade lokal installiert haben:

Im obigen Screenshot versucht kubectl eine Verbindung zum lokalen Kubernetes-Cluster herzustellen. Dies schlägt jedoch fehl, da auf unserem lokalen Rechner noch kein Kubernetes-Cluster läuft.
Um eine Verbindung zum Remote-Kubernetes-Cluster herzustellen, laden Sie zunächst die Kubernetes-Anmeldedaten vom Remote-Cluster herunter. Hier ist ein Befehl zum Kopieren der Anmeldedaten vom Master-Node:
|
1 |
scp -r hackins@178.22.66.253:/home/hackins/.kube . |
Ersetzen Sie die hervorgehobenen Teile durch Ihren ssh Benutzernamen und die öffentliche IP des Master-Nodes. Sobald die Anmeldedaten heruntergeladen wurden, kopieren Sie sie in Ihr Home-Verzeichnis:
|
1 |
cp -r .kube $HOME/ |
Das ist alles. Ihr lokales kubectl sollte nun in der Lage sein, eine Verbindung zu Ihrem Remote-Kubernetes-Cluster herzustellen und Befehle darauf auszuführen. Um zu bestätigen, dass Ihr lokales kubectl mit dem Remote-Cluster verbunden ist, überprüfen Sie dies erneut mit dem Versionsbefehl:
|
1 |
kubectl version --output='json' |
Hier ist die Ausgabe, die eine erfolgreiche Verbindung zeigt:

Optional können Sie den Befehl get nodes wie folgt ausführen:

Abrufen der Cluster-IP eines Pods
Sie können die Cluster-IP eines Pods abrufen, indem Sie den Befehl kubectl get pod auf Ihrem lokalen Rechner ausführen. Um weitere Informationen wie den Host-Node des Pods und die Cluster-IP des Pods anzuzeigen, fügen Sie das Flag -o wide zum Befehl hinzu:
|
1 |
kubectl get pod -o wide |
Hier ist eine Ausgabe von unserem Kubernetes-Cluster. Im vorbereitenden Tutorial hatten wir, wie Sie sehen können, ein Nginx-Webserver-Deployment erstellt:

Die Spalte IP zeigt die interne IP-Adresse der einzelnen Pods. Wenn der gesuchte Pod nicht in der Liste erscheint, befinden Sie sich möglicherweise in einem anderen Namespace. Sie können den folgenden Befehl ausführen, um Pods in allen Namespaces:
|
1 |
kubectl get pod -o wide --all-namespaces |
Abrufen der IP-Adresse eines Service
Sie können auch die IP-Adresse eines Service in Ihrem Cluster abrufen. Durch Hinzufügen des Flags --all-namespaces erhalten Sie alle im Cluster ausgeführten Services:
|
1 |
kubectl get service --all-namespaces |
Die Ausgabe des obigen Befehls lautet wie folgt. Die Service-IP befindet sich in der Spalte cluster-ip -Spalte:

Abrufen von und Zugreifen auf Pod-Netzwerk-Namespaces
Jedem Kubernetes-Pod ist ein Netzwerk-Namespace zugewiesen. Netzwerk-Namespaces, auch als netns bezeichnet, sind native Netzwerkbibliotheken in Linux, die eine Isolierung zwischen Netzwerkgeräten ermöglichen.
Um die DNS-Auflösung oder die allgemeine Netzwerkkonnektivität zu überprüfen, können Sie Befehle innerhalb des Netzwerk-Namespace eines Pods ausführen. Dazu ermitteln Sie zunächst die Prozess-ID eines der Container in einem Pod. Dies können Sie in Docker mithilfe von Docker-spezifischen Befehlen ganz einfach tun. Der erste Befehl listet die auf einem Node ausgeführten Container auf. Melden Sie sich an einem Ihrer Worker-Nodes an und führen Sie den folgenden Befehl aus:
|
1 |
docker ps |

In der Ausgabe interessiert uns die Spalte mit der Container-ID oder den Namen. Beachten Sie den Nginx-Container, den wir im vorbereitenden Tutorial How to Install and Use Kubernetes on Ubuntu 20.04.
Kopieren Sie als Nächstes die Container-ID oder den Namen, da wir diese im nächsten Befehl verwenden werden, um die Prozess-ID zu finden:
|
1 |
docker inspect --format '{{ .State.Pid }}' container-id-oder-name |
Ersetzen Sie den markierten Teil durch Ihren aus dem vorherigen Befehl kopierten Wert. Unten sehen Sie die Ausgabe, die wir erhalten haben, nämlich die Prozess-ID:

Da wir nun eine Prozess-ID haben, können wir sie verwenden, um den Befehl nsenter innerhalb des Netzwerk-Namespace des Prozesses auszuführen:
|
1 |
sudo nsenter -t container-pid -n ip addr |
Ersetzen Sie den markierten Teil durch die Prozess-ID, die Sie im vorherigen Befehl erhalten haben. Anstelle von ip addr, können Sie jeden beliebigen Befehl eingeben, den Sie im Netzwerk-Namespace des Pods ausführen möchten. Sie können ihn auch mit sudo ausführen, falls Sie eine Fehlermeldung bezüglich verweigerten Zugriffs erhalten.
Der Befehl nsenter ermöglicht es Ihnen, eine größere Auswahl an auf einem Node verfügbaren Befehlen auszuführen, im Gegensatz zur Verwendung von docker exec was Sie nur auf die im Container installierten Befehle beschränkt.
Abrufen der virtuellen Ethernet-Schnittstelle eines Pods
Ein Netzwerk-Namespace auf einem Pod kommuniziert mit dem Root-netns des Nodes über eine virtuelle Ethernet-Pipe. Auf der Seite des Nodes erscheint diese Pipe als ein Gerät, dessen Name mit veth beginnt und mit einer eindeutigen Kennung endet, wie z. B. veth742f721 oder veth90. Während sich die Pipe innerhalb des Pods als eth0.
identifiziert. Möglicherweise möchten Sie wissen, welches veth-Gerät mit welchem Pod gekoppelt ist. Sie können damit beginnen, alle Netzwerkgeräte auf dem Node aufzulisten, und dann alle Geräte im Netzwerk des Pods auflisten. Um zu identifizieren, welches veth -Gerät mit einem bestimmten Pod gekoppelt ist, können Sie die Gerätenummern zwischen den beiden Auflistungen korrelieren.
Verwenden Sie den Befehl nsenter , um den Befehl ip addr im Netzwerk-Namespace des Pods auszuführen. Sie müssen eine der Prozess-IDs des Containers kennen. Siehe dazu den vorherigen Abschnitt über Abrufen von und Zugreifen auf Pod-Netzwerk-Namespaces.
Führen Sie als Nächstes den folgenden Befehl im Terminal Ihres Worker-Nodes aus und ersetzen Sie den markierten Teil entsprechend:
|
1 |
sudo nsenter -t container-pid -n ip addr |
Der Befehl gibt eine Liste der Schnittstellen des Pods aus:

Beachten Sie die if7 Zeichen nach dem eth0@ in der obigen Ausgabe. Dies bedeutet, dass das eth0 des Pods mit der 7. Schnittstelle des Nodes gekoppelt ist. Listen Sie als Nächstes die Schnittstellen im Standard-Namespace des Nodes auf, indem Sie den ip addr Befehl ausführen:
|
1 |
ip addr |
Der Befehl listet die Schnittstellen wie unten gezeigt auf:

In der Ausgabe ist die 7. Schnittstelle veth254b50e6@if3 – die virtuelle Ethernet-Pipe, die mit dem Pod gekoppelt ist, gegen den wir testen.
Überprüfung der Iptables-Regeln
Sie können den Befehl iptables-save ausführen, um alle Iptables auf einem Node aufzulisten:
|
1 |
iptables-save |
Die Ausgabe des Befehls kann lang sein, daher können Sie sie zur späteren Überprüfung in einer Datei speichern:
|
1 |
iptables-save > iptables.txt |
Sie können auch less verwenden, um die Ausgabe seitenweise anzuzeigen:
|
1 |
iptables-save | less |
Da wir uns nur für die Kubernetes-NAT-Regeln interessieren, fügen Sie das Flag -L hinzu, um das richtige Ziel anzugeben:
|
1 |
sudo iptables -t nat -L KUBE-SERVICES |
Hier ist die Ausgabe:

Überprüfung der IPVS-Details
Kube-proxy ist ein Netzwerk-Proxy, der auf jedem Node in Ihrem Kubernetes-Cluster ausgeführt wird. Er kann verwendet werden, um IPVS so zu konfigurieren, dass die Übersetzung von virtuellen Service-IPs in Pod-IPs übernommen wird. Um die Übersetzungstabelle der IPs aufzulisten, können Sie den Befehl ipvsadm verwenden. Zuerst müssen Sie ihn auf Ihrem Node installieren:
|
1 |
sudo apt install ipvsadm |
Jetzt können Sie den folgenden Befehl ausführen:
|
1 |
sudo ipvsadm -Ln |
Um eine einzelne Service-IP anzuzeigen, fügen Sie das Flag -t hinzu und geben Sie die gewünschte IP-Adresse an:
|
1 |
ipvsadm -Ln -t 10.244.1.255 |
Abfragen des Cluster-DNS
Es gibt verschiedene Möglichkeiten, wie Sie die DNS-Auflösung Ihres Clusters debuggen können. Die offizielle Dokumentation beschreibt eine Möglichkeit: das Bereitstellen eines Debug-Containers mit allen erforderlichen Tools und die anschließende Verwendung von kubectl zur Ausführung von nslookup.
Optional können Sie den DNS mit den Befehlen dig und nsenter direkt vom Node aus abfragen. Zuerst müssen Sie dig auf Ihrem Master-Node installieren. Installieren Sie es unter Ubuntu mit dem apt Befehl:
|
1 |
sudo apt install dnsutils |

Gehen Sie zurück zum Terminal auf Ihrem lokalen Rechner und führen Sie den folgenden Befehl aus, um die Cluster-IP des kube-dns -Services zu finden:
|
1 |
kubectl get service -n kube-system kube-dns |
Der Befehl gibt Folgendes aus:

Die Spalte cluster-ip enthält den Wert, den wir benötigen. Jetzt können wir nsenter verwenden, um dig im Namespace des Containers auszuführen. Sie benötigen jedoch eine Container-Prozess-ID, um auf dessen Namespace zuzugreifen. Eine Anleitung dazu finden Sie im Abschnitt Abrufen von und Zugreifen auf Pod-Netzwerk-Namespaces oben.
Sobald Sie die container-id haben, führen Sie den folgenden Befehl auf Ihrem Master-Node aus:
|
1 |
sudo nsenter -t 27168 -n dig kubernetes.default.svc.cluster.local @10.96.0.10 |
Der Befehl dig übernimmt die IP des Cluster-DNS-Service ( @10.96.0.10) und sucht nach dem vollständigen Domänennamen des Services service-name.namespace.svc.cluster.local:

Informationen zum Finden von Service-Namen und Namespaces finden Sie im Abschnitt Abrufen der IP-Adresse eines Services.
Überprüfung der Conntrack-Verbindungsverfolgung
Sie können den Befehl conntrack verwenden, um alle aktuell verfolgten Verbindungen anzuzeigen:
|
1 |
sudo conntrack -L |
Die Ausgabe ähnelt dem Screenshot:

Fügen Sie das Flag -E hinzu, um eingehende Verbindungen kontinuierlich zu überwachen:
|
1 |
sudo conntrack -E |
Um Verbindungen anzuzeigen, die zu einer bestimmten Zieladresse verfolgt werden, fügen Sie das Flag -d hinzu und geben Sie die Zieladresse an:
|
1 |
sudo conntrack -L -d 80.45.6.4 |
Manchmal füllt sich die Tabelle zur Verbindungsverfolgung, was dazu führt, dass neue Verbindungen verworfen werden. Dies führt zu Problemen, die verhindern, dass Ihre Nodes zuverlässige Verbindungen herstellen. In diesem Fall sehen Sie Meldungen wie die folgende in Ihren Systemprotokollen unter dem Pfad /var/log/syslog:
|
1 |
Mar 07 19:12:11 worker-105 kernel: nf_conntrack: table full, dropping packet. |
Es gibt eine Systemeinstellung für die maximale Anzahl der zu verfolgenden Verbindungen. Verwenden Sie den folgenden Befehl, um Ihren aktuellen Wert anzuzeigen:
|
1 |
sysctl net.netfilter.nf_conntrack_max |
Die Ausgabe lautet:

Sie können den Wert mithilfe des -w -Flags ändern:
|
1 |
sudo sysctl -w net.netfilter.nf_conntrack_max=231074 |
Möglicherweise möchten Sie Ihre /etc/sysctl.conf -Datei anpassen, um den Wert dauerhaft zu machen und sicherzustellen, dass er auch nach Neustarts erhalten bleibt. Öffnen Sie die Datei mit nano:
|
1 |
sudo nano /etc/sysctl.conf |
Ändern Sie als Nächstes den Wert, falls die Zeile existiert, oder fügen Sie die Zeile am Ende der Datei hinzu, indem Sie den neuen Wert angeben:
|
1 |
net.netfilter.nf_conntrack_max=231074 |
Fazit
Bei der Bereitstellung mehrerer containerisierter Dienste werden Sie stark von Kubernetes profitieren, da es Ihnen eine zentrale Verwaltung ermöglicht. Um sicherzustellen, dass die Konnektivität zwischen den verschiedenen Kubernetes-Pods gegeben ist, haben wir Ihnen einige Befehle zur Netzwerküberprüfung gezeigt, mit denen Sie Fehler in Ihrer Kubernetes-Infrastruktur beheben können.
Um mehr über Kubernetes, seine Vorteile sowie das Einrichten und Bereitstellen von Anwendungen auf Kubernetes zu erfahren, werfen Sie einen Blick auf unsere verschiedenen Kubernetes-Tutorials.
Viel Spaß beim Computing!
Kommentare
Noch keine Kommentare. Schreiben Sie den ersten.