Condividi tramite

Configurare l'osservabilità di rete avanzata per il servizio Azure Kubernetes - Prometheus e Grafana gestiti da Azure (anteprima)

  • Articolo

Questo articolo illustra come configurare l'osservabilità di rete avanzata per il servizio Azure Kubernetes usando Prometheus e Grafana gestiti per visualizzare le metriche raschiate.

È possibile usare l'osservabilità di rete avanzata per raccogliere dati sul traffico di rete dei cluster del servizio Azure Kubernetes. Questa funzionalità offre una piattaforma centralizzata per il monitoraggio dell'integrità delle applicazioni e della rete. Attualmente, le metriche vengono archiviate in Prometheus e Grafana può essere usato per visualizzarle. Osservabilità di rete avanzata offre anche la possibilità di abilitare Hubble. Queste funzionalità sono supportate sia per i cluster Cilium che per quelli non Cilium.

Osservabilità di rete avanzata è una delle funzionalità dei servizi avanzati di rete per contenitori. Per altre informazioni sui servizi avanzati di rete per contenitori per il servizio Azure Kubernetes, vedere Che cosa sono i servizi avanzati di rete per contenitori per il servizio Azure Kubernetes?.

Importante

L’osservabilità di rete avanzata è attualmente disponibile in ANTEPRIMA. Vedere le condizioni per l'utilizzo supplementari per le anteprime di Microsoft Azure per termini legali aggiuntivi che si applicano a funzionalità di Azure in versione beta, in anteprima o in altro modo non ancora disponibili a livello generale.

Prerequisiti

  • La versione minima dell'interfaccia della riga di comando di Azure necessaria per i passaggi descritti in questo articolo è 2.56.0. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

Installare l'estensione aks-preview dell'interfaccia della riga di comando di Azure.

Installare o aggiornare l'estensione di anteprima dell'interfaccia della riga di comando di Azure usando i comandi 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

Registrare il flag di funzionalità AdvancedNetworkingPreview

Registrare il flag di funzionalità az feature register --namespace "Microsoft.ContainerService" --name "AdvancedNetworkingPreview" usando il comando az feature register.

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

Verificare la corretta registrazione usando il comando az feature show. Per completare la registrazione sono necessari alcuni minuti.

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

Una volta visualizzata la funzionalità Registered, aggiornare la registrazione del provider di risorse Microsoft.ContainerService usando il comando az provider register.

Creare un gruppo di risorse

Un gruppo di risorse è un contenitore logico in cui vengono distribuite e gestite le risorse di Azure. Creare un gruppo di risorse usando il 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

Creare un cluster del servizio Azure Kubernetes con l'osservabilità di rete avanzata

Creare un cluster del servizio Azure Kubernetes con l'osservabilità di rete avanzata con un piano dati non Cilium utilizzando il comando az aks create e il flag --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

Abilitare l'osservabilità di rete avanzata in un cluster esistente

Abilitare l'osservabilità di rete avanzata in un cluster esistente usando il comando az aks update.

Nota

I cluster con il piano dati Cilium supportano l'osservabilità di rete avanzata a partire dalla versione 1.29 di Kubernetes.

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

Ottenere le credenziali del cluster

Ottenere le credenziali del cluster usando il comando az aks get-credentials.

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

Prometheus gestito di Azure e Grafana

Usare l'esempio seguente per installare e abilitare Prometheus e Grafana per il cluster del servizio Azure Kubernetes.

Creare una risorsa di Monitoraggio di Azure

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

Creare un'istanza di Grafana

Usare az grafana create per creare un'istanza di Grafana. Il nome dell'istanza di Grafana deve essere univoco.

# 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

Inserire gli ID risorsa Grafana e Monitoraggio di Azure nelle variabili

Usare az grafana show per inserire l'ID risorsa Grafana in una variabile. Usare az resource show per inserire l'ID risorsa di Monitoraggio di Azure in una variabile. Sostituire myGrafana con il nome dell'istanza di 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)

Usare az aks update per collegare le risorse di Monitoraggio di Azure e Grafana al cluster del servizio Azure Kubernetes.

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

Visualizzazione con Grafana

Nota

La metrica hubble_flows_processed_total non viene raschiata per impostazione predefinita a causa dell'elevata cardinalità delle metriche nei cluster su larga scala. Per questo motivo, i dashboard dei flussi di pod dispongono di pannelli con dati mancanti. Per cambiare questo parametro, è possibile modificare le impostazioni delle metriche ama in modo da includerle hubble_flows_processed_total nell'elenco di mantenimento delle metriche. Per informazioni su come eseguire questa operazione, vedere la Documentazione sull’inserimento minimo.

  1. Assicurarsi che i pod di Monitoraggio di Azure siano in esecuzione usando il comando kubectl get pods.

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

    L'output dovrebbe essere simile all'esempio di output seguente:

    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. Sono stati creati dashboard di esempio, che sono disponibili nella cartella Dashboard> di Prometheus gestito da Azure. I nomi di tali dashboard sono, ad esempio "Kubernetes/Networking/ <name>". La suite di dashboard include:

    • Cluster: mostra le metriche a livello di nodo per i cluster.
    • DNS (cluster): mostra le metriche DNS in un cluster o in una selezione di nodi.
    • DNS (carico di lavoro): mostra le metriche DNS per il carico di lavoro specificato (ad esempio, i pod di un DaemonSet o una distribuzione, ad esempio CoreDNS).
    • Drop (carico di lavoro): mostra i drop da/verso il carico di lavoro specificato, ad esempio i pod di un oggetto Deployment o DaemonSet.
    • Flussi pod (spazio dei nomi): mostra i flussi di pacchetti L4/L7 da/verso lo spazio dei nomi specificato, ad esempio i pod nello spazio dei nomi.
    • Flussi pod (carico di lavoro): mostra i flussi di pacchetti L4/L7 da/verso il carico di lavoro specificato, ad esempio i pod di un oggetto Deployment o DaemonSet.

Nota

  • Il piano dati Cilium attualmente non supporta metriche/dashboard DNS.

Installare l'interfaccia della riga di comando di Hubble

Installare l'interfaccia della riga di comando di Hubble per accedere ai dati raccolti usando i comandi seguenti:

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

Visualizzare i flussi di Hubble

  1. Assicurarsi che i pod di Hubble siano in esecuzione usando il comando kubectl get pods.

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

    L'output dovrebbe essere simile all'esempio di output seguente:

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

  2. Configurare il port-forwarding nell’Inoltro di Hubble tramite il comando kubectl port-forward.

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

  3. Il protocollo TLS reciproco (mTLS) garantisce la sicurezza del server dell’Inoltro di Hubble. Per consentire al client Hubble di recuperare i flussi, è necessario ottenere i certificati appropriati e configurare il client con essi. Applicare i certificati usando i comandi seguenti:

    #!/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. Verificare che i segreti siano stati generati usando il comando kubectl get secrets seguente:

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

    L'output dovrebbe essere simile all'esempio di output seguente:

    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. Assicurarsi che il pod dell’Inoltro di Hubble sia in esecuzione usando il comando hubble observe.

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

Visualizzare tramite l'interfaccia utente di Hubble

  1. Per usare l'interfaccia utente di Hubble, salvare il codice seguente in 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. Applicare il manifesto hubble-ui.yaml al cluster usando il comando seguente

    kubectl apply -f hubble-ui.yaml

  3. Configurare il port forwarding per l'interfaccia utente di Hubble usando il comando kubectl port-forward.

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

  4. Accedere all'interfaccia utente di Hubble immettendo http://localhost:12000/ nel Web browser.

Pulire le risorse

Se non si prevede di usare questa applicazione, eliminare le altre risorse create in questo articolo usando il comando az group delete.

  az group delete --name $RESOURCE_GROUP

Passaggi successivi

In questo articolo di istruzioni si è appreso come installare e abilitare l'osservabilità di rete avanzata per il cluster del servizio Azure Kubernetes.