Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Usa la instrumentación sin código de OpenTelemetry para cargas de trabajo de Java en GKE

La instrumentación sin código de OpenTelemetry te permite recopilar automáticamente métricas y seguimientos de aplicaciones de Java que se ejecutan en Google Kubernetes Engine (GKE) sin modificar el código de la aplicación. En esta explicación, implementarás una aplicación de Java de muestra en GKE, configurarás la instrumentación automática de OpenTelemetry y verás la telemetría generada en Google Cloud Observability. Aunque estos pasos se enfocan en las cargas de trabajo de Java, puedes extender este enfoque a otros lenguajes compatibles.

¿Por qué usar la instrumentación sin código?

La instrumentación sin código (también llamada instrumentación automática) en OpenTelemetry es una herramienta potente que permite a los desarrolladores de aplicaciones agregar observabilidad configurable a su código sin necesidad de escribir código adicional ni modificar el código existente. La instrumentación sin código funciona agregando automáticamente instrumentación a las bibliotecas de aplicaciones implementadas de forma activa, lo que proporciona información confiable sobre el rendimiento de las aplicaciones a través de la emisión de indicadores clave. Esto hace que la instrumentación sin código sea un excelente punto de partida para el recorrido de observabilidad de una aplicación.

La instrumentación sin código en Java emite métricas y tramos de seguimiento a través de la instrumentación de bibliotecas populares que se usan ampliamente en el ecosistema del lenguaje. En el caso de Java, las métricas incluyen lo siguiente:

Métricas del entorno de ejecución de JVM emitidas por la plataforma de Java
Métricas de HttpClient y intervalos de HttpClient emitidos desde bibliotecas como la biblioteca cliente HTTP de Java y la biblioteca cliente HTTP de Google.
Métricas del cliente de base de datos y intervalos del cliente de base de datos emitidos desde bibliotecas como JDBC y Lettuce.

El conjunto de métricas emitidas depende de la aplicación que se instrumenta y de las bibliotecas que usa la aplicación. Para obtener una lista completa de las bibliotecas y los frameworks que puede instrumentar el agente de instrumentación sin código de Java, consulta Bibliotecas y frameworks compatibles.

Con la instrumentación automática, puedes hacer lo siguiente:

Obtén la supervisión de indicadores de oro sin tener que realizar cambios en el código.
Correlaciona la latencia alta del percentil 99.9 con los seguimientos de usuarios individuales, que abarcan todas las llamadas RPC.
Obtén telemetría coherente en las métricas, los registros y los seguimientos de una amplia variedad de bibliotecas y frameworks populares.

Para obtener más información sobre la instrumentación sin código, consulta Sin código de OpenTelemetry.

Descripción general

Para agregar observabilidad a una carga de trabajo de Java que se ejecuta en GKE, se deben implementar los siguientes componentes:

La instrumentación sin código de OpenTelemetry, que genera la telemetría desde tu aplicación.
El recopilador de OpenTelemetry, que recopila la telemetría que genera tu aplicación, la enriquece con metadatos y contexto críticos, y la enruta a Google Cloud para su consumo.

En esta explicación, implementarás una aplicación de Java instrumentada en GKE que emite métricas y seguimientos a Google Cloud. Luego, puedes ver estos indicadores de telemetría con las ofertas de observabilidad de Google Cloud, como el Explorador de métricas, el Explorador de registros y el Explorador de seguimiento. Para obtener información sobre cómo ver y usar la telemetría generada, consulta Cómo ver tu telemetría.

En esta explicación, se usan los siguientes servicios facturables para escribir indicadores:

Managed Service para Prometheus de Cloud Monitoring
Cloud Logging
Cloud Trace
Google Kubernetes Engine
Cloud Build
Artifact Registry

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Antes de comenzar

En esta sección, se describe cómo configurar tu entorno para implementar e instrumentar la app y, luego, ejecutarla.

Selecciona o crea un proyecto de Google Cloud

Elige un Google Cloud proyecto para esta explicación. Si aún no tienes un proyecto Google Cloud , crea uno:

Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

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.

Instala herramientas de línea de comandos

En este documento, se usan las siguientes herramientas de línea de comandos:

gcloud
kubectl

Las herramientas gcloud y kubectl forman parte de la CLI de Google Cloud. Para obtener información sobre cómo instalarlos, consulta Administra los componentes de Google Cloud CLI. Para ver los componentes de la gcloud CLI que instalaste, ejecuta el siguiente comando:

gcloud components list

Configura las variables de entorno

Para reducir la escritura de valores frecuentes, evitar errores de escritura y hacer que los comandos de este documento se puedan ejecutar, establece las siguientes variables de entorno:

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

Antes de ejecutar los comandos, reemplaza las siguientes variables o usa los valores predeterminados:

PROJECT_ID: Es el identificador del proyecto.
CLUSTER_NAME: Es el nombre de tu clúster. Puede referirse a un clúster nuevo o existente.
us-east1: Es la región de tu clúster. Si usas un clúster existente, usa la región de ese clúster.
opentelemetry-autoinstrument-registry: Es el nombre de tu repositorio de Artifact Registry. Esto puede hacer referencia a un repositorio nuevo o existente.
us-east4: Es la región de tu repositorio de Artifact Registry. Si usas un repositorio existente, usa la región de ese repositorio.

Si encuentras errores cuando ejecutas los comandos de este documento, verifica que estas variables estén configuradas correctamente en tu entorno de terminal.

Habilita las APIs

Para usar los servicios de este documento, debes tener habilitadas las siguientes APIs en tu proyecto de Google Cloud :

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

Es posible que estas APIs, con la probable excepción de la API de Telemetry, ya estén habilitadas en tu proyecto de Google Cloud . Ejecuta el siguiente comando para enumerar las APIs habilitadas:

gcloud services list

Habilita cualquiera de las APIs que aún no estén habilitadas. Presta especial atención a la API de Telemetry, telemetry.googleapis.com. Es posible que este documento sea la primera vez que encuentres esta API.

Para habilitar las APIs que aún no están habilitadas, ejecuta los comandos de las APIs correspondientes:

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

Obtén permisos

Para obtener los permisos que necesitas para ejecutar la aplicación y hacer que escriba datos de registros, métricas y seguimiento, pídele a tu administrador que te otorgue los siguientes roles de IAM:
- Escritor de registros (roles/logging.logWriter) en tu proyecto
- Escritor de métricas de Monitoring (roles/monitoring.metricWriter) en tu proyecto
- Escritor de seguimientos de telemetría de Cloud (roles/telemetry.tracesWriter) en tu proyecto
- Desarrollador (roles/container.developer) en tu proyecto
- Editor de Cloud Build (roles/cloudbuild.builds.editor) en tu proyecto
- Escritor de Artifact Registry (roles/artifactregistry.writer) en tu proyecto
- Usuario de la cuenta de servicio (roles/iam.serviceAccountUser) en tu proyecto
- Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer) en tu proyecto de cuota
Estos permisos son suficientes si ejecutas la muestra en Cloud Shell, en recursos de Google Cloud o en un entorno de desarrollo local. Para obtener información sobre cómo configurar un proyecto de cuota, consulta Configura el proyecto de cuota.

Importante: Por lo general, las aplicaciones de producción dependen de una cuenta de servicio para proporcionar las credenciales necesarias para escribir datos de registro, métricas y seguimientos. En esos casos, otorga los roles anteriores a la cuenta de servicio.
Para obtener los permisos que necesitas para ver los datos de registros, métricas y seguimientos, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:
- Visor de registros (roles/logging.viewer)
- Visualizador de Monitoring (roles/monitoring.viewer)
- Usuario de Cloud Trace (roles/cloudtrace.user)

Configura tu clúster

Configura un clúster de GKE para la aplicación de ejemplo y el recopilador:

Accede a Google Cloud ejecutando los siguientes comandos:

gcloud auth login
gcloud config set project PROJECT_ID

Si aún no tienes un clúster de GKE, crea uno de Autopilot ejecutando el siguiente comando:

gcloud container clusters create-auto --region us-east1 CLUSTER_NAME --project PROJECT_ID

Para interactuar con tu clúster, conecta tu utilidad kubectl local ejecutando el siguiente comando:

gcloud container clusters get-credentials CLUSTER_NAME --region us-east1 --project PROJECT_ID

Implementa la aplicación de Java

En los pasos de esta sección, se implementa una aplicación de Java de ejemplo sin instrumentar, el ejemplo de instrumentación de Spring Boot de OpenTelemetry, en tu clúster. En esta sección, se usan Cloud Build y Artifact Registry para crear y almacenar la imagen de la aplicación.

Si aún no tienes un repositorio de Artifact Registry, ejecuta el siguiente comando para crear uno:

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

Ejecuta el siguiente comando para clonar la aplicación de ejemplo:

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

Configura las siguientes variables de entorno:

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

Ejecuta los siguientes comandos para compilar la imagen de la aplicación y enviarla a tu repositorio de Artifact Registry:
```
pushd opentelemetry-samples/java/instrumentation-quickstart && \
gcloud builds submit --config <(envsubst < cloudbuild-uninstrumented-app.yaml) . && \
popd
```
Nota: Si usas una Mac, es posible que para ejecutar los comandos anteriores primero debas instalar el paquete gettext desde Homebrew. Para obtener más información, consulta este artículo de Stack Overflow. Después de instalar el paquete, es posible que debas volver a configurar las variables de entorno.

Crea un archivo de configuración de implementación de Kubernetes para la aplicación. Copia la siguiente configuración y guárdala en un archivo llamado 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

Crea un espacio de nombres para tu aplicación ejecutando el siguiente comando:
```
kubectl create namespace APPLICATION_NAMESPACE
```
Ejecuta el siguiente comando para aplicar la configuración de implementación a tu clúster:
```
kubectl apply -f deployment.yaml -n APPLICATION_NAMESPACE
```
Después de crear la implementación, es posible que los Pods tarden un tiempo en crearse y comenzar a ejecutarse. Para verificar el estado de los Pods, ejecuta el siguiente comando:
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Para dejar de supervisar el estado del pod, presiona Ctrl + C para detener el comando.

Configura una instancia del recopilador de OpenTelemetry

En esta sección, crearás otra implementación que ejecute una instancia del recopilador de OpenTelemetry compilado por Google en tu clúster de GKE. El recopilador está configurado para exportar datos con los siguientes exportadores:

Métricas con el exportador de HTTP de OTLP
Seguimientos con el exportador de HTTP de OTLP
Registros con el exportador de Google Cloud

En lugar de seguir los pasos manuales de este documento para implementar el recopilador de OpenTelemetry, puedes seguir OpenTelemetry administrado para GKE, que usa el recopilador de OpenTelemetry integrado en Google en un entorno administrado.

Autoriza la cuenta de servicio de Kubernetes para la implementación del recopilador de OpenTelemetry ejecutando los siguientes comandos:

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

Implementa la instancia del recopilador de OpenTelemetry creado por Google en tu clúster de GKE con la configuración predeterminada recomendada ejecutando el siguiente comando:
```
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest//k8s/base?ref=otlpmetric | envsubst | kubectl apply -f -
```
Esta configuración implementa el recopilador en el espacio de nombres opentelemetry.
Después de crear la implementación, es posible que los Pods tarden un tiempo en crearse y comenzar a ejecutarse. Para verificar el estado de los Pods, ejecuta el siguiente comando:
```
kubectl get po -n opentelemetry -w
```
Para dejar de ver el estado del Pod, presiona Ctrl + C para detener el comando.

Configura la instrumentación sin código de OpenTelemetry

Para configurar la instrumentación sin código de OpenTelemetry para una aplicación implementada en GKE, instala el operador de OpenTelemetry en tu clúster de GKE. El operador de OpenTelemetry proporciona acceso a una definición de recurso personalizado (CRD) de Kubernetes, el recurso de instrumentación, que se usa para insertar la instrumentación automática en los recursos de Kubernetes que se ejecutan dentro de un clúster.

El recurso de instrumentación se "inserta" o "aplica" a cargas de trabajo específicas con anotaciones especiales. El operador de OpenTelemetry observa estas anotaciones en los recursos que se ejecutan dentro del clúster y, luego, inserta la instrumentación adecuada en las aplicaciones que administran esos recursos.

Si aún no tienes instalada la CLI de Helm, ejecuta los siguientes comandos para instalarla:

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

Si aún no tienes cert-manager instalado en el clúster, ejecuta los siguientes comandos para instalarlo:

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

Instala el operador de OpenTelemetry ejecutando el siguiente comando y usando la versión 0.140.0 o una posterior:

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

Crea un archivo de configuración para el recurso personalizado de instrumentación. Para ello, crea un archivo llamado instrumentation.yaml con el siguiente contenido:

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

Crea un espacio de nombres para el operador. Puedes usar el mismo valor que usaste para el espacio de nombres de la aplicación, APPLICATION_NAMESPACE.
```
kubectl create namespace INSTRUMENTATION_NAMESPACE
```
Crea el recurso personalizado de instrumentación en tu clúster y aplica el archivo instrumentation.yaml ejecutando el siguiente comando:
```
kubectl apply -f instrumentation.yaml -n INSTRUMENTATION_NAMESPACE
```

Aplica la anotación de instrumentación automática a la aplicación de Java de ejemplo implementada anteriormente. Aplica parches a la implementación original con la anotación ejecutando el siguiente comando:

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"}}}}}'

Después de aplicar el parche a la implementación, lo que hace que se reinicie la implementación de la aplicación, puedes verificar el estado de los Pods en la aplicación ejecutando el siguiente comando:
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Para dejar de supervisar el estado del pod, presiona Ctrl + C para detener el comando.

La aplicación de Java implementada en tu clúster de GKE ahora se instrumenta de forma automática.

Genera datos de telemetría a partir de la aplicación implementada

Para generar telemetría a partir de la aplicación instrumentada automáticamente, debes enviar solicitudes a la aplicación para simular la actividad del usuario. Puedes generar un flujo constante de tráfico ejecutando un simulador de tráfico. En esta sección, se describe cómo descargar el simulador, compilarlo con Cloud Build, almacenar la imagen en Artifact Registry y, luego, implementar el simulador:

Descarga la aplicación del simulador de tráfico ejecutando los siguientes comandos:

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

Los comandos anteriores hacen lo siguiente:

Crea un directorio independiente para compilar una aplicación de simulador de tráfico.
Descarga el Dockerfile de la aplicación.
Descarga la configuración de compilación de Cloud Build para compilar la imagen de la aplicación.

Crea la imagen de la aplicación con Cloud Build y envíala a Artifact Registry ejecutando los siguientes comandos:

pushd traffic-simulator && \
gcloud builds submit --config <(envsubst < cloudbuild-hey.yaml) . && \
popd

Crea un archivo de configuración de implementación para el simulador copiando el siguiente contenido en un archivo del directorio traffic-simulator llamado quickstart-traffic.yaml:

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

Para implementar el simulador de tráfico, ejecuta los siguientes comandos:

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

Después de crear el Deployment, es posible que los Pods tarden un poco en crearse y comenzar a ejecutarse. Para verificar el estado de los Pods, ejecuta el siguiente comando:
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Para dejar de supervisar el estado del pod, presiona Ctrl + C para detener el comando.

Visualiza tu telemetría

Después de que el simulador de tráfico comienza a enviar solicitudes a la aplicación, la aplicación de Java implementada genera telemetría. Es posible que las métricas y los registros tarden unos minutos en aparecer en Google Cloud.

La instrumentación que inserta el operador de OpenTelemetry se basa en el agente de Java de OpenTelemetry. El agente de Java de OpenTelemetry contiene instrumentación integrada para muchas bibliotecas y frameworks de Java populares que emiten métricas.
La instrumentación insertada también captura automáticamente los seguimientos de cualquier llamada realizada a cualquier extremo expuesto por la aplicación de ejemplo. El simulador de tráfico envía solicitudes constantemente al extremo /multi que expone la aplicación de Java a una velocidad fija. El extremo /multi, a su vez, envía solicitudes al extremo /single para generar la respuesta final. Estas interacciones terminan como seguimientos que se pueden ver con el Explorador de seguimiento.

Ver métricas

Puedes ver tus métricas instrumentadas de forma automática en el Explorador de métricas de Cloud Monitoring. En esta sección, se incluyen consultas de muestra escritas en PromQL.

En la consola de Google Cloud , accede a la página Explorador de métricas:

Acceder al Explorador de métricas

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Monitoring.

Estas son algunas de las métricas que puedes ver para la aplicación de ejemplo:

Métricas del entorno de ejecución de JVM: El agente de Java de OpenTelemetry emite métricas sobre la JVM subyacente. Estas métricas exponen información sobre la memoria de JVM, la recolección de elementos no utilizados, las clases, los subprocesos y otros conceptos relacionados. Para obtener una lista completa de las métricas de JVM compatibles, consulta la página Convenciones semánticas de las métricas del entorno de ejecución de JVM.
- Uso de memoria de JVM: Pega la siguiente consulta de PromQL en el Explorador de métricas:
```
sum(avg_over_time({"process.runtime.jvm.memory.usage"}[${__interval}]))
```
- Utilización de CPU de la JVM: Pega la siguiente consulta de PromQL en el Explorador de métricas:
```
sum(avg_over_time({"process.runtime.jvm.cpu.utilization"}[${__interval}]))
```
  En el siguiente gráfico, se muestra la métrica de uso de CPU de la JVM:
Métricas de Spring Boot: La aplicación de ejemplo usa el framework de Spring Boot, que también es compatible con la instrumentación sin código de OpenTelemetry para Java.
- Duración media del cliente HTTP: pega la siguiente consulta de PromQL en el Explorador de métricas:
```
sum(rate({"http.client.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.client.duration_count"}[${__interval}])) by (cluster, job)
```
- Duración media del servidor HTTP: pega la siguiente consulta de PromQL en el Explorador de métricas:
```
sum(rate({"http.server.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.server.duration_count"}[${__interval}])) by (cluster, job)
```
  En el siguiente gráfico, se muestra la métrica de duración media del servidor HTTP de Spring Boot:

Para obtener más información sobre el uso del Explorador de métricas, consulta Selecciona métricas cuando uses el Explorador de métricas.

Ver seguimientos

Puedes ver tus seguimientos instrumentados automáticamente en el Explorador de seguimiento de Cloud Trace. Puedes filtrar estos registros en el Explorador de registros filtrando por el "Nombre del servicio" y configurando el nombre del servicio en quickstart-app.

En la consola de Google Cloud , ve a la página Explorador de seguimiento:

Ve al Explorador de seguimiento

También puedes usar la barra de búsqueda para encontrar esta página.

En la siguiente captura de pantalla, se muestran los registros generados por la implementación de quickstart-app de OpenTelemetry:

El Explorador de seguimiento muestra los seguimientos capturados por la instrumentación sin código de OpenTelemetry.

Para obtener más información sobre el uso del Explorador de seguimiento, consulta Busca y explora seguimientos.

Realiza una limpieza

Si creaste un proyecto Google Cloud nuevo y ya no lo necesitas, puedes borrarlo ejecutando el siguiente comando:

gcloud projects delete PROJECT_ID

Si usaste un proyecto existente, puedes borrar los recursos que creaste como parte de esta explicación para ahorrar costos:

Borra el clúster de GKE con el siguiente comando:

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

Borra el repositorio de Artifact Registry ejecutando el siguiente comando:

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

Usa la instrumentación sin código de OpenTelemetry para cargas de trabajo de Java en GKE Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

¿Por qué usar la instrumentación sin código?

Descripción general

Antes de comenzar

Selecciona o crea un proyecto de Google Cloud

Instala herramientas de línea de comandos

Configura las variables de entorno

Habilita las APIs

Obtén permisos

Configura tu clúster

Implementa la aplicación de Java

Configura una instancia del recopilador de OpenTelemetry

Configura la instrumentación sin código de OpenTelemetry

Genera datos de telemetría a partir de la aplicación implementada

Visualiza tu telemetría

Ver métricas

Ver seguimientos

Realiza una limpieza

Usa la instrumentación sin código de OpenTelemetry para cargas de trabajo de Java en GKE