Monitorer NGINX sur Kubernetes avec OpenTelemetry

Monitorez vos serveurs NGINX fonctionnant dans des clusters Kubernetes pour envoyer des métriques et des données télémétriques à New Relic.

Vous pouvez choisir entre trois options de collecteur :

NRDOT : Distribution New Relic d'OpenTelemetry
OTel Collector Contrib : Collecteur OpenTelemetry standard avec des composants issus de la communauté
Prometheus Receiver : Pour les environnements exécutant déjà nginx-prometheus-exporter en tant que sidecar

Cette intégration spécifique à Kubernetes découvre automatiquement les pods NGINX dans votre cluster et collecte des métriques sans configuration manuelle pour chaque instance. Elle exploite le nginxreceiver et le receivercreator OpenTelemetry pour monitorer dynamiquement les métriques de performance NGINX, les statistiques de connexion et l'état de santé du serveur dans votre environnement conteneurisé.

Configurer le monitoring NGINX

Choisissez votre collecteur préféré et suivez les étapes :

Avant de commencer

Assurez-vous d'avoir :

Clé de licenceNew Relic valide
Activez le module HTTP stub status sur le pod NGINX qui doit être monitoré
Ajoutez les étiquettes app et role à chaque pod NGINX qui doit être monitoré
Pour l'installation via manifeste : terminez l'installation de base du manifeste Kubernetes OpenTelemetry

Pour l'installation Helm : terminez l'installation Helm d'OpenTelemetry sur Kubernetesde base

Configurer le collecteur NRDOT

Installer le collecteur NRDOT à l'aide de manifestes Kubernetes ou Helm.

Après avoir terminé l'installation du manifeste Kubernetes OpenTelemetry de base, configurez le monitoring de NGINX en suivant ces étapes :

Mettre à jour l'image du collecteur pour utiliser le collecteur NRDOT.
Dans les fichiers deployment.yaml et daemonset.yaml de votre répertoire local rendered, mettez à jour l'image vers :
```
image: newrelic/nrdot-collector:latest
```

Mettez à jour le deployment-configmap.yaml pour le monitoring de NGINX :

Choisissez l'une des options de configuration suivantes en fonction de vos exigences de monitoring :

Important

Cette option monitore uniquement NGINX et supprime la collecte d'autres métriques Kubernetes. Vous supprimerez les collecteurs supplémentaires plus tard pour éviter l'ingestion de métriques indésirables.

Remplacez le contenu sous deployment-config.yaml: | par la configuration spécifique à NGINX ci-dessous :

extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  k8s_observer:
    auth_type: serviceAccount
    observe_pods: true
    observe_nodes: true

receivers:
  receiver_creator/nginx:
    watch_observers: [k8s_observer]
    receivers:
      nginx:
        rule: type == "pod" && labels["app"] == "nginx" && labels["role"] == "reverse-proxy"  # Update with your labels
        config:
          endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
          metrics:
            nginx.requests:
              enabled: true
            nginx.connections_accepted:
              enabled: true
            nginx.connections_handled:
              enabled: true
            nginx.connections_current:
              enabled: true
          collection_interval: 30s
        resource_attributes:
          nginx.server.endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
          nginx.port: '<YOUR_STUB_STATUS_PORT>'  # Update to match your configuration

processors:
  batch:
    send_batch_max_size: 1000
    timeout: 30s
    send_batch_size: 800

  memory_limiter:
    check_interval: 1s
    limit_percentage: 80
    spike_limit_percentage: 25

  resource/cluster:
    attributes:
      - key: k8s.cluster.name
        value: "<CLUSTER_NAME>"  # Replace with your cluster name
        action: insert

  transform/nginx:
    metric_statements:
      - context: resource
        statements:
          - set(attributes["nginx.display.name"], Concat([
              "server",
              "k8s",
              attributes["k8s.cluster.name"],
              attributes["k8s.namespace.name"],
              "pod",
              attributes["k8s.pod.name"],
              "nginx",
              attributes["nginx.port"]
            ], ":"))
          - set(attributes["nginx.deployment.name"], attributes["k8s.pod.name"])
  
  transform/metadata_nullify:
    metric_statements:
      - context: metric
        statements:
          - set(description, "")
          - set(unit, "")

exporters:
  otlp_http/newrelic:
    endpoint: "<YOUR_NEWRELIC_OTLP_ENDPOINT>"
    headers:
      api-key: ${env:NR_LICENSE_KEY}

service:
  extensions: [health_check, k8s_observer]
  pipelines:
    metrics/nginx:
      receivers: [receiver_creator/nginx]
      processors: [batch, resource/cluster, transform/nginx, transform/metadata_nullify, memory_limiter]
      exporters: [otlp_http/newrelic]

Paramètres de configuration

Le tableau suivant décrit les principaux paramètres de configuration :

paramètres	Description
`<YOUR_STUB_STATUS_PORT>`	Remplacez par votre port de statut stub NGINX (par exemple 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Remplacez par le chemin de votre statut stub NGINX (par exemple basic_status)
`<CLUSTER_NAME>`	Remplacez par le nom de votre cluster Kubernetes pour l'identification dans New Relic
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	Mettez à jour avec le point de terminaison OTLP de votre région. Consultez la documentation sur les points de terminaison OTLP
`app` et `role` labels	Labels de pod utilisés pour identifier les pods NGINX (mettez à jour la règle pour correspondre à vos labels)
`collection_interval`	Intervalle en secondes pour collecter les métriques. La valeur par défaut est définie sur `30s`
`send_batch_max_size`	Nombre maximal de métriques à regrouper en lot avant l'envoi. La valeur par défaut est définie sur `1000`
`timeout`	Délai d'attente en secondes avant d'envoyer les métriques groupées. La valeur par défaut est définie sur `30s`

Ajoutez les sections suivantes à votre deployment-configmap.yaml existant :

Extensions à ajouter :

extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  k8s_observer:
    auth_type: serviceAccount
    observe_pods: true
    observe_nodes: true

Récepteurs à ajouter :

receivers:
  receiver_creator/nginx:
    watch_observers: [k8s_observer]
    receivers:
      nginx:
        rule: type == "pod" && labels["app"] == "nginx" && labels["role"] == "reverse-proxy"  # Update with your labels
        config:
          endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
          metrics:
            nginx.requests:
              enabled: true
            nginx.connections_accepted:
              enabled: true
            nginx.connections_handled:
              enabled: true
            nginx.connections_current:
              enabled: true
          collection_interval: 30s
        resource_attributes:
          nginx.server.endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
          nginx.port: '<YOUR_STUB_STATUS_PORT>'  # Update to match your configuration

Processeurs à ajouter :

processors:
  resource/cluster:
    attributes:
      - key: k8s.cluster.name
        value: "<CLUSTER_NAME>"  # Replace with your cluster name
        action: insert

  transform/nginx:
    metric_statements:
      - context: resource
        statements:
          - set(attributes["nginx.display.name"], Concat([
              "server",
              "k8s",
              attributes["k8s.cluster.name"],
              attributes["k8s.namespace.name"],
              "pod",
              attributes["k8s.pod.name"],
              "nginx",
              attributes["nginx.port"]
            ], ":"))
          - set(attributes["nginx.deployment.name"], attributes["k8s.pod.name"])
  
  transform/metadata_nullify:
    metric_statements:
      - context: metric
        statements:
          - set(description, "")
          - set(unit, "")

Pipelines de service à ajouter :

service:
  extensions: [health_check, k8s_observer]  # Add to existing extensions
  pipelines:
    metrics/nginx:
      receivers: [receiver_creator/nginx]
      processors: [batch, resource/cluster, transform/nginx, transform/metadata_nullify, memory_limiter]
      exporters: [otlphttp/newrelic]

Paramètres de configuration

Le tableau suivant décrit les principaux paramètres de configuration :

paramètres	Description
`<YOUR_STUB_STATUS_PORT>`	Remplacez par votre port de statut stub NGINX (par exemple 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Remplacez par le chemin de votre statut stub NGINX (par exemple basic_status)
`<CLUSTER_NAME>`	Remplacez par le nom de votre cluster Kubernetes pour l'identification dans New Relic
`app` et `role` labels	Labels de pod utilisés pour identifier les pods NGINX (mettez à jour la règle pour correspondre à vos labels)
`collection_interval`	Intervalle en secondes pour collecter les métriques. La valeur par défaut est définie sur `30s`
`memory_limiter`	Processeur utilisé dans la configuration Kubernetes existante pour limiter l'utilisation de la mémoire

Appliquez les manifestes mis à jour et redémarrez le déploiement.
1. Pour le monitoring NGINX uniquement, exécutez ces commandes :
bash
```
$kubectl apply -n newrelic -R -f rendered
$kubectl delete daemonset nr-k8s-otel-collector-daemonset -n newrelic
$kubectl delete deployment nr-k8s-otel-collector-kube-state-metrics -n newrelic
$kubectl rollout restart deployment nr-k8s-otel-collector-deployment -n newrelic
```
1. Pour le monitoring de K8s + NGINX, exécutez ces commandes :
bash
```
$kubectl apply -n newrelic -R -f rendered
$kubectl rollout restart deployment nr-k8s-otel-collector-deployment -n newrelic
```

Ajoutez les sections suivantes sous deployment.extraConfig dans votre values.yaml:

Important

Dans deployment.extraConfig, pipelines: doit être défini au niveau racine — et non imbriqué sous service:. Le modèle de chart Helm associe extraConfig.pipelines à service.pipelines, et extraConfig.service.extensions à service.extensions.

Extensions :

extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  k8s_observer:
    auth_type: serviceAccount
    observe_pods: true
    observe_nodes: true

Récepteurs :

receivers:
  receiver_creator/nginx:
    watch_observers: [k8s_observer]
    receivers:
      nginx:
        rule: type == "pod" && labels["app"] == "nginx" && labels["role"] == "reverse-proxy"  # Update with your labels
        resource_attributes:
          nginx.server.endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
          nginx.port: '<YOUR_STUB_STATUS_PORT>'  # Update to match your configuration
        config:
          endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
          metrics:
            nginx.requests:
              enabled: true
            nginx.connections_accepted:
              enabled: true
            nginx.connections_handled:
              enabled: true
            nginx.connections_current:
              enabled: true
          collection_interval: 30s

Processeurs :

processors:

  resource/cluster:
    attributes:
      - key: k8s.cluster.name
        value: "<CLUSTER_NAME>"  # Replace with your cluster name
        action: insert

  transform/nginx:
    metric_statements:
      - context: resource
        statements:
          - set(attributes["nginx.display.name"], Concat([
              "server",
              "k8s",
              attributes["k8s.cluster.name"],
              attributes["k8s.namespace.name"],
              "pod",
              attributes["k8s.pod.name"],
              "nginx",
              attributes["nginx.port"]
            ], ":"))
          - set(attributes["nginx.deployment.name"], attributes["k8s.pod.name"])

  transform/metadata_nullify:
    metric_statements:
      - context: metric
        statements:
          - set(description, "")
          - set(unit, "")

Extensions de service :

service:
  extensions: [health_check, k8s_observer]

Pipelines :

pipelines:
  metrics/nginx:
    receivers: [receiver_creator/nginx]
    processors: [batch, resource/cluster, transform/nginx, transform/metadata_nullify, memory_limiter]
    exporters: [otlphttp/newrelic]

Paramètres de configuration

Le tableau suivant décrit les principaux paramètres de configuration :

paramètres	Description
`<YOUR_STUB_STATUS_PORT>`	Remplacez par votre port de statut stub NGINX (par exemple 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Remplacez par le chemin de votre statut stub NGINX (par exemple basic_status)
`<CLUSTER_NAME>`	Remplacez par le nom de votre cluster Kubernetes pour l'identification dans New Relic
`app` et `role` labels	Labels de pod utilisés pour identifier les pods NGINX (mettez à jour la règle pour correspondre à vos labels)
`collection_interval`	Intervalle en secondes pour collecter les métriques. La valeur par défaut est définie sur `30s`
`send_batch_max_size`	Nombre maximal de métriques à regrouper en lot avant l'envoi. La valeur par défaut est définie sur `1000`
`timeout`	Délai d'attente en secondes avant d'envoyer les métriques groupées. La valeur par défaut est définie sur `30s`
`memory_limiter`	Processeur utilisé pour limiter l'utilisation de la mémoire. `limit_percentage` définit le pourcentage maximal de mémoire avant le début de la limitation

Appliquez les valeurs mises à jour à votre sortie Helm en cours d'exécution :

bash

$helm upgrade nr-k8s-otel-collector newrelic/nr-k8s-otel-collector \
>  --namespace newrelic \
>  --reuse-values \
>  -f values.yaml

Avant de commencer

Assurez-vous d'avoir :

Clé de licenceNew Relic valide
Activez le module HTTP stub status sur le pod NGINX qui doit être monitoré
Ajoutez les étiquettes app et role à chaque pod NGINX qui doit être monitoré

Helm installé

Configurer le OpenTelemetry Collector

Déployez le collecteur OpenTelemetry sur votre cluster Kubernetes à l'aide de Helm. Le collecteur découvrira et extraira automatiquement les métriques de vos pods NGINX.

Téléchargez ou créez un fichier values.yaml personnalisé basé sur le values.yaml de l'OpenTelemetry Collector.

Mettez à jour les sections suivantes dans votre fichier values.yaml :

Définir le mode sur déploiement :
```
mode: deployment
```

Remplacez le référentiel d'images :

image:
  repository: otel/opentelemetry-collector-contrib

Configurer le rôle de cluster :

clusterRole:
  create: true
  rules:
    - apiGroups: [""]
      resources: ["pods", "nodes", "nodes/stats", "nodes/proxy"]
      verbs: ["get", "list", "watch"]
    - apiGroups: ["apps"]
      resources: ["replicasets"]
      verbs: ["get", "list", "watch"]

Configurer les limites de ressources :

resources:
  limits:
    cpu: 250m
    memory: 512Mi

Remplacez toute la section de configuration par la configuration de monitoring NGINX :

config:
     extensions:
       health_check:
         endpoint: 0.0.0.0:13133
       k8s_observer:
         auth_type: serviceAccount
         observe_pods: true
         observe_nodes: true

     receivers:
       receiver_creator/nginx:
         watch_observers: [k8s_observer]
         receivers:
           nginx:
             rule: type == "pod" && labels["app"] == "nginx" && labels["role"] == "reverse-proxy" # Update with your labels
             config:
               endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
               metrics:
                 nginx.requests:
                   enabled: true
                 nginx.connections_accepted:
                   enabled: true
                 nginx.connections_handled:
                   enabled: true
                 nginx.connections_current:
                   enabled: true
               collection_interval: 30s
             resource_attributes:
               nginx.server.endpoint: 'http://`endpoint`:<YOUR_STUB_STATUS_PORT>/<YOUR_STUB_STATUS_PATH>'  # Update port and path as needed
               nginx.port: '<YOUR_STUB_STATUS_PORT>'  # Update to match your configuration

     processors:
       batch:
         send_batch_size: 1024
         timeout: 30s

       resource/cluster:
         attributes:
           - key: k8s.cluster.name
             value: "<CLUSTER_NAME>"  # Replace with your cluster name
             action: insert

       transform/nginx:
         metric_statements:
           - context: resource
             statements:
               - set(attributes["nginx.display.name"], Concat([
                   "server",
                   "k8s",
                   attributes["k8s.cluster.name"],
                   attributes["k8s.namespace.name"],
                   "pod",
                   attributes["k8s.pod.name"],
                   "nginx",
                   attributes["nginx.port"]
                   ], ":"))
               - set(attributes["nginx.deployment.name"], attributes["k8s.pod.name"])

       transform/metadata_nullify:
         metric_statements:
           - context: metric
             statements:
               - set(description, "")
               - set(unit, "")

     exporters:
       otlp_http/newrelic:
         endpoint: "<YOUR_NEWRELIC_OTLP_ENDPOINT>"  # Update for your region
         headers:
           api-key: "<YOUR_NEW_RELIC_LICENSE_KEY>"  # Replace with your New Relic license key

     service:
       extensions: [health_check, k8s_observer]
       pipelines:
         metrics/nginx:
           receivers: [receiver_creator/nginx]
           processors: [batch, resource/cluster, transform/nginx, transform/metadata_nullify]
           exporters: [otlp_http/newrelic]

Paramètres de configuration

Le tableau suivant décrit les principaux paramètres de configuration :

paramètres	Description
`<YOUR_STUB_STATUS_PORT>`	Remplacez par votre port de statut stub NGINX (par exemple 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Remplacez par le chemin de votre statut stub NGINX (par exemple basic_status)
`<CLUSTER_NAME>`	Remplacez par le nom de votre cluster Kubernetes pour l'identification dans New Relic
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	Mettez à jour avec le point de terminaison OTLP de votre région. Consultez la documentation sur les points de terminaison OTLP
`<YOUR_NEW_RELIC_LICENSE_KEY>`	Remplacez par votre clé de licence New Relic
`app` et `role` labels	Labels de pod utilisés pour identifier les pods NGINX (mettez à jour la règle pour correspondre à vos labels)
`basic_status`	Chemin du point de terminaison de statut stub NGINX (mettez à jour si vous utilisez un chemin différent)
`collection_interval`	Intervalle en secondes pour collecter les métriques. La valeur par défaut est définie sur `30s`
`send_batch_size`	Nombre de métriques à regrouper par lot avant l'envoi. La valeur par défaut est définie sur `1024`
`timeout`	Délai d'attente en secondes avant d'envoyer les métriques groupées. La valeur par défaut est définie sur `30s`

Suivez le guide d'installation du chart Helm OpenTelemetry Collector pour installer le collecteur à l'aide de votre fichier values.yaml personnalisé.

Exemples de commandes :

bash

$helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
$helm repo update
$helm upgrade my-opentelemetry-collector open-telemetry/opentelemetry-collector -f your-custom-values.yaml -n newrelic --create-namespace --install

Vérifiez que les pods sont en cours d'exécution :
bash
```
$kubectl get pods -n newrelic --watch
```
Vous devriez voir les pods du Collector OpenTelemetry dans un état Running dans l'espace de nommage newrelic.

Exécutez une requête NRQL dans New Relic pour vérifier la collecte des données. Remplacez le nom du cluster par le nom réel de votre cluster :

FROM Metric
SELECT *
WHERE metricName LIKE 'nginx.%'
  AND instrumentation.provider = 'opentelemetry'
  AND k8s.cluster.name = 'your-cluster-name'
SINCE 10 minutes ago

Utilisez cette approche si vous avez déjà nginx-prometheus-exporter fonctionnant en tant que sidecar dans vos pods NGINX, ou si vous migrez depuis une stack de monitoring basée sur Prometheus.

Conseil

Recommandé : si vous n'avez pas déjà un exportateur Prometheus en cours d'exécution, utilisez plutôt les onglets collecteur NRDOT ou OpenTelemetry Collector Contrib. Ils se connectent directement au point de terminaison de statut stub NGINX sans nécessiter de composant exportateur supplémentaire.

Avant de commencer

Assurez-vous d'avoir :

Clé de licenceNew Relic valide
Activez le module HTTP stub status sur chaque pod NGINX qui doit être monitoré
Ajoutez les étiquettes app et role à chaque pod NGINX qui doit être monitoré

Helm installé

Terminez l'installation de base de Helm Kubernetes OpenTelemetry pour nr-k8s-otel-collector avant de continuer.

Ajoutez les sections suivantes sous deployment.configMap.extraConfig dans votre values.yaml:

Important

Dans deployment.configMap.extraConfig, pipelines: doit être défini au niveau racine — et non imbriqué sous service:. Le modèle de chart Helm mappe extraConfig.pipelines dans service.pipelines, et extraConfig.service.extensions dans service.extensions.

Extensions :

extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  k8s_observer:
    auth_type: serviceAccount
    observe_nodes: true
    observe_pods: true

Récepteurs :

receivers:
  receiver_creator/nginx_prom:
    watch_observers:
      - k8s_observer
    receivers:
      prometheus:
        rule: type == "port" && pod.labels["app"] == "nginx" && pod.labels["role"] == "reverse-proxy" && name == "metrics"  # Update with your pod labels
        config:
          config:
            scrape_configs:
              - job_name: nginx_prom
                metrics_path: /metrics
                scrape_interval: 30s
                static_configs:
                  - targets:
                      - '`endpoint`'
        resource_attributes:
          nginx.port: "9113"  # Update if nginx-prometheus-exporter runs on a different port
          nginx.server.endpoint: http://`endpoint`/metrics

Processeurs :

processors:
  resource/cluster:
    attributes:
      - action: insert
        key: k8s.cluster.name
        value: "<CLUSTER_NAME>"  # Replace with your cluster name

  metricstransform/nginx_prom:
    transforms:
      - action: update
        include: nginx_http_requests_total
        new_name: nginx.requests
      - action: update
        include: nginx_connections_accepted
        new_name: nginx.connections_accepted
      - action: update
        include: nginx_connections_handled
        new_name: nginx.connections_handled
      - action: combine
        include: ^nginx_connections_(?P<state>active|reading|writing|waiting)$
        match_type: regexp
        new_name: nginx.connections_current

  filter/nginx_prom_only:
    metrics:
      include:
        match_type: regexp
        metric_names:
          - ^nginx\..*

  transform/nginx:
    metric_statements:
      - context: resource
        statements:
          - set(attributes["nginx.display.name"], Concat([ "server", "k8s", attributes["k8s.cluster.name"], attributes["k8s.namespace.name"], "pod", attributes["k8s.pod.name"], "nginx", attributes["nginx.port"] ], ":"))
          - set(attributes["nginx.deployment.name"], attributes["k8s.pod.name"])

  transform/metadata_nullify:
    metric_statements:
      - context: metric
        statements:
          - set(description, "")
          - set(unit, "")

Extensions de service :

service:
  extensions:
    - health_check
    - k8s_observer

Pipelines :

pipelines:
  metrics/nginx_prometheus:
    receivers:
      - receiver_creator/nginx_prom
    processors:
      - batch
      - resource/cluster
      - metricstransform/nginx_prom
      - filter/nginx_prom_only
      - transform/nginx
      - transform/metadata_nullify
      - memory_limiter
    exporters:
      - otlphttp/newrelic

Paramètres de configuration

Le tableau suivant décrit les principaux paramètres de configuration :

paramètres	Description
`<CLUSTER_NAME>`	Nom de votre cluster Kubernetes. Utilisé pour l'identification dans New Relic.
`<YOUR_LICENSE_KEY>`	Votre clé de licence New Relic.
`app` et `role` labels	Labels de pod utilisés pour découvrir les pods NGINX. Mettez à jour le `rule` pour correspondre aux labels de vos pods.
`name == "metrics"`	Le port de conteneur nommé sur `9113` que le receiver_creator surveille. Doit correspondre au nom du port dans la spécification de votre pod.
`scrape_interval`	Fréquence de scraping des métriques Prometheus. Par défaut : `30s` .

Appliquez les valeurs mises à jour à votre sortie Helm en cours d'exécution :

bash

$helm upgrade nr-k8s-otel-collector newrelic/nr-k8s-otel-collector \
>  --namespace newrelic \
>  --reuse-values \
>  -f values.yaml

Téléchargez ou créez un fichier values.yaml personnalisé basé sur le values.yaml de l'OpenTelemetry Collector.

Mettez à jour les sections suivantes dans votre fichier values.yaml :

Définir le mode sur déploiement :
```
mode: deployment
```

Remplacez le référentiel d'images :

image:
  repository: otel/opentelemetry-collector-contrib

Configurer le rôle de cluster :

clusterRole:
  create: true
  rules:
    - apiGroups: [""]
      resources: ["pods", "nodes", "nodes/stats", "nodes/proxy"]
      verbs: ["get", "list", "watch"]
    - apiGroups: ["apps"]
      resources: ["replicasets"]
      verbs: ["get", "list", "watch"]

Configurer les limites de ressources :

resources:
  limits:
    cpu: 250m
    memory: 512Mi

Remplacez toute la section de configuration par la configuration du récepteur Prometheus :

config:
  extensions:
    health_check:
      endpoint: 0.0.0.0:13133
    k8s_observer:
      auth_type: serviceAccount
      observe_pods: true
      observe_nodes: true

  receivers:
    receiver_creator/nginx_prom:
      watch_observers: [k8s_observer]
      receivers:
        prometheus:
          rule: type == "port" && pod.labels["app"] == "nginx" && pod.labels["role"] == "reverse-proxy" && name == "metrics"  # Update with your pod labels
          config:
            config:
              scrape_configs:
                - job_name: nginx_prom
                  metrics_path: /metrics
                  scrape_interval: 30s
                  static_configs:
                    - targets:
                        - '`endpoint`'
          resource_attributes:
            nginx.port: "9113"  # Update if nginx-prometheus-exporter runs on a different port
            nginx.server.endpoint: http://`endpoint`/metrics

  processors:
    batch:
      send_batch_size: 1024
      timeout: 30s

    resource/cluster:
      attributes:
        - key: k8s.cluster.name
          value: "<CLUSTER_NAME>"  # Replace with your cluster name
          action: insert

    metricstransform/nginx_prom:
      transforms:
        - action: update
          include: nginx_http_requests_total
          new_name: nginx.requests
        - action: update
          include: nginx_connections_accepted
          new_name: nginx.connections_accepted
        - action: update
          include: nginx_connections_handled
          new_name: nginx.connections_handled
        - action: combine
          include: ^nginx_connections_(?P<state>active|reading|writing|waiting)$
          match_type: regexp
          new_name: nginx.connections_current

    filter/nginx_prom_only:
      metrics:
        include:
          match_type: regexp
          metric_names:
            - ^nginx\..*

    transform/nginx:
      metric_statements:
        - context: resource
          statements:
            - set(attributes["nginx.display.name"], Concat([ "server", "k8s", attributes["k8s.cluster.name"], attributes["k8s.namespace.name"], "pod", attributes["k8s.pod.name"], "nginx", attributes["nginx.port"] ], ":"))
            - set(attributes["nginx.deployment.name"], attributes["k8s.pod.name"])

    transform/metadata_nullify:
      metric_statements:
        - context: metric
          statements:
            - set(description, "")
            - set(unit, "")

  exporters:
    otlphttp/newrelic:
      endpoint: "<YOUR_NEWRELIC_OTLP_ENDPOINT>"  # Replace with your region's endpoint
      headers:
        api-key: "<YOUR_NEW_RELIC_LICENSE_KEY>"   # Replace with your license key

  service:
    extensions: [health_check, k8s_observer]
    pipelines:
      metrics/nginx_prometheus:
        receivers: [receiver_creator/nginx_prom]
        processors: [batch, resource/cluster, metricstransform/nginx_prom, filter/nginx_prom_only, transform/nginx, transform/metadata_nullify]
        exporters: [otlphttp/newrelic]

Paramètres de configuration

Le tableau suivant décrit les principaux paramètres de configuration :

paramètres	Description
`<CLUSTER_NAME>`	Nom de votre cluster Kubernetes. Utilisé pour l'identification dans New Relic.
`<YOUR_NEW_RELIC_LICENSE_KEY>`	Votre clé de licence New Relic.
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	Le point de terminaison OTLP de votre région. Consultez la documentation sur les points de terminaison OTLP .
`app` et `role` labels	Labels de pod utilisés pour découvrir les pods NGINX. Mettez à jour le `rule` pour correspondre aux labels de vos pods.
`name == "metrics"`	Le port de conteneur nommé sur `9113` que le receiver_creator surveille. Doit correspondre au nom du port dans la spécification de votre pod.
`scrape_interval`	Fréquence de scraping des métriques Prometheus. Par défaut : `30s` .

Suivez le guide d'installation du chart Helm OpenTelemetry Collector pour installer le collecteur à l'aide de votre fichier values.yaml personnalisé.

bash

$helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
$helm repo update
$helm upgrade --install nginx-otel-collector open-telemetry/opentelemetry-collector \
>  --namespace newrelic --create-namespace \
>  -f values.yaml

Vérifiez que les pods du collecteur sont en cours d'exécution :
bash
```
$kubectl get pods -n newrelic --watch
```
Consultez les logs du collecteur pour vérifier la découverte et le scraping réussis des pods :
bash
```
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector -f
```
Recherchez les lignes faisant référence à receiver_creator/nginx_prom découvrant vos pods NGINX.

Exécutez une requête NRQL dans New Relic pour confirmer que les données arrivent. Remplacez <CLUSTER_NAME> par le nom de votre cluster :

FROM Metric SELECT *
WHERE metricName LIKE 'nginx.%'
  AND instrumentation.provider = 'opentelemetry'
  AND k8s.cluster.name = '<CLUSTER_NAME>'
SINCE 10 minutes ago

Affichez vos données dans New Relic

Une fois votre configuration terminée et que les données circulent, vous pouvez accéder à vos métriques NGINX dans les dashboards New Relic et créer des alertes personnalisées.

Pour des instructions complètes sur l'accès aux dashboards, l'interrogation des données avec NRQL et la création d'alertes, consultez Trouver et interroger vos données NGINX.

Référence des métriques et des attributs

Cette intégration collecte les mêmes métriques NGINX de base que le déploiement sur l'hôte, avec des attributs de ressource spécifiques à Kubernetes supplémentaires pour l'identification du cluster, de l'espace de noms et du pod.

Pour une référence complète des métriques et attributs : Consultez la référence des métriques et attributs NGINX OpenTelemetry pour des descriptions détaillées de toutes les métriques, types et attributs de ressources pour les déploiements Kubernetes.

Prochaines étapes

Explorer le monitoring connexe :

Monitorer NGINX Plus avec OpenTelemetry - Pour les déploiements commerciaux de NGINX Plus
Monitorer NGINX auto-hébergé avec OpenTelemetry - Pour les déploiements de serveurs traditionnels

Ressources spécifiques à Kubernetes :

OpenTelemetry Collector sur Kubernetes - Configurations avancées du collecteur

Cette traduction automatique est fournie pour votre commodité.

Monitorer NGINX sur Kubernetes avec OpenTelemetry

Configurer le monitoring NGINX

Avant de commencer

Configurer le collecteur NRDOT

Installation via manifeste

Monitoring NGINX uniquement

Important

Paramètres de configuration

Monitoring K8s + NGINX

Paramètres de configuration

Installation Helm

Important

Paramètres de configuration

Avant de commencer

Configurer le OpenTelemetry Collector

Étape 1 : créer une configuration values.yaml personnalisée

Paramètres de configuration

Étape 2 : installer avec Helm

Étape 3 : vérifier le déploiement et la collecte de données

Conseil

Avant de commencer

Collecteur NRDOT — Installation Helm

Important

Paramètres de configuration

Collecteur Otel Contrib — Installation Helm

Étape 1 : créer une configuration values.yaml personnalisée

Paramètres de configuration

Étape 2 : installer avec Helm

Étape 3 : vérifier le déploiement et la collecte de données

Affichez vos données dans New Relic

Référence des métriques et des attributs

Prochaines étapes

Cette traduction automatique est fournie pour votre commodité.

Monitorer NGINX sur Kubernetes avec OpenTelemetry

Configurer le monitoring NGINX .css-21sua1{background:none;border:none;width:0;padding:0;}

Avant de commencer

Configurer le collecteur NRDOT

Installation Helm

Avant de commencer

Configurer le OpenTelemetry Collector

Étape 1 : créer une configuration values.yaml personnalisée

Étape 2 : installer avec Helm

Étape 3 : vérifier le déploiement et la collecte de données

Conseil

Avant de commencer

Collecteur NRDOT — Installation Helm

Collecteur Otel Contrib — Installation Helm

Affichez vos données dans New Relic

Référence des métriques et des attributs

Prochaines étapes

Configurer le monitoring NGINX