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

In diesem Dokument wird gezeigt, wie Sie Java-Anwendungen, die in Google Kubernetes Engine (GKE) ausgeführt werden, automatisch mit OpenTelemetry-Instrumentierung ohne Code instrumentieren. Mit der instrumentierungsfreien Beobachtbarkeit erhalten Sie umfassende Einblicke in Ihre Java-Arbeitslasten – und das mit minimalem manuellem Aufwand.

In dieser Anleitung finden Sie eine detaillierte Schritt-für-Schritt-Anleitung zum Bereitstellen einer Beispiel-Java-Anwendung in GKE, zum automatischen Instrumentieren der Anwendung mit OpenTelemetry und zum Visualisieren der generierten Telemetriesignale mit Google Cloud Observability.

In der Anleitung wird die automatische Instrumentierung von Java-Arbeitslasten beschrieben, die in GKE ausgeführt werden. Sie können diese Anleitung jedoch auf andere unterstützte Sprachen ausweiten.

Vorteile der instrumentierung ohne Code

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

Bei der Instrumentierung ohne Code in Java werden Messwerte und Trace-Spans durch Instrumentierung beliebter Bibliotheken ausgegeben, die im Ökosystem der Sprache weit verbreitet sind. Für Java sind folgende Messwerte verfügbar:

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

Die Menge der ausgegebenen Messwerte hängt von der instrumentierten Anwendung und den von der Anwendung verwendeten Bibliotheken ab. Eine vollständige Liste der Bibliotheken und Frameworks, die vom Java-Agent für die instrumentierungsfreie Instrumentierung instrumentiert werden können, finden Sie unter Unterstützte Bibliotheken und Frameworks.

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

Golden Signals-Monitoring ohne Codeänderungen
Hohe Latenz im 99,9.Perzentil mit einzelnen Nutzer-Traces korrelieren, die jeden RPC-Aufruf umfassen.
Sie erhalten einheitliche Telemetriedaten für Messwerte, Logs und Traces aus einer Vielzahl beliebter 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-Instrumentierung ohne Code, die die Telemetrie aus Ihrer Anwendung generiert.
Der OpenTelemetry Collector erfasst die von Ihrer Anwendung generierten Telemetriedaten, reichert sie mit wichtigen Metadaten und Kontext an und leitet sie zur Nutzung an Google Cloud weiter.

In dieser Anleitung stellen Sie eine instrumentierte Java-Anwendung in GKE bereit, die Messwerte und Traces an Google Cloudausgibt. Sie können diese Telemetriesignale dann mit den Observability-Angeboten von Google Cloudwie Metrics Explorer, Logs Explorer und Trace Explorer ansehen. Informationen zum Ansehen 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 Projekt in Google Cloud für diese 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 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

Um das Eintippen häufig verwendeter Werte zu reduzieren, Tippfehler zu vermeiden und die Ausführung der Befehle in diesem Dokument zu ermöglichen, legen Sie die folgenden Umgebungsvariablen fest:

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 für Ihr Artifact Registry-Repository. Dies kann sich auf ein neues oder ein vorhandenes Repository beziehen.
us-east4: Die Region für Ihr Artifact Registry-Repository. Wenn Sie ein vorhandenes Repository verwenden, nutzen 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 der wahrscheinlichen Ausnahme der Telemetry API, sind möglicherweise bereits in Ihrem Google Cloud -Projekt 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 Telemetry API, telemetry.googleapis.com. Möglicherweise ist dies das erste Mal, dass Sie auf diese API stoßen.

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

Cluster einrichten

GKE-Cluster für die Beispielanwendung und den Collector einrichten:

Melden Sie sich in Google Cloud an, indem Sie die folgenden Befehle ausführen:
```
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
```
Um mit Ihrem Cluster zu interagieren, stellen Sie mit dem folgenden Befehl eine Verbindung zu Ihrem lokalen kubectl-Dienstprogramm her:
```
gcloud container clusters get-credentials CLUSTER_NAME --region us-east1 --project PROJECT_ID
```

Java-Anwendung bereitstellen

Bei den Schritten 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, indem Sie den folgenden Befehl ausführen:

git clone https://github.com/GoogleCloudPlatform/opentelemetry-operations-java.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. Verwenden Sie dazu die folgenden Befehle:
```
pushd opentelemetry-operations-java/examples/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 finden Sie in diesem Stack Overflow-Artikel. Nach der Installation des Pakets müssen Sie möglicherweise Ihre Umgebungsvariablen neu 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
```
Wenn Sie den Pod-Status nicht länger beobachten möchten, drücken Sie Strg+C, um den Befehl zu beenden.

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 Managed 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 mit der empfohlenen Standardkonfiguration in Ihrem GKE-Cluster 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 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 opentelemetry -w
```
Wenn Sie den Pod-Status nicht länger beobachten möchten, drücken Sie Strg+C, um den Befehl zu beenden.

OpenTelemetry-Instrumentierung ohne Code konfigurieren

Wenn Sie die Zero-Code-Instrumentierung von OpenTelemetry 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 Instrumentation-Ressource, die verwendet wird, um die automatische Instrumentierung in Kubernetes-Ressourcen einzufügen, die in einem Cluster ausgeführt werden.

Die Instrumentation Resource 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 von diesen Ressourcen verwalteten Anwendungen ein.

Wenn Sie die Helm-CLI 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. Verwenden Sie 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 verwendet haben: APPLICATION_NAMESPACE.
```
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 Beispiel-Java-Anwendung 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 die Anwendungsbereitstellung 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
```
Wenn Sie den Pod-Status nicht länger beobachten möchten, drücken Sie Strg+C, um den Befehl zu beenden.

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

Telemetriedaten aus der bereitgestellten Anwendung generieren

Damit Telemetriedaten aus der automatisch instrumentierten Anwendung generiert werden, müssen Sie Anfragen an die Anwendung senden, um Nutzeraktivitäten zu simulieren. Mit einem Traffic-Simulator können Sie einen stetigen Traffic-Stream generieren. 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 Anwendung für den Verkehrssimulator 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

Mit den vorherigen Befehlen wird Folgendes ausgeführt:

Erstellen Sie ein separates Verzeichnis für die Entwicklung einer Verkehrssimulatoranwendung.
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 Traffic-Simulator mit den folgenden Befehlen bereit:

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

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
```
Wenn Sie den Pod-Status nicht länger beobachten möchten, drücken Sie Strg+C, um den Befehl zu beenden.

Telemetriedaten ansehen

Nachdem der Traffic-Simulator mit dem Senden von Anfragen an die Anwendung begonnen hat, 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 beliebte 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 /multi-Endpunkt sendet wiederum Anfragen an den /single-Endpunkt, 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 die automatisch instrumentierten Messwerte im Metrics Explorer von Cloud Monitoring aufrufen. Dieser Abschnitt enthält Beispielabfragen, die in PromQL geschrieben sind.

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.

Für die Beispielanwendung können Sie unter anderem die folgenden Messwerte aufrufen:

JVM-Laufzeitmesswerte: Der OpenTelemetry Java-Agent gibt Messwerte zur zugrunde liegenden JVM aus. Diese Messwerte enthalten Informationen zu JVM-Arbeitsspeicher, Garbage Collection, 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-Speichernutzung: Fügen Sie die folgende PromQL-Abfrage in Metrics Explorer ein:
```
sum(avg_over_time({"process.runtime.jvm.memory.usage"}[${__interval}]))
```
- JVM-CPU-Auslastung: Fügen Sie die folgende PromQL-Abfrage in 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)
```
- Mittlere Dauer des HTTP-Servers: Fügen Sie die folgende PromQL-Abfrage in 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 Dauer des HTTP-Servers in 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 ansehen. Sie können diese Traces im 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 von der OpenTelemetry-Instrumentierung ohne Code erfasst wurden.

Weitere Informationen zur Verwendung des Trace-Explorers 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 Ressourcen löschen, die Sie im Rahmen dieser Anleitung erstellt haben, 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 instrumentierung ohne Code

Übersicht

Hinweis

Google Cloud Projekt auswählen oder erstellen

Befehlszeilentools installieren

Umgebungsvariablen festlegen

APIs aktivieren

Cluster einrichten

Java-Anwendung bereitstellen

OpenTelemetry Collector-Instanz einrichten

OpenTelemetry-Instrumentierung ohne Code 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