OpenTelemetry Collector in Google Kubernetes Engine bereitstellen

In diesem Dokument wird beschrieben, wie Sie den OpenTelemetry Collector in einem GKE-Cluster ausführen, um OTLP-Protokolle, -Messwerte und -Traces aus instrumentierten Anwendungen zu erfassen und diese Daten nach Google Cloud zu exportieren.

Hinweise

Für das Ausführen des OpenTelemetry Collector in GKE sind die folgenden Ressourcen erforderlich:

  • Ein Google Cloud-Projekt mit aktivierter Cloud Monitoring API, Cloud Trace API und Cloud Logging API.

    • Wenn Sie kein Google Cloud-Projekt haben, gehen Sie so vor:

      1. Wechseln Sie in der Google Cloud Console zu Neues Projekt:

        Neues Projekt erstellen

      2. Geben Sie im Feld Projektname einen Namen für Ihr Projekt ein und klicken Sie dann auf Erstellen.

      3. Wechseln Sie zu Billing (Abrechnung):

        Zur Abrechnung

      4. Wählen Sie das Projekt aus, das Sie gerade erstellt haben, falls es nicht bereits oben auf der Seite ausgewählt wurde.

      5. Sie werden aufgefordert, ein vorhandenes Zahlungsprofil auszuwählen oder ein neues Zahlungsprofil zu erstellen.

      Die Monitoring API, die Trace API und die Logging API sind für neue Projekte standardmäßig aktiviert.

    • Wenn Sie bereits ein Google Cloud-Projekt haben, dann stellen Sie sicher, dass die Monitoring API, die Trace API und die Logging API aktiviert sind:

      1. Gehen Sie zu APIs & Dienste:

        Zu APIs und Dienste

      2. Wählen Sie Ihr Projekt aus.

      3. Klicken Sie auf  APIs und Dienste aktivieren.

      4. Suchen Sie nach den einzelnen APIs anhand ihrer Namen.

      5. Klicken Sie in den Suchergebnissen auf die gewünschte API. Die Monitoring API wird als „Stackdriver Monitoring API“ angezeigt.

      6. Wenn "API aktiviert" nicht angezeigt wird, klicken Sie auf die Schaltfläche Aktivieren.

  • Einen Kubernetes-Cluster. Wenn Sie keinen Kubernetes-Cluster haben, folgen Sie der Anleitung in der Kurzanleitung für GKE.

  • Die folgenden Befehlszeilentools:

    • gcloud
    • kubectl

    Die Tools gcloud und kubectl sind Teil der Google Cloud CLI. Informationen zur Installation finden Sie unter Komponenten der Google Cloud-Befehlszeile verwalten. Führen Sie den folgenden Befehl aus, um die installierten gloud CLI-Komponenten aufzurufen:

    gcloud components list

Collector bereitstellen

Die Collector-Pipeline kann direkt über GitHub mit den folgenden Befehlen bereitgestellt werden, nachdem Sie PROJECT_ID durch die ID Ihres Google Cloud-Projekts ersetzt haben:

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

Collector beobachten und debuggen

Der OpenTelemetry Collector bietet sofort einsetzbare Messwerte zur Selbstbeobachtbarkeit, mit denen Sie die Leistung überwachen und eine kontinuierliche Verfügbarkeit der OTLP-Aufnahmepipeline gewährleisten können.

Wenn Sie den Collector überwachen möchten, installieren Sie das Beispiel-Dashboard für den Collector. Dieses Dashboard bietet einen übersichtlichen Überblick über verschiedene Messwerte des Collectors, einschließlich Betriebszeit, Arbeitsspeichernutzung und API-Aufrufe an Google Cloud Observability.

So installieren Sie das Dashboard:

  1. Rufen Sie in der Google Cloud Console die Seite Dashboards auf.

    Dashboards aufrufen

    Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.

  2. Wählen Sie den Tab Beispielbibliothek aus.
  3. Wählen Sie die Kategorie OpenTelemetry Collector aus.
  4. Wählen Sie das Dashboard "OpenTelemetry Collector" aus.
  5. Klicken Sie auf  Importieren.

Weitere Informationen zur Installation finden Sie unter Beispiel-Dashboards installieren.

Collector konfigurieren

Die selbst verwaltete OTLP-Aufnahmepipeline enthält eine Standardkonfiguration des OpenTelemetry-Collectors, die für die Übermittlung großer Mengen von OTLP-Messwerten, ‑Protokollen und ‑Traces mit konsistenten GKE- und Kubernetes-Metadaten entwickelt wurde. Außerdem soll es häufige Probleme bei der Datenaufnahme verhindern.

Möglicherweise haben Sie jedoch spezielle Anforderungen, die eine Anpassung der Standardkonfiguration erfordern. In diesem Abschnitt werden die mit der Pipeline gelieferten Standardeinstellungen beschrieben und wie Sie diese nach Ihren Anforderungen anpassen können.

Die Standardkonfiguration des Collectors befindet sich auf GitHub unter 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

Exporteure

Zu den Standard-Exportern gehören der Exporter googlecloud (für Protokolle und Traces) und der Exporter googlemanagedprometheus (für Messwerte).

Der googlecloud-Exporter ist mit einem Standardprotokollnamen konfiguriert. Der Exporter googlemanagedprometheus erfordert keine Standardkonfiguration. Weitere Informationen zur Konfiguration dieses Exporters finden Sie unter Erste Schritte mit dem OpenTelemetry Collector in der Dokumentation zu Google Cloud Managed Service for Prometheus.

Prozessoren

Die Standardkonfiguration umfasst die folgenden Prozessoren:

  • batch: Konfiguriert, um Telemetrieanfragen mit der maximalen Anzahl von Einträgen pro Anfrage in Google Cloud oder mit dem Google Cloud-Mindestintervall von 5 Sekunden (je nachdem, was zuerst erreicht ist) in Batches zu verarbeiten.
  • k8sattributes: Ordnet Kubernetes-Ressourcenattribute automatisch Telemetrielabels zu.
  • memory_limiter: Mit dieser Option wird die Arbeitsspeichernutzung des Collectors auf einem angemessenen Niveau begrenzt, um Abstürze aufgrund von Arbeitsspeichermangel zu verhindern. Dazu werden Datenpunkte über diesem Niveau verworfen.
  • resourcedetection: Google Cloud-Ressourcenlabels wie Clustername und Projekt-ID werden automatisch erkannt.
  • transform: Benennt Messwertlabels um, die mit Google Cloud-überwachten Ressourcenfeldern kollidieren würden.

Empfänger

Die Standardkonfiguration enthält nur den otlp-Empfänger. Unter Instrumentierungsansatz auswählen finden Sie eine detaillierte Anleitung zur Instrumentierung Ihrer Anwendungen, um OTLP-Traces und ‑Messwerte an den OTLP-Endpunkt des Collectors zu senden.

Nächste Schritte: Telemetriedaten erfassen und ansehen

In diesem Abschnitt wird beschrieben, wie Sie eine Beispielanwendung bereitstellen, diese Anwendung auf den OTLP-Endpunkt des Collectors verweisen und die Telemetriedaten in Google Cloud aufrufen. Die Beispielanwendung ist ein kleiner Generator, der Traces, Protokolle und Messwerte an den Collector exportiert.

Wenn Sie bereits eine Anwendung haben, die mit einem OpenTelemetry SDK instrumentiert ist, können Sie Ihre Anwendung stattdessen auf den Endpunkt des Collectors verweisen.

Führen Sie den folgenden Befehl aus, um die Beispielanwendung bereitzustellen:

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

Wenn Sie vorhandene Anwendungen, die das OpenTelemetry SDK verwenden, auf den Endpunkt des Collectors verweisen lassen möchten, legen Sie die Umgebungsvariable OTEL_EXPORTER_OTLP_ENDPOINT auf http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317 fest.

Nach einigen Minuten beginnt die von der Anwendung generierte Telemetrie, für jedes Signal durch den Collector an die Google Cloud Console zu fließen.