Esegui la migrazione dall'esportatore di traccia all'endpoint OTLP

Puoi eseguire la migrazione delle applicazioni Java, Go, Python e Node.js strumentate manualmente da un esportatore di tracce Google Cloud a un esportatore OTLP OpenTelemetry in-process. L'esportatore OTLP invia i dati di traccia direttamente all'API Telemetry (OTLP) nel tuo progetto Google Cloud utilizzando i protocolli di esportazione supportati (gRPC o http/protobuf).

Questa configurazione esporta solo i dati di traccia e si applica solo agli esportatori in-process. Se la tua applicazione utilizza un agente di raccolta OpenTelemetry, consulta gli esempi di strumentazione basata sull'agente di raccolta e l'agente di raccolta OpenTelemetry creato da Google.

Perché dovresti eseguire la migrazione

Gli SDK OpenTelemetry generano dati di log, metriche e tracce in un formato generalmente coerente con i file proto definiti dal protocollo OpenTelemetry. Tuttavia, i campi potrebbero essere convertiti da un tipo di dati specifico di OpenTelemetry a un tipo di dati JSON prima dell'archiviazione.

Quando un'applicazione esporta i dati in un progetto Google Cloud utilizzando un esportatore Google Cloud , quest'ultimo esegue i seguenti passaggi:

1. Trasforma i dati registrati dal formato OTLP in un formato proprietario definito dall'API Cloud Logging, dall'API Cloud Monitoring o dall'Cloud Trace API.
2. Invia i dati trasformati all'API appropriata, che vengono poi archiviati nel tuo progetto Google Cloud .

Per i dati di traccia, ti consigliamo di eseguire la migrazione della tua applicazione in modo che utilizzi l'API Telemetry (OTLP) per esportare i dati, perché questa esportazione non richiede una trasformazione dei dati. La trasformazione dei dati potrebbe causare la perdita di alcuni dati. Ad esempio, il formato proprietario potrebbe avere limiti inferiori per determinati campi o alcuni campi OTLP potrebbero non essere mappati a un campo nel formato proprietario.

Campioni disponibili

Le applicazioni di esempio a cui si fa riferimento in questa pagina sono disponibili su GitHub. La maggior parte delle applicazioni è configurata per esportare i dati di traccia utilizzando gRPC, il che significa che inviano dati codificati in protobuf nel formato di rete gRPC tramite connessioni HTTP/2. Viene fornito anche un codice di esempio per le applicazioni configurate per esportare i dati di traccia come dati codificati in protobuf su connessioni HTTP:

• Applicazione Java

  L'applicazione di esempio è configurata per esportare le tracce come dati codificati in protobuf su connessioni HTTP. Se preferisci utilizzare gRPC, la strumentazione in questo esempio è applicabile. Tuttavia, devi modificare le proprietà di sistema utilizzate dal modulo di configurazione automatica. L'applicazione di esempio specifica l'esportatore http/protobuf. Per utilizzare gRPC, modifica questa impostazione in grpc.

  Ti consigliamo di utilizzare il modulo di configurazione automatica dell'SDK OpenTelemetry per configurare l'SDK per le tue applicazioni Java, come l'applicazione di esempio.

• Applicazione Go che utilizza gRPC e Applicazione Go che utilizza HTTP

  Esistono due repository Go. In un repository, l'applicazione di esempio utilizza gRPC. L'esempio nell'altro repository utilizza dati codificati con protobuf su connessioni HTTP.

• Repository Python

  Questo repository contiene due esempi, uno per gRPC e uno che utilizza dati codificati con protobuf su connessioni HTTP.

• Applicazione Node.js

  Questo repository contiene due esempi, uno per gRPC e uno che utilizza dati codificati con protobuf su connessioni HTTP.

Prima di iniziare

Prima di eseguire la migrazione dell'applicazione per inviare i dati di traccia all'endpoint OTLP, abilita l'API Telemetry e assicurati di disporre dei ruoli Identity and Access Management (IAM) richiesti. Potresti anche dover concedere ruoli IAM a un account di servizio.

Abilita la fatturazione e l'API Telemetry

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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, if any are not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). 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, if any are not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

Configura autorizzazioni

• Per assicurarti che il account di servizio utilizzato dalla tua applicazione disponga delle autorizzazioni necessarie per scrivere dati di log, metriche e tracce, chiedi all'amministratore di concedere i seguenti ruoli IAM al account di servizio utilizzato dalla tua applicazione:

  Importante: devi concedere questi ruoli al account di servizio utilizzato dalla tua applicazione, non al tuo account utente. La mancata concessione dei ruoli all'entità corretta potrebbe comportare errori di autorizzazione.
  • Logs Writer (roles/logging.logWriter) sul progetto
  • Monitoring Metric Writer (roles/monitoring.metricWriter) sul progetto
  • Cloud Telemetry Traces Writer (roles/telemetry.tracesWriter) sul tuo progetto
  • Service Usage Consumer (roles/serviceusage.serviceUsageConsumer) sul progetto di quota

  Per scoprire come configurare un progetto di quota, consulta Imposta il progetto di quota.

  Per scoprire di più sulle Credenziali predefinite dell'applicazione (ADC), consulta Come funzionano le Credenziali predefinite dell'applicazione e Configura le Credenziali predefinite dell'applicazione (ADC) per un ambiente di sviluppo locale.

• Per ottenere le autorizzazioni necessarie per visualizzare i dati di log, metriche e tracce, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

  • Visualizzatore log (roles/logging.viewer)
  • Monitoring Viewer (roles/monitoring.viewer)
  • Utente Cloud Trace (roles/cloudtrace.user)

  Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

  Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Guida alla migrazione per la strumentazione manuale

Questa sezione descrive come modificare l'applicazione in modo che invii i dati di traccia al progetto Google Cloud utilizzando l'API Telemetry.

Aggiungi dipendenze

Il primo passaggio consiste nell'aggiungere le dipendenze per l'esportatore di tracce OTLP di OpenTelemetry nella tua applicazione. Seleziona le versioni delle dipendenze appropriate per la tua applicazione e il tuo sistema di compilazione.

Java

Nota: ti consigliamo di utilizzare il modulo di configurazione automatica dell'SDK OpenTelemetry per configurare l'SDK. L'applicazione di esempio utilizza questo modulo.

Per un'applicazione Java, aggiungi le seguenti dipendenze allo script build.gradle:

implementation("io.opentelemetry:opentelemetry-exporter-otlp:1.62.0")
implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.62.0")

Vai

Questa sezione illustra le modifiche che devi apportare alle dipendenze quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf su connessioni HTTP per l'esportazione, includi il pacchetto otlptracehttp come dipendenza. Per saperne di più, consulta Applicazione Go che utilizza HTTP.

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiorna il file go.mod per includere la seguente dipendenza:

require (
	// ...
	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0
)

Python

Questa sezione illustra le modifiche che devi apportare alle dipendenze quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf su connessioni HTTP per l'esportazione, includi il pacchetto opentelemetry-exporter-otlp-proto-http come requisito. Per saperne di più, consulta il repository Python.

Per un'applicazione Python che utilizza gRPC per l'esportazione, installa le seguenti dipendenze o aggiorna il file requirements.txt:

opentelemetry-exporter-otlp-proto-grpc==1.42.1
grpcio==1.80.0

Node.js

Questa sezione illustra le modifiche che devi apportare alle dipendenze quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf su connessioni HTTP per l'esportazione, includi il pacchetto @opentelemetry/exporter-trace-otlp-proto come dipendenza. Per saperne di più, consulta Applicazione Node.js.

Per un'applicazione Node.js che esporta i dati di traccia utilizzando gRPC, aggiungi le seguenti dipendenze:

"@opentelemetry/exporter-trace-otlp-grpc": "0.221.0",
"@grpc/grpc-js": "1.14.4"

Sostituisci l'utilizzo degli esportatori Google Cloud con gli esportatori OTLP

Aggiorna il codice dell'applicazione in modo che l'SDK OpenTelemetry sia configurato per utilizzare gli esportatori OTLP OpenTelemetry anziché un esportatore di tracce Google Cloud . Le modifiche richieste sono specifiche per lingua.

Java

Per un'applicazione Java, segui questi passaggi:

1. Aggiungi le seguenti istruzioni di importazione:

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

2. Aggiorna il codice dell'applicazione per utilizzare il modulo di configurazione automatica dell'SDK OpenTelemetry per configurare l'SDK:

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

3. Configura le proprietà di sistema utilizzate dal modulo di configurazione automatica in fase di runtime. Questo modulo utilizza queste proprietà per eseguire il bootstrap dell'SDK. Puoi anche utilizzare le variabili di ambiente anziché le proprietà di sistema. Per saperne di più, consulta Variabili di ambiente e proprietà di sistema.

   L'applicazione di esempio definisce le proprietà di sistema nello 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=otlptrace-example',
   	'-Dotel.exporter.otlp.protocol=http/protobuf',
   	'-Dotel.java.global-autoconfigure.enabled=true',
   ]

   Inoltre, passa la configurazione come argomenti JVM:

   application {
   	mainClassName = 'com.google.cloud.opentelemetry.samples.otlptrace.OTLPTraceExample'
   	// Pass the config as JVM arguments to the Java application
   	applicationDefaultJvmArgs = autoconf_config
   }

   Se preferisci esportare i dati di traccia utilizzando gRPC, imposta il protocollo OTLP su grpc anziché su http/protobuf.

Vai

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf su connessioni HTTP per l'esportazione, devi importare il pacchetto otlptracehttp e configurare l'esportatore con le opzioni corrispondenti. Per saperne di più, consulta Applicazione Go che utilizza HTTP.

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiungi le seguenti istruzioni di importazione:

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

	// ...
)

Inoltre, aggiorna il codice di inizializzazione per configurare TraceProvider con l'esportatore gRPC:

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

// Configure gRPC client with 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>"
// Configure exporter to use the credentials
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

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf su connessioni HTTP per l'esportazione, devi importarli dal pacchetto opentelemetry.exporter.otlp.proto.http e configurare l'esportatore con le opzioni corrispondenti. Per saperne di più, consulta il repository Python.

Per un'applicazione Python che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
    OTLPSpanExporter,
)

Inoltre, aggiorna il codice di inizializzazione per configurare TraceProvider con l'esportatore 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

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf su connessioni HTTP per l'esportazione, importa il pacchetto @opentelemetry/exporter-trace-otlp-proto. Per saperne di più, consulta Applicazione Node.js.

Per un'applicazione Node.js che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

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

Inoltre, aggiorna il codice di inizializzazione per configurare TraceProvider con l'esportatore gRPC:

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    credentials: credentials.combineChannelCredentials(
      credentials.createSsl(),
      credentials.createFromGoogleCredential({
        async getRequestHeaders(
          url?: string,
        ): Promise<{[index: string]: string}> {
          const rawHeaders = await authenticatedClient.getRequestHeaders(url);
          return Object.fromEntries(rawHeaders.entries());
        },
      }),
    ),
  }),
});
sdk.start();

Configura l'autenticazione

Con le modifiche precedenti alla configurazione dell'SDK OpenTelemetry, l'applicazione è configurata per esportare le tracce con gli esportatori OTLP OpenTelemetry utilizzando gRPC o HTTP. Successivamente, devi configurare gli esportatori per inviare le tracce al tuo progetto Google Cloud .

Per configurare l'autenticazione, segui questi passaggi:

1. Configura le intestazioni di autenticazione per le chiamate di esportazione.
2. Configura gli attributi delle risorse OpenTelemetry e le intestazioni OTLP obbligatori.
3. Configura l'endpoint dell'esportatore.

Questa sezione descrive in dettaglio ciascuno di questi passaggi.

Configura le intestazioni di autenticazione per le chiamate di esportazione

Per configurare l'esportatore con le tue Google Cloud Credenziali predefinite dell'applicazione (ADC), aggiungi una libreria di autenticazione Google specifica per il linguaggio.

Java

Per un'applicazione Java che utilizza il modulo di configurazione automatica dell'SDK OpenTelemetry, ti consigliamo di utilizzare anche l'estensione di autenticazione di Google Cloud.

implementation("io.opentelemetry.contrib:opentelemetry-gcp-auth-extension:1.56.0-alpha")

Vai

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiorna il file go.mod per includere la seguente dipendenza:

// When using gRPC based OTLP exporter, the auth is built in.
google.golang.org/grpc v1.82.1

Per un'applicazione Go che utilizza HTTP per l'esportazione, aggiorna il file go.mod per includere la seguente dipendenza:

// When using http based OTLP exporter, use explicit auth library
golang.org/x/oauth2 v0.36.0

Python

Per un'applicazione Python, aggiungi le seguenti dipendenze al file requirements.txt:

# Google Auth Library
google-auth==2.53.0

Node.js

Per un'applicazione Node.js, aggiungi la seguente dipendenza:

"google-auth-library": "10.5.0"

Successivamente, aggiorna il codice dell'applicazione che crea l'esportatore di span OTLP in modo che aggiunga alle intestazioni i token di autorizzazione recuperati dalla libreria. Questo passaggio è specifico per ogni linguaggio, ma l'implementazione è simile per tutti i linguaggi.

Java

Se hai un'applicazione Java che utilizza il modulo di configurazione automatica dell'SDK OpenTelemetry e l'estensione di autenticazione di Google Cloud, non devi eseguire passaggi speciali durante l'inizializzazione dell'applicazione. Il modulo di configurazione automatica esegue automaticamente i passaggi necessari per configurare ADC.

Vai

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf su connessioni HTTP per l'esportazione, devi importare il pacchetto otlptracehttp e configurare l'esportatore in modo che sia un oggetto otlptracehttp. Per saperne di più, consulta Applicazione Go che utilizza HTTP.

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiungi le seguenti istruzioni di importazione:

"google.golang.org/grpc"
"google.golang.org/grpc/credentials/oauth"

Inoltre, aggiorna il codice di inizializzazione per configurare ADC prima di creare un'istanza dell'esportatore gRPC:

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

// Configure gRPC client with 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>"
// Configure exporter to use the credentials
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

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf su connessioni HTTP per l'esportazione, utilizza le credenziali predefinite. Devi anche passare queste credenziali quando crei un'istanza di BatchSpanProcessor. Per saperne di più, consulta il repository Python.

Per un'applicazione Python che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

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

Inoltre, aggiorna il codice di inizializzazione per configurare ADC prima di creare un'istanza dell'esportatore 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),
)

Node.js

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf su connessioni HTTP per l'esportazione, le modifiche da apportare sono leggermente diverse da quelle descritte qui. Per saperne di più, consulta il file app-http-proto-export.ts incluso nell'applicazione Node.js.

Per un'applicazione Node.js che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

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

Inoltre, aggiorna il codice di inizializzazione per configurare ADC prima di creare un'istanza dell'esportatore 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();

  // ...
}

Configura gli attributi delle risorse OpenTelemetry richiesti

Aggiungi alla variabile di ambiente OTEL_RESOURCE_ATTRIBUTES la coppia chiave-valore che specifica il tuo progetto. Per la chiave, utilizza gcp.project_id. Come valore, utilizza l'ID del tuo progetto Google Cloud .

Esempio:

export OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=PROJECT_ID"

Se utilizzi Java e configuri l'applicazione in modo che utilizzi l'estensione di autenticazione di Google Cloud, come fa l'applicazione Java di esempio, non devi impostare l'ID progetto come parte degli attributi della risorsa OpenTelemetry. Tuttavia, l'impostazione di questo attributo non è dannosa.

Per saperne di più sulle variabili di ambiente OpenTelemetry, consulta Configurazione generale dell'SDK.

Imposta l'ID progetto di quota

Il progetto di quotaè il progetto Google Cloud che monitora l'utilizzo delle richieste API. Poiché l'API Telemetry è un'API basata su client, il modo in cui esegui l'autenticazione determina se il progetto di quota viene identificato automaticamente. Ad esempio, non è necessario specificare il progetto di quota quando utilizzi un account di servizio per l'autenticazione. Tuttavia, devi specificare il progetto di quota quando le credenziali utente vengono utilizzate per l'autenticazione.

Puoi impostare un progetto di quota utilizzando una variabile di ambiente. Per determinare quale variabile di ambiente impostare per il tuo linguaggio di programmazione, consulta Imposta il progetto di quota utilizzando una variabile di ambiente.

Ad esempio, per Go, puoi impostare il progetto di quota come segue:

export GOOGLE_CLOUD_QUOTA_PROJECT="QUOTA_PROJECT_ID"

Per informazioni su come risolvere gli errori di autenticazione, consulta Le credenziali utente non funzionano.

Nota: non aggiornare la variabile di ambiente OTEL_EXPORTER_OTLP_HEADERS con una coppia chiave-valore che utilizza la chiave x-goog-user-project. Questa configurazione può comportare valori duplicati nella richiesta, il che causa l'errore dei comandi API.

Configura l'endpoint dell'esportatore

Imposta il valore della variabile di ambiente OTEL_EXPORTER_OTLP_ENDPOINT sull'endpoint OTLP per Google Cloud.

Esempio:

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

Se utilizzi Java e il modulo di configurazione automatica, puoi impostare l'endpoint dell'esportatore utilizzando le proprietà di sistema, come fa l'applicazione Java di esempio. Non è necessario impostare la variabile di ambiente dell'esportatore per questa configurazione.

Per saperne di più sulle variabili di ambiente OpenTelemetry, consulta Configurazione generale dell'SDK.