Utiliser l'instrumentation OpenTelemetry sans code pour les charges de travail Java sur GKE

Ce document explique comment instrumenter automatiquement les applications Java exécutées sur Google Kubernetes Engine (GKE) à l'aide de l'instrumentation OpenTelemetry sans code. L'instrumentation sans code vous offre une observabilité complète de vos charges de travail Java avec un minimum d'efforts manuels.

Ce tutoriel fournit des instructions détaillées pour déployer un exemple d'application Java sur GKE, instrumenter automatiquement l'application à l'aide d'OpenTelemetry et visualiser les signaux de télémétrie générés à l'aide de Google Cloud Observability.

La procédure pas à pas décrit l'instrumentation automatique des charges de travail Java exécutées sur GKE, mais vous pouvez étendre ces instructions à d'autres langages compatibles.

Pourquoi utiliser l'instrumentation sans code ?

L'instrumentation sans code (également appelée instrumentation automatique) dans OpenTelemetry est un outil puissant qui permet aux développeurs d'applications d'ajouter une observabilité configurable à leur code sans avoir à écrire de code supplémentaire ni à modifier de code existant. L'instrumentation sans code fonctionne en ajoutant automatiquement l'instrumentation aux bibliothèques d'applications déployées activement. Elle fournit ainsi des insights fiables sur les performances des applications en émettant des signaux clés. L'instrumentation sans code est donc un excellent point de départ pour l'observabilité d'une application.

L'instrumentation sans code en Java émet des métriques et des spans de trace en instrumentant les bibliothèques populaires largement utilisées dans l'écosystème du langage. Pour Java, les métriques incluent les éléments suivants :

Métriques d'exécution JVM émises par la plate-forme Java
Métriques HttpClient et spans HttpClient émis par des bibliothèques telles que la bibliothèque cliente HTTP Java et la bibliothèque cliente HTTP Google.
Métriques du client de base de données et couvertures du client de base de données émises par des bibliothèques telles que JDBC et Lettuce.

L'ensemble des métriques émises dépend de l'application instrumentée et des bibliothèques utilisées par l'application. Pour obtenir la liste complète des bibliothèques et frameworks qui peuvent être instrumentés par l'agent d'instrumentation Java sans code, consultez Bibliothèques et frameworks compatibles.

L'instrumentation automatique vous permet, entre autres, d'effectuer les actions suivantes :

Surveillez les signaux d'or sans avoir à modifier le code.
Corrélez la latence élevée du 99,9e centile aux traces d'utilisateurs individuels, qui couvrent chaque appel RPC.
Obtenez des données de télémétrie cohérentes pour les métriques, les journaux et les traces à partir d'une grande variété de bibliothèques et de frameworks populaires.

Pour en savoir plus sur l'instrumentation sans code, consultez la section Zero-code d'OpenTelemetry.

Présentation

Pour ajouter l'observabilité à une charge de travail Java exécutée sur GKE, vous devez déployer les composants suivants :

L'instrumentation OpenTelemetry sans code, qui génère la télémétrie à partir de votre application.
Le collecteur OpenTelemetry, qui collecte les données de télémétrie générées par votre application, les enrichit avec des métadonnées et un contexte essentiels, et les achemine vers Google Cloud pour qu'elles puissent être utilisées.

Dans ce tutoriel, vous allez déployer une application Java instrumentée sur GKE qui émet des métriques et des traces vers Google Cloud. Vous pouvez ensuite afficher ces signaux de télémétrie à l'aide des offres d'observabilité de Google Cloud, telles que l'explorateur de métriques, l'explorateur de journaux et l'explorateur de traces. Pour savoir comment afficher et utiliser la télémétrie générée, consultez Afficher votre télémétrie.

Cette procédure utilise les services payants suivants pour écrire des signaux :

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

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

Cette section explique comment configurer votre environnement pour déployer et instrumenter l'application, puis l'exécuter.

Sélectionner ou créer un projet Google Cloud

Choisissez un projet Google Cloud pour ce tutoriel. Si vous n'avez pas encore de projet Google Cloud , créez-en un :

Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $de crédits sans frais pour exécuter, tester et déployer des charges de travail.

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.

Installer les outils de ligne de commande

Ce document utilise les outils de ligne de commande suivants :

gcloud
kubectl

Les outils gcloud et kubectl font partie de Google Cloud CLI. Pour en savoir plus sur leur installation, consultez Gérer les composants de Google Cloud CLI. Pour afficher les composants de gcloud CLI que vous avez installés, exécutez la commande suivante :

gcloud components list

Définir des variables d'environnement

Pour réduire la saisie des valeurs fréquentes, éviter les erreurs de frappe et rendre les commandes de ce document exécutables, définissez les variables d'environnement suivantes :

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

Avant d'exécuter les commandes, remplacez les variables suivantes ou utilisez les valeurs par défaut :

PROJECT_ID : identifiant du projet.
CLUSTER_NAME : nom de votre cluster. Il peut s'agir d'un cluster nouveau ou existant.
us-east1 : région de votre cluster. Si vous utilisez un cluster existant, utilisez la région de ce cluster.
opentelemetry-autoinstrument-registry : nom de votre dépôt Artifact Registry. Il peut s'agir d'un dépôt nouveau ou existant.
us-east4 : région de votre dépôt Artifact Registry. Si vous utilisez un dépôt existant, utilisez la région de ce dépôt.

Si vous rencontrez des erreurs lors de l'exécution des commandes de ce document, vérifiez que ces variables sont correctement définies dans votre environnement de terminal.

Activer les API

Pour utiliser les services décrits dans ce document, vous devez activer les API suivantes dans votre projet Google Cloud :

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

Ces API, à l'exception probable de l'API Telemetry, sont peut-être déjà activées dans votre projet Google Cloud . Exécutez la commande suivante pour lister les API activées :

gcloud services list

Activez les API qui ne le sont pas encore. Portez une attention particulière à l'API Telemetry, telemetry.googleapis.com. C'est peut-être la première fois que vous rencontrez cette API.

Pour activer les API qui ne le sont pas encore, exécutez les commandes correspondantes :

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

Configurer votre cluster

Configurez un cluster GKE pour l'application et le collecteur exemples :

Connectez-vous à Google Cloud en exécutant les commandes suivantes :
```
gcloud auth login
gcloud config set project PROJECT_ID
```

Si vous n'avez pas encore de cluster GKE, créez-en un en exécutant la commande suivante :

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

Pour interagir avec votre cluster, connectez votre utilitaire kubectl local en exécutant la commande suivante :
```
gcloud container clusters get-credentials CLUSTER_NAME --region us-east1 --project PROJECT_ID
```

Déployer l'application Java

Les étapes de cette section permettent de déployer un exemple d'application Java non instrumentée, l'exemple d'instrumentation Spring Boot OpenTelemetry, sur votre cluster. Cette section utilise Cloud Build et Artifact Registry pour créer et stocker l'image de l'application.

Si vous n'avez pas encore de dépôt Artifact Registry, créez-en un en exécutant la commande suivante :

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

Clonez l'exemple d'application en exécutant la commande suivante :

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

Définissez les variables d'environnement suivantes :

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

Créez l'image de l'application et transférez-la vers votre dépôt Artifact Registry en exécutant les commandes suivantes :
```
pushd opentelemetry-operations-java/examples/instrumentation-quickstart && \
gcloud builds submit --config <(envsubst < cloudbuild-uninstrumented-app.yaml) . && \
popd
```
Remarque : Si vous utilisez un Mac, l'exécution des commandes précédentes peut nécessiter l'installation préalable du package gettext à partir de Homebrew. Pour en savoir plus, consultez cet article Stack Overflow. Après avoir installé le package, vous devrez peut-être redéfinir vos variables d'environnement.

Créez un fichier de configuration de déploiement Kubernetes pour l'application. Copiez la configuration suivante et enregistrez-la dans un fichier nommé 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

Créez un espace de noms pour votre application en exécutant la commande suivante :
```
kubectl create namespace APPLICATION_NAMESPACE
```
Appliquez la configuration du déploiement à votre cluster en exécutant la commande suivante :
```
kubectl apply -f deployment.yaml -n APPLICATION_NAMESPACE
```
Une fois le déploiement créé, la création et le démarrage des pods peuvent prendre un certain temps. Pour vérifier l'état des pods, exécutez la commande suivante :
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Pour arrêter la surveillance de l'état du pod, saisissez Ctrl+C pour arrêter la commande.

Configurer une instance de collecteur OpenTelemetry

Dans cette section, vous allez créer un autre déploiement qui exécute une instance de collecteur OpenTelemetry conçu par Google dans votre cluster GKE. Le collecteur est configuré pour exporter des données à l'aide des exportateurs suivants :

Métriques à l'aide de l'exportateur HTTP OTLP
Traces à l'aide de l'exportateur HTTP OTLP
Journaux à l'aide de l'exportateur Google Cloud

Au lieu de suivre les étapes manuelles de ce document pour déployer le collecteur OpenTelemetry, vous pouvez suivre Managed OpenTelemetry pour GKE, qui utilise le collecteur OpenTelemetry intégré à Google dans un environnement géré.

Autorisez le compte de service Kubernetes pour le déploiement du collecteur OpenTelemetry en exécutant les commandes suivantes :

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

Déployez l'instance de collecteur OpenTelemetry conçue par Google sur votre cluster GKE avec la configuration par défaut recommandée en exécutant la commande suivante :
```
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest//k8s/base?ref=otlpmetric | envsubst | kubectl apply -f -
```
Cette configuration déploie le collecteur dans l'espace de noms opentelemetry.
Une fois le déploiement créé, la création et le démarrage des pods peuvent prendre un certain temps. Pour vérifier l'état des pods, exécutez la commande suivante :
```
kubectl get po -n opentelemetry -w
```
Pour arrêter la surveillance de l'état du pod, saisissez Ctrl+C pour arrêter la commande.

Configurer l'instrumentation OpenTelemetry sans code

Pour configurer l'instrumentation OpenTelemetry sans code pour une application déployée sur GKE, installez l'opérateur OpenTelemetry sur votre cluster GKE. L'opérateur OpenTelemetry permet d'accéder à une définition de ressource personnalisée (CRD, Custom Resource Definition) Kubernetes, la ressource d'instrumentation, qui est utilisée pour injecter l'instrumentation automatique dans les ressources Kubernetes s'exécutant dans un cluster.

La ressource d'instrumentation est "injectée" ou "appliquée" à des charges de travail spécifiques à l'aide d'annotations spéciales. L'opérateur OpenTelemetry observe ces annotations sur les ressources s'exécutant dans le cluster et injecte l'instrumentation appropriée dans les applications gérées par ces ressources.

Si vous n'avez pas encore installé la CLI Helm, faites-le en exécutant les commandes suivantes :

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 cert-manager n'est pas déjà installé sur le cluster, installez-le en exécutant les commandes suivantes :

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

Installez l'opérateur OpenTelemetry en exécutant la commande suivante et en utilisant la version 0.140.0 ou ultérieure :

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

Créez un fichier de configuration pour la ressource personnalisée d'instrumentation en créant un fichier nommé instrumentation.yaml avec le contenu suivant :

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

Créez un espace de noms pour l'opérateur. Vous pouvez utiliser la même valeur que celle utilisée pour l'espace de noms de l'application, APPLICATION_NAMESPACE.
```
kubectl create namespace INSTRUMENTATION_NAMESPACE
```
Créez la ressource personnalisée d'instrumentation dans votre cluster et appliquez votre fichier instrumentation.yaml en exécutant la commande suivante :
```
kubectl apply -f instrumentation.yaml -n INSTRUMENTATION_NAMESPACE
```

Appliquez l'annotation d'instrumentation automatique à l'exemple d'application Java déployé précédemment. Corrigez le déploiement d'origine avec l'annotation en exécutant la commande suivante :

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

Après avoir corrigé le déploiement, ce qui entraîne le redémarrage du déploiement de l'application, vous pouvez vérifier l'état des pods dans l'application en exécutant la commande suivante :
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Pour arrêter la surveillance de l'état du pod, saisissez Ctrl+C pour arrêter la commande.

L'application Java déployée dans votre cluster GKE est désormais instrumentée automatiquement.

Générer des données de télémétrie à partir de l'application déployée

Pour générer des données de télémétrie à partir de l'application auto-instrumentée, vous devez envoyer des requêtes à l'application pour simuler l'activité des utilisateurs. Vous pouvez générer un flux de trafic constant en exécutant un simulateur de trafic. Cette section explique comment télécharger le simulateur, le compiler à l'aide de Cloud Build, stocker l'image dans Artifact Registry et déployer le simulateur :

Téléchargez l'application de simulation du trafic en exécutant les commandes suivantes :

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

Les commandes précédentes effectuent les opérations suivantes :

Créez un répertoire distinct pour créer une application de simulateur de trafic.
Téléchargez le fichier Dockerfile pour l'application.
Téléchargez la configuration Cloud Build pour créer l'image de l'application.

Créez l'image d'application avec Cloud Build et transférez-la vers Artifact Registry en exécutant les commandes suivantes :
```
pushd traffic-simulator && \
gcloud builds submit --config <(envsubst < cloudbuild-hey.yaml) . && \
popd
```

Créez un fichier de configuration de déploiement pour le simulateur en copiant le contenu suivant dans un fichier du répertoire traffic-simulator nommé 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

Déployez le simulateur de trafic en exécutant les commandes suivantes :

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

Une fois le déploiement créé, la création et le démarrage des pods peuvent prendre un certain temps. Pour vérifier l'état des pods, exécutez la commande suivante :
```
kubectl get po -n APPLICATION_NAMESPACE -w
```
Pour arrêter la surveillance de l'état du pod, saisissez Ctrl+C pour arrêter la commande.

Afficher votre télémétrie

Une fois que le simulateur de trafic commence à envoyer des requêtes à l'application, l'application Java déployée génère des données de télémétrie. L'affichage des métriques et des traces dans Google Cloudpeut prendre quelques minutes.

L'instrumentation injectée par l'opérateur OpenTelemetry repose sur l'agent Java OpenTelemetry. L'agent Java OpenTelemetry contient une instrumentation intégrée pour de nombreuses bibliothèques et frameworks Java populaires qui émettent des métriques.
L'instrumentation injectée capture également automatiquement les traces de tous les appels effectués vers les points de terminaison exposés par l'application exemple. Le simulateur de trafic envoie constamment des requêtes au point de terminaison /multi exposé par l'application Java à un taux fixe. Le point de terminaison /multi envoie à son tour des requêtes au point de terminaison /single pour générer la réponse finale. Ces interactions se traduisent par des traces qui peuvent être consultées à l'aide de l'explorateur de traces.

Afficher les métriques

Vous pouvez afficher vos métriques auto-instrumentées dans l'explorateur de métriques de Cloud Monitoring. Cette section inclut des exemples de requêtes écrites en PromQL.

Dans la console Google Cloud , accédez à la page Explorateur de métriques.

Accéder à l'Explorateur de métriques

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.

Voici quelques-unes des métriques que vous pouvez consulter pour l'application exemple :

Métriques du runtime JVM : l'agent Java OpenTelemetry émet des métriques sur la JVM sous-jacente. Ces métriques exposent des informations sur la mémoire JVM, la récupération de mémoire, les classes, les threads et d'autres concepts associés. Pour obtenir la liste complète des métriques JVM acceptées, consultez la page Conventions sémantiques pour les métriques d'exécution JVM.
- Utilisation de la mémoire JVM : collez la requête PromQL suivante dans l'explorateur de métriques :
```
sum(avg_over_time({"process.runtime.jvm.memory.usage"}[${__interval}]))
```
- Utilisation du processeur par la JVM : collez la requête PromQL suivante dans l'explorateur de métriques :
```
sum(avg_over_time({"process.runtime.jvm.cpu.utilization"}[${__interval}]))
```
  Le graphique suivant montre la métrique d'utilisation du processeur par la JVM :
Métriques Spring Boot : l'exemple d'application utilise le framework Spring Boot, qui est également compatible avec l'instrumentation OpenTelemetry sans code pour Java.
- Durée moyenne du client HTTP : collez la requête PromQL suivante dans l'explorateur de métriques :
```
sum(rate({"http.client.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.client.duration_count"}[${__interval}])) by (cluster, job)
```
- Durée moyenne du serveur HTTP : collez la requête PromQL suivante dans l'explorateur de métriques :
```
sum(rate({"http.server.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.server.duration_count"}[${__interval}])) by (cluster, job)
```
  Le graphique suivant montre la métrique de durée moyenne du serveur HTTP Spring Boot :

Pour plus d'informations sur l'utilisation de l'explorateur de métriques, consultez Sélectionner des métriques lorsque vous utilisez l'explorateur de métriques.

Afficher les traces

Vous pouvez afficher vos traces auto-instrumentées dans l'explorateur de traces de Cloud Trace. Vous pouvez filtrer ces traces dans l'explorateur de traces en filtrant sur "Nom du service" et en définissant le nom du service sur quickstart-app.

Dans la console Google Cloud , accédez à la page Explorateur Trace :

Accéder à Explorateur Trace

Vous pouvez également accéder à cette page à l'aide de la barre de recherche.

La capture d'écran suivante montre les traces générées par le déploiement OpenTelemetry quickstart-app :

L'explorateur de traces affiche les traces capturées par l'instrumentation OpenTelemetry sans code.

Pour en savoir plus sur l'utilisation de l'explorateur de traces, consultez Rechercher et explorer des traces.

Effectuer un nettoyage

Si vous avez créé un projet Google Cloud et que vous n'en avez plus besoin, vous pouvez le supprimer en exécutant la commande suivante :

gcloud projects delete PROJECT_ID

Si vous avez utilisé un projet existant, vous pouvez supprimer les ressources que vous avez créées dans le cadre de ce tutoriel pour réduire les coûts :

Supprimez le cluster GKE en exécutant la commande suivante :

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

Supprimez le dépôt Artifact Registry en exécutant la commande suivante :

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

Utiliser l'instrumentation OpenTelemetry sans code pour les charges de travail Java sur GKE Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Pourquoi utiliser l'instrumentation sans code ?

Présentation

Avant de commencer

Sélectionner ou créer un projet Google Cloud

Installer les outils de ligne de commande

Définir des variables d'environnement

Activer les API

Configurer votre cluster

Déployer l'application Java

Configurer une instance de collecteur OpenTelemetry

Configurer l'instrumentation OpenTelemetry sans code

Générer des données de télémétrie à partir de l'application déployée

Afficher votre télémétrie

Afficher les métriques

Afficher les traces

Effectuer un nettoyage

Utiliser l'instrumentation OpenTelemetry sans code pour les charges de travail Java sur GKE