Introduction
Les applications avec état telles que les bases de données, les files de messages et les systèmes de stockage distribués sont des composants essentiels de nombreux déploiements Kubernetes. Contrairement aux applications sans état, les applications avec état nécessitent des identités réseau stables, un stockage persistant et souvent une communication directe de pair à pair entre les réplicas. Lorsque des problèmes de réseau surviennent, ils peuvent entraîner des incohérences de données, des scénarios de split-brain (cerveau divisé) ou des pannes de service complètes. Le dépannage de ces problèmes exige une approche systématique qui tient compte du modèle de mise en réseau unique des StatefulSets Kubernetes et de leurs Services associés.
Ce guide propose une approche pratique et concrète pour diagnostiquer et résoudre les problèmes de mise en réseau dans les applications avec état répliquées s'exécutant sur Kubernetes. Nous aborderons les concepts essentiels, les modes de défaillance courants, les commandes de diagnostic et les stratégies de récupération. Que vous soyez un développeur déployant votre première charge de travail avec état ou un ingénieur DevOps gérant des clusters de production, ce guide vous fournira les outils et les connaissances nécessaires pour maintenir vos applications avec état connectées et en bonne santé.
Inventaire des versions et de l'environnement
Avant de commencer le dépannage, il est crucial d'avoir une vision claire de votre environnement. Cela inclut les versions de Kubernetes, le runtime de conteneurs, le plugin réseau, la configuration de l'application et la topologie de votre StatefulSet et de vos Services. Des versions incohérentes ou des erreurs de configuration peuvent être elles-mêmes la cause première des problèmes de mise en réseau.
Versions de Kubernetes et du plugin réseau
Tout d'abord, vérifiez la version de votre cluster Kubernetes et la solution de mise en réseau utilisée. Les différents plugins réseau (CNI) peuvent avoir des comportements spécifiques, notamment en ce qui concerne les NetworkPolicies, l'équilibrage de charge des services et l'intégration DNS.
kubectl version --short
Sortie attendue (exemple) :
Client Version: v1.28.2
Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3
Server Version: v1.28.2
Pour vérifier le plugin CNI, vous pouvez inspecter les pods dans l'espace de noms kube-system :
kubectl get pods -n kube-system | grep -E 'calico|flannel|weave|cilium'
Exemple de sortie :
calico-node-4x7vz 1/1 Running 0 5d2h
calico-node-8j2kq 1/1 Running 0 5d2h
calico-node-mp9wd 1/1 Running 0 5d2h
Topologie du StatefulSet et du Service
Identifiez le StatefulSet et son Service de gouvernance associé. Le Service de gouvernance est essentiel pour fournir des identités réseau stables aux Pods. Utilisez les commandes suivantes pour les lister :
kubectl get statefulsets -n <namespace>
kubectl get services -n <namespace>
Exemple de sortie :
NAME READY AGE
my-stateful-app 3/3 2d
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-stateful-app ClusterIP None <none> 5432/TCP 2d
Notez que le Service d'un StatefulSet est souvent headless (ClusterIP: None). C'est intentionnel : cela permet aux Pods d'être adressés individuellement via leurs noms DNS stables.
Prérequis pour le dépannage
- Assurez-vous que kubectl est configuré avec les autorisations appropriées pour exécuter des commandes dans les pods et inspecter les ressources.
- Ayez accès aux journaux d'application (via
kubectl logs) et aux événements du cluster (kubectl get events). - Pour un débogage réseau avancé, des outils comme
tcpdump,netcat,curletdigdoivent être disponibles dans vos conteneurs d'application ou dans un conteneur de débogage séparé.
Chemin de configuration sûr
Lors de la configuration de la mise en réseau pour les applications avec état répliquées, certains choix ont un impact significatif sur la fiabilité et la facilité de dépannage. Dans cette section, nous discutons des choix d'implémentation ciblés qui minimisent les risques et améliorent l'observabilité.
Utiliser un Service headless pour des identités stables
Un Service headless (avec clusterIP: None) est le moyen standard de gouverner un StatefulSet. Il n'équilibre pas la charge du trafic mais renvoie plutôt les IP individuelles des Pods lorsqu'il est interrogé via DNS. Cela permet une communication directe de pod à pod, souvent requise par les applications avec état pour les protocoles de réplication et de consensus.
Exemple de définition de Service :
apiVersion: v1
kind: Service
metadata:
name: my-stateful-app
namespace: production
spec:
clusterIP: None
selector:
app: my-stateful-app
ports:
- name: replication
port: 5432
targetPort: 5432
- name: metrics
port: 9104
targetPort: 9104
Avec ce Service, chaque Pod obtient une entrée DNS de la forme <pod-name>.<service-name>.<namespace>.svc.cluster.local. Par exemple, my-stateful-app-0.my-stateful-app.production.svc.cluster.local.
Pour vous assurer que le service headless fonctionne correctement, vous pouvez vérifier sa configuration :
kubectl get service my-stateful-app -n production -o jsonpath='{.spec.clusterIP}'
Sortie attendue :
None
Confirmez également que le service a un sélecteur qui correspond aux pods du StatefulSet :
kubectl get service my-stateful-app -n production -o jsonpath='{.spec.selector}'
Sortie attendue (exemple) :
{"app":"my-stateful-app"}
Exposer des pods individuels pour un accès externe (si nécessaire)
Si des clients externes doivent atteindre des pods spécifiques (par exemple, pour des connexions directes à la base de données), envisagez de créer un Service par pod ou d'utiliser un Service headless avec un équilibreur de charge externe devant. Cependant, soyez prudent : exposer des pods individuels peut contourner la gestion ordonnée du StatefulSet et peut conduire à un split-brain si ce n'est pas soigneusement coordonné.
Une approche consiste à créer un Service distinct pour chaque pod en utilisant une étiquette unique. Par exemple, vous pouvez ajouter une étiquette statefulset.kubernetes.io/pod-name: my-stateful-app-0 à chaque pod et créer un Service avec ce sélecteur. Cela vous permet d'exposer chaque pod individuellement tout en maintenant des noms DNS stables.
Implémenter les NetworkPolicies avec soin
Les NetworkPolicies fournissent une segmentation mais peuvent bloquer par inadvertance le trafic requis entre les réplicas. Lors de la définition des politiques, soyez explicite sur les entrées et sorties autorisées pour les ports de l'application. Testez les modifications dans un environnement de préproduction d'abord.
Exemple de NetworkPolicy autorisant le trafic intra-StatefulSet :
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-stateful-app-replication
namespace: production
spec:
podSelector:
matchLabels:
app: my-stateful-app
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
app: my-stateful-app
ports:
- protocol: TCP
port: 5432
egress:
- to:
- podSelector:
matchLabels:
app: my-stateful-app
ports:
- protocol: TCP
port: 5432
Cette politique garantit que tous les pods avec l'étiquette app: my-stateful-app peuvent communiquer entre eux sur le port TCP 5432, mais uniquement dans la direction spécifiée. Notez que la politique ci-dessus autorise l'entrée depuis des pods avec la même étiquette et la sortie vers des pods avec la même étiquette, mais uniquement sur le port 5432. Si votre application utilise des ports supplémentaires (par exemple, pour les métriques ou l'administration), vous devez ajouter des règles pour ceux-ci également.
Après avoir appliqué une NetworkPolicy, vérifiez toujours qu'elle est correctement sélectionnée et vérifiez les règles réelles en utilisant :
kubectl describe networkpolicy allow-stateful-app-replication -n production
Cela vous montrera les sélecteurs et les règles de la politique. Assurez-vous que le podSelector correspond à vos pods StatefulSet et que les ports autorisés sont corrects.
Activer une journalisation et une surveillance appropriées
Assurez-vous que les journaux de votre application avec état incluent des informations relatives au réseau (par exemple, tentatives de connexion, erreurs). Intégrez à la surveillance du cluster pour suivre les métriques réseau telles que la latence de connexion, la perte de paquets et les paquets abandonnés. Cela facilite un diagnostic plus rapide lorsque des problèmes surviennent.
Par exemple, vous pouvez configurer votre application pour enregistrer au niveau DEBUG pour les composants réseau. De plus, utilisez une pile de surveillance comme Prometheus et Grafana pour collecter les métriques de votre application et du plugin CNI. Les métriques clés à surveiller incluent :
node_network_receive_drop_totaletnode_network_transmit_drop_totalpour les pertes de paquets.container_network_receive_bytes_totaletcontainer_network_transmit_bytes_totalpour le trafic des pods.- Métriques spécifiques à l'application comme le nombre de connexions ou le retard de réplication.
Vérification et diagnostics
Une fois votre StatefulSet et vos Services déployés, vous devez vérifier que la mise en réseau fonctionne correctement. Cette section fournit une série de vérifications et d'étapes de diagnostic, chacune avec des résultats attendus.
Vérifier la disponibilité des pods et les endpoints du Service
Commencez par vous assurer que tous les pods sont en cours d'exécution et prêts :
kubectl get pods -n <namespace> -l app=my-stateful-app
Sortie attendue :
NAME READY STATUS RESTARTS AGE
my-stateful-app-0 1/1 Running 0 5m
my-stateful-app-1 1/1 Running 0 4m
my-stateful-app-2 1/1 Running 0 3m
Vérifiez que le Service a des endpoints correspondant à l'IP de chaque pod :
kubectl get endpoints my-stateful-app -n <namespace>
Sortie attendue :
NAME ENDPOINTS AGE
my-stateful-app 10.244.1.5:5432,10.244.2.3:5432,10.244.3.7:5432 5m
Si la liste des endpoints est vide ou manque certains pods, examinez le sélecteur du Service et les étiquettes des pods. Confirmez que les étiquettes sur les pods correspondent au sélecteur du service :
kubectl get pods -n <namespace> --show-labels
Recherchez l'étiquette app: my-stateful-app sur chaque pod. Si les étiquettes sont manquantes, le service ne les sélectionnera pas et les endpoints seront vides.
Tester la résolution DNS
Le DNS est un composant critique pour la communication de pod à pod. Utilisez nslookup ou dig depuis l'intérieur d'un pod pour vérifier que le nom d'hôte de chaque pod se résout en la bonne adresse IP. Exécutez des commandes dans l'un des pods :
kubectl exec -it my-stateful-app-0 -n <namespace> -- nslookup my-stateful-app-1.my-stateful-app.<namespace>.svc.cluster.local
Sortie attendue (exemple) :
Server: 10.96.0.10
Address: 10.96.0.10#53
Name: my-stateful-app-1.my-stateful-app.<namespace>.svc.cluster.local
Address: 10.244.2.3
L'adresse IP doit correspondre à l'IP du pod obtenue avec kubectl get pods -o wide.
Pour un débogage DNS plus détaillé, vous pouvez utiliser dig :
kubectl exec -it my-stateful-app-0 -n <namespace> -- dig +short my-stateful-app-1.my-stateful-app.<namespace>.svc.cluster.local
Cela devrait renvoyer uniquement l'adresse IP.
Testez également le nom du service sans le préfixe du pod pour voir toutes les IP :
kubectl exec -it my-stateful-app-0 -n <namespace> -- nslookup my-stateful-app.<namespace>.svc.cluster.local
Pour un service headless, cela devrait renvoyer plusieurs enregistrements A pour chaque pod.
Vérifier la connectivité entre les pods
Utilisez telnet, nc ou curl pour tester la connectivité TCP sur le port de l'application. Par exemple, depuis pod-0, connectez-vous à pod-1 sur le port 5432 :
kubectl exec -it my-stateful-app-0 -n <namespace> -- nc -zv my-stateful-app-1.my-stateful-app.<namespace>.svc.cluster.local 5432
Sortie attendue :
Connection to my-stateful-app-1.my-stateful-app.<namespace>.svc.cluster.local 5432 port [tcp/*] succeeded!
Si la connexion échoue, passez à la section des modes de défaillance.
Pour un test plus approfondi, vous pouvez utiliser curl si l'application parle HTTP, ou utiliser un script personnalisé pour envoyer des sondes spécifiques à l'application.
Inspecter les NetworkPolicies
Si des NetworkPolicies sont en place, vérifiez qu'elles autorisent le trafic requis. Listez toutes les politiques dans l'espace de noms :
kubectl get networkpolicies -n <namespace>
Décrivez une politique spécifique pour examiner ses règles :
kubectl describe networkpolicy allow-stateful-app-replication -n <namespace>
Recherchez tout PodSelector ou NamespaceSelector qui pourrait exclure les pods. Assurez-vous que les policyTypes de la politique incluent à la fois Ingress et Egress si une communication bidirectionnelle est nécessaire.
Vérifiez également si une politique réseau est appliquée aux pods en examinant les étiquettes des pods et le podSelector de la politique. Vous pouvez utiliser :
kubectl get pods -n <namespace> --show-labels
et comparer avec le sélecteur de la politique.
Valider le type de Service et ClusterIP
Assurez-vous que le Service est headless si vous comptez sur le DNS individuel des pods. Vérifiez les détails du Service :
kubectl get service my-stateful-app -n <namespace> -o yaml
Dans la sortie, vérifiez clusterIP: None. S'il n'est pas headless, la requête DNS pour <pod-name>.<service-name> ne se résoudra pas vers le pod ; au lieu de cela, elle peut se résoudre vers l'IP du cluster du service et équilibrer la charge, ce qui peut perturber la communication avec état.
Vous pouvez également vérifier via la commande :
kubectl get service my-stateful-app -n <namespace> -o jsonpath='{.spec.clusterIP}'
Si la sortie est une adresse IP (par exemple, 10.96.0.100), alors le service n'est pas headless.
Modes de défaillance et récupération
Même avec une configuration soignée, des problèmes de mise en réseau peuvent survenir. Comprendre les modes de défaillance courants vous aide à récupérer rapidement. Cette section décrit les problèmes typiques, leurs symptômes, les étapes de diagnostic et les actions de récupération.
Échecs de résolution DNS
Symptôme : Les pods ne peuvent pas résoudre les noms d'hôte les uns des autres ; les journaux d'application montrent « unknown host » ou des délais de connexion.
Causes possibles :
- Les pods CoreDNS ne fonctionnent pas.
- Le service DNS (kube-dns) est mal configuré.
- Le fichier
/etc/resolv.confdu pod a un serveur de noms incorrect. - Une politique réseau bloque le trafic DNS (port UDP/TCP 53).
Diagnostics :
- Vérifiez les pods CoreDNS :
kubectl get pods -n kube-system -l k8s-app=kube-dns
Attendu : tous les pods en cours d'exécution et prêts.
- Testez le DNS depuis un pod :
kubectl exec -it <pod> -n <namespace> -- nslookup kubernetes.default
Si cela échoue, le problème est un DNS à l'échelle du cluster.
- Inspectez
/etc/resolv.confà l'intérieur du pod :
kubectl exec -it <pod> -n <namespace> -- cat /etc/resolv.conf
Il doit contenir nameserver 10.96.0.10 (ou l'IP DNS de votre cluster) et search <namespace>.svc.cluster.local svc.cluster.local cluster.local.
Récupération :
- Si CoreDNS est en panne, redémarrez ou mettez à l'échelle le déploiement :
kubectl rollout restart deployment coredns -n kube-system
- Assurez-vous que les NetworkPolicies autorisent la sortie vers le service DNS sur le port 53. Exemple de règle de sortie :
egress:
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
ports:
- protocol: UDP
port: 53
- protocol: TCP
port: 53
- Si la configuration DNS du pod est incorrecte, vérifiez les champs
dnsPolicyetdnsConfigdu pod. Dans la plupart des cas,dnsPolicy: ClusterFirstest correct.
La NetworkPolicy refuse le trafic
Symptôme : Certains pods peuvent se connecter tandis que d'autres non, ou les connexions échouent depuis des espaces de noms spécifiques.
Causes possibles :
- Une NetworkPolicy avec un podSelector ou namespaceSelector restrictif.
- Règle de sortie manquante pour permettre les réponses.
Diagnostics :
- Décrivez les NetworkPolicies dans l'espace de noms et inspectez les règles.
kubectl describe networkpolicy -n <namespace>
- Supprimez temporairement une politique suspecte pour voir si la connectivité revient (dans un environnement de test).
kubectl delete networkpolicy <policy-name> -n <namespace>
Après suppression, testez la connectivité ; si cela fonctionne, la politique était le problème.
Récupération :
- Ajustez la politique pour permettre le trafic requis. Assurez-vous que des règles bidirectionnelles sont spécifiées si nécessaire. Par exemple, pour autoriser tout le trafic entre les pods avec l'étiquette
app: my-stateful-app:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-all-stateful-app
namespace: production
spec:
podSelector:
matchLabels:
app: my-stateful-app
ingress:
- from:
- podSelector:
matchLabels:
app: my-stateful-app
egress:
- to:
- podSelector:
matchLabels:
app: my-stateful-app
Note : Ceci est permissif ; ajustez les ports selon les besoins.
- Testez la politique dans un environnement de préproduction avant de l'appliquer en production.
Mauvaise configuration du Service headless
Symptôme : Les noms DNS individuels des pods ne se résolvent pas, ou ils se résolvent vers une seule IP de cluster (si le Service n'est pas headless).
Diagnostics :
- Vérifiez le YAML du Service pour
clusterIP: None.
kubectl get service my-stateful-app -n <namespace> -o jsonpath='{.spec.clusterIP}'
Si la sortie est une IP, ce n'est pas headless.
- Utilisez
nslookuppour le nom d'hôte d'un pod ; s'il renvoie une IP de service, le Service n'est pas headless.
Récupération :
- Recréez le Service avec
clusterIP: None. Note : changer un type de Service peut causer une brève interruption ; planifiez en conséquence.
kubectl delete service my-stateful-app -n <namespace>
kubectl apply -f headless-service.yaml
Changements d'IP de pod ou problèmes de mise à l'échelle du StatefulSet
Symptôme : Après un redémarrage d'un pod, les autres pods ne peuvent pas se reconnecter car ils ont mis en cache l'ancienne IP du pod.
Causes possibles :
- Les pods StatefulSet ont des noms d'hôte stables mais leurs IP peuvent changer au redémarrage si le pod est supprimé et recréé sur un nœud différent.
- Les applications peuvent mettre en cache les adresses IP au lieu de résoudre à nouveau le DNS.
Diagnostics :
- Vérifiez les IP des pods avant et après le redémarrage :
kubectl get pods -o wide -n <namespace>
Comparez la colonne IP.
- Recherchez des erreurs de connexion mentionnant des IP obsolètes dans les journaux d'application.
Récupération :
- Assurez-vous que les applications utilisent des noms DNS et actualisent périodiquement les résolutions DNS.
- Si la mise en cache DNS est le problème, ajustez les paramètres du résolveur de l'application ou utilisez un Service headless avec
publishNotReadyAddresses: truepour minimiser les changements d'IP. - Envisagez d'utiliser un StatefulSet avec
podManagementPolicy: Parallelpour réduire les redémarrages séquentiels, mais soyez conscient des implications pour l'application.
Problèmes de pare-feu ou de réseau de nœud
Symptôme : Toute connectivité entre les pods sur différents nœuds échoue, alors que la communication sur le même nœud fonctionne.
Causes possibles :
- Pare-feu au niveau du nœud bloquant les ports du réseau overlay.
- Le plugin CNI ne route pas correctement entre les nœuds.
- Interface réseau ou table de routage défectueuse sur un nœud.
Diagnostics :
- Testez la connectivité entre nœuds :
kubectl exec -it <pod-sur-nœud-1> -n <namespace> -- ping <ip-du-pod-sur-nœud-2>
Si le ping échoue mais que le ping sur le même nœud fonctionne, suspectez le réseau du nœud.
- Vérifiez les règles de pare-feu du nœud (sur le nœud) :
sudo iptables -L -n
- Vérifiez l'état du plugin CNI :
kubectl get pods -n kube-system | grep <cni-name>
Récupération :
- Ajustez les règles de pare-feu pour autoriser les ports requis (par exemple, VXLAN UDP 8472, BGP TCP 179, etc., selon le CNI).
- Redémarrez les pods CNI s'ils sont en état d'erreur :
kubectl delete pod -n kube-system <cni-pod>
- Vérifiez la table de routage du nœud et assurez-vous que l'interface overlay existe.
Vérifications de retour en arrière et de récupération
Lors de la mise en œuvre de modifications pour résoudre les problèmes de mise en réseau, ayez toujours un plan de retour en arrière. Documentez la configuration d'origine et testez les modifications dans un environnement hors production. Après avoir appliqué un correctif, exécutez les étapes de vérification de la section précédente pour confirmer la résolution. Surveillez l'application pendant un certain temps pour garantir la stabilité.
Par exemple, avant d'appliquer une modification de NetworkPolicy, enregistrez le YAML de la politique actuelle :
kubectl get networkpolicy <name> -n <namespace> -o yaml > backup-policy.yaml
Si la modification cause des problèmes, restaurez-la :
kubectl apply -f backup-policy.yaml
Liste de contrôle des opérations
Utilisez la liste de contrôle suivante comme processus répétable pour exploiter et examiner la configuration de mise en réseau de votre application avec état répliquée. Exécuter ces vérifications périodiquement peut aider à détecter les problèmes avant qu'ils n'affectent la disponibilité. Attribuez un responsable unique pour chaque décision majeure ou élément de la liste de contrôle, et révisez à la fréquence spécifiée.
Vérifications quotidiennes
- [ ] Tous les pods StatefulSet sont en cours d'exécution et prêts.
- Responsable : Ingénieur de garde (rotation)
- Comment : Exécutez
kubectl get pods -n <namespace> -l app=my-stateful-appet vérifiez que tous les réplicas sont 1/1 Ready. - [ ] Les endpoints du Service correspondent au nombre de réplicas.
- Responsable : Ingénieur de garde
- Comment :
kubectl get endpoints my-stateful-app -n <namespace>et confirmez que le nombre d'endpoints est égal aux réplicas souhaités. - [ ] Aucune erreur récente liée au réseau dans les journaux d'application.
- Responsable : Développeur d'application (par exemple, Priya Shah, responsable de l'ingénierie)
- Comment : Vérifiez la journalisation centralisée pour des motifs comme « connection refused », « timeout », « unknown host » au cours des dernières 24 heures.
Vérifications hebdomadaires
- [ ] La résolution DNS de tous les noms d'hôte des pods réussit depuis plusieurs pods.
- Responsable : Ingénieur DevOps (par exemple, John Doe, ingénieur plateforme)
- Comment : Exécutez un script qui exécute
nslookupdans chaque pod pour le nom d'hôte de chaque autre pod. - [ ] Connectivité TCP sur tous les ports requis entre un échantillon de pods.
- Responsable : Ingénieur DevOps
- Comment : Utilisez
nc -zvdepuis quelques pods vers d'autres, couvrant tous les ports de service (par exemple, 5432, 9104). - [ ] Les règles NetworkPolicy sont examinées et toujours alignées sur les besoins de l'application.
- Responsable : Ingénieur sécurité (par exemple, Maria Garcia, architecte sécurité)
- Comment : Examinez chaque politique dans l'espace de noms et comparez avec les exigences documentées de l'application. Supprimez ou mettez à jour les règles obsolètes.
Avant tout changement
- [ ] Capturer les YAML actuels du StatefulSet, du Service et de la NetworkPolicy pour le retour en arrière.
- Responsable : Personne effectuant le changement (doit être identifiée individuellement)
- Comment : Utilisez
kubectl get <ressource> -o yaml > backup-<ressource>.yaml. - [ ] Tester les modifications de configuration dans un cluster de préproduction.
- Responsable : Personne effectuant le changement
- Comment : Déployez le même manifeste dans un environnement de préproduction et exécutez les étapes de vérification.
Après tout changement
- [ ] Exécuter les commandes de vérification (endpoints, DNS, connectivité).
- Responsable : Personne effectuant le changement
- Comment : Suivez les étapes de la section « Vérification et diagnostics ».
- [ ] Surveiller les métriques de l'application pour le comportement attendu.
- Responsable : Ingénieur de garde
- Comment : Surveillez les tableaux de bord pendant 30 minutes après le changement ; recherchez des anomalies dans les connexions, la latence ou les erreurs.
- [ ] Documenter le changement et son impact.
- Responsable : Personne effectuant le changement
- Comment : Mettez à jour le journal des modifications ou le ticket avec les détails et les résultats.
Référence rapide de dépannage
| Symptôme | Cause probable | Première commande à exécuter |
|---|---|---|
| Les pods ne peuvent pas se résoudre mutuellement | Problèmes DNS | kubectl exec -it <pod> -- nslookup <nom-d'hôte-autre-pod> |
| Connexion refusée sur le port de l'application | L'application n'écoute pas ou mauvais port | kubectl exec -it <pod> -- nc -zv <cible> <port> |
| Connectivité partielle | Restrictions NetworkPolicy | kubectl describe networkpolicy -n <namespace> |
| Tout le trafic entre nœuds échoue | CNI ou pare-feu de nœud | kubectl get pods -n kube-system -l k8s-app=calico-node (ou l'étiquette de votre CNI) |
| Endpoints du Service vides | Inadéquation du sélecteur d'étiquettes | kubectl get pods --show-labels -n <namespace> |
Pièges courants et comment les éviter
De nombreux problèmes de mise en réseau dans les applications avec état proviennent de quelques erreurs récurrentes. Être conscient de ces pièges peut vous aider à les éviter et à les reconnaître rapidement lorsqu'ils se produisent.
1. Utiliser un Service ClusterIP au lieu d'un headless
Pourquoi cela arrive : Les développeurs peuvent réutiliser un modèle de Service standard ou ne pas comprendre la nécessité de services headless avec les StatefulSets.
Comment l'éviter : Définissez toujours un Service headless (avec clusterIP: None) pour les StatefulSets qui nécessitent une communication directe de pod à pod. Documentez cela comme une norme.
Récupération : Si un Service non headless est en place, recréez-le en headless. Notez que cela peut causer une brève perturbation pendant la mise à jour des enregistrements DNS.
2. NetworkPolicies trop restrictives
Pourquoi cela arrive : Au nom de la sécurité, les équipes peuvent appliquer des politiques larges de refus total ou des sélecteurs trop spécifiques qui bloquent involontairement le trafic de réplication.
Comment l'éviter : Commencez par une politique qui autorise explicitement le trafic requis et testez soigneusement en préproduction. Utilisez les étiquettes avec soin et assurez-vous que les entrées et sorties sont prises en compte.
Récupération : Supprimez temporairement ou modifiez la politique pour restaurer la connectivité, puis affinez et réappliquez avec des règles appropriées.
3. Ignorer la mise en cache DNS dans les applications
Pourquoi cela arrive : De nombreuses applications résolvent les noms d'hôte une fois et mettent en cache l'IP indéfiniment. Lorsque les pods redémarrent et que les IP changent, les connexions échouent.
Comment l'éviter : Configurez les applications pour utiliser des noms DNS et actualiser les résolutions de manière appropriée. Si possible, définissez un TTL bas pour les enregistrements DNS (la valeur par défaut de Kubernetes est de 30 secondes pour les services headless). Envisagez d'utiliser publishNotReadyAddresses: true pour garder les IP stables plus longtemps pendant les mises à jour progressives.
Récupération : Redémarrez les pods d'application pour vider les caches DNS, ou si l'application le permet, déclenchez une re-résolution manuelle.
4. Mauvaise étiquetage des pods ou des services
Pourquoi cela arrive : Des modifications manuelles ou des erreurs de configuration CI/CD peuvent causer des inadéquations d'étiquettes, entraînant des endpoints manquants.
Comment l'éviter : Utilisez des manifestes déclaratifs et le contrôle de version. Implémentez une vérification CI qui valide les sélecteurs par rapport aux étiquettes des pods.
Récupération : Corrigez les étiquettes sur les pods ou le sélecteur du service et réappliquez.
5. Ne pas tenir compte des exigences spécifiques au CNI
Pourquoi cela arrive : Différents plugins CNI ont des ports et des comportements par défaut différents. Par exemple, Calico utilise BGP (TCP 179) par défaut, tandis que Flannel utilise VXLAN (UDP 8472). Les règles de pare-feu peuvent ne pas être mises à jour.
Comment l'éviter : Documentez le CNI spécifique utilisé et ses exigences réseau. Assurez-vous que les pare-feu des nœuds autorisent ces ports.
Récupération : Ouvrez les ports requis sur les nœuds ou ajustez la configuration du CNI.
6. Mise à l'échelle du StatefulSet sans tenir compte de l'ordre
Pourquoi cela arrive : Les StatefulSets utilisent par défaut une gestion ordonnée des pods (OrderedReady), ce qui peut entraîner des retards ou des problèmes lors de la réduction d'échelle si ce n'est pas compris.
Comment l'éviter : Si votre application peut gérer une mise à l'échelle non ordonnée, définissez podManagementPolicy: Parallel pour accélérer les opérations. Sinon, planifiez une mise à l'échelle séquentielle et assurez-vous que les sondes de disponibilité sont correctes.
Récupération : Si une réduction d'échelle cause des problèmes, vérifiez la podManagementPolicy du StatefulSet et ajustez si nécessaire.
Conclusion
La mise en réseau pour les applications avec état répliquées dans Kubernetes exige une planification minutieuse et une vigilance continue. En comprenant le rôle des Services headless, des identités de pod stables et des NetworkPolicies, vous pouvez construire un environnement résilient. Lorsque des problèmes surviennent, les étapes de diagnostic systématiques décrites dans ce guide, de la vérification de la résolution DNS à l'inspection des politiques réseau, vous aideront à identifier et à résoudre efficacement les problèmes.
N'oubliez pas de maintenir à jour l'inventaire de votre environnement, de tester les modifications de configuration de manière sûre et de conserver un plan de retour en arrière. Utilisez la liste de contrôle des opérations pour intégrer des vérifications régulières dans votre routine. Avec ces pratiques, vous pouvez vous assurer que vos applications avec état restent connectées, cohérentes et hautement disponibles.
Pour en savoir plus, explorez la documentation officielle de Kubernetes sur les StatefulSets et les Services, et entraînez-vous au dépannage dans un cluster bac à sable pour gagner en confiance.