Configurare l'osservabilità di GKE Dataplane V2

Autopilot Standard

---

Questa pagina mostra come configurare i cluster Google Kubernetes Engine (GKE) con l'osservabilità di GKE Dataplane V2, a partire dalle versioni GKE 1.28 o successive. Per ulteriori informazioni sui vantaggi e sui requisiti dell'osservabilità di GKE Dataplane V2, consulta Informazioni sull'osservabilità di GKE Dataplane V2.

Nota: puoi attivare le metriche di GKE Dataplane V2 e gli strumenti di osservabilità di GKE Dataplane V2 indipendentemente l'uno dall'altro.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

• Attiva l'API Google Kubernetes Engine.
Attiva l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializzala. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti le località predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

Configura le metriche GKE Dataplane V2

Per raccogliere le metriche, devi configurare le metriche GKE Dataplane V2. Puoi configurare le metriche di GKE Dataplane V2 quando crei un cluster o aggiorni un cluster in esecuzione con GKE Dataplane V2. Puoi abilitare o disabilitare le metriche di GKE Dataplane V2 utilizzando gcloud CLI.

Ti consigliamo di abilitare le metriche GKE Dataplane V2 e Google Cloud Managed Service per Prometheus sul tuo cluster GKE. Una volta abilitate entrambe, le metriche di GKE Dataplane V2 vengono inviate a Google Cloud Managed Service per Prometheus.

Crea un cluster Autopilot con le metriche di GKE Dataplane V2 abilitate

Quando crei nuovi cluster GKE Autopilot, GKE abilita le metriche di GKE Dataplane V2 per impostazione predefinita sul cluster senza richiedere un flag specifico.

Per utilizzare le metriche GKE Dataplane V2 del cluster GKE Autopilot con Google Cloud Managed Service per Prometheus, configura la risorsa ClusterPodMonitoring per estrarre le metriche e inviarle a Google Cloud Managed Service per Prometheus.

1. Crea un manifest ClusterPodMonitoring:

   # 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. Applica il manifest ClusterPodMonitoring:

   kubectl apply -f ClusterPodMonitoring.yaml
   

Nota: per impostazione predefinita, Google Cloud Managed Service per Prometheus non è configurato per raccogliere le metriche GKE Dataplane V2 sui cluster Autopilot. Dopo aver configurato la risorsa ClusterPodMonitoring, GKE addebita un costo di importazione in base al volume delle metriche.

Crea un cluster Standard con le metriche di GKE Dataplane V2 abilitate

Per abilitare le metriche di GKE Dataplane V2, crea un cluster con il flag --enable-dataplane-v2-metrics:

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

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del tuo cluster.

Il flag --enable-managed-prometheus indica a GKE di utilizzare le metriche con Google Cloud Managed Service per Prometheus.

Abilita le metriche di GKE Dataplane V2 su un cluster esistente

Per abilitare le metriche di GKE Dataplane V2 su un cluster esistente, esegui questo comando:

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

Sostituisci CLUSTER_NAME con il nome del cluster.

Disabilita le metriche di GKE Dataplane V2

Per disabilitare le metriche di GKE Dataplane V2:

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

Sostituisci CLUSTER_NAME con il nome del cluster.

Configura gli strumenti di osservabilità di GKE Dataplane V2

Puoi utilizzare un endpoint privato per accedere agli strumenti di risoluzione dei problemi di osservabilità di GKE Dataplane V2. Per abilitare gli strumenti di osservabilità di GKE Dataplane V2, devi avere un cluster configurato con GKE Dataplane V2. Puoi abilitare gli strumenti di osservabilità di GKE Dataplane V2 su un nuovo cluster o su un cluster esistente.

Crea un cluster Autopilot con l'osservabilità abilitata

Per creare un cluster GKE Autopilot con l'osservabilità di GKE Dataplane V2 abilitata:

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

Sostituisci quanto segue: * CLUSTER_NAME: il nome del tuo cluster. * COMPUTE_LOCATION: la posizione di Compute Engine per il cluster.

Crea un cluster Standard con l'osservabilità abilitata

Per creare un cluster GKE Standard con l'osservabilità di GKE Dataplane V2 abilitata:

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

Sostituisci quanto segue: * CLUSTER_NAME: il nome del tuo cluster. * COMPUTE_LOCATION: la posizione di Compute Engine per il cluster.

Abilita gli strumenti di osservabilità di GKE Dataplane V2 su un cluster esistente

Per abilitare l'osservabilità di GKE Dataplane V2 su un cluster esistente, esegui questo comando:

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

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del cluster.
• COMPUTE_LOCATION: la posizione di Compute Engine per il cluster.

Disabilita gli strumenti di osservabilità di GKE Dataplane V2

Per disabilitare gli strumenti di osservabilità di GKE Dataplane V2 su un cluster esistente, esegui questo comando:

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

Sostituisci CLUSTER_NAME con il nome del cluster.

Come utilizzare Hubble CLI

Utilizza lo strumento Hubble CLI sul cluster dopo aver abilitato la funzionalità di osservabilità di GKE Dataplane V2.

1. Definisci l'alias per il binario hubble-cli:

   alias hubble="kubectl exec -it -n gke-managed-dpv2-observability deployment/hubble-relay -c hubble-cli -- hubble"
   

2. Per controllare lo stato di Hubble, con la funzionalità di osservabilità di GKE Dataplane V2 abilitata, utilizza la CLI Hubble in tutti i cluster Autopilot:

   hubble status
   

3. Per visualizzare il traffico attuale, utilizza Hubble CLI nel seguente modo:

   hubble observe
   

Nota: questa immagine viene sottoposta a deployment come deployment di un singolo pod sui cluster Standard in cui è attivata l'osservabilità di GKE Dataplane V2. Il pod di cui è stato eseguito il deployment ha un indirizzo IP, una porta e il certificato TLS di Hubble preconfigurato. Non devi specificarli quando utilizzi la CLI di Hubble.

Come eseguire il deployment della distribuzione binaria dell'interfaccia utente di Hubble

Dopo aver attivato l'osservabilità di GKE Dataplane V2, puoi eseguire il deployment dell'interfaccia utente Hubble open source.

1. Abilita l'osservabilità nel cluster GKE:

   1. Crea un cluster GKE con l'osservabilità abilitata:

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

      Sostituisci quanto segue:

      • VERSION: la versione del cluster.
      • COMPUTE_LOCATION: la posizione di Compute Engine per il cluster.

   2. In alternativa, abilita l'osservabilità in un cluster esistente:

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

      Sostituisci quanto segue:

      • CLUSTER_NAME: il nome del cluster.
      • COMPUTE_LOCATION: la posizione di Compute Engine per il cluster.

2. Configura kubectl per connetterti al cluster:

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

   Sostituisci

   • CLUSTER_NAME: il nome del cluster.
   • COMPUTE_LOCATION: la posizione di Compute Engine per il cluster.

3. Esegui il deployment dell'interfaccia utente di Hubble:

   # 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. Applica il manifest hubble-ui-128.yaml:

   kubectl apply -f hubble-ui-128.yaml
   

5. Esporre il servizio con port forwarding:

   kubectl -n gke-managed-dpv2-observability port-forward service/hubble-ui 16100:80 --address='0.0.0.0'
   

6. Accedi all'interfaccia utente di Hubble nel browser web:

   http://localhost:16100/

   Nota: se utilizzi kubectl sulla VM, utilizza http://<VM_IP>:16100/.

Passaggi successivi

• Osserva il traffico utilizzando l'osservabilità di GKE Dataplane V2