Configuración de la observabilidad de la red de contenedor para Azure Kubernetes Service (AKS): Prometheus y Grafana administrados por Azure

En este artículo se muestra cómo configurar la observabilidad de la red de contenedor para Azure Kubernetes Service (AKS) mediante Prometheus administrado y Grafana y BYO Prometheus y Grafana y para visualizar las métricas desguazadas.

Puede usar observabilidad de red de contenedor para recopilar datos sobre el tráfico de red de los clústeres de AKS. Proporciona una plataforma centralizada para supervisar el estado de la aplicación y la red. Actualmente, las métricas se almacenan en Prometheus y Grafana se pueden usar para visualizarlas. La observabilidad de la red contenedora también ofrece la posibilidad de habilitar a Storage. Estas funcionalidades se admiten tanto para clústeres de Cilium como para clústeres que no son de Cilium.

La observabilidad de la red de contenedor es una de las características de Advanced Container Networking Services. Para más información sobre los servicios avanzados de redes de contenedores en Azure Kubernetes Service (AKS), consulte ¿Qué son los servicios avanzados de redes de contenedores en Azure Kubernetes Service (AKS)?.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Si no tiene una, cree una cuenta gratuita antes de empezar.

• Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Inicio rápido para Bash en Azure Cloud Shell.

  

• Si prefiere ejecutar comandos de referencia de la CLI localmente, instale la CLI de Azure. Si utiliza Windows o macOS, considere la posibilidad de ejecutar la CLI de Azure en un contenedor Docker. Para más información, vea Ejecución de la CLI de Azure en un contenedor de Docker.

  • Si usa una instalación local, inicie sesión en la CLI de Azure mediante el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Inicio de sesión con la CLI de Azure.

  • En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información sobre las extensiones, consulte Uso de extensiones con la CLI de Azure.

  • Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para realizar la actualización a la versión más reciente, ejecute az upgrade.

• La versión mínima de la CLI de Azure necesaria para los pasos de este artículo es la 2.56.0. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.

Instalación de la versión preliminar de la extensión de la CLI de Azure en versión preliminar de AKS

Instale o actualice la extensión de versión preliminar de la CLI de Azure mediante el comando az extension add o 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

Habilitación de Servicios avanzados de redes de contenedores

Para continuar, debe tener un clúster de AKS con Servicios avanzados de redes de contenedores habilitado.

El comando az aks create con la marca Advanced Container Networking Services, --enable-acns, crea un nuevo clúster de AKS con todas las características avanzadas de Container Networking Services. Estas características abarcan:

• Observabilidad de red de contenedor: Proporciona información sobre el tráfico de red. Para obtener más información, visite Observabilidad de la red de contenedor.

• Seguridad de red de contenedor: ofrece características de seguridad como el filtrado de FQDN. Para más información, visite Seguridad de red de contenedores.

Cilium

Nota:

Los clústeres con el plano de datos de Cilium admiten la observabilidad de la red de contenedor y la seguridad de la red de contenedor a partir de la versión 1.29 de Kubernetes.

# 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

No perteneciente a Cilium

Nota:

Característica de seguridad de red de contenedor no está disponible para clústeres que no son de cilium

# 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

Habilitación de Servicios avanzados de redes de contenedores en un clúster existente

El comando az aks update con la marca Advanced Container Networking Services, --enable-acns, actualiza un clúster de AKS existente con todas las características avanzadas de Container Networking Services, que incluye Observabilidad de red de contenedor y la característica Seguridad de red de contenedor.

Nota:

Solo los clústeres con el plano de datos de Cilium admiten características de seguridad de red de contenedor de Advanced Container Networking Services.

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

---

Obtener credenciales del clúster

Una vez que obtenga sus credenciales de clúster mediante el comandoaz aks get-credentials.

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

Prometheus y Grafana administrados por Azure

Omitir esta sección si usa BYO Prometheus y Grafana

Use el ejemplo siguiente para instalar y habilitar Prometheus y Grafana para el clúster de AKS.

Creación de un recurso de 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 '{}'

Creación de una instancia de Grafana administrada de Azure

Use az grafana create para crear una instancia de Grafana. El nombre de la instancia de Grafana debe ser único.

# 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 

Colocar los identificadores de recursos de Azure Managed Grafana y Azure Monitor en variables

Use az grafana show para colocar el id. de recurso de Grafana en una variable. Use az resource show para colocar el id. de recurso de Azure Monitor en una variable. Reemplace myGrafana por el nombre único de la instancia de 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)

Vinculación de Azure Monitor y Azure Managed Grafana al clúster de AKS

Use az aks update para vincular los recursos de Azure Monitor y Grafana al clúster de 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

Visualización

Visualización mediante Azure Managed Grafana

Omitir este paso si usa BYO Grafana

Nota:

La métrica hubble_flows_processed_total no se extrae de forma predeterminada debido a una cardinalidad de métrica alta en clústeres a gran escala. Por este motivo, los paneles de flujos de pods tienen paneles con datos que faltan. Para cambiar esto, puede modificar la configuración de las métricas ama para incluir hubble_flows_processed_total en la lista de mantenimiento de métricas. Para obtener información sobre cómo hacerlo, consulte la documentación de ingesta mínima.

1. Asegúrese de que los pods de Azure Monitor se ejecutan con el comando kubectl get pods.

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

   El resultado debería ser similar al ejemplo siguiente:

   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. Hemos creado paneles de ejemplo. Se pueden encontrar en la carpeta Dashboards > Azure Managed Prometheus. Tienen nombres como "Kubernetes / Networking/ <name>". El conjunto de paneles incluye:

   • Clústeres: muestra las métricas de nivel de nodo para los clústeres.
   • DNS (clúster): muestra las métricas de DNS en un clúster o la selección de Nodos.
   • DNS (carga de trabajo): muestra las métricas de DNS para la carga de trabajo especificada (por ejemplo, pods de un DaemonSet o implementación como CoreDNS).
   • Anulaciones (carga de trabajo): muestra las anulaciones hacia o desde la carga de trabajo especificada (por ejemplo, pods de una implementación o DaemonSet).
   • Flujos de pod (espacio de nombres): muestra los flujos de paquetes L4/L7 hacia y desde el espacio de nombres especificado (es decir, pods en el espacio de nombres).
   • Flujos de pod (carga de trabajo): muestra los flujos de paquetes L4/L7 hacia o desde la carga de trabajo especificada (por ejemplo, pods de una implementación o DaemonSet).

Visualización mediante BYO Grafana

Omitir este paso si usa Grafana administrado por Azure

1. Agregue el siguiente trabajo de extracción a la configuración de Prometheus existente y reinicie el servidor de 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. En Destinos de Prometheus, compruebe que los pods de red estén presentes.

3. Inicie sesión en Grafana e importe los paneles de ejemplo siguientes mediante los siguientes identificadores:

   • Clústeres: muestra las métricas de nivel de nodo para los clústeres. (ID: 18814)
   • DNS (clúster): muestra las métricas de DNS en un clúster o la selección de Nodos.( Identificador: 20925)
   • DNS (carga de trabajo): muestra las métricas de DNS para la carga de trabajo especificada (por ejemplo, pods de un DaemonSet o implementación como CoreDNS). (ID : [20926] https://grafana.com/grafana/dashboards/20926-kubernetes-networking-dns-workload/)
   • Gotas (carga de trabajo): muestra las caídas hacia o desde la carga de trabajo especificada (por ejemplo, pods de una implementación o DaemonSet). ( Identificador: 20927).
   • Flujos de pod (espacio de nombres): muestra los flujos de paquetes L4/L7 hacia y desde el espacio de nombres especificado (es decir, pods en el espacio de nombres). (ID: 20928)
   • Flujos de pod (carga de trabajo): muestra los flujos de paquetes L4/L7 hacia o desde la carga de trabajo especificada (por ejemplo, pods de una implementación o DaemonSet). (Identificador: 20929)

   Nota:

   • En función de la configuración de las instancias de Prometheus/Grafana, algunos paneles de panel pueden requerir ajustes para mostrar todos los datos.
   • Cilium no admite actualmente métricas o paneles de DNS.

Instalación de la CLI de Hubble

Instale la CLI de Hubble para acceder a los datos que recopila mediante los siguientes comandos:

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

Visualización de los flujos de Hubble

1. Asegúrese de que los pods de Hubble se ejecuten con el comando kubectl get pods.

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

   El resultado debería ser similar al ejemplo siguiente:

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

2. Reenvíe el puerto de retransmisión de Hubble mediante el comando kubectl port-forward.

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

3. TLS mutuo (mTLS) garantiza la seguridad del servidor de retransmisión de Hubble. Para permitir que el cliente de Hubble recupere flujos, debe obtener los certificados adecuados y configurar el cliente con ellos. Aplique los certificados mediante los siguientes comandos:

   #!/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. Compruebe que los secretos se generaron mediante el siguiente comando kubectl get secrets:

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

   El resultado debería ser similar al ejemplo siguiente:

   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. Asegúrese de que el pod de retransmisión de Hubble se está ejecutando con el comando hubble observe.

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

Visualización mediante la interfaz de usuario de Hubble

1. Para usar la interfaz de usuario de Hubble, guarde lo siguiente en 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. Aplique el manifiesto hubble-ui.yaml al clúster mediante el siguiente comando.

   kubectl apply -f hubble-ui.yaml
   

3. Configure el reenvío de puertos para la interfaz de usuario de Hubble con el comando kubectl port-forward.

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

4. Para acceder a la interfaz de usuario de Hubble, escriba http://localhost:12000/ en el explorador web.

---

Limpieza de recursos

Si no planea usar esta aplicación, elimine los demás recursos que creó en este artículo mediante el comando az group delete.

  az group delete --name $RESOURCE_GROUP

Pasos siguientes

En este artículo de procedimientos, ha aprendido a instalar y habilitar la observabilidad de red de contenedor para el clúster de AKS.

• Para más información sobre los servicios avanzados de redes de contenedores en Azure Kubernetes Service (AKS), consulte ¿Qué son los servicios avanzados de redes de contenedores en Azure Kubernetes Service (AKS)?.

• Para obtener más información sobre la seguridad de red de contenedor y sus funcionalidades, consulte ¿Qué es la seguridad de red de contenedores?.