Configuración de la observabilidad de red avanzada para Azure Kubernetes Service (AKS) (versión preliminar)

Artículo
08/02/2024

Este artículo muestra cómo configurar la observabilidad de red avanzada para Azure Kubernetes Service (AKS) y usar su propio (BYO) Prometheus y Grafana para visualizar las métricas.

Puede usar la observabilidad de red avanzada para recopilar datos sobre los datos de tráfico de red en los clústeres de AKS. Permite 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 red avanzada también ofrece la posibilidad de habilitar Hubble. Estas funcionalidades se admiten tanto para clústeres de Cilium como para clústeres que no son de Cilium.

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

Importante

La observabilidad de red avanzada está actualmente en versión preliminar. Consulte Términos de uso complementarios para las versiones preliminares de Microsoft Azure para conocer los términos legales que se aplican a las características de Azure que se encuentran en la versión beta, en versión preliminar o que todavía no se han publicado para que estén disponibles con carácter general.

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 extensión de la CLI de Azure `aks-preview`

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

Registro de la marca de característica `AdvancedNetworkingPreview`

Registre la marca de características de AdvancedNetworkingPreview mediante el comando az feature register.

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

Compruebe el registro correcto mediante el comandoaz feature show. El proceso de registro tarda unos minutos en completarse.

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

Una vez que la característica muestre Registered, actualice el registro del proveedor de recursos Microsoft.ContainerService mediante el comando az provider register.

Crear un grupo de recursos

Un grupo de recursos es un contenedor lógico en el que se implementan y se administran los recursos de Azure. Cree un grupo de recursos con el comando 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

Creación de un clúster de AKS con observabilidad de red avanzada

No perteneciente a Cilium
Cilium

Cree un clúster AKS con Advanced Network Observability y un plano de datos que no sea de Cilium utilizando el comando az aks create y la marca --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

Cree un clúster de AKS con observabilidad de red avanzada con Cilium mediante el comandoaz aks create y la marca --enable-advanced-networking-observability.

Nota:

Los clústeres con Cilium admiten la observabilidad avanzada 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-advanced-network-observability

Habilitación de la observabilidad de red avanzada en un clúster existente

Habilite la observabilidad de red avanzada en un clúster existente mediante el comando az aks update.

Nota:

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

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

Obtener credenciales del clúster

Obtenga las credenciales del clúster mediante el comando az aks get-credentials.

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

Visualización mediante Grafana

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

En Destinos de Prometheus, compruebe que los pods de red estén presentes.
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.

Instale Hubble CLI para acceder a los datos que recoge utilizando los siguientes comandos:

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

Visualización de los flujos de Flow

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 
```
Configure el reenvío de puertos para Relay de Azure Mediante el comando kubectl port-forward.
```
kubectl port-forward -n kube-system svc/hubble-relay --address 127.0.0.1 4245:443
```

TLS mutuo (mTLS) garantiza la seguridad del servidor de Relay de Azure. 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

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

Asegúrese de que el pod de retransmisión de Hubble se está ejecutando con el comando hubble relay service.
```
hubble relay service 
```

Visualización mediante la interfaz de usuario de Hubble

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:
      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

Aplique el manifiesto xaml-ui.yaml al clúster mediante el siguiente comando
```
kubectl apply -f hubble-ui.yaml
```
Exponga el servicio configurando el reenvío de puertos mediante el comando kubectl port-forward.
```
kubectl port-forward svc/hubble-ui 12000:80
```
Acceda a la interfaz de usuario de Office escribiendo 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 avanzada para el clúster de AKS.

Para más información sobre Advanced Container Networking Services for Azure Kubernetes Service (AKS), consulte ¿Qué son los servicios avanzados de redes de contenedores para Azure Kubernetes Service (AKS)?.
Para crear un clúster AKS con la observabilidad de red avanzada y Prometheus y Grafana administrados por Azure, consulte Configuración de la observabilidad de red avanzada para Azure Kubernetes Service (AKS) Prometheus y Grafana administrados por Azure.

Compartir a través de

Configuración de la observabilidad de red avanzada para Azure Kubernetes Service (AKS) (versión preliminar)

Requisitos previos

Instalación de la extensión de la CLI de Azure `aks-preview`

Registro de la marca de característica `AdvancedNetworkingPreview`

Crear un grupo de recursos

Creación de un clúster de AKS con observabilidad de red avanzada

Habilitación de la observabilidad de red avanzada en un clúster existente

Obtener credenciales del clúster

Visualización mediante Grafana

Visualización de los flujos de Flow

Visualización mediante la interfaz de usuario de Hubble

Limpieza de recursos

Pasos siguientes

Recursos adicionales

Compartir a través de

Configuración de la observabilidad de red avanzada para Azure Kubernetes Service (AKS) (versión preliminar)

Requisitos previos

Instalación de la extensión de la CLI de Azure aks-preview

Registro de la marca de característica AdvancedNetworkingPreview

Crear un grupo de recursos

Creación de un clúster de AKS con observabilidad de red avanzada

Habilitación de la observabilidad de red avanzada en un clúster existente

Obtener credenciales del clúster

Visualización mediante Grafana

Visualización de los flujos de Flow

Visualización mediante la interfaz de usuario de Hubble

Limpieza de recursos

Pasos siguientes

Recursos adicionales

Instalación de la extensión de la CLI de Azure `aks-preview`

Registro de la marca de característica `AdvancedNetworkingPreview`