Diagnostisera och lösa PROBLEM med AKS-nätverk med Advanced Container Networking Services

Den här guiden beskriver hur du diagnostiserar och löser verkliga nätverksproblem i Azure Kubernetes Service (AKS) med hjälp av Advanced Container Networking Services (ACNS). Varje spelbok startar från ett symptom (DNS-fel, paketfall, obalans i trafiken, L7-fel), visar vilken signal du ska kontrollera först och anger när du ska öka detaljnivån i loggarna.

Guiden är organiserad kring uppgifter, inte funktioner. Läs den mentala modellen en gång och hoppa sedan direkt till spelboken som matchar ditt symptom.

Vad den här guiden hjälper dig att lösa

• DNS-upplösningsfel i pods (NXDOMAIN, SERVFAIL, saknade svar).
• Paketförluster som orsakas av felkonfigurerade nätverksprinciper, anslutningsspårning eller anslutningsförsämring.
• Obalans i trafiken mellan poddar eller namnområden (heta poddar, ojämn belastningsfördelning).
• L7-applikationsfel (HTTP 4xx/5xx, gRPC-fel, Kafka-droppar).
• Klusteromfattande övervakning av nätverkshälsa och kapacitetsplanering.
• Kostnadskontroll för observerbarhet via målmått och logginsamling.

Mental modell: hur mått, loggar och filtrering passar ihop

ACNS ger dig tre signaler. Var och en svarar på en annan fråga.

En djupare funktionsreferens finns i Containernätverksmått, Containernätverksloggar och Konfigurera måttfiltrering.

Standardfelsökningsflöde

Använd den här loopen för alla nätverksincidenter:

1. Börja i mätinstrumentpaneler. Bekräfta avvikelsen: en ökning i förluster, fel, TCP-återställningar eller DNS-fel. Identifiera den berörda noden, namnrymden eller arbetsbelastningen.
2. Växla till lagrade loggar. ContainerNetworkLogs Filtrera tabellen efter namnrymden och tidsfönstret från steg 1. Loggar visar utfall, borttagningsorsak, käll-/målarbetsbelastning och L7-statuskoder som inte inkluderas i metrik.
3. Återskapa live med loggar på begäran. Om problemet är tillfälligt eller redan har åtgärdats i de lagrade uppgifterna, använd Hubble CLI eller Hubble UI för att fånga liveflöden för den arbetsbelastningen.
4. Verifiera korrigeringen. Kontrollera samma måttpanel igen och kör samma KQL-fråga igen. Avvikelsen bör vara borta.
5. Justera samling Om du överinsamlade under incidenten kan du begränsa din ContainerNetworkLog CRD eller använda ett ContainerNetworkMetric filter så att du bara samlar in det du behöver i framtiden.

Snabb överblick över inbyggda instrumentpaneler

Konfigurera dem en gång med Konfigurera containernätverksobservabilitet. Du refererar till dem i spelböckerna.

Spelbok 1: Diagnostisera DNS-matchningsfel

Symptom. Poddar loggar fel som DNS_PROBE_FINISHED_NXDOMAIN, SERVFAIL eller låser sig där de löser tjänstnamn.

Mål. Identifiera om felet är uppströms (CoreDNS eller extern matchare), principdriven (FQDN-neka) eller arbetsbelastningsspecifik.

Steg 1: Bekräfta avvikelsen i DNS-mått

Öppna DNS-instrumentpanelen (kluster). Leta efter plötsliga ändringar i begärandevolym, svarsvolym eller begäranden utan svar %. Sammanfattningspanelerna innehåller de vanligaste frågorna, de vanligaste svarskoderna och noderna som genererar flest fel.

Vad du ska leta efter: En ihållande ökning av felsvar, en minskning av lyckade svar eller en enda nod som dominerar antalet fel. Observera tidsstämpeln för avvikelsen.

Steg 2: Identifiera de mest bullriga poddar

Rulla nedåt på samma instrumentpanel till panelen som rangordnar poddar efter DNS-fel i alla namnområden. De främsta inläggen är dina huvudsakliga misstänkta.

Beslutspunkt.

• Om felen är koncentrerade till CoreDNS-poddar, hoppar du till DNS-dashboard (arbetsbelastning) med kube-system / coredns markerat – CoreDNS eller dess överordnade resolver är själva problemet.
• Om fel koncentreras till en programarbetsbelastning genererar den arbetsbelastningen felaktiga frågor eller nekas av en FQDN-princip.

Steg 3: Granska den berörda arbetsbelastningen

Öppna DNS-instrumentpanelen (arbetsbelastning) för den arbetsbelastning som du identifierade.

• DNS-begäranden/DNS-svarspaneler. Ett högt Begäranden som saknar svar % pekar på uppströms timeouts eller frågeöverbelastning.

  

• DNS-fel efter typ. Matcha spiken med en kod:

  • NXDOMAIN – fel eller inaktuellt domännamn i appkonfigurationen.
  • SERVFAIL — problem med överordnad lösning.
  • Query Refused – FQDN-policy eller DNS-konfigurationskonflikt.

  

• DNS-svars-IP-adresser returnerade. Bekräftar lyckad lösningsfrekvens. En minskning innebär vanligtvis att CoreDNS inte kan nå uppströms; en plötslig ökning kan tyda på en förfrågningsstorm.

• DNS-svarstabell. Använd detta för att upptäcka mönster som "A-poster misslyckas men AAAA-poster lyckas", som vanligtvis pekar på en stack som är felkonfigurerad för miljöer med endast IPv4.

  

Steg 4: Bekräfta med lagrade loggar

Kör den här KQL-frågan på din Log Analytics arbetsyta för att visa DNS-felmönster. Aggregerade rader bevarar Verdict, namnrymder, arbetsbelastningar och Layer7.dns.rcode, så den här frågan fungerar mot standardtabellen (aggregerad): 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

Ersätt <start-time> och <end-time> med tidsstämplar i formatet 2026-04-30T15:00:00Z.

Så här kontrollerar du resultatet:

• Slutsats DROPPED innebär att en FQDN- eller nätverksprincip blockerar frågan. FORWARDED med en icke-NOERRORDnsRcode (till exempel NXDOMAIN, SERVFAIL) betyder att den överordnade upplösaren returnerade ett fel.
• Käll-/målarbetsbelastningar. Bekräfta att trafiken går till den avsedda CoreDNS-tjänsten.
• DnsRcode. DNS-svarskoden identifierar felläget snabbt.

Du kan också visualisera samma flöden i Azure-portalen under AKS-kluster>Insights>Networking>Flow Logs.

Steg 5: Återskapa live om problemet är tillfälligt

Om toppen redan har passerat och du inte kan samla in den i lagrade loggar använder du Hubble CLI på begäran:

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

Steg 6: Verifiera korrigeringen

När du har uppdaterat FQDN-principen, åtgärdat programkonfigurationen och skalat CoreDNS, öppnar du översiktspanelen DNS (arbetsbelastning). Felfrekvensen bör sjunka inom en minut eller två. Kör KQL-frågan igen under samma tidsperiod för att bekräfta att de misslyckade frågorna är borta.

Handbok 2: Undersök paketförlust

Symptom. Tjänster kan inte nå varandra. Prober misslyckas. Anslutningar upphör på grund av tidsgräns. Räknare för packetförluster ökar i instrumentpaneler.

Mål. Identifiera om droppar orsakas av nätverkspolicy, utmattning av anslutningsspårning eller uppströmanslutningsproblem – och vilken arbetsbelastning som är ansvarig.

Steg 1: Leta upp droppar på namnområdesnivå

Öppna poddflöden (namnområde). Heatmaps visar namnrymder och pods med högsta utgående och inkommande borttappningsfrekvens.

Ljusare celler indikerar högre bortfallsfrekvens. Observera namnrymden och tidsfönstret.

Steg 2: Undersök den berörda arbetsbelastningen

Öppna Drops (Workload) och välj den arbetsbelastning som du identifierade.

• Arbetsbelastningsögonblicksbild visar maximala/minimala utgående tapp i paket per sekund. Använd den för att bedöma allvarlighetsgraden.

  

• Bortfiltrerad trafik efter orsak är den viktigaste panelen. Anledningen talar om för dig vad du ska åtgärda:

  • Policyn nekades – en NetworkPolicy eller CiliumNetworkPolicy blockerar trafiken.
  • CT: Kartinfogningen misslyckades – anslutningsspårningstabellen är full; skala noden eller minska anslutningsomsättningen.
  • L3-protokoll som inte stöds/Ogiltigt paket – program eller proxy skickar felaktig trafik.

  

• Värmekarta över inkommande/utgående droppar. Identifierar vilka specifika poddpar som förlorar trafik.

  

• Staplade totala droppar per källpodd. Rangordnar förövarna så att du vet vilken kopia du ska titta på först.

  

Steg 3: Bekräfta de borttagna flödena i lagrade loggar

Hitta de exakta käll- och målarbetsbelastningarna för den borttagna trafiken. Verdict, DropReason, namnrymder och arbetsbelastningar finns alla i aggregeringsnyckeln, så den här frågan fungerar på aggregerade data:

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

Begränsa till ett namnområde när du har identifierat det:

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

Instrumentpanelen Flow Logs i Azure-portalen visar samma data visuellt, inklusive ett tjänstberoendediagram som markerar blockerade sökvägar.

Steg 4: Korskolla med principer

När du känner till källpodden och målpodden:

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

Matcha det misslyckade flödet mot regler för ingress/utgående trafik. Den vanligaste orsaken är en princip för standardnekelse som läggs till utan en tillåt-regel för en legitim sökväg.

Steg 5: Verifiera korrigeringen

När du har justerat regeln Dropped Traffic by Reason bör diagrammet vara platt för regeln avvisad. Kör KQL-frågan igen – DROPPED domar för det käll-/målparet bör sluta visas.

Handlingsplan 3: Hitta trafikobalanser och heta pods

Symptom. Några poddar i en distribution mättar CPU eller nätverk medan andra är inaktiva. TCP-återställningar klättrar. Svarstidsrapporter kommer från användare (själva svarstiden visas inte i ACNS-mått – se anteckningen i Mental modell).

Mål. Identifiera vilka poddar som hanterar oproportionerlig trafik och om återställningar indikerar överbelastning eller felkonfigurerad belastningsutjämning.

Steg 1: Jämför trafik på poddnivå

Öppna poddflöden (arbetsbelastning). Arbetsbelastningsöversikten sammanfattar utgående/inkommande trafik och förluster.

Panelen för trafik-efter-spårtyp visar trafikens mönster över tid. En stor skillnad mellan utgående och inkommande volymer pekar ofta på en nedströms flaskhals.

Steg 2: Upptäck heta enheter med värmekartor

Värmekartor på podnivå gör obalansen uppenbar. Om en pod (till exempel default/tcp-client-0) visas i både utgående och inkommande värmekartor med mycket mörkare celler än dess repliker, så koncentreras trafiken där.

Vanliga orsaker:

• Tjänsten sessionAffinity: ClientIP kopplar klienter till en nod.
• Huvudlös tjänst med ihållande DNS-upplösning.
• Extern lastbalanserare hashing på ett fält med låg kardinalitet.

Steg 3: Använd TCP-återställningar som en mättnadssignal

Öppna panelerna för TCP-återställningsmått .

• Värmekarta över utgående TCP RST från källpodd. En het källpodd som också genererar RST-signal är överbelastad – programmet stänger anslutningar på ett aggressivt sätt.

  

• Värmekarta över inkommande TCP RST efter destinationspodd. En podd som tar emot RST-signaler från många källor innebär vanligtvis att den inte kan acceptera nya anslutningar tillräckligt snabbt (backloggen är full, lyssnaren är långsam).

  

• Staplad total RST efter källa/mål. Trender över tid anger om återställningar är en incident eller ett nytt stabilt tillstånd.

Steg 4: Bekräfta med loggar

Identifiera de mest belastade arbetsbelastningarna utifrån total flödesvolym. Använd kolumnerna för aggregerat flödesantal istället för count(), som bara räknar aggregerade rader, inte de underliggande flödena.

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

Steg 5: Verifiera korrigeringen

När du har skalat om belastningen, balanserat om tjänsten eller åtgärdat affinitetsregler bör värmekartan lysa upp över fler poddar jämnt och TCP RST-hastigheten bör sjunka.

Spelbok 4: Övervaka klusteromfattande nätverkshälsa

Använd detta när du behöver en vy över flottan: kapacitetsplanering, jourinstrumentpaneler eller en snabb hälsokontroll i många kluster.

Öppna Kubernetes/Nätverk/Kluster.

Signaler att titta på och vad de betyder:

När något på den här instrumentpanelen ser fel ut går du till matchande spelbok (Spelbok 1 för DNS, Spelbok 2 för droppar, Spelbok 3 för heta poddar).

Spelbok 5: Diagnostisera programnivåfel (L7)

Symptom. HTTP 4xx/5xx felfrekvenser stiger. gRPC-anrop misslyckas. Kafka-konsumenter släpar efter. Tillgängligt i Cilium-kluster med L7-principtillämpning aktiverat och ett CiliumNetworkPolicy som innehåller L7-regler – se Konfigurera en Layer 7-princip.

Mål. Identifiera om L7-fel kommer från felkonfigurerade klienter, fel på serversidan eller nekade flöden.

Steg 1: Öppna instrumentpanelen L7

Använd Kubernetes/Nätverk/L7 (arbetsbelastning) för en enskild tjänst eller L7 (namnområde) för en hel klientorganisation.

Steg 2: Avgränsa borttagen eller vidarebefordrad HTTP-trafik

Bedömningspanelen delar upp HTTP-trafik i vidarebefordrade och borttagna flöden. En topp i tappad HTTP innebär vanligtvis att en CiliumNetworkPolicy nekar begäran på lager 7 (till exempel blockerar en sökväg eller en metod).

Steg 3: Spåra statuskoder över tid

Panelen statuskod anger om felen är på klientsidan eller på serversidan. En ökning av 4xx pekar på felaktiga indata, förfallna tokens eller nekade sökvägar. En ökning av 5xx-svar vid backend-fel.

Steg 4: Hitta de felaktiga poddarna

4xx-värmekartan visar vilka källpoddar som genererar de mest misslyckade begärandena. En enda pod som lyser starkt innebär vanligtvis att den har fastnat i en klientomstartslinga eller en felkonfigurerad replika.

Steg 5: Bekräfta med KQL

Hämta HTTP-trafik uppdelad efter statuskod. Layer7.http.code är en del av aggregeringsnyckeln, så detta fungerar mot aggregerade rader:

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

För gRPC och Kafka Layer7 , bär den protokollspecifika nyttolasten men endast http.code och dns.rcode är aggregeringsnycklar. Filtrera på Verdict och arbetsbelastningsidentiteten och använd loggar på begäran när du behöver gRPC-metoden eller Kafka-ämnet:

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

Vad du ska fokusera på under L7 RCA

• Trafikvolym och struktur. Använd värmekartor för att hitta obalans; en one hot-replika förklarar ofta felfrekvensen.
• Statuskodtrend. 4xx vs 5xx begränsar undersökningen till klient- eller serversidan.
• Dom.Förlorade L7-flöden innebär att en L7-policy avvisar begäran – läs policyn och bekräfta avsikten.

Grundlig genomgång av funktioner (när du ska använda vad)

Använd det här avsnittet som en snabbreferens när du känner till spelböckerna.

Mått för containernätverk

• Används för: avvikelseidentifiering, instrumentpaneler, aviseringar, kapacitetsplanering.
• Hoppa över för: rotorsak som behöver identitet (vilken pod, vilken sökväg, vilket utlåtande).
• Kornighet: nodnivå på alla dataplan; poddnivå i Linux.
• Kostnadskänsliga arbetsbelastningar: Använd måttfiltrering på Cilium-kluster för att endast behålla de namnområden, etiketter och måtttyper som du bryr dig om. Filtrering sker innan skrapning, så oönskade serier når aldrig Prometheus.

Containernätverksloggar (lagrade)

• Används för: rotorsaksanalys, historiska trender, efterlevnad/granskning.

• Dataplan: Endast Cilium. Sparade loggar är inte tillgängliga på kluster utan Cilium.

• Obligatoriskt steg: Definiera en ContainerNetworkLog CRD som väljer den trafik du vill använda. Utan den samlas inga loggar in. Se Konfigurera containernätverksloggar.

• Där loggarna hamnar: som standard skriver Cilium flödesposter till /var/log/acns/hubble/events.log på varje nod (50 MB roterande buffert). Därifrån har du två lagringssökvägar:

  • Azure Log Analytics (hanterad, rekommenderad) – Container Insights skickar loggar till tabellen ContainerNetworkLogs för KQL-frågor och inbyggda instrumentpaneler i Azure-portalen.
  • Bringa din egen insamlare – peka en OpenTelemetry-kompatibel agent (Splunk, Datadog, Elastic, valfri OTel-insamlare) på värdloggsökvägen för att vidarebefordra flöden till din befintliga observerbarhetsstack i stället för, eller utöver, Log Analytics.

• Kostnadskontroll: flödesloggaggregeringen sammanfogar liknande flöden över ett 30-sekundersfönster, vilket bevarar mönster samtidigt som det minskar volymen. Kombinera med smal includeFilters för bästa resultat.

• Visualization: använder Flow Logs - Analytics Tier eller Flow Logs - Basic Tier instrumentpaneler under Azure>Insights>Containers>Networking.

  

  

Containernätverksloggar (på begäran)

• Används för: live-incidenter, tillfälliga problem, ad hoc-undersökning utan att ändra insamlingskonfigurationen.

• Dataplan:Endast Cilium.

• Verktyg: Hubble CLI för terminalfiltrering; Hubble-användargränssnittet för visuella tjänst-till-tjänst-kartor.

• Ingen beständig lagring, ingen extra kostnad, ingen installation utöver att aktivera ACNS.

  

Måttfiltrering (Cilium-kluster)

Använd en ContainerNetworkMetric CRD för att styra vilka Hubble-mått som exporteras per nod. Användbart när du behöver bred observerbarhet på några viktiga namnområden men inte vill betala för flödesserier med hög kardinalitet i alla.

Vanliga mönster:

• Behåll DNS och släpp mått i hela klustret. begränsa flödesmått till produktionsnamnområden.
• Exkludera systemnamnområden med stora volymer, till exempel kube-system från flödesmått.
• Avgränsa per-tenant namnrymder till sina egna filterblock.

Fullständiga CRD-exempel finns i Konfigurera filtrering av containernätverksmått.

Metodtips

• Börja brett och sedan smalt. Aktivera breda loggar/metrik i några dagar, granska vad du använder och dra sedan åt ContainerNetworkLog och ContainerNetworkMetric filtrena.
• Håll mått- och loggtidsfönstren synkroniserade. När du undersöker en incident använder du samma start-/sluttid på instrumentpanelen och KQL-frågan så att signalerna korrelerar rent.
• Föredrar de färdiga instrumentpanelerna. De täcker de vanligaste frågorna. Anpassade paneler behövs vanligtvis bara när du har passerat den inledande triagen.
• Anpassa ContainerNetworkLogs efter behov. Växla till Basic-nivån för kostnadskänsliga arbetsbelastningar. använd den matchande instrumentpanelen på Basic-nivån. Se Log Analytics tabellplaner.
• Behandla aggregerade loggar och loggar på begäran som komplement. Aggregerade loggar är bra för trend- och mönsteridentifiering men hoppar över information per flöde. Använd på begäran (Hubble) för detaljerad inspektion.
• Verifiera korrigeringar med samma panel som identifierade problemet. Om samma panel blir platt efter ändringen har du en riktig korrigering.

Vanliga fallgropar

• ContainerNetworkLog Glömmer CRD. Aktivering av containernätverksloggar i klustret samlar inte in något förrän du har tillämpat minst en CRD som filtrerar trafik.
• Försöker använda lagrade loggar för tidigare inträffade händelser som redan har inträffat. Om loggarna inte var aktiverade före incidenten eller föll utanför det insamlade filtret växlar du till Hubble-flöden på begäran för nästa förekomst.
• L7-dashboards är tomma i ett Cilium-kluster. L7-mått kräver både --acns-advanced-networkpolicies L7 på klustret och en CiliumNetworkPolicy med L7-regler. CCNP stöder inte L7-regler. Se Tillämpa L7-principer.
• DNS-mått är tomma på Cilium. DNS-synlighet kräver en CiliumNetworkPolicy med en dns regel (vanligtvis tillsammans med toFQDNs). FQDN/DNS-proxyn är inte kompatibel med nodlokal DNS eller lokal AKS-DNS – om du kör antingen inaktiveras DNS-proxy och de resulterande måtten. Se FQDN-filtreringsbegränsningar.
• matchPattern: "*" blockerar all DNS. Ett rent jokertecken stöds inte. Använd inledande jokerteckenmönster, till exempel *.example.com eller app*.example.com. Se Tillämpa FQDN-filtreringsprinciper.

Nätverksobservabilitet ingår i Azure Monitoring

När du aktiverar Azure Monitor-hanterad tjänst för Prometheus i ett AKS-kluster samlas grundläggande nätverksövervakningsmått för noder in som standard via networkobservabilityRetina målet. Detta ger:

• Grundläggande nätverksmått på nodnivå: Viktig synlighet för nätverkstrafik på nodnivå
• Prometheus-standardmål: Mått för nätverksobservabilitet som automatiskt skrapas av Azure Monitor
• Azure Monitor-integrering: Sömlös integrering med Azure Monitor; mått samlas in automatiskt och kan visualiseras i Grafana
• Ingen ytterligare installation krävs: Aktiveras automatiskt när Azure Monitor-hanterad Prometheus har konfigurerats
• Microsoft-support: Stöds som en del av Azure Monitor och AKS

Obs! Detta kräver att Azure Monitor-hanterad tjänst för Prometheus aktiveras i AKS-klustret, vilket kan ha associerade kostnader.

Komma igång: Aktivera Azure Monitor-hanterad tjänst för Prometheus i ditt AKS-kluster via Azure-portalen eller CLI. Mått för nätverksobservabilitet samlas in automatiskt och är tillgängliga för visualisering i Azure Managed Grafana.

Nätverksobservabilitet med Retina OSS

Även om Advanced Container Networking Services (ACNS) är ett betalerbjudande som tillhandahåller omfattande funktioner för nätverksobservabilitet, stöder Microsoft även nätverksobservabilitet med Retina OSS, en plattform för nätverksobservabilitet med öppen källkod som tillhandahåller viktiga funktioner för nätverksövervakning.

Retina OSS är den plattform för observerbarhet med öppen källkod som finns tillgänglig på retina.sh och GitHub. Den innehåller:

• eBPF-baserad nätverksobservabilitet: Använder eBPF-tekniker för att samla in insikter med minimala omkostnader
• Djup trafikanalys med Kubernetes-kontext: Omfattande avbildning och analys av nätverkstrafikflöden med fullständig Kubernetes-integrering
• Avancerad insamling av mått: Layer 4-mått, DNS-mått och funktioner för distribuerad paketinsamling
• Utökningsbarhet baserad på plugin-program: Anpassa och utöka funktioner via en plugin-arkitektur
• Prometheus-kompatibla mått: Exportera omfattande nätverksmått i Prometheus-format med konfigurerbara måttlägen
• Distribuerad paketinsamling: Paketinsamlingar på begäran över flera noder för djup felsökning
• Plattforms- och CNI-agnostik: Fungerar med alla Kubernetes-kluster (AKS, Arc-aktiverade, lokala), alla operativsystem (Linux/Windows) och alla CNI
• Community-stöd: Öppen källkod med communitybaserat stöd och bidrag
• Självhanterad: Fullständig kontroll över distribution och konfiguration
• Hubble-integrering: Integreras med Ciliums Hubble för ytterligare nätverksinsikter

Komma igång: Distribuera Retina OSS med hjälp av Helm-diagram eller Kubernetes-manifest från den officiella Retina-lagringsplatsen. Konfigurera Prometheus och Grafana för att visualisera mått, konfigurera djuptrafikanalys med Kubernetes-kontext, aktivera distribuerad paketinsamling för avancerad felsökning och anpassa funktioner med hjälp av plugin-baserad arkitektur för specifika användningsfall.

Jämförelse av erbjudanden om nätverksobservabilitet

Lära sig mer

Advanced Container Networking Services (ACNS)

• Plattformsöversikt:Vad är Advanced Container Networking Services för AKS?
• Konfigurera observerbarhet:Konfigurera containernätverksobservabilitet
• Mått för containernätverk:Översikt över nätverksmått för containrar
• Containernätverksloggar:Översikt över containernätverksloggar och Konfigurera containernätverksloggar
• Måttfiltrering (Cilium):Konfigurera filtrering av containernätverksmått

AI-baserad diagnostik

• Container Network Insights Agent (förhandsversion):Översikt och Konfigurera agenten
• AKS MCP-server:AKS Model Context Protocol-server

Container-nätsäkerhet (Cilium)

• FQDN-filtrering:Begrepp och Tillämpa FQDN-filtreringsprinciper
• Layer 7-princip:Begrepp och Tillämpa L7-principer
• Ömsesidig TLS (Cilium):Begrepp och konfigurera ömsesidig TLS
• Kryptering under överföring:WireGuard-krypteringsbegrepp

Dataplan och plattform

• Azure CNI som drivs av Cilium:Konfigurera Azure CNI som drivs av Cilium
• Prestanda för eBPF-värddirigering:Prestanda för containernätverk med eBPF-värddirigering
• Log Analytics tabellplaner:Välj en tabellplan baserat på dataanvändning

Verktyg med öppen källkod

• Retina:retina.sh och lagringsplatsen Microsoft Retina GitHub
• Hubble (Cilium-projekt):Dokumentation om Hubble