Diagnostiquer et résoudre les problèmes réseau AKS avec Advanced Container Networking Services

Ce guide vous guide tout au long du diagnostic et de la résolution des problèmes de mise en réseau réel dans Azure Kubernetes Service (AKS) à l’aide de Advanced Container Networking Services (ACNS). Chaque playbook commence à partir d’un symptôme (échecs DNS, suppressions de paquets, déséquilibre du trafic, erreurs L7), vous indique le signal à vérifier en premier et vous indique quand explorer les journaux.

Le guide est organisé autour des tâches, et non des fonctionnalités. Lisez le modèle mental une fois, puis passez directement au manuel correspondant à votre problème.

Ce que ce guide vous aide à résoudre

• Échecs de résolution DNS dans les pods (NXDOMAIN, SERVFAIL, réponses manquantes).
• Les suppressions de paquets causées par des stratégies réseau mal configurées, un suivi des connexions ou une dégradation de la connectivité.
• Déséquilibre du trafic entre pods ou espaces de noms (pods chauds, distribution de charge inégale).
• Erreurs d’application L7 (HTTP 4xx/5xx, échecs de gRPC, pertes de Kafka).
• Surveillance de l’intégrité du réseau à l’échelle du cluster et planification de la capacité.
• Contrôle des coûts d’observabilité grâce à la collecte ciblée de métriques et de journaux.

Modèle mental : comment les métriques, les logs et le filtrage s'intègrent

ACNS vous donne trois signaux. Chacun répond à une question différente.

Pour obtenir une référence plus approfondie des fonctionnalités, consultez les métriques du réseau de conteneurs, les journaux d’activité du réseau de conteneurs et configurer le filtrage des métriques.

Flux de résolution des problèmes standard

Utilisez cette boucle pour tout incident réseau :

1. Commencez avec les tableaux de bord des métriques. Confirmez l’anomalie : pic de baisses, d’erreurs, de réinitialisations TCP ou d’échecs DNS. Identifiez le nœud concerné, l’espace de noms ou la charge de travail.
2. Diriger vers les journaux enregistrés. Filtrez la ContainerNetworkLogs table par l’espace de noms et la fenêtre de temps à partir de l’étape 1. Les journaux vous indiquent le verdict, la raison de rejet, les charges de travail source/destination et les codes d’état L7 que les métriques ne comportent pas.
3. Reproduire en direct avec les journaux à la demande. Si le problème est intermittent ou déjà résolu dans les données stockées, utilisez l’interface utilisateur Hubble CLI ou Hubble pour capturer des flux en direct pour cette charge de travail.
4. Validez le correctif. Vérifiez à nouveau le même panneau de métriques et réexécutez la même requête KQL. L’anomalie doit être supprimée.
5. Paramétrez la collection. Si vous avez sur-collecté pendant l’incident, réduisez votre ContainerNetworkLog CRD ou appliquez un ContainerNetworkMetric filtre afin de capturer uniquement ce dont vous avez besoin.

Tableaux de bord intégrés en un clin d’œil

Configurez-les une fois avec Configurer l’observabilité du réseau de conteneurs. Vous vous y référerez tout au long des playbooks.

Playbook 1 : Diagnostiquer les échecs de résolution DNS

Symptôme. Les pods enregistrent des erreurs telles que DNS_PROBE_FINISHED_NXDOMAIN, SERVFAIL, ou se bloquent en résolvant les noms de service.

Objectif. Identifiez si l’échec est en amont (CoreDNS ou programme de résolution externe), piloté par la stratégie (refus FQDN) ou spécifique à la charge de travail.

Étape 1 : Confirmer l’anomalie dans les métriques DNS

Ouvrez le tableau de bord DNS (cluster). Recherchez les changements soudains dans le volume de requêtes, le volume de réponse ou % de demandes sans réponse. Les panneaux récapitulatives affichent les requêtes les plus courantes, les codes de réponse les plus courants et les nœuds générant les erreurs les plus fréquentes.

Éléments à rechercher : Une augmentation soutenue des réponses d’erreur, une baisse des réponses réussies ou un nœud unique dominant le nombre d’erreurs. Notez l’horodatage de l’anomalie.

Étape 2 : Identifier les pods les plus bruyants

Faites défiler le tableau de bord vers le bas jusqu’au panneau qui classe les pods par erreurs DNS sur tous les espaces de noms. Les premières entrées sont vos suspects initiaux.

Point de décision.

• Si des erreurs sont concentrées dans les pods CoreDNS, accédez au tableau de bord DNS (Charge de travail) avec kube-system / coredns sélectionné : CoreDNS lui-même ou son résolveur en amont est le problème.
• Si des erreurs sont concentrées dans une charge de travail d’application, cette charge de travail génère des requêtes incorrectes ou est refusée par une stratégie de nom de domaine complet.

Étape 3 : Explorer la charge de travail affectée

Ouvrez le tableau de bord DNS (Charge de travail) de la charge de travail que vous avez identifiée.

• Requêtes DNS / Panneaux réponses DNS. Un pourcentage élevé de Requests Missing Response % indique des délais de réponse en amont ou une surcharge de requête.

  

• Erreurs DNS par type. Faire correspondre la crête à un code :

  • NXDOMAIN — nom de domaine obsolète ou incorrect dans la configuration de l’application.
  • SERVFAIL — problème de résolution en amont.
  • Requête refusée : incompatibilité de politique FQDN ou de configuration DNS.

  

• Adresses IP de réponse DNS retournées. Confirme le taux de résolution réussi. Une baisse signifie généralement que CoreDNS ne peut pas atteindre les serveurs amont ; une vague soudaine peut indiquer un orage de requêtes.

• Table de réponse DNS. Utilisez-le pour repérer les modèles comme « Échec des enregistrements A mais les enregistrements AAAA réussissent », ce qui pointe généralement vers une pile mal configurée pour les environnements IPv4 uniquement.

  

Étape 4 : Confirmer avec les logs stockés

Exécutez cette requête KQL dans votre espace de travail Log Analytics pour exposer les modèles d’erreur DNS. Les lignes agrégées conservent Verdict, les espaces de noms, les charges de travail et Layer7.dns.rcode, donc cette requête fonctionne sur la table par défaut (agrégée) ContainerNetworkLogs :

ContainerNetworkLogs
| where TimeGenerated between (datetime(<start-time>) .. datetime(<end-time>))
| extend L4 = parse_json(Layer4), L7 = parse_json(Layer7)
| where L4.UDP.destination_port == 53
| where Reply == true
| extend SrcWorkload = tostring(SourceWorkloads[0].name),
         DstWorkload = tostring(DestinationWorkloads[0].name),
         DnsRcode    = tostring(L7.dns.rcode)
| where DnsRcode != "NOERROR"
| summarize ResponseCount = sum(IngressFlowCount + EgressFlowCount + UnknownDirectionFlowCount)
    by SourceNamespace, SrcWorkload, DestinationNamespace, DstWorkload, DnsRcode, Verdict
| order by ResponseCount desc

Remplacez <start-time> et <end-time> par des horodatages au format 2026-04-30T15:00:00Z.

Que vérifier dans les résultats :

• Verdict. DROPPED signifie qu’un nom de domaine complet ou une stratégie réseau bloque la requête. FORWARDED avec un non-NOERRORDnsRcode (par exemple, NXDOMAIN, SERVFAIL) signifie que le programme de résolution en amont a retourné une erreur.
• Charges de travail source/destination. Vérifiez que le trafic se dirige vers le workload CoreDNS attendu.
• DnsRcode. Le code de réponse DNS identifie le mode d’échec en un clin d’œil.

Vous pouvez également visualiser les mêmes flux dans le portail Azure sous AKS cluster>Insights>Networking>Flow Logs.

Étape 5 : Reproduire en direct si le problème est intermittent

Si le pic est déjà passé et que vous ne pouvez pas le capturer dans les journaux stockés, utilisez l’interface CLI Hubble à la demande :

hubble observe --namespace <ns> --port 53 --type l7 --follow

Étape 6 : Valider le correctif

Après la mise à jour de la stratégie FQDN, la correction de la configuration de l’application ou la montée en charge de CoreDNS, rouvrez le tableau de bord DNS (charge de travail). Le taux d’erreur doit tomber dans un délai d’une minute ou deux. Réexécutez la requête KQL pour la même fenêtre de temps pour confirmer que les requêtes ayant échoué sont supprimées.

Playbook 2 : Analyser les pertes de paquets

Symptôme. Les services ne peuvent pas communiquer entre eux. Les sondes échouent. Les connexions expirent. Les compteurs de pertes montent dans les tableaux de bord.

Objectif. Identifiez si les suppressions sont causées par la stratégie réseau, l’épuisement du suivi des connexions ou les problèmes de connectivité en amont , et quelle charge de travail est responsable.

Étape 1 : Localiser les suppressions au niveau de l’espace de noms

Ouvrez les flux de pods (espace de noms). Les cartes thermiques révèlent les espaces de noms et les pods avec les taux de perte sortants et entrants les plus élevés.

Les cellules plus brillantes indiquent des taux de chute plus élevés. Notez l’espace de noms et la fenêtre de temps.

Étape 2 : Explorer la charge de travail affectée

Ouvrez Les suppressions (charge de travail) et sélectionnez la charge de travail que vous avez identifiée.

• Utilisez l’instantané de charge de travail pour afficher les pertes sortantes max/min en paquets par seconde et évaluer la gravité.

  

• Le trafic supprimé par raison est le panneau le plus important. La raison vous indique ce qu’il faut corriger :

  • Stratégie refusée : une stratégie NetworkPolicy ou CiliumNetworkPolicy bloque le trafic.
  • CT : Échec de l’insertion de carte : la table de suivi des connexions est complète ; mettre à l’échelle le nœud ou réduire l’activité de connexion.
  • Protocole L3 non pris en charge / paquet non valide : l’application ou le proxy envoie du trafic incorrect.

  

• Carte thermique des gouttes entrantes/sortantes. Identifie les paires de pods spécifiques qui perdent du trafic.

  

• Nombre total de pertes cumulées par pod source. Classe les réplicas problématiques afin que vous sachiez quel réplica vous devez examiner en premier.

  

Étape 3 : Confirmer les flux supprimés dans les journaux stockés

Recherchez les charges de travail source et de destination exactes du trafic supprimé. Verdict, DropReason espaces de noms, et charges de travail sont tous dans la clé d’agrégation. Cette requête fonctionne donc sur les données agrégées.

ContainerNetworkLogs
| where TimeGenerated between (datetime(<start-time>) .. datetime(<end-time>))
| where Verdict == "DROPPED"
| extend SrcWorkload = tostring(SourceWorkloads[0].name),
         DstWorkload = tostring(DestinationWorkloads[0].name)
| summarize DropCount = sum(IngressFlowCount + EgressFlowCount + UnknownDirectionFlowCount)
    by SourceNamespace, SrcWorkload, DestinationNamespace, DstWorkload, DropReason, bin(TimeGenerated, 5m)
| order by TimeGenerated desc, DropCount desc

Limitez-vous à un espace de noms une fois que vous l’avez identifié :

ContainerNetworkLogs
| where TimeGenerated between (datetime(<start-time>) .. datetime(<end-time>))
| where Verdict == "DROPPED"
| where SourceNamespace == "<namespace-name>"
| extend SrcWorkload = tostring(SourceWorkloads[0].name),
         DstWorkload = tostring(DestinationWorkloads[0].name)
| summarize DropCount = sum(IngressFlowCount + EgressFlowCount + UnknownDirectionFlowCount)
    by SrcWorkload, DestinationNamespace, DstWorkload, DropReason, TrafficDirection
| order by DropCount desc

Le tableau de bord Flow Logs dans le portail Azure affiche visuellement les mêmes données, y compris un graphique de dépendance de service qui met en évidence les chemins bloqués.

Étape 4 : Vérification croisée avec les stratégies

Une fois que vous connaissez le pod source et le pod de destination :

kubectl get netpol,cnp -A
kubectl describe cnp -n <namespace> <policy-name>

Associer le flux défaillant aux règles d'entrée et de sortie. La cause la plus courante est une politique de refus par défaut ajoutée sans règle d’autorisation pour un chemin légitime.

Étape 5 : Valider le correctif

Après avoir ajusté la stratégie, le Dropped Traffic by Reason graphique doit tomber à plat pour la stratégie refusée. Réexécuter la requête KQL : DROPPED les verdicts pour cette paire source/destination doivent cesser d’apparaître.

Playbook 3 : Identifier les déséquilibres de trafic et les pods chauds

Symptôme. Quelques pods d’un déploiement saturent le processeur ou le réseau tandis que d’autres sont inactifs. TCP réinitialise la montée. Les rapports de latence proviennent d’utilisateurs (la latence elle-même n’est pas visible dans les métriques ACNS : consultez la note dans le modèle mental).

Objectif. Identifiez les pods qui transportent un trafic disproportionné et déterminez si les réinitialisations indiquent une surcharge ou un équilibrage de charge mal configuré.

Étape 1 : comparer le trafic au niveau du pod

Ouvrez les flux de pods (charge de travail). Le instantané de la charge de travail résume le trafic sortant/entrant ainsi que les pertes de paquets.

Le panneau de type trafic par trace affiche la forme du trafic au fil du temps. Un écart important entre le volume sortant et le volume entrant pointe souvent vers un goulot d’étranglement en aval.

Étape 2 : Repérer les pods chauds avec des cartes thermiques

Les cartes thermiques au niveau du pod rendent le déséquilibre évident. Si un pod (par exemple, default/tcp-client-0) apparaît dans les heatmaps sortants et entrants avec des cases beaucoup plus sombres que ses réplicas, le trafic y est concentré.

Causes courantes :

• Épinglage des sessionAffinity: ClientIP clients vers un pod.
• Service sans tête avec résolution DNS rémanente.
• Hachage de l’équilibreur de charge externe sur un champ de faible cardinalité.

Étape 3 : Utiliser les réinitialisations TCP comme signal de saturation

Ouvrez les panneaux de métriques de réinitialisation TCP .

• Carte thermique du protocole TCP RST sortant par pod source. Un pod source fortement sollicité, qui génère également des RST, est surchargé : l’application ferme les connexions de manière agressive.

  

• Carte thermique du protocole TCP RST entrant par pod de destination. Un pod recevant des RSTs de nombreuses sources signifie généralement qu'il ne peut pas accepter de nouvelles connexions assez rapidement (file d'attente complète, écouteur lent).

  

• Total RST empilé par source/destination. Les tendances au fil du temps vous indiquent si les réinitialisations sont un incident ou un nouvel état stable.

Étape 4 : Confirmer avec les journaux de bord

Identifiez les charges de travail les plus chargées par le volume total de flux. Utilisez les colonnes de nombre de flux agrégées plutôt que count(), qui ne compte que les lignes agrégées et non les flux sous-jacents.

ContainerNetworkLogs
| where TimeGenerated between (datetime(<start-time>) .. datetime(<end-time>))
| extend SrcWorkload = tostring(SourceWorkloads[0].name)
| summarize TotalFlows = sum(IngressFlowCount + EgressFlowCount + UnknownDirectionFlowCount)
    by SourceNamespace, SrcWorkload
| top 10 by TotalFlows desc

Étape 5 : Valider le correctif

Après la mise à l’échelle de la charge de travail, le rééquilibrage du service ou la correction des règles d’affinité, le mappage thermique doit s'intensifier uniformément à travers plus de pods et le taux de TCP RST doit diminuer.

Playbook 4 : Surveiller l’intégrité du réseau à l’échelle du cluster

Utilisez cette option lorsque vous avez besoin d'une vue d'ensemble de la flotte : pour la planification de la capacité, les tableaux de bord en astreinte ou une vérification de l'état de santé rapide sur de nombreux clusters.

Ouvrez Kubernetes / Mise en réseau / Clusters.

Signaux à regarder et ce qu’ils signifient :

Lorsque quelque chose sur ce tableau de bord semble incorrect, accédez au playbook correspondant (Playbook 1 pour DNS, Playbook 2 pour les gouttes, Playbook 3 pour les pods chauds).

Playbook 5 : Diagnostiquer les erreurs de couche applicative (L7)

Symptôme. Les taux d’erreur HTTP 4xx/5xx augmentent. Les appels gRPC échouent. Retard des consommateurs Kafka. Disponible sur les clusters Cilium avec l’application de stratégie L7 activée et qui CiliumNetworkPolicy inclut des règles de niveau 7 : consultez Configurer une stratégie de niveau 7.

Objectif. Identifiez si les erreurs L7 proviennent de clients mal configurés, d’échecs côté serveur ou de flux refusés.

Étape 1 : Ouvrir le tableau de bord L7

Utilisez Kubernetes / Mise en réseau / L7 (charge de travail) pour un seul service ou L7 (espace de noms) pour un locataire entier.

Étape 2 : Séparation du trafic HTTP supprimé par rapport au trafic HTTP transféré

Le panneau de verdict fractionne le trafic HTTP en flux transférés et supprimés. Un pic de requêtes HTTP rejetées signifie généralement qu’une stratégie CiliumNetworkPolicy refuse la requête à L7 (par exemple, le blocage d’un chemin d’accès ou d’une méthode).

Étape 3 : Suivre les codes d’état au fil du temps

Le panneau de code d’état vous indique si les erreurs sont côté client ou côté serveur. Une augmentation des codes 4xx indique une entrée incorrecte, des jetons expirés ou des chemins refusés. Une augmentation des incidents de type 5xx lors des défaillances du système back-end.

Étape 4 : Rechercher les modules incriminés

La heatmap 4xx montre quels pods sources génèrent le plus de requêtes échouées. Un seul pod brillant intensément signifie généralement une boucle de réessai du client bloquée ou un réplica mal configuré.

Étape 5 : Confirmer avec KQL

Analysez le trafic HTTP ventilé par code d'état. Layer7.http.code fait partie de la clé d’agrégation. Cela fonctionne donc sur les lignes agrégées :

ContainerNetworkLogs
| where TimeGenerated between (datetime(<start-time>) .. datetime(<end-time>))
| extend L7 = parse_json(Layer7)
| where isnotnull(L7.http)
| extend StatusCode  = tostring(L7.http.code),
         SrcWorkload = tostring(SourceWorkloads[0].name),
         DstWorkload = tostring(DestinationWorkloads[0].name)
| where StatusCode startswith "4" or StatusCode startswith "5"
| summarize ErrorFlows = sum(IngressFlowCount + EgressFlowCount + UnknownDirectionFlowCount),
            UniqueCodes = dcount(StatusCode)
    by SrcWorkload, DstWorkload, StatusCode
| order by ErrorFlows desc

Pour gRPC et Kafka, Layer7 porte la charge utile spécifique au protocole, mais uniquement http.code et dns.rcode sont des clés d’agrégation. Filtrez sur Verdict et sur l'identité de la charge de travail, et utilisez les journaux à la demande lorsque vous avez besoin de la méthode gRPC ou du sujet Kafka.

ContainerNetworkLogs
| where TimeGenerated between (datetime(<start-time>) .. datetime(<end-time>))
| where FlowType == "L7"
| extend SrcWorkload = tostring(SourceWorkloads[0].name),
         DstWorkload = tostring(DestinationWorkloads[0].name)
| where Verdict == "DROPPED"
| summarize DroppedFlows = sum(IngressFlowCount + EgressFlowCount + UnknownDirectionFlowCount)
    by SrcWorkload, DstWorkload
| order by DroppedFlows desc

Sur quoi se concentrer pendant L7 RCA

• Volume et forme du trafic. Utilisez des cartes thermiques pour trouver un déséquilibre ; un réplica chaud explique souvent le taux d’erreur.
• Tendance du code d’état. 4xx vs 5xx limite l’investigation côté client ou serveur.
• Verdict.Abandonné Les flux L7 signifient qu’une stratégie L7 rejette la demande : lisez la stratégie et confirmez l’intention.

Présentation approfondie des fonctionnalités (quand utiliser ce qui)

Utilisez cette section comme référence rapide une fois que vous connaissez les manuels.

Métriques réseau de conteneur

• Permet de : détection d’anomalies, tableaux de bord, alertes, planification de la capacité.
• Passez pour : cause racine qui requiert une identité (quel pod, quel chemin, quel verdict).
• Granularité : niveau nœud sur tous les plans de données ; niveau pod sur Linux.
• Charges de travail sensibles aux coûts : appliquez le filtrage des métriques sur les clusters Cilium pour conserver uniquement les espaces de noms, les étiquettes et les types de métriques qui vous intéressent. Le filtrage se produit avant le scraping, donc les données de séries indésirables n’atteignent jamais Prometheus.

Fichiers journaux réseau de conteneurs (archivés)

• Utiliser pour : analyse de la cause racine, tendances historiques, conformité/audit.

• Plan de données :Cilium uniquement. Les journaux stockés ne sont pas disponibles sur les clusters non-Cilium.

• Étape obligatoire : définissez un ContainerNetworkLog CRD qui sélectionne le trafic souhaité. Sans cela, aucun fichier log n’est collecté. Voir Configurer les journaux réseau de conteneurs.

• Où les journaux d’activité atterrissent : par défaut, Cilium écrit les enregistrements /var/log/acns/hubble/events.log de flux sur chaque nœud (50 Mo de mémoire tampon pivotante). À partir de là, vous avez deux chemins de stockage :

  • Azure Log Analytics (géré, recommandé) : Container Insights envoie des journaux dans la table ContainerNetworkLogs pour les requêtes KQL et les tableaux de bord du portail Azure intégrés.
  • Bring your own collector — pointez un agent compatible OpenTelemetry (Splunk, Datadog, Elastic, any OTel collector) sur le chemin du journal hôte pour transférer les flux dans votre pile d’observabilité existante au lieu, ou en plus, de Log Analytics.

• Contrôle des coûts : l’agrégation des journaux de flux réduit les flux similaires sur une fenêtre de 30 secondes, préservant les modèles tout en réduisant le volume. Combinez avec un includeFilters étroit pour les meilleurs résultats.

• Visualisation : utilisez les tableaux de bord Journaux de flux - Niveau Analytics ou Journaux de flux - Niveau de base sous Azure>Insights>Conteneurs>Réseau.

  

  

Journaux de logs réseau de conteneurs (à la demande)

• Utiliser pour : incidents en direct, problèmes intermittents, investigation ad hoc sans modifier la configuration de collecte.

• Plan de données :Cilium uniquement.

• Outils: Interface CLI Hubble pour le filtrage de terminal ; Interface utilisateur Hubble pour les cartes de service à service visuels.

• Aucun stockage persistant, aucun coût supplémentaire, aucune configuration au-delà de l’activation d’ACNS.

  

Filtrage des métriques (clusters Cilium)

Appliquez un ContainerNetworkMetric CRD pour contrôler les métriques Hubble exportées par nœud. Utile lorsque vous avez besoin d’une observabilité étendue sur quelques espaces de noms critiques, mais que vous ne souhaitez pas payer pour les séries de flux à cardinalité élevée sur tous ces espaces de noms.

Modèles courants :

• Conservez dns et supprimez les métriques à l’échelle du cluster ; limitez les métriques de flux aux espaces de noms de production.
• Excluez les espaces de noms système à volume élevé comme kube-system dans les métriques de flux.
• Confinez les espaces de noms par locataire à leurs propres blocs de filtres.

Pour obtenir des exemples CRD complets, consultez Configurer le filtrage des métriques de réseau de conteneurs.

Bonnes pratiques

• Commencez large, puis étroit. Activez les journaux/métriques étendus pendant quelques jours, passez en revue ce que vous utilisez réellement, puis resserrez les filtres ContainerNetworkLog et ContainerNetworkMetric.
• Gardez les plages de temps des métriques et des journaux alignées. Lorsque vous examinez un incident, utilisez la même heure de début/fin dans le tableau de bord et la requête KQL afin que les signaux soient corrélés correctement.
• Privilégiez les tableaux de bord préconfigurés. Ils couvrent les questions les plus courantes. Les panneaux personnalisés ne sont généralement nécessaires qu'une fois la phase de tri initiale terminée.
• Niveau ContainerNetworkLogs selon le besoin. Basculez vers le niveau De base pour les charges de travail sensibles aux coûts ; utilisez le tableau de bord de niveau De base correspondant. Consultez plans de tables Log Analytics.
• Traitez les journaux agrégés et les journaux à la demande comme des compléments. Les journaux agrégés sont parfaits pour la détection des tendances et des modèles, mais ignorent les détails par flux. Utilisez Hubble à la demande pour une inspection détaillée.
• Validez les correctifs avec le même panneau qui a exposé le problème. Si le même panneau est plat après votre modification, vous avez un véritable correctif.

Pièges courants

• Oublier le ContainerNetworkLog CRD. L’activation des journaux réseau de conteneurs dans le cluster ne recueille rien tant que vous n'avez pas appliqué au moins un CRD pour sélectionner le trafic.
• Utilisez les journaux stockés pour les incidents en direct qui sont déjà passés. Si les journaux de bord n'ont pas été activés avant l'incident ou n'étaient pas inclus dans le filtre capturé, passez aux flux Hubble à la demande lors du prochain incident.
• Tableaux de bord L7 vides sur un cluster Cilium. Les métriques L7 nécessitent à la fois --acns-advanced-networkpolicies L7 sur le cluster et une CiliumNetworkPolicy avec des règles L7. LE CCNP ne prend pas en charge les règles L7. Consultez Appliquer des stratégies L7.
• Métriques DNS vides sur Cilium. Pour avoir une visibilité DNS, une règle CiliumNetworkPolicy est requise avec une règle dns, généralement utilisée en conjonction avec toFQDNs. Le proxy FQDN/DNS n’est pas compatible avec le DNS local de nœud ou le DNS local AKS — exécuter l’un ou l’autre désactive le proxy DNS et affecte les métriques obtenues. Consultez les limitations de filtrage du nom de domaine entièrement qualifié.
• matchPattern: "*" bloque tous les DNS. Un caractère générique simple n'est pas pris en charge. Utilisez un motif avec un caractère générique au début, comme *.example.com ou app*.example.com. Consultez Appliquer des stratégies de filtrage FQDN.

Observabilité du réseau incluse avec la supervision Azure

Lorsque vous activez le service géré pour Prometheus d’Azure Monitor sur un cluster AKS, les mesures de surveillance du réseau du nœud de base sont collectées par défaut via la cible networkobservabilityRetina. Cela fournit les éléments suivants :

• Mesures réseau de base au niveau du nœud : visibilité du trafic réseau de base au niveau du nœud
• Cibles Prometheus par défaut : mesures d’observabilité du réseau automatiquement récupérées par Azure Monitor
• Intégration Azure Monitor : intégration transparente avec Azure Monitor. Les mesures sont collectées automatiquement et peuvent être visualisées dans Grafana
• Aucune configuration supplémentaire requise : activé automatiquement quand le service géré pour Prometheus d’Azure Monitor est configuré
• Support Microsoft : pris en charge dans le cadre d’Azure Monitor et AKS

Note : cela nécessite que le service géré pour Prometheus d’Azure Monitor soit activé sur votre cluster AKS, ce qui peut générer des coûts associés.

Prise en main : activez le service géré pour Prometheus d’Azure Monitor sur votre cluster AKS via le portail Azure ou la CLI. Les mesures d’observabilité du réseau sont automatiquement collectées et disponibles pour une visualisation dans Azure Managed Grafana.

Observabilité du réseau avec le logiciel Open Source Retina

Bien que les services avancés de mise en réseau de conteneurs (ACNS) soient une offre payante qui fournit des fonctionnalités d’observabilité du réseau complètes, Microsoft prend également en charge l’observabilité du réseau avec le logiciel Open Source Retina, une plateforme d’observabilité du réseau open source qui fournit des fonctionnalités de surveillance du réseau essentielles.

Le logiciel Open Source Retina est la plateforme d’observabilité open source disponible sur retina.sh et GitHub. Elle fournit :

• Observabilité réseau basée sur eBPF : utilise des technologies eBPF pour collecter des insights avec une surcharge minimale
• Analyse approfondie du trafic avec le contexte Kubernetes : capture et analyse complètes des flux de trafic réseau avec une intégration Kubernetes complète
• Collection de mesures avancée : mesures de couche 4, mesures DNS et fonctionnalités de capture de paquets distribués
• Extensibilité basée sur un plug-in : personnalisez et étendez les fonctionnalités via une architecture de plug-in
• Mesures compatibles avec Prometheus : exportez des mesures de réseau complètes au format Prometheus avec des modes de mesure configurables
• Capture de paquets distribués : captures de paquets à la demande sur plusieurs nœuds pour une résolution approfondie des problèmes
• Plateforme et CNI indépendantes : fonctionne avec n’importe quel cluster Kubernetes (AKS, avec Arc, local), n’importe quel système d’exploitation (Linux/Windows) et n’importe quel CNI
• Support de la communauté : open source avec un support et des contributions pilotés par la communauté
• Auto-managé : contrôle complet du déploiement et de la configuration
• Intégration Hubble : s’intègre au Hubble de Cilium pour des aperçus réseau supplémentaires

Prise en main : déployez le logiciel Open Source Retina à l’aide de graphiques Helm ou de manifestes Kubernetes à partir du référentiel Retina officiel. Configurer Prometheus et Grafana pour visualiser les mesures, configurer une analyse approfondie du trafic avec le contexte Kubernetes, activer la capture de paquets distribués pour une résolution avancée des problèmes et personnaliser les fonctionnalités à l’aide de l’architecture basée sur le plug-in pour des cas d’usage spécifiques.

Comparaison des offres d’observabilité du réseau

En savoir plus

Services avancés de mise en réseau de conteneurs (ACNS)

• Vue d’ensemble de la plateforme :Qu’est-ce que Advanced Container Networking Services pour AKS ?
• Configurer l’observabilité :configurer l’observabilitédu réseau de conteneurs
• Métriques du réseau de conteneurs :Vue d’ensemble des métriques réseau de conteneur
• Journaux de réseau de conteneurs :Aperçu des journaux de réseau de conteneurs et Configuration des journaux de réseau de conteneurs
• Filtrage des métriques (Cilium) :configurer le filtrage des métriques réseau de conteneurs

Diagnostics pilotés par l’IA

• Agent Container Network Insights (préversion) :vue d’ensemble et configuration de l’agent
• Serveur AKS MCP :serveur de protocole de contexte de modèle AKS

Sécurité réseau de conteneur (Cilium)

• Filtrage FQDN :Concepts et Appliquer des stratégies de filtrage FQDN
• Stratégie de couche 7 :Concepts et appliquer des stratégies L7
• TLS mutuel (Cilium) :concepts et configuration du protocole TLS mutuel
• Chiffrement en transit :Concepts de chiffrement WireGuard

Plan de données et plateforme

• Azure CNI alimenté par Cilium :Configure Azure CNI alimenté par Cilium
• Performances du routage de l’hôte eBPF :Performances du réseau de conteneurs avec le routage de l’hôte eBPF
• Plans de table Log Analytics :Choisissez un plan de table de données basé sur l’utilisation des données

Outils open source

• Retina :retina.sh et le dépôt Microsoft Retina GitHub
• Hubble (projet Cilium) :documentation Hubble