Résolution des problèmes de connexion aux pods ou services au sein d’un cluster AKS (trafic interne)

Article
10/15/2024

Cet article explique comment résoudre les problèmes de connexion aux pods ou services en tant que trafic interne à partir du même cluster Microsoft Azure Kubernetes Services (AKS).

Prerequisites

L’outil Kubernetes kubectl ou un outil similaire pour se connecter au cluster. Pour installer kubectl à l’aide d’Azure CLI, exécutez la commande az aks install-cli .
Outil en ligne de commande apt-get pour la gestion des packages.
Outil d’URL client (cURL) ou d’un outil en ligne de commande similaire.
Outil en ligne de commande Netcat (nc) pour les connexions TCP.

Liste de contrôle pour la résolution des problèmes

Étape 1 : Configurer le pod de test et le port du serveur distant

Configurez le pod de test et vérifiez que le port requis est ouvert sur le serveur distant. À partir du pod source (ou d’un pod de test qui se trouve dans le même espace de noms que le pod source), procédez comme suit :

Démarrez un pod de test dans le cluster en exécutant la commande kubectl run :
```
kubectl run -it --rm aks-ssh --namespace <namespace> --image=debian:stable
```
Une fois que vous avez accès au pod, exécutez les commandes suivantes apt-get pour installer les packages DNS Utils, cURL et Netcat :
```
apt-get update -y
apt-get install dnsutils -y
apt-get install curl -y
apt-get install netcat-openbsd -y
```
Une fois les packages installés, exécutez la commande cURL suivante pour tester la connectivité à l’adresse IP du pod :
```
curl -Iv http://<pod-ip-address>:<port>
```
Exécutez la commande Netcat pour vérifier si le serveur distant a ouvert le port requis :
```
nc -z -v <endpoint> <port>
```

Étape 2 : afficher des informations opérationnelles sur les pods, les conteneurs, les services Kubernetes et les points de terminaison

À l’aide de kubectl et cURL sur la ligne de commande, procédez comme prévu pour vérifier que tout fonctionne comme prévu :

Vérifiez que le pod de destination est opérationnel :
```
kubectl get pods -n <namespace-name>
```
Si le pod de destination fonctionne correctement, l’état du pod s’affiche comme Runningsuit et le pod est affiché en tant que READY.
```
NAME           READY   STATUS    RESTARTS   AGE
my-other-pod   1/1     Running   0          44m
my-pod         1/1     Running   0          44m
```
Recherchez les erreurs d’accès dans les journaux des pods :
```
kubectl logs <pod-name> -n <namespace-name>
```
Recherchez les journaux de pod pour un conteneur individuel dans un pod multicontainer :
```
kubectl logs <pod-name> -n <namespace-name> -c <container-name>
```
Si l’application qui se trouve à l’intérieur du pod redémarre à plusieurs reprises, affichez les journaux de pod d’une instance de conteneur précédente pour obtenir les messages de sortie :
```
kubectl logs <pod-name> --previous                      
```
Pour le cas multicontainer, utilisez la commande suivante :
```
kubectl logs <pod-name> -c <container-name> --previous  
```
Vérifiez s’il existe des stratégies réseau susceptibles de bloquer le trafic :
```
kubectl get networkpolicies -A
```
Vous devriez voir une sortie semblable au tableau suivant.
```
NAMESPACE     NAME                 POD-SELECTOR             AGE
kube-system   konnectivity-agent   app=konnectivity-agent   4d1h
```
Si vous voyez une autre stratégie réseau personnalisée, vérifiez si cette stratégie bloque l’accès aux ou à partir des pods.
Vérifiez si vous pouvez atteindre l’application à partir de l’adresse IP du service. Tout d’abord, affichez des détails sur la ressource de service, telles que l’adresse IP externe et le port, en exécutant la kubectl get services commande :
```
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
```
Ensuite, exécutez cURL à l’aide de l’adresse IP du service et du port pour vérifier si vous pouvez atteindre l’application :
```
curl -Iv http://20.119.121.232:80
.
.
.
< HTTP/1.1 200 OK
HTTP/1.1 200 OK
```

Obtenez plus d’informations détaillées sur le service :

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

Vérifiez l’adresse IP du 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

Vérifiez que l’adresse IP du pod existe en tant que point de terminaison dans le service :

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

Vérifiez directement les points de terminaison :

kubectl get endpoints

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

Si la connexion à un service ne fonctionne pas, redémarrez les kube-proxy pods CoreDNS :

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

Vérifiez que le nœud n’est pas trop utilisé :
```
kubectl top nodes
```
Note

Vous pouvez également utiliser Azure Monitor pour obtenir les données d’utilisation du cluster.

Contactez-nous pour obtenir de l’aide

Pour toute demande ou assistance, créez une demande de support ou posez une question au support de la communauté Azure. Vous pouvez également soumettre des commentaires sur les produits à la communauté de commentaires Azure.

Partager via