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

Cette page installe l'OpenTelemetry Collector Contrib communautaire à l'aide de manifestes Kubernetes, le configure pour collecter les métriques du proxy Linkerd et du control plane, et vérifie que les données sont transmises à New Relic. Prévoyez environ 15 minutes pour cette opération.

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 manifeste (sans Helm)

Vous avez besoin de

Une clé de licence d’ingestionNew Relic
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 de New Relic, cela est déjà géré

Installation

Copiez le manifeste ci-dessous dans un fichier nommé otel-collector.yaml.

apiVersion: v1
    kind: ServiceAccount
    metadata: { name: my-opentelemetry-collector, namespace: newrelic }
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata: { name: my-opentelemetry-collector }
    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]
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata: { name: my-opentelemetry-collector }
    roleRef: { apiGroup: rbac.authorization.k8s.io, kind: ClusterRole, name: my-opentelemetry-collector }
    subjects:
      - { kind: ServiceAccount, name: my-opentelemetry-collector, namespace: newrelic }
    ---
    apiVersion: v1
    kind: ConfigMap
    metadata: { name: my-opentelemetry-collector-config, namespace: newrelic }
    data:
      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:
          memory_limiter:
            check_interval: 1s
            limit_percentage: <MEMORY_LIMIT_PERCENTAGE>
            spike_limit_percentage: <MEMORY_SPIKE_LIMIT_PERCENTAGE>
          resource/strip_service:
            attributes:
              - { key: service.name, action: delete }
              - { key: service.instance.id, action: delete }
          resource/cluster:
            attributes:
              - key: k8s.cluster.name
                value: "<YOUR_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, "")
          batch: {}

        exporters:
          otlp_http/newrelic:
            endpoint: "https://otlp.nr-data.net:4318"
            headers:
              api-key: "<YOUR_NR_INGEST_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]
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata: { name: my-opentelemetry-collector, namespace: newrelic }
    spec:
      replicas: 1
      selector: { matchLabels: { app: my-opentelemetry-collector } }
      template:
        metadata:
          labels: { app: my-opentelemetry-collector }
        spec:
          serviceAccountName: my-opentelemetry-collector
          securityContext:
            runAsNonRoot: true
            runAsUser: 10001
          containers:
            - name: opentelemetry-collector
              image: otel/opentelemetry-collector-contrib:0.160.0
              args: ["--config=/conf/config.yaml"]
              securityContext:
                allowPrivilegeEscalation: false
                readOnlyRootFilesystem: true
                capabilities: { drop: [ALL] }
              resources:
                limits: { cpu: <CPU_LIMIT>, memory: <MEMORY_LIMIT> }
              volumeMounts:
                - { name: config, mountPath: /conf }
          volumes:
            - name: config
              configMap:
                name: my-opentelemetry-collector-config
                items:
                  - { key: config, path: config.yaml }
    ---
    apiVersion: v1
    kind: Service
    metadata: { name: my-opentelemetry-collector, namespace: newrelic }
    spec:
      selector: { app: my-opentelemetry-collector }
      ports:
        - { name: otlp, port: 4317, targetPort: 4317, protocol: TCP, appProtocol: grpc }
        - { name: otlp-http, port: 4318, targetPort: 4318, protocol: TCP }

Conseil

Ce manifeste 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 obtenir la liste des filtres.

Configure

Remplissez les espaces réservés dans otel-collector.yaml avant d'appliquer :

Champ	Emplacement	Ce qu'il faut définir
`resource/cluster`	processeur	Nom de votre cluster Kubernetes
`otlp_http/newrelic`	exportateur	Votre clé de licence d'ingestion New Relic
`memory_limiter`	processeur	Limite de mémoire et pourcentages de pics, par exemple `80` et `25`
`resources.limits`	Conteneur de déploiement	Limites de CPU et de mémoire pour le pod du collecteur

Appliquez le manifeste.

bash

$kubectl apply -f otel-collector.yaml
$    kubectl rollout status deployment/my-opentelemetry-collector -n newrelic

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 de collecteur 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é.