Esta página se ha traducido con Cloud Translation API.

Desplegar el Collector de OpenTelemetry creado por Google en Google Kubernetes Engine

En este documento se describe cómo ejecutar el Collector de OpenTelemetry creado por Google en Google Kubernetes Engine para recoger registros, métricas y trazas de OTLP de aplicaciones instrumentadas y, a continuación, exportar esos datos a Google Cloud.

Antes de empezar

Para ejecutar el Collector de OpenTelemetry creado por Google, se necesitan los siguientes recursos:

Un Google Cloud proyecto con las APIs Cloud Monitoring, Cloud Trace y Cloud Logging habilitadas.
- Si no tienes ningún Google Cloud proyecto, haz lo siguiente:
  1. En la Google Cloud consola, ve a Nuevo proyecto:
    
    Crear un proyecto
  2. En el campo Nombre del proyecto, escribe el nombre que quieras darle al proyecto y, a continuación, 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 pedirá que elijas un perfil de pagos o que crees uno.
  Las APIs Monitoring, Trace y Logging están habilitadas de forma predeterminada en los proyectos nuevos.
- Si ya tienes un Google Cloud proyecto, asegúrate de que las APIs Monitoring, Trace y Logging estén habilitadas:
  
  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
Un clúster de Kubernetes. Si no tienes un clúster de Kubernetes, sigue las instrucciones de la guía de inicio rápido de GKE.
Las siguientes herramientas de línea de comandos:
- gcloud
- kubectl
Las herramientas gcloud y kubectl forman parte de Google Cloud CLI. Para obtener información sobre cómo instalarlos, consulta Gestionar componentes de la CLI de Google Cloud. Para ver los componentes de la CLI de gcloud que tienes instalados, ejecuta el siguiente comando:
```
gcloud components list
```

Configurar los permisos del recopilador

Si has inhabilitado Workload Identity de GKE, puedes saltarte esta sección.

Para asegurarte de que la cuenta de servicio de Kubernetes de OpenTelemetry Collector tiene los permisos necesarios para exportar telemetría, pide a tu administrador que conceda a la cuenta de servicio de Kubernetes de OpenTelemetry Collector los siguientes roles de gestión de identidades y accesos en tu proyecto:

Editor de las métricas de monitorización (roles/monitoring.metricWriter)
Escritor de registros de Logging (roles/logging.logWriter)
Agente de Cloud Trace (roles/cloudtrace.agent)

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Es posible que tu administrador también pueda conceder a la cuenta de servicio de Kubernetes del OpenTelemetry Collector los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Para configurar los permisos, usa los siguientes comandos de add-iam-policy-binding:

gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/logging.logWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/monitoring.metricWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/cloudtrace.agent \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector

Antes de ejecutar los comandos, sustituye las siguientes variables:

PROJECT_ID: identificador del proyecto.
PROJECT_NUMBER: el Google Cloud número de proyecto.

Implementar el recopilador

La canalización de Collector se puede implementar directamente desde los ejemplos verificados que se proporcionan en el repositorio de ingestión de OTLP de Kubernetes autogestionado. Puedes desplegar directamente desde GitHub con los siguientes comandos después de sustituir PROJECT_ID por el ID de tu proyecto Google Cloud :

export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export PROJECT_NUMBER=PROJECT_NUMBER
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest.git/k8s/base | envsubst | kubectl apply -f -

Antes de ejecutar los comandos, sustituye las siguientes variables:

PROJECT_ID: identificador del proyecto.
PROJECT_NUMBER: identificador numérico del proyecto.

Configurar el recopilador

Te proporcionamos una configuración de OpenTelemetry Collector para que la uses con el Collector creado por Google. Esta configuración se ha diseñado para enviar grandes volúmenes de métricas, registros y trazas de OTLP con metadatos de GKE y Kubernetes coherentes. Esta configuración también está diseñada para evitar problemas habituales de ingesta. Puedes añadir elementos a la configuración, pero te recomendamos que no los elimines.

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

Configuración del recopilador proporcionada

Puede encontrar la configuración del recopilador para entornos de Kubernetes en el repositorio otlp-k8s-ingest:

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

exporters:
  googlecloud:
    log:
      default_log_name: opentelemetry-collector
    user_agent: Google-Cloud-OTLP manifests:0.5.0 OpenTelemetry Collector Built By Google/0.131.0 (linux/amd64)
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.5.0 OpenTelemetry Collector Built By Google/0.131.0 (linux/amd64)
  # The otlphttp exporter is used to send traces to Google Cloud Trace using OTLP http/proto
  # The otlp exporter could also be used to send them using OTLP grpc
  otlphttp:
    encoding: proto
    endpoint: https://telemetry.googleapis.com
    # Use the googleclientauth extension to authenticate with Google credentials
    auth:
      authenticator: googleclientauth


extensions:
  health_check:
    endpoint: ${env:MY_POD_IP}:13133
  googleclientauth:


processors:
  filter/self-metrics:
    metrics:
      include:
        match_type: strict
        metric_names:
        - otelcol_process_uptime
        - otelcol_process_memory_rss
        - otelcol_grpc_io_client_completed_rpcs
        - otelcol_googlecloudmonitoring_point_count
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  k8sattributes:
    extract:
      metadata:
      - k8s.namespace.name
      - k8s.deployment.name
      - k8s.statefulset.name
      - k8s.daemonset.name
      - k8s.cronjob.name
      - k8s.job.name
      - k8s.replicaset.name
      - k8s.node.name
      - k8s.pod.name
      - k8s.pod.uid
      - k8s.pod.start_time
    passthrough: false
    pod_association:
    - sources:
      - from: resource_attribute
        name: k8s.pod.ip
    - sources:
      - from: resource_attribute
        name: k8s.pod.uid
    - sources:
      - from: connection

  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  metricstransform/self-metrics:
    transforms:
    - action: update
      include: otelcol_process_uptime
      operations:
      - action: add_label
        new_label: version
        new_value: Google-Cloud-OTLP manifests:0.5.0 OpenTelemetry Collector Built By Google/0.131.0 (linux/amd64)

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

  # The relative ordering of statements between ReplicaSet & Deployment and Job & CronJob are important.
  # The ordering of these controllers is decided based on the k8s controller documentation available at
  # https://kubernetes.io/docs/concepts/workloads/controllers.
  # The relative ordering of the other controllers in this list is inconsequential since they directly
  # create pods.
  transform/aco-gke:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["top_level_controller_type"], "ReplicaSet") where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.replicaset.name"]) where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_type"], "Deployment") where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.deployment.name"]) where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_type"], "DaemonSet") where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.daemonset.name"]) where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_type"], "StatefulSet") where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.statefulset.name"]) where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_type"], "Job") where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.job.name"]) where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_type"], "CronJob") where resource.attributes["k8s.cronjob.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.cronjob.name"]) where resource.attributes["k8s.cronjob.name"] != nil

  # When sending telemetry to the GCP OTLP endpoint, the gcp.project_id resource attribute is required to be set to your project ID.
  resource/gcp_project_id:
    attributes:
    - key: gcp.project_id
      # MAKE SURE YOU REPLACE THIS WITH YOUR PROJECT ID
      value: ${GOOGLE_CLOUD_PROJECT}
      action: insert
  # The metricstarttime processor is important to include if you are using the prometheus receiver to ensure the start time is set properly.
  # It is a no-op otherwise.
  metricstarttime:
    strategy: subtract_initial_point

receivers:
  # This collector is configured to accept OTLP metrics, logs, and traces, and is designed to receive OTLP from workloads running in the cluster.
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  otlp/self-metrics:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:14317

service:
  extensions:
  - health_check
  - googleclientauth
  pipelines:
    logs:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - resourcedetection
      - memory_limiter
      - batch
      receivers:
      - otlp
    metrics/otlp:
      exporters:
      - googlemanagedprometheus
      processors:
      - k8sattributes
      - memory_limiter
      - metricstarttime
      - resourcedetection
      - transform/collision
      - transform/aco-gke
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp/self-metrics
    traces:
      exporters:
      - otlphttp
      processors:
      - k8sattributes
      - memory_limiter
      - resource/gcp_project_id
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    logs:
      encoding: json
    metrics:
      readers:
      - periodic:
          exporter:
            otlp:
              protocol: grpc
              endpoint: ${env:MY_POD_IP}:14317

Exportadores

La configuración del recopilador incluye los siguientes exportadores:

googlecloud exportador, para registros y trazas. Este exportador está configurado con un nombre de registro predeterminado.
googlemanagedprometheus exporter para métricas. Este exportador no requiere ninguna configuración, pero hay opciones de configuración. Para obtener información sobre las opciones de configuración del exportador googlemanagedprometheus, consulta la sección Primeros pasos con el Collector de OpenTelemetry de la documentación de Google Cloud Managed Service para Prometheus.

Procesadores

La configuración del Collector incluye los siguientes procesadores:

batch: Configurado para agrupar las solicitudes de telemetría en lotes con el Google Cloud número máximo de entradas por solicitud o con el Google Cloud intervalo mínimo de 5 segundos (lo que ocurra primero).
memory_limiter: Limita el uso de memoria del recolector para evitar fallos por falta de memoria eliminando puntos de datos cuando se supera el límite.
resourcedetection: Detecta automáticamente las etiquetas de recursos, como Google Cloud y project_id.cluster_name
k8sattributes: mapea automáticamente los atributos de recursos de Kubernetes con etiquetas de telemetría.
transform: cambia el nombre de las etiquetas de métricas que coinciden con las etiquetas de los recursos monitorizados de Google Cloud.

Receptores

La configuración del recopilador solo incluye el otlpreceptor. Para obtener información sobre cómo instrumentar tus aplicaciones para enviar trazas y métricas de OTLP al endpoint de OTLP del Collector, consulta Elegir un método de instrumentación.

Componentes disponibles

El Collector de OpenTelemetry creado por Google contiene los componentes que la mayoría de los usuarios necesitarán para habilitar una experiencia completa en Observabilidad de Google Cloud. Para ver una lista completa de los componentes disponibles, consulta Components (Componentes) en el repositorio opentelemetry-operations-collector.

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

Generar telemetría

En esta sección se describe cómo desplegar una aplicación de ejemplo, dirigirla al endpoint OTLP del Collector y ver la telemetría enGoogle Cloud. La aplicación de ejemplo es un pequeño generador que exporta trazas, registros y métricas al Collector.

Si ya tienes una aplicación instrumentada con un SDK de OpenTelemetry, puedes dirigirla al endpoint del Collector.

Para desplegar la aplicación de ejemplo, ejecuta el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/otlp-k8s-ingest/main/sample/app.yaml

Para dirigir las aplicaciones que usan el SDK de OpenTelemetry al endpoint del Collector, define la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT como http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317.

Al cabo de unos minutos, la telemetría generada por la aplicación empieza a fluir a través del Collector a la Google Cloud consola de cada señal.

Ver telemetría

El OpenTelemetry Collector creado por Google envía métricas, registros y trazas 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.

Ver tus métricas

El Collector de OpenTelemetry creado por Google recoge métricas de Prometheus que puede ver con el explorador de métricas. Las métricas recogidas dependen de la instrumentación de la aplicación, aunque el Collector creado por Google también escribe algunas métricas propias.

Para ver las métricas recogidas por el OpenTelemetry Collector creado por Google, haz lo siguiente:

En la Google Cloud consola, ve a la página Explorador de métricas:
Ve al explorador de métricas.

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuya sección sea Monitorización.
En la barra de herramientas de la Google Cloud consola, selecciona tu Google Cloud proyecto. En las configuraciones de App Hub, selecciona el proyecto host de App Hub o el proyecto de gestión de la carpeta habilitada para aplicaciones.
En el elemento Métrica, despliega el menú Seleccionar una métrica, introduce Prometheus Target en la barra de filtros y, a continuación, usa los submenús para seleccionar un tipo de recurso y una métrica específicos:
1. En el menú Recursos activos, selecciona 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 recogidas por el Collector de OpenTelemetry creado por Google tienen el prefijo prometheus.googleapis.com.
3. Haz clic en Aplicar.
Para añadir filtros que eliminen series temporales de los resultados de la consulta, usa el elemento Filter.
Configure cómo se ven los datos.
Cuando las mediciones de una métrica son acumulativas, Explorador de métricas normaliza automáticamente los datos medidos por el periodo de alineación, lo que hace que el gráfico muestre una tasa. Para obtener más información, consulta Tipos, clases y conversiones.

Cuando se miden valores 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, selecciona Ninguna en el primer menú de la entrada Agregación.

Para obtener más información sobre cómo configurar un gráfico, consulta el artículo Seleccionar métricas al utilizar el explorador de métricas.

Ver tus trazas

Para ver los datos de la traza, haz lo siguiente:

En la Google Cloud consola, ve a la página Explorador de trazas:
Ir a Explorador de trazas

También puedes encontrar esta página mediante la barra de búsqueda.
En la barra de herramientas de la Google Cloud consola, selecciona tu Google Cloud proyecto. En el caso de las configuraciones de App Hub, seleccione el proyecto host de App Hub o el proyecto de gestión de la carpeta habilitada para aplicaciones.
En la sección de la tabla de la página, seleccione una fila.
En el gráfico de Gantt del panel Detalles del seguimiento, selecciona un intervalo.

Se abrirá un panel con información sobre la solicitud registrada. Estos detalles incluyen el método, el código de estado, el número de bytes y el agente de usuario de la persona que llama.
Para ver los registros asociados a este rastreo, selecciona la pestaña Registros y eventos.

En la pestaña se muestran los registros individuales. Para ver los detalles de la entrada de registro, despliégala. También puede hacer clic en Ver registros y consultar el registro con el Explorador de registros.

Para obtener más información sobre cómo usar el explorador de Cloud Trace, consulta Buscar y explorar trazas.

Consultar los registros

En Explorador de registros, puedes inspeccionar tus registros y ver las trazas asociadas, si las hay.

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

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuya sección sea Registro.
Busca una entrada de registro de tu aplicación instrumentada. Para ver los detalles, despliega la entrada de registro.
Haz clic en Trazas en una entrada de registro con un mensaje de traza y, a continuación, selecciona Ver detalles de la traza.

Se abre el panel Detalles de la traza, donde se muestra la traza seleccionada.

Para obtener más información sobre cómo usar el Explorador de registros, consulta el artículo Ver registros con el Explorador de registros.

Observar y depurar el Collector

El Collector de OpenTelemetry creado por Google proporciona automáticamente métricas de autoobservabilidad para ayudarte a monitorizar su rendimiento y asegurar el tiempo de actividad continuo de la canalización de ingestión de OTLP.

Para monitorizar el Collector, instala el panel de control de ejemplo del Collector. Este panel de control ofrece información general sobre varias métricas del recopilador, como el tiempo de actividad, el uso de memoria y las llamadas a la API de Google Cloud Observability.

Para instalar el panel de control, siga estos pasos:

En la Google Cloud consola, ve a la página Paneles de control:
Ve a Paneles.

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuya sección sea Monitorización.
Haz clic en Plantillas de panel de control.
Busca el panel de control OpenTelemetry Collector.
Opcional: Para previsualizar el panel de control, selecciónalo.
Haz clic en Añadir panel de control a tu lista y, a continuación, completa el cuadro de diálogo.

En el cuadro de diálogo, puedes seleccionar el nombre del panel de control y añadirle etiquetas.

Para obtener más información sobre cómo instalar paneles de control, consulta el artículo Instalar una plantilla de panel de control.