Este documento ha sido traducido utilizando tecnología de traducción automática. Si bien nos esforzamos por proporcionar traducciones precisas, no ofrecemos garantías sobre la integridad, precisión o confiabilidad del contenido traducido. En caso de discrepancia, la versión original en inglés prevalecerá y constituirá el texto autorizado.

Introducción a Open Telemetry en Kubernetes

Esta guía proporciona instrucciones sobre cómo monitorizar una aplicación.

  • La aplicación/carga de trabajo monitorizada que se ejecuta en el clúster A.

  • El recolector de Open Telemetry que se ejecuta cerca de las aplicaciones observadas en el clúster A y envía los datos a SUSE® Observability.

  • SUSE® Observability ejecutándose en el clúster B, o SUSE Cloud Observability.

Instrumentación de contenedores con Open Telemetry a través del recolector que se ejecuta como despliegue de Kubernetes

El recolector de Open Telemetry

Para una configuración de producción, se recomienda encarecidamente instalar el recolector, ya que permite a tu servicio descargar datos rápidamente y el recolector puede encargarse del manejo adicional, como reintentos, agrupación, cifrado o incluso filtrado de datos sensibles.

Instala el recolector OTel (Open Telemetry) en el clúster A y configúralo para:

  • Recibir datos de, potencialmente, muchas aplicaciones instrumentadas.

  • Enriquecer los datos recogidos con atributos de Kubernetes.

  • Generar métricas para trazas.

  • Reenviar los datos a SUSE® Observability, incluyendo autenticación usando la clave API.

SUSE® Observability también reintenta enviar datos cuando hay problemas de conexión.

Crear un Token de Servicio

Existen dos maneras de crear un token de servicio:

  • SUSE® Observability UI - abre el menú principal haciendo clic en la parte superior izquierda de la pantalla y ve a StackPacks > Open Telemetry. Si no lo has hecho antes, haz clic en el botón INSTALL. Haz clic en el botón CREATE NEW SERVICE TOKEN y copia el valor en tu portapapeles.

  • SUSE® Observability CLI - consulta Gestionar tokens de servicio

El valor del token de servicio debe utilizarse donde las instrucciones a continuación mencionen <SERVICE_TOKEN>.

Crea el espacio de nombres y un secreto para el token de servicio

Instala en el espacio de nombres open-telemetry y utiliza el token de servicio:

kubectl create namespace open-telemetry
kubectl create secret generic open-telemetry-collector \
    --namespace open-telemetry \
    --from-literal=API_KEY='<SERVICE_TOKEN>'

Configura e instala el recolector

Instalamos el recolector con un chart de Helm proporcionado por el proyecto Open Telemetry. Asegúrate de tener configurado el repositorio de charts de Helm de Open Telemetry:

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts

Crea un archivo values otel-collector.yaml para el chart de Helm. Aquí tienes un buen punto de partida para su uso con SUSE® Observability, reemplaza <otlp-suse-observability-endpoint:port> por tu endpoint OTLP (consulta API OTLP para tu endpoint) e introduce el nombre de tu clúster de Kubernetes en lugar de <your-cluster-name>:

otel-collector.yaml
# Set the API key from the secret as an env var:
extraEnvsFrom:
  - secretRef:
      name: open-telemetry-collector
mode: deployment
image:
  # Use the collector container image that has all components important for k8s. In case of missing components the ghcr.io/open-telemetry/opentelemetry-collector-releases/opentelemetry-collector-contrib image can be used which
  # has all components in the contrib repository: https://github.com/open-telemetry/opentelemetry-collector-contrib
  repository: "ghcr.io/open-telemetry/opentelemetry-collector-releases/opentelemetry-collector-k8s"
ports:
  metrics:
    enabled: true
presets:
  kubernetesAttributes:
    enabled: true
    extractAllPodLabels: true
# This is the config file for the collector:
config:
  receivers:
    otlp:
      protocols:
        grpc:
          endpoint: 0.0.0.0:4317
        http:
          endpoint: 0.0.0.0:4318
    # Scrape the collectors own metrics
    prometheus:
      config:
        scrape_configs:
        - job_name: opentelemetry-collector
          scrape_interval: 10s
          static_configs:
          - targets:
            - ${env:MY_POD_IP}:8888
  extensions:
    # Use the API key from the env for authentication
    bearertokenauth:
      scheme: SUSEObservability
      token: "${env:API_KEY}"
  exporters:
    nop: {}
    otlp/suse-observability:
      auth:
        authenticator: bearertokenauth
      # Put in your own otlp endpoint, for example otlp-suse-observability.my.company.com:443
      endpoint: <otlp-suse-observability-endpoint:port>
      compression: snappy
  processors:
    memory_limiter:
      check_interval: 5s
      limit_percentage: 80
      spike_limit_percentage: 25
    batch: {}
    resource:
      attributes:
      - key: k8s.cluster.name
        action: upsert
        # Insert your own cluster name
        value: <your-cluster-name>
      - key: service.instance.id
        from_attribute: k8s.pod.uid
        action: insert
        # Use the k8s namespace also as the open telemetry namespace
      - key: service.namespace
        from_attribute: k8s.namespace.name
        action: insert
  connectors:
    # Generate metrics for spans
    spanmetrics:
      metrics_expiration: 5m
      namespace: otel_span
  service:
    extensions: [ health_check,  bearertokenauth ]
    pipelines:
      traces:
        receivers: [otlp]
        processors: [memory_limiter, resource, batch]
        exporters: [debug, spanmetrics, otlp/suse-observability]
      metrics:
        receivers: [otlp, spanmetrics, prometheus]
        processors: [memory_limiter, resource, batch]
        exporters: [debug, otlp/suse-observability]
      logs:
        receivers: [otlp]
        processors: []
        exporters: [nop]
    telemetry:
      metrics:
        address: ${env:MY_POD_IP}:8888

Usa el mismo nombre de clúster que se utilizó para instalar el Agente SUSE® Observability si también usas el agente SUSE® Observability con el stackpack de Kubernetes. Usar un nombre de clúster diferente resultará en una perspectiva de trazas vacía para los componentes de Kubernetes y, en general, dificultará mucho la correlación de información para SUSE® Observability y tus usuarios.

Instala el recolector utilizando el archivo de configuración:

helm upgrade --install opentelemetry-collector open-telemetry/opentelemetry-collector \
  --values otel-collector.yaml \
  --namespace open-telemetry

El recolector ofrece muchas más opciones de configuración de receptores, procesadores y exportadores; para más detalles, consulta nuestra página del recolector. Para uso en producción, a menudo se generan grandes cantidades de spans. Por lo tanto, configura muestreo.

Recoge datos de telemetría de tu aplicación

La forma común de recoger datos de telemetría es instrumentar tu aplicación utilizando los SDK de Open Telemetry.

Para otros idiomas, sigue la documentación en opentelemetry.io y asegúrate de configurar el exportador del SDK para enviar datos al recolector que acabas de instalar siguiendo estas instrucciones.

Ver los resultados

Ve a SUSE® Observability y asegúrate de que el Stackpack de Open Telemetry esté instalado (a través del menú principal -> Stackpacks).

Si tus pods están recibiendo tráfico, deberías poder encontrarlos bajo su nombre de servicio en las vistas de Open Telemetry -> servicios e instancias de servicio. Las trazas aparecen en el explorador de trazas y en la perspectiva de trazas para los componentes de servicio e instancia de servicio. Las métricas de span y las métricas específicas del lenguaje (si están disponibles) estarán disponibles en la perspectiva de métricas para los componentes.

Si también tienes instalado el stackpack de Kubernetes, los pods instrumentados también tendrán las trazas disponibles en la perspectiva de trazas.

Rancher RBAC

Para que Rancher RBAC funcione, los datos de telemetría deben tener presentes los siguientes atributos de recurso:

  • k8s.cluster.name - el nombre del clúster tal como lo utiliza el stackpack de Kubernetes

  • k8s.namespace.name - un espacio de nombres gestionado por un Proyecto de Rancher

Esto se puede lograr mediante una configuración como la anterior. Allí, el kubernetesAttributes preajuste del chart de Helm opentelemetry-collector inyecta un k8sattributes procesador en cada canalización.

Pasos siguientes

Puedes añadir nuevos gráficos a los componentes, por ejemplo, el servicio o la instancia de servicio, para tu aplicación, siguiendo nuestra guía. También es posible crear nuevos monitores utilizando las métricas y configurando notificaciones para recibir notificaciones cuando tu aplicación no esté disponible o presente problemas de rendimiento.