Vincule o aplicativo OpenTelemetry-instrumentado ao Kubernetes

Se você é um desenvolvedor executando aplicativo no Kubernetes, pode usar New Relic para entender como a infraestrutura Kubernetes afeta seu aplicativo instrumentado OpenTelemetry .

Depois de concluir as etapas abaixo, você pode usar a interface New Relic para correlacionar a métrica em nível de aplicativo do OpenTelemetry com a métrica de infraestrutura Kubernetes . Isso permite que você veja todo o cenário de seus dados de telemetria e colabore entre equipes para obter um tempo médio de resolução (MTTR) mais rápido para problemas em seu ambiente Kubernetes.

Como correlacionamos os dados

Este documento orienta você na habilitação do seu aplicativo para injetar metadados específicos da infraestrutura nos dados de telemetria. O resultado é que a interface do New Relic é preenchida com informações acionáveis. Aqui estão as etapas que você seguirá para começar:

• Em cada contêiner de aplicativo, defina uma variável de ambiente para enviar dados de telemetria ao coletor.
• implantar o coletor OpenTelemetry como um DaemonSet no modo agente com processadores resourcedetection, resource, batch e k8sattributes para injetar metadados relevantes (nomes cluster, implantação e namespace ).

Antes de você começar

Para concluir com êxito as etapas abaixo, você já deve estar familiarizado com OpenTelemetry e Kubernetes e ter feito o seguinte:

• Criou estas variáveis de ambiente:

  • OTEL_EXPORTER_OTLP_ENDPOINT: consulte o endpoint OTLP da New Relic para obter mais informações.
  • NEW_RELIC_API_KEY:Consulte a New Relic chave de API para obter mais informações.

• Instalou a integração do New Relic Kubernetes em seu cluster.

• instrumentou seu aplicativo com OpenTelemetry e enviou dados com sucesso para New Relic via OpenTelemetry Protocol (OTLP).

Se você tiver dúvidas gerais sobre o uso do coletor com New Relic, consulte nossa Introdução ao coletor OpenTelemetry com New Relic.

Configure seu aplicativo para enviar dados de telemetria para o coletor OpenTelemetry

Para configurar isso, você precisa adicionar um trecho personalizado à seção env do seu arquivo YAML Kubernetes . O exemplo abaixo mostra o trecho para um exemplo de microsserviços de frontend (Frontend.yaml). O trecho inclui 2 seções que fazem o seguinte:

• Section 1: Certifique-se de que os dados de telemetria sejam enviados ao coletor. Isso define a variável de ambiente OTEL_EXPORTER_OTLP_ENDPOINT com o IP do host. Isso é feito chamando a API descendente para extrair o IP do host.
• Section 2: Anexe metadados específicos da infraestrutura. Para fazer isso, capturamos metadata.uid usando a API descendente e o adicionamos à variável de ambiente OTEL_RESOURCE_ATTRIBUTES . Esta variável de ambiente é usada pelos processadores resourcedetection e k8sattributes do coletor OpenTelemetry para adicionar contexto específico de infraestrutura adicional aos dados de telemetria.

Para cada microsserviços instrumentado com OpenTelemetry, adicione as linhas destacadas abaixo na seção env do seu manifesto:

# 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 e implantar o coletor OpenTelemetry como agente

Recomendamos que você implante o coletor como agente em cada nó de um cluster do Kubernetes. O agente pode receber dados de telemetria e enriquecer os dados de telemetria com metadados. Por exemplo, o coletor pode adicionar atributo personalizado ou infraestrutura de informações por meio de processadores, bem como lidar com lotes, novas tentativas, compactação e recursos avançados adicionais que são tratados de forma menos eficiente no nível de instrumentação do cliente.

Para obter ajuda na configuração do coletor, consulte o arquivo de configuração do coletor de amostra abaixo, juntamente com as seções sobre como configurar essas opções:

• Exportador OTLP
• processador em lote
• processador de resourcedetection
• Processador de atributos k8s: geral
• Processador de atributos k8s: RBAC
• Processador de atributos k8s: 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 estes passos para configurar e implantar o coletor 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

Valide se sua configuração está funcionando

Você poderá verificar se sua configuração está funcionando depois de vincular com êxito os dados do OpenTelemetry aos dados do Kubernetes .

1. Vá para one.newrelic.com > All capabilities > APM & Services e selecione seu aplicativo dentro de Services - OpenTelemetry.
2. Na seção Monitor , clique em Service map.
3. Veja a conexão entre seu serviço OpenTelemetry e seu cluster. À direita, você verá o atributo Kubernetes como k8s.cluster.name, k8s.namespace.name e k8s.deployment.name como tag.

Escolha seu próximo passo