Vincular la aplicación OpenTelemetry-instrumentada a Kubernetes

Si es un desarrollador que ejecuta una aplicación en Kubernetes, puede usar New Relic para comprender cómo la infraestructura Kubernetes afecta su aplicación instrumentada OpenTelemetry .

Luego de completar los pasos a continuación, puede usar la New Relic UI para correlacionar la métrica a nivel de OpenTelemetry aplicación de con Kubernetes la infraestructura métrica . Esto le permite ver el panorama completo de sus telemetry data y colaborar entre equipos para lograr un tiempo medio de resolución (MTTR) más rápido para problemas en su entorno Kubernetes .

Cómo correlacionamos los datos

Este documento lo guía para habilitar su aplicación para inyectar metadatos específicos de infraestructura en los telemetry data. El resultado es que la New Relic UI está llena de información procesable. Estos son los pasos que deberá seguir para comenzar:

• En cada contenedor de aplicación, defina una variable de entorno para enviar telemetry data al recolector.
• Implementar el recolector OpenTelemetry como DaemonSet en modo agente con procesadores resourcedetection, resource, batch y k8sattributes para inyectar metadatos relevantes (nombres de clúster, despliegue y namespace ).

Antes de que empieces

Para completar con éxito los pasos siguientes, ya debe estar familiarizado con OpenTelemetry y Kubernetes y hacer lo siguiente:

• Creó estas variables de entorno:

  • OTEL_EXPORTER_OTLP_ENDPOINT: Consulte el extremoNew Relic OTLP para obtener más información.
  • NEW_RELIC_API_KEY: Consulte New Relic clave de API para obtener más información.

• Instaló la integración de New Relic Kubernetes en su clúster.

• instrumentó su aplicación con OpenTelemetry y envió datos exitosamente a New Relic a través del Protocolo OpenTelemetry (OTLP).

Si tiene preguntas generales sobre el uso del recolector con New Relic, consulte nuestra Introducción al recolector OpenTelemetry con New Relic.

Configure su aplicación para enviar telemetry data al recolector OpenTelemetry

Para configurar esto, debe agregar un fragmento personalizado a la sección env de su archivo YAML de Kubernetes. El siguiente ejemplo muestra el fragmento de un microservicio de interfaz de muestra (Frontend.yaml). El fragmento incluye 2 secciones que hacen lo siguiente:

• Section 1: Asegúrese de que los telemetry data se envíen al recolector. Esto establece la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT con la IP del host. Para ello, llama a la API descendente para extraer la IP del host.
• Section 2: Anexe metadatos específicos de la infraestructura. Para hacer esto, capturamos metadata.uid usando la API descendente y lo agregamos a la variable de entorno OTEL_RESOURCE_ATTRIBUTES . Esta variable de entorno la emplean los procesadores resourcedetection y k8sattributes del recolector OpenTelemetry para agregar contexto adicional específico de la infraestructura a telemetry data.

Para cada microservicio instrumentado con OpenTelemetry, agregue las líneas resaltadas a continuación a la sección env de su manifiesto:

# Frontend.yaml
apiVersion: apps/v1
kind: Deployment

# ...
spec:
  containers:
    - name: yourfrontendservice
      image: yourfrontendservice-beta
  env:
    # Section 1: Ensure that telemetry data is sent to the collector
    - name: HOST_IP
      valueFrom:
        fieldRef:
          fieldPath: status.hostIP
    
    # This is picked up by the opentelemetry sdks
    - name: OTEL_EXPORTER_OTLP_ENDPOINT
      value: "http://$(HOST_IP):55680"
    
    # Section 2: Attach infrastructure-specific metadata
    # Get pod ip so that k8sattributes can tag resources
    - name: POD_NAME
      valueFrom:
        fieldRef:
          fieldPath: metadata.name
    
    - name: POD_UID
      valueFrom:
        fieldRef:
          fieldPath: metadata.uid
    
    # This is picked up by the resource detector
    - name: OTEL_RESOURCE_ATTRIBUTES
      value: "service.instance.id=$(POD_NAME),k8s.pod.uid=$(POD_UID)"

Configurar y desplegar el recolector OpenTelemetry como agente

Le recomendamos implementar el recolector como agente en cada nodo dentro de un clúster de Kubernetes. El agente puede recibir telemetry data y enriquecer telemetry data con metadatos. Por ejemplo, el recolector puede agregar información de atributos personalizados o de infraestructura a través de procesadores, así como manejar procesamiento por lotes, reintentos, compresión y características avanzadas adicionales que se manejan de manera menos eficiente en el nivel de instrumentación del cliente.

Para obtener ayuda para configurar el recolector, consulte el archivo de configuración del recolector de muestra a continuación, junto con las secciones sobre cómo configurar estas opciones:

• Exportador OTLP
• procesador por lotes
• procesador de resourcedetection
• Procesador k8sattributes: general
• Procesador de atributos k8: RBAC
• Procesador k8sattributes: filtros

receivers:
  otlp:
    protocols:
      grpc:

processors:
  batch:
  resource:
    attributes:
      - key: host.id
        from_attribute: host.name
        action: upsert
  resourcedetection:
    detectors: [gke, gce]
  k8sattributes:
    auth_type: "serviceAccount"
    passthrough: false
    filter:
      node_from_env_var: KUBE_NODE_NAME
    extract:
      metadata:
        - k8s.pod.name
        - k8s.pod.uid
        - k8s.deployment.name
        - k8s.cluster.name
        - k8s.namespace.name
        - k8s.node.name
        - k8s.pod.start_time
    pod_association:
      - from: resource_attribute
        name: k8s.pod.uid

exporters:
  otlp:
    endpoint: $OTEL_EXPORTER_OTLP_ENDPOINT
    headers:
      api-key: $NEW_RELIC_API_KEY
  logging:
    logLevel: DEBUG

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [resourcedetection, k8sattributes, resource, cumulativetodelta, batch]
      exporters: [otlp]
    traces:
      receivers: [otlp]
      processors: [resourcedetection, k8sattributes, resource, batch]
      exporters: [otlp]
    logs:
      receivers: [otlp]
      processors: [resourcedetection, k8sattributes, resource, batch]
      exporters: [otlp]

Siga estos pasos para configurar y desplegar el recolector OpenTelemetry como agente:

exporters:
otlp:
    endpoint: $OTEL_EXPORTER_OTLP_ENDPOINT
    headers: api-key: $NEW_RELIC_API_KEY

processors:
batch:

processors:
k8sattributes:
    auth_type: "serviceAccount"
    passthrough: false
    filter:
    node_from_env_var: KUBE_NODE_NAME
    extract:
    metadata:
        - k8s.pod.name
        - k8s.pod.uid
        - k8s.deployment.name
        - k8s.cluster.name
        - k8s.namespace.name
        - k8s.node.name
        - k8s.pod.start_time
    pod_association:
    - from: resource_attribute
        name: k8s.pod.uid

spec:
containers:
    - env:
        - name: KUBE_NODE_NAME
        valueFrom:
            fieldRef:
            apiVersion: v1
            fieldPath: spec.nodeName

k8sattributes:
filter:
    node_from_env_var: KUBE_NODE_NAME

Valida que tu configuración esté funcionando

Debería poder verificar que su configuración esté funcionando una vez que vinculó exitosamente sus datos OpenTelemetry con sus datos Kubernetes .

1. Vaya a one.newrelic.com > All capabilities > APM & Services y seleccione su aplicación dentro de Services - OpenTelemetry.
2. En la sección Monitor , haga clic en Service map.
3. Vea la conexión entre su servicio OpenTelemetry y su clúster. A la derecha, verá el atributo Kubernetes como k8s.cluster.name, k8s.namespace.name y k8s.deployment.name como etiqueta.

Elige tu próximo paso