Konfigurera containernätverksobservabilitet för Azure Kubernetes Service (AKS) – Azure-hanterad Prometheus och Grafana

Den här artikeln visar hur du konfigurerar containernätverksobservabilitet för Azure Kubernetes Service (AKS) med hjälp av Managed Prometheus och Grafana och BYO Prometheus och Grafana samt visualiserar de skrapade måtten

Du kan använda Container Network Observability för att samla in data om nätverkstrafiken i dina AKS-kluster. Det möjliggör en centraliserad plattform för övervakning av program och nätverkshälsa. För närvarande lagras mått i Prometheus och Grafana kan användas för att visualisera dem. Container Network Observability erbjuder också möjligheten att aktivera Hubble. Dessa funktioner stöds för både Cilium- och icke-Cilium-kluster.

Container Network Observability är en av funktionerna i Advanced Container Networking Services. Mer information om Advanced Container Networking Services för Azure Kubernetes Service (AKS) finns i Vad är Advanced Container Networking Services för Azure Kubernetes Service (AKS)?.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Om du inte har ett konto kan du skapa ett kostnadsfritt konto innan du börjar.

• Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Snabbstart för Bash i Azure Cloud Shell.

  

• Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör i Windows eller macOS kan du köra Azure CLI i en Docker-container. Mer information finns i Så här kör du Azure CLI i en Docker-container.

  • Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Andra inloggningsalternativ finns i Logga in med Azure CLI.

  • När du uppmanas att installera Azure CLI-tillägget vid första användningen. Mer information om tillägg finns i Använda tillägg med Azure CLI.

  • Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

• Den lägsta versionen av Azure CLI som krävs för stegen i den här artikeln är 2.56.0. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

Installera Azure CLI-tillägget aks-preview

Installera eller uppdatera azure CLI-förhandsgranskningstillägget az extension add med hjälp av kommandot eller az extension update .

# Install the aks-preview extension
az extension add --name aks-preview

# Update the extension to make sure you have the latest version installed
az extension update --name aks-preview

Aktivera avancerade containernätverkstjänster

För att kunna fortsätta måste du ha ett AKS-kluster med Advanced Container Networking Services aktiverat.

Kommandot az aks create med flaggan Advanced Container Networking Services, --enable-acns, skapar ett nytt AKS-kluster med alla funktioner i Advanced Container Networking Services. Dessa funktioner omfattar:

• Observerbarhet för containernätverk: Ger insikter om din nätverkstrafik. Mer information finns i Container Network Observability (Observerbarhet för containernätverk).

• Säkerhet för containernätverk: Erbjuder säkerhetsfunktioner som FQDN-filtrering. Mer information finns i Container Network Security.

Cilium

Kommentar

Kluster med Cilium-dataplanet stöder containernätverksobservabilitet och containernätverkssäkerhet från och med Kubernetes version 1.29.

# Set an environment variable for the AKS cluster name. Make sure to replace the placeholder with your own value.
export CLUSTER_NAME="<aks-cluster-name>"

# Create an AKS cluster
az aks create \
    --name $CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP \
    --generate-ssh-keys \
    --location eastus \
    --max-pods 250 \
    --network-plugin azure \
    --network-plugin-mode overlay \
    --network-dataplane cilium \
    --node-count 2 \
    --pod-cidr 192.168.0.0/16 \
    --kubernetes-version 1.29 \
    --enable-acns

Icke-Cilium

Kommentar

Container Network Security-funktionen är inte tillgänglig för icke-ciliumkluster

# Set an environment variable for the AKS cluster name. Make sure to replace the placeholder with your own value.
export CLUSTER_NAME="<aks-cluster-name>"

# Create an AKS cluster
az aks create \
    --name $CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP \
    --generate-ssh-keys \
    --network-plugin azure \
    --network-plugin-mode overlay \
    --pod-cidr 192.168.0.0/16 \
    --enable-acns

Aktivera Advanced Container Networking Services i ett befintligt kluster

Kommandot az aks update med flaggan Advanced Container Networking Services uppdaterar --enable-acnsett befintligt AKS-kluster med alla avancerade funktioner för containernätverkstjänster som innehåller containernätverksobservabilitet och funktionen Container Network Security .

Kommentar

Endast kluster med Cilium-dataplanet stöder funktioner för containernätverkssäkerhet i Advanced Container Networking Services.

az aks update \
    --resource-group $RESOURCE_GROUP \
    --name $CLUSTER_NAME \
    --enable-acns

---

Hämta klusterautentiseringsuppgifter

När du har hämtat autentiseringsuppgifterna för az aks get-credentials klustret med kommandot .

az aks get-credentials --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

Azure-hanterad Prometheus och Grafana

Hoppa över det här avsnittet om du använder BYO Prometheus och Grafana

Använd följande exempel för att installera och aktivera Prometheus och Grafana för ditt AKS-kluster.

Skapa Azure Monitor-resurs

#Set an environment variable for the Grafana name. Make sure to replace the placeholder with your own value.
export AZURE_MONITOR_NAME="<azure-monitor-name>"

# Create Azure monitor resource
az resource create \
    --resource-group $RESOURCE_GROUP \
    --namespace microsoft.monitor \
    --resource-type accounts \
    --name $AZURE_MONITOR_NAME \
    --location eastus \
    --properties '{}'

Skapa Azure Managed Grafana-instans

Använd az grafana create för att skapa en Grafana-instans. Namnet på Grafana-instansen måste vara unikt.

# Set an environment variable for the Grafana name. Make sure to replace the placeholder with your own value.
export GRAFANA_NAME="<grafana-name>"

# Create Grafana instance
az grafana create \
    --name $GRAFANA_NAME \
    --resource-group $RESOURCE_GROUP 

Placera resurs-ID:t för Azure Managed Grafana och Azure Monitor i variabler

Använd az grafana show för att placera Grafana-resurs-ID:t i en variabel. Använd az resource show för att placera Azure Monitor-resurs-ID:t i en variabel. Ersätt myGrafana med namnet på grafanainstansen.

grafanaId=$(az grafana show \
                --name $GRAFANA_NAME \
                --resource-group $RESOURCE_GROUP \
                --query id \
                --output tsv)
azuremonitorId=$(az resource show \
                    --resource-group $RESOURCE_GROUP \
                    --name $AZURE_MONITOR_NAME \
                    --resource-type "Microsoft.Monitor/accounts" \
                    --query id \
                    --output tsv)

Länka Azure Monitor och Azure Managed Grafana till AKS-klustret

Använd az aks update för att länka Azure Monitor- och Grafana-resurserna till ditt AKS-kluster.

az aks update \
    --name $CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP \
    --enable-azure-monitor-metrics \
    --azure-monitor-workspace-resource-id $azuremonitorId \
    --grafana-resource-id $grafanaId

Visualisering

Visualisering med Azure Managed Grafana

Hoppa över det här steget om du använder BYO Grafana

Kommentar

Måttet hubble_flows_processed_total skrapas inte som standard på grund av hög mått kardinalitet i storskaliga kluster. Därför har poddflödenas instrumentpaneler paneler med data som saknas. Om du vill ändra detta kan du ändra ama-måttinställningarna så att de inkluderas hubble_flows_processed_total i listan över måttförstållar. Information om hur du gör detta finns i Doumentation för minimal inmatning.

1. Kontrollera att Azure Monitor-poddarna körs med kommandot kubectl get pods .

   kubectl get pods -o wide -n kube-system | grep ama-
   

   Dina utdata bör se ut ungefär som följande exempelutdata:

   ama-metrics-5bc6c6d948-zkgc9          2/2     Running   0 (21h ago)   26h
   ama-metrics-ksm-556d86b5dc-2ndkv      1/1     Running   0 (26h ago)   26h
   ama-metrics-node-lbwcj                2/2     Running   0 (21h ago)   26h
   ama-metrics-node-rzkzn                2/2     Running   0 (21h ago)   26h
   ama-metrics-win-node-gqnkw            2/2     Running   0 (26h ago)   26h
   ama-metrics-win-node-tkrm8            2/2     Running   0 (26h ago)   26h
   

2. Vi har skapat exempelinstrumentpaneler. De finns under mappen Instrumentpaneler > i Azure Managed Prometheus . De har namn som "Kubernetes/ Networking / <name>". Sviten med instrumentpaneler innehåller:

   • Kluster: visar mått på nodnivå för dina kluster.
   • DNS (kluster): visar DNS-mått i ett kluster eller val av noder.
   • DNS (Arbetsbelastning): visar DNS-mått för den angivna arbetsbelastningen (t.ex. poddar för en DaemonSet eller distribution, till exempel CoreDNS).
   • Drops (Workload): visar droppar till/från den angivna arbetsbelastningen (t.ex. poddar för en distribution eller DaemonSet).
   • Poddflöden (namnområde): visar L4/L7-paketflöden till/från det angivna namnområdet (dvs. poddar i namnområdet).
   • Poddflöden (arbetsbelastning): visar L4/L7-paketflöden till/från den angivna arbetsbelastningen (t.ex. poddar i en distribution eller DaemonSet).

Visualisering med BYO Grafana

Hoppa över det här steget om du använder Azure-hanterad Grafana

1. Lägg till följande skrapjobb i din befintliga Prometheus-konfiguration och starta om Prometheus-servern:

   - job_name: networkobservability-hubble
     kubernetes_sd_configs:
       - role: pod
     relabel_configs:
       - target_label: cluster
         replacement: myAKSCluster
         action: replace
       - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_pod_label_k8s_app]
         regex: kube-system;(retina|cilium)
         action: keep
       - source_labels: [__address__]
         action: replace
         regex: ([^:]+)(?::\d+)?
         replacement: $1:9965
         target_label: __address__
       - source_labels: [__meta_kubernetes_pod_node_name]
         target_label: instance
         action: replace
     metric_relabel_configs:
       - source_labels: [__name__]
         regex: '|hubble_dns_queries_total|hubble_dns_responses_total|hubble_drop_total|hubble_tcp_flags_total' # if desired, add |hubble_flows_processed_total
         action: keep
   

2. I Mål för Prometheus kontrollerar du att nätverks-obs-poddar finns.

3. Logga in på Grafana och importera följande exempelinstrumentpaneler med hjälp av följande ID:n:

   • Kluster: visar mått på nodnivå för dina kluster. (ID: 18814)
   • DNS (Kluster): visar DNS-mått i ett kluster eller val av noder.( ID: 20925)
   • DNS (Arbetsbelastning): visar DNS-mått för den angivna arbetsbelastningen (t.ex. poddar för en DaemonSet eller distribution, till exempel CoreDNS). (ID: [20926] https://grafana.com/grafana/dashboards/20926-kubernetes-networking-dns-workload/)
   • Drops (Workload): visar droppar till/från den angivna arbetsbelastningen (t.ex. poddar för en distribution eller DaemonSet).( ID: 20927).
   • Poddflöden (namnområde): visar L4/L7-paketflöden till/från det angivna namnområdet (dvs. poddar i namnområdet). (ID: 20928)
   • Poddflöden (arbetsbelastning): visar L4/L7-paketflöden till/från den angivna arbetsbelastningen (t.ex. poddar för en distribution eller daemonSet).( ID: 20929)

   Kommentar

   • Beroende på dina Inställningar för Prometheus/Grafana-instanser kan vissa instrumentpaneler kräva justeringar för att visa alla data.
   • Cilium stöder för närvarande inte DNS-mått/instrumentpaneler.

Installera Hubble CLI

Installera Hubble CLI för att komma åt de data som samlas in med hjälp av följande kommandon:

# Set environment variables
export HUBBLE_VERSION=v1.16.3
export HUBBLE_ARCH=amd64

#Install Hubble CLI
if [ "$(uname -m)" = "aarch64" ]; then HUBBLE_ARCH=arm64; fi
curl -L --fail --remote-name-all https://github.com/cilium/hubble/releases/download/$HUBBLE_VERSION/hubble-linux-${HUBBLE_ARCH}.tar.gz{,.sha256sum}
sha256sum --check hubble-linux-${HUBBLE_ARCH}.tar.gz.sha256sum
sudo tar xzvfC hubble-linux-${HUBBLE_ARCH}.tar.gz /usr/local/bin
rm hubble-linux-${HUBBLE_ARCH}.tar.gz{,.sha256sum}

Visualisera Hubble-flödena

1. Kontrollera att Hubble-poddarna körs med kommandot kubectl get pods .

   kubectl get pods -o wide -n kube-system -l k8s-app=hubble-relay
   

   Dina utdata bör se ut ungefär som följande exempelutdata:

   hubble-relay-7ddd887cdb-h6khj     1/1  Running     0       23h 
   

2. Porta vidare Hubble Relay med kommandot kubectl port-forward .

   kubectl port-forward -n kube-system svc/hubble-relay --address 127.0.0.1 4245:443
   

3. Ömsesidig TLS (mTLS) säkerställer säkerheten för Hubble Relay-servern. Om du vill att Hubble-klienten ska kunna hämta flöden måste du hämta lämpliga certifikat och konfigurera klienten med dem. Använd certifikaten med hjälp av följande kommandon:

   #!/usr/bin/env bash
   
   set -euo pipefail
   set -x
   
   # Directory where certificates will be stored
   CERT_DIR="$(pwd)/.certs"
   mkdir -p "$CERT_DIR"
   
   declare -A CERT_FILES=(
     ["tls.crt"]="tls-client-cert-file"
     ["tls.key"]="tls-client-key-file"
     ["ca.crt"]="tls-ca-cert-files"
   )
   
   for FILE in "${!CERT_FILES[@]}"; do
     KEY="${CERT_FILES[$FILE]}"
     JSONPATH="{.data['${FILE//./\\.}']}"
   
     # Retrieve the secret and decode it
     kubectl get secret hubble-relay-client-certs -n kube-system \
       -o jsonpath="${JSONPATH}" | \
       base64 -d > "$CERT_DIR/$FILE"
   
     # Set the appropriate hubble CLI config
     hubble config set "$KEY" "$CERT_DIR/$FILE"
   done
   
   hubble config set tls true
   hubble config set tls-server-name instance.hubble-relay.cilium.io
   

4. Kontrollera att hemligheterna genererades med hjälp av följande kubectl get secrets kommando:

   kubectl get secrets -n kube-system | grep hubble-
   

   Dina utdata bör se ut ungefär som följande exempelutdata:

   kube-system     hubble-relay-client-certs     kubernetes.io/tls     3     9d
   
   kube-system     hubble-relay-server-certs     kubernetes.io/tls     3     9d
   
   kube-system     hubble-server-certs           kubernetes.io/tls     3     9d    
   

5. Kontrollera att Hubble Relay-podden körs med kommandot hubble observe .

   hubble observe --pod hubble-relay-7ddd887cdb-h6khj
   

Visualisera med hjälp av Användargränssnittet för Hubble

1. Om du vill använda Användargränssnittet för Hubble sparar du följande i hubble-ui.yaml

   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: hubble-ui
     namespace: kube-system
   ---
   kind: ClusterRole
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: hubble-ui
     labels:
       app.kubernetes.io/part-of: retina
   rules:
     - apiGroups:
         - networking.k8s.io
       resources:
         - networkpolicies
       verbs:
         - get
         - list
         - watch
     - apiGroups:
         - ""
       resources:
         - componentstatuses
         - endpoints
         - namespaces
         - nodes
         - pods
         - services
       verbs:
         - get
         - list
         - watch
     - apiGroups:
         - apiextensions.k8s.io
       resources:
         - customresourcedefinitions
       verbs:
         - get
         - list
         - watch
     - apiGroups:
         - cilium.io
       resources:
         - "*"
       verbs:
         - get
         - list
         - watch
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: hubble-ui
     labels:
       app.kubernetes.io/part-of: retina
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: hubble-ui
   subjects:
     - kind: ServiceAccount
       name: hubble-ui
       namespace: kube-system
   ---
   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: hubble-ui-nginx
     namespace: kube-system
   data:
     nginx.conf: |
       server {
           listen       8081;
           server_name  localhost;
           root /app;
           index index.html;
           client_max_body_size 1G;
           location / {
               proxy_set_header Host $host;
               proxy_set_header X-Real-IP $remote_addr;
               # CORS
               add_header Access-Control-Allow-Methods "GET, POST, PUT, HEAD, DELETE, OPTIONS";
               add_header Access-Control-Allow-Origin *;
               add_header Access-Control-Max-Age 1728000;
               add_header Access-Control-Expose-Headers content-length,grpc-status,grpc-message;
               add_header Access-Control-Allow-Headers range,keep-alive,user-agent,cache-control,content-type,content-transfer-encoding,x-accept-content-transfer-encoding,x-accept-response-streaming,x-user-agent,x-grpc-web,grpc-timeout;
               if ($request_method = OPTIONS) {
                   return 204;
               }
               # /CORS
               location /api {
                   proxy_http_version 1.1;
                   proxy_pass_request_headers on;
                   proxy_hide_header Access-Control-Allow-Origin;
                   proxy_pass http://127.0.0.1:8090;
               }
               location / {
                   try_files $uri $uri/ /index.html /index.html;
               }
               # Liveness probe
               location /healthz {
                   access_log off;
                   add_header Content-Type text/plain;
                   return 200 'ok';
               }
           }
       }
   ---
   kind: Deployment
   apiVersion: apps/v1
   metadata:
     name: hubble-ui
     namespace: kube-system
     labels:
       k8s-app: hubble-ui
       app.kubernetes.io/name: hubble-ui
       app.kubernetes.io/part-of: retina
   spec:
     replicas: 1
     selector:
       matchLabels:
         k8s-app: hubble-ui
     template:
       metadata:
         labels:
           k8s-app: hubble-ui
           app.kubernetes.io/name: hubble-ui
           app.kubernetes.io/part-of: retina
       spec:
         serviceAccountName: hubble-ui
         automountServiceAccountToken: true
         containers:
         - name: frontend
           image: mcr.microsoft.com/oss/cilium/hubble-ui:v0.12.2   
           imagePullPolicy: Always
           ports:
           - name: http
             containerPort: 8081
           livenessProbe:
             httpGet:
               path: /healthz
               port: 8081
           readinessProbe:
             httpGet:
               path: /
               port: 8081
           resources: {}
           volumeMounts:
           - name: hubble-ui-nginx-conf
             mountPath: /etc/nginx/conf.d/default.conf
             subPath: nginx.conf
           - name: tmp-dir
             mountPath: /tmp
           terminationMessagePolicy: FallbackToLogsOnError
           securityContext: {}
         - name: backend
           image: mcr.microsoft.com/oss/cilium/hubble-ui-backend:v0.12.2
           imagePullPolicy: Always
           env:
           - name: EVENTS_SERVER_PORT
             value: "8090"
           - name: FLOWS_API_ADDR
             value: "hubble-relay:443"
           - name: TLS_TO_RELAY_ENABLED
             value: "true"
           - name: TLS_RELAY_SERVER_NAME
             value: ui.hubble-relay.cilium.io
           - name: TLS_RELAY_CA_CERT_FILES
             value: /var/lib/hubble-ui/certs/hubble-relay-ca.crt
           - name: TLS_RELAY_CLIENT_CERT_FILE
             value: /var/lib/hubble-ui/certs/client.crt
           - name: TLS_RELAY_CLIENT_KEY_FILE
             value: /var/lib/hubble-ui/certs/client.key
           livenessProbe:
             httpGet:
               path: /healthz
               port: 8090
           readinessProbe:
             httpGet:
               path: /healthz
               port: 8090
           ports:
           - name: grpc
             containerPort: 8090
           resources: {}
           volumeMounts:
           - name: hubble-ui-client-certs
             mountPath: /var/lib/hubble-ui/certs
             readOnly: true
           terminationMessagePolicy: FallbackToLogsOnError
           securityContext: {}
         nodeSelector:
           kubernetes.io/os: linux 
         volumes:
         - configMap:
             defaultMode: 420
             name: hubble-ui-nginx
           name: hubble-ui-nginx-conf
         - emptyDir: {}
           name: tmp-dir
         - name: hubble-ui-client-certs
           projected:
             defaultMode: 0400
             sources:
             - secret:
                 name: hubble-relay-client-certs
                 items:
                   - key: tls.crt
                     path: client.crt
                   - key: tls.key
                     path: client.key
                   - key: ca.crt
                     path: hubble-relay-ca.crt
   ---
   kind: Service
   apiVersion: v1
   metadata:
     name: hubble-ui
     namespace: kube-system
     labels:
       k8s-app: hubble-ui
       app.kubernetes.io/name: hubble-ui
       app.kubernetes.io/part-of: retina
   spec:
     type: ClusterIP
     selector:
       k8s-app: hubble-ui
     ports:
       - name: http
         port: 80
         targetPort: 8081
   

2. Använd manifestet hubble-ui.yaml på klustret med hjälp av följande kommando

   kubectl apply -f hubble-ui.yaml
   

3. Konfigurera portvidarebefordring för Hubble-användargränssnittet kubectl port-forward med kommandot .

   kubectl -n kube-system port-forward svc/hubble-ui 12000:80
   

4. Få åtkomst till Användargränssnittet för Hubble genom att gå in http://localhost:12000/ i webbläsaren.

---

Rensa resurser

Om du inte planerar att använda det här programmet tar du bort de andra resurser som du skapade i den här artikeln med hjälp av az group delete kommandot .

  az group delete --name $RESOURCE_GROUP

Nästa steg

I den här artikeln har du lärt dig hur du installerar och aktiverar containernätverksobservabilitet för ditt AKS-kluster.

• Mer information om Advanced Container Networking Services för Azure Kubernetes Service (AKS) finns i Vad är Advanced Container Networking Services för Azure Kubernetes Service (AKS)?.

• Mer information om containernätverkssäkerhet och dess funktioner finns i Vad är containernätverkssäkerhet?.