Partager via

Configurer l’observabilité réseau avancée pour Azure Kubernetes Service (AKS) (préversion)

  • Article

Cet article explique comment configurer l’observabilité réseau avancée pour Azure Kubernetes Service (AKS) et utiliser BYO (Bring-Your-Own) Prometheus et Grafana pour visualiser les métriques.

Vous pouvez utiliser l’observabilité réseau avancée pour collecter des données sur le trafic réseau dans 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.
  • 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

Créez un cluster AKS avec l’observabilité réseau avancée 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

Activer l’observabilité réseau avancée 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é réseau avancée à 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

Visualisation à l’aide de 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.

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

    # Set environment variables
export HUBBLE_VERSION=0.11  
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. Configurez le transfert de port pour Hubble Relay à 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 Hubble Relay. 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 relay service.

    hubble relay service

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. Exposez le service en configurant le transfert de port à l’aide de la commande kubectl port-forward.

    kubectl 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é réseau avancée pour votre cluster AKS.