Beobachtbarkeit für GKE Dataplane V2 einrichten


Auf dieser Seite wird gezeigt, wie Sie GKE-Cluster (Google Kubernetes Engine) mit GKE Dataplane V2-Beobachtbarkeit konfigurieren, ab GKE-Version 1.28. Weitere Informationen zu den Vorteilen und Anforderungen der Beobachtbarkeit von GKE Dataplane V2 finden Sie unter Beobachtbarkeit für GKE Dataplane V2.

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

  • Aktivieren Sie die Google Kubernetes Engine API.
  • Google Kubernetes Engine API aktivieren
  • Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.

GKE Dataplane V2-Messwerte konfigurieren

Zum Erfassen von Messwerten müssen Sie GKE Dataplane V2-Messwerte konfigurieren. Sie können GKE Dataplane V2-Messwerte konfigurieren, wenn Sie einen Cluster erstellen oder einen Cluster aktualisieren, der mit GKE Dataplane V2 ausgeführt wird. Sie können GKE Dataplane V2-Messwerte mit der gcloud CLI aktivieren oder deaktivieren.

Wir empfehlen, GKE Dataplane V2-Messwerte und Google Cloud Managed Service for Prometheus in Ihrem GKE-Cluster zu aktivieren. Wenn beide Messwerte aktiviert sind, werden GKE Dataplane V2-Messwerte an Google Cloud Managed Service for Prometheus gesendet.

Autopilot-Cluster mit aktivierten GKE Dataplane V2-Messwerten erstellen

Wenn Sie neue GKE Autopilot-Cluster erstellen, aktiviert GKE standardmäßig GKE Dataplane V2-Messwerte im Cluster, ohne dass ein bestimmtes Flag erforderlich ist.

Um die GKE Dataplane V2-Messwerte des GKE Autopilot-Clusters mit Google Cloud Managed Service for Prometheus zu verwenden, konfigurieren Sie die Ressource ClusterPodMonitoring so, dass die Messwerte extrahiert und an Google Cloud Managed Service for Prometheus gesendet werden.

  1. Erstellen Sie ein ClusterPodMonitoring-Manifest.

    # Copyright 2023 Google LLC
    #
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     https://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.
    
    apiVersion: monitoring.googleapis.com/v1
    kind: ClusterPodMonitoring
    metadata:
      name: advanced-datapath-observability-metrics
    spec:
      selector:
        matchLabels:
          k8s-app: cilium
      endpoints:
      - port: flowmetrics
        interval: 60s
        metricRelabeling:
        # only keep denormalized pod flow metrics
        - sourceLabels: [__name__]
          regex: 'pod_flow_(ingress|egress)_flows_count'
          action: keep
        # extract pod name
        - sourceLabels: [__name__, destination]
          regex: 'pod_flow_ingress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${2}'
          targetLabel: pod_name
          action: replace
        - sourceLabels: [__name__, source]
          regex: 'pod_flow_egress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${2}'
          targetLabel: pod_name
          action: replace
        # extract workload name by removing 2 last "-XXX" parts
        - sourceLabels: [pod_name]
          regex: '([a-zA-Z0-9-\.]+)((-[a-zA-Z0-9\.]+){2})'
          replacement: '${1}'
          targetLabel: workload_name
          action: replace
        # extract workload name by removing one "-XXX" part when pod name has only 2 parts (eg. daemonset)
        - sourceLabels: [pod_name]
          regex: '([a-zA-Z0-9\.]+)((-[a-zA-Z0-9\.]+){1})'
          replacement: '${1}'
          targetLabel: workload_name
          action: replace
        # extract pod namespace
        - sourceLabels: [__name__, destination]
          regex: 'pod_flow_ingress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${1}'
          targetLabel: namespace_name
          action: replace
        - sourceLabels: [__name__, source]
          regex: 'pod_flow_egress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${1}'
          targetLabel: namespace_name
          action: replace
        # extract remote workload name
        - sourceLabels: [__name__, source]
          regex: 'pod_flow_ingress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${2}'
          targetLabel: remote_workload
          action: replace
        - sourceLabels: [__name__, destination]
          regex: 'pod_flow_egress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${2}'
          targetLabel: remote_workload
          action: replace
        # extract remote workload namespace
        - sourceLabels: [__name__, source]
          regex: 'pod_flow_ingress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${1}'
          targetLabel: remote_namespace
          action: replace
        - sourceLabels: [__name__, destination]
          regex: 'pod_flow_egress_flows_count;([a-zA-Z0-9-\.]+)/([a-zA-Z0-9-\.]+)'
          replacement: '${1}'
          targetLabel: remote_namespace
          action: replace
        # default remote workload class to "pod"
        - replacement: 'pod'
          targetLabel: remote_class
          action: replace
        # extract remote workload class from reserved identity
        - sourceLabels: [__name__, source]
          regex: 'pod_flow_ingress_flows_count;reserved:([^/]*)'
          replacement: '${1}'
          targetLabel: remote_class
          action: replace
        - sourceLabels: [__name__, destination]
          regex: 'pod_flow_egress_flows_count;reserved:([^/]*)'
          replacement: '${1}'
          targetLabel: remote_class
          action: replace
      targetLabels:
        metadata: []
    
  2. Wenden Sie das ClusterPodMonitoring-Manifest an:

    kubectl apply -f ClusterPodMonitoring.yaml
    

Standardcluster mit aktivierten GKE Dataplane V2-Messwerten erstellen

Erstellen Sie zum Aktivieren von GKE Dataplane V2-Messwerten einen Cluster mit dem Flag --enable-dataplane-v2-metrics:

gcloud container clusters create CLUSTER_NAME \
    --enable-dataplane-v2 \
    --enable-ip-alias \
    --enable-managed-prometheus \
    --enable-dataplane-v2-metrics

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name Ihres Clusters.

Das Flag --enable-managed-prometheus weist GKE an, die Messwerte mit Google Cloud Managed Service for Prometheus zu verwenden.

GKE Dataplane V2-Messwerte auf einem vorhandenen Cluster aktivieren

Führen Sie den folgenden Befehl aus, um GKE Dataplane V2-Messwerte in einem vorhandenen Cluster zu aktivieren:

gcloud container clusters update CLUSTER_NAME \
    --enable-dataplane-v2-metrics

Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

GKE Dataplane V2-Messwerte deaktivieren

So deaktivieren Sie GKE Dataplane V2-Messwerte:

gcloud container clusters update CLUSTER_NAME \
    --disable-dataplane-v2-metrics

Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

GKE Dataplane V2-Beobachtbarkeitstools konfigurieren

Sie können einen privaten Endpunkt verwenden, um auf die Fehlerbehebungstools von GKE Dataplane V2 zuzugreifen. Damit Sie die Beobachtbarkeitstools von GKE Dataplane V2 aktivieren können, muss ein Cluster mit GKE Dataplane V2 konfiguriert sein. Sie können die Beobachtbarkeitstools von GKE Dataplane V2 für einen neuen oder einen vorhandenen Cluster aktivieren.

Autopilot-Cluster mit aktivierter Beobachtbarkeit erstellen

So erstellen Sie einen GKE Autopilot-Cluster mit aktivierter GKE Dataplane V2-Beobachtbarkeit:

gcloud container clusters create-auto CLUSTER_NAME \
    --enable-dataplane-v2-flow-observability

Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

Standardcluster mit aktivierter Beobachtbarkeit erstellen

So erstellen Sie einen GKE Standard-Cluster mit aktivierter Beobachtbarkeit für GKE Dataplane V2:

gcloud container clusters create CLUSTER_NAME \
    --enable-dataplane-v2 \
    --enable-ip-alias \
    --enable-dataplane-v2-flow-observability

Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

GKE Dataplane V2-Beobachtbarkeitstools für einen vorhandenen Cluster aktivieren

Führen Sie den folgenden Befehl aus, um die Beobachtbarkeit von GKE Dataplane V2 in einem vorhandenen Cluster zu aktivieren:

gcloud container clusters update CLUSTER_NAME \
    --enable-dataplane-v2-flow-observability

Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

GKE Dataplane V2-Beobachtbarkeitstools deaktivieren

Führen Sie den folgenden Befehl aus, um die Beobachtbarkeitstools von GKE Dataplane V2 in einem vorhandenen Cluster zu deaktivieren:

gcloud container clusters update CLUSTER_NAME \
    --disable-dataplane-v2-flow-observability

Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

Hubble-Befehlszeile verwenden

Verwenden Sie das Hubble-Befehlszeilentool auf dem Cluster, nachdem Sie das Beobachtbarkeitsfeature von GKE Dataplane V2 aktiviert haben.

  1. Alias für die hubble-cli-Binärdatei definieren:

    alias hubble="kubectl exec -it -n gke-managed-dpv2-observability deployment/hubble-relay -c hubble-cli -- hubble"
    
  2. Wenn Sie den Hubble-Status mit aktivierter Beobachtbarkeitsfunktion für GKE Dataplane V2 prüfen möchten, verwenden Sie die Hubble-Befehlszeile in allen Autopilotclustern:

    hubble status
    
  3. Verwenden Sie die Hubble-Befehlszeile, um den aktuellen Traffic aufzurufen:

    hubble observe
    

Binäre Verteilung der Hubble-UI bereitstellen

Nachdem die Beobachtbarkeit von GKE Dataplane V2 aktiviert wurde, können Sie die Open-Source-Hubble-UI bereitstellen.

  1. Aktivieren Sie die Beobachtbarkeit in Ihrem GKE-Cluster:

    1. Erstellen Sie einen GKE-Cluster mit aktivierter Beobachtbarkeit:

      gcloud container clusters create-auto hubble-rc-auto \
          --location COMPUTE_LOCATION \
          --cluster-version VERSION \
          --enable-dataplane-v2-flow-observability
      

      Ersetzen Sie Folgendes:

    2. Alternativ können Sie die Beobachtbarkeit in einem vorhandenen Cluster aktivieren:

      gcloud container clusters update CLUSTER_NAME \
          --location COMPUTE_LOCATION \
          --enable-dataplane-v2-flow-observability
      

      Ersetzen Sie Folgendes:

  2. Konfigurieren Sie kubectl, um eine Verbindung zum Cluster herzustellen:

    gcloud container clusters get-credentials CLUSTER_NAME \
        --location COMPUTE_LOCATION
    

    Ersetzen

  3. Stellen Sie die Hubble-UI bereit:

    # Copyright 2024 Google LLC
    #
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     https://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.
    
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: hubble-ui
      namespace: gke-managed-dpv2-observability
    ---
    kind: ClusterRole
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: hubble-ui
      labels:
        app.kubernetes.io/part-of: cilium
    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
    ---
    kind: ClusterRoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: hubble-ui
      labels:
        app.kubernetes.io/part-of: cilium
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: ClusterRole
      name: hubble-ui
    subjects:
      - kind: ServiceAccount
        name: hubble-ui
        namespace: gke-managed-dpv2-observability
    ---
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: hubble-ui-nginx
      namespace: gke-managed-dpv2-observability
    data:
      nginx.conf: |
        server {
            listen       8081;
            # uncomment for IPv6
            # 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 / {
                    # double `/index.html` is required here
                    try_files $uri $uri/ /index.html /index.html;
                }
            }
        }
    ---
    kind: Deployment
    apiVersion: apps/v1
    metadata:
      name: hubble-ui
      namespace: gke-managed-dpv2-observability
      labels:
        k8s-app: hubble-ui
        app.kubernetes.io/name: hubble-ui
        app.kubernetes.io/part-of: cilium
    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: cilium
        spec:
          securityContext:
            fsGroup: 1000
            seccompProfile:
              type: RuntimeDefault
          serviceAccount: hubble-ui
          serviceAccountName: hubble-ui
          containers:
            - name: frontend
              image: quay.io/cilium/hubble-ui:v0.11.0
              ports:
                - name: http
                  containerPort: 8081
              volumeMounts:
                - name: hubble-ui-nginx-conf
                  mountPath: /etc/nginx/conf.d/default.conf
                  subPath: nginx.conf
                - name: tmp-dir
                  mountPath: /tmp
              terminationMessagePolicy: FallbackToLogsOnError
              securityContext:
                allowPrivilegeEscalation: false
                readOnlyRootFilesystem: true
                runAsUser: 1000
                runAsGroup: 1000
                capabilities:
                  drop:
                    - all
            - name: backend
              image: quay.io/cilium/hubble-ui-backend:v0.11.0
              env:
                - name: EVENTS_SERVER_PORT
                  value: "8090"
                - name: FLOWS_API_ADDR
                  value: "hubble-relay.gke-managed-dpv2-observability.svc:443"
                - name: TLS_TO_RELAY_ENABLED
                  value: "true"
                - name: TLS_RELAY_SERVER_NAME
                  value: relay.gke-managed-dpv2-observability.svc.cluster.local
                - 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
              ports:
                - name: grpc
                  containerPort: 8090
              volumeMounts:
                - name: hubble-ui-client-certs
                  mountPath: /var/lib/hubble-ui/certs
                  readOnly: true
              terminationMessagePolicy: FallbackToLogsOnError
              securityContext:
                allowPrivilegeEscalation: false
                readOnlyRootFilesystem: true
                runAsUser: 1000
                runAsGroup: 1000
                capabilities:
                  drop:
                    - all
          volumes:
            - configMap:
                defaultMode: 420
                name: hubble-ui-nginx
              name: hubble-ui-nginx-conf
            - emptyDir: {}
              name: tmp-dir
            - name: hubble-ui-client-certs
              projected:
                # note: the leading zero means this number is in octal representation: do not remove it
                defaultMode: 0400
                sources:
                  - secret:
                      name: hubble-relay-client-certs
                      items:
                        - key: ca.crt
                          path: hubble-relay-ca.crt
                        - key: tls.crt
                          path: client.crt
                        - key: tls.key
                          path: client.key
    ---
    kind: Service
    apiVersion: v1
    metadata:
      name: hubble-ui
      namespace: gke-managed-dpv2-observability
      labels:
        k8s-app: hubble-ui
        app.kubernetes.io/name: hubble-ui
        app.kubernetes.io/part-of: cilium
    spec:
      type: ClusterIP
      selector:
        k8s-app: hubble-ui
      ports:
        - name: http
          port: 80
          targetPort: 8081
    
  4. Wenden Sie das hubble-ui-128.yaml-Manifest an:

    kubectl apply -f hubble-ui-128.yaml
    
  5. Geben Sie den Dienst mit Portweiterleitung frei:

    kubectl -n gke-managed-dpv2-observability port-forward service/hubble-ui 16100:80 --address='0.0.0.0'
    
  6. Greifen Sie in Ihrem Webbrowser auf die Hubble-UI zu:

    http://localhost:16100/

Nächste Schritte