Diese Seite wurde von der Cloud Translation API übersetzt.

Von Google erstellten OpenTelemetry-Collector in der Google Kubernetes Engine bereitstellen

In diesem Dokument wird beschrieben, wie Sie den von Google entwickelten OpenTelemetry Collector in Google Kubernetes Engine ausführen, um OTLP-Logs, ‑Messwerte und ‑Traces aus instrumentierten Anwendungen zu erfassen und diese Daten dann nach Google Cloudzu exportieren.

Hinweise

Für die Ausführung des von Google entwickelten OpenTelemetry Collectors 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 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, müssen die Monitoring API, die Trace API und die Logging API aktiviert sein:
  
  Enable the APIs
Einen Kubernetes-Cluster. Wenn Sie keinen Kubernetes-Cluster haben, folgen Sie der Anleitung im Schnellstart 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 CLI verwalten. Führen Sie den folgenden Befehl aus, um die installierten gcloud CLI-Komponenten aufzurufen:
```
gcloud components list
```

Berechtigungen für den Collector konfigurieren

Wenn Sie die GKE-Workload-Identität deaktiviert haben, können Sie diesen Abschnitt überspringen.

Damit das Kubernetes-Dienstkonto des OpenTelemetry Collectors die erforderlichen Berechtigungen zum Exportieren von Telemetriedaten hat, bitten Sie Ihren Administrator, dem Kubernetes-Dienstkonto des OpenTelemetry Collectors die folgenden IAM-Rollen für Ihr Projekt zu erteilen:

Monitoring-Messwert-Autor (roles/monitoring.metricWriter)
Logging Log Writer (roles/logging.logWriter)
Cloud Trace-Agent (roles/cloudtrace.agent)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Ihr Administrator kann dem Kubernetes-Dienstkonto des OpenTelemetry Collectors möglicherweise auch die erforderlichen Berechtigungen über benutzerdefinierte Rollen oder andere vordefinierte Rollen erteilen.

Verwenden Sie die folgenden add-iam-policy-binding-Befehle, um die Berechtigungen zu konfigurieren:

gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/logging.logWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/monitoring.metricWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/cloudtrace.agent \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector

Ersetzen Sie vor dem Ausführen der Befehle die folgenden Variablen:

PROJECT_ID: Die Kennung des Projekts.
PROJECT_NUMBER: Die Google Cloud Projektnummer.

Collector bereitstellen

Die Collector-Pipeline kann direkt aus den geprüften Beispielen bereitgestellt werden, die im Self-Managed OTLP Kubernetes Ingestion-Repository verfügbar sind. Sie können direkt von GitHub aus bereitstellen. Ersetzen Sie dazu PROJECT_ID durch die ID Ihres Google Cloud Projekts und führen Sie die folgenden Befehle aus:

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

Ersetzen Sie vor dem Ausführen der Befehle die folgenden Variablen:

PROJECT_ID: Die Kennung des Projekts.
PROJECT_NUMBER: Die numerische Kennung des Projekts.

Collector konfigurieren

Wir stellen eine OpenTelemetry Collector-Konfiguration zur Verfügung, die Sie mit dem von Google entwickelten Collector verwenden können. Diese Konfiguration ist für die Bereitstellung großer Mengen von OTLP-Messwerten, ‑Logs und ‑Traces mit konsistenten GKE- und Kubernetes-Metadaten konzipiert. Diese Konfiguration soll auch häufige Probleme bei der Aufnahme verhindern. Sie können der Konfiguration Elemente hinzufügen, aber wir empfehlen dringend, keine Elemente zu entfernen.

In diesem Abschnitt werden die bereitgestellte Konfiguration, die wichtigsten Komponenten wie Exporter, Prozessoren und Empfänger sowie andere verfügbare Komponenten beschrieben.

Bereitgestellte Collector-Konfiguration

Die Collector-Konfiguration für Kubernetes-Umgebungen finden Sie im otlp-k8s-ingest-Repository:

# 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.4.0 OpenTelemetry Collector Built By Google/0.128.0 (linux/amd64)
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.4.0 OpenTelemetry Collector Built By Google/0.128.0 (linux/amd64)
  # The otlphttp exporter is used to send traces to Google Cloud Trace using OTLP http/proto
  # The otlp exporter could also be used to send them using OTLP grpc
  otlphttp:
    encoding: proto
    endpoint: https://telemetry.googleapis.com
    # Use the googleclientauth extension to authenticate with Google credentials
    auth:
      authenticator: googleclientauth


extensions:
  health_check:
    endpoint: ${env:MY_POD_IP}:13133
  googleclientauth:


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.replicaset.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.4.0 OpenTelemetry Collector Built By Google/0.128.0 (linux/amd64)

  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")

  # The relative ordering of statements between ReplicaSet & Deployment and Job & CronJob are important.
  # The ordering of these controllers is decided based on the k8s controller documentation available at
  # https://kubernetes.io/docs/concepts/workloads/controllers.
  # The relative ordering of the other controllers in this list is inconsequential since they directly
  # create pods.
  transform/aco-gke:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["top_level_controller_type"], "ReplicaSet") where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.replicaset.name"]) where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_type"], "Deployment") where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.deployment.name"]) where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_type"], "DaemonSet") where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.daemonset.name"]) where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_type"], "StatefulSet") where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.statefulset.name"]) where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_type"], "Job") where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.job.name"]) where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_type"], "CronJob") where resource.attributes["k8s.cronjob.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.cronjob.name"]) where resource.attributes["k8s.cronjob.name"] != nil

  # When sending telemetry to the GCP OTLP endpoint, the gcp.project_id resource attribute is required to be set to your project ID.
  resource/gcp_project_id:
    attributes:
    - key: gcp.project_id
      # MAKE SURE YOU REPLACE THIS WITH YOUR PROJECT ID
      value: ${GOOGLE_CLOUD_PROJECT}
      action: insert
  # The metricstarttime processor is important to include if you are using the prometheus receiver to ensure the start time is set properly.
  # It is a no-op otherwise.
  metricstarttime:
    strategy: subtract_initial_point

receivers:
  # This collector is configured to accept OTLP metrics, logs, and traces, and is designed to receive OTLP from workloads running in the cluster.
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  otlp/self-metrics:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:14317

service:
  extensions:
  - health_check
  - googleclientauth
  pipelines:
    logs:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - resourcedetection
      - memory_limiter
      - batch
      receivers:
      - otlp
    metrics/otlp:
      exporters:
      - googlemanagedprometheus
      processors:
      - k8sattributes
      - memory_limiter
      - metricstarttime
      - resourcedetection
      - transform/collision
      - transform/aco-gke
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp/self-metrics
    traces:
      exporters:
      - otlphttp
      processors:
      - k8sattributes
      - memory_limiter
      - resource/gcp_project_id
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    logs:
      encoding: json
    metrics:
      readers:
      - periodic:
          exporter:
            otlp:
              protocol: grpc
              endpoint: ${env:MY_POD_IP}:14317

Exporteure

Die Collector-Konfiguration umfasst die folgenden Exporter:

googlecloud-Exporter für Logs und Traces. Dieser Exporter ist mit einem Standardlognamen konfiguriert.
googlemanagedprometheus-Exporter für Messwerte. Für diesen Exporteur ist keine Konfiguration erforderlich, es gibt aber Konfigurationsoptionen. Informationen zu den Konfigurationsoptionen für den googlemanagedprometheus-Exporter finden Sie in der Dokumentation zu Google Cloud Managed Service for Prometheus unter Erste Schritte mit dem OpenTelemetry Collector.

Prozessoren

Die Collector-Konfiguration umfasst die folgenden Prozessoren:

batch: Konfiguriert, um Telemetrieanfragen mit der Google Cloud maximalen Anzahl von Einträgen pro Anfrage oder mit dem Google Cloud Mindestintervall von 5 Sekunden (je nachdem, was zuerst erreicht ist) in Batches zu verarbeiten.
memory_limiter: Beschränkt die Speichernutzung des Collectors, um Abstürze aufgrund von Speichermangel zu verhindern. Dazu werden Datenpunkte verworfen, wenn das Limit überschritten wird.
resourcedetection: Erkennt automatisch Google Cloud Ressourcenlabels wie project_id und cluster_name.
k8sattributes: Ordnet Kubernetes-Ressourcenattribute automatisch Telemetrielabels zu.
transform: Benennt Messwertlabels um, die mit Labels für überwachte Ressourcen vom Typ Google Cloudkollidieren.

Empfänger

Die Collector-Konfiguration enthält nur den otlp-Empfänger. Informationen zum Instrumentieren Ihrer Anwendungen zum Senden von OTLP-Traces und -Messwerten an den OTLP-Endpunkt des Collectors finden Sie unter Instrumentierungsansatz auswählen.

Verfügbare Komponenten

Der von Google entwickelte OpenTelemetry Collector enthält die Komponenten, die die meisten Nutzer benötigen, um Google Cloud Observability optimal nutzen zu können. Eine vollständige Liste der verfügbaren Komponenten finden Sie im opentelemetry-operations-collector-Repository unter Components.

Wenn Sie Änderungen oder Ergänzungen an den verfügbaren Komponenten anfordern möchten, erstellen Sie eine Funktionsanfrage im opentelemetry-operations-collector-Repository.

Telemetrie generieren

In diesem Abschnitt wird beschrieben, wie Sie eine Beispielanwendung bereitstellen, diese Anwendung auf den OTLP-Endpunkt des Collectors verweisen und die Telemetrie inGoogle Cloudansehen. 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 wurde, 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 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.

Telemetriedaten ansehen

Der von Google entwickelte OpenTelemetry Collector sendet Messwerte, Logs und Traces aus Ihren instrumentierten Anwendungen an Google Cloud Observability. Der Collector sendet auch Messwerte zur Selbstbeobachtung. In den folgenden Abschnitten wird beschrieben, wie Sie diese Telemetriedaten aufrufen.

Messwerte ansehen

Der von Google entwickelte OpenTelemetry Collector erfasst Prometheus-Messwerte, die Sie mit dem Metrics Explorer aufrufen können. Die erfassten Messwerte hängen von der Instrumentierung der App ab. Der von Google entwickelte Collector schreibt jedoch auch einige eigene Messwerte.

So rufen Sie die vom Google-eigenen OpenTelemetry Collector erfassten Messwerte auf:

Rufen Sie in der Google Cloud Console die Seite Metrics Explorer auf:
Zum Metrics Explorer

Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.
Wählen Sie in der Symbolleiste der Google Cloud -Console Ihr Google Cloud -Projekt aus. Wählen Sie für App Hub-Konfigurationen das App Hub-Hostprojekt oder das Verwaltungsprojekt des für Apps aktivierten Ordners aus.
Maximieren Sie im Element Messwert das Menü Messwert auswählen, geben Sie Prometheus Target in die Filterleiste ein und wählen Sie dann über die Untermenüs einen bestimmten Ressourcentyp und Messwert aus:
1. Wählen Sie im Menü Aktive Ressourcen die Option Prometheus-Ziel aus.
2. Einen Messwert wählen Sie in den Menüs Aktive Messwertkategorien und Aktive Messwerte aus. Messwerte, die vom Google-eigenen OpenTelemetry Collector erfasst werden, haben das Präfix prometheus.googleapis.com.
3. Klicken Sie auf Übernehmen.
Konfigurieren Sie, wie die Daten angezeigt werden.
Wenn die Messungen für einen Messwert kumulativ sind, normalisiert Metrics Explorer die gemessenen Daten automatisch nach dem Ausrichtungszeitraum. Dadurch wird im Diagramm eine Rate angezeigt. Weitere Informationen finden Sie unter Arten, Typen und Umwandlungen.

Wenn ganzzahlige oder doppelte Werte gemessen werden, z. B. mit counter-Messwerten, summiert der Metrics Explorer automatisch alle Zeitachsen. Wenn Sie dieses Verhalten ändern möchten, legen Sie das erste Menü des Eintrags Aggregation auf Keine fest.

Weitere Informationen zum Konfigurieren eines Diagramms finden Sie unter Messwerte bei Verwendung von Metrics Explorer auswählen.

Traces ansehen

So rufen Sie Ihre Trace-Daten auf:

Rufen Sie in der Google Cloud Console die Seite Trace Explorer auf:
Zum Trace Explorer

Sie können diese Seite auch über die Suchleiste finden.
Wählen Sie in der Symbolleiste der Google Cloud -Console Ihr Google Cloud -Projekt aus. Wählen Sie für App Hub-Konfigurationen das App Hub-Hostprojekt oder das Verwaltungsprojekt des für Apps aktivierten Ordners aus.
Wählen Sie im Tabellenbereich der Seite eine Zeile aus.
Wählen Sie im Gantt-Diagramm im Bereich Trace-Details einen Span aus.

Ein Bereich mit Informationen zur verfolgten Anfrage wird geöffnet. Zu diesen Details gehören die Methode, der Statuscode, die Anzahl der Byte und der User-Agent des Aufrufers.
Wählen Sie den Tab Logs und Ereignisse aus, um die mit diesem Trace verknüpften Logs aufzurufen.

Auf dem Tab werden einzelne Logs angezeigt. Maximieren Sie den Logeintrag, um die Details anzusehen. Sie können auch auf Logs ansehen klicken und das Log mit dem Log-Explorer aufrufen.

Weitere Informationen zur Verwendung von Cloud Trace-Explorer finden Sie unter Traces suchen und untersuchen.

Logs ansehen

Im Log-Explorer können Sie Ihre Logs prüfen und sich auch die zugehörigen Traces ansehen, sofern vorhanden.

Rufen Sie in der Google Cloud Console die Seite Log-Explorer auf:
Zum Log-Explorer

Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Logging ist.
Suchen Sie nach einem Logeintrag aus Ihrer instrumentierten App. Maximieren Sie den Logeintrag, um die Details anzusehen.
Klicken Sie auf Traces für einen Logeintrag mit einer Trace-Nachricht und wählen Sie dann Trace-Details anzeigen aus.

Der Bereich Trace-Details wird geöffnet und zeigt den ausgewählten Trace an.

Weitere Informationen zur Verwendung des Log-Explorers finden Sie unter Logs mit dem Log-Explorer ansehen.

Collector beobachten und debuggen

Der von Google entwickelte OpenTelemetry Collector bietet automatisch 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:

Öffnen Sie in der Google Cloud Console die Seite Dashboards :
Dashboards aufrufen

Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.
Klicken Sie auf Dashboard-Vorlagen.
Suchen Sie nach dem Dashboard OpenTelemetry Collector.
Optional: Wenn Sie sich eine Vorschau des Dashboards ansehen möchten, wählen Sie es aus.
Klicken Sie auf Dashboard in Liste aufnehmen und füllen Sie das Dialogfeld aus.

Im Dialogfeld können Sie den Namen des Dashboards auswählen und Labels hinzufügen.

Weitere Informationen zum Installieren von Dashboards finden Sie unter Dashboardvorlage installieren.