Udostępnij za pośrednictwem

Konfigurowanie możliwości obserwowania sieci kontenerów dla usługi Azure Kubernetes Service (AKS) — zarządzane przez platformę Azure Prometheus i Grafana

  • Artykuł

W tym artykule pokazano, jak skonfigurować możliwość obserwowania sieci kontenerów dla usługi Azure Kubernetes Service (AKS) przy użyciu zarządzanych rozwiązań Prometheus i Grafana i BYO Prometheus i Grafana oraz wizualizacji zeskropionych metryk

Funkcja obserwacji sieci kontenerów umożliwia zbieranie danych dotyczących ruchu sieciowego klastrów usługi AKS. Umożliwia ona scentralizowaną platformę do monitorowania kondycji aplikacji i sieci. Obecnie metryki są przechowywane w rozwiązaniu Prometheus i narzędzia Grafana mogą służyć do ich wizualizacji. Możliwość obserwowania sieci kontenerów umożliwia również włączenie usługi Hubble. Te możliwości są obsługiwane zarówno w przypadku klastrów Cilium, jak i innych niż Cilium.

Obserwacja sieci kontenerów jest jedną z funkcji usług Advanced Container Networking Services. Aby uzyskać więcej informacji na temat usług Advanced Container Networking Services dla usługi Azure Kubernetes Service (AKS), zobacz Co to jest usługa Advanced Container Networking Services dla usługi Azure Kubernetes Service (AKS)?.

Wymagania wstępne

  • Konto platformy Azure z aktywną subskrypcją. Jeśli nie masz subskrypcji, przed rozpoczęciem utwórz bezpłatne konto.
  • Minimalna wersja interfejsu wiersza polecenia platformy Azure wymagana do wykonania kroków w tym artykule to 2.56.0. Uruchom polecenie az --version, aby dowiedzieć się, jaka wersja jest używana. Jeśli konieczna będzie instalacja lub uaktualnienie, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure.

Instalowanie rozszerzenia interfejsu wiersza polecenia platformy Azure w wersji zapoznawczej usługi aks

Zainstaluj lub zaktualizuj rozszerzenie interfejsu wiersza polecenia platformy Azure w wersji zapoznawczej przy użyciu az extension add polecenia lub 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

Włączanie zaawansowanych usług sieciowych kontenerów

Aby kontynuować, musisz mieć klaster usługi AKS z włączoną usługą Advanced Container Networking Services .

Polecenie az aks create z flagą --enable-acnsAdvanced Container Networking Services tworzy nowy klaster AKS ze wszystkimi funkcjami advanced Container Networking Services. Obejmują one następujące funkcje:

  • Obserwowanie sieci kontenerów: zapewnia wgląd w ruch sieciowy. Aby dowiedzieć się więcej, odwiedź stronę Obserwacja sieci kontenerów.

  • Zabezpieczenia sieci kontenerów: oferuje funkcje zabezpieczeń, takie jak filtrowanie nazw FQDN. Aby dowiedzieć się więcej, odwiedź stronę Zabezpieczenia sieci kontenerów.

Uwaga

Klastry z płaszczyzną danych Cilium obsługują zabezpieczenia sieci kontenerów i sieci kontenerów, począwszy od platformy Kubernetes w wersji 1.29.

# 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

Włączanie usług Advanced Container Networking Services w istniejącym klastrze

Polecenie az aks update z flagą --enable-acnsAdvanced Container Networking Services , aktualizuje istniejący klaster AKS ze wszystkimi funkcjami Advanced Container Networking Services, które obejmują możliwość obserwowania sieci kontenerów i funkcję zabezpieczeń sieci kontenerów.

Uwaga

Tylko klastry z płaszczyzną danych Cilium obsługują funkcje zabezpieczeń sieci kontenerów usługi Advanced Container Networking Services.

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

Pobieranie poświadczeń klastra

Po utworzeniu az aks get-credentials poświadczeń klastra za pomocą polecenia .

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

Zarządzane przez platformę Azure rozwiązania Prometheus i Grafana

Pomiń tę sekcję, jeśli używasz rozwiązania BYO Prometheus i Grafana

Użyj poniższego przykładu, aby zainstalować i włączyć rozwiązanie Prometheus i Grafana dla klastra usługi AKS.

Tworzenie zasobu usługi 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 '{}'

Tworzenie wystąpienia usługi Azure Managed Grafana

Użyj polecenia az grafana create , aby utworzyć wystąpienie narzędzia Grafana. Nazwa wystąpienia narzędzia Grafana musi być unikatowa.

# 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

Umieść identyfikatory zasobów usługi Azure Managed Grafana i Azure Monitor w zmiennych

Użyj polecenia az grafana show , aby umieścić identyfikator zasobu Grafana w zmiennej. Użyj polecenia az resource show , aby umieścić identyfikator zasobu usługi Azure Monitor w zmiennej. Zastąp ciąg myGrafana nazwą wystąpienia narzędzia 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)

Użyj polecenia az aks update , aby połączyć zasoby usługi Azure Monitor i Grafana z klastrem usługi 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

Wizualizacja

Wizualizacja przy użyciu narzędzia Azure Managed Grafana

Pomiń ten krok, jeśli używasz narzędzia BYO Grafana

Uwaga

hubble_flows_processed_total Metryka nie jest domyślnie złomowana ze względu na kardynalność wysokiej metryki w klastrach na dużą skalę. W związku z tym pulpity nawigacyjne Przepływy zasobników mają panele z brakującymi danymi. Aby to zmienić, możesz zmodyfikować ustawienia metryk ama, aby uwzględnić hubble_flows_processed_total je na liście zachowań metryk. Aby dowiedzieć się, jak to zrobić, zobacz Dokumentację minimalnego pozyskiwania.

  1. Upewnij się, że zasobniki usługi Azure Monitor są uruchomione przy użyciu kubectl get pods polecenia .

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

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

    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. Utworzyliśmy przykładowe pulpity nawigacyjne. Znajdują się one w folderze Pulpity > nawigacyjne zarządzane przez platformę Azure Prometheus. Mają nazwy takie jak "Kubernetes / Networking / <name>". Pakiet pulpitów nawigacyjnych obejmuje:

    • Klastry: przedstawia metryki na poziomie węzła dla klastrów.
    • SYSTEM DNS (klaster): wyświetla metryki DNS w klastrze lub wybrane węzły.
    • Dns (obciążenie): pokazuje metryki DNS dla określonego obciążenia (np. zasobniki demonaset lub wdrożenie, takie jak CoreDNS).
    • Drop (Obciążenie): pokazuje spadki do/z określonego obciążenia (np. zasobniki wdrożenia lub daemonSet).
    • Przepływy zasobników (przestrzeń nazw): pokazuje przepływy pakietów L4/L7 do/z określonej przestrzeni nazw (tj. zasobniki w przestrzeni nazw).
    • Przepływy zasobników (obciążenie): pokazuje przepływy pakietów L4/L7 do/z określonego obciążenia (np. zasobniki wdrożenia lub demonaset).

Wizualizacja przy użyciu narzędzia BYO Grafana

Pomiń ten krok, jeśli korzystasz z zarządzanej przez platformę Azure narzędzia Grafana

  1. Dodaj następujące zadanie zeskrobania do istniejącej konfiguracji rozwiązania Prometheus i uruchom ponownie serwer 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. W obszarze Targets of Prometheus sprawdź, czy są obecne zasobniki network-obs-pods .

  3. Zaloguj się do aplikacji Grafana i zaimportuj następujące przykładowe pulpity nawigacyjne przy użyciu następujących identyfikatorów:

    • Klastry: przedstawia metryki na poziomie węzła dla klastrów. (IDENTYFIKATOR: 18814)
    • SYSTEM DNS (klaster): pokazuje metryki DNS w klastrze lub wybrane węzły.( Identyfikator: 20925)
    • Dns (obciążenie): pokazuje metryki DNS dla określonego obciążenia (np. zasobniki demonaset lub wdrożenie, takie jak CoreDNS). (IDENTYFIKATOR: [20926] https://grafana.com/grafana/dashboards/20926-kubernetes-networking-dns-workload/)
    • Drop (Obciążenie): pokazuje spadki do/z określonego obciążenia (np. zasobniki wdrożenia lub daemonSet).( Identyfikator: 20927).
    • Przepływy zasobników (przestrzeń nazw): pokazuje przepływy pakietów L4/L7 do/z określonej przestrzeni nazw (tj. zasobniki w przestrzeni nazw). (IDENTYFIKATOR: 20928)
    • Przepływy zasobników (obciążenie): pokazuje przepływy pakietów L4/L7 do/z określonego obciążenia (np. zasobniki wdrożenia lub zestawu demonów).( Identyfikator: 20929)

    Uwaga

    • W zależności od ustawień wystąpień rozwiązania Prometheus/Grafana niektóre panele pulpitu nawigacyjnego mogą wymagać dostosowania do wyświetlania wszystkich danych.
    • Cilium nie obsługuje obecnie metryk/pulpitów nawigacyjnych DNS.

Instalowanie interfejsu wiersza polecenia platformy Hubble

Zainstaluj interfejs wiersza polecenia platformy Hubble, aby uzyskać dostęp do zbieranych danych przy użyciu następujących poleceń:

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

Wizualizowanie przepływów Hubble

  1. Upewnij się, że zasobniki Hubble są uruchomione przy użyciu kubectl get pods polecenia .

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

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

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

  2. Przekieruj usługę kubectl port-forward Hubble Relay przy użyciu polecenia .

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

  3. Protokół TLS (mTLS) zapewnia bezpieczeństwo serwera usługi Hubble Relay. Aby umożliwić klientowi Hubble pobieranie przepływów, należy uzyskać odpowiednie certyfikaty i skonfigurować klienta przy użyciu nich. Zastosuj certyfikaty przy użyciu następujących poleceń:

    #!/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. Sprawdź, czy wpisy tajne zostały wygenerowane przy użyciu następującego kubectl get secrets polecenia:

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

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

    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. Upewnij się, że zasobnik usługi Hubble Relay jest uruchomiony przy użyciu hubble observe polecenia .

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

Wizualizowanie przy użyciu interfejsu użytkownika platformy Hubble

  1. Aby użyć interfejsu użytkownika platformy Hubble, zapisz następujące polecenie w pliku 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. Zastosuj manifest hubble-ui.yaml do klastra przy użyciu następującego polecenia

    kubectl apply -f hubble-ui.yaml

  3. Skonfiguruj przekazywanie portów dla interfejsu użytkownika hubble'a kubectl port-forward przy użyciu polecenia .

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

  4. Uzyskiwanie dostępu do interfejsu użytkownika hubble przez wprowadzenie http://localhost:12000/ do przeglądarki internetowej.

Czyszczenie zasobów

Jeśli nie planujesz korzystania z tej aplikacji, usuń inne zasoby utworzone w tym artykule przy użyciu az group delete polecenia .

  az group delete --name $RESOURCE_GROUP

Następne kroki

W tym artykule z instrukcjami przedstawiono sposób instalowania i włączania możliwości obserwowania sieci kontenerów dla klastra usługi AKS.