OpenTelemetry Collector in Google Kubernetes Engine bereitstellen

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

Hinweise

Für die Ausführung des OpenTelemetry Collector in GKE sind folgende 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 benannte 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 mit den folgenden Befehlen direkt von GitHub 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.

Installieren Sie zum Überwachen des Collectors 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 zum Installationsprozess finden Sie unter Beispiel-Dashboards installieren.

Collector konfigurieren

Die selbstverwaltete OTLP-Aufnahmepipeline enthält eine OpenTelemetry Collector-Standardkonfiguration, die für die Bereitstellung großer Mengen von OTLP-Messwerten, -Logs und -Traces mit konsistenten GKE- und Kubernetes-Metadaten vorgesehen ist. Außerdem sollen häufige Datenaufnahmeprobleme verhindert werden.

Möglicherweise haben Sie jedoch spezielle Anforderungen, die eine Anpassung der Standardkonfiguration erfordern. In diesem Abschnitt werden die mit der Pipeline gelieferten Standardwerte beschrieben und wie Sie sie an Ihre Anforderungen anpassen können.

Die Standard-Collector-Konfiguration befindet sich auf GitHub als 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

Exporteure

Die Standard-Exporter umfassen den Exporter googlecloud (für Logs und Traces) und den Exporter googlemanagedprometheus (für Messwerte).

Der Exporter googlecloud ist mit einem Standard-Lognamen 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: Beschränkt die Collector-Speichernutzung auf ein angemessenes Niveau, um Abstürze aufgrund fehlenden Arbeitsspeichers zu verhindern. Dazu werden Datenpunkte über dieses Niveau hinaus verworfen.
  • resourcedetection: Erkennt automatisch Google Cloud-Ressourcenlabels wie Clustername und Projekt-ID.
  • transform: Benennt Messwertlabels um, die mit überwachten Ressourcenfeldern von Google Cloud kollidieren würden.

Empfänger

Die Standardkonfiguration enthält nur den Empfänger otlp. 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 übertragen.

Nächste Schritte: Telemetrie erfassen und ansehen

In diesem Abschnitt wird beschrieben, wie Sie eine Beispielanwendung bereitstellen, diese Anwendung auf den OTLP-Endpunkt des Collectors verweisen und die Telemetrie in Google Cloud aufrufen. Die Beispielanwendung ist ein kleiner Generator, der Traces, Logs und Messwerte in 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 verweisen möchten, die das OpenTelemetry SDK am Endpunkt des Collectors verwenden, setzen Sie die Umgebungsvariable OTEL_EXPORTER_OTLP_ENDPOINT auf http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317.

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.