## 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. ```bash kubectl version --short ``` Sortie attendue (exemple) : ```text 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 : ```bash kubectl get pods -n kube-system | grep -E 'calico|flannel|weave|cilium' ``` Exemple de sortie : ```text 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 : ```bash kubectl get statefulsets -n kubectl get services -n ``` Exemple de sortie : ```text NAME READY AGE my-stateful-app 3/3 2d NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE my-stateful-app ClusterIP 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`, `curl` et `dig` doivent ê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 : ```yaml 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 `...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 : ```bash kubectl get service my-stateful-app -n production -o jsonpath='{.spec.clusterIP}' ``` Sortie attendue : ```text None ``` Confirmez également que le service a un sélecteur qui correspond aux pods du StatefulSet : ```bash kubectl get service my-stateful-app -n production -o jsonpath='{.spec.selector}' ``` Sortie attendue (exemple) : ```text {"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 : ```yaml 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 : ```bash 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_total` et `node_network_transmit_drop_total` pour les pertes de paquets. - `container_network_receive_bytes_total` et `container_network_transmit_bytes_total` pour 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 : ```bash kubectl get pods -n -l app=my-stateful-app ``` Sortie attendue : ```text 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 : ```bash kubectl get endpoints my-stateful-app -n ``` Sortie attendue : ```text 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 : ```bash kubectl get pods -n --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 : ```bash kubectl exec -it my-stateful-app-0 -n -- nslookup my-stateful-app-1.my-stateful-app..svc.cluster.local ``` Sortie attendue (exemple) : ```text Server: 10.96.0.10 Address: 10.96.0.10#53 Name: my-stateful-app-1.my-stateful-app..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` : ```bash kubectl exec -it my-stateful-app-0 -n -- dig +short my-stateful-app-1.my-stateful-app..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 : ```bash kubectl exec -it my-stateful-app-0 -n -- nslookup my-stateful-app..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 : ```bash kubectl exec -it my-stateful-app-0 -n -- nc -zv my-stateful-app-1.my-stateful-app..svc.cluster.local 5432 ``` Sortie attendue : ```text Connection to my-stateful-app-1.my-stateful-app..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 : ```bash kubectl get networkpolicies -n ``` Décrivez une politique spécifique pour examiner ses règles : ```bash kubectl describe networkpolicy allow-stateful-app-replication -n ``` 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 : ```bash kubectl get pods -n --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 : ```bash kubectl get service my-stateful-app -n -o yaml ``` Dans la sortie, vérifiez `clusterIP: None`. S'il n'est pas headless, la requête DNS pour `.` 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 : ```bash kubectl get service my-stateful-app -n -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.conf` du 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 : ```bash 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 : ```bash kubectl exec -it -n -- 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 : ```bash kubectl exec -it -n -- cat /etc/resolv.conf ``` Il doit contenir `nameserver 10.96.0.10` (ou l'IP DNS de votre cluster) et `search .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 : ```bash 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 : ```yaml 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 `dnsPolicy` et `dnsConfig` du pod. Dans la plupart des cas, `dnsPolicy: ClusterFirst` est 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. ```bash kubectl describe networkpolicy -n ``` - Supprimez temporairement une politique suspecte pour voir si la connectivité revient (dans un environnement de test). ```bash kubectl delete networkpolicy -n ``` 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` : ```yaml 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`. ```bash kubectl get service my-stateful-app -n -o jsonpath='{.spec.clusterIP}' ``` Si la sortie est une IP, ce n'est pas headless. - Utilisez `nslookup` pour 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. ```bash kubectl delete service my-stateful-app -n 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 : ```bash kubectl get pods -o wide -n ``` 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: true` pour minimiser les changements d'IP. - Envisagez d'utiliser un StatefulSet avec `podManagementPolicy: Parallel` pour 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 : ```bash kubectl exec -it -n -- ping ``` 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) : ```bash sudo iptables -L -n ``` - Vérifiez l'état du plugin CNI : ```bash kubectl get pods -n kube-system | grep ``` **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 : ```bash kubectl delete pod -n kube-system ``` - 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 : ```bash kubectl get networkpolicy -n -o yaml > backup-policy.yaml ``` Si la modification cause des problèmes, restaurez-la : ```bash 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 -l app=my-stateful-app` et 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 ` 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 `nslookup` dans 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 -zv` depuis 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 -o yaml > backup-.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 -- nslookup ` | | Connexion refusée sur le port de l'application | L'application n'écoute pas ou mauvais port | `kubectl exec -it -- nc -zv ` | | Connectivité partielle | Restrictions NetworkPolicy | `kubectl describe networkpolicy -n ` | | 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 ` | ## 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.