Configuration de l’observabilité avancée du réseau pour Azure Kubernetes Service (AKS) : Grafana et Prometheus gérés par Azure (préversion)

Article
08/02/2024

Cet article explique comment configurer l’observabilité avancée du réseau pour Azure Kubernetes Service (AKS) à l’aide de Grafana et Prometheus gérés pour visualiser les métriques récupérées.

Vous pouvez utiliser l’observabilité avancée du réseau pour collecter des données sur le trafic réseau de vos clusters AKS. Elle active une plateforme centralisée qui surveille l’intégrité des applications et du réseau. Actuellement, les métriques sont stockées dans Prometheus et Grafana peut être utilisé pour les visualiser. L’observabilité réseau avancée offre également la possibilité d’activer Hubble. Ces fonctionnalités sont prises en charge pour les clusters Cilium et non-Cilium.

L’observabilité réseau avancée est l’une des fonctionnalités des services avancés de mise en réseau de conteneurs. Pour plus d’informations sur les services avancés de mise en réseau de conteneurs pour Azure Kubernetes Service (AKS), consultez Que sont les services avancés de mise en réseau de conteneurs pour Azure Kubernetes Service (AKS) ?.

Important

L’observabilité réseau avancée est actuellement en PRÉVERSION. Pour connaître les conditions juridiques qui s’appliquent aux fonctionnalités Azure en version bêta, en préversion ou plus généralement non encore en disponibilité générale, consultez l’Avenant aux conditions d’utilisation des préversions de Microsoft Azure.

Prérequis

Compte Azure avec un abonnement actif. Si vous n’en avez pas, créez un compte gratuit avant de commencer.

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour plus d’informations, consultez Démarrage rapide pour Bash dans Azure Cloud Shell.
Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
- Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour connaître les autres options de connexion, consultez Se connecter avec Azure CLI.
- Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

La version minimale d’Azure CLI requise pour les étapes de cet article est la version 2.56.0. Exécutez az --version pour trouver la version. Si vous devez installer ou mettre à niveau, voir Installer Azure CLI.

Installer l’extension Azure CLI `aks-preview`

Installez ou mettez à jour l’extension Azure CLI en préversion à l’aide de la commande az extension add ou 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

Inscrire l’indicateur de fonctionnalité `AdvancedNetworkingPreview`

Inscrivez l’indicateur de fonctionnalité az feature register --namespace "Microsoft.ContainerService" --name "AdvancedNetworkingPreview" à l’aide de la commande az feature register.

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

Vérifiez que l’inscription a réussi à l’aide de la commande az feature show. L’inscription peut prendre quelques minutes.

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

Une fois que la fonctionnalité affiche Registered, actualisez l’inscription du fournisseur de ressources Microsoft.ContainerService à l’aide de la commande az provider register.

Créer un groupe de ressources

Un groupe de ressources est un conteneur logique dans lequel les ressources Azure sont déployées et gérées. Créez un groupe de ressources avec la commande az group create.

# 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

Créer un cluster AKS avec l’observabilité réseau avancée

Non-Cilium
Cilium

Créez un cluster AKS avec l’observabilité avancée du réseau avec un plan de données non Cilium à l’aide de la commande az aks create et de l’indicateur --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

Créez un cluster AKS avec l’observabilité avancée du réseau avec un plan de données Cilium à l’aide de la commande az aks create et de l’indicateur --enable-advanced-networking-observability.

Remarque

Les clusters avec le plan de données Cilium prennent en charge l’observabilité avancée du réseau à partir de 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

Activer l’observabilité avancée du réseau sur un cluster existant

Activez l’observabilité réseau avancée sur un cluster existant à l’aide de la commande az aks update.

Remarque

Les clusters avec le plan de données Cilium prennent en charge l’observabilité avancée du réseau à partir de Kubernetes version 1.29.

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

Obtenir les informations d’identification du cluster

Obtenez les informations d’identification du cluster à l’aide de la commande az aks get-credentials.

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

Prometheus et Grafana gérés par Azure

Utilisez l’exemple suivant pour installer et activer Prometheus et Grafana pour votre cluster AKS.

Créer une ressource Azure Monitor

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

Créer une instance Grafana

Utilisez la commande az grafana create pour créer un instance Grafana. Le nom de l’instance Grafana doit être unique.

# 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

Placer les ID de ressource Azure Monitor et Grafana dans des variables

Utilisez la commande az grafana show pour placer l’ID de ressource Grafana dans une variable. Utilisez la commande az resource show pour placer l’ID de ressource Azure Monitor dans une variable. Remplacez myGrafana par le nom de votre instance Grafana.

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)

Lier Azure Monitor et Grafana au cluster AKS

Utilisez la commande az aks update pour lier des ressources Azure Monitor et Grafana à votre cluster AKS.

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

Visualisation à l’aide de Grafana

Remarque

La métrique hubble_flows_processed_total n’est pas récupérée par défaut en raison d’une cardinalité de métrique élevée dans les clusters à grande échelle. En raison de cela, les tableaux de bord de Flux de pods ont des panneaux avec des données manquantes. Pour modifier cela, vous pouvez modifier les paramètres des métriques ama pour inclure hubble_flows_processed_total dans la liste des métriques à conserver. Pour savoir comment procéder, consultez la Doumentation sur l’ingestion minimale.

Vérifiez que les pods Azure Monitor s’exécutent à l’aide de la commande kubectl get pods.

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

Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

Nous avons créé des exemples de tableaux de bord. Ils se trouvent sous le dossier Tableaux de bord > Prometheus géré par Azure. Ils ont des noms comme « Kubernetes / Networking / <name>». La suite de tableaux de bord comprend les éléments suivants :
- Clusters : affiche les métriques au niveau du nœud pour vos clusters.
- DNS (Cluster) : affiche les métriques DNS sur un cluster ou une sélection de nœuds.
- DNS (Charge de travail) : affiche les métriques DNS pour la charge de travail spécifiée (par exemple, les pods d’un DaemonSet ou d’un déploiement comme CoreDNS).
- Dépôts (Charge de travail) : affiche les dépôts vers/à partir de la charge de travail spécifiée (par exemple, les pods d’un déploiement ou d’un DaemonSet).
- Flux de pods (Espace de noms) : affiche les flux de paquets L4/L7 vers/à partir de l’espace de noms spécifié (c’est-à-dire les pods dans l’espace de noms).
- Flux de pods (Charge de travail) : affiche les flux de paquets L4/L7 vers/à partir de la charge de travail spécifiée (par exemple, pods d’un déploiement ou d’un DaemonSet).

Remarque

Le plan de données Cilium ne prend actuellement pas en charge les métriques/tableaux de bord DNS.

Installer l’interface CLI Hubble

Installez l’interface CLI Hubble pour accéder aux données collectées à l’aide des commandes suivantes :

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

Visualiser les flux Hubble

Vérifiez que les pods Hubble s’exécutent à l’aide de la commande kubectl get pods.
```
kubectl get pods -o wide -n kube-system -l k8s-app=hubble-relay
```
Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :
```
hubble-relay-7ddd887cdb-h6khj     1/1  Running     0       23h 
```
Transférez le port du relais Hubble à l’aide de la commande kubectl port-forward.
```
kubectl port-forward -n kube-system svc/hubble-relay --address 127.0.0.1 4245:443
```

Le protocole TLS mutuel (mTLS) garantit la sécurité du serveur de relais Hubble. Pour permettre au client Hubble de récupérer les flux, vous devez obtenir les certificats appropriés et configurer le client avec eux. Appliquez les certificats à l’aide des commandes suivantes :

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

Vérifiez que les secrets ont été générés à l’aide de la commande kubectl get secrets suivante :

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

Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

Vérifiez que le pod Hubble Relay est en cours d’exécution à l’aide de la commande hubble observe.
```
hubble observe --pod hubble-relay-7ddd887cdb-h6khj
```

Visualisation à l’aide de l’interface utilisateur Hubble

Pour utiliser l’interface utilisateur Hubble, enregistrez ce qui suit dans 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

Appliquez le manifeste hubble-ui.yaml à votre cluster à l’aide de la commande suivante
```
kubectl apply -f hubble-ui.yaml
```
Configurez le transfert de port pour l’interface utilisateur Hubble à l’aide de la commande kubectl port-forward.
```
kubectl -n kube-system port-forward svc/hubble-ui 12000:80
```
Accédez à l’interface utilisateur Hubble en entrant http://localhost:12000/ dans votre navigateur web.

Nettoyer les ressources

Si vous ne prévoyez pas d’utiliser cette application, supprimez les autres ressources que vous avez créées dans cet article à l’aide de la commande az group delete.

  az group delete --name $RESOURCE_GROUP

Étapes suivantes

Dans ce guide pratique, vous avez appris à installer et à activer l’observabilité réseau avancée pour votre cluster AKS.

Pour plus d’informations sur les services avancés de mise en réseau de conteneurs pour Azure Kubernetes Service (AKS), consultez Que sont les services avancés de mise en réseau de conteneurs pour Azure Kubernetes Service (AKS) ?.
Pour créer une instance d’observabilité avancée du réseau – BYO Prometheus et Grafana, consultez l’article Configurer l’observabilité avancée du réseau pour Azure Kubernetes Service (AKS) – BYO Prometheus et Grafana.

Partager via

Configuration de l’observabilité avancée du réseau pour Azure Kubernetes Service (AKS) : Grafana et Prometheus gérés par Azure (préversion)

Prérequis

Installer l’extension Azure CLI `aks-preview`

Inscrire l’indicateur de fonctionnalité `AdvancedNetworkingPreview`

Créer un groupe de ressources

Créer un cluster AKS avec l’observabilité réseau avancée

Activer l’observabilité avancée du réseau sur un cluster existant

Obtenir les informations d’identification du cluster

Prometheus et Grafana gérés par Azure

Créer une ressource Azure Monitor

Créer une instance Grafana

Placer les ID de ressource Azure Monitor et Grafana dans des variables

Lier Azure Monitor et Grafana au cluster AKS

Visualisation à l’aide de Grafana

Installer l’interface CLI Hubble

Visualiser les flux Hubble

Visualisation à l’aide de l’interface utilisateur Hubble

Nettoyer les ressources

Étapes suivantes

Ressources supplémentaires

Partager via

Configuration de l’observabilité avancée du réseau pour Azure Kubernetes Service (AKS) : Grafana et Prometheus gérés par Azure (préversion)

Prérequis

Installer l’extension Azure CLI aks-preview

Inscrire l’indicateur de fonctionnalité AdvancedNetworkingPreview

Créer un groupe de ressources

Créer un cluster AKS avec l’observabilité réseau avancée

Activer l’observabilité avancée du réseau sur un cluster existant

Obtenir les informations d’identification du cluster

Prometheus et Grafana gérés par Azure

Créer une ressource Azure Monitor

Créer une instance Grafana

Placer les ID de ressource Azure Monitor et Grafana dans des variables

Lier Azure Monitor et Grafana au cluster AKS

Visualisation à l’aide de Grafana

Installer l’interface CLI Hubble

Visualiser les flux Hubble

Visualisation à l’aide de l’interface utilisateur Hubble

Nettoyer les ressources

Étapes suivantes

Ressources supplémentaires

Installer l’extension Azure CLI `aks-preview`

Inscrire l’indicateur de fonctionnalité `AdvancedNetworkingPreview`