Monitorer NGINX sur Kubernetes avec OpenTelemetry

Monitorez vos serveurs NGINX fonctionnant dans des clusters Kubernetes en utilisant le collecteur NRDOT (recommandé) ou le collecteur OpenTelemetry contrib pour envoyer des métriques et des données télémétriques à New Relic.

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é

Terminez l'installation de base du manifeste Kubernetes OpenTelemetry

Configurer le collecteur NRDOT

Installer le collecteur NRDOT à l'aide de manifestes Kubernetes. La prise en charge des charts Helm sera bientôt disponible.

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
```

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

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

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

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

Affichez vos données dans New Relic

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

Prochaines étapes

Configurer le monitoring NGINX