Configurar o ATP para o host

Visualização

Ainda estamos trabalhando nesse recurso, mas adoraríamos que você experimentasse!

Atualmente, esse recurso é fornecido como parte de uma prévia, de acordo com nossas políticas de pré-lançamento.

Saiba como instalar e configurar o Adaptive Telemetry Processor (ATP) com o NRDOT Collector. O ATP está incluído na distribuição padrão do NRDOT para reduzir o volume de dados de telemetria, mantendo a visibilidade crítica.

Opções de instalação

Escolha a abordagem de instalação que corresponde à sua configuração atual:

Antes de você começar

Certifique-se de ter:

Sua chave de licença New Relic
Privilégios de root ou sudo.
Acesso de rede às releases do GitHub

Instalar o host do coletor NRDOT

O ATP vem pré-empacotado com a distribuição do coletor NRDOT. Com base no seu sistema operacional, escolha o método de instalação:

Defina as variáveis de ambiente:
bash
```
$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>" #Fetch the latest version from GitHub releases available at https://github.com/newrelic/nrdot-collector-releases/releases
$export collector_arch="amd64"  # Use 'arm64' for ARM processors
$export license_key="<YOUR_NEW_RELIC_LICENSE_KEY>"
```

Baixe o pacote NRDOT:

bash

$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.deb" \
>  --location \
>  --output collector.deb

Instale o pacote baixado:
bash
```
$sudo dpkg -i collector.deb
```

Configure o coletor NRDOT para usar variáveis de ambiente definidas:

bash

$echo "NEW_RELIC_LICENSE_KEY=${license_key}" | sudo tee -a /etc/${collector_distro}/${collector_distro}.conf > /dev/null

Inicie o serviço de coletor NRDOT:

bash

$sudo systemctl reload-or-restart "${collector_distro}.service"

Defina as variáveis de ambiente:

bash

$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>" #Fetch the latest version from GitHub releases available at https://github.com/newrelic/nrdot-collector-releases/releases
$export collector_arch="x86_64"  # Use 'arm64' for ARM processors
$export license_key="<YOUR_NEW_RELIC_LICENSE_KEY>"

Baixe o pacote NRDOT:

bash

$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.rpm" \
>  --location \
>  --output collector.rpm

Instale o pacote baixado:
bash
```
$sudo rpm -i collector.rpm
```

Configure o coletor NRDOT para usar variáveis de ambiente definidas:

bash

$echo "NEW_RELIC_LICENSE_KEY=${license_key}" | sudo tee -a /etc/${collector_distro}/${collector_distro}.conf > /dev/null

Inicie o serviço de coletor NRDOT:

bash

$sudo systemctl reload-or-restart "${collector_distro}.service"

Defina as variáveis de ambiente:

bash

$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>" #Fetch the latest version from GitHub releases available at https://github.com/newrelic/nrdot-collector-releases/releases
$export collector_arch="amd64"  # Use 'arm64' for ARM processors
$export license_key="<YOUR_NEW_RELIC_LICENSE_KEY>"

Baixe o coletor NRDOT:

bash

$# Download the tarball
$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.tar.gz" \
>  --location \
>  --output collector.tar.gz

Extraia o coletor NRDOT:

bash

$# Extract contents
$tar -xzf collector.tar.gz

Execute o coletor:

bash

$# Run collector in foreground
$NEW_RELIC_LICENSE_KEY="${license_key}" ./nrdot-collector --config ./config.yaml

Configurar ATP

Assim que o coletor NRDOT estiver instalado, edite o arquivo de configuração do coletor para ativar e personalizar o ATP. Os caminhos do arquivo de configuração variam dependendo do seu método de instalação:

Para instalações DEB/RPM, o arquivo de configuração está localizado em /etc/nrdot-collector/config.yaml.
Para instalações manuais de binários, o arquivo de configuração está localizado dentro da pasta extraída.
Para editar o arquivo de configuração:

Abra o arquivo de configuração (config.yaml) com um editor de texto:
- Para instalações DEB/RPM:
bash
```
$sudo nano /etc/nrdot-collector/config.yaml
```
- Para instalações manuais de binários:
bash
```
$nano config.yaml
```
Para coletar as métricas de processo, na seção scrapers do receiver hostmetrics, adicione a seguinte configuração process:
```
receivers:
  hostmetrics:
    scrapers:
      # Your existing scrapers...
      process:
        metrics:
          process.cpu.utilization:
            enabled: true
          process.memory.utilization:
            enabled: true
        mute_process_name_error: true
        mute_process_exe_error: true
        mute_process_io_error: true
        mute_process_user_error: true
```

Para habilitar o ATP, localize a seção processors existente e adicione a configuração adaptivetelemetry abaixo dela:

processors:
  adaptivetelemetry:
    enable_storage: true
    retention_minutes: 30
    include_process_list:
      - "/usr/bin/postgres"
      - "/usr/sbin/nginx" # Replace with your target processes
    metric_thresholds:
      process.cpu.utilization: 0.05     # 5% CPU
      process.memory.utilization: 0.05  # 5% memory

Adicione o processador ATP ao seu pipeline de métricas na seção service:

service:
  pipelines:
    metrics/host:
      receivers: [hostmetrics]
      processors:
        - memory_limiter
        - adaptivetelemetry  # ADD THIS LINE
        - metricstransform
        - filter/exclude_cpu_utilization
        - filter/exclude_memory_utilization

(Opcional) Atualize a configuração do ATP, como limites de métrica, conforme necessário. Para mais detalhes sobre as opções de configuração, consulte os Parâmetros de configuração.
Salve o arquivo de configuração.
Reinicie o coletor NRDOT para aplicar as alterações:
bash
```
$sudo systemctl restart nrdot-collector
```

Acesse os dados do ATP no New Relic

Assim que o ATP for configurado, ele começa a coletar dados do seu host Linux. Você pode acessar esses dados na interface do New Relic OpenTelemetry. Para mais informações sobre a interface do usuário do New Relic OpenTelemetry, consulte OpenTelemetry APM UI.

Para visualizar os dados de métrica do processo ATP no New Relic:

Vá para one.newrelic.com > All Entities.
OU
Vá para one.newrelic.com > Catalogs > Infrastructure.
Pesquise a entidade onde você instalou o coletor NRDOT com ATP.
Selecione a entidade e clique em Process no painel esquerdo.
Na página Process, você pode visualizar todos os processos em execução no seu host, juntamente com seus IDs e métricas de utilização de CPU e memória. Ele também exibe a relação pai-filho entre processos se um processo gerar outros processos.

Antes de você começar

Certifique-se de ter:

NRDOT Collector existente versão 1.11.0 ou posterior
Sua chave de licença New Relic
Privilégios de root ou sudo
Backup da configuração atual

Fazer backup da configuração atual

Salve suas configurações atuais antes de prosseguir:

bash

$sudo cp /etc/nrdot-collector/config.yaml /etc/nrdot-collector/config.yaml.bak

Atualizar o coletor NRDOT

Para atualizar o coletor NRDOT para a versão mais recente com suporte ao ATP, execute novamente os comandos de instalação da versão mais recente. Isso sobrescreverá o binário antigo, preservando seu arquivo de configuração existente.

Defina as variáveis de ambiente:

bash

$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>" #Fetch the latest version from GitHub releases available at https://github.com/newrelic/nrdot-collector-releases/releases
$export collector_arch="amd64"  # Use 'arm64' for ARM processors

Baixe a versão mais recente do coletor NRDOT:

bash

$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.deb" \
>  --location \
>  --output collector.deb

Instale o pacote do coletor NRDOT baixado:
bash
```
$sudo dpkg -i collector.deb
```

Defina as variáveis de ambiente:

bash

$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>"
$export collector_arch="x86_64"  # Use 'arm64' for ARM processors

Baixe a versão mais recente do coletor NRDOT:

bash

$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.rpm" \
>  --location \
>  --output collector.rpm

Instale o pacote do coletor NRDOT baixado:
bash
```
$sudo rpm -U collector.rpm
```

Pare o coletor em execução e faça o backup da sua configuração:
bash
```
$pkill -f nrdot-collector
$cp config.yaml config.yaml.bak
```
Siga as etapas de instalação na aba New Installation → seção For manual binary para concluir as etapas restantes.
Cuidado
Isso sobrescreverá seu config.yaml atual, e é por isso que o backup na Etapa 1 foi necessário.

Configurar ATP

A atualização preservou suas configurações anteriores, então seu config.yaml ainda não contém as novas configurações de ATP. Você deve adicioná-los manualmente.

Para editar o arquivo de configuração:

Abra o arquivo de configuração (config.yaml) com um editor de texto usando privilégios de root ou sudo:
- Para instalações DEB/RPM:
bash
```
$sudo nano /etc/nrdot-collector/config.yaml
```
- Para instalações manuais de binários:
bash
```
$nano config.yaml
```

Para coletar as métricas de processo, na seção scrapers do receiver hostmetrics, adicione a seguinte configuração process:

processes:
process:
  metrics:
    process.cpu.utilization:
      enabled: true
    process.memory.utilization:
      enabled: true
  mute_process_name_error: true
  mute_process_exe_error: true
  mute_process_io_error: true
  mute_process_user_error: true

Para habilitar o ATP, localize a seção processors existente e adicione a configuração adaptivetelemetry abaixo dela:

processors:
  # Your existing processors...
  adaptivetelemetry:
    enable_storage: true
    retention_minutes: 30
    include_process_list:
      - "/usr/bin/postgres"
      - "/usr/sbin/nginx" # Replace with your target processes
    metric_thresholds:
      process.cpu.utilization: 0.05     # 5% CPU
      process.memory.utilization: 0.05  # 5% memory

Adicione o processador ATP ao seu pipeline de métricas na seção service:

service:
  pipelines:
    metrics/host:
      receivers: [hostmetrics]
      processors:
        - memory_limiter
        - adaptivetelemetry  # ADD THIS LINE
        - metricstransform
        - filter/exclude_cpu_utilization
        - filter/exclude_memory_utilization

(Opcional) Atualize a configuração do ATP, como limites de métrica, conforme necessário. Para mais detalhes sobre as opções de configuração, consulte os Parâmetros de configuração.
Salve o arquivo de configuração.
Reinicie o coletor NRDOT para aplicar as alterações:
bash
```
$sudo systemctl restart nrdot-collector
```

Acesse os dados do ATP no New Relic

Para visualizar os dados de métrica do processo ATP no New Relic:

Vá para one.newrelic.com > All Entities.
OU
Vá para one.newrelic.com > Catalogs > Infrastructure.
Pesquise a entidade onde você instalou o coletor NRDOT com ATP.
Selecione a entidade e clique em Process no painel esquerdo.
Na página Process, você pode visualizar todos os processos em execução no seu host, juntamente com seus IDs e métricas de utilização de CPU e memória. Ele também exibe a relação pai-filho entre processos se um processo gerar outros processos.

Para instalar o ATP migrando do agente de infraestrutura nativo da New Relic para a distribuição de host do coletor NRDOT, você precisa desinstalar o agente nativo e configurar o NRDOT com o ATP.

Antes de você começar

Certifique-se de ter:

Sua chave de licença New Relic
Privilégios de root ou sudo
Planeje para uma interrupção mínima do serviço

Parar e desabilitar o agente nativo

Para parar o agente de infraestrutura existente para evitar conflito de dados, execute:
bash
```
$# Stop the service
$sudo systemctl stop newrelic-infra
```
Para desabilitar a inicialização do agente de infraestrutura no boot, execute:
bash
```
$# Disable from starting on boot
$sudo systemctl disable newrelic-infra
```

Instalar o host do coletor NRDOT

O ATP vem pré-empacotado com a distribuição do coletor NRDOT. Com base no seu sistema operacional, escolha o método de instalação:

Defina as variáveis de ambiente:

bash

$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>" #Fetch the latest version from GitHub releases available at https://github.com/newrelic/nrdot-collector-releases/releases
$export collector_arch="amd64"  # Use 'arm64' for ARM processors
$export license_key="<YOUR_NEW_RELIC_LICENSE_KEY>"

Baixe o pacote NRDOT:

bash

$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.deb" \
>  --location \
>  --output collector.deb

Instale o pacote baixado:
bash
```
$sudo dpkg -i collector.deb
```

Configure o coletor NRDOT para usar variáveis de ambiente definidas:

bash

$echo "NEW_RELIC_LICENSE_KEY=${license_key}" | sudo tee -a /etc/${collector_distro}/${collector_distro}.conf > /dev/null

Inicie o serviço de coletor NRDOT:

bash

$sudo systemctl reload-or-restart "${collector_distro}.service"

Defina as variáveis de ambiente:

bash

$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>" #Fetch the latest version from GitHub releases available at https://github.com/newrelic/nrdot-collector-releases/releases
$export collector_arch="x86_64"  # Use 'arm64' for ARM processors
$export license_key="<YOUR_NEW_RELIC_LICENSE_KEY>"

Baixe o pacote NRDOT:

bash

$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.rpm" \
>  --location \
>  --output collector.rpm

Instale o pacote baixado:
bash
```
$sudo rpm -i collector.rpm
```

Configure o coletor NRDOT para usar variáveis de ambiente definidas:

bash

$echo "NEW_RELIC_LICENSE_KEY=${license_key}" | sudo tee -a /etc/${collector_distro}/${collector_distro}.conf > /dev/null

Inicie o serviço de coletor NRDOT:

bash

$sudo systemctl reload-or-restart "${collector_distro}.service"

Defina as variáveis de ambiente:

bash

$export collector_distro="nrdot-collector"
$export collector_version="<NRDOT_COLLECTOR_LATEST_VERSION>" #Fetch the latest version from GitHub releases available at https://github.com/newrelic/nrdot-collector-releases/releases
$export collector_arch="amd64"  # Use 'arm64' for ARM processors
$export license_key="<YOUR_NEW_RELIC_LICENSE_KEY>"

Baixe o coletor NRDOT:

bash

$# Download the tarball
$curl "https://github.com/newrelic/nrdot-collector-releases/releases/download/${collector_version}/${collector_distro}_${collector_version}_linux_${collector_arch}.tar.gz" \
>  --location \
>  --output collector.tar.gz

Extraia o coletor NRDOT:

bash

$# Extract contents
$tar -xzf collector.tar.gz

Execute o coletor:

bash

$# Run collector in foreground
$NEW_RELIC_LICENSE_KEY="${license_key}" ./nrdot-collector --config ./config.yaml

Configurar ATP

Para instalações DEB/RPM, o arquivo de configuração está localizado em /etc/nrdot-collector/config.yaml.
Para instalações manuais de binários, o arquivo de configuração está localizado dentro da pasta extraída.
Para editar o arquivo de configuração:

Abra o arquivo de configuração (config.yaml) com um editor de texto:
- Para instalações DEB/RPM:
bash
```
$sudo nano /etc/nrdot-collector/config.yaml
```
- Para instalações manuais de binários:
bash
```
$nano config.yaml
```

Para coletar as métricas de processo, na seção scrapers do receiver hostmetrics, adicione a seguinte configuração process:

receivers:
  hostmetrics:
    scrapers:
      # Your existing scrapers...
      process:
        metrics:
          process.cpu.utilization:
            enabled: true
          process.memory.utilization:
            enabled: true
        mute_process_name_error: true
        mute_process_exe_error: true
        mute_process_io_error: true
        mute_process_user_error: true

Para habilitar o ATP, localize a seção processors existente e adicione a configuração adaptivetelemetry abaixo dela:

processors:
  adaptivetelemetry:
    enable_storage: true
    retention_minutes: 30
    include_process_list:
      - "/usr/bin/postgres"
      - "/usr/sbin/nginx" # Replace with your target processes
    metric_thresholds:
      process.cpu.utilization: 0.05     # 5% CPU
      process.memory.utilization: 0.05  # 5% memory

Adicione o processador ATP ao seu pipeline de métricas na seção service:

service:
  pipelines:
    metrics/host:
      receivers: [hostmetrics]
      processors:
        - memory_limiter
        - adaptivetelemetry  # ADD THIS LINE
        - metricstransform
        - filter/exclude_cpu_utilization
        - filter/exclude_memory_utilization

(Opcional) Atualize a configuração do ATP, como limites de métrica, conforme necessário. Para mais detalhes sobre as opções de configuração, consulte os Parâmetros de configuração.
Salve o arquivo de configuração.
Reinicie o coletor NRDOT para aplicar as alterações:
bash
```
$sudo systemctl restart nrdot-collector
```

Verificar migração

Assim que a instalação for concluída com sucesso, verifique se os dados estão fluindo para o New Relic:

Para verificar o status do serviço, execute:
bash
```
$sudo systemctl status nrdot-collector
```
Para verificar os logs, execute:
bash
```
$sudo journalctl -u nrdot-collector -f
```

Acesse os dados do ATP no New Relic

Para visualizar os dados de métrica do processo ATP no New Relic:

Vá para one.newrelic.com > All Entities.
OU
Vá para one.newrelic.com > Catalogs > Infrastructure.
Pesquise a entidade onde você instalou o coletor NRDOT com ATP.
Selecione a entidade e clique em Process no painel esquerdo.
Na página Process, você pode visualizar todos os processos em execução no seu host, juntamente com seus IDs e métricas de utilização de CPU e memória. Ele também exibe a relação pai-filho entre processos se um processo gerar outros processos.

Configuração de armazenamento

O ATP usa armazenamento persistente para manter o estado do processo entre reinicializações do coletor. Os caminhos de armazenamento são selecionados automaticamente com base no seu ambiente de execução:

Instalações de serviço Systemd (pacotes DEB/RPM)

Quando executado como um serviço systemd, o ATP usa automaticamente /var/lib/nrdot-collector/ para armazenamento. A configuração do serviço systemd inclui StateDirectory=nrdot-collector que:

Cria automaticamente o diretório com a propriedade correta (usuário/grupo nrdot-collector)
Define permissões seguras (0700)
Não é necessária a criação manual de diretório ou configuração de permissão.

Instalação manual de binários

Ao executar como um usuário comum, o binário do coletor usa automaticamente o caminho padrão XDG -/.local/state/nrdot-collector/, permitindo que o ATP funcione sem privilégios de root.

Comportamento de fallback

Se nenhum dos locais de armazenamento for gravável (por exemplo, devido a problemas de permissão), o ATP desabilita automaticamente o armazenamento e continua operando apenas com o estado em memória. O recurso de retenção funciona normalmente durante o tempo de execução, rastreando processos que excedem os limites para o retention_minutes configurado. No entanto, esse estado de rastreamento é perdido nas reinicializações do coletor, pois não é persistido em disco.

Dica

Para instalações do systemd, você não precisa criar manualmente diretórios de armazenamento ou configurar permissões. O serviço gerencia isso automaticamente para você.

Parâmetro de configuração

Parâmetro	Tipo	Padrão	Descrição
`enable_storage`	boleano	`true`	Habilite o armazenamento persistente. Os caminhos de armazenamento são determinados automaticamente com base no contexto de execução: Serviço systemd do Linux: `/var/lib/nrdot-collector/adaptiveprocess.db` (gerenciado automaticamente pelo systemd) Binário manual do Linux: `~/.local/state/nrdot-collector/adaptiveprocess.db` (padrão XDG, não requer root) Windows: `%LOCALAPPDATA%\nrdot-collector\adaptiveprocess.db` Se nenhum caminho gravável estiver disponível, o armazenamento é desabilitado automaticamente e o ATP opera apenas com estado em memória (a retenção funciona durante o tempo de execução, mas o estado é perdido nas reinicializações).
`retention_minutes`	inteiro	`30`	Por quanto tempo reter o estado do processo em minutos
`include_process_list`	matriz	`[]`	Nomes de processos a serem sempre incluídos (ignora a filtragem)
`metric_thresholds`	map	`{}`	Limites estáticos por tipo de métrica

Parâmetro	Tipo	Padrão	Descrição
`enable_dynamic_thresholds`	boleano	`false`	Habilitar ajuste de limite adaptativo
`dynamic_smoothing_factor`	float	`0.1`	Fator de suavização para adaptação de limiar (0.0-1.0)
`min_thresholds`	map	`{}`	Valores de limiar mínimo por métrica
`max_thresholds`	map	`{}`	Valores máximos de limite por métrica

Parâmetro	Tipo	Padrão	Descrição
`enable_multi_metric`	boleano	`false`	Habilitar pontuação composta em métricas
`composite_threshold`	float	`1.5`	Limiar para avaliação da pontuação composta. Esta pontuação deve ser maior que `0.0`
`weights`	map	`{}`	Valores de peso por métrica para pontuação composta

Parâmetro	Tipo	Padrão	Descrição
`enable_anomaly_detection`	boleano	`false`	Ativar camada de detecção de anomalias
`anomaly_history_size`	inteiro	`15`	Número de pontos de dados históricos para rastrear
`anomaly_change_threshold`	float	`50.0`	Limite de variação percentual para anomalias
`anomaly_min_data_points`	inteiro	`3`	Mínimo de pontos de dados necessários antes da detecção de anomalias

Resolução de problemas

Saiba como solucionar problemas de ATP no seu ambiente.

Consulte seus dados

Saiba como consultar dados de ATP no New Relic usando NRQL.

Recursos-avançados

Saiba como ativar recursos avançados para sua implantação do ATP.

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

Visualização

Opções de instalação .css-21sua1{background:none;border:none;width:0;padding:0;}

Antes de você começar

Instalar o host do coletor NRDOT

Para RHEL/CentOS

Para binário manual

Configurar ATP

Acesse os dados do ATP no New Relic

Antes de você começar

Fazer backup da configuração atual

Atualizar o coletor NRDOT

Para Debian/Ubuntu

Para RHEL/CentOS

Para binário manual

Configurar ATP

Acesse os dados do ATP no New Relic

Antes de você começar

Parar e desabilitar o agente nativo

Instalar o host do coletor NRDOT

Para Debian/Ubuntu

Para RHEL/CentOS

Para binário manual

Configurar ATP

Verificar migração

Acesse os dados do ATP no New Relic

Configuração de armazenamento

Instalações de serviço Systemd (pacotes DEB/RPM)

Instalação manual de binários

Comportamento de fallback

Dica

Parâmetro de configuração

Configurações principais

Limiares dinâmicos

Pontuação composta multimétrica

Detecção de anomalia

Recursos relacionados

Resolução de problemas

Consulte seus dados

Recursos-avançados

Opções de instalação