Installez et configurez le monitoring de Linkerd : Collecteur Otel Contrib avec Helm

Cette page installe la version communautaire d'OpenTelemetry Collector Contrib à l'aide de Helm, la configure pour récupérer les métriques du proxy Linkerd et du control plane, et vérifie que les données sont transmises à New Relic. Attendez-vous à ce que cela prenne environ 15 minutes.

Compatibilité et exigences

Soutenu

Cluster Kubernetes (EKS, GKE, AKS, ou autogéré) avec kubectl configuré sur celui-ci
Linkerd installé et sain (linkerd check réussites)
Configuration de cluster gérée par Helm

Vous avez besoin de

Une clé de licence d’ingestionNew Relic
Helm installé et configuré sur votre cluster
Connectivité réseau vers les points de terminaison OTLP de New Relic
Injection activée sur les espaces de nommage que vous souhaitez observer. Si ce n’est pas le cas, annotez-les et redémarrez-les :
bash
```
$kubectl annotate namespace <YOUR_NAMESPACE> linkerd.io/inject=enabled
$kubectl rollout restart deployment -n <YOUR_NAMESPACE>
```
(Facultatif) kube-state-metrics en cours d’exécution dans votre cluster, si vous souhaitez que les entités de workload Kubernetes soient corrélées avec les métriques Linkerd. Si vous avez déjà installé l’ intégration Kubernetes New Relic, cela est déjà pris en charge.

Installation

Ajoutez le référentiel (repository) Helm OpenTelemetry.

bash

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

Créez values.yaml et mettez à jour les sections suivantes :
Définir le mode sur déploiement.

mode: deployment

Remplacez le référentiel d’images.

image:
      repository: otel/opentelemetry-collector-contrib

Configurez le rôle de 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]

Définissez le nom de votre cluster et votre clé de licence d'ingestion New Relic.

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

Remplacez toute la section config par la configuration de monitoring 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]

Conseil

Ce chart ne filtre pas les métriques de proxy de faible valeur par défaut. Si vous souhaitez le même filtrage que celui appliqué par NRDOT, ajoutez un Processeur filter/drop_unused. Consultez la page NRDOT avec Helm pour la liste des filtres.

Configure

Mettez à jour le fichier values.yaml selon le tableau suivant :

paramètres	Description
`<YOUR_CLUSTER_NAME>`	Remplacez par le nom de votre cluster Kubernetes pour l'identification dans New Relic
`K8S_CLUSTER_NAME`	Le nom de votre cluster dans `extraEnvs`. Ce nom de cluster est utilisé par le Collecteur Otel pour identifier votre cluster Kubernetes dans New Relic
`NEWRELIC_LICENSE_KEY`	Votre clé de licence d'ingestion New Relic définie dans `extraEnvs`
`filter/drop_unused`	Non inclus par défaut dans la configuration de ce chart. Consultez NRDOT avec Helm si vous souhaitez le même filtrage des métriques de faible valeur

Installer le helm-chart

bash

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

Trouvez vos données

Allez à one.newrelic.com > All capabilities > All entities.
Recherchez le nom de votre cluster.
Sélectionnez votre entité Linkerd pour ouvrir le dashboard intégré.
Le dashboard intégré couvre le taux de requêtes, la latence p50/p95/p99, le taux de réussite, les connexions TCP, le statut des certificats mTLS, la santé du control plane, et l’inventaire des pods maillés. Pour des informations détaillées, consultez la documentation Trouver les données Linkerd.

Tracing distribué Linkerd avec OpenTelemetry

Activez l’exportation de trace du proxy et instrumentez vos pods d’application pour corréler les spans du maillage avec les traces APM.

Collecter les logs du proxy Linkerd

Ajoutez une deuxième sortie Helm pour collecter les logs sidecar

linkerd-proxy

Référence des métriques

Liste complète des métriques et des attributs de ressource Linkerd collectés par le Collecteur Otel.

Cette traduction automatique est fournie pour votre commodité.