Einrichten von Advanced Network Observability für Azure Kubernetes Service (AKS) – von Azure verwaltete Prometheus- und Grafana-Instanzen (Vorschau)

Artikel
08/02/2024

In diesem Artikel erfahren Sie, wie Sie Advanced Network Observability für Azure Kubernetes Service (AKS) mit verwalteten Prometheus- und Grafana-Instanzen einrichten, um die ausgelesenen Metriken zu visualisieren.

Mit Advanced Network Observability können Sie Daten über den Netzwerkdatenverkehr Ihrer AKS-Cluster sammeln. Eine zentrale Plattform für die Überwachung der Anwendungs- und Netzwerkintegrität wird aktiviert. Derzeit werden Metriken in Prometheus gespeichert, und Grafana kann verwendet werden, um sie zu visualisieren. Advanced Network Observability bietet auch die Möglichkeit, Hubble zu aktivieren. Diese Funktionen werden sowohl für Cilium- als auch für Nicht-Cilium-Cluster unterstützt.

Advanced Network Observability ist eine der Funktionen von Erweiterte Container-Netzwerkdienste. Weitere Informationen zu Erweiterte Container-Netzwerkdienste für Azure Kubernetes Service (AKS) finden Sie unter Was ist Erweiterte Container-Netzwerkdienste für Azure Kubernetes Service (AKS)?.

Wichtig

Advanced Network Observability befindet sich derzeit in der VORSCHAU. Die zusätzlichen Nutzungsbestimmungen für Microsoft Azure-Vorschauen enthalten rechtliche Bedingungen. Sie gelten für diejenigen Azure-Features, die sich in der Beta- oder Vorschauversion befinden oder aber anderweitig noch nicht zur allgemeinen Verfügbarkeit freigegeben sind.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Sollten Sie kein Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Verwenden Sie die Bash-Umgebung in Azure Cloud Shell. Weitere Informationen finden Sie unter Schnellstart für Bash in Azure Cloud Shell.
Wenn Sie CLI-Referenzbefehle lieber lokal ausführen, installieren Sie die Azure CLI. Wenn Sie Windows oder macOS ausführen, sollten Sie die Azure CLI in einem Docker-Container ausführen. Weitere Informationen finden Sie unter Ausführen der Azure CLI in einem Docker-Container.
- Wenn Sie eine lokale Installation verwenden, melden Sie sich mithilfe des Befehls az login bei der Azure CLI an. Führen Sie die in Ihrem Terminal angezeigten Schritte aus, um den Authentifizierungsprozess abzuschließen. Informationen zu anderen Anmeldeoptionen finden Sie unter Anmelden mit der Azure CLI.
- Installieren Sie die Azure CLI-Erweiterung beim ersten Einsatz, wenn Sie dazu aufgefordert werden. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden von Erweiterungen mit der Azure CLI.
- Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um das Upgrade auf die aktuelle Version durchzuführen.

Für die Schritte in diesem Artikel ist die Azure CLI mindestens in Version 2.56.0 erforderlich. Führen Sie az --version aus, um die Version zu ermitteln. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI.

Installieren der Azure CLI-Erweiterung `aks-preview`

Installieren oder aktualisieren Sie die Azure CLI-Vorschauerweiterung mithilfe des Befehls az extension add oder 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

Registrieren des `AdvancedNetworkingPreview`-Featureflags

Registrieren Sie das Featureflag az feature register --namespace "Microsoft.ContainerService" --name "AdvancedNetworkingPreview" mithilfe des Befehls az feature register.

az feature register --namespace "Microsoft.ContainerService" --name "AdvancedNetworkingPreview"

Überprüfen Sie mit dem Befehl az feature show, ob die Registrierung erfolgreich war. Es dauert einige Minuten, bis die Registrierung abgeschlossen ist.

az feature show --namespace "Microsoft.ContainerService" --name "AdvancedNetworkingPreview"

Sobald die Funktion Registered anzeigt, aktualisieren Sie die Registrierung des Ressourcenanbieters Microsoft.ContainerService mit dem Befehl az provider register.

Erstellen einer Ressourcengruppe

Eine Ressourcengruppe ist ein logischer Container, in dem Azure-Ressourcen bereitgestellt und verwaltet werden. Erstellen Sie mit dem Befehl az group create eine Ressourcengruppe.

# Set environment variables for the resource group name and location. Make sure to replace the placeholders with your own values.
export RESOURCE_GROUP="<resource-group-name>"
export LOCATION="<azure-region>"

# Create a resource group
az group create --name $RESOURCE_GROUP --location $LOCATION

Erstellen eines AKS-Clusters mit Advanced Network Observability

Non-Cilium
Cilium

Erstellen Sie einen AKS-Cluster mit Advanced Network Observability mit einer Nicht-Cilium-Datenebene mit dem Befehl az aks create und dem Flag --enable-advanced-networking-observability.

# 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-advanced-network-observability

Erstellen Sie einen AKS-Cluster mit Advanced Network Observability mit einer Cilium-Datenebene mit dem Befehl az aks create und dem Flag --enable-advanced-networking-observability.

Hinweis

Cluster mit der Cilium-Datenebene unterstützen Advanced Network Observability ab 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-advanced-network-observability

Aktivieren von Advanced Network Observability in einem vorhandenen Cluster

Aktivieren Sie Advanced Network Observability in einem vorhandenen Cluster mit dem Befehl az aks update.

Hinweis

Cluster mit der Cilium-Datenebene unterstützen Advanced Network Observability ab Kubernetes-Version 1.29.

az aks update \
    --resource-group $RESOURCE_GROUP \
    --name $CLUSTER_NAME \
    --enable-advanced-network-observability

Abrufen von Clusteranmeldeinformationen

Rufen Sie Ihre Clusteranmeldeinformationen mithilfe des Befehls az aks get-credentials ab.

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

Von Azure verwaltetes Prometheus und Grafana

Verwenden Sie das folgende Beispiel, um Prometheus und Grafana für Ihren AKS-Cluster zu installieren und zu aktivieren.

Erstellen einer Azure Monitor-Ressource

#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 '{}'

Erstellen einer Grafana-Instanz

Verwenden Sie az grafana create, um eine Grafana-Instanz zu erstellen. Der Name der Grafana-Instanz muss eindeutig sein.

# 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

Platzieren der Grafana- und Azure Monitor-Ressourcen-IDs in Variablen

Verwenden Sie az grafana show, um die Grafana-Ressourcen-ID in einer Variablen zu platzieren. Verwenden Sie az resource show, um die Azure Monitor-Ressourcen-ID in einer Variablen zu platzieren. Ersetzen Sie myGrafana durch den Namen Ihrer Grafana-Instanz.

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)

Verknüpfen von Azure Monitor und Grafana mit dem AKS-Cluster

Verwenden Sie az aks update, um die Azure Monitor- und Grafana-Ressourcen mit Ihrem AKS-Cluster zu verknüpfen.

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

Visualisierung mithilfe von Grafana

Hinweis

Die Metrik hubble_flows_processed_total wird aufgrund der hohen Kardinalität der Metrik in großen Clustern standardmäßig nicht ausgelesen. Aus diesem Grund enthalten die Dashboards zu Podsdatenflüssen Bereiche mit fehlenden Daten. Um dies zu ändern, können Sie die ama-Metrikeinstellungen so bearbeiten, dass hubble_flows_processed_total in die Positivliste der Metriken aufgenommen wird. Informationen dazu finden Sie in der Dokumentation zur minimalen Erfassung.

Stellen Sie mit dem Befehl kubectl get pods sicher, dass die Azure Monitor-Pods ausgeführt werden.

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

Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

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

Wir haben Beispieldashboards erstellt. Sie finden Sie im Ordner Dashboards > Azure Managed Prometheus. Sie haben Namen wie „Kubernetes / Networking / <name>“. Die Suite von Dashboards umfasst:
- Cluster: zeigt Metriken auf Knotenebene für Ihre Cluster an.
- DNS (Cluster): zeigt DNS-Metriken für einen Cluster oder eine Auswahl von Knoten an.
- DNS (Workload): zeigt DNS-Metriken für die angegebene Workload an (z. B. Pods eines DaemonSet oder einer Bereitstellung wie CoreDNS).
- Drops (Workload): zeigt Drops zu/von der angegebenen Workload an (z. B. Pods einer Bereitstellung oder eines DaemonSet).
- Poddatenflüsse (Namespace): zeigt L4/L7-Paketdatenflüsse in den / aus dem angegebenen Namespace an (d. h. Pods im Namespace).
- Poddatenflüsse (Workload):zeigt L4/L7-Paketdatenflüsse zu/von der angegebenen Workload an (z. B. Pods einer Bereitstellung oder eines DaemonSet).

Hinweis

Die Cilium-Datenebene unterstützt derzeit keine DNS-Metriken/Dashboards.

Installieren von Hubble CLI

Installieren Sie die Hubble CLI, um auf die davon gesammelten Daten zuzugreifen, indem Sie die folgenden Befehle verwenden:

# Set environment variables
export HUBBLE_VERSION=v0.11.0
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}

Visualisieren der Hubble-Datenflüsse

Stellen Sie mit dem Befehl kubectl get pods sicher, dass die Hubble-Pods ausgeführt werden.
```
kubectl get pods -o wide -n kube-system -l k8s-app=hubble-relay
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
hubble-relay-7ddd887cdb-h6khj     1/1  Running     0       23h 
```
Führen Sie mit dem Befehl kubectl port-forward eine Portweiterleitung für Hubble Relay durch.
```
kubectl port-forward -n kube-system svc/hubble-relay --address 127.0.0.1 4245:443
```

Mutual TLS (mTLS) stellt die Sicherheit des Hubble Relay-Servers sicher. Um den Hubble-Client zum Abrufen von Datenflüssen zu aktivieren, müssen Sie die entsprechenden Zertifikate abrufen und den Client mit diesen konfigurieren. Wenden Sie die Zertifikate mit den folgenden Befehlen an:

#!/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

Überprüfen Sie, ob die Geheimnisse mit dem folgenden kubectl get secrets-Befehl generiert wurden:

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

Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

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

Stellen Sie mit dem Befehl hubble observe sicher, dass der Hubble Relay-Pod ausgeführt wird.
```
hubble observe --pod hubble-relay-7ddd887cdb-h6khj
```

Visualisieren mithilfe von Hubble UI

Um Hubble UI zu verwenden, speichern Sie Folgendes in „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:
      serviceAccount: hibble-ui
      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

Wenden Sie das Manifest „hubble-ui.yaml“ mithilfe des folgenden Befehls auf Ihren Cluster an:
```
kubectl apply -f hubble-ui.yaml
```
Richten Sie die Portweiterleitung für Hubble UI mithilfe des Befehls kubectl port-forward ein.
```
kubectl -n kube-system port-forward svc/hubble-ui 12000:80
```
Greifen Sie auf Hubble UI zu, indem Sie http://localhost:12000/ in Ihren Webbrowser eingeben.

Bereinigen von Ressourcen

Wenn Sie nicht vorhaben, diese Anwendung zu verwenden, löschen Sie die anderen Ressourcen, die Sie in diesem Artikel erstellt haben, mit dem Befehl az group delete.

  az group delete --name $RESOURCE_GROUP

Nächste Schritte

In diesem Artikel haben Sie erfahren, wie Sie Advanced Network Observability für Ihren AKS-Cluster installieren und aktivieren.

Weitere Informationen zu Erweiterte Container-Netzwerkdienste für Azure Kubernetes Service (AKS) finden Sie unter Was ist Erweiterte Container-Netzwerkdienste für Azure Kubernetes Service (AKS)?.
Informationen zum Erstellen von Advanced Network Observability mit Verwendung eigener Prometheus- und Grafana-Instanzen finden Sie unter Einrichten von Network Observability für Azure Kubernetes Service (AKS) BYO Prometheus und Grafana.

Teilen über

Einrichten von Advanced Network Observability für Azure Kubernetes Service (AKS) – von Azure verwaltete Prometheus- und Grafana-Instanzen (Vorschau)

Voraussetzungen

Installieren der Azure CLI-Erweiterung `aks-preview`

Registrieren des `AdvancedNetworkingPreview`-Featureflags

Erstellen einer Ressourcengruppe

Erstellen eines AKS-Clusters mit Advanced Network Observability

Aktivieren von Advanced Network Observability in einem vorhandenen Cluster

Abrufen von Clusteranmeldeinformationen

Von Azure verwaltetes Prometheus und Grafana

Erstellen einer Azure Monitor-Ressource

Erstellen einer Grafana-Instanz

Platzieren der Grafana- und Azure Monitor-Ressourcen-IDs in Variablen

Verknüpfen von Azure Monitor und Grafana mit dem AKS-Cluster

Visualisierung mithilfe von Grafana

Installieren von Hubble CLI

Visualisieren der Hubble-Datenflüsse

Visualisieren mithilfe von Hubble UI

Bereinigen von Ressourcen

Nächste Schritte

Zusätzliche Ressourcen

Teilen über

Einrichten von Advanced Network Observability für Azure Kubernetes Service (AKS) – von Azure verwaltete Prometheus- und Grafana-Instanzen (Vorschau)

Voraussetzungen

Installieren der Azure CLI-Erweiterung aks-preview

Registrieren des AdvancedNetworkingPreview-Featureflags

Erstellen einer Ressourcengruppe

Erstellen eines AKS-Clusters mit Advanced Network Observability

Aktivieren von Advanced Network Observability in einem vorhandenen Cluster

Abrufen von Clusteranmeldeinformationen

Von Azure verwaltetes Prometheus und Grafana

Erstellen einer Azure Monitor-Ressource

Erstellen einer Grafana-Instanz

Platzieren der Grafana- und Azure Monitor-Ressourcen-IDs in Variablen

Verknüpfen von Azure Monitor und Grafana mit dem AKS-Cluster

Visualisierung mithilfe von Grafana

Installieren von Hubble CLI

Visualisieren der Hubble-Datenflüsse

Visualisieren mithilfe von Hubble UI

Bereinigen von Ressourcen

Nächste Schritte

Zusätzliche Ressourcen

Installieren der Azure CLI-Erweiterung `aks-preview`

Registrieren des `AdvancedNetworkingPreview`-Featureflags