Esegui il deployment del Collector OpenTelemetry su Google Kubernetes Engine

Questo documento mostra come eseguire OpenTelemetry Collecting in un cluster GKE per raccogliere log, metriche e tracce OTLP dalle applicazioni strumentate ed esportare questi dati in Google Cloud.

Prima di iniziare

L'esecuzione del raccoglitore OpenTelemetry su GKE richiede le seguenti risorse:

  • Un progetto Google Cloud con le API Cloud Monitoring, Cloud Trace API e API Cloud Logging abilitate.

    • Se non hai un progetto Google Cloud, segui questi passaggi:

      1. Nella console Google Cloud, vai a Nuovo progetto:

        Creare un nuovo progetto

      2. Nel campo Nome progetto, inserisci un nome per il progetto, quindi fai clic su Crea.

      3. Vai a Fatturazione:

        Vai a Fatturazione

      4. Seleziona il progetto appena creato se non è già selezionato nella parte superiore della pagina.

      5. Ti viene chiesto di scegliere un profilo pagamenti esistente o di crearne uno nuovo.

      L'API Monitoring, l'API Trace e l'API Logging sono abilitate per impostazione predefinita per i nuovi progetti.

    • Se hai già un progetto Google Cloud, assicurati che le API Monitoring, Trace e API Logging siano abilitate:

      1. Vai ad API e servizi:

        Vai ad API e servizi

      2. Seleziona il progetto.

      3. Fai clic su  Abilita API e servizi.

      4. Cerca ogni API per nome.

      5. Nei risultati di ricerca, fai clic sull'API denominata. L'API Monitoring viene visualizzata come "API Stackdriver Monitoring".

      6. Se non viene visualizzato il messaggio "API abilitata", fai clic sul pulsante Attiva.

  • Un cluster Kubernetes. Se non hai un cluster Kubernetes, segui le istruzioni riportate nella guida rapida per GKE.

  • I seguenti strumenti a riga di comando:

    • gcloud
    • kubectl

    Gli strumenti gcloud e kubectl fanno parte dellGoogle Cloud CLI. Per informazioni sull'installazione, consulta Gestire i componenti dell'interfaccia a riga di comando Google Cloud. Per visualizzare i componenti gcloud CLI che hai installato, esegui il seguente comando:

    gcloud components list

Esegui il deployment del raccoglitore

La pipeline del Collector può essere implementata direttamente da GitHub con i seguenti comandi dopo aver sostituito PROJECT_ID con l'ID del tuo progetto Google Cloud:

export GCLOUD_PROJECT=PROJECT_ID
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest.git/k8s/base | envsubst | kubectl apply -f -

Monitora ed esegui il debug del raccoglitore

OpenTelemetry Collector fornisce immediatamente le metriche di auto-osservabilità per aiutarti a monitorarne le prestazioni e garantire il tempo di attività continuo della pipeline di importazione OTLP.

Per monitorare il raccoglitore, installa la dashboard di esempio per il raccoglitore. Questa dashboard offre informazioni di riepilogo su diverse metriche del Collector, tra cui uptime, utilizzo della memoria e chiamate API a Google Cloud Observability.

Per installare la dashboard:

  1. Nella console Google Cloud, vai alla pagina  Dashboard:

    Vai a Dashboard

    Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

  2. Seleziona la scheda Sample Library (Raccolta di Sample).
  3. Seleziona la categoria OpenTelemetry Collector.
  4. Seleziona la dashboard "OpenTelemtry Collector".
  5. Fai clic su  Importa.

Per ulteriori informazioni sulla procedura di installazione, consulta Installare dashboard di esempio.

Configura il raccoglitore

La pipeline di importazione OTLP autogestita include una configurazione predefinita di OpenTelemetry Collector progettata per fornire elevati volumi di metriche, log e tracce OTLP con metadati GKE e Kubernetes coerenti allegati. È inoltre progettato per prevenire i problemi di importazione più comuni.

Tuttavia, potresti avere esigenze specifiche che richiedono la personalizzazione della configurazione predefinita. Questa sezione descrive i valori predefiniti forniti con la pipeline e come puoi personalizzarli in base alle tue esigenze.

La configurazione predefinita di Collector si trova su GitHub come config/collector.yaml:

# 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
#
#     http://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.

exporters:
  googlecloud:
    log:
      default_log_name: opentelemetry-collector
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.106.0
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.106.0

extensions:
  health_check:
    endpoint: ${env:MY_POD_IP}:13133
processors:
  filter/self-metrics:
    metrics:
      include:
        match_type: strict
        metric_names:
        - otelcol_process_uptime
        - otelcol_process_memory_rss
        - otelcol_grpc_io_client_completed_rpcs
        - otelcol_googlecloudmonitoring_point_count
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  k8sattributes:
    extract:
      metadata:
      - k8s.namespace.name
      - k8s.deployment.name
      - k8s.statefulset.name
      - k8s.daemonset.name
      - k8s.cronjob.name
      - k8s.job.name
      - k8s.node.name
      - k8s.pod.name
      - k8s.pod.uid
      - k8s.pod.start_time
    passthrough: false
    pod_association:
    - sources:
      - from: resource_attribute
        name: k8s.pod.ip
    - sources:
      - from: resource_attribute
        name: k8s.pod.uid
    - sources:
      - from: connection
  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  metricstransform/self-metrics:
    transforms:
    - action: update
      include: otelcol_process_uptime
      operations:
      - action: add_label
        new_label: version
        new_value: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.106.0

  # We need to add the pod IP as a resource label so the k8s attributes processor can find it.
  resource/self-metrics:
    attributes:
    - action: insert
      key: k8s.pod.ip
      value: ${env:MY_POD_IP}

  resourcedetection:
    detectors: [gcp]
    timeout: 10s

  transform/collision:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["exported_location"], attributes["location"])
      - delete_key(attributes, "location")
      - set(attributes["exported_cluster"], attributes["cluster"])
      - delete_key(attributes, "cluster")
      - set(attributes["exported_namespace"], attributes["namespace"])
      - delete_key(attributes, "namespace")
      - set(attributes["exported_job"], attributes["job"])
      - delete_key(attributes, "job")
      - set(attributes["exported_instance"], attributes["instance"])
      - delete_key(attributes, "instance")
      - set(attributes["exported_project_id"], attributes["project_id"])
      - delete_key(attributes, "project_id")

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  prometheus/self-metrics:
    config:
      scrape_configs:
      - job_name: otel-self-metrics
        scrape_interval: 1m
        static_configs:
        - targets:
          - ${env:MY_POD_IP}:8888

service:
  extensions:
  - health_check
  pipelines:
    logs:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - resourcedetection
      - memory_limiter
      - batch
      receivers:
      - otlp
    metrics/otlp:
      exporters:
      - googlemanagedprometheus
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - transform/collision
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - resource/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - prometheus/self-metrics
    traces:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    metrics:
      address: ${env:MY_POD_IP}:8888

Esportatori

Gli esportatori predefiniti includono l'esportatore googlecloud (per log e tracce) e l'esportatore googlemanagedprometheus (per le metriche).

L'esportatore googlecloud è configurato con un nome predefinito per i log. L'esportatoregooglemanagedprometheus non richiede alcuna configurazione predefinita. Per ulteriori informazioni sulla configurazione di questo esportatore, consulta Introduzione al Collector OpenTelemetry nella documentazione di Google Cloud Managed Service per Prometheus.

Processori

La configurazione predefinita include i seguenti processori:

  • batch: configurato per raggruppare le richieste di telemetria in base al numero massimo di voci per richiesta di Google Cloud o all'intervallo minimo di 5 secondi di Google Cloud (a seconda del caso).
  • k8sattributes: mappa automaticamente gli attributi delle risorse Kubernetes alle etichette di telemetria.
  • memory_limiter: limita l'utilizzo della memoria del Collector a un livello ragionevole per evitare arresti anomali dovuti a esaurimento della memoria eliminando i punti dati oltre questo livello.
  • resourcedetection: rileva automaticamente le etichette delle risorse Google Cloud, come il nome del cluster e l'ID progetto.
  • transform: Rinomina le etichette delle metriche che potrebbero entrare in conflitto con i campi risorsa monitorata di Google Cloud.

Ricevitori

La configurazione predefinita include solo il otlp ricevente. Consulta Scegliere un approccio di instrumentation per istruzioni dettagliate su come eseguire l'instrumentation delle applicazioni per inviare le tracce e le metriche OTLP all'endpoint OTLP del Collector.

Passaggi successivi: raccogli e visualizza la telemetria

Questa sezione descrive come eseguire il deployment di un'applicazione di esempio, indirizzarla all'endpoint OTLP del Collector e visualizzare la telemetria in Google Cloud. L'applicazione di esempio è un piccolo generatore che esporta tracce, log e metriche nel Collector.

Se hai già un'applicazione instrumentata con un SDK OpenTelemetry, puoi indirizzarla all'endpoint del Collector.

Per eseguire il deployment dell'applicazione di esempio, esegui il seguente comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/otlp-k8s-ingest/main/sample/app.yaml

Per indirizzare le applicazioni esistenti che utilizzano l'SDK OpenTelemetry all'endpoint del Collector, imposta la variabile di ambiente OTEL_EXPORTER_OTLP_ENDPOINT su http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317.

Dopo alcuni minuti, la telemetria generata dall'applicazione inizia a essere inviata tramite il Collector alla console Google Cloud per ogni indicatore.