Monitore o NGINX no Kubernetes com OpenTelemetry

Monitore seus servidores NGINX em execução em clusters Kubernetes para enviar métricas e dados de telemetria para o New Relic.

Você pode escolher entre três opções de coletor:

NRDOT: Distribuição New Relic do OpenTelemetry
OTel Collector Contrib: Coletor OpenTelemetry padrão com componentes contribuídos pela comunidade
Prometheus Receiver: Para ambientes que já executam o nginx-prometheus-exporter como um sidecar

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

Adicione as seguintes seções sob deployment.extraConfig no seu values.yaml:

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

Use esta abordagem se você já tiver o nginx-prometheus-exporter em execução como um sidecar nos seus pods do NGINX, ou se estiver migrando de uma stack de monitoramento baseada no Prometheus.

Dica

Recomendado: se você ainda não tem um exportador Prometheus em execução, use as guias do coletor NRDOT ou do OpenTelemetry Collector Contrib em vez disso. Eles se conectam diretamente ao endpoint de status stub do NGINX sem precisar de um componente exportador adicional.

Antes de você começar

Certifique-se de ter:

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

Helm instalado

Conclua a instalação base do Helm do OpenTelemetry para Kubernetes para nr-k8s-otel-collector antes de prosseguir.

Adicione as seguintes seções sob deployment.configMap.extraConfig no seu values.yaml:

Importante

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

Extensões:

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

Receptores:

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

Processadores:

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

Extensões de serviço:

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

Parâmetro de configuração

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

Parâmetro	Descrição
`<CLUSTER_NAME>`	Nome do seu cluster Kubernetes. Usado para identificação no New Relic.
`<YOUR_LICENSE_KEY>`	Sua chave de licença New Relic.
`app` e `role` rótulos	Rótulos de pod usados para descobrir pods do NGINX. Atualize o `rule` para corresponder aos rótulos do seu pod.
`name == "metrics"`	A porta de contêiner nomeada em `9113` que o receiver_creator monitora. Deve corresponder ao nome da porta na especificação do seu pod.
`scrape_interval`	Com que frequência extrair métricas do Prometheus. Padrão: `30s` .

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

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 do receiver do 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]

Parâmetro de configuração

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

Parâmetro	Descrição
`<CLUSTER_NAME>`	Nome do seu cluster Kubernetes. Usado para identificação no New Relic.
`<YOUR_NEW_RELIC_LICENSE_KEY>`	Sua chave de licença New Relic.
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	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 descobrir pods do NGINX. Atualize o `rule` para corresponder aos rótulos do seu pod.
`name == "metrics"`	A porta de contêiner nomeada em `9113` que o receiver_creator monitora. Deve corresponder ao nome da porta na especificação do seu pod.
`scrape_interval`	Com que frequência extrair métricas do Prometheus. Padrão: `30s` .

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

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

Verifique se os pods do coletor estão em execução:
bash
```
$kubectl get pods -n newrelic --watch
```
Verifique os logs do coletor para confirmar o sucesso na descoberta de pods e no scraping:
bash
```
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector -f
```
Procure linhas que referenciam receiver_creator/nginx_prom descobrindo seus pods do NGINX.

Execute uma consulta NRQL no New Relic para confirmar se os dados estão chegando. Substitua <CLUSTER_NAME> pelo nome do seu cluster:

FROM Metric SELECT *
WHERE metricName LIKE 'nginx.%'
  AND instrumentation.provider = 'opentelemetry'
  AND k8s.cluster.name = '<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

Dica

Antes de você começar

Coletor NRDOT — Instalação do Helm

Importante

Parâmetro de configuração

OTel Collector Contrib — Instalação via Helm

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

Dica

Antes de você começar

Coletor NRDOT — Instalação do Helm

OTel Collector Contrib — Instalação via Helm

Visualize seus dados no New Relic

Referência de métricas e atributos

Próximos passos

Configurar o monitoramento do NGINX