Monitorer Redis sur Kubernetes (OpenTelemetry)

Créer un espace de nommage et des identifiants

Créez un espace de nommage newrelic et stockez votre clé de licence et votre point de terminaison OTLP dans un Secret Kubernetes, que le collecteur lit à l'exécution afin que vos identifiants restent en dehors de la configuration :

$
kubectl create namespace newrelic
$

$
# Set OTEL_EXPORTER_OTLP_ENDPOINT for your region.
$
# See https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp
$
kubectl create secret generic newrelic-credentials \
>
  --from-literal=NEW_RELIC_LICENSE_KEY=YOUR_LICENSE_KEY \
>
  --from-literal=OTEL_EXPORTER_OTLP_ENDPOINT=YOUR_OTLP_ENDPOINT \
>
  -n newrelic

Configurer RBAC

Le k8s_observer a besoin d’autorisations pour surveiller les pods. Créer rbac.yaml:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: otel-collector-redis
  namespace: newrelic
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: otel-collector-redis
rules:
  - apiGroups: [""]
    resources: ["pods", "namespaces", "nodes"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["apps"]
    resources: ["replicasets"]
    verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: otel-collector-redis
subjects:
  - kind: ServiceAccount
    name: otel-collector-redis
    namespace: newrelic
roleRef:
  kind: ClusterRole
  name: otel-collector-redis
  apiGroup: rbac.authorization.k8s.io

$
kubectl apply -f rbac.yaml

Configurer le collecteur

Ce ConfigMap indique au collecteur comment découvrir les pods Redis, collecter leurs métriques et les envoyer à New Relic. Il gère trois tâches principales :

• Découvrir les pods Redis automatiquement avec k8s_observer et le receiver_creator

• Façonner les données — réduire la cardinalité, convertir les compteurs en deltas et définir l'identité de l'entité

• Exportez les métriques traitées vers New Relic via OTLP

  Créer otel-collector-config.yaml:

  apiVersion: v1
  kind: ConfigMap
  metadata:
    name: otel-collector-redis-config
    namespace: newrelic
  data:
    config.yaml: |
      extensions:
        health_check:
          endpoint: "0.0.0.0:13133"
        k8s_observer:
          auth_type: serviceAccount
          observe_pods: true
          observe_nodes: false
  
      receivers:
        receiver_creator/redis:
          watch_observers: [k8s_observer]
          receivers:
            redis:
              rule: type == "pod" && labels["app"] == "redis"  # Update with your Redis pod labels
              config:
                endpoint: "`endpoint`:6379"
                collection_interval: 10s
                metrics:
                  redis.maxmemory:
                    enabled: true
                  redis.role:
                    enabled: false
                  redis.cmd.calls:
                    enabled: true
                  redis.cmd.usec:
                    enabled: true
                  redis.clients.max_input_buffer:
                    enabled: false
                  redis.clients.max_output_buffer:
                    enabled: false
                  redis.replication.backlog_first_byte_offset:
                    enabled: false
                resource_attributes:
                  server.address:
                    enabled: false
                  server.port:
                    enabled: false
  
      processors:
        memory_limiter:
          check_interval: 5s
          limit_mib: 256
          spike_limit_mib: 64
  
        resource/k8s_cluster:
          attributes:
            - key: k8s.cluster.name
              value: "my-cluster"  # Update with your cluster name
              action: upsert
            - key: redis.instance.id
              value: "my-cluster.default:6379"  # Update with cluster.namespace:port
              action: upsert
  
        attributes/entity_tags:
          actions:
            - key: instrumentation.provider
              value: opentelemetry
              action: upsert
  
        cumulativetodelta:
          include:
            match_type: regexp
            metrics:
              - redis\.commands\.processed
              - redis\.connections\.received
              - redis\.connections\.rejected
              - redis\.keys\.evicted
              - redis\.keys\.expired
              - redis\.keyspace\.hits
              - redis\.keyspace\.misses
              - redis\.net\.input
              - redis\.net\.output
              - redis\.cpu\.time
              - redis\.cmd\.calls
              - redis\.cmd\.usec
              - redis\.uptime
  
        filter/cardinality:
          metrics:
            datapoint:
              - 'metric.name == "redis.cpu.time" and attributes["state"] != "sys" and attributes["state"] != "user"'
              - 'metric.name == "redis.cmd.calls" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'
              - 'metric.name == "redis.cmd.usec" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'
  
        transform/metadata_nullify:
          metric_statements:
            - context: metric
              statements:
                - set(description, "")
                - set(unit, "")
  
        batch:
          send_batch_size: 2048
          send_batch_max_size: 4096
          timeout: 10s
  
      exporters:
        otlp_http:
          endpoint: ${env:OTEL_EXPORTER_OTLP_ENDPOINT}
          headers:
            api-key: ${env:NEW_RELIC_LICENSE_KEY}
          compression: gzip
  
      service:
        extensions: [health_check, k8s_observer]
        pipelines:
          metrics/redis:
            receivers: [receiver_creator/redis]
            processors: [memory_limiter, resource/k8s_cluster, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
            exporters: [otlp_http]

  Copier
  bash

  Copier

  $
  kubectl apply -f otel-collector-config.yaml

  Ce que fait cette configuration

  Chaque composant du pipeline a une tâche spécifique :

  Composant	Description
  health_check	Expose un point de terminaison de santé sur 0.0.0.0:13133 afin que vous puissiez confirmer que le collecteur est en cours d'exécution.
  k8s_observer	Surveille l'API Kubernetes pour les pods afin que le collecteur puisse découvrir les instances Redis dynamiquement.
  receiver_creator/redis	Démarre un récepteur redis pour chaque pod correspondant à la règle (labels["app"] == "redis") et lit ses métriques à partir de la commande Redis INFO toutes les 10 secondes.
  memory_limiter	Limite l'utilisation de la mémoire du collecteur (limite souple de 256 Mio, pic de 64 Mio) pour protéger le pod.
  resource/k8s_cluster	Définit k8s.cluster.name et redis.instance.id, l'identité stable pour votre entité Redis (le modèle composite server.address:server.port n'est pas utilisé sur Kubernetes).
  attributes/entity_tags	Ajoute instrumentation.provider: opentelemetry à chaque métrique afin que vous puissiez limiter les requêtes au chemin OpenTelemetry.
  cumulativetodelta	Convertit les compteurs cumulatifs de Redis — commandes, succès d'espace clé, évictions, etc. — en valeurs delta afin que New Relic représente correctement les taux.
  filter/cardinality	Supprime les points de données à forte cardinalité (états du processeur autres que user et sys, et métriques par commande pour les commandes peu communes) afin de contrôler les coûts d'ingestion.
  transform/metadata_nullify	Efface les descriptions et les unités des métriques pour réduire la taille de la charge.
  batch	Regroupe les points de données avant l’exportation (2 048 par lot, jusqu’à 4 096) et les vide au moins toutes les 10 secondes pour réduire la surcharge du réseau.
  otlp_http	Exporte les métriques traitées vers New Relic via OTLP avec la compression gzip, authentifiées avec votre clé de licence.

Facultatif : collecter les logs Redis

Au-delà des métriques, le collecteur peut transférer les logs de Redis à New Relic afin que vous puissiez corréler les événements de log — redémarrages, événements de persistance ou erreurs — avec les pics de métriques sur la même entité. Pour les collecter, ajoutez le récepteur filelog à votre ConfigMap et montez /var/log/pods dans le DaemonSet.

Ajoutez à la section receivers de votre ConfigMap :

file_log/redis:
      include:
        - /var/log/pods/<namespace>_*redis*/*/*.log  # Update <namespace> with your Redis namespace (e.g., default, production)
      start_at: end
      include_file_path: true
      operators:
        - type: regex_parser
          regex: '^\S+ stdout F \d+:[XCSM] \d+ \w+ \d+ \d+:\d+:\d+\.\d+ (?P<level>.) '
          on_error: send
      resource:
        db.system: redis

Ajouter un Processeur resource/redis_logs :

resource/redis_logs:
      attributes:
        - key: redis.instance.id
          value: "my-cluster.default:6379"  # Update with cluster.namespace:port
          action: upsert
        - key: instrumentation.provider
          value: "opentelemetry"
          action: upsert

Ajoutez un pipeline de logs à la section Service :

service:
      pipelines:
        metrics/redis:
          # ... existing metrics pipeline ...
        logs/redis:
          receivers: [file_log/redis]
          processors: [memory_limiter, resource/redis_logs, batch]
          exporters: [otlp_http]

Facultatif : activer le monitoring du Cluster Redis

Le monitoring du Cluster Redis nécessite actuellement l'approche du récepteur Prometheus (en utilisant redis_exporter). Le récepteur Redis natif du Collecteur Otel Contrib ne prend pas encore en charge la commande CLUSTER INFO nécessaire pour les métriques de cluster. Utilisez l'onglet Récepteur Prometheus pour la configuration du monitoring de cluster.

Déployer le DaemonSet

Créer otel-collector-daemonset.yaml:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: otel-collector-redis
  namespace: newrelic
spec:
  selector:
    matchLabels:
      app: otel-collector-redis
  template:
    metadata:
      labels:
        app: otel-collector-redis
    spec:
      serviceAccountName: otel-collector-redis
      containers:
        - name: otel-collector
          image: otel/opentelemetry-collector-contrib:latest
          args: ["--config=/etc/otel/config.yaml"]
          env:
            - name: NEW_RELIC_LICENSE_KEY
              valueFrom:
                secretKeyRef:
                  name: newrelic-credentials
                  key: NEW_RELIC_LICENSE_KEY
            - name: OTEL_EXPORTER_OTLP_ENDPOINT
              valueFrom:
                secretKeyRef:
                  name: newrelic-credentials
                  key: OTEL_EXPORTER_OTLP_ENDPOINT
            - name: K8S_NODE_NAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
          resources:
            limits:
              cpu: 500m
              memory: 512Mi
            requests:
              cpu: 100m
              memory: 128Mi
          volumeMounts:
            - name: config
              mountPath: /etc/otel
            - name: machine-id
              mountPath: /etc/machine-id
              readOnly: true
            # Uncomment if collecting logs:
            # - name: varlogpods
            #   mountPath: /var/log/pods
            #   readOnly: true
          livenessProbe:
            httpGet:
              path: /
              port: 13133
            initialDelaySeconds: 15
          readinessProbe:
            httpGet:
              path: /
              port: 13133
            initialDelaySeconds: 5
      volumes:
        - name: config
          configMap:
            name: otel-collector-redis-config
        - name: machine-id
          hostPath:
            path: /etc/machine-id
        # Uncomment if collecting logs:
        # - name: varlogpods
        #   hostPath:
        #     path: /var/log/pods

$
kubectl apply -f otel-collector-daemonset.yaml

Vérifier

Confirmez que le pod du collecteur est en cours d'exécution :

$
kubectl get pods -n newrelic -l app=otel-collector-redis

Le pod doit afficher Running avec tous les conteneurs prêts. S'il est CrashLoopBackOff ou Error, vérifiez ses logs avec kubectl logs -n newrelic -l app=otel-collector-redis — les causes les plus courantes sont des erreurs YAML du ConfigMap, un ClusterRole RBAC manquant ou la règle de découverte ne correspondant pas aux labels de vos pods Redis.

Confirmez ensuite que vos métriques parviennent à New Relic. Attendez environ une minute après le démarrage du pod, puis exécutez cette requête dans le générateur de requêtes:

SELECT count(*) FROM Metric
WHERE metricName LIKE 'redis.%'
AND instrumentation.provider = 'opentelemetry'
AND k8s.cluster.name IS NOT NULL
SINCE 5 minutes ago

Un nombre non nul confirme que les métriques Redis circulent. S'il renvoie 0, consultez Dépanner Redis (OpenTelemetry).

Créer un espace de nommage et des identifiants

Créez un espace de nommage newrelic et stockez votre clé de licence et votre point de terminaison OTLP dans un Secret Kubernetes, que le collecteur lit à l'exécution afin que vos identifiants restent en dehors de la configuration :

$
kubectl create namespace newrelic
$

$
# Set OTEL_EXPORTER_OTLP_ENDPOINT for your region.
$
# See https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp
$
kubectl create secret generic newrelic-credentials \
>
  --from-literal=NEW_RELIC_LICENSE_KEY=YOUR_LICENSE_KEY \
>
  --from-literal=OTEL_EXPORTER_OTLP_ENDPOINT=YOUR_OTLP_ENDPOINT \
>
  -n newrelic

Déployer redis_exporter

Déployez redis_exporter en tant que sidecar dans votre pod Redis ou en tant que déploiement séparé. Cet exemple le déploie en tant que déploiement autonome avec un service pour que le collecteur le scrape.

Créer redis-exporter.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-exporter
  namespace: default  # Update with your Redis namespace
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis-exporter
  template:
    metadata:
      labels:
        app: redis-exporter
    spec:
      containers:
        - name: redis-exporter
          image: oliver006/redis_exporter:latest
          env:
            - name: REDIS_ADDR
              value: "redis://redis:6379"  # Update with your Redis service name:port
            # Uncomment if using Redis authentication:
            # - name: REDIS_PASSWORD
            #   valueFrom:
            #     secretKeyRef:
            #       name: redis-credentials
            #       key: password
          ports:
            - containerPort: 9121
              name: metrics
          livenessProbe:
            httpGet:
              path: /health
              port: 9121
            initialDelaySeconds: 5
          readinessProbe:
            httpGet:
              path: /health
              port: 9121
            initialDelaySeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: redis-exporter
  namespace: default  # Update with your Redis namespace
spec:
  selector:
    app: redis-exporter
  ports:
    - port: 9121
      targetPort: 9121
      name: metrics

$
kubectl apply -f redis-exporter.yaml

Vérifiez que l'exportateur est en cours d'exécution :

$
kubectl port-forward svc/redis-exporter 9121:9121 &
$
curl -s http://localhost:9121/metrics | grep redis_up

Configurer le collecteur

Cette ConfigMap récupère les métriques de redis_exporter et les envoie à New Relic. Elle gère ces tâches principales :

• Scraper le service redis_exporter via le Récepteur prometheus

• Renommer les métriques Prometheus avec les noms de métrique Redis de New Relic

• Façonner les données — réduire la cardinalité, convertir les compteurs en deltas et définir l'identité de l'entité

• Exportez les métriques traitées vers New Relic via OTLP

  Créer otel-collector-config.yaml:

  apiVersion: v1
  kind: ConfigMap
  metadata:
    name: otel-collector-redis-config
    namespace: newrelic
  data:
    config.yaml: |
      extensions:
        health_check:
          endpoint: "0.0.0.0:13133"
  
      receivers:
        prometheus:
          config:
            scrape_configs:
              - job_name: 'redis'
                scrape_interval: 10s
                static_configs:
                  - targets: ['redis-exporter.default.svc.cluster.local:9121']  # Update with your exporter service FQDN
                metric_relabel_configs:
                  - source_labels: [__name__]
                    regex: '(go_|process_|promhttp_|redis_exporter_).*'
                    action: drop
  
      processors:
        memory_limiter:
          check_interval: 5s
          limit_mib: 256
          spike_limit_mib: 64
  
        resource/redis_identity:
          attributes:
            - key: k8s.cluster.name
              value: "my-cluster"  # Update with your cluster name
              action: upsert
            - key: redis.instance.id
              value: "my-cluster.default:6379"  # Update with cluster.namespace:port
              action: upsert
  
        attributes/entity_tags:
          actions:
            - key: instrumentation.provider
              value: opentelemetry
              action: upsert
  
        metricstransform:
          transforms:
            - include: redis_uptime_in_seconds
              action: update
              new_name: redis.uptime
            - include: redis_connected_clients
              action: update
              new_name: redis.clients.connected
            - include: redis_blocked_clients
              action: update
              new_name: redis.clients.blocked
            - include: redis_memory_used_bytes
              action: update
              new_name: redis.memory.used
            - include: redis_memory_max_bytes
              action: update
              new_name: redis.maxmemory
            - include: redis_mem_fragmentation_ratio
              action: update
              new_name: redis.memory.fragmentation_ratio
            - include: redis_memory_used_rss_bytes
              action: update
              new_name: redis.memory.rss
            - include: redis_memory_used_peak_bytes
              action: update
              new_name: redis.memory.peak
            - include: redis_memory_used_lua_bytes
              action: update
              new_name: redis.memory.lua
            - include: redis_connections_received_total
              action: update
              new_name: redis.connections.received
            - include: redis_rejected_connections_total
              action: update
              new_name: redis.connections.rejected
            - include: redis_commands_processed_total
              action: update
              new_name: redis.commands.processed
            - include: redis_keyspace_hits_total
              action: update
              new_name: redis.keyspace.hits
            - include: redis_keyspace_misses_total
              action: update
              new_name: redis.keyspace.misses
            - include: redis_evicted_keys_total
              action: update
              new_name: redis.keys.evicted
            - include: redis_expired_keys_total
              action: update
              new_name: redis.keys.expired
            - include: redis_net_input_bytes_total
              action: update
              new_name: redis.net.input
            - include: redis_net_output_bytes_total
              action: update
              new_name: redis.net.output
            - include: redis_connected_slaves
              action: update
              new_name: redis.slaves.connected
            - include: redis_db_keys
              action: update
              new_name: redis.db.keys
            - include: redis_db_keys_expiring
              action: update
              new_name: redis.db.expires
            - include: redis_rdb_changes_since_last_save
              action: update
              new_name: redis.rdb.changes_since_last_save
            - include: redis_db_avg_ttl_seconds
              action: update
              new_name: redis.db.avg_ttl
            - include: redis_latest_fork_seconds
              action: update
              new_name: redis.latest_fork
            - include: redis_master_repl_offset
              action: update
              new_name: redis.replication.offset
            - include: redis_repl_backlog_first_byte_offset
              action: update
              new_name: redis.replication.backlog_first_byte_offset
            - include: redis_commands_total
              action: update
              new_name: redis.cmd.calls
            - include: redis_commands_duration_seconds_total
              action: update
              new_name: redis.cmd.usec
            - include: redis_cpu_sys_seconds_total
              action: update
              new_name: redis.cpu.time
              operations:
                - action: add_label
                  new_label: state
                  new_value: sys
            - include: redis_cpu_user_seconds_total
              action: update
              new_name: redis.cpu.time
              operations:
                - action: add_label
                  new_label: state
                  new_value: user
  
        cumulativetodelta:
          include:
            match_type: regexp
            metrics:
              - redis\.commands\.processed
              - redis\.connections\.received
              - redis\.connections\.rejected
              - redis\.keys\.evicted
              - redis\.keys\.expired
              - redis\.keyspace\.hits
              - redis\.keyspace\.misses
              - redis\.net\.input
              - redis\.net\.output
              - redis\.cpu\.time
              - redis\.cmd\.calls
              - redis\.cmd\.usec
              - redis\.uptime
  
        filter/cardinality:
          metrics:
            datapoint:
              - 'metric.name == "redis.cpu.time" and attributes["state"] != "sys" and attributes["state"] != "user"'
              - 'metric.name == "redis.cmd.calls" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'
              - 'metric.name == "redis.cmd.usec" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'
  
        transform/metadata_nullify:
          metric_statements:
            - context: metric
              statements:
                - set(description, "")
                - set(unit, "")
  
        batch:
          send_batch_size: 2048
          send_batch_max_size: 4096
          timeout: 10s
  
      exporters:
        otlp_http:
          endpoint: ${env:OTEL_EXPORTER_OTLP_ENDPOINT}
          headers:
            api-key: ${env:NEW_RELIC_LICENSE_KEY}
          compression: gzip
  
      service:
        extensions: [health_check]
        pipelines:
          metrics/redis:
            receivers: [prometheus]
            processors: [memory_limiter, resource/redis_identity, attributes/entity_tags, metricstransform, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
            exporters: [otlp_http]

  Copier
  bash

  Copier

  $
  kubectl apply -f otel-collector-config.yaml

  Ce que fait cette configuration

  Chaque composant du pipeline a une tâche spécifique :

  Composant	Description
  health_check	Expose un point de terminaison de santé sur 0.0.0.0:13133 afin que vous puissiez confirmer que le collecteur est en cours d'exécution.
  prometheus Récepteur	Scrape le service redis_exporter (par défaut redis-exporter.default.svc.cluster.local:9121) toutes les 10 secondes et supprime les propres métriques go_*, process_*, promhttp_* et redis_exporter_* de l'exportateur.
  memory_limiter	Limite l'utilisation de la mémoire du collecteur (limite souple de 256 Mio, pic de 64 Mio) pour protéger le pod.
  resource/redis_identity	Définit k8s.cluster.name et redis.instance.id, l'identité stable pour votre entité Redis. C'est requis ici car le Récepteur Prometheus ne fournit pas server.address ni server.port.
  attributes/entity_tags	Ajoute instrumentation.provider: opentelemetry à chaque métrique afin que vous puissiez limiter les requêtes au chemin OpenTelemetry.
  metricstransform	Renomme les métriques Prometheus de l'exportateur (par exemple, redis_uptime_in_seconds) avec les noms Redis de New Relic (redis.uptime) et ajoute l'étiquette state aux métriques de processeur.
  cumulativetodelta	Convertit les compteurs cumulatifs — commandes, succès d’espace clé, évictions, etc. — en valeurs delta afin que New Relic affiche correctement les taux.
  filter/cardinality	Supprime les points de données à forte cardinalité (états du processeur autres que user et sys, et métriques par commande pour les commandes peu communes) afin de contrôler les coûts d'ingestion.
  transform/metadata_nullify	Efface les descriptions et les unités des métriques pour réduire la taille de la charge.
  batch	Regroupe les points de données avant l’exportation (2 048 par lot, jusqu’à 4 096) et les vide au moins toutes les 10 secondes pour réduire la surcharge du réseau.
  otlp_http	Exporte les métriques traitées vers New Relic via OTLP avec la compression gzip, authentifiées avec votre clé de licence.

Facultatif : activer le monitoring du Cluster Redis

Si votre Redis s'exécute en mode Cluster, démarrez redis_exporter avec l'indicateur --is-cluster pour collecter automatiquement les métriques d'état du cluster à partir de tous les nœuds :

$
redis_exporter --redis.addr=redis://localhost:7000 --is-cluster

La configuration du Récepteur Prometheus ci-dessus renomme déjà les métriques du cluster (par exemple, redis_cluster_state → redis.cluster.state). Pour créer une entité de cluster distincte dans New Relic, ajoutez un attribut de ressource redis.cluster.name à un pipeline distinct qui n’inclut PAS redis.instance.id:

resource/cluster:
    attributes:
      - key: redis.cluster.name
        value: "my-redis-cluster"  # Update with your cluster name
        action: upsert

Ajoutez un pipeline de cluster à votre section de service :

metrics/cluster:
      receivers: [prometheus]
      processors: [memory_limiter, resource/cluster, attributes/entity_tags, metricstransform, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]

Facultatif : collecter les logs Redis

Au-delà des métriques, le collecteur peut transférer les logs de Redis à New Relic afin que vous puissiez corréler les événements de log — redémarrages, événements de persistance ou erreurs — avec les pics de métriques sur la même entité. Pour les collecter, ajoutez le récepteur file_log à votre ConfigMap et montez /var/log/pods dans le déploiement.

Ajoutez à la section receivers de votre ConfigMap :

file_log/redis:
      include:
        - /var/log/pods/<namespace>_*redis*/*/*.log  # Update <namespace> with your Redis namespace (e.g., default, production)
      start_at: end
      include_file_path: true
      operators:
        - type: regex_parser
          regex: '^\S+ stdout F \d+:[XCSM] \d+ \w+ \d+ \d+:\d+:\d+\.\d+ (?P<level>.) '
          on_error: send
      resource:
        db.system: redis

Ajouter un Processeur resource/redis_logs :

resource/redis_logs:
      attributes:
        - key: redis.instance.id
          value: "my-cluster.default:6379"  # Must match the value in resource/redis_identity
          action: upsert
        - key: instrumentation.provider
          value: "opentelemetry"
          action: upsert

Ajoutez un pipeline de logs à la section Service :

service:
      pipelines:
        metrics/redis:
          # ... existing metrics pipeline ...
        logs/redis:
          receivers: [file_log/redis]
          processors: [memory_limiter, resource/redis_logs, batch]
          exporters: [otlp_http]

Ajoutez le montage de volume /var/log/pods à votre déploiement (voir l'étape pour déployer ci-dessous).

Déployer le collecteur

Créer otel-collector-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: otel-collector-redis
  namespace: newrelic
spec:
  replicas: 1
  selector:
    matchLabels:
      app: otel-collector-redis
  template:
    metadata:
      labels:
        app: otel-collector-redis
    spec:
      containers:
        - name: otel-collector
          image: otel/opentelemetry-collector-contrib:latest
          args: ["--config=/etc/otel/config.yaml"]
          env:
            - name: NEW_RELIC_LICENSE_KEY
              valueFrom:
                secretKeyRef:
                  name: newrelic-credentials
                  key: NEW_RELIC_LICENSE_KEY
            - name: OTEL_EXPORTER_OTLP_ENDPOINT
              valueFrom:
                secretKeyRef:
                  name: newrelic-credentials
                  key: OTEL_EXPORTER_OTLP_ENDPOINT
          resources:
            limits:
              cpu: 500m
              memory: 512Mi
            requests:
              cpu: 100m
              memory: 128Mi
          volumeMounts:
            - name: config
              mountPath: /etc/otel
            # Uncomment if collecting logs:
            # - name: varlogpods
            #   mountPath: /var/log/pods
            #   readOnly: true
          livenessProbe:
            httpGet:
              path: /
              port: 13133
            initialDelaySeconds: 15
          readinessProbe:
            httpGet:
              path: /
              port: 13133
            initialDelaySeconds: 5
      volumes:
        - name: config
          configMap:
            name: otel-collector-redis-config
        # Uncomment if collecting logs:
        # - name: varlogpods
        #   hostPath:
        #     path: /var/log/pods

$
kubectl apply -f otel-collector-deployment.yaml

Vérifier

Confirmez que le pod du collecteur est en cours d'exécution :

$
kubectl get pods -n newrelic -l app=otel-collector-redis

Le pod doit afficher Running avec tous les conteneurs prêts. S'il s'agit de CrashLoopBackOff ou Error, vérifiez ses logs avec kubectl logs -n newrelic -l app=otel-collector-redis — les causes les plus courantes sont des erreurs YAML de ConfigMap ou un service redis_exporter inaccessible.

Confirmez ensuite que vos métriques parviennent à New Relic. Attendez environ une minute après le démarrage du pod, puis exécutez cette requête dans le générateur de requêtes:

SELECT count(*) FROM Metric
WHERE metricName LIKE 'redis.%'
AND instrumentation.provider = 'opentelemetry'
AND k8s.cluster.name IS NOT NULL
SINCE 5 minutes ago

Un nombre non nul confirme que les métriques Redis circulent. S'il renvoie 0, consultez Dépanner Redis (OpenTelemetry).