Implementa el recopilador de OpenTelemetry en Google Kubernetes Engine

En este documento, se muestra cómo ejecutar el Recopilador de OpenTelemetry en un clúster de GKE para recopilar registros, métricas y seguimientos de OTLP de aplicaciones instrumentadas y exportar esos datos a Google Cloud.

Antes de comenzar

La ejecución del recopilador de OpenTelemetry en GKE requiere los siguientes recursos:

  • Un proyecto de Google Cloud con la API de Cloud Monitoring, la API de Cloud Trace y la API de Cloud Logging habilitadas.

    • Si no tienes un proyecto de Google Cloud, 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 proyecto de Google Cloud, asegúrate de que la API de Monitoring, la API de Trace y la API de Logging estén habilitadas:

      1. Ve a API y servicios:

        Ir a API y servicios (APIs & Services)

      2. Elige tu proyecto.

      3. Haz clic en Habilitar APIs y servicios.

      4. Busca cada API por nombre.

      5. En los resultados de la búsqueda, haz clic en la API con nombre. La API de Monitoring aparece como “API de Stackdriver Monitoring”.

      6. Si no se muestra "API habilitada", haz clic en el botón Habilitar.

  • Un clúster de Kubernetes. Si no tienes un clúster de Kubernetes, sigue las instrucciones en la Guía de inicio rápido para GKE.

  • Las siguientes herramientas de línea de comandos:

    • gcloud
    • kubectl

    Las herramientas gcloud y kubectl forman parte de la CLI de Google Cloud. Para obtener información sobre cómo instalarlos, consulta Administra los componentes de la CLI de Google Cloud. Para ver los componentes de la CLI de gcloud que instalaste, ejecuta el siguiente comando:

    gcloud components list

Implementa el recopilador

La canalización del colector se puede implementar directamente desde GitHub con los siguientes comandos después de reemplazar PROJECT_ID por el ID de tu proyecto de Google Cloud:

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

Observa y depura el recopilador

El recopilador de OpenTelemetry proporciona métricas de autoobservabilidad listas para usar 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:

  1. En la consola de Google Cloud, ve a la página  Paneles.

    Dirígete a Paneles de control

    Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Monitoring.

  2. Selecciona la pestaña Biblioteca de muestra.
  3. Selecciona la categoría Recopilador de OpenTelemetry.
  4. Selecciona el panel “Recopilador de OpenTelemtry”.
  5. Haz clic en Importar.

Para obtener más información sobre el proceso de instalación, consulta Instala paneles de muestra.

Configura el recopilador

La canalización de transferencia de OTLP autoadministrada incluye una configuración predeterminada del recopilador de OpenTelemetry que está diseñada para entregar grandes volúmenes de métricas, registros y seguimientos de OTLP con metadatos coherentes de GKE y Kubernetes adjuntos. También está diseñado para evitar problemas comunes de transferencia.

Sin embargo, es posible que tengas necesidades únicas que requieran la personalización de la configuración predeterminada. En esta sección, se describen los valores predeterminados enviados con la canalización y cómo puedes personalizarlos para que se adapten a tus necesidades.

La configuración predeterminada del recopilador se encuentra en GitHub como config/collector.yaml:

# 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.1.0 otel/opentelemetry-collector-contrib:0.105.0
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.105.0

extensions:
  health_check:
    endpoint: ${env:MY_POD_IP}:13133
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.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.1.0 otel/opentelemetry-collector-contrib:0.105.0

  # We need to add the pod IP as a resource label so the k8s attributes processor can find it.
  resource/self-metrics:
    attributes:
    - action: insert
      key: k8s.pod.ip
      value: ${env:MY_POD_IP}

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

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  prometheus/self-metrics:
    config:
      scrape_configs:
      - job_name: otel-self-metrics
        scrape_interval: 1m
        static_configs:
        - targets:
          - ${env:MY_POD_IP}:8888

service:
  extensions:
  - health_check
  pipelines:
    logs:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - resourcedetection
      - memory_limiter
      - batch
      receivers:
      - otlp
    metrics/otlp:
      exporters:
      - googlemanagedprometheus
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - transform/collision
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - resource/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - prometheus/self-metrics
    traces:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    metrics:
      address: ${env:MY_POD_IP}:8888

Exportadores

Los exportadores predeterminados incluyen el exportador googlecloud (para registros y seguimientos) y el exportador googlemanagedprometheus (para métricas).

El exportador googlecloud se configura con un nombre de registro predeterminado. El exportador googlemanagedprometheus no requiere ninguna configuración predeterminada. Consulta Comienza a usar el recopilador de OpenTelemetry en la documentación de Google Cloud Managed Service para Prometheus a fin de obtener más información sobre cómo configurar este exportador.

Procesadores

La configuración predeterminada 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 Google Cloud de 5 segundos (lo que ocurra primero).
  • k8sattributes: Asigna de forma automática los atributos de recursos de Kubernetes a etiquetas de telemetría.
  • memory_limiter: Limita el uso de memoria del colector a un nivel razonable para evitar fallas por memoria insuficiente mediante la eliminación de datos más allá de este nivel.
  • resourcedetection: Detecta de forma automática las etiquetas de recursos de Google Cloud, como el nombre del clúster y el ID del proyecto.
  • transform: Cambia el nombre de las etiquetas de métricas que entrarían en conflicto con los campos de recursos supervisados de Google Cloud.

Receptores

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

Próximos pasos: Recopila y visualiza la telemetría

En esta sección, se describe cómo implementar una aplicación de ejemplo y cómo apuntar esa aplicación al extremo de OTLP del recopilador y cómo ver la telemetría en Google Cloud. La aplicación de muestra es un generador pequeño que exporta seguimientos, registros y métricas al recopilador.

Si ya tienes una aplicación instrumentada con un SDK de OpenTelemetry, puedes apuntar tu aplicación al extremo del recopilador.

Para implementar la aplicación de muestra, ejecuta el siguiente comando:

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

Para apuntar a las aplicaciones existentes que usan el SDK de OpenTelemetry en el extremo del recopilador, establece la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT en http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317.

Después de unos minutos, la telemetría que genera la aplicación comienza a fluir a través del recopilador hacia la consola de Google Cloud para cada indicador.