E-NO
Kubernetes 8 min de lecture

Résolution des problèmes réseau pour applications avec état répliquées sur Kubernetes : guide pratique

calendar_today Publié : 2026-11-19
update Dernière mise à jour : 2026-11-19
analytics Efficacité SEO : 100%
Illustration du guide technique pour « Résolution des problèmes réseau pour applications avec état répliquées sur Kubernetes : guide pratique ».

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, curl et dig doivent être disponibles dans vos conteneurs d'application ou dans un conteneur de débogage séparé.

Question rapide 1 sur 2

D'après le passage, lequel des éléments suivants n'est PAS cité comme une raison pour laquelle les StatefulSets sont précieux ?

Le passage cite les identifiants réseau stables et uniques, le stockage persistant stable, le déploiement et la mise à l'échelle ordonnés et sans interruption, ainsi que les mises à jour progressives automatiques et ordonnées, mais pas la mise à l'échelle horizontale automatique entre les namespaces.

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_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 :

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.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 :
  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 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.
  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 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.
  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: 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 :
  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

Question rapide 2 sur 2

Dans le motif de nom d'hôte des Pods d'un StatefulSet, comment le nom d'hôte de chaque Pod est-il construit ?

Le passage indique que le motif de nom d'hôte est `$(statefulset name)-$(ordinal)`, par exemple web-0, web-1, web-2.

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-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 <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 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 <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ômeCause probablePremière commande à exécuter
Les pods ne peuvent pas se résoudre mutuellementProblèmes DNSkubectl exec -it <pod> -- nslookup <nom-d'hôte-autre-pod>
Connexion refusée sur le port de l'applicationL'application n'écoute pas ou mauvais portkubectl exec -it <pod> -- nc -zv <cible> <port>
Connectivité partielleRestrictions NetworkPolicykubectl describe networkpolicy -n <namespace>
Tout le trafic entre nœuds échoueCNI ou pare-feu de nœudkubectl get pods -n kube-system -l k8s-app=calico-node (ou l'étiquette de votre CNI)
Endpoints du Service videsInadéquation du sélecteur d'étiquetteskubectl 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.

Recherches connexes

Score de qualité de l’article

Utilité pour le lecteur 100%
  • check_circle Guide prêt à lire
  • check_circle Exemples pratiques inclus
  • check_circle URL d’article optimisée pour le SEO