Problembehandlung Verbindungsprobleme mit Pods oder Diensten in einem AKS-Cluster (interner Datenverkehr)

Artikel
10/15/2024

In diesem Artikel wird erläutert, wie Sie Verbindungsprobleme mit Pods oder Diensten als internen Datenverkehr innerhalb desselben Microsoft Azure Kubernetes Services (AKS)-Clusters behandeln.

Voraussetzungen

Das Kubernetes-Kubectl-Tool oder ein ähnliches Tool zum Herstellen einer Verbindung mit dem Cluster. Führen Sie zum Installieren von Kubectl mithilfe der Azure CLI den Befehl "az aks install-cli " aus.
Das Apt-get-Befehlszeilentool zum Behandeln von Paketen.
Das Client-URL-Tool (cURL) oder ein ähnliches Befehlszeilentool.
Das Befehlszeilentool Netcat (nc) für TCP-Verbindungen.

Checkliste zur Problembehandlung

Schritt 1: Einrichten des Test-Pods und des Remoteserverports

Richten Sie den Test pod ein, und stellen Sie sicher, dass der erforderliche Port auf dem Remoteserver geöffnet ist. Führen Sie in der Quell-Pod (oder einem Test-Pod, der sich im selben Namespace wie der Quell-Pod befindet) die folgenden Schritte aus:

Starten Sie einen Test pod im Cluster, indem Sie den Befehl "kubectl run" ausführen :
```
kubectl run -it --rm aks-ssh --namespace <namespace> --image=debian:stable
```
Nachdem Sie Zugriff auf den Pod erhalten haben, führen Sie die folgenden apt-get Befehle aus, um die DNS Utils-, cURL- und Netcat-Pakete zu installieren:
```
apt-get update -y
apt-get install dnsutils -y
apt-get install curl -y
apt-get install netcat-openbsd -y
```
Führen Sie nach der Installation der Pakete den folgenden cURL-Befehl aus, um die Verbindung mit der IP-Adresse des Pods zu testen:
```
curl -Iv http://<pod-ip-address>:<port>
```
Führen Sie den Netcat-Befehl aus, um zu überprüfen, ob der Remoteserver den erforderlichen Port geöffnet hat:
```
nc -z -v <endpoint> <port>
```

Schritt 2: Anzeigen von betriebstechnischen Informationen zu Pods, Containern, kubernetes-Diensten und Endpunkten

Führen Sie die folgenden Schritte aus, indem Sie kubectl und cURL an der Befehlszeile verwenden, um zu überprüfen, ob alles wie erwartet funktioniert:

Stellen Sie sicher, dass der Ziel-Pod aktiv ist und ausgeführt wird:
```
kubectl get pods -n <namespace-name>
```
Wenn der Ziel-Pod ordnungsgemäß funktioniert, wird der Pod-Status als Runningangezeigt, und der Pod wird als READYangezeigt.
```
NAME           READY   STATUS    RESTARTS   AGE
my-other-pod   1/1     Running   0          44m
my-pod         1/1     Running   0          44m
```
Durchsuchen Sie die Pod-Protokolle nach Zugriffsfehlern:
```
kubectl logs <pod-name> -n <namespace-name>
```
Durchsuchen Sie die Podprotokolle nach einem einzelnen Container in einem Multicontainer-Pod:
```
kubectl logs <pod-name> -n <namespace-name> -c <container-name>
```
Wenn die Anwendung, die sich innerhalb des Pods befindet, wiederholt neu gestartet wird, zeigen Sie pod-Protokolle einer vorherigen Containerinstanz an, um die Ausgangsmeldungen abzurufen:
```
kubectl logs <pod-name> --previous                      
```
Verwenden Sie für den Multicontainer-Fall den folgenden Befehl:
```
kubectl logs <pod-name> -c <container-name> --previous  
```
Überprüfen Sie, ob Netzwerkrichtlinien vorhanden sind, die den Datenverkehr blockieren können:
```
kubectl get networkpolicies -A
```
Sie sollten eine Ausgabe erhalten, die der folgenden Tabelle ähnelt.
```
NAMESPACE     NAME                 POD-SELECTOR             AGE
kube-system   konnectivity-agent   app=konnectivity-agent   4d1h
```
Wenn eine andere benutzerdefinierte Netzwerkrichtlinie vorhanden ist, überprüfen Sie, ob diese Richtlinie den Zugriff auf oder von den Pods blockiert.
Überprüfen Sie, ob Sie die Anwendung über die IP-Adresse des Diensts erreichen können. Zeigen Sie zunächst Details zur Dienstressource an, z. B. die externe IP-Adresse und den Port, indem Sie den kubectl get services Befehl ausführen:
```
kubectl get services -n <namespace-name>
```
```
NAME         TYPE           CLUSTER-IP   EXTERNAL-IP      PORT(S)        AGE
my-service   LoadBalancer   10.0.21.43   20.119.121.232   80:31773/TCP   28s
```
Führen Sie dann cURL mithilfe der Dienst-IP-Adresse und des Ports aus, um zu überprüfen, ob Sie die Anwendung erreichen können:
```
curl -Iv http://20.119.121.232:80
.
.
.
< HTTP/1.1 200 OK
HTTP/1.1 200 OK
```

Erhalten Sie ausführlichere Informationen zum Dienst:

kubectl describe services <service-name> -n <namespace-name>

Überprüfen Sie die IP-Adresse des Pods:

kubectl get pods -o wide

NAME            READY   STATUS        RESTARTS   AGE   IP            NODE                                
my-pod          1/1     Running       0          12m   10.244.0.15   aks-agentpool-000000-vmss000000

Stellen Sie sicher, dass die IP-Adresse des Pods als Endpunkt im Dienst vorhanden ist:

kubectl describe services my-cluster-ip-service

Name:              my-cluster-ip-service
Namespace:         default
Selector:          app=my-pod
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.0.174.133
IPs:               10.0.174.133
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         10.244.0.15:80     # <--- Here

Überprüfen Sie die Endpunkte direkt:

kubectl get endpoints

NAME                      ENDPOINTS           AGE
my-cluster-ip-service     10.244.0.15:80      14m

Wenn die Verbindung mit einem Dienst nicht funktioniert, starten Sie die Pods und CoreDNS kube-proxy neu:

kubectl delete pods -n kube-system -l component=kube-proxy
kubectl delete pods -n kube-system -l k8s-app=kube-dns

Stellen Sie sicher, dass der Knoten nicht überlastet ist:
```
kubectl top nodes
```
Notiz

Sie können azure Monitor auch verwenden , um die Nutzungsdaten für den Cluster abzurufen.

Kontaktieren Sie uns für Hilfe

Wenn Sie Fragen haben oder Hilfe mit Ihren Azure-Gutschriften benötigen, dann erstellen Sie beim Azure-Support eine Support-Anforderung oder fragen Sie den Azure Community-Support. Sie können auch Produktfeedback an die Azure Feedback Community senden.

Freigeben über