Migrer de l'exportateur de trace vers le point de terminaison OTLP

Ce document explique comment configurer l'exportation des données de trace dans le processus par le SDK OpenTelemetry vers votre projet Google Cloud . Les exemples pour Java, Go, Python et Node.js montrent comment configurer le SDK pour envoyer des données de trace à l'API Telemetry (OTLP) lorsque vous utilisez l'instrumentation manuelle. Pour chaque langage, la page fournit des informations sur l'utilisation des exportateurs OTLP pour envoyer des données de trace à l'aide des protocoles d'exportation compatibles.

L'instrumentation décrite sur cette page ne s'applique qu'aux données de trace. Il n'envoie pas de données de journaux ni de métriques à votre projet Google Cloud .

Si votre application s'appuie sur un collecteur OpenTelemetry pour envoyer des données de trace à votre projet Google Cloud , ce document ne s'applique pas :

• Pour obtenir des exemples d'instrumentation, consultez Exemples d'instrumentation basée sur le collecteur.
• Pour en savoir plus sur les collecteurs, consultez Collecteur OpenTelemetry conçu par Google.

Pourquoi migrer ?

Les SDK OpenTelemetry génèrent des données de journaux, de métriques et de traces dans un format généralement cohérent avec les fichiers proto définis par le protocole OTLP OpenTelemetry. Toutefois, les champs peuvent être convertis d'un type de données spécifique à OpenTelemetry en type de données JSON avant le stockage.

Lorsqu'une application exporte ces données vers un projet Google Cloud à l'aide d'un exportateur Google Cloud , cet exportateur effectue les étapes suivantes :

1. Transforme les données enregistrées au format OTLP en un format propriétaire défini par l'API Cloud Logging, l'API Cloud Monitoring ou l'API Cloud Trace.
2. envoie les données transformées à l'API appropriée, qui les stocke ensuite dans votre projet Google Cloud .

Pour les données de trace, nous vous recommandons de migrer votre application afin d'utiliser l'API Telemetry (OTLP) pour exporter les données, car cette exportation ne nécessite pas de transformation des données. La transformation des données peut entraîner la perte de certaines données. Par exemple, le format propriétaire peut avoir des limites inférieures pour certains champs, ou certains champs OTLP peuvent ne pas correspondre à un champ du format propriétaire.

Remarque : L'API Telemetry n'accepte que les données de trace. Vous ne pouvez pas envoyer de données de métriques ni de journaux à votre projet Google Cloud à l'aide de ce point de terminaison.

Échantillons disponibles

Les exemples d'applications mentionnés sur cette page sont disponibles sur GitHub. La plupart des applications sont configurées pour exporter des données de trace à l'aide de gRPC, ce qui signifie qu'elles utilisent des données encodées au format protobuf à l'aide du format filaire gRPC sur des connexions HTTP/2. Un exemple de code est également fourni pour les applications configurées pour exporter les données de trace sous forme de données encodées au format protobuf via des connexions HTTP :

• Application Java

  L'application exemple est configurée pour exporter les traces sous forme de données encodées au format protobuf via des connexions HTTP. Si vous préférez utiliser gRPC, l'instrumentation de cet exemple est applicable. Toutefois, vous devez modifier les propriétés système que consomme le module d'autoconfiguration. L'application exemple spécifie l'exportateur http/protobuf. Pour utiliser gRPC, définissez ce paramètre sur grpc.

  Nous vous recommandons d'utiliser le module Autoconfigure du SDK OpenTelemetry pour configurer le SDK dans vos applications Java, comme l'exemple d'application.

• Application Go utilisant gRPC et Application Go utilisant HTTP

  Il existe deux dépôts Go. Dans un dépôt, l'exemple d'application utilise gRPC. L'exemple de l'autre dépôt utilise des données encodées au format Protobuf sur des connexions HTTP.

• Application Python

  Ce dépôt contient deux exemples : l'un pour gRPC et l'autre qui utilise des données encodées au format Protobuf sur des connexions HTTP.

• Application Node.js

  Ce dépôt contient deux exemples : l'un pour gRPC et l'autre qui utilise des données encodées au format Protobuf sur des connexions HTTP.

Avant de commencer

Avant de migrer votre application pour envoyer des données de trace au point de terminaison OTLP, activez l'API Telemetry et assurez-vous de disposer des rôles Identity and Access Management (IAM) requis. Vous devrez peut-être également attribuer des rôles IAM à un compte de service.

Activer la facturation et l'API Telemetry

Remarque : L'API Telemetry est désactivée par défaut.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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.

Enable the Telemetry, Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

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.

Enable the Telemetry, Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Configurer les autorisations

• Attribuez les rôles IAM suivants au compte de service utilisé par votre application :

  • Rédacteur de traces de télémétrie cloud (roles/telemetry.tracesWriter)
  • Rédacteur de journaux (roles/logging.logWriter) |
  • Rédacteur de métriques Monitoring (roles/monitoring.metricWriter)

  Pour en savoir plus sur les Identifiants par défaut de l'application (ADC), consultez Fonctionnement des identifiants par défaut de l'application et Configurer les Identifiants par défaut de l'application (ADC) pour un environnement de développement local.

• Pour obtenir les autorisations nécessaires pour afficher vos données de journaux, de métriques et de traces, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

  • Lecteur de journaux (roles/logging.viewer)
  • Lecteur Monitoring (roles/monitoring.viewer)
  • Utilisateur Cloud Trace (roles/cloudtrace.user)

  Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

  Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Guide de migration pour l'instrumentation manuelle

Cette section explique comment modifier votre application pour qu'elle envoie vos données de trace à votre projet Google Cloud à l'aide de l'API Telemetry. Vous ne pouvez pas envoyer de données de métriques ni de journaux à ce point de terminaison.

Ajouter des dépendances

La première étape consiste à ajouter des dépendances pour l'exportateur de trace OTLP d'OpenTelemetry dans votre application. Sélectionnez les versions de dépendances adaptées à votre application et à votre système de compilation.

Java

Remarque : Nous vous recommandons d'utiliser le module Autoconfigure du SDK OpenTelemetry pour configurer le SDK. L'exemple d'application utilise ce module.

Pour une application Java, ajoutez les dépendances suivantes à votre script build.gradle :

// use the latest versions
implementation("io.opentelemetry:opentelemetry-exporter-otlp:1.56.0")
implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.56.0")

Go

Cette section illustre les modifications que vous devez apporter à vos dépendances lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format protobuf sur des connexions HTTP pour l'exportation, incluez le package otlptracehttp en tant que dépendance. Pour en savoir plus, consultez Application Go utilisant HTTP.

Pour une application Go qui utilise gRPC pour l'exportation, mettez à jour le fichier go.mod pour inclure la dépendance suivante :

// go.mod file
require(
  // OTLP exporter that uses grpc protocol for export
  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0
)

Python

Cette section illustre les modifications que vous devez apporter à vos dépendances lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format protobuf sur des connexions HTTP pour l'exportation, incluez le package opentelemetry-exporter-otlp-proto-http comme exigence. Pour en savoir plus, consultez Application Python.

Pour une application Python qui utilise gRPC pour l'exportation, installez les dépendances suivantes ou mettez à jour le fichier requirements.txt :

# Requirements.txt - use appropriate versions
#
# OTLP exporter that uses grcp protocol for export
opentelemetry-exporter-otlp-proto-grpc==1.39.0
grpcio==1.76.0

Node.js

Cette section illustre les modifications que vous devez apporter à vos dépendances lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format protobuf sur des connexions HTTP pour l'exportation, incluez le package @opentelemetry/exporter-trace-otlp-proto en tant que dépendance. Pour en savoir plus, consultez Application Node.js.

Pour une application Node.js qui utilise gRPC pour les exportations, ajoutez les dépendances suivantes.

"@opentelemetry/exporter-trace-otlp-grpc": "0.203.0",
"@grpc/grpc-js": "1.13.4",

Remplacer l'utilisation des exportateurs Google Cloud par des exportateurs OTLP

Mettez à jour le code de votre application afin que le SDK OpenTelemetry soit configuré pour utiliser les exportateurs OTLP OpenTelemetry au lieu de l'exportateur de trace Google Cloud . Les modifications requises dépendent de la langue.

Java

Pour une application Java, procédez comme suit :

1. Ajoutez les instructions d'importation suivantes :

   import io.opentelemetry.sdk.OpenTelemetrySdk;
   import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
   

2. Mettez à jour le code de l'application pour utiliser le module Autoconfigure du SDK OpenTelemetry afin de configurer le SDK :

   public static void main(String[] args) {
       // Configure the OpenTelemetry pipeline with Auto configuration
       openTelemetrySdk = AutoConfiguredOpenTelemetrySdk.initialize().getOpenTelemetrySdk();
       ...
   }
   

3. Configurez les propriétés système que le module de configuration automatique utilise au moment de l'exécution. Ce module utilise ces propriétés pour amorcer le SDK. Vous pouvez également utiliser des variables d'environnement au lieu de propriétés système. Pour en savoir plus, consultez Variables d'environnement et propriétés système.

   L'application exemple définit les propriétés système dans le script build.gradle :

   // You can switch the desired protocol here by changing `otel.exporter.otlp.protocol`.
   def autoconf_config = [
     '-Dotel.exporter.otlp.endpoint=https://telemetry.googleapis.com',
     '-Dotel.traces.exporter=otlp',
     '-Dotel.logs.exporter=none',
     '-Dotel.metrics.exporter=none',
     '-Dotel.service.name=my-service',
     '-Dotel.exporter.otlp.protocol=http/protobuf',
     '-Dotel.java.global-autoconfigure.enabled=true',
     // ID of your Google Cloud Project, required by the auth extension
     '-Dgoogle.cloud.project=PROJECT_ID',
   ]
   
   // Now pass the config as JVM arguments to your java application:
   application {
           // Replace with the fully qualified name of your Main class.
     mainClassName = 'com.example.Main'
     applicationDefaultJvmArgs = autoconf_config
   }
   

   Si vous préférez exporter les données de trace à l'aide de gRPC, définissez le protocole OTLP sur grpc au lieu de http/protobuf.

Go

Cette section illustre les modifications à apporter lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format protobuf via des connexions HTTP pour l'exportation, vous devez importer le package otlptracehttp et configurer l'exportateur avec les options correspondantes. Pour en savoir plus, consultez Application Go utilisant HTTP.

Pour une application Go qui utilise gRPC pour l'exportation, ajoutez les instructions d'importation suivantes :

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    // other dependencies
)

Mettez également à jour le code d'initialisation pour configurer TraceProvider avec l'exportateur gRPC :

// Initializes OpenTelemetry with OTLP exporters
ctx := context.Background()

// creds: configure Application Default Credentials

// Initialize the OTLP gRPC exporter
exporter, err := otlptracegrpc.New(ctx)
if err != nil {
  panic(err)
}

// set OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=<project_id>"
// set endpoint with OTEL_EXPORTER_OTLP_ENDPOINT=https://<endpoint>
// set OTEL_EXPORTER_OTLP_HEADERS="x-goog-user-project=<project_id>"
exporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithDialOption(grpc.WithPerRPCCredentials(creds)))
if err != nil {
  panic(err)
}

tp := sdktrace.NewTracerProvider(
  // For this example code we use sdktrace.AlwaysSample sampler to sample all traces.
  // In a production application, use sdktrace.TraceIDRatioBased with a desired probability.
  sdktrace.WithSampler(sdktrace.AlwaysSample()),
  sdktrace.WithBatcher(exporter))

otel.SetTracerProvider(tp)

Python

Cette section illustre les modifications à apporter lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format Protobuf via des connexions HTTP pour l'exportation, vous devez importer à partir du package opentelemetry.exporter.otlp.proto.http et configurer l'exportateur avec les options correspondantes. Pour en savoir plus, consultez Application Python.

Pour une application Python qui utilise gRPC pour l'exportation, ajoutez les importations suivantes :

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
    OTLPSpanExporter,
)
from opentelemetry.sdk.resources import SERVICE_NAME, Resource

Mettez également à jour le code d'initialisation pour configurer TraceProvider avec l'exportateur gRPC :

# Initialize OpenTelemetry with OTLP exporters

# channel_creds: configure Application Default Credentials

trace_provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(
    OTLPSpanExporter(
        credentials=channel_creds,
        endpoint="https://telemetry.googleapis.com:443/v1/traces",
    )
)
trace_provider.add_span_processor(processor)
trace.set_tracer_provider(trace_provider)
tracer = trace.get_tracer("my.tracer.name")

Node.js

Cette section illustre les modifications à apporter lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format protobuf sur des connexions HTTP pour l'exportation, importez le package @opentelemetry/exporter-trace-otlp-proto. Pour en savoir plus, consultez Application Node.js.

Pour une application Node.js qui utilise gRPC pour l'exportation, ajoutez les importations suivantes :

import {OTLPTraceExporter} from '@opentelemetry/exporter-trace-otlp-grpc';

Mettez également à jour le code d'initialisation pour configurer TraceProvider avec l'exportateur gRPC :

// Express App that exports traces via gRPC with protobuf
async function main() {
  // authenticatedClient: configure Application Default Credentials

  // Configure the TraceExporter
  const sdk = new NodeSDK({
    traceExporter: new OTLPTraceExporter({
      credentials: credentials.combineChannelCredentials(
        credentials.createSsl(),
        credentials.createFromGoogleCredential(authenticatedClient),
      ),
    }),
  });
  sdk.start();
}

Configurer l'authentification

Grâce aux modifications apportées à la configuration du SDK OpenTelemetry, votre application est configurée pour exporter des traces à l'aide des exportateurs OTLP OpenTelemetry, que ce soit avec gRPC ou HTTP. Ensuite, vous devez configurer les exportateurs pour envoyer ces traces à votre projet Google Cloud .

Pour configurer l'authentification, procédez comme suit :

1. Configurez les en-têtes d'authentification pour les appels d'exportation.
2. Configurez les attributs de ressources OpenTelemetry et les en-têtes OTLP requis.
3. Configurez le point de terminaison de l'exportateur.

Cette section détaille chacune de ces étapes.

Configurer les en-têtes d'authentification pour les appels d'exportation

Pour configurer l'exportateur avec vos Google Cloud identifiants par défaut de l'application (ADC), ajoutez une bibliothèque d'authentification Google spécifique à la langue.

Java

Pour vous authentifier auprès de Trace, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Pour une application Java qui utilise le module d'autoconfiguration du SDK OpenTelemetry, nous vous recommandons d'utiliser également l'extension d'authentification Google Cloud.

// build.gradle
implementation("io.opentelemetry.contrib:opentelemetry-gcp-auth-extension:1.52.0-alpha")

Go

Pour vous authentifier auprès de Trace, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Pour une application Go qui utilise gRPC pour l'exportation, mettez à jour le fichier go.mod pour inclure la dépendance suivante :

// go.mod file
require (
    // When using gRPC based OTLP exporter, auth is built-in
    google.golang.org/grpc v1.75.1
)

Pour une application Go qui utilise HTTP pour l'exportation, mettez à jour le fichier go.mod pour inclure la dépendance suivante :

// go.mod file
require (
    // When using http based OTLP exported, use explicit auth library
  golang.org/x/oauth2 v0.31.0
)

Python

Pour vous authentifier auprès de Trace, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Pour une application Python, ajoutez les importations suivantes :

# requirements.txt
# Google Auth Library
google-auth==2.38.0

Node.js

Pour vous authentifier auprès de Trace, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Pour une application Node.js, ajoutez les dépendances suivantes :

"google-auth-library": "9.15.1",

Ensuite, mettez à jour le code de l'application qui construit l'exportateur de spans OTLP afin qu'il ajoute les jetons d'autorisation récupérés à partir de la bibliothèque aux en-têtes. Cette étape est spécifique à un langage, mais l'implémentation est semblable pour tous les langages.

Java

Si vous disposez d'une application Java qui utilise le module d'autoconfiguration du SDK OpenTelemetry et l'extension d'authentification Google Cloud, vous n'avez pas besoin d'effectuer d'étapes spéciales lors de l'initialisation de votre application. Le module de configuration automatique effectue automatiquement les étapes nécessaires à la configuration d'ADC.

Go

Cette section illustre les modifications à apporter lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format protobuf sur des connexions HTTP pour l'exportation, vous devez importer le package otlptracehttp et configurer l'exportateur pour qu'il soit un objet otlptracehttp. Pour en savoir plus, consultez Application Go utilisant HTTP.

Pour une application Go qui utilise gRPC pour l'exportation, ajoutez les instructions d'importation suivantes :

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    // other dependencies
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/oauth"
)

Mettez également à jour le code d'initialisation pour configurer ADC avant d'instancier l'exportateur gRPC :

// Initializes OpenTelemetry with OTLP exporters
ctx := context.Background()

// Retrieve and store Google application-default credentials
creds, err := oauth.NewApplicationDefault(ctx)
if err != nil {
  panic(err)
}

// set OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=<project_id>"
// set endpoint with OTEL_EXPORTER_OTLP_ENDPOINT=https://<endpoint>
// set OTEL_EXPORTER_OTLP_HEADERS="x-goog-user-project=<project_id>"
exporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithDialOption(grpc.WithPerRPCCredentials(creds)))
if err != nil {
  panic(err)
}

// Other OpenTelemetry configuration remains unaffected.

Python

Cette section illustre les modifications à apporter lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format Protobuf sur des connexions HTTP pour l'exportation, utilisez les identifiants par défaut. Vous devez également transmettre ces identifiants lorsque vous instanciez BatchSpanProcessor. Pour en savoir plus, consultez Application Python.

Pour une application Python qui utilise gRPC pour l'exportation, ajoutez les importations suivantes :

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
    OTLPSpanExporter,
)
from opentelemetry.sdk.resources import SERVICE_NAME, Resource

import google.auth
import google.auth.transport.grpc
import google.auth.transport.requests
import grpc
from google.auth.transport.grpc import AuthMetadataPlugin

Mettez également à jour le code d'initialisation pour configurer ADC avant d'instancier l'exportateur gRPC :

credentials, _ = google.auth.default()
request = google.auth.transport.requests.Request()
resource = Resource.create(attributes={SERVICE_NAME: "otlp-gcp-grpc-sample"})

auth_metadata_plugin = AuthMetadataPlugin(credentials=credentials, request=request)
channel_creds = grpc.composite_channel_credentials(
    grpc.ssl_channel_credentials(),
    grpc.metadata_call_credentials(auth_metadata_plugin),
)

# Configure the TraceProvider

Node.js

Cette section illustre les modifications à apporter lorsque vous utilisez gRPC pour l'exportation. Si vous utilisez des données encodées au format protobuf sur des connexions HTTP pour l'exportation, les modifications à apporter sont légèrement différentes de celles décrites ici. Pour en savoir plus, consultez le fichier app-http-proto-export.ts inclus dans l'application Node.js.

Pour une application Node.js qui utilise gRPC pour l'exportation, ajoutez les importations suivantes :

import {AuthClient, GoogleAuth} from 'google-auth-library';
import {credentials} from '@grpc/grpc-js';

Mettez également à jour le code d'initialisation pour configurer ADC avant d'instancier l'exportateur gRPC :

async function getAuthenticatedClient(): Promise<AuthClient> {
  const auth: GoogleAuth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
  });
  return await auth.getClient();
}

// Express App that exports traces via gRPC with protobuf
async function main() {
  const authenticatedClient: AuthClient = await getAuthenticatedClient();

  // Configure the TraceExporter
}

Configurer les attributs de ressource OpenTelemetry requis

Ajoutez à la variable d'environnement OTEL_RESOURCE_ATTRIBUTES la paire clé-valeur qui spécifie votre projet. Pour la clé, utilisez gcp.project_id. Pour la valeur, utilisez l'ID de votre projet Google Cloud .

Exemple :

export OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=PROJECT_ID"

Si vous utilisez Java et que vous configurez votre application pour qu'elle utilise l'extension d'authentification Google Cloud, comme le fait l'exemple d'application Java, vous n'avez pas besoin de définir l'ID de projet dans les attributs de ressource OpenTelemetry. Toutefois, la définition de cet attribut n'est pas préjudiciable.

Pour en savoir plus sur les variables d'environnement OpenTelemetry, consultez Configuration générale du SDK.

Définir l'ID du projet de quota

Le projet de quota est le projet Google Cloud qui suit votre utilisation des requêtes API. Étant donné que l'API Telemetry est une API basée sur le client, la façon dont vous vous authentifiez détermine si le projet de quota est automatiquement identifié. Par exemple, vous n'avez pas besoin de spécifier le projet de quota lorsque vous utilisez un compte de service pour l'authentification. Toutefois, vous devez spécifier le projet de quota lorsque des identifiants utilisateur sont utilisés pour l'authentification.

Vous pouvez définir un projet de quota à l'aide d'une variable d'environnement. Pour déterminer la variable d'environnement à définir pour votre langage de programmation, consultez Définir le projet de quota à l'aide d'une variable d'environnement.

Par exemple, pour Go, vous pouvez définir le projet de quota comme suit :

export GOOGLE_CLOUD_QUOTA_PROJECT="QUOTA_PROJECT_ID"

Pour savoir comment résoudre les erreurs d'authentification, consultez Les identifiants utilisateur ne fonctionnent pas.

Remarque : Ne mettez pas à jour la variable d'environnement OTEL_EXPORTER_OTLP_HEADERS avec une paire clé/valeur qui utilise la clé x-goog-user-project. Cette configuration peut entraîner des valeurs en double dans la requête, ce qui provoque l'échec des commandes API.

Configurer le point de terminaison de l'exportateur

Définissez la valeur de la variable d'environnement OTEL_EXPORTER_OTLP_ENDPOINT sur le point de terminaison OTLP pour Google Cloud.

Exemple :

export OTEL_EXPORTER_OTLP_ENDPOINT=https://telemetry.googleapis.com

Si vous utilisez Java et le module de configuration automatique, vous pouvez définir le point de terminaison de l'exportateur à l'aide des propriétés système, comme le fait l'exemple d'application Java. Vous n'avez pas besoin de définir la variable d'environnement de l'exportateur pour cette configuration.

Pour en savoir plus sur les variables d'environnement OpenTelemetry, consultez Configuration générale du SDK.