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 OpenTelemetry-Zero-Code-Instrumentierung können Sie automatisch Messwerte und Traces von Java-Anwendungen erfassen, die in der Google Kubernetes Engine (GKE) ausgeführt werden, ohne den Anwendungscode zu ändern. In dieser Schritt-für-Schritt-Anleitung stellen Sie eine Java-Beispielanwendung in GKE bereit, konfigurieren die automatische OpenTelemetry-Instrumentierung 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 Zero-Code-Instrumentierung wird die Instrumentierung automatisch zu aktiv bereitgestellten Anwendungsbibliotheken hinzugefügt. So erhalten Sie zuverlässige Informationen zur 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.
Datenbankclient-Messwerte und Datenbankclient-Spans, 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 können Sie Folgendes tun:

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 Zero-Code-Instrumentierung finden Sie unter Zero-Code von OpenTelemetry.

Ü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 Telemetrie aus Ihrer Anwendung generiert.
Der OpenTelemetry Collector, der die von Ihrer Anwendung generierten Telemetriedaten erfasst, sie mit wichtigen Metadaten und Kontext anreichert und zur Nutzung an Google Cloud weiterleitet.

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

In dieser Schritt-für-Schritt-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 Anwendung einrichten und sie dann ausführen.

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:

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.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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 Projekt in Google Cloud 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. Möglicherweise ist dieses Dokument das erste Mal, dass Sie mit dieser API in Berührung kommen.

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 erforderlichen Anmeldedaten zum Schreiben von Log-, Messwert- und Trace-Daten bereitzustellen. 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 mit dem folgenden Befehl:
```
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 werden 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, um die vorherigen Befehle auszuführen. Weitere Informationen finden Sie in diesem Stack Overflow-Artikel. 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 mit dem folgenden Befehl einen Namespace für Ihre Anwendung:
```
kubectl create namespace APPLICATION_NAMESPACE
```
Wenden Sie die Bereitstellungskonfiguration 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 die Überwachung des Pod-Status zu beenden.

OpenTelemetry Collector-Instanz einrichten

In diesem Abschnitt erstellen Sie ein weiteres Deployment, das eine von Google entwickelte OpenTelemetry Collector-Instanz in Ihrem GKE-Cluster ausführt. 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./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./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./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. Führen Sie dazu den folgenden Befehl aus:
```
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
```
Drücken Sie Strg + C, um den Befehl zu beenden und die Überwachung des Pod-Status zu beenden.

OpenTelemetry-Instrumentierung ohne Code konfigurieren

Wenn Sie die OpenTelemetry-Zero-Code-Instrumentierung 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 verwenden Sie die 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 Instrumentierungsressource, indem Sie eine Datei mit dem Namen instrumentation.yaml und 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 Instrumentierungsressource in Ihrem Cluster und wenden Sie die Datei instrumentation.yaml 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, wird das Anwendungs-Deployment neu gestartet. Sie können 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 ist 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. Sie können einen kontinuierlichen Traffic-Stream generieren, indem Sie einen Traffic-Simulator in Ihrem Cluster bereitstellen:

Erstellen Sie eine Bereitstellungskonfigurationsdatei für den Simulator, indem Sie den folgenden Inhalt in eine Datei 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: golang:1.24
          command:
            - go
            - run
            - github.com/rakyll/hey@latest
            - -c=2
            - -q=1
            - -z=1h
            - http://quickstart-app:8080/multi

Stellen Sie den Trafficsimulator mit dem folgenden Befehl bereit:

kubectl apply -f quickstart-traffic.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 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-Agenten. 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 angezeigt 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.

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-Speicher, automatischer Speicherbereinigung, 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 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-Zero-Code-Instrumentierung für Java unterstützt wird.
- Durchschnittliche HTTP-Clientdauer: Fügen Sie die folgende PromQL-Abfrage in den Metrics Explorer ein:
```
sum(rate({"http.client.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.client.duration_count"}[${__interval}])) by (cluster, job)
```
- Mittlere 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-quickstart-app-Bereitstellung 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 Schritt-für-Schritt-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