Monitore o NGINX no Kubernetes com OpenTelemetry

Monitore seus servidores NGINX em execução em cluster do Kubernetes usando o coletor NRDOT (recomendado) ou o coletor OpenTelemetry contrib para enviar métricas e dados de telemetria para o New Relic.

Esta integração específica do Kubernetes descobre automaticamente os pods NGINX em seu cluster e coleta métricas sem configuração manual para cada instância. Ele utiliza o nginxreceiver e o receivercreator OpenTelemetry para monitorar dinamicamente as métricas de desempenho do NGINX, estatísticas de conexão e integridade do servidor em seu ambiente em contêineres.

Configurar o monitoramento do NGINX

Escolha seu coletor preferido e siga as etapas:

Antes de você começar

Certifique-se de ter:

Chave de licençada New Relic válida
Habilite o módulo HTTP stub status no pod do NGINX que precisa ser monitorado
Adicione os rótulos app e role a cada pod NGINX que precisa ser monitorado
Para instalação via manifesto: conclua a instalação base do manifesto do OpenTelemetry para Kubernetes

Para instalação via Helm: conclua a instalação base do OpenTelemetry no Kubernetes via Helm

Configure o coletor NRDOT

Instale o coletor NRDOT usando manifestos do Kubernetes ou Helm.

Após concluir a instalação do manifesto base do OpenTelemetry no Kubernetes, configure o monitoramento do NGINX seguindo estes passos:

Atualize a imagem do coletor para usar o coletor NRDOT.
Em ambos os arquivos deployment.yaml e daemonset.yaml no seu diretório local rendered, atualize a imagem para:
```
image: newrelic/nrdot-collector:latest
```

Atualize o deployment-configmap.yaml para o monitoramento do NGINX:

Escolha uma das seguintes opções de configuração com base nos seus requisitos de monitoramento:

Importante

Esta opção monitora apenas o NGINX e remove a coleta de outras métricas do Kubernetes. Você excluirá coletores adicionais mais tarde para evitar a ingestão indesejada de métricas.

Substitua o conteúdo em deployment-config.yaml: | pela configuração específica do NGINX abaixo:

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]

Parâmetro de configuração

A tabela a seguir descreve os principais parâmetros de configuração:

Parâmetro	Descrição
`<YOUR_STUB_STATUS_PORT>`	Substitua pela sua porta de status stub do NGINX (por exemplo, 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Substitua pelo seu caminho de status stub do NGINX (por exemplo, basic_status)
`<CLUSTER_NAME>`	Substitua pelo nome do seu cluster do Kubernetes para identificação no New Relic
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	Atualize com o endpoint OTLP da sua região. Consulte a documentação do endpoint OTLP
`app` e `role` rótulos	Rótulos de pod usados para identificar pods NGINX (atualize a regra para corresponder aos seus rótulos)
`collection_interval`	Intervalo em segundos para coletar métricas. O valor padrão é definido como `30s`
`send_batch_max_size`	Número máximo de métricas a serem agrupadas em lote antes de enviar. O valor padrão é definido como `1000`
`timeout`	Tempo limite em segundos para aguardar antes de enviar métricas em lote. O valor padrão é definido como `30s`

Adicione as seguintes seções ao seu deployment-configmap.yaml existente:

Extensões a adicionar:

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

Receptores a adicionar:

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

Processadores a adicionar:

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 serviço a adicionar:

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]

Parâmetro de configuração

A tabela a seguir descreve os principais parâmetros de configuração:

Parâmetro	Descrição
`<YOUR_STUB_STATUS_PORT>`	Substitua pela sua porta de status stub do NGINX (por exemplo, 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Substitua pelo seu caminho de status stub do NGINX (por exemplo, basic_status)
`<CLUSTER_NAME>`	Substitua pelo nome do seu cluster do Kubernetes para identificação no New Relic
`app` e `role` rótulos	Rótulos de pod usados para identificar pods NGINX (atualize a regra para corresponder aos seus rótulos)
`collection_interval`	Intervalo em segundos para coletar métricas. O valor padrão é definido como `30s`
`memory_limiter`	Processador usado na configuração existente do Kubernetes para limitar o uso de memória

Aplique os manifestos atualizados e reinicie a implantação.
1. Para monitoramento apenas do NGINX, execute estes comandos:
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. Para o monitoramento do K8s + NGINX, execute estes comandos:
bash
```
$kubectl apply -n newrelic -R -f rendered
$kubectl rollout restart deployment nr-k8s-otel-collector-deployment -n newrelic
```

Atualize seu values.yaml para o Helm chart nr-k8s-otel-collector com as seguintes alterações:

a. Atualize o repositório da imagem do coletor e a tag para usar o NRDOT:

images:
  collector:
    repository: newrelic/nrdot-collector
    tag: latest

b. Adicione as seguintes seções sob deployment.extraConfig:

Importante

Em deployment.extraConfig, pipelines: deve ser definido no nível raiz — não aninhado sob service:. O template de chart do Helm mapeia extraConfig.pipelines em service.pipelines, e extraConfig.service.extensions em service.extensions.

Extensões:

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

Receptores:

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

Processadores:

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, "")

Extensões de serviço:

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]

Parâmetro de configuração

A tabela a seguir descreve os principais parâmetros de configuração:

Parâmetro	Descrição
`<YOUR_STUB_STATUS_PORT>`	Substitua pela sua porta de status stub do NGINX (por exemplo, 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Substitua pelo seu caminho de status stub do NGINX (por exemplo, basic_status)
`<CLUSTER_NAME>`	Substitua pelo nome do seu cluster do Kubernetes para identificação no New Relic
`app` e `role` rótulos	Rótulos de pod usados para identificar pods NGINX (atualize a regra para corresponder aos seus rótulos)
`collection_interval`	Intervalo em segundos para coletar métricas. O valor padrão é definido como `30s`
`send_batch_max_size`	Número máximo de métricas a serem agrupadas em lote antes de enviar. O valor padrão é definido como `1000`
`timeout`	Tempo limite em segundos para aguardar antes de enviar métricas em lote. O valor padrão é definido como `30s`
`memory_limiter`	Processador usado para limitar o uso de memória. `limit_percentage` define a porcentagem máxima de memória antes do início da limitação

Aplique os valores atualizados à sua release do Helm em execução:

bash

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

Antes de você começar

Certifique-se de ter:

Chave de licençada New Relic válida
Habilite o módulo HTTP stub status no pod do NGINX que precisa ser monitorado
Adicione os rótulos app e role a cada pod NGINX que precisa ser monitorado

Helm instalado

Configurar o coletor OpenTelemetry

Implante o OpenTelemetry Collector em seu cluster Kubernetes usando Helm. O coletor descobrirá e coletará automaticamente métricas de seus pods NGINX.

Baixe ou crie um arquivo values.yaml personalizado com base no values.yaml do OpenTelemetry Collector.

Atualize as seguintes seções no seu arquivo values.yaml:

Definir modo para implantação:
```
mode: deployment
```

Substitua o repositório de imagens:

image:
  repository: otel/opentelemetry-collector-contrib

Configurar a função do 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"]

Configure os limites de recursos:

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

Substitua toda a seção de configuração pela configuração de monitoramento do 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]

Parâmetro de configuração

A tabela a seguir descreve os principais parâmetros de configuração:

Parâmetro	Descrição
`<YOUR_STUB_STATUS_PORT>`	Substitua pela sua porta de status stub do NGINX (por exemplo, 80, 8080)
`<YOUR_STUB_STATUS_PATH>`	Substitua pelo seu caminho de status stub do NGINX (por exemplo, basic_status)
`<CLUSTER_NAME>`	Substitua pelo nome do seu cluster do Kubernetes para identificação no New Relic
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	Atualize com o endpoint OTLP da sua região. Consulte a documentação do endpoint OTLP
`<YOUR_NEW_RELIC_LICENSE_KEY>`	Substitua por sua chave de licença New Relic
`app` e `role` rótulos	Rótulos de pod usados para identificar pods NGINX (atualize a regra para corresponder aos seus rótulos)
`basic_status`	Caminho do endpoint de status stub do NGINX (atualize se estiver usando um caminho diferente)
`collection_interval`	Intervalo em segundos para coletar métricas. O valor padrão é definido como `30s`
`send_batch_size`	Número de métricas a serem agrupadas em lote antes de enviar. O valor padrão é definido como `1024`
`timeout`	Tempo limite em segundos para aguardar antes de enviar métricas em lote. O valor padrão é definido como `30s`

Siga o guia de instalação do chart do Helm do OpenTelemetry Collector para instalar o coletor usando seu arquivo values.yaml personalizado.

Exemplos de comandos:

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

Verifique se os pods estão em execução:
bash
```
$kubectl get pods -n newrelic --watch
```
Você deve ver os pods do OpenTelemetry Collector em um estado Running no namespace newrelic.

Execute uma consulta NRQL no New Relic para verificar a coleta de dados. Substitua o nome do cluster pelo nome real do seu cluster:

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

Visualize seus dados no New Relic

Depois que sua configuração estiver concluída e os dados estiverem fluindo, você poderá acessar suas métricas NGINX nos dashboards do New Relic e criar alertas personalizados.

Para instruções completas sobre como acessar dashboards, consultar dados com NRQL e criar alertas, veja Encontre e consulte seus dados do NGINX.

Referência de métricas e atributos

Esta integração coleta as mesmas métricas principais do NGINX que a implantação no host, com atributos de recursos específicos do Kubernetes adicionais para identificação de cluster, namespace e pod.

Para referência completa de métricas e atributos: Consulte a referência de métricas e atributos do NGINX OpenTelemetry para descrições detalhadas de todas as métricas, tipos e atributos de recurso para implantações do Kubernetes.

Próximos passos

Explore o monitoramento relacionado:

Monitore o NGINX Plus com OpenTelemetry - Para implantações comerciais do NGINX Plus
Monitore o NGINX auto-hospedado com OpenTelemetry - Para implantações de servidor tradicionais

Recursos específicos do Kubernetes:

OpenTelemetry Collector no Kubernetes - Configurações avançadas do coletor

Esta tradução de máquina é fornecida para sua comodidade.

Monitore o NGINX no Kubernetes com OpenTelemetry

Configurar o monitoramento do NGINX

Antes de você começar

Configure o coletor NRDOT

Instalação via manifesto

Monitoramento exclusivo do NGINX

Importante

Parâmetro de configuração

Monitoramento de K8s + NGINX

Parâmetro de configuração

Instalação via Helm

Importante

Parâmetro de configuração

Antes de você começar

Configurar o coletor OpenTelemetry

Etapa 1: criar configuração values.yaml personalizada

Parâmetro de configuração

Passo 2: Instalar com Helm

Etapa 3: verifique a implantação e a coleta de dados

Visualize seus dados no New Relic

Referência de métricas e atributos

Próximos passos

Esta tradução de máquina é fornecida para sua comodidade.

Monitore o NGINX no Kubernetes com OpenTelemetry

Configurar o monitoramento do NGINX .css-21sua1{background:none;border:none;width:0;padding:0;}

Antes de você começar

Configure o coletor NRDOT

Instalação via Helm

Antes de você começar

Configurar o coletor OpenTelemetry

Etapa 1: criar configuração values.yaml personalizada

Passo 2: Instalar com Helm

Etapa 3: verifique a implantação e a coleta de dados

Visualize seus dados no New Relic

Referência de métricas e atributos

Próximos passos

Configurar o monitoramento do NGINX