Risoluzione dei problemi di connessione a pod o servizi all'interno di un cluster del servizio Azure Kubernetes (traffico interno)

2024-10-15

Questo articolo illustra come risolvere i problemi di connessione ai pod o ai servizi come traffico interno all'interno dello stesso cluster del servizio Azure Kubernetes (Microsoft servizio Azure Kubernetes s).

Prerequisiti

Lo strumento Kubernetes kubectl o uno strumento simile per connettersi al cluster. Per installare kubectl usando l'interfaccia della riga di comando di Azure, eseguire il comando az aks install-cli .
Lo strumento da riga di comando apt-get per la gestione dei pacchetti.
Lo strumento URL client (cURL) o uno strumento da riga di comando simile.
Strumento da riga di comando Netcat (nc) per le connessioni TCP.

Elenco di controllo per la risoluzione dei problemi

Passaggio 1: Configurare il pod di test e la porta del server remoto

Configurare il pod di test e assicurarsi che la porta richiesta sia aperta nel server remoto. Dall'interno del pod di origine (o da un pod di test che si trova nello stesso spazio dei nomi del pod di origine), seguire questa procedura:

Avviare un pod di test nel cluster eseguendo il comando kubectl run :

kubectl run -it --rm aks-ssh --namespace <namespace> --image=debian:stable

Dopo aver ottenuto l'accesso al pod, eseguire i comandi seguenti apt-get per installare i pacchetti DNS Utils, cURL e Netcat:
```
apt-get update -y
apt-get install dnsutils -y
apt-get install curl -y
apt-get install netcat-openbsd -y
```
Dopo aver installato i pacchetti, eseguire il comando cURL seguente per testare la connettività all'indirizzo IP del pod:
```
curl -Iv http://<pod-ip-address>:<port>
```
Eseguire il comando Netcat per verificare se il server remoto ha aperto la porta richiesta:
```
nc -z -v <endpoint> <port>
```

Passaggio 2: Visualizzare informazioni operative su pod, contenitori, servizi Kubernetes ed endpoint

Usando kubectl e cURL nella riga di comando, seguire questa procedura per verificare che tutto funzioni come previsto:

Verificare che il pod di destinazione sia operativo:
```
kubectl get pods -n <namespace-name>
```
Se il pod di destinazione funziona correttamente, lo stato del pod viene visualizzato come Runninge il pod viene visualizzato come READY.
```
NAME           READY   STATUS    RESTARTS   AGE
my-other-pod   1/1     Running   0          44m
my-pod         1/1     Running   0          44m
```
Cercare i log dei pod per individuare gli errori di accesso:
```
kubectl logs <pod-name> -n <namespace-name>
```
Cercare un singolo contenitore nei log dei pod in un pod multicontainer:
```
kubectl logs <pod-name> -n <namespace-name> -c <container-name>
```
Se l'applicazione all'interno del pod viene riavviata ripetutamente, visualizzare i log dei pod di un'istanza del contenitore precedente per ottenere i messaggi di uscita:
```
kubectl logs <pod-name> --previous                      
```
Per il caso multicontainer, usare il comando seguente:
```
kubectl logs <pod-name> -c <container-name> --previous  
```
Controllare se sono presenti criteri di rete che potrebbero bloccare il traffico:
```
kubectl get networkpolicies -A
```
Viene visualizzato un output simile alla tabella seguente.
```
NAMESPACE     NAME                 POD-SELECTOR             AGE
kube-system   konnectivity-agent   app=konnectivity-agent   4d1h
```
Se vengono visualizzati altri criteri di rete creati in modo personalizzato, verificare se tali criteri stiano bloccando l'accesso ai pod o dai pod.
Controllare se è possibile raggiungere l'applicazione dall'indirizzo IP del servizio. Per prima cosa, visualizzare i dettagli sulla risorsa del servizio, ad esempio l'indirizzo IP esterno e la porta, eseguendo il kubectl get services comando :
```
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
```
Eseguire quindi cURL usando l'indirizzo IP e la porta del servizio per verificare se è possibile raggiungere l'applicazione:
```
curl -Iv http://20.119.121.232:80
.
.
.
< HTTP/1.1 200 OK
HTTP/1.1 200 OK
```

Ottenere altre informazioni dettagliate sul servizio:

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

Controllare l'indirizzo IP del pod:

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

Verificare che l'indirizzo IP del pod esista come endpoint nel servizio:

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

Verificare direttamente gli endpoint:

kubectl get endpoints

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

Se la connessione a un servizio non funziona, riavviare i kube-proxy pod e CoreDNS:

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

Verificare che il nodo non sia sovrautilato:
```
kubectl top nodes
```
Note

È anche possibile usare Monitoraggio di Azure per ottenere i dati di utilizzo per il cluster.

Contattaci per ricevere assistenza

In caso di domande o bisogno di assistenza, creare una richiesta di supporto tecnico oppure formula una domanda nel Supporto della community di Azure. È possibile anche inviare un feedback sul prodotto al feedback della community di Azure.