Instale e configure o monitoramento do Linkerd: OTel Collector Contrib com Helm

Esta página instala o OpenTelemetry Collector Contrib da comunidade usando o Helm, configura-o para coletar métricas do proxy e do plano de controle do Linkerd e verifica se os dados estão fluindo para a New Relic. Isso deve levar cerca de 15 minutos.

Compatibilidade e requisitos

Suportado

Cluster do Kubernetes (EKS, GKE, AKS ou autogerenciado) com kubectl configurado nele
Linkerd instalado e íntegro (linkerd check aprovado)
Configuração de cluster gerenciada pelo Helm

Você precisa

Uma chave de licença de ingestãoda New Relic
Helm instalado e configurado em seu cluster
Conectividade de rede para os endpoints OTLP da New Relic
Injeção habilitada nos namespaces que você deseja observar. Se não estiver, anote e reinicie-os:
bash
```
$kubectl annotate namespace <YOUR_NAMESPACE> linkerd.io/inject=enabled
$kubectl rollout restart deployment -n <YOUR_NAMESPACE>
```
(Opcional) kube-state-metrics em execução no seu cluster, se você quiser entidades de workload do Kubernetes correlacionadas com métricas do Linkerd. Se você já possui a integração do Kubernetes da New Relic instalada, isso já está resolvido.

Instalar

Adicione o repositório Helm do OpenTelemetry.

bash

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

Crie values.yaml e atualize as seguintes seções:
Defina o modo para implantação.

mode: deployment

Substitua o repositório de imagens.

image:
      repository: otel/opentelemetry-collector-contrib

Configure a função do cluster.

clusterRole:
      create: true
      rules:
        - apiGroups: [""]
          resources: [pods, nodes, nodes/proxy, endpoints, services, namespaces]
          verbs: [get, list, watch]
        - apiGroups: ["apps"]
          resources: [replicasets, deployments, daemonsets, statefulsets]
          verbs: [get, list, watch]

Defina o nome do seu cluster e a chave de licença de ingestão da New Relic.

extraEnvs:
      - name: K8S_CLUSTER_NAME
        value: "<YOUR_CLUSTER_NAME>"
      - name: NEWRELIC_LICENSE_KEY
        value: "<YOUR_NR_INGEST_LICENSE_KEY>"

Substitua toda a seção config pela configuração de monitoramento do Linkerd.

config:
      receivers:
        prometheus:
          config:
            scrape_configs:
              - job_name: 'linkerd-controller'
                kubernetes_sd_configs:
                  - role: pod
                    namespaces: { names: ['linkerd', 'linkerd-viz'] }
                relabel_configs:
                  - { source_labels: [__meta_kubernetes_pod_container_port_name], action: keep, regex: admin-http }
                  - { source_labels: [__meta_kubernetes_pod_container_name], target_label: component }
                  - { source_labels: [__meta_kubernetes_namespace], target_label: namespace }
                  - { source_labels: [__meta_kubernetes_pod_name], target_label: pod }
              - job_name: 'linkerd-proxy'
                kubernetes_sd_configs: [{ role: pod }]
                relabel_configs:
                  - { source_labels: [__meta_kubernetes_pod_container_name, __meta_kubernetes_pod_container_port_name, __meta_kubernetes_pod_label_linkerd_io_control_plane_ns], action: keep, regex: ^linkerd-proxy;linkerd-admin;linkerd$ }
                  - { source_labels: [__meta_kubernetes_namespace], target_label: namespace }
                  - { source_labels: [__meta_kubernetes_pod_name], target_label: pod }
                  - { source_labels: [__meta_kubernetes_pod_label_linkerd_io_control_plane_ns], target_label: linkerd_control_plane_ns }
                  - { source_labels: [__meta_kubernetes_pod_label_linkerd_io_control_plane_component], target_label: linkerd_control_plane_component }

      processors:
        resource/strip_service:
          attributes:
            - { key: service.name, action: delete }
            - { key: service.instance.id, action: delete }
        resource/cluster:
          attributes:
            - key: k8s.cluster.name
              value: "${env:K8S_CLUSTER_NAME}"
              action: insert
        transform/k8s:
          metric_statements:
            - context: datapoint
              statements:
                - set(attributes["k8s.namespace.name"], attributes["namespace"]) where attributes["namespace"] != nil
                - set(attributes["k8s.pod.name"], attributes["pod"]) where attributes["pod"] != nil
                - delete_key(attributes, "instance")
        transform/deployment:
          metric_statements:
            - context: datapoint
              statements:
                - set(attributes["k8s.deployment.name"], attributes["k8s.pod.name"]) where attributes["k8s.deployment.name"] == nil and attributes["k8s.pod.name"] != nil
                - replace_pattern(attributes["k8s.deployment.name"], "-[a-z0-9]+-[a-z0-9]+$", "") where attributes["k8s.deployment.name"] == attributes["k8s.pod.name"]
        transform/metadata_nullify:
          metric_statements:
            - context: metric
              statements:
                - set(description, "")
                - set(unit, "")

      exporters:
        otlp_http/newrelic:
          endpoint: "https://otlp.nr-data.net:4318"
          headers:
            api-key: "${env:NEWRELIC_LICENSE_KEY}"

      service:
        pipelines:
          metrics:
            receivers: [prometheus]
            processors: [memory_limiter, resource/strip_service, resource/cluster, transform/k8s, transform/deployment, transform/metadata_nullify, batch]
            exporters: [otlp_http/newrelic]

Dica

Este chart não filtra métricas de proxy de baixo valor por padrão. Se você deseja a mesma filtragem que o NRDOT aplica, adicione um processador filter/drop_unused. Consulte a página NRDOT com Helm para ver a lista de filtros.

Configurar

Atualize o arquivo values.yaml de acordo com a tabela a seguir:

Parâmetro	Descrição
`<YOUR_CLUSTER_NAME>`	Substitua pelo nome do seu cluster do Kubernetes para identificação no New Relic
`K8S_CLUSTER_NAME`	O nome do seu cluster em `extraEnvs`. Este nome de cluster é usado pelo OTel Collector para identificar seu cluster do Kubernetes no New Relic
`NEWRELIC_LICENSE_KEY`	Sua chave de licença de ingestão da New Relic definida em `extraEnvs`
`filter/drop_unused`	Não incluído por padrão na configuração deste chart. Consulte NRDOT com Helm se desejar a mesma filtragem de métrica de baixo valor

Instale o helm-chart

bash

$helm upgrade my-opentelemetry-collector open-telemetry/opentelemetry-collector \
>      -f values.yaml -n newrelic --create-namespace --install

Encontre seus dados

Vá para one.newrelic.com > All capabilities > All entities.
Pesquise o nome do seu cluster.
Selecione sua entidade do Linkerd para abrir o dashboard integrado.
O dashboard integrado abrange a taxa de requisições, latência p50/p95/p99, taxa de sucesso, conexões TCP, status do certificado mTLS, integridade do plano de controle e inventário de pods na malha. Para obter informações detalhadas, consulte a documentação Find Linkerd data.

Linkerd distributed tracing com OpenTelemetry

Ative a exportação de trace de proxy e instrumente os pods do seu aplicativo para correlacionar spans de malha com traces de APM.

Colete logs do proxy do Linkerd

Adicione um segundo release do Helm para coletar logs do sidecar

linkerd-proxy

Referência de métricas

Lista completa de métricas e atributos de recursos do Linkerd coletados pelo OTel Collector.

Esta tradução de máquina é fornecida para sua comodidade.