Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment del raccoglitore OpenTelemetry su Google Kubernetes Engine

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

Prima di iniziare

L'esecuzione di OpenTelemetry Collector su GKE richiede quanto segue di risorse:

Un progetto Google Cloud in cui sono abilitate l'API Cloud Monitoring, Cloud Trace API e l'API Cloud Logging.
- 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. e fai clic su Crea.
  3. Vai a Fatturazione:
    
    Vai a Fatturazione
  4. Seleziona il progetto appena creato, se non lo è già selezionata nella parte superiore della pagina.
  5. Ti viene chiesto di scegliere un profilo pagamenti esistente per 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 L'API Monitoring, l'API Trace e l'API Logging sono abilitate:
  1. Vai su API e Google Cloud:
    
    Vai su 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 "API abilitata" non viene visualizzato, fai clic sul pulsante Attiva.
Un cluster Kubernetes. Se non hai un cluster Kubernetes, segui le istruzioni nella Guida rapida per GKE.
I seguenti strumenti a riga di comando:
- gcloud
- kubectl
Gli strumenti gcloud e kubectl fanno parte Google Cloud CLI. Per informazioni sull'installazione consulta Gestione dei componenti dell'interfaccia a riga di comando di Google Cloud. Per vedere le componenti gcloud CLI che hai installato, esegui questo comando:
```
gcloud components list
```

esegui il deployment del raccoglitore

Il deployment della pipeline del raccoglitore può essere eseguito direttamente da GitHub con quanto segue 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 -

Osserva ed esegui il debug del raccoglitore

OpenTelemetry Collector fornisce metriche di autoosservabilità pronte all'uso per aiutarti a monitorarne le prestazioni e garantire un tempo di attività continuo dell'OTLP di importazione dati.

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

Per installare la dashboard, procedi nel seguente modo:

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 Monitoraggio.
Seleziona la scheda Raccolta di esempi.
Seleziona la categoria OpenTelemetry Collector.
Seleziona "OpenTelemtry Collector" Fitbit.com.
Fai clic su Importa.

Per saperne di più sul processo di installazione, consulta Installazione di esempio dashboard.

Configura il raccoglitore

La pipeline di importazione OTLP autogestita include un parametro Configurazione di OpenTelemetry Collector progettata per fornire volumi elevati di metriche, log e tracce OTLP con metadati GKE e Kubernetes coerenti in allegato. Inoltre, è progettato per prevenire i problemi comuni di importazione.

Tuttavia, potresti avere esigenze uniche che richiedono la personalizzazione del valore predefinito . Questa sezione descrive i valori predefiniti forniti con la pipeline e come puoi personalizzare le impostazioni predefinite in base alle tue esigenze.

La configurazione predefinita del raccoglitore 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.105.0
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.105.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.105.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 googlecloud esportatore (per log e tracce) e googlemanagedprometheus esportatore (per le metriche).

L'esportatore googlecloud è configurato con un nome di log predefinito. La L'utilità di esportazione googlemanagedprometheus non richiede alcuna configurazione predefinita. consulta la Guida introduttiva a OpenTelemetry Raccoglitore nella documentazione di Google Cloud Managed Service per Prometheus per saperne di più configurando questo esportatore.

Processori

La configurazione predefinita include i seguenti processori:

batch: Configurata per eseguire in batch richieste di telemetria in batch al numero massimo di Google Cloud voci per richiesta o con un intervallo minimo di Google Cloud ogni 5 secondi (a seconda dell'evento che si verifica per primo).
k8sattributes: Mappa automaticamente gli attributi delle risorse Kubernetes su etichette di telemetria.
memory_limiter: Limita l'utilizzo della memoria del raccoglitore a un livello ragionevole per evitare di esaurire la memoria si arresta in modo anomalo facendo cadere punti dati oltre questo livello.
resourcedetection: Rileva automaticamente le etichette delle risorse Google Cloud, come il nome del cluster e dell'ID progetto.
transform: Rinomina le etichette delle metriche che entrerebbero in collisione con la risorsa monitorata da Google Cloud campi.

Ricevitori

La configurazione predefinita include solo otlp destinatario. Consulta la sezione Scegliere una strumentazione per informazioni dettagliate Istruzioni su come strumentare le tue applicazioni per eseguire il push di tracce e metriche OTLP nell'endpoint OTLP del raccoglitore.

Passaggi successivi: raccogli e visualizza la telemetria

Questa sezione descrive il deployment di un'applicazione di esempio e indica che all'endpoint OTLP del raccoglitore e la visualizzazione della telemetria in Google Cloud. L'applicazione di esempio è un piccolo generatore che esporta tracce, log e metriche al raccoglitore.

Se hai già un'applicazione instrumentata con un SDK OpenTelemetry, puoi invece puntare l'applicazione all'endpoint del raccoglitore.

Per eseguire il deployment dell'applicazione di esempio, esegui questo 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 al campo 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 passare tramite il raccoglitore alla console Google Cloud per ogni segnale.