Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

OpenTelemetry-Instrumentierung ohne Code für Java-Arbeitslasten in GKE verwenden

Mit der Zero-Code-Instrumentierung von OpenTelemetry können Sie automatisch Messwerte und Traces von Java-Anwendungen erfassen, die in Google Kubernetes Engine (GKE) ausgeführt werden, ohne den Anwendungscode ändern zu müssen. In dieser Schritt-für-Schritt-Anleitung stellen Sie eine Java-Beispielanwendung in GKE bereit, konfigurieren die automatische Instrumentierung von OpenTelemetry und rufen die generierten Telemetriedaten in Google Cloud Observability auf. Diese Schritte konzentrieren sich zwar auf Java-Arbeitslasten, Sie können diesen Ansatz aber auch auf andere unterstützte Sprachen ausweiten.

Vorteile der Zero-Code-Instrumentierung

Die No-Code-Instrumentierung (auch automatische Instrumentierung genannt) in OpenTelemetry ist ein leistungsstarkes Tool, mit dem Anwendungsentwickler ihrem Code konfigurierbare Beobachtbarkeit hinzufügen können, ohne zusätzlichen Code schreiben oder vorhandenen Code ändern zu müssen. Bei der Instrumentierung ohne Code wird die Instrumentierung automatisch zu aktiv bereitgestellten Anwendungsbibliotheken hinzugefügt. So erhalten Sie zuverlässige Einblicke in die Anwendungsleistung, indem Golden Signals ausgegeben werden. Die Instrumentierung ohne Code ist daher ein hervorragender Ausgangspunkt für die Beobachtbarkeit einer Anwendung.

Bei der Zero-Code-Instrumentierung in Java werden Messwerte und Trace-Spans ausgegeben, indem gängige Bibliotheken instrumentiert werden, die im Ökosystem der Sprache weit verbreitet sind. Für Java umfassen die Messwerte:

JVM-Laufzeitmesswerte, die von der Java-Plattform ausgegeben werden
HttpClient-Messwerte und HttpClient-Spans, die von Bibliotheken wie der Http Client-Bibliothek für Java und der Http Client-Bibliothek von Google ausgegeben werden.
Messwerte für Datenbankclients und Spans für Datenbankclients, die von Bibliotheken wie JDBC und Lettuce ausgegeben werden.

Die ausgegebenen Messwerte hängen von der instrumentierten Anwendung und den von der Anwendung verwendeten Bibliotheken ab. Eine vollständige Liste der Bibliotheken und Frameworks, die vom Java-Zero-Code-Instrumentierungs-Agent instrumentiert werden können, finden Sie unter Unterstützte Bibliotheken und Frameworks.

Mit der automatischen Instrumentierung haben Sie beispielsweise folgende Möglichkeiten:

Sie können die Golden Signals-Überwachung nutzen, ohne Codeänderungen vornehmen zu müssen.
Korrelieren Sie eine hohe p99.9-Latenz mit einzelnen Nutzer-Traces, die jeden RPC-Aufruf umfassen.
Sie erhalten konsistente Telemetriedaten für Messwerte, Logs und Traces aus einer Vielzahl gängiger Bibliotheken und Frameworks.

Weitere Informationen zur Instrumentierung ohne Code finden Sie unter OpenTelemetry Zero-code.

Übersicht

Wenn Sie einer Java-Arbeitslast, die in GKE ausgeführt wird, Beobachtbarkeit hinzufügen möchten, müssen Sie die folgenden Komponenten bereitstellen:

OpenTelemetry-Zero-Code-Instrumentierung, die die Telemetriedaten aus Ihrer Anwendung generiert.
Der OpenTelemetry Collector erfasst die von Ihrer Anwendung generierte Telemetrie, reichert sie mit wichtigen Metadaten und Kontext an und leitet sie zur Nutzung an Google Cloud weiter.

In dieser Schritt-für-Schritt-Anleitung stellen Sie eine instrumentierte Java-Anwendung in der GKE bereit, die Messwerte und Traces an Google Cloudsendet. Anschließend können Sie diese Telemetriesignale mit den Observability-Angeboten von Google Cloudwie Metrics Explorer, Logs Explorer und Trace Explorer ansehen. Informationen zum Aufrufen und Verwenden der generierten Telemetriedaten finden Sie unter Telemetriedaten ansehen.

In dieser Anleitung werden die folgenden kostenpflichtigen Dienste zum Schreiben von Signalen verwendet:

Managed Service for Prometheus von Cloud Monitoring
Cloud Logging
Cloud Trace
Google Kubernetes Engine
Cloud Build
Artifact Registry

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Hinweis

In diesem Abschnitt wird beschrieben, wie Sie Ihre Umgebung für die Bereitstellung und Instrumentierung der App und die anschließende Ausführung einrichten.

Google Cloud Projekt auswählen oder erstellen

Wählen Sie ein Google Cloud -Projekt für diese Schritt-für-Schritt-Anleitung aus. Wenn Sie noch kein Google Cloud Projekt haben, erstellen Sie eines:

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Befehlszeilentools installieren

In diesem Dokument werden die folgenden Befehlszeilentools verwendet:

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

Umgebungsvariablen festlegen

Legen Sie die folgenden Umgebungsvariablen fest, um die Eingabe häufiger Werte zu reduzieren, Tippfehler zu vermeiden und die Befehle in diesem Dokument ausführbar zu machen:

export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export CLUSTER_REGION=us-east1
export ARTIFACT_REGISTRY=opentelemetry-autoinstrument-registry
export REGISTRY_LOCATION=us-east4

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

PROJECT_ID: Die Kennung des Projekts.
CLUSTER_NAME: Der Name des Clusters. Dies kann sich auf einen neuen oder vorhandenen Cluster beziehen.
us-east1: Die Region für Ihren Cluster. Wenn Sie einen vorhandenen Cluster verwenden, verwenden Sie die Region dieses Clusters.
opentelemetry-autoinstrument-registry: Der Name Ihres Artifact Registry-Repositorys. Dies kann sich auf ein neues oder vorhandenes Repository beziehen.
us-east4: Die Region für Ihr Artifact Registry-Repository. Wenn Sie ein vorhandenes Repository verwenden, verwenden Sie die Region dieses Repositorys.

Wenn beim Ausführen der Befehle in diesem Dokument Fehler auftreten, prüfen Sie, ob diese Variablen in Ihrer Terminalumgebung richtig festgelegt sind.

APIs aktivieren

Wenn Sie die Dienste in diesem Dokument verwenden möchten, müssen die folgenden APIs in Ihrem Google Cloud -Projekt aktiviert sein:

Artifact Registry API: artifactregistry.googleapis.com
Cloud Build API: cloudbuild.googleapis.com
Google Kubernetes Engine: container.googleapis.com
Identity and Access Management API: iam.googleapis.com
Cloud Logging API: logging.googleapis.com
Cloud Monitoring API: monitoring.googleapis.com
Telemetry API: telemetry.googleapis.com

Diese APIs, mit Ausnahme der Telemetry API, sind möglicherweise bereits in Ihrem Projekt in Google Cloud aktiviert. Führen Sie den folgenden Befehl aus, um die aktivierten APIs aufzulisten:

gcloud services list

Aktivieren Sie alle APIs, die noch nicht aktiviert sind. Achten Sie besonders auf die Telemetrie API, telemetry.googleapis.com. In diesem Dokument wird diese API möglicherweise zum ersten Mal erwähnt.

Führen Sie die Befehle für die entsprechenden APIs aus, um APIs zu aktivieren, die noch nicht aktiviert sind:

gcloud services enable artifactregistry.googleapis.com
gcloud services enable cloudbuild.googleapis.com
gcloud services enable container.googleapis.com
gcloud services enable iam.googleapis.com
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com
gcloud services enable telemetry.googleapis.com

Berechtigungen abrufen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen der Anwendung und zum Schreiben von Log-, Messwert- und Trace-Daten benötigen:
- Log-Autor (roles/logging.logWriter) für Ihr Projekt
- Monitoring-Messwert-Autor (roles/monitoring.metricWriter) für Ihr Projekt
- Cloud Telemetry Traces Writer (roles/telemetry.tracesWriter) für Ihr Projekt
- Entwickler (roles/container.developer) für Ihr Projekt
- Cloud Build-Bearbeiter (roles/cloudbuild.builds.editor) für Ihr Projekt
- Artifact Registry-Autor (roles/artifactregistry.writer) für Ihr Projekt
- Dienstkontonutzer (roles/iam.serviceAccountUser) für Ihr Projekt
- Service Usage Consumer (roles/serviceusage.serviceUsageConsumer) für Ihr Kontingentprojekt
Diese Berechtigungen reichen aus, wenn Sie das Beispiel in Cloud Shell, auf Google Cloud -Ressourcen oder in einer lokalen Entwicklungsumgebung ausführen. Informationen zum Konfigurieren eines Kontingentprojekts finden Sie unter Kontingentprojekt festlegen.

Wichtig: Produktionsanwendungen verwenden in der Regel ein Dienstkonto, um die Anmeldedaten bereitzustellen, die zum Schreiben von Log-, Messwert- und Trace-Daten erforderlich sind. Weisen Sie dem Dienstkonto in diesen Szenarien die vorherigen Rollen zu.
Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Aufrufen von Log-, Messwert- und Trace-Daten benötigen:
- Loganzeige (roles/logging.viewer)
- Monitoring-Betrachter (roles/monitoring.viewer)
- Cloud Trace User (roles/cloudtrace.user)

Cluster einrichten

Richten Sie einen GKE-Cluster für die Beispielanwendung und den Collector ein:

Melden Sie sich mit den folgenden Befehlen in Google Cloud an:

gcloud auth login
gcloud config set project PROJECT_ID

Wenn Sie noch keinen GKE-Cluster haben, erstellen Sie einen Autopilot-Cluster, indem Sie den folgenden Befehl ausführen:
```
gcloud container clusters create-auto --region us-east1 CLUSTER_NAME --project PROJECT_ID
```
Wenn Sie mit Ihrem Cluster interagieren möchten, verbinden Sie das lokale kubectl-Dienstprogramm mit dem folgenden Befehl:
```
gcloud container clusters get-credentials CLUSTER_NAME --region us-east1 --project PROJECT_ID
```

Java-Anwendung bereitstellen

In diesem Abschnitt wird eine nicht instrumentierte Java-Beispielanwendung, das OpenTelemetry Spring Boot-Instrumentierungsbeispiel, in Ihrem Cluster bereitgestellt. In diesem Abschnitt wird Cloud Build und Artifact Registry verwendet, um das Anwendungs-Image zu erstellen und zu speichern.

Wenn Sie noch kein Artifact Registry-Repository haben, erstellen Sie eines mit dem folgenden Befehl:

gcloud artifacts repositories create opentelemetry-autoinstrument-registry --repository-format=docker --location=us-east4 --description="GKE Autoinstrumentation sample app"

Klonen Sie die Beispielanwendung mit dem folgenden Befehl:

git clone https://github.com/GoogleCloudPlatform/opentelemetry-samples.git

Legen Sie die folgenden Umgebungsvariablen fest:

export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export ARTIFACT_REGISTRY=opentelemetry-autoinstrument-registry
export REGISTRY_LOCATION=us-east4

Erstellen Sie das Anwendungs-Image und übertragen Sie es per Push in Ihr Artifact Registry-Repository, indem Sie die folgenden Befehle ausführen:
```
pushd opentelemetry-samples/java/instrumentation-quickstart && \
gcloud builds submit --config <(envsubst < cloudbuild-uninstrumented-app.yaml) . && \
popd
```
Hinweis :Wenn Sie einen Mac verwenden, müssen Sie möglicherweise zuerst das gettext-Paket von Homebrew installieren, bevor Sie die vorherigen Befehle ausführen können. Weitere Informationen Nach der Installation des Pakets müssen Sie möglicherweise Ihre Umgebungsvariablen noch einmal festlegen.

Erstellen Sie eine Kubernetes-Bereitstellungskonfigurationsdatei für die Anwendung. Kopieren Sie die folgende Konfiguration und speichern Sie sie in einer Datei mit dem Namen deployment.yaml:

apiVersion: v1
kind: Service
metadata:
  name: quickstart-app
  labels:
    app: quickstart-app
    app.kubernetes.io/part-of: gke-autoinstrument-guide
spec:
  ports:
    - port: 8080
      targetPort: 8080
      name: quickstart-app
  selector:
    app: quickstart-app
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: quickstart-app
  labels:
    app: quickstart-app
    app.kubernetes.io/part-of: gke-autoinstrument-guide
spec:
  replicas: 2
  selector:
    matchLabels:
      app: quickstart-app
  template:
    metadata:
      labels:
        app: quickstart-app
    spec:
      containers:
        - name: quickstart-app
          image: us-east4-docker.pkg.dev/PROJECT_ID/opentelemetry-autoinstrument-registry/java-quickstart:latest
          ports:
            - containerPort: 8080
              name: quickstart-app

Erstellen Sie einen Namespace für Ihre Anwendung, indem Sie den folgenden Befehl ausführen:
```
kubectl create namespace APPLICATION_NAMESPACE
```
Wenden Sie die Deployment-Konfiguration auf Ihren Cluster an, indem Sie den folgenden Befehl ausführen:
```
kubectl apply -f deployment.yaml -n APPLICATION_NAMESPACE
```
Nachdem Sie das Deployment erstellt haben, kann es eine Weile dauern, bis die Pods erstellt und ausgeführt werden. Führen Sie den folgenden Befehl aus, um den Status der Pods zu prüfen:
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Drücken Sie Strg+C, um den Befehl zu beenden und den Pod-Status nicht mehr zu beobachten.

OpenTelemetry Collector-Instanz einrichten

In diesem Abschnitt erstellen Sie eine weitere Bereitstellung, in der eine von Google erstellte OpenTelemetry Collector-Instanz in Ihrem GKE-Cluster ausgeführt wird. Der Collector ist so konfiguriert, dass Daten mit den folgenden Exportern exportiert werden:

Messwerte mit dem OTLP-HTTP-Exporter
Traces mit dem OTLP-HTTP-Exporter
Logs mit dem Google Cloud Exporter

Anstatt die manuellen Schritte in diesem Dokument zum Bereitstellen des OpenTelemetry Collectors auszuführen, können Sie auch Verwaltetes OpenTelemetry für GKE verwenden. Dabei wird der von Google entwickelte OpenTelemetry Collector in einer verwalteten Umgebung verwendet.

Autorisieren Sie das Kubernetes-Dienstkonto für die Bereitstellung des OpenTelemetry-Collectors, indem Sie die folgenden Befehle ausführen:

export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")

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 \
  --condition=None

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 \
  --condition=None

gcloud projects add-iam-policy-binding projects/PROJECT_ID \
  --role=roles/telemetry.tracesWriter \
  --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector \
  --condition=None

Stellen Sie die von Google entwickelte OpenTelemetry Collector-Instanz in Ihrem GKE-Cluster mit der empfohlenen Standardkonfiguration bereit, indem Sie den folgenden Befehl ausführen:
```
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest//k8s/base?ref=otlpmetric | envsubst | kubectl apply -f -
```
Mit dieser Konfiguration wird der Collector im Namespace opentelemetry bereitgestellt.
Nachdem Sie die Bereitstellung erstellt haben, kann es eine Weile dauern, bis die Pods erstellt und ausgeführt werden. Führen Sie den folgenden Befehl aus, um den Status der Pods zu prüfen:
```
kubectl get po -n opentelemetry -w
```
Drücken Sie Strg + C, um den Befehl zu beenden und die Überwachung des Pod-Status zu beenden.

OpenTelemetry-Zero-Code-Instrumentierung konfigurieren

Wenn Sie die OpenTelemetry-Instrumentierung ohne Code für eine in GKE bereitgestellte Anwendung konfigurieren möchten, installieren Sie den OpenTelemetry Operator in Ihrem GKE-Cluster. Der OpenTelemetry-Operator bietet Zugriff auf eine benutzerdefinierte Kubernetes-Ressourcendefinition (CRD), die Instrumentierungsressource, die zum Einfügen der automatischen Instrumentierung in Kubernetes-Ressourcen verwendet wird, die in einem Cluster ausgeführt werden.

Die Instrumentierungsressource wird mithilfe spezieller Annotationen in bestimmte Arbeitslasten „eingefügt“ oder „angewendet“. Der OpenTelemetry-Operator beobachtet diese Annotationen für Ressourcen, die im Cluster ausgeführt werden, und fügt die entsprechende Instrumentierung in die Anwendungen ein, die von diesen Ressourcen verwaltet werden.

Wenn Sie die Helm-Befehlszeile noch nicht installiert haben, installieren Sie Helm mit den folgenden Befehlen:

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3

chmod 700 get_helm.sh

./get_helm.sh

Wenn cert-manager noch nicht auf dem Cluster installiert ist, installieren Sie es mit den folgenden Befehlen:

helm repo add jetstack https://charts.jetstack.io

helm repo update

helm install \
--create-namespace \
--namespace cert-manager \
--set installCRDs=true \
--set global.leaderElection.namespace=cert-manager \
--set extraArgs={--issuer-ambient-credentials=true} \
cert-manager jetstack/cert-manager

Installieren Sie den OpenTelemetry Operator mit dem folgenden Befehl und der Version 0.140.0 oder höher:

kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/download/v0.140.0/opentelemetry-operator.yaml

Erstellen Sie eine Konfigurationsdatei für die benutzerdefinierte Instrumentation-Ressource, indem Sie eine Datei mit dem Namen instrumentation.yaml mit folgendem Inhalt erstellen:

apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
  name: sample-java-auto-instrumentation
spec:
  exporter:
    endpoint: http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317
  sampler:
    type: parentbased_traceidratio
    # Adjust the sampling rate to control cost
    argument: "0.01"

  java:
    env:
      - name: OTEL_EXPORTER_OTLP_PROTOCOL
        value: grpc
      - name: OTEL_LOGS_EXPORTER
        value: none

Erstellen Sie einen Namespace für den Operator. Sie können denselben Wert verwenden, den Sie für den Anwendungs-Namespace APPLICATION_NAMESPACE verwendet haben.
```
kubectl create namespace INSTRUMENTATION_NAMESPACE
```
Erstellen Sie die benutzerdefinierte Instrumentation-Ressource in Ihrem Cluster und wenden Sie Ihre instrumentation.yaml-Datei an, indem Sie den folgenden Befehl ausführen:
```
kubectl apply -f instrumentation.yaml -n INSTRUMENTATION_NAMESPACE
```

Wenden Sie die Annotation für die automatische Instrumentierung auf die zuvor bereitgestellte Java-Beispielanwendung an. Patchen Sie das ursprüngliche Deployment mit der Annotation, indem Sie den folgenden Befehl ausführen:

kubectl patch deployment.apps/quickstart-app -n APPLICATION_NAMESPACE -p '{"spec":{"template":{"metadata":{"annotations":{"instrumentation.opentelemetry.io/inject-java": "'"INSTRUMENTATION_NAMESPACE"'/sample-java-auto-instrumentation"}}}}}'

Nachdem Sie das Deployment gepatcht haben, wodurch das Anwendungs-Deployment neu gestartet wird, können Sie den Status der Pods in der Anwendung mit dem folgenden Befehl prüfen:
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Drücken Sie Strg + C, um den Befehl zu beenden und die Überwachung des Pod-Status zu beenden.

Die in Ihrem GKE-Cluster bereitgestellte Java-Anwendung wird jetzt automatisch instrumentiert.

Telemetriedaten aus der bereitgestellten Anwendung generieren

Wenn Sie Telemetriedaten aus der automatisch instrumentierten Anwendung generieren möchten, müssen Sie Anfragen an die Anwendung senden, um Nutzeraktivitäten zu simulieren. Sie können einen kontinuierlichen Traffic-Stream generieren, indem Sie einen Traffic-Simulator ausführen. In diesem Abschnitt wird beschrieben, wie Sie den Simulator herunterladen, mit Cloud Build erstellen, das Image in Artifact Registry speichern und den Simulator bereitstellen:

Laden Sie die Traffic-Simulator-Anwendung mit den folgenden Befehlen herunter:

mkdir traffic-simulator && pushd traffic-simulator && \
curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/opentelemetry-operator-sample/refs/heads/main/recipes/self-managed-otlp-ingest/traffic/hey.Dockerfile  && \
curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/opentelemetry-operator-sample/refs/heads/main/recipes/self-managed-otlp-ingest/traffic/cloudbuild-hey.yaml && \
popd

Die vorherigen Befehle führen folgende Schritte aus:

Erstellen Sie ein separates Verzeichnis zum Erstellen einer Anwendung für den Verkehrssimulator.
Laden Sie das Dockerfile für die Anwendung herunter.
Laden Sie die Cloud Build-Konfiguration herunter, um das Anwendungs-Image zu erstellen.

Erstellen Sie das Anwendungs-Image mit Cloud Build und übertragen Sie es per Push in Artifact Registry, indem Sie die folgenden Befehle ausführen:
```
pushd traffic-simulator && \
gcloud builds submit --config <(envsubst < cloudbuild-hey.yaml) . && \
popd
```

Erstellen Sie eine Bereitstellungskonfigurationsdatei für den Simulator, indem Sie den folgenden Inhalt in eine Datei im Verzeichnis traffic-simulator mit dem Namen quickstart-traffic.yaml kopieren:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: traffic-simulator
  labels:
    app.kubernetes.io/part-of: gke-autoinstrument-guide
spec:
  replicas: 1
  selector:
    matchLabels:
      app: traffic-simulator
  template:
    metadata:
      labels:
        app: traffic-simulator
    spec:
      containers:
        - name: traffic-simulator
          image: us-east4-docker.pkg.dev/PROJECT_ID/opentelemetry-autoinstrument-registry/hey:latest
          args:
          - -c=2
          - -q=1
          - -z=1h
          - http://quickstart-app:8080/multi

Stellen Sie den Trafficsimulator mit den folgenden Befehlen bereit:

pushd traffic-simulator && \
kubectl apply -f quickstart-traffic.yaml -n APPLICATION_NAMESPACE && \
popd

Nachdem Sie die Bereitstellung erstellt haben, kann es eine Weile dauern, bis die Pods erstellt und ausgeführt werden. Führen Sie den folgenden Befehl aus, um den Status der Pods zu prüfen:
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Drücken Sie Strg + C, um den Befehl zu beenden und die Überwachung des Pod-Status zu beenden.

Telemetriedaten ansehen

Nachdem der Trafficsimulator begonnen hat, Anfragen an die Anwendung zu senden, generiert die bereitgestellte Java-Anwendung Telemetriedaten. Es kann einige Minuten dauern, bis die Messwerte und Traces in Google Cloudangezeigt werden.

Die vom OpenTelemetry Operator eingefügte Instrumentierung basiert auf dem OpenTelemetry-Java-Agent. Der OpenTelemetry-Java-Agent enthält eine integrierte Instrumentierung für viele gängige Java-Bibliotheken und -Frameworks, die Messwerte ausgeben.
Die eingefügte Instrumentierung erfasst auch automatisch Traces für alle Aufrufe, die an einen von der Beispielanwendung bereitgestellten Endpunkt gesendet werden. Der Traffic-Simulator sendet kontinuierlich Anfragen an den Endpunkt /multi, der von der Java-Anwendung mit einer festen Rate bereitgestellt wird. Der Endpunkt /multi sendet wiederum Anfragen an den Endpunkt /single, um die endgültige Antwort zu generieren. Diese Interaktionen werden als Traces erfasst, die mit dem Trace Explorer aufgerufen werden können.

Messwerte aufrufen

Sie können Ihre automatisch instrumentierten Messwerte im Metrics Explorer von Cloud Monitoring ansehen. Dieser Abschnitt enthält Beispielabfragen, die in PromQL geschrieben wurden.

Rufen Sie in der Google Cloud Console das auf der Seite des Metrics Explorer auf:

Zu Metrics Explorer

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

Zu den Messwerten, die Sie für die Beispielanwendung aufrufen können, gehören:

JVM-Laufzeitmesswerte: Der OpenTelemetry Java-Agent gibt Messwerte zur zugrunde liegenden JVM aus. Diese Messwerte enthalten Informationen zum JVM-Speicher, zur automatischen Speicherbereinigung, zu Klassen, Threads und anderen zugehörigen Konzepten. Eine vollständige Liste der unterstützten JVM-Messwerte finden Sie auf der Seite Semantische Konventionen für JVM-Laufzeitmesswerte.
- JVM-Arbeitsspeichernutzung: Fügen Sie die folgende PromQL-Abfrage in den Metrics Explorer ein:
```
sum(avg_over_time({"process.runtime.jvm.memory.usage"}[${__interval}]))
```
- JVM-CPU-Auslastung: Fügen Sie die folgende PromQL-Abfrage in den Metrics Explorer ein:
```
sum(avg_over_time({"process.runtime.jvm.cpu.utilization"}[${__interval}]))
```
  Das folgende Diagramm zeigt den Messwert für die JVM-CPU-Auslastung:
Spring Boot-Messwerte: Die Beispielanwendung verwendet das Spring Boot-Framework, das auch von der OpenTelemetry-Instrumentierung ohne Code für Java unterstützt wird.
- Mittlere Dauer des HTTP-Clients: Fügen Sie die folgende PromQL-Abfrage in Metrics Explorer ein:
```
sum(rate({"http.client.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.client.duration_count"}[${__interval}])) by (cluster, job)
```
- Durchschnittliche HTTP-Serverdauer: Fügen Sie die folgende PromQL-Abfrage in den Metrics Explorer ein:
```
sum(rate({"http.server.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.server.duration_count"}[${__interval}])) by (cluster, job)
```
  Das folgende Diagramm zeigt den Messwert für die durchschnittliche HTTP-Serverdauer von Spring Boot:

Weitere Informationen zur Verwendung von Metrics Explorer finden Sie unter Messwerte bei Verwendung von Metrics Explorer auswählen.

Traces ansehen

Sie können Ihre automatisch instrumentierten Traces im Trace Explorer von Cloud Trace aufrufen. Sie können diese Traces in Trace Explorer filtern, indem Sie nach „Dienstname“ filtern und den Dienstnamen auf quickstart-app festlegen.

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.

Der folgende Screenshot zeigt Traces, die von der OpenTelemetry-Bereitstellung quickstart-app generiert wurden:

Im Trace Explorer werden Traces angezeigt, die mit der Zero-Code-Instrumentierung von OpenTelemetry erfasst wurden.

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

Bereinigen

Wenn Sie ein neues Google Cloud -Projekt erstellt haben und es nicht mehr benötigen, können Sie es mit dem folgenden Befehl löschen:

gcloud projects delete PROJECT_ID

Wenn Sie ein vorhandenes Projekt verwendet haben, können Sie die im Rahmen dieser Anleitung erstellten Ressourcen löschen, um Kosten zu sparen:

Löschen Sie den GKE-Cluster mit dem folgenden Befehl:

gcloud container clusters delete CLUSTER_NAME --location=us-east1

Löschen Sie das Artifact Registry-Repository mit dem folgenden Befehl:

gcloud artifacts repositories delete opentelemetry-autoinstrument-registry --location=us-east4

OpenTelemetry-Instrumentierung ohne Code für Java-Arbeitslasten in GKE verwenden Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Vorteile der Zero-Code-Instrumentierung

Übersicht

Hinweis

Google Cloud Projekt auswählen oder erstellen

Befehlszeilentools installieren

Umgebungsvariablen festlegen

APIs aktivieren

Berechtigungen abrufen

Cluster einrichten

Java-Anwendung bereitstellen

OpenTelemetry Collector-Instanz einrichten

OpenTelemetry-Zero-Code-Instrumentierung konfigurieren

Telemetriedaten aus der bereitgestellten Anwendung generieren

Telemetriedaten ansehen

Messwerte aufrufen

Traces ansehen

Bereinigen

OpenTelemetry-Instrumentierung ohne Code für Java-Arbeitslasten in GKE verwenden