Configurer l’Observabilité du réseau de conteneurs pour Azure Kubernetes Service (AKS) : Prometheus et Grafana managés par Azure

Cet article explique comment configurer l’Observabilité du réseau de conteneurs pour Azure Kubernetes Service (AKS) à l’aide de Grafana et BYO Prometheus et Grafana et de visualiser les métriques récupérées

Vous pouvez utiliser l’Observabilité du réseau de conteneurs 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é du réseau de conteneurs offre également la possibilité d’activer Hubble. Ces fonctionnalités sont prises en charge pour les clusters Cilium et non-Cilium.

L’Observabilité du réseau de conteneurs 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) ?.

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

Activer les services avancés de mise en réseau de conteneurs

Pour continuer, vous devez disposer d’un cluster AKS avec Advanced Container Networking Services activé.

La commande az aks create avec l'indicateur Advanced Container Azure Networking Services, --enable-acns, crée un nouveau cluster AKS avec toutes les fonctionnalités Advanced Container Networking Services. Ces fonctionnalités comprennent :

• Observabilité du réseau de conteneurs : fournit des informations sur votre trafic réseau. Pour en savoir plus, visitez Observabilité du réseau de conteneurs.

• Sécurité du réseau de conteneurs : offre des fonctionnalités de sécurité telles que le filtrage FQDN. Pour en savoir plus, visitez Sécurité du réseau de conteneurs.

# 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

# 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

Les services avancés de mise en réseau de conteneurs sur un cluster existant

La commande az aks update avec l'indicateur Services avancés de mise en réseau de conteneurs, --enable-acns, met à jour un cluster AKS existant avec toutes les fonctionnalités des services avancés de mise en réseau de conteneurs, qui incluent Observabilité du réseau de conteneurs et Sécurité du réseau de conteneurs.

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

Obtenir les informations d’identification du cluster

Une fois que vous avez obtenu vos informations d’identification de 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

Ignorez cette section si vous utilisez BYO Prometheus et Grafana

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 Azure Managed 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 Managed Grafana et Azure Monitor 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 Azure Managed 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

Visualisation à l’aide d’Azure Managed Grafana

Ignorez cette étape si vous utilisez BYO Grafana

1. 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
   

2. 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).

Visualisation à l’aide de BYO Grafana

Ignorez cette étape si vous utilisez Azure Managed Grafana

1. Ajoutez le travail de scrape suivant à votre configuration Prometheus existante et redémarrez votre serveur Prometheus :

   - 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. Dans Cibles de Prometheus, vérifiez la présence des pods observabilité réseau.

3. Connectez-vous à Grafana et importez les exemples de tableaux de bord suivants à l’aide des ID suivants :

   • Clusters : affiche les métriques au niveau du nœud pour vos clusters. (ID : 18814)
   • DNS (Cluster) : affiche les métriques DNS sur un cluster ou une sélection de nœuds. (ID : 20925)
   • 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). (ID : [20926] https://grafana.com/grafana/dashboards/20926-kubernetes-networking-dns-workload/)
   • Dépôts (Charge de travail) : affiche les dépôts vers/depuis la charge de travail spécifiée (par exemple, les pods d’un déploiement ou d’un DaemonSet). (ID : 20927).
   • Flux de pods (Espace de noms) : affiche les flux de paquets L4/L7 vers/depuis l’espace de noms spécifié (c’est-à-dire les pods dans l’espace de noms). (ID : 20928)
   • Flux de pods (Charge de travail) : affiche les flux de paquets L4/L7 vers/depuis la charge de travail spécifiée (par exemple, pods d’un déploiement ou d’un DaemonSet). (ID : 20929)

   Remarque

   • Selon les paramètres de vos instances Prometheus/Grafana, certains panneaux de tableau de bord peuvent nécessiter des ajustements pour afficher toutes les données.
   • Actuellement, Cilium ne prend 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

1. 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 
   

2. 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
   

3. 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
   

4. 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    
   

5. 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

1. 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
   

2. Appliquez le manifeste hubble-ui.yaml à votre cluster à l’aide de la commande suivante

   kubectl apply -f hubble-ui.yaml
   

3. 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
   

4. 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é du réseau de conteneurs 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 plus d’informations sur Sécurité du réseau de conteneurs et ses fonctionnalités, consultez Qu’est-ce que Sécurité du réseau de conteneurs ?.