Migra del exportador de seguimiento al extremo de OTLP

En este documento, se describe cómo configurar la exportación integrada de datos de seguimiento por parte del SDK de OpenTelemetry a tu proyecto de Google Cloud . En los ejemplos para Java, Go, Python y Node.js, se muestra cómo configurar el SDK para enviar datos de seguimiento a la API de Telemetry (OTLP) cuando usas la instrumentación manual. Para cada lenguaje, la página proporciona información para usar exportadores de OTLP y enviar datos de seguimiento con los protocolos de exportación compatibles.

La instrumentación que se describe en esta página solo se aplica a los datos de seguimiento. No envía datos de registro ni de métricas a tu proyecto Google Cloud .

Si tu aplicación depende de un recopilador de OpenTelemetry para enviar datos de seguimiento a tu proyecto de Google Cloud , este documento no se aplica:

• Para ver ejemplos de instrumentación, consulta Ejemplos de instrumentación basados en el recopilador.
• Para obtener información sobre los recopiladores, consulta Recopilador de OpenTelemetry integrado en Google.

Por qué deberías migrar

Los SDKs de OpenTelemetry generan datos de registro, métricas y seguimiento en un formato que suele ser coherente con los archivos .proto definidos por el protocolo OTLP de OpenTelemetry. Sin embargo, es posible que los campos se conviertan de un tipo de datos específico de OpenTelemetry a un tipo de datos JSON antes del almacenamiento.

Cuando una aplicación exporta esos datos a un Google Cloud proyecto con un Google Cloud exportador, este realiza los siguientes pasos:

1. Transforma los datos registrados del formato OTLP a un formato propietario definido por la API de Cloud Logging, la API de Cloud Monitoring o la API de Cloud Trace.
2. Envía los datos transformados a la API adecuada, que luego se almacena en tu proyecto Google Cloud .

Para los datos de seguimiento, te recomendamos que migres tu aplicación para usar la API de Telemetry (OTLP) para exportar datos, ya que esta exportación no requiere una transformación de datos. La transformación de datos puede provocar la pérdida de algunos datos. Por ejemplo, el formato propietario podría tener límites más bajos para ciertos campos, o algunos campos de OTLP podrían no asignarse a un campo en el formato propietario.

Nota: La API de Telemetry solo acepta datos de seguimiento. No puedes enviar datos de métricas ni de registros a tu proyecto de Google Cloud con este extremo.

Muestras disponibles

Las aplicaciones de muestra a las que se hace referencia en esta página están disponibles en GitHub. La mayoría de las aplicaciones están configuradas para exportar datos de seguimiento con gRPC, lo que significa que usan datos codificados con protobuf en formato de transferencia de gRPC a través de conexiones HTTP/2. También se proporciona código de ejemplo para las aplicaciones configuradas para exportar datos de seguimiento como datos codificados con protobuf a través de conexiones HTTP:

• Aplicación Java

  La aplicación de ejemplo está configurada para exportar registros como datos codificados con protobuf a través de conexiones HTTP. Si prefieres usar gRPC, la instrumentación de este ejemplo es aplicable. Sin embargo, debes modificar las propiedades del sistema que consume el módulo de autoconfiguración. La aplicación de ejemplo especifica el exportador http/protobuf. Para usar gRPC, cambia este parámetro de configuración a grpc.

  Recomendamos que tus aplicaciones de Java, como la aplicación de ejemplo, usen el módulo de autoconfiguración del SDK de OpenTelemetry para configurar el SDK.

• Aplicación en Go que usa gRPC y aplicación en Go que usa HTTP

  Hay dos repositorios de Go. En un repositorio, la aplicación de ejemplo usa gRPC. La muestra del otro repositorio usa datos codificados con protobuf a través de conexiones HTTP.

• Aplicación de Python

  Este repositorio contiene dos muestras, una para gRPC y otra que usa datos codificados con protobuf a través de conexiones HTTP.

• Aplicación de Node.js

  Este repositorio contiene dos muestras, una para gRPC y otra que usa datos codificados con protobuf a través de conexiones HTTP.

Antes de comenzar

Antes de migrar tu aplicación para enviar datos de seguimiento al extremo de OTLP, habilita la API de Telemetry y asegúrate de que se te hayan otorgado los roles necesarios de Identity and Access Management (IAM). También es posible que debas otorgar roles de IAM a una cuenta de servicio.

Habilita la facturación y la API de Telemetry

Nota: La API de Telemetry está inhabilitada de forma predeterminada.

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

Configura permisos

• Otorga los siguientes roles de IAM a la cuenta de servicio que usa tu aplicación:

  • Escritor de registros de telemetría de Cloud (roles/telemetry.tracesWriter)
  • Escritor de registros (roles/logging.logWriter) |
  • Escritor de métricas de Monitoring (roles/monitoring.metricWriter)

  Para obtener información sobre las credenciales predeterminadas de la aplicación (ADC), consulta Cómo funcionan las credenciales predeterminadas de la aplicación y Configura las credenciales predeterminadas de la aplicación (ADC) para un entorno de desarrollo local.

• Para obtener los permisos que necesitas para ver tus datos de registros, métricas y seguimientos, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

  • Visor de registro (roles/logging.viewer)
  • Visualizador de Monitoring (roles/monitoring.viewer)
  • Usuario de Cloud Trace (roles/cloudtrace.user)

  Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

  También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Guía de migración para la instrumentación manual

En esta sección, se describe cómo modificar tu aplicación para que envíe tus datos de seguimiento a tu proyecto de Google Cloud con la API de Telemetry. No puedes enviar datos de métricas ni de registros a este extremo.

Agrega dependencias

El primer paso es agregar dependencias para el exportador de seguimiento de OTLP de OpenTelemetry en tu aplicación. Selecciona las versiones de dependencia adecuadas para tu aplicación y sistema de compilación.

Java

Nota: Te recomendamos que uses el módulo de autoconfiguración del SDK de OpenTelemetry para configurar el SDK. La aplicación de ejemplo usa este módulo.

Para una aplicación Java, en tu secuencia de comandos build.gradle, agrega las siguientes dependencias:

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

Go

En esta sección, se ilustran los cambios que debes realizar en tus dependencias cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, incluye el paquete otlptracehttp como dependencia. Para obtener más información, consulta Aplicación en Go que usa HTTP.

En el caso de una aplicación en Go que usa gRPC para la exportación, actualiza el archivo go.mod para incluir la siguiente dependencia:

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

Python

En esta sección, se ilustran los cambios que debes realizar en tus dependencias cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, incluye el paquete opentelemetry-exporter-otlp-proto-http como requisito. Para obtener más información, consulta Aplicación de Python.

Para una aplicación de Python que usa gRPC para la exportación, instala las siguientes dependencias o actualiza el archivo 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

En esta sección, se ilustran los cambios que debes realizar en tus dependencias cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, incluye el paquete @opentelemetry/exporter-trace-otlp-proto como dependencia. Para obtener más información, consulta Aplicación de Node.js.

Para una aplicación de Node.js que exporte con gRPC, agrega las siguientes dependencias.

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

Reemplaza el uso de exportadores de Google Cloud por exportadores de OTLP

Actualiza el código de tu aplicación para que el SDK de OpenTelemetry esté configurado para usar los exportadores de OTLP de OpenTelemetry en lugar del exportador de seguimientos de Google Cloud . Los cambios requeridos son específicos para cada idioma.

Java

Para una aplicación de Java, haz lo siguiente:

1. Agrega las siguientes instrucciones de importación:

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

2. Actualiza el código de la aplicación para usar el módulo de autoconfiguración del SDK de OpenTelemetry para configurar el SDK:

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

3. Configura las propiedades del sistema que consume el módulo de autoconfiguración en el tiempo de ejecución. Ese módulo usa esas propiedades para iniciar el SDK. También puedes usar variables de entorno en lugar de propiedades del sistema. Para obtener más información, consulta Variables de entorno y propiedades del sistema.

   La aplicación de ejemplo define las propiedades del sistema en la secuencia de comandos 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 prefieres exportar datos de seguimiento con gRPC, configura el protocolo de OTLP como grpc en lugar de http/protobuf.

Go

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, debes importar el paquete otlptracehttp y configurar el exportador con las opciones correspondientes. Para obtener más información, consulta Aplicación en Go que usa HTTP.

Para una aplicación en Go que usa gRPC para la exportación, agrega las siguientes instrucciones de importación:

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

Además, actualiza el código de inicialización para configurar TraceProvider con el exportador de 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

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, debes importar desde el paquete opentelemetry.exporter.otlp.proto.http y también configurar el exportador con las opciones correspondientes. Para obtener más información, consulta Aplicación de Python.

Para una aplicación de Python que usa gRPC para la exportación, agrega las siguientes importaciones:

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

Además, actualiza el código de inicialización para configurar TraceProvider con el exportador de 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

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, importa el paquete @opentelemetry/exporter-trace-otlp-proto. Para obtener más información, consulta Aplicación de Node.js.

Para una aplicación de Node.js que usa gRPC para la exportación, agrega las siguientes importaciones:

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

Además, actualiza el código de inicialización para configurar TraceProvider con el exportador de 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();
}

Configura la autenticación

Con los cambios anteriores en la configuración del SDK de OpenTelemetry, tu aplicación está configurada para exportar seguimientos con los exportadores de OTLP de OpenTelemetry a través de gRPC o HTTP. A continuación, debes configurar los exportadores para que envíen esos registros a tu proyecto de Google Cloud .

Para configurar la autenticación, haz lo siguiente:

1. Configura los encabezados de autenticación para las llamadas de exportación.
2. Configura los atributos de recursos de OpenTelemetry y los encabezados de OTLP necesarios.
3. Configura el extremo del exportador.

En esta sección, se detallan cada uno de estos pasos.

Configura los encabezados de autenticación para las llamadas de exportación

Para configurar el exportador con tus Google Cloud credenciales predeterminadas de la aplicación (ADC), agrega una biblioteca de Google Auth específica del lenguaje.

Java

Para autenticarte en Google Cloud Observability, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Para una aplicación Java que usa el módulo de autoconfiguración del SDK de OpenTelemetry, te recomendamos que también uses la extensión de autenticación de Google Cloud.

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

Go

Para autenticarte en Google Cloud Observability, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

En el caso de una aplicación en Go que usa gRPC para la exportación, actualiza el archivo go.mod para incluir la siguiente dependencia:

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

Para una aplicación en Go que usa HTTP para la exportación, actualiza el archivo go.mod para incluir la siguiente dependencia:

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

Python

Para autenticarte en Google Cloud Observability, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Para una aplicación de Python, agrega las siguientes importaciones:

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

Node.js

Para autenticarte en Google Cloud Observability, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Para una aplicación de Node.js, agrega las siguientes dependencias:

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

A continuación, actualiza el código de la aplicación que construye el exportador de intervalos de OTLP para que agregue los tokens de autorización recuperados de la biblioteca a los encabezados. Este paso es específico del lenguaje, pero la implementación es similar para todos los lenguajes.

Java

Cuando tienes una aplicación Java que usa el módulo de autoconfiguración del SDK de OpenTelemetry y la extensión de autenticación de Google Cloud, no necesitas realizar ningún paso especial durante la inicialización de la aplicación. El módulo de configuración automática realiza automáticamente los pasos necesarios para configurar el ADC.

Go

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, debes importar el paquete otlptracehttp y configurar el exportador para que sea un objeto otlptracehttp. Para obtener más información, consulta Aplicación en Go que usa HTTP.

Para una aplicación en Go que usa gRPC para la exportación, agrega las siguientes instrucciones de importación:

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"
)

Además, actualiza el código de inicialización para configurar el ADC antes de crear una instancia del exportador de 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

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, usa las credenciales predeterminadas. También debes pasar estas credenciales cuando crees una instancia de BatchSpanProcessor. Para obtener más información, consulta Aplicación de Python.

Para una aplicación de Python que usa gRPC para la exportación, agrega las siguientes importaciones:

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

Además, actualiza el código de inicialización para configurar el ADC antes de crear una instancia del exportador de 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

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf a través de conexiones HTTP para la exportación, los cambios que debes realizar son ligeramente diferentes de los que se describen aquí. Para obtener más información, consulta el archivo app-http-proto-export.ts incluido en la aplicación de Node.js.

Para una aplicación de Node.js que usa gRPC para la exportación, agrega las siguientes importaciones:

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

Además, actualiza el código de inicialización para configurar el ADC antes de crear una instancia del exportador de 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
}

Configura los atributos de recursos de OpenTelemetry necesarios

Agrega a la variable de entorno OTEL_RESOURCE_ATTRIBUTES el par clave-valor que especifica tu proyecto. Para la clave, usa gcp.project_id. Para el valor, usa el ID de tu proyecto Google Cloud .

Ejemplo:

export OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=PROJECT_ID"

Si usas Java y configuras tu aplicación para que use la extensión de autenticación de Google Cloud, como lo hace la aplicación de Java de muestra, no es necesario que establezcas el ID del proyecto como parte de los atributos de recursos de OpenTelemetry. Sin embargo, configurar este atributo no es perjudicial.

Para obtener más información sobre las variables de entorno de OpenTelemetry, consulta Configuración general del SDK.

Configura el ID del proyecto de cuota

El proyecto de cuota es el proyecto Google Cloud que hace un seguimiento de tu uso de las solicitudes a la API. Dado que la API de Telemetry es una API basada en el cliente, la forma en que te autentiques determinará si el proyecto de cuota se identifica automáticamente. Por ejemplo, no es necesario que especifiques el proyecto de cuota cuando usas una cuenta de servicio para la autenticación. Sin embargo, debes especificar el proyecto de cuota cuando se usan credenciales de usuario para la autenticación.

Puedes configurar un proyecto de cuota con una variable de entorno. Para determinar qué variable de entorno debes configurar para tu lenguaje de programación, consulta Configura el proyecto de cuota con una variable de entorno.

Por ejemplo, para Go, puedes establecer el proyecto de cuota de la siguiente manera:

export GOOGLE_CLOUD_QUOTA_PROJECT="QUOTA_PROJECT_ID"

Para obtener información sobre cómo resolver errores de autenticación, consulta Las credenciales de usuario no funcionan.

Nota: No actualices la variable de entorno OTEL_EXPORTER_OTLP_HEADERS con un par clave-valor que use la clave x-goog-user-project. Esta configuración puede generar valores duplicados en la solicitud, lo que provoca que fallen los comandos de la API.

Configura el extremo del exportador

Establece el valor de la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT en el extremo de OTLP para Google Cloud.

Ejemplo:

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

Si usas Java y el módulo de configuración automática, puedes establecer el extremo del exportador con las propiedades del sistema, como lo hace la aplicación de Java de ejemplo. No es necesario que establezcas la variable de entorno del exportador para esa configuración.

Para obtener más información sobre las variables de entorno de OpenTelemetry, consulta Configuración general del SDK.