Usar a instrumentação sem código do OpenTelemetry para cargas de trabalho Java no GKE

Este documento mostra como instrumentar automaticamente aplicativos Java em execução no Google Kubernetes Engine (GKE) usando a instrumentação de código zero do OpenTelemetry. A instrumentação sem código oferece observabilidade abrangente das suas cargas de trabalho Java com o mínimo de esforço manual.

Este tutorial apresenta etapas detalhadas para implantar um exemplo de aplicativo Java no GKE, instrumentar automaticamente o aplicativo usando o OpenTelemetry e visualizar os indicadores de telemetria gerados usando o Google Cloud Observability.

O tutorial descreve a instrumentação automática de cargas de trabalho Java em execução no GKE, mas é possível estender essas instruções a outras linguagens compatíveis.

Por que usar a instrumentação sem código?

A instrumentação sem código (também chamada de instrumentação automática) no OpenTelemetry é uma ferramenta poderosa que permite aos desenvolvedores de aplicativos adicionar capacidade de observabilidade configurável ao código sem precisar escrever código adicional ou modificar o código existente. A instrumentação sem código funciona adicionando automaticamente instrumentação a bibliotecas de aplicativos implantadas ativamente, fornecendo insights confiáveis sobre o desempenho do aplicativo ao emitir Indicadores de ouro. Isso torna a instrumentação sem código um excelente ponto de partida para a jornada de observabilidade de um aplicativo.

A instrumentação sem código em Java emite métricas e intervalos de rastreamento ao instrumentar bibliotecas conhecidas que são amplamente usadas no ecossistema da linguagem. Para Java, as métricas incluem:

• Métricas de tempo de execução da JVM emitidas pela plataforma Java.
• Métricas do HttpClient e intervalos do HttpClient emitidos por bibliotecas como a biblioteca de cliente HTTP do Java e a biblioteca de cliente HTTP do Google.
• Métricas de cliente de banco de dados e intervalos de cliente de banco de dados emitidos por bibliotecas como JDBC e Lettuce.

O conjunto de métricas emitidas depende do aplicativo instrumentado e das bibliotecas usadas por ele. Para uma lista completa de bibliotecas e frameworks que podem ser instrumentados pelo agente de instrumentação Java sem código, consulte Bibliotecas e frameworks compatíveis.

Com a instrumentação automática, é possível fazer o seguinte:

• Receba o monitoramento dos Golden Signals sem precisar fazer mudanças no código.
• Correlacione a alta latência p99,9 com rastreamentos de usuários individuais, que abrangem todas as chamadas RPC.
• Receba telemetria consistente em métricas, registros e traces de uma ampla variedade de bibliotecas e frameworks conhecidos.

Para mais informações sobre a instrumentação sem código, consulte Sem código do OpenTelemetry.

Visão geral

Para adicionar observabilidade a uma carga de trabalho Java em execução no GKE, é necessário implantar os seguintes componentes:

• Instrumentação sem código do OpenTelemetry, que gera a telemetria do aplicativo.
• O OpenTelemetry Collector, que coleta a telemetria gerada pelo seu aplicativo, enriquece com metadados e contexto críticos e a encaminha para Google Cloud para consumo.

Neste tutorial, você implanta um aplicativo Java instrumentado no GKE que emite métricas e rastreamentos para o Google Cloud. Em seguida, é possível conferir esses indicadores de telemetria usando as ofertas de observabilidade do Google Cloud, como o Metrics Explorer, a Análise de registros e o Trace Explorer. Para informações sobre como ver e usar a telemetria gerada, consulte Ver sua telemetria.

Este tutorial usa os seguintes serviços pagos para gravar indicadores:

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

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.

Antes de começar

Esta seção descreve como configurar o ambiente para implantar e instrumentar o app e depois executá-lo.

Selecione ou crie um projeto do Google Cloud

Escolha um projeto do Google Cloud para este tutorial. Se você ainda não tiver um projeto do Google Cloud , crie um:

Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloud, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

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.

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.

Instalar ferramentas de linha de comando

Este documento usa as seguintes ferramentas de linha de comando:

• gcloud
• kubectl

As ferramentas gcloud e kubectl fazem parte da Google Cloud CLI. Para informações sobre como instalá-los, consulte Como gerenciar componentes da CLI do Google Cloud. Para ver os componentes da CLI gcloud que você instalou, execute o seguinte comando:

gcloud components list

Defina as variáveis de ambiente

Para reduzir a digitação de valores frequentes, evitar erros de digitação e tornar os comandos deste documento executáveis, defina as seguintes variáveis de ambiente:

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 executar os comandos, substitua as seguintes variáveis ou use os padrões:

• PROJECT_ID: o identificador do projeto.
• CLUSTER_NAME: o nome do cluster. Isso pode se referir a um cluster novo ou atual.
• us-east1: a região do cluster. Se você estiver usando um cluster atual, use a região dele.
• opentelemetry-autoinstrument-registry: o nome do repositório do Artifact Registry. Isso pode se referir a um repositório novo ou atual.
• us-east4: a região do repositório do Artifact Registry. Se você estiver usando um repositório atual, use a região dele.

Se você encontrar erros ao executar os comandos neste documento, verifique se essas variáveis estão definidas corretamente no seu ambiente de terminal.

Ativar APIs

Para usar os serviços neste documento, ative as seguintes APIs no seu projeto Google Cloud :

• API Artifact Registry: artifactregistry.googleapis.com
• API Cloud Build: cloudbuild.googleapis.com
• Google Kubernetes Engine: container.googleapis.com
• API de Gerenciamento de identidade e acesso: iam.googleapis.com
• API Cloud Logging: logging.googleapis.com
• API Cloud Monitoring: monitoring.googleapis.com
• API Telemetry: telemetry.googleapis.com

Essas APIs, provavelmente com exceção da API Telemetry, já podem estar ativadas no seu projeto Google Cloud . Execute o seguinte comando para listar as APIs ativadas:

gcloud services list

Ative as APIs que ainda não estão ativadas. Preste atenção especial à API Telemetry, telemetry.googleapis.com. Este documento pode ser a primeira vez que você encontra essa API.

Para ativar as APIs que ainda não estão ativadas, execute os comandos das APIs correspondentes:

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

Configurar o cluster

Configure um cluster do GKE para o aplicativo de amostra e o coletor:

1. Faça login no Google Cloud executando os seguintes comandos:

   gcloud auth login
   gcloud config set project PROJECT_ID
   

2. Se você ainda não tiver um cluster do GKE, crie um cluster do Autopilot executando o seguinte comando:

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

3. Para interagir com o cluster, conecte o utilitário kubectl local executando o seguinte comando:

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

Implantar o aplicativo Java

As etapas nesta seção implantam um aplicativo Java de amostra não instrumentado, o exemplo de instrumentação do OpenTelemetry Spring Boot, no seu cluster. Esta seção usa o Cloud Build e o Artifact Registry para criar e armazenar a imagem do aplicativo.

1. Se você ainda não tiver um repositório do Artifact Registry, crie um executando o seguinte comando:

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

2. Execute o seguinte comando para clonar o aplicativo de exemplo:

   git clone https://github.com/GoogleCloudPlatform/opentelemetry-operations-java.git
   

3. Configure as variáveis de ambiente a seguir:

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

4. Crie a imagem do aplicativo e envie-a para o repositório do Artifact Registry executando os seguintes comandos:

   pushd opentelemetry-operations-java/examples/instrumentation-quickstart && \
   gcloud builds submit --config <(envsubst < cloudbuild-uninstrumented-app.yaml) . && \
   popd
   

   Observação: se você estiver usando um Mac, a execução dos comandos anteriores poderá exigir que você instale primeiro o pacote gettext do Homebrew. Para mais informações, consulte este artigo do Stack Overflow (em inglês). Depois de instalar o pacote, talvez seja necessário definir as variáveis de ambiente novamente.

5. Crie um arquivo de configuração de implantação do Kubernetes para o aplicativo. Copie a configuração a seguir e salve em um arquivo chamado 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
   

6. Crie um namespace para seu aplicativo executando o seguinte comando:

   kubectl create namespace APPLICATION_NAMESPACE
   

7. Aplique a configuração de implantação ao cluster executando o seguinte comando:

   kubectl apply -f deployment.yaml -n APPLICATION_NAMESPACE
   

8. Depois de criar a implantação, pode levar um tempo para que os pods sejam criados e comecem a ser executados. Para verificar o status dos pods, execute o comando a seguir:

   kubectl get po -n APPLICATION_NAMESPACE -w
   

   Para parar de monitorar o status do pod, pressione Ctrl+C para interromper o comando.

Configurar uma instância do OpenTelemetry Collector

Nesta seção, você cria outra implantação que executa uma instância do coletor do OpenTelemetry criado pelo Google no cluster do GKE. O coletor é configurado para exportar dados usando os seguintes exportadores:

• Métricas usando o exportador HTTP OTLP
• Rastreamentos usando o exportador HTTP OTLP
• Registros usando o exportador do Google Cloud

Em vez de seguir as etapas manuais neste documento para implantar o OpenTelemetry Collector, siga o OpenTelemetry gerenciado para GKE, que usa o OpenTelemetry Collector criado pelo Google em um ambiente gerenciado.

Observação: este documento configura o coletor com a configuração recomendada do Google, que é suficiente para a maioria dos usuários e casos de uso. Embora seja possível implantar um coletor personalizado para oferecer suporte a casos de uso avançados, é necessário manter determinadas opções de configuração para continuar compatível com o Google Cloud. Para mais informações sobre como configurar um coletor personalizado, consulte Implantar o coletor do OpenTelemetry criado pelo Google no Google Kubernetes Engine.

1. Autorize a conta de serviço do Kubernetes para a implantação do OpenTelemetry Collector executando os seguintes 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
   

2. Implante a instância do coletor do OpenTelemetry criada pelo Google no cluster do GKE com a configuração padrão recomendada executando o seguinte comando:

   kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest//k8s/base?ref=otlpmetric | envsubst | kubectl apply -f -
   

   Essa configuração implanta o coletor no namespace opentelemetry.

3. Depois de criar a implantação, pode levar um tempo para que os pods sejam criados e comecem a ser executados. Para verificar o status dos pods, execute o comando a seguir:

   kubectl get po -n opentelemetry -w
   

   Para parar de monitorar o status do pod, pressione Ctrl+C para interromper o comando.

Configurar a instrumentação sem código do OpenTelemetry

Para configurar a instrumentação sem código do OpenTelemetry em um aplicativo implantado no GKE, instale o operador do OpenTelemetry no cluster do GKE. O operador OpenTelemetry fornece acesso a uma definição de recurso personalizada (CRD) do Kubernetes, o recurso de instrumentação, que é usado para injetar instrumentação automática em recursos do Kubernetes em execução em um cluster.

O recurso de instrumentação é "injetado" ou "aplicado" a cargas de trabalho específicas usando anotações especiais. O operador do OpenTelemetry observa essas anotações em recursos executados no cluster e injeta a instrumentação adequada nos aplicativos gerenciados por esses recursos.

1. Se você ainda não tiver a CLI do Helm instalada, instale o Helm executando os seguintes comandos:

   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                         
   

2. Se você ainda não tiver o cert-manager instalado no cluster, execute os seguintes comandos para fazer isso:

   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
   

3. Instale o operador OpenTelemetry executando o seguinte comando e usando a versão 0.140.0 ou mais recente:

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

4. Crie um arquivo de configuração para o recurso personalizado de instrumentação criando um arquivo chamado instrumentation.yaml com o seguinte conteúdo:

   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
   

5. Crie um namespace para o operador. Você pode usar o mesmo valor que usou para o namespace do aplicativo, APPLICATION_NAMESPACE.

   kubectl create namespace INSTRUMENTATION_NAMESPACE
   

6. Crie o recurso personalizado de instrumentação no cluster e aplique o arquivo instrumentation.yaml executando o seguinte comando:

   kubectl apply -f instrumentation.yaml -n INSTRUMENTATION_NAMESPACE
   

7. Aplique a anotação de instrumentação automática ao aplicativo de exemplo em Java implantado anteriormente. Adicione a anotação à implantação original executando o seguinte 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"}}}}}'
   

8. Depois de corrigir a implantação, o que faz com que a implantação do aplicativo seja reiniciada, verifique o status dos pods no aplicativo executando o seguinte comando:

   kubectl get po -n APPLICATION_NAMESPACE -w
   

   Para parar de monitorar o status do pod, pressione Ctrl+C para interromper o comando.

O aplicativo Java implantado no cluster do GKE agora está instrumentado automaticamente.

Gerar telemetria do aplicativo implantado

Para gerar telemetria do aplicativo autoinstrumentado, envie solicitações a ele para simular a atividade do usuário. É possível gerar um fluxo constante de tráfego executando um simulador. Esta seção descreve como baixar o simulador, criá-lo usando o Cloud Build, armazenar a imagem no Artifact Registry e implantar o simulador:

1. Faça o download do aplicativo de simulação de tráfego executando os seguintes 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
   

   Os comandos anteriores fazem o seguinte:

   1. Crie um diretório separado para criar um aplicativo de simulador de tráfego.
   2. Faça o download do Dockerfile para o aplicativo.
   3. Faça o download da configuração do Cloud Build para criar a imagem do aplicativo.

2. Crie a imagem do aplicativo com o Cloud Build e faça o push dela para o Artifact Registry executando os seguintes comandos:

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

3. Crie um arquivo de configuração de implantação para o simulador copiando o conteúdo a seguir em um arquivo no diretório traffic-simulator chamado 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
   

4. Implante o simulador de tráfego executando os seguintes comandos:

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

5. Depois de criar a implantação, pode levar um tempo para que os pods sejam criados e comecem a ser executados. Para verificar o status dos pods, execute o comando a seguir:

   kubectl get po -n APPLICATION_NAMESPACE -w
   

   Para parar de monitorar o status do pod, pressione Ctrl+C para interromper o comando.

Acessar sua telemetria

Depois que o simulador de tráfego começa a enviar solicitações ao aplicativo, o aplicativo Java implantado gera telemetria. Pode levar alguns minutos para que as métricas e os rastreamentos comecem a aparecer no Google Cloud.

• A instrumentação injetada pelo operador do OpenTelemetry depende do agente Java do OpenTelemetry. O agente Java do OpenTelemetry contém instrumentação integrada para muitas bibliotecas e frameworks Java conhecidos que emitem métricas.

• A instrumentação injetada também captura automaticamente traces de todas as chamadas feitas para qualquer endpoint exposto pelo aplicativo de exemplo. O simulador de tráfego envia constantemente solicitações ao endpoint /multi exposto pelo aplicativo Java a uma taxa fixa. O endpoint /multi, por sua vez, envia solicitações ao endpoint /single para gerar a resposta final. Essas interações acabam sendo traces que podem ser visualizados usando o Explorador de traces.

Ver métricas

É possível conferir as métricas instrumentadas automaticamente no Metrics Explorer do Cloud Monitoring. Esta seção inclui exemplos de consultas escritas em PromQL.

No console Google Cloud , acesse a página do  Metrics explorer:

Acesse o Metrics Explorer

Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.

Algumas das métricas que você pode conferir para o aplicativo de exemplo incluem:

• Métricas de tempo de execução da JVM: o agente Java do OpenTelemetry emite métricas sobre a JVM subjacente. Essas métricas expõem informações sobre memória da JVM, coleta de lixo, classes, linhas de execução e outros conceitos relacionados. Para uma lista completa de métricas da JVM compatíveis, consulte a página Convenções semânticas de métricas de tempo de execução da JVM.

  • Uso da memória da JVM: cole a seguinte consulta do PromQL no Metrics Explorer:

    sum(avg_over_time({"process.runtime.jvm.memory.usage"}[${__interval}]))
    

  • Utilização da CPU da JVM: cole a seguinte consulta PromQL no Metrics Explorer:

    sum(avg_over_time({"process.runtime.jvm.cpu.utilization"}[${__interval}]))
    

    O gráfico a seguir mostra a métrica de utilização da CPU da JVM:

    

• Métricas do Spring Boot: o aplicativo de exemplo usa o framework Spring Boot, que também é compatível com a instrumentação de código zero do OpenTelemetry para Java.

  • Duração média do cliente HTTP: cole a seguinte consulta do PromQL no Metrics Explorer:

    sum(rate({"http.client.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.client.duration_count"}[${__interval}])) by (cluster, job)
    

  • Duração média do servidor HTTP: cole a seguinte consulta do PromQL no Metrics Explorer:

    sum(rate({"http.server.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.server.duration_count"}[${__interval}])) by (cluster, job)
    

    O gráfico a seguir mostra a métrica de duração média do servidor HTTP do Spring Boot:

    

Para mais informações sobre como usar o Metrics Explorer, consulte Selecionar métricas ao usar o Metrics Explorer.

Ver traces

É possível ver os traces instrumentados automaticamente no Explorador de traces do Cloud Trace. É possível filtrar esses rastreamentos no Explorador de rastreamento filtrando por "Nome do serviço" e definindo o nome do serviço como quickstart-app.

No console Google Cloud , acesse a página Explorador de traces:

Acessar o Explorador de traces

Também é possível encontrar essa página usando a barra de pesquisa.

A captura de tela a seguir mostra os rastreamentos gerados pela implantação do OpenTelemetry quickstart-app:

Para mais informações sobre como usar o Trace Explorer, consulte Encontrar e explorar traces.

Limpar

Se você criou um novo projeto do Google Cloud e não precisa mais dele, é possível excluí-lo executando o seguinte comando:

gcloud projects delete PROJECT_ID

Se você usou um projeto atual, exclua os recursos criados como parte deste tutorial para economizar custos:

• Exclua o cluster do GKE executando o seguinte comando:

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

• Exclua o repositório do Artifact Registry executando o seguinte comando:

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