Se usó la API de Cloud Translation para traducir esta página.

Implementa el recopilador de OpenTelemetry creado por Google en Cloud Run

En este documento, se muestra cómo ejecutar el recopilador de OpenTelemetry compilado por Google en Cloud Run para recopilar registros, métricas y seguimientos de OTLP de aplicaciones instrumentadas y, luego, exportar esos datos a Google Cloud.

Antes de comenzar

Para ejecutar el recopilador de OpenTelemetry integrado en Google, se requieren los siguientes recursos:

Un Google Cloud proyecto con la API de Cloud Monitoring, la API de Cloud Trace y la API de Cloud Logging habilitadas.
- Si no tienes un Google Cloud proyecto, haz lo siguiente:
  1. En la consola de Google Cloud , ve a Proyecto nuevo:
    
    Crear un proyecto nuevo
  2. En el campo Nombre del proyecto, ingresa un nombre para tu proyecto y, luego, haz clic en Crear.
  3. Ve a facturación:
    
    Ir a Facturación
  4. Selecciona el proyecto que acabas de crear si aún no está seleccionado en la parte superior de la página.
  5. Se te solicitará que elijas un perfil de pagos existente o que crees uno nuevo.
  La API de Monitoring, la API de Trace y la API de Logging están habilitadas de forma predeterminada para los proyectos nuevos.
- Si ya tienes un Google Cloud proyecto, asegúrate de que la API de Monitoring, la API de Trace y la API de Logging estén habilitadas:
  
  Enable the APIs
Es un servicio de Cloud Run. Si no tienes un servicio de Cloud Run, sigue las instrucciones en Planifica y prepara tu servicio.
Una instalación de gcloud Para obtener información sobre la instalación de gcloud, consulta Instala la CLI de gcloud.

Configura los permisos del recopilador

De forma predeterminada, los trabajos y servicios de Cloud Run usan la cuenta de servicio predeterminada de Compute Engine, PROJECT_NUMBER-compute@developer.gserviceaccount.com. Por lo general, esta cuenta de servicio tiene los roles de Identity and Access Management (IAM) necesarios para escribir las métricas y los registros que se describen en este documento:

Pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

Administrador de Cloud Run (roles/run.admin)
Secret Manager Secret Accessor (roles/secretmanager.secretAccessor)

También puedes configurar una cuenta de servicio administrada por el usuario para Cloud Run. Una cuenta de servicio administrada por el usuario también debe tener estos roles. Para obtener más información sobre las cuentas de servicio de Cloud Run, consulta Introducción a la identidad del servicio.

Implementa el recopilador

Para instalar el recopilador de OpenTelemetry integrado en Google como un sidecar para tu Cloud Run, primero crea un secreto para almacenar la configuración del recopilador.

gcloud secrets create SECRET_NAME --data-file=config.yaml --project=PROJECT_ID

A continuación, agrega el recopilador de OpenTelemetry integrado en Google como un archivo adicional a tu service.yaml:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  annotations:
    run.googleapis.com/launch-stage: ALPHA
  name: google-otel-cloud-run-sample
spec:
  template:
    metadata:
      annotations:
        # [REQUIRED] set the collector as a parent to the app
        run.googleapis.com/container-dependencies: "{app:[collector]}"
        run.googleapis.com/secrets: 'SECRET_NAME:projects/PROJECT_ID/secrets/SECRET_NAME'
    spec:
      containers:
      - image: my-app
        name: app
        ports:
        - containerPort: 8080
        env:
        - name: "OTEL_EXPORTER_OTLP_ENDPOINT"
          value: "http://localhost:4317"
      - image: "us-docker.pkg.dev/cloud-ops-agents-artifacts/google-cloud-opentelemetry-collector/otelcol-google:0.134.0"
        args:
        - --config=/etc/otelcol-google/config.yaml
        name: collector
        startupProbe:
          httpGet:
            path: /
            port: 13133
          timeoutSeconds: 30
          periodSeconds: 30
        livenessProbe:
          httpGet:
            path: /
            port: 13133
          timeoutSeconds: 30
          periodSeconds: 30
        volumeMounts:
        - mountPath: /etc/otelcol-google/
          name: config
      volumes:
      - name: config
        secret:
          items:
          - key: latest
            path: config.yaml
          secretName: 'SECRET_NAME'

Configura el recopilador

Te proporcionamos una configuración del recopilador de OpenTelemetry para que la uses con el recopilador integrado en Google. Esta configuración está diseñada para entregar grandes volúmenes de métricas, registros y seguimientos de OTLP. Esta configuración también está diseñada para evitar problemas comunes de transferencia. Puedes agregar elementos a la configuración, pero te recomendamos que no los quites.

En esta sección, se describe la configuración proporcionada, los componentes clave, como los exportadores, los procesadores, los receptores y otros componentes disponibles.

Configuración del recopilador proporcionada

Puedes encontrar la configuración del recopilador en el directorio google-built-opentelemetry-collector del repositorio opentelemetry-operations-collector:

receivers:
  # Open two OTLP servers:
  # - On port 4317, open an OTLP GRPC server
  # - On port 4318, open an OTLP HTTP server
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
  otlp:
    protocols:
      grpc:
        endpoint: localhost:4317
      http:
        cors:
          # This effectively allows any origin
          # to make requests to the HTTP server.
          allowed_origins:
          - http://*
          - https://*
        endpoint: localhost:4318

processors:
  # The batch processor is in place to regulate both the number of requests
  # being made and the size of those requests.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  # The memorylimiter will check the memory usage of the collector process.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor
  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  # The resourcedetection processor is configured to detect GCP resources.
  # Resource attributes that represent the GCP resource the collector is
  # running on will be attached to all telemetry that goes through this
  # processor.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#gcp-metadata
  resourcedetection:
    detectors: [gcp]
    timeout: 10s

  transform/collision:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["exported_location"], attributes["location"])
      - delete_key(attributes, "location")
      - set(attributes["exported_cluster"], attributes["cluster"])
      - delete_key(attributes, "cluster")
      - set(attributes["exported_namespace"], attributes["namespace"])
      - delete_key(attributes, "namespace")
      - set(attributes["exported_job"], attributes["job"])
      - delete_key(attributes, "job")
      - set(attributes["exported_instance"], attributes["instance"])
      - delete_key(attributes, "instance")
      - set(attributes["exported_project_id"], attributes["project_id"])
      - delete_key(attributes, "project_id")

exporters:
  # The googlecloud exporter will export telemetry to different
  # Google Cloud services:
  # Logs -> Cloud Logging
  # Metrics -> Cloud Monitoring
  # Traces -> Cloud Trace
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/googlecloudexporter
  googlecloud:
    log:
      default_log_name: opentelemetry-collector

  # The googlemanagedprometheus exporter will send metrics to
  # Google Managed Service for Prometheus.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/googlemanagedprometheusexporter
  googlemanagedprometheus:

extensions:
  # Opens an endpoint on 13133 that can be used to check the
  # status of the collector. Since this does not configure the
  # `path` config value, the endpoint will default to `/`.
  #
  # When running on Cloud Run, this extension is required and not optional.
  # In other environments it is recommended but may not be required for operation
  # (i.e. in Container-Optimized OS or other GCE environments).
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/healthcheckextension
  health_check:
    endpoint: 0.0.0.0:13133

service:
  extensions:
  - health_check
  pipelines:
    logs:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - memory_limiter
      - batch
      exporters:
      - googlecloud
    metrics/otlp:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - transform/collision
      - memory_limiter
      - batch
      exporters:
      - googlemanagedprometheus
    traces:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - memory_limiter
      - batch
      exporters:
      - googlecloud
  # Internal telemetry for the collector supports both push and pull-based telemetry data transmission.
  # Leveraging the pre-configured OTLP receiver eliminates the need for an additional port.
  #
  # Docs:
  # https://opentelemetry.io/docs/collector/internal-telemetry/
  telemetry:
    metrics:
      readers:
        - periodic:
            exporter:
              otlp:
                protocol: grpc
                endpoint: localhost:4317

Exportadores

La configuración del recopilador incluye los siguientes exportadores:

Exportador googlecloud para registros y seguimientos Este exportador se configura con un nombre de registro predeterminado.
Exportador de googlemanagedprometheus para métricas. Este exportador no requiere ninguna configuración, pero hay opciones de configuración disponibles. Para obtener información sobre las opciones de configuración del exportador googlemanagedprometheus, consulta Comienza a usar el recopilador de OpenTelemetry en la documentación de Google Cloud Managed Service para Prometheus.

Procesadores

La configuración del recopilador incluye los siguientes procesadores:

batch: Se configura para solicitudes de telemetría por lotes en la cantidad máxima de entradas por solicitud o en el intervalo mínimo de cada 5 segundos (lo que ocurra primero). Google Cloud Google Cloud
memory_limiter: Limita el uso de memoria del recopilador para evitar fallas por memoria insuficiente descartando puntos de datos cuando se supera el límite.
resourcedetection: Detecta automáticamente etiquetas de recursos Google Cloud , como project_id.

Receptores

La configuración del recopilador solo incluye el receptor otlp. Para obtener información sobre cómo instrumentar tus aplicaciones para enviar seguimientos y métricas de OTLP al extremo de OTLP del recopilador, consulta Elige un enfoque de instrumentación.

Componentes disponibles

El recopilador de OpenTelemetry integrado en Google contiene los componentes que la mayoría de los usuarios necesitarán para habilitar una experiencia enriquecida en Google Cloud Observability. Para obtener una lista completa de los componentes disponibles, consulta Components en el repositorio de opentelemetry-operations-collector.

Para solicitar cambios o adiciones a los componentes disponibles, abre una solicitud de función en el repositorio de opentelemetry-operations-collector.

Genera datos de telemetría

Para generar telemetría, crea una aplicación de Cloud Run con un recopilador de sidecar. En el documento Escribe métricas de OTLP con un archivo adicional de OpenTelemetry, se proporciona un instructivo para usar el recopilador de OpenTelemetry integrado en Google como archivo adicional. Puedes usar este instructivo para generar datos de telemetría con el recopilador integrado en Google.

Ver telemetría

El recopilador de OpenTelemetry integrado en Google envía métricas, registros y seguimientos de tus aplicaciones instrumentadas a Google Cloud Observability. El recopilador también envía métricas de autoobservabilidad. En las siguientes secciones, se describe cómo ver esta telemetría.

Consulta tus métricas

El recopilador de OpenTelemetry integrado en Google recopila métricas de Prometheus que puedes ver con el Explorador de métricas. Las métricas recopiladas dependen de la instrumentación de la app, aunque el recopilador creado por Google también escribe algunas métricas propias.

Para ver las métricas recopiladas por el recopilador de OpenTelemetry integrado en Google, haz lo siguiente:

En la consola de Google Cloud , accede a la página Explorador de métricas:
Acceder al Explorador de métricas

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Monitoring.
En la barra de herramientas de la consola de Google Cloud , selecciona tu proyecto de Google Cloud . Para las configuraciones de App Hub, selecciona el proyecto host de App Hub o el proyecto de administración de la carpeta habilitada para apps.
En el elemento Métrica, expande el menú Seleccionar una métrica, ingresa Prometheus Target en la barra de filtros y, luego, usa los submenús para seleccionar un métrica y tipo de recurso específicos:
1. En el menú Recursos activos, elige Destino de Prometheus.
2. Para seleccionar una métrica, usa los menús Categorías de métricas activas y Métricas activas. Las métricas recopiladas por el recopilador de OpenTelemetry integrado en Google tienen el prefijo prometheus.googleapis.com.
3. Haz clic en Aplicar.
Para agregar filtros que quiten series temporales de los resultados de la consulta, usa el elemento Filtro.
Configura cómo se ven los datos.
Cuando las mediciones de una métrica son acumulativas, el Explorador de métricas normaliza automáticamente los datos medidos por el período de alineación, lo que hace que el gráfico muestre una frecuencia. Para obtener más información, consulta Categorías, tipos y conversiones.

Cuando se miden valores de números enteros o dobles, como con las métricas counter, el Explorador de métricas suma automáticamente todas las series temporales. Para cambiar este comportamiento, establece el primer menú de la entrada Agregación como Ninguna.

Para obtener más información sobre la configuración de un gráfico, consulta elige métricas cuando uses el Explorador de métricas.

Ve tus seguimientos

Para ver tus datos de seguimiento, haz lo siguiente:

En la consola de Google Cloud , ve a la página Explorador de seguimiento:
Ve al Explorador de seguimiento

También puedes usar la barra de búsqueda para encontrar esta página.
En la barra de herramientas de la consola de Google Cloud , selecciona tu proyecto de Google Cloud . Para las configuraciones de App Hub, selecciona el proyecto host de App Hub o el proyecto de administración de la carpeta habilitada para la app.
En la sección de la tabla de la página, selecciona una fila.
En el diagrama de Gantt del panel Detalles de seguimiento, selecciona un intervalo.

Se abrirá un panel que muestra información sobre la solicitud registrada. Estos detalles incluyen el método, el código de estado, la cantidad de bytes y el usuario-agente del emisor.
Para ver los registros asociados con este seguimiento, selecciona la pestaña Registros y eventos.

La pestaña muestra registros individuales. Para ver los detalles de la entrada de registro, expande la entrada de registro. También puedes hacer clic en Ver registros y ver el registro con el Explorador de registros.

Si deseas obtener más información para usar el explorador de Cloud Trace, consulta Busca y explora seguimientos.

Mira los registros

En el Explorador de registros, puedes inspeccionar tus registros y, también, puedes ver los seguimientos asociados, cuando existen.

En la consola de Google Cloud , accede a la página Explorador de registros:
Acceder al Explorador de registros

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Logging.
Busca una entrada de registro de tu app instrumentada. Para ver los detalles, expande la entrada de registro.
Haz clic en Seguimientos en una entrada de registro con un mensaje de seguimiento y, luego, selecciona Ver detalles de seguimiento.

Se abrirá el panel Detalles de seguimiento y se mostrará el seguimiento seleccionado.

Para obtener más información sobre el uso del Explorador de registros, consulta Visualiza registros con el Explorador de registros.

Observa y depura el recopilador

El recopilador de OpenTelemetry creado por Google proporciona automáticamente métricas de autoobservabilidad para ayudarte a supervisar su rendimiento y garantizar un tiempo de actividad continuo de la canalización de transferencia de OTLP.

Para supervisar el recopilador, instala el panel de muestra para el recopilador. Este panel ofrece estadísticas resumidas sobre varias métricas del recopilador, incluidos el tiempo de actividad, el uso de memoria y las llamadas a la API de Google Cloud Observability.

Para instalar el panel, haz lo siguiente:

En la consola de Google Cloud , accede a la página Paneles :
Acceder a Paneles

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Monitoring.
Haz clic en Plantillas de panel.
Busca el panel OpenTelemetry Collector.
Opcional: Para obtener una vista previa del panel, selecciónalo.
Haz clic en Agregar panel a tu lista y, luego, completa el diálogo.

El diálogo te permite seleccionar el nombre del panel y agregarle etiquetas.

Para obtener más información sobre la instalación de paneles, consulta Instala una plantilla de panel.