Esegui il deployment del Collector OpenTelemetry su Container-Optimized OS

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo documento descrive come eseguire il collezionista OpenTelemetry creato da Google su Container-Optimized OS per raccogliere log, metriche e tracce OTLP dalle applicazioni sottoposte a ispezione e poi esportare questi dati in Google Cloud.

Prima di iniziare

L'esecuzione del raccoglitore OpenTelemetry richiede le seguenti risorse:

• Un progetto Google Cloud con le API Cloud Monitoring, Cloud Trace e 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 Logging siano abilitate:

    Enable the APIs

• Una macchina virtuale (VM) Container-Optimized OS. Se non hai una VM con sistema operativo ottimizzato per i container, segui le istruzioni riportate in Creare e configurare istanze.

• Un'installazione di gcloud. Per informazioni sull'installazione digcloud, consulta Installare Google Cloud CLI.

Configura le autorizzazioni per il raccoglitore

Per impostazione predefinita, le VM con sistema operativo ottimizzato per i container utilizzano l'account di servizio predefinito di Compute Engine,PROJECT_NUMBER-compute@developer.gserviceaccount.com. In genere, questo account di servizio dispone dei ruoli IAM (Identity and Access Management) necessari per scrivere le metriche e i log descritti in questo documento:

• Monitoring Metric Writer (roles/monitoring.metricWriter)
• Logging Log Writer (roles/logging.logWriter)

Se stai configurando un account di servizio personalizzato per la tua istanza, consulta Gestire l'accesso agli account di servizio.

Esegui il deployment del raccoglitore

Per eseguire OpenTelemetry Collector creato da Google, devi fornire un file di configurazione per la VM OS ottimizzata per i contenitori. Puoi utilizzare lo strumento cloud-init per scrivere un file di configurazione. Di seguito è riportato un file cloud-init consigliato per l'utilizzo del Collector creato da Google:

write_files:
- path: /etc/config/config.yaml
  permissions: 0644
  owner: root
  content: |
    receivers:
      # Open two OTLP servers:
      # - On port 4317, open an OTLP GRPC server
      # - On port 4318, open an OTLP HTTP server
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
      otlp:
        protocols:
          grpc:
            endpoint: localhost:4317
          http:
            cors:
              # This effectively allows any origin
              # to make requests to the HTTP server.
              allowed_origins:
              - http://*
              - https://*
            endpoint: localhost:4318

      # Using the prometheus scraper, scrape the Collector's self metrics.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/prometheusreceiver
      # https://opentelemetry.io/docs/collector/internal-telemetry/
      prometheus/self-metrics:
        config:
          scrape_configs:
          - job_name: otel-self-metrics
            scrape_interval: 1m
            static_configs:
            - targets:
              - localhost:8888

    processors:
      # The batch processor is in place to regulate both the number of requests
      # being made and the size of those requests.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor
      batch:
        send_batch_max_size: 200
        send_batch_size: 200
        timeout: 5s

      # The memorylimiter will check the memory usage of the collector process.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor
      memory_limiter:
        check_interval: 1s
        limit_percentage: 65
        spike_limit_percentage: 20

      # The resourcedetection processor is configured to detect GCP resources.
      # Resource attributes that represent the GCP resource the collector is
      # running on will be attached to all telemetry that goes through this
      # processor.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#gcp-metadata
      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")

    exporters:
      # The googlecloud exporter will export telemetry to different
      # Google Cloud services:
      # Logs -> Cloud Logging
      # Metrics -> Cloud Monitoring
      # Traces -> Cloud Trace
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/googlecloudexporter
      googlecloud:
        log:
          default_log_name: opentelemetry-collector

      # The googlemanagedprometheus exporter will send metrics to
      # Google Managed Service for Prometheus.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/googlemanagedprometheusexporter
      googlemanagedprometheus:

    service:
      pipelines:
        logs:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - memory_limiter
          - batch
          exporters:
          - googlecloud
        metrics/otlp:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - transform/collision
          - memory_limiter
          - batch
          exporters:
          - googlemanagedprometheus
        metrics/self-metrics:
          receivers:
          - prometheus/self-metrics
          processors:
          - resourcedetection
          - transform/collision
          - memory_limiter
          - batch
          exporters:
          - googlemanagedprometheus
        traces:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - memory_limiter
          - batch
          exporters:
          - googlecloud
      telemetry:
        metrics:
          address: localhost:8888

Ti consigliamo di creare una rete Docker bridge per facilitare la comunicazione tra il contenitore del Collector e qualsiasi altro contenitore sul sistema che invierà la telemetria. Per creare la rete, esegui il comando seguente:

docker network create -d bridge otel otel

Esegui il contenitore del Collector con il seguente comando:

docker run -d \
    --network otel \
    --name opentelemetry-collector \
    -v /etc/config:/etc/config \
    us-docker.pkg.dev/cloud-ops-agents-artifacts/google-cloud-opentelemetry-collector/otelcol-google:0.122.1 \
    --config=/etc/config/config.yaml

Il comando precedente esegue le seguenti operazioni:

• Esegue il contenitore del raccoglitore in background.
• Collega il contenitore del raccoglitore alla rete bridgeotel creata in precedenza. Altri contenitori possono essere collegati al bridge per inviare la telemetria.
• Monta il file di configurazione sul contenitore in modo da poter accedere al file per configurare il Collector.

Configura il raccoglitore

Forniamo una configurazione di OpenTelemetry Collector da utilizzare con il Collector creato da Google. Questa configurazione è progettata per fornire elevati volumi di metriche, log e tracce OTLP. Questa configurazione è progettata anche per evitare i problemi comuni di importazione. Puoi aggiungere elementi alla configurazione, ma ti consigliamo vivamente di non rimuovere elementi.

Questa sezione descrive la configurazione fornita, i componenti chiave come esportatori, elaboratori, ricevitori e altri componenti disponibili.

Configurazione del raccoglitore fornita

receivers:
  # Open two OTLP servers:
  # - On port 4317, open an OTLP GRPC server
  # - On port 4318, open an OTLP HTTP server
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
  otlp:
    protocols:
      grpc:
        endpoint: localhost:4317
      http:
        cors:
          # This effectively allows any origin
          # to make requests to the HTTP server.
          allowed_origins:
          - http://*
          - https://*
        endpoint: localhost:4318

  # Using the prometheus scraper, scrape the Collector's self metrics.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/prometheusreceiver
  # https://opentelemetry.io/docs/collector/internal-telemetry/
  prometheus/self-metrics:
    config:
      scrape_configs:
      - job_name: otel-self-metrics
        scrape_interval: 1m
        static_configs:
        - targets:
          - localhost:8888

processors:
  # The batch processor is in place to regulate both the number of requests
  # being made and the size of those requests.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  # The memorylimiter will check the memory usage of the collector process.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor
  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  # The resourcedetection processor is configured to detect GCP resources.
  # Resource attributes that represent the GCP resource the collector is
  # running on will be attached to all telemetry that goes through this
  # processor.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#gcp-metadata
  resourcedetection:
    detectors: [gcp]
    timeout: 10s

  # The transform/collision processor ensures that any attributes that may
  # collide with the googlemanagedprometheus exporter's monitored resource
  # construction are moved to a similar name that is not reserved.
  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")

exporters:
  # The googlecloud exporter will export telemetry to different
  # Google Cloud services:
  # Logs -> Cloud Logging
  # Metrics -> Cloud Monitoring
  # Traces -> Cloud Trace
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/googlecloudexporter
  googlecloud:
    log:
      default_log_name: opentelemetry-collector

  # The googlemanagedprometheus exporter will send metrics to
  # Google Managed Service for Prometheus.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/googlemanagedprometheusexporter
  googlemanagedprometheus:

extensions:
  # Opens an endpoint on 13133 that can be used to check the
  # status of the collector. Since this does not configure the
  # `path` config value, the endpoint will default to `/`.
  #
  # When running on Cloud Run, this extension is required and not optional.
  # In other environments it is recommended but may not be required for operation
  # (i.e. in Container-Optimized OS or other GCE environments).
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/healthcheckextension
  health_check:
    endpoint: 0.0.0.0:13133

service:
  extensions:
  - health_check
  pipelines:
    logs:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - memory_limiter
      - batch
      exporters:
      - googlecloud
    metrics/otlp:
      receivers:
      - otlp
      processors:
      - transform/collision
      - resourcedetection
      - memory_limiter
      - batch
      exporters:
      - googlemanagedprometheus
    metrics/self-metrics:
      receivers:
      - prometheus/self-metrics
      processors:
      - resourcedetection
      - memory_limiter
      - batch
      exporters:
      - googlemanagedprometheus
    traces:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - memory_limiter
      - batch
      exporters:
      - googlecloud
  telemetry:
    metrics:
      address: localhost:8888

Esportatori

La configurazione del raccoglitore include i seguenti esportatori:

• googlecloud esportatore per log e tracce. Questo esportatore è configurato con un nome log predefinito.

• Esportatore googlemanagedprometheus per le metriche. Questo esportatore non richiede alcuna configurazione, ma sono disponibili opzioni di configurazione. Per informazioni sulle opzioni di configurazione per l'esportatore googlemanagedprometheus, consulta Introduzione a OpenTelemetry Collector nella documentazione di Google Cloud Managed Service per Prometheus.

Processori

La configurazione del Collector include i seguenti processori:

• batch: configurato per raggruppare le richieste di telemetria in base al Google Cloud numero massimo di voci per richiesta o all' Google Cloud intervallo minimo di ogni 5 secondi (a seconda del caso).

• memory_limiter: limita l'utilizzo della memoria del Collector per evitare arresti anomali dovuti a esaurimento della memoria eliminando i punti dati quando viene superato il limite.

• resourcedetection: rileva automaticamente Google Cloud le etichette delle risorse, ad esempio project_id.

Ricevitori

La configurazione del Collector include solo il otlp ricevente. Per informazioni sulla strumentazione delle applicazioni per inviare tracce e metriche OTLP all'endpoint OTLP del Collector, consulta Scegliere un approccio di strumentazione.

Componenti disponibili

OpenTelemetry Collector creato da Google contiene i componenti di cui la maggior parte degli utenti avrà bisogno per attivare un'esperienza completa in Google Cloud Observability. Per un elenco completo dei componenti disponibili, consulta Componenti nel repository opentelemetry-operations-collector.

Per richiedere modifiche o aggiunte ai componenti disponibili, apri una richiesta di funzionalità. nel repository opentelemetry-operations-collector.

Generare dati di telemetria

Puoi testare la tua configurazione utilizzando lo strumento telemetrygen open source. Il progetto OpenTelemetry fornisce un container nel registry GitHub Container.

Prima di eseguire i comandi seguenti, se hai modificato i valori predefiniti utilizzati nei comandi Docker in Eseguire il deployment del Collector, sostituisci i seguenti segnaposto:

• otel: il nome specificato quando hai creato la rete Dockerbridge.
• opentelemetry-collector: il nome specificato durante l'esecuzione del container.

Generare log

Per generare i log utilizzando lo strumento telemetrygen, esegui il seguente comando:

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  logs --otlp-insecure --rate=3 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

Generare metriche

Per generare metriche utilizzando lo strumento telemetrygen, esegui il seguente comando:

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  metrics --otlp-insecure --rate=0.1 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

Generare metriche

Per generare tracce utilizzando lo strumento telemetrygen, esegui il seguente comando:

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  traces --otlp-insecure --rate=3 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

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

Visualizza la telemetria

OpenTelemetry Collector, creato da Google, invia metriche, log e tracce dalle applicazioni instrumentate a Google Cloud Observability. Il Collector invia anche le metriche di auto-osservabilità. Le sezioni seguenti descrivono come visualizzare questa telemetria.

Visualizzare le metriche

OpenTelemetry Collector, creato da Google, raccoglie le metriche di Prometheus che puoi visualizzare utilizzando Metrics Explorer. Le metriche raccolte dipendono dalla misurazione dell'app, anche se il Collector creato da Google scrive anche alcune metriche proprie.

1. Nella console Google Cloud, vai alla pagina leaderboard Esplora metriche:

   Vai a Esplora metriche

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

2. Nella barra degli strumenti della console Google Cloud, seleziona il tuo progetto Google Cloud. Per le configurazioni di App Hub, seleziona il progetto host di App Hub o il progetto di gestione della cartella abilitata per le app.
3. Nell'elemento Metrica, espandi il menu Seleziona una metrica, digita Prometheus Target nella barra dei filtri e poi utilizza i sottomenu per selezionare un tipo di risorsa e una metrica specifici:
   1. Nel menu Risorse attive, seleziona Destinazione Prometheus.
   2. Per selezionare una metrica, utilizza i menu Categorie di metriche attive e Metriche attive. Le metriche raccolte da OpenTelemetry Collector creato da Google hanno il prefisso prometheus.googleapis.com.
   3. Fai clic su Applica.
4. Configura la visualizzazione dei dati.
   

   Quando le misurazioni di una metrica sono cumulative, Metrics Explorer normalizza automaticamente i dati misurati in base al periodo di allineamento, in modo che il grafico mostri una percentuale. Per maggiori informazioni, consulta Tipi, conversioni e tipi.

   Quando vengono misurati valori interi o doppi, ad esempio con le metriche counter, Metrics Explorer somma automaticamente tutte le serie temporali. Per modificare questo comportamento, imposta il primo menu della voce Aggregazione su Nessuna.

   Per ulteriori informazioni sulla configurazione di un grafico, consulta Selezionare le metriche durante l'utilizzo di Metrics Explorer.

Visualizzare le tracce

Per visualizzare i dati di traccia:

1. Nella console Google Cloud, vai alla pagina Esplora tracce.

   Vai a Trace Explorer

   Puoi trovare questa pagina anche utilizzando la barra di ricerca.

2. Nella barra degli strumenti della console Google Cloud, seleziona il tuo progetto Google Cloud. Per le configurazioni di App Hub, seleziona il progetto host di App Hub o il progetto di gestione della cartella abilitata per le app.
3. Nella sezione della tabella della pagina, seleziona una riga.

4. Nel grafico di Gantt nel riquadro Dettagli su Trace, seleziona un intervallo.

   Viene visualizzato un riquadro che mostra le informazioni sulla richiesta tracciata. Questi dettagli includono il metodo, il codice di stato, il numero di byte e l'agente utente del chiamante.

5. Per visualizzare i log associati a questa traccia, seleziona la scheda Log ed eventi.

   La scheda mostra i singoli log. Per visualizzare i dettagli della voce di log, espandila. Puoi anche fare clic su Visualizza log e visualizzare il log utilizzando Esplora log.

Per ulteriori informazioni sull'utilizzo di Esplora tracce di Cloud, consulta Trovare ed esplorare le tracce.

Visualizza i log

In Esplora log puoi ispezionare i log e anche visualizzare le tracce associate, se esistono.

1. Nella console Google Cloud, vai alla pagina Esplora log:

   Vai a Esplora log

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

2. Individua una voce di log della tua app sottoposta a strumenti. Per visualizzare i dettagli, espandi la voce di log.

3. Fai clic su Tracce in una voce di log con un messaggio di traccia e poi seleziona Visualizza dettagli traccia.

   Si apre un riquadro Dettagli su Trace che mostra la traccia selezionata.

Per ulteriori informazioni sull'utilizzo di Esplora log, consulta Visualizza i log utilizzando Esplora log.

Monitora ed esegui il debug del raccoglitore

OpenTelemetry Collector, creato da Google, fornisce automaticamente 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 rapide 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. Fai clic su Modelli di dashboard.
3. Cerca la dashboard del collezionista OpenTelemetry.
4. (Facoltativo) Per visualizzare l'anteprima della dashboard, selezionala.

5. Fai clic su playlist_add Aggiungi dashboard al tuo elenco e completa la finestra di dialogo.

   La finestra di dialogo ti consente di selezionare il nome della dashboard e di aggiungervi le etichette.

Per saperne di più sull'installazione delle dashboard, consulta Installare un modello di dashboard.