Monitore o Redis com o Docker Compose (OpenTelemetry)

Monitore suas instâncias do Redis usando o Docker Compose implantando o OpenTelemetry Collector como um contêiner junto ao seu Redis existente.

Antes de você começar

Você precisará do seguinte antes de configurar o coletor:

Docker e Docker Compose (v2 ou posterior) instalados
Seu New Relic
Redis em execução e acessível — versão 6.0 ou posterior recomendada (4.0 e posterior funciona com um conjunto reduzido de métricas)
HTTPS de saída (porta 443) para o endpoint OTLPda New Relic

Escolha a distribuição do seu coletor em Opções de instalação: o coletor NRDOT, o OpenTelemetry Collector Contrib ou o receptor Prometheus. O arquivo Docker Compose de cada caminho extrai as imagens de que precisa, incluindo o redis_exporter para o caminho do receptor Prometheus.

Opções de instalação

Crie a configuração do coletor

Esta configuração informa ao coletor como coletar métricas do Redis e enviá-las para o New Relic. Ele realiza três tarefas principais:

Colete métricas do Redis através do receptor redis
Molde os dados — reduza a cardinalidade, converta contadores em deltas e adicione tags para a síntese de entidade

Exporte as métricas processadas para o New Relic via OTLP

Crie otel-collector-config.yaml no diretório do seu projeto:

extensions:
  health_check:
    endpoint: "0.0.0.0:13133"

receivers:
  redis:
    endpoint: "redis:6379"  # Update with your Redis service name:port
    collection_interval: 10s
    metrics:
      redis.maxmemory:
        enabled: true
      redis.role:
        enabled: false
      redis.cmd.calls:
        enabled: true
      redis.cmd.usec:
        enabled: true
      redis.clients.max_input_buffer:
        enabled: false
      redis.clients.max_output_buffer:
        enabled: false
      redis.replication.backlog_first_byte_offset:
        enabled: false
    resource_attributes:
      server.address:
        enabled: true
      server.port:
        enabled: true

processors:
  memory_limiter:
    check_interval: 5s
    limit_mib: 512
    spike_limit_mib: 128

  resource_detection:
    detectors: [env, system]
    timeout: 5s
    override: false
    system:
      resource_attributes:
        host.name:
          enabled: true
        host.id:
          enabled: true

  # Uncomment the section below to use a custom human-readable name for your
  # Redis entity instead of the default server.address:server.port identifier.
  # resource/redis:
  #   attributes:
  #     - key: redis.instance.id
  #       value: "my-redis-instance"
  #       action: upsert

  attributes/entity_tags:
    actions:
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

  cumulativetodelta:
    include:
      match_type: regexp
      metrics:
        - redis\.commands\.processed
        - redis\.connections\.received
        - redis\.connections\.rejected
        - redis\.keys\.evicted
        - redis\.keys\.expired
        - redis\.keyspace\.hits
        - redis\.keyspace\.misses
        - redis\.net\.input
        - redis\.net\.output
        - redis\.cpu\.time
        - redis\.cmd\.calls
        - redis\.cmd\.usec
        - redis\.uptime

  filter/cardinality:
    metrics:
      datapoint:
        - 'metric.name == "redis.cpu.time" and attributes["state"] != "sys" and attributes["state"] != "user"'
        - 'metric.name == "redis.cmd.calls" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'
        - 'metric.name == "redis.cmd.usec" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'

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

  batch:
    send_batch_size: 2048
    send_batch_max_size: 4096
    timeout: 10s

exporters:
  otlp_http:
    endpoint: ${env:OTEL_EXPORTER_OTLP_ENDPOINT}
    headers:
      api-key: ${env:NEW_RELIC_LICENSE_KEY}
    compression: gzip

service:
  extensions: [health_check]
  pipelines:
    metrics/redis:
      receivers: [redis]
      # If using resource/redis for custom name, add it to the processors list:
      # processors: [memory_limiter, resource_detection, resource/redis, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]

O que esta configuração faz

Cada componente no pipeline tem uma função específica:

Componente	Descrição
`health_check`	Expõe um endpoint de integridade em `0.0.0.0:13133` para que você possa confirmar que o coletor está em execução.
`redis` receptor	Conecta-se ao seu endpoint do Redis a cada 10 segundos e lê métricas do comando `INFO` do Redis. `server.address` e `server.port` se tornam a identidade da entidade.
`memory_limiter`	Limita o uso de memória do coletor (limite flexível de 512 MiB, pico de 128 MiB) para proteger o contêiner.
`resource_detection`	Detecta o host e adiciona `host.name` e `host.id`, vinculando as métricas do Redis à entidade de host subjacente.
`attributes/entity_tags`	Marca `instrumentation.provider: opentelemetry` em cada métrica para que você possa definir o escopo das consultas para o caminho do OpenTelemetry.
`cumulativetodelta`	Converte os contadores cumulativos do Redis — comandos, acertos de keyspace, remoções e assim por diante — em valores delta para que o New Relic gere gráficos de taxas corretamente.
`filter/cardinality`	Descarta pontos de dados de cardinalidade alta (estados de CPU diferentes de `user` e `sys`, e métricas por comando para comandos incomuns) para controlar o custo de ingestão.
`transform/metadata_nullify`	Limpa as descrições e unidades de métricas para reduzir o tamanho da carga.
`batch`	Agrupa pontos de dados antes da exportação (2.048 por lote, até 4.096) e descarrega pelo menos a cada 10 segundos para reduzir a sobrecarga de rede.
`otlp_http`	Exporta as métricas processadas para o New Relic via OTLP com compactação gzip, autenticadas com sua chave de licença.

Dica

Deseja um nome de entidade amigável para o usuário? Por padrão, sua entidade do Redis é nomeada usando a combinação server.address:server.port. Para usar um nome legível por humanos personalizado, descomente a seção resource/redis na configuração acima, defina seu nome preferido no valor redis.instance.id e adicione resource/redis ao pipeline de processadores.

Opcional: configurar autenticação

Por padrão, o coletor se conecta ao Redis sem credenciais. Se a sua instância do Redis exigir autenticação, adicione as credenciais correspondentes ao receptor redis. Escolha a opção que corresponde à sua configuração:

receivers:
  redis:
    endpoint: "redis:6379"
    password: "${env:REDIS_PASSWORD}"

Adicione REDIS_PASSWORD ao seu arquivo .env:

bash

$REDIS_PASSWORD=your-redis-password

receivers:
  redis:
    endpoint: "redis:6379"
    username: "${env:REDIS_USERNAME}"
    password: "${env:REDIS_PASSWORD}"

Adicione ao seu arquivo .env:

bash

$REDIS_USERNAME=otel-monitor
$REDIS_PASSWORD=your-monitor-password

receivers:
  redis:
    endpoint: "redis:6380"
    password: "${env:REDIS_PASSWORD}"
    tls:
      insecure: false
      ca_file: /etc/ssl/redis/ca.crt
      cert_file: /etc/ssl/redis/client.crt
      key_file: /etc/ssl/redis/client.key

Opcional: coletar logs do Redis

Além das métricas, o coletor pode encaminhar o arquivo de log do Redis para a New Relic para que você possa correlacionar eventos de log — reinicializações, eventos de persistência ou erros — com picos de métricas na mesma entidade.

Importante

Por padrão, o Redis no Docker registra logs no stdout (não em um arquivo). Para coletar logs com o receptor filelog, você deve configurar o Redis para gravar em um arquivo de log e compartilhá-lo por meio de um volume do Docker entre os contêineres do Redis e do coletor.

Adicione isso ao seu serviço Redis em docker-compose.yml:

redis:
    image: redis:7
    command: >
      sh -c "touch /data/redis.log && chmod 644 /data/redis.log && redis-server --logfile /data/redis.log"
    volumes:
      - redis-logs:/data

E adicione o volume compartilhado ao seu serviço do coletor:

otel-collector:
    volumes:
      - redis-logs:/var/log/redis:ro

Em seguida, adicione no final do seu docker-compose.yml:

volumes:
  redis-logs:

Adicione o receptor filelog ao seu otel-collector-config.yaml:

receivers:
  # ... existing redis receiver ...
  file_log/redis:
    include:
      - /var/log/redis/redis.log
    start_at: end
    operators:
      - type: regex_parser
        regex: '^\d+:[XCSM] \d+ \w+ \d+ \d+:\d+:\d+\.\d+ (?P<level>.) '
        on_error: send
    resource:
      db.system: redis

As linhas de log do arquivo não têm contexto de conexão do Redis por si só — você deve anexar explicitamente atributos de identidade para que o New Relic associe os logs à sua entidade do Redis. Adicione um processador resource/redis_logs com valores fixos correspondentes à identidade da sua entidade do Redis:

processors:
  # ... existing processors ...
  resource/redis_logs:
    attributes:
      - key: server.address
        value: "redis"  # Must match your redis receiver endpoint host
        action: upsert
      - key: server.port
        value: 6379  # Must match your redis receiver endpoint port
        action: upsert
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

Dica

Usando um ID da instância personalizado? Se você ativou o processador resource/redis para nomenclatura de entidade personalizada, substitua server.address e server.port acima pelo seu redis.instance.id:

resource/redis_logs:
    attributes:
      - key: redis.instance.id
        value: "my-redis-instance"  # Must match the value in resource/redis
        action: upsert
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

Adicione um pipeline de logs separado à seção de serviço:

service:
  pipelines:
    metrics/redis:
      receivers: [redis]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]
    logs/redis:
      receivers: [file_log/redis]
      processors: [memory_limiter, resource/redis_logs, batch]
      exporters: [otlp_http]

Importante

O contêiner do coletor deve ter acesso de leitura ao arquivo de log do Redis. Ao montar o diretório de log no seu contêiner, certifique-se de que o arquivo seja legível pelo processo do coletor. No host, execute:

bash

$sudo chmod 755 /var/log/redis
$sudo chmod 644 /var/log/redis/redis.log

Opcional: coletar métricas do host

O desempenho do Redis geralmente acompanha a pressão dos recursos do host — saturação de CPU, esgotamento de memória ou contenção de I/O de disco. Adicione o receptor hostmetrics para coletar métricas do sistema junto com o Redis para que você possa correlacionar os dois no New Relic. A configuração root_path: /hostfs é necessária ao executar dentro de um contêiner Docker para que o coletor leia o sistema de arquivos do host, não o do contêiner:

receivers:
  # ... existing receivers ...
  host_metrics:
    collection_interval: 10s
    root_path: /hostfs
    scrapers:
      cpu:
        metrics:
          system.cpu.utilization: {enabled: true}
          system.cpu.time: {enabled: true}
      load:
        metrics:
          system.cpu.load_average.1m: {enabled: true}
          system.cpu.load_average.5m: {enabled: true}
          system.cpu.load_average.15m: {enabled: true}
      memory:
        metrics:
          system.memory.usage: {enabled: true}
          system.memory.utilization: {enabled: true}
      disk:
        metrics:
          system.disk.io: {enabled: true}
          system.disk.operations: {enabled: true}
      filesystem:
        metrics:
          system.filesystem.usage: {enabled: true}
          system.filesystem.utilization: {enabled: true}
      network:
        metrics:
          system.network.io: {enabled: true}
          system.network.packets: {enabled: true}

Adicione um pipeline metrics/host separado para métricas de host (não adicione host_metrics ao pipeline do Redis):

service:
  pipelines:
    metrics/redis:
      receivers: [redis]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]
    metrics/host:
      receivers: [host_metrics]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, batch]
      exporters: [otlp_http]

Opcional: Adicionar metadados personalizados

Atributos de recurso personalizados adicionam tags a cada métrica do Redis com contexto — ambiente, equipe ou nível — para que você possa filtrar e agrupar seus dados na New Relic. Adicione um processador resource/custom com as tags que você deseja:

processors:
  # ... existing processors ...
  resource/custom:
    attributes:
      - key: environment
        value: "production"
        action: upsert
      - key: team
        value: "platform"
        action: upsert

Inclua o processador no seu pipeline:

service:
  pipelines:
    metrics/redis:
      receivers: [redis]
      processors: [memory_limiter, resource_detection, resource/custom, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]

Opcional: habilite o monitoramento do Redis Cluster

Atualmente, o monitoramento do Redis Cluster requer a abordagem do receiver do Prometheus (usando redis_exporter). O receiver nativo do Redis do NRDOT Collector ainda não oferece suporte ao comando CLUSTER INFO necessário para as métricas do cluster. Use a aba Prometheus receiver para a configuração de monitoramento do cluster.

Crie o arquivo do Docker Compose

Crie docker-compose.yml para executar o coletor junto com o seu Redis existente. O arquivo .env no mesmo diretório é carregado automaticamente pelo Docker Compose:

services:
  otel-collector:
    image: newrelic/nrdot-collector:latest
    env_file: .env
    volumes:
      - ./otel-collector-config.yaml:/etc/otel/config.yaml:ro
      - /etc/machine-id:/etc/machine-id:ro
      # Uncomment if collecting Redis logs (requires shared volume — see logs step above):
      # - redis-logs:/var/log/redis:ro
      # Uncomment if collecting host metrics:
      # - /:/hostfs:ro
      # Uncomment if using TLS:
      # - ./certs:/etc/ssl/redis:ro
    environment:
      - NEW_RELIC_LICENSE_KEY=${NEW_RELIC_LICENSE_KEY}
      - OTEL_EXPORTER_OTLP_ENDPOINT=${OTEL_EXPORTER_OTLP_ENDPOINT}
      # Uncomment if collecting host metrics:
      # - HOST_PROC=/hostfs/proc
      # - HOST_SYS=/hostfs/sys
      # - HOST_ETC=/hostfs/etc
      # Uncomment if using Redis authentication:
      # - REDIS_PASSWORD=${REDIS_PASSWORD}
      # - REDIS_USERNAME=${REDIS_USERNAME}
    command: ["--config=/etc/otel/config.yaml"]
    ports:
      - "13133:13133"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:13133"]
      interval: 10s
      timeout: 5s
      retries: 3

# Uncomment if collecting Redis logs:
# volumes:
#   redis-logs:

Dica

Se você ativou quaisquer recursos opcionais (logs, métricas de host, TLS ou autenticação) nos passos anteriores, remova o comentário das linhas correspondentes no arquivo do Docker Compose acima.

Crie o arquivo de ambiente

O Docker Compose lê valores específicos da implantação de um arquivo .env no mesmo diretório que o seu docker-compose.yml, o que mantém a sua chave de licença fora do arquivo do compose. Crie o arquivo .env:

bash

$NEW_RELIC_LICENSE_KEY=YOUR_LICENSE_KEY
$OTEL_EXPORTER_OTLP_ENDPOINT=YOUR_OTLP_ENDPOINT
$# Set the New Relic OTLP endpoint for your region.
$# See https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp

Substitua os espaços reservados pelos seus próprios valores:

Variável	Obrigatório	Descrição
`NEW_RELIC_LICENSE_KEY`	Sim	Sua chave de licença de ingestão da New Relic.
`OTEL_EXPORTER_OTLP_ENDPOINT`	Sim	Endpoint OTLP da New Relic para sua região. Para mais informações, consulte o endpoint OTLP da New Relic.

Inicie e verifique

Inicie o coletor em segundo plano:

bash

$docker compose up -d

Confirme se os contêineres estão em execução com docker compose ps — o coletor deve mostrar um status running. Se ele foi encerrado, verifique seus logs com docker compose logs otel-collector — as causas mais comuns são erros de indentação YAML e um endpoint do Redis inacessível.

Em seguida, confirme se suas métricas estão chegando à New Relic. Aguarde cerca de um minuto após a inicialização e, em seguida, execute esta consulta no criador de consulta:

SELECT count(*) FROM Metric WHERE metricName LIKE 'redis.%' AND instrumentation.provider = 'opentelemetry' SINCE 5 minutes ago

Uma contagem diferente de zero confirma que as métricas do Redis estão fluindo. Se retornar 0, consulte Solucionar problemas do Redis (OpenTelemetry).

Crie a configuração do coletor

Esta configuração informa ao coletor como coletar métricas do Redis e enviá-las para o New Relic. Ele realiza três tarefas principais:

Colete métricas do Redis através do receptor redis
Molde os dados — reduza a cardinalidade, converta contadores em deltas e adicione tags para a síntese de entidade

Exporte as métricas processadas para o New Relic via OTLP

Crie otel-collector-config.yaml no diretório do seu projeto:

extensions:
  health_check:
    endpoint: "0.0.0.0:13133"

receivers:
  redis:
    endpoint: "redis:6379"  # Update with your Redis service name:port
    collection_interval: 10s
    metrics:
      redis.maxmemory:
        enabled: true
      redis.role:
        enabled: false
      redis.cmd.calls:
        enabled: true
      redis.cmd.usec:
        enabled: true
      redis.clients.max_input_buffer:
        enabled: false
      redis.clients.max_output_buffer:
        enabled: false
      redis.replication.backlog_first_byte_offset:
        enabled: false
    resource_attributes:
      server.address:
        enabled: true
      server.port:
        enabled: true

processors:
  memory_limiter:
    check_interval: 5s
    limit_mib: 512
    spike_limit_mib: 128

  resource_detection:
    detectors: [env, system]
    timeout: 5s
    override: false
    system:
      resource_attributes:
        host.name:
          enabled: true
        host.id:
          enabled: true

  # Uncomment the section below to use a custom human-readable name for your
  # Redis entity instead of the default server.address:server.port identifier.
  # resource/redis:
  #   attributes:
  #     - key: redis.instance.id
  #       value: "my-redis-instance"
  #       action: upsert

  attributes/entity_tags:
    actions:
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

  cumulativetodelta:
    include:
      match_type: regexp
      metrics:
        - redis\.commands\.processed
        - redis\.connections\.received
        - redis\.connections\.rejected
        - redis\.keys\.evicted
        - redis\.keys\.expired
        - redis\.keyspace\.hits
        - redis\.keyspace\.misses
        - redis\.net\.input
        - redis\.net\.output
        - redis\.cpu\.time
        - redis\.cmd\.calls
        - redis\.cmd\.usec
        - redis\.uptime

  filter/cardinality:
    metrics:
      datapoint:
        - 'metric.name == "redis.cpu.time" and attributes["state"] != "sys" and attributes["state"] != "user"'
        - 'metric.name == "redis.cmd.calls" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'
        - 'metric.name == "redis.cmd.usec" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'

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

  batch:
    send_batch_size: 2048
    send_batch_max_size: 4096
    timeout: 10s

exporters:
  otlp_http:
    endpoint: ${env:OTEL_EXPORTER_OTLP_ENDPOINT}
    headers:
      api-key: ${env:NEW_RELIC_LICENSE_KEY}
    compression: gzip

service:
  extensions: [health_check]
  pipelines:
    metrics/redis:
      receivers: [redis]
      # If using resource/redis for custom name, add it to the processors list:
      # processors: [memory_limiter, resource_detection, resource/redis, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]

O que esta configuração faz

Cada componente no pipeline tem uma função específica:

Componente	Descrição
`health_check`	Expõe um endpoint de integridade em `0.0.0.0:13133` para que você possa confirmar que o coletor está em execução.
`redis` receptor	Conecta-se ao seu endpoint do Redis a cada 10 segundos e lê métricas do comando `INFO` do Redis. `server.address` e `server.port` se tornam a identidade da entidade.
`memory_limiter`	Limita o uso de memória do coletor (limite flexível de 512 MiB, pico de 128 MiB) para proteger o contêiner.
`resource_detection`	Detecta o host e adiciona `host.name` e `host.id`, vinculando as métricas do Redis à entidade de host subjacente.
`attributes/entity_tags`	Marca `instrumentation.provider: opentelemetry` em cada métrica para que você possa definir o escopo das consultas para o caminho do OpenTelemetry.
`cumulativetodelta`	Converte os contadores cumulativos do Redis — comandos, acertos de keyspace, remoções e assim por diante — em valores delta para que o New Relic gere gráficos de taxas corretamente.
`filter/cardinality`	Descarta pontos de dados de cardinalidade alta (estados de CPU diferentes de `user` e `sys`, e métricas por comando para comandos incomuns) para controlar o custo de ingestão.
`transform/metadata_nullify`	Limpa as descrições e unidades de métricas para reduzir o tamanho da carga.
`batch`	Agrupa pontos de dados antes da exportação (2.048 por lote, até 4.096) e descarrega pelo menos a cada 10 segundos para reduzir a sobrecarga de rede.
`otlp_http`	Exporta as métricas processadas para o New Relic via OTLP com compactação gzip, autenticadas com sua chave de licença.

Dica

Opcional: configurar autenticação

receivers:
  redis:
    endpoint: "redis:6379"
    username: "${env:REDIS_USERNAME}"
    password: "${env:REDIS_PASSWORD}"

Adicione ao seu arquivo .env:

bash

$REDIS_USERNAME=otel-monitor
$REDIS_PASSWORD=your-monitor-password

receivers:
  redis:
    endpoint: "redis:6380"
    password: "${env:REDIS_PASSWORD}"
    tls:
      insecure: false
      ca_file: /etc/ssl/redis/ca.crt
      cert_file: /etc/ssl/redis/client.crt
      key_file: /etc/ssl/redis/client.key

Opcional: coletar logs do Redis

Importante

Adicione isso ao seu serviço Redis em docker-compose.yml:

redis:
    image: redis:7
    command: >
      sh -c "touch /data/redis.log && chmod 644 /data/redis.log && redis-server --logfile /data/redis.log"
    volumes:
      - redis-logs:/data

E adicione o volume compartilhado ao seu serviço do coletor:

otel-collector:
    volumes:
      - redis-logs:/var/log/redis:ro

Em seguida, adicione no final do seu docker-compose.yml:

volumes:
  redis-logs:

Adicione o receptor filelog ao seu otel-collector-config.yaml:

receivers:
  # ... existing redis receiver ...
  file_log/redis:
    include:
      - /var/log/redis/redis.log
    start_at: end
    operators:
      - type: regex_parser
        regex: '^\d+:[XCSM] \d+ \w+ \d+ \d+:\d+:\d+\.\d+ (?P<level>.) '
        on_error: send
    resource:
      db.system: redis

processors:
  # ... existing processors ...
  resource/redis_logs:
    attributes:
      - key: server.address
        value: "redis"  # Must match your redis receiver endpoint host
        action: upsert
      - key: server.port
        value: 6379  # Must match your redis receiver endpoint port
        action: upsert
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

Dica

resource/redis_logs:
    attributes:
      - key: redis.instance.id
        value: "my-redis-instance"  # Must match the value in resource/redis
        action: upsert
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

Adicione um pipeline de logs separado à seção de serviço:

service:
  pipelines:
    metrics/redis:
      receivers: [redis]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]
    logs/redis:
      receivers: [file_log/redis]
      processors: [memory_limiter, resource/redis_logs, batch]
      exporters: [otlp_http]

Importante

bash

$sudo chmod 755 /var/log/redis
$sudo chmod 644 /var/log/redis/redis.log

Opcional: coletar métricas do host

receivers:
  # ... existing receivers ...
  host_metrics:
    collection_interval: 10s
    root_path: /hostfs
    scrapers:
      cpu:
        metrics:
          system.cpu.utilization: {enabled: true}
          system.cpu.time: {enabled: true}
      load:
        metrics:
          system.cpu.load_average.1m: {enabled: true}
          system.cpu.load_average.5m: {enabled: true}
          system.cpu.load_average.15m: {enabled: true}
      memory:
        metrics:
          system.memory.usage: {enabled: true}
          system.memory.utilization: {enabled: true}
      disk:
        metrics:
          system.disk.io: {enabled: true}
          system.disk.operations: {enabled: true}
      filesystem:
        metrics:
          system.filesystem.usage: {enabled: true}
          system.filesystem.utilization: {enabled: true}
      network:
        metrics:
          system.network.io: {enabled: true}
          system.network.packets: {enabled: true}

Adicione um pipeline metrics/host separado para métricas de host (não adicione host_metrics ao pipeline do Redis):

service:
  pipelines:
    metrics/redis:
      receivers: [redis]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]
    metrics/host:
      receivers: [host_metrics]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, batch]
      exporters: [otlp_http]

Opcional: Adicionar metadados personalizados

processors:
  # ... existing processors ...
  resource/custom:
    attributes:
      - key: environment
        value: "production"
        action: upsert
      - key: team
        value: "platform"
        action: upsert

Inclua o processador no seu pipeline:

service:
  pipelines:
    metrics/redis:
      receivers: [redis]
      processors: [memory_limiter, resource_detection, resource/custom, attributes/entity_tags, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]

Opcional: habilite o monitoramento do Redis Cluster

O monitoramento do Redis Cluster atualmente requer a abordagem do receiver do Prometheus (usando redis_exporter). O receiver nativo do Redis do OTel Collector Contrib ainda não suporta o comando CLUSTER INFO necessário para as métricas do cluster. Use a aba Prometheus receiver para a configuração de monitoramento do cluster.

Crie o arquivo do Docker Compose

Crie docker-compose.yml para executar o coletor junto com o seu Redis existente. O arquivo .env no mesmo diretório é carregado automaticamente pelo Docker Compose:

services:
  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    env_file: .env
    volumes:
      - ./otel-collector-config.yaml:/etc/otelcol-contrib/config.yaml:ro
      - /etc/machine-id:/etc/machine-id:ro
      # Uncomment if collecting Redis logs (requires shared volume — see logs step above):
      # - redis-logs:/var/log/redis:ro
      # Uncomment if collecting host metrics:
      # - /:/hostfs:ro
      # Uncomment if using TLS:
      # - ./certs:/etc/ssl/redis:ro
    environment:
      - NEW_RELIC_LICENSE_KEY=${NEW_RELIC_LICENSE_KEY}
      - OTEL_EXPORTER_OTLP_ENDPOINT=${OTEL_EXPORTER_OTLP_ENDPOINT}
      # Uncomment if collecting host metrics:
      # - HOST_PROC=/hostfs/proc
      # - HOST_SYS=/hostfs/sys
      # - HOST_ETC=/hostfs/etc
      # Uncomment if using Redis authentication:
      # - REDIS_PASSWORD=${REDIS_PASSWORD}
      # - REDIS_USERNAME=${REDIS_USERNAME}
    command: ["--config=/etc/otelcol-contrib/config.yaml"]
    ports:
      - "13133:13133"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:13133"]
      interval: 10s
      timeout: 5s
      retries: 3

# Uncomment if collecting Redis logs:
# volumes:
#   redis-logs:

Dica

Crie o arquivo de ambiente

bash

$NEW_RELIC_LICENSE_KEY=YOUR_LICENSE_KEY
$OTEL_EXPORTER_OTLP_ENDPOINT=YOUR_OTLP_ENDPOINT
$# Set the New Relic OTLP endpoint for your region.
$# See https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp

Substitua os espaços reservados pelos seus próprios valores:

Variável	Obrigatório	Descrição
`NEW_RELIC_LICENSE_KEY`	Sim	Sua chave de licença de ingestão da New Relic.
`OTEL_EXPORTER_OTLP_ENDPOINT`	Sim	Endpoint OTLP da New Relic para sua região. Para mais informações, consulte o endpoint OTLP da New Relic.

Inicie e verifique

Inicie o coletor em segundo plano:

bash

$docker compose up -d

Em seguida, confirme se suas métricas estão chegando à New Relic. Aguarde cerca de um minuto após a inicialização e, em seguida, execute esta consulta no criador de consulta:

SELECT count(*) FROM Metric WHERE metricName LIKE 'redis.%' AND instrumentation.provider = 'opentelemetry' SINCE 5 minutes ago

Uma contagem diferente de zero confirma que as métricas do Redis estão fluindo. Se retornar 0, consulte Solucionar problemas do Redis (OpenTelemetry).

Crie a configuração do coletor

Esta configuração extrai métricas de redis_exporter e as envia para a New Relic. Ele lida com estas tarefas principais:

Colete o endpoint do Prometheus redis_exporter por meio do receptor prometheus
Renomeie as métricas do Prometheus para os nomes de métrica do Redis da New Relic
Molde os dados — reduza a cardinalidade, converta contadores em deltas e adicione tags para a síntese de entidade

Exporte as métricas processadas para o New Relic via OTLP

Crie otel-collector-config.yaml no diretório do seu projeto:

extensions:
  health_check:
    endpoint: "0.0.0.0:13133"

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: 'redis'
          scrape_interval: 10s
          static_configs:
            - targets: ['redis-exporter:9121']  # Update with your Redis exporter host:port
          metric_relabel_configs:
            - source_labels: [__name__]
              regex: '(go_|process_|promhttp_|redis_exporter_).*'
              action: drop

processors:
  memory_limiter:
    check_interval: 5s
    limit_mib: 512
    spike_limit_mib: 128

  resource_detection:
    detectors: [env, system]
    timeout: 5s
    override: false
    system:
      resource_attributes:
        host.name:
          enabled: true
        host.id:
          enabled: true

  # Required: Set a unique identifier for your Redis entity.
  # The Prometheus receiver does not provide server.address/server.port,
  # so redis.instance.id is required for entity creation in New Relic.
  resource/redis_identity:
    attributes:
      - key: redis.instance.id
        value: "my-redis-instance:6379"  # Update with a unique name for this Redis instance
        action: upsert

  attributes/entity_tags:
    actions:
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

  metricstransform:
    transforms:
      - include: redis_uptime_in_seconds
        action: update
        new_name: redis.uptime
      - include: redis_connected_clients
        action: update
        new_name: redis.clients.connected
      - include: redis_blocked_clients
        action: update
        new_name: redis.clients.blocked
      - include: redis_memory_used_bytes
        action: update
        new_name: redis.memory.used
      - include: redis_memory_max_bytes
        action: update
        new_name: redis.maxmemory
      - include: redis_mem_fragmentation_ratio
        action: update
        new_name: redis.memory.fragmentation_ratio
      - include: redis_memory_used_rss_bytes
        action: update
        new_name: redis.memory.rss
      - include: redis_memory_used_peak_bytes
        action: update
        new_name: redis.memory.peak
      - include: redis_memory_used_lua_bytes
        action: update
        new_name: redis.memory.lua
      - include: redis_connections_received_total
        action: update
        new_name: redis.connections.received
      - include: redis_rejected_connections_total
        action: update
        new_name: redis.connections.rejected
      - include: redis_commands_processed_total
        action: update
        new_name: redis.commands.processed
      - include: redis_keyspace_hits_total
        action: update
        new_name: redis.keyspace.hits
      - include: redis_keyspace_misses_total
        action: update
        new_name: redis.keyspace.misses
      - include: redis_evicted_keys_total
        action: update
        new_name: redis.keys.evicted
      - include: redis_expired_keys_total
        action: update
        new_name: redis.keys.expired
      - include: redis_net_input_bytes_total
        action: update
        new_name: redis.net.input
      - include: redis_net_output_bytes_total
        action: update
        new_name: redis.net.output
      - include: redis_connected_slaves
        action: update
        new_name: redis.slaves.connected
      - include: redis_db_keys
        action: update
        new_name: redis.db.keys
      - include: redis_db_keys_expiring
        action: update
        new_name: redis.db.expires
      - include: redis_rdb_changes_since_last_save
        action: update
        new_name: redis.rdb.changes_since_last_save
      - include: redis_db_avg_ttl_seconds
        action: update
        new_name: redis.db.avg_ttl
      - include: redis_latest_fork_seconds
        action: update
        new_name: redis.latest_fork
      - include: redis_master_repl_offset
        action: update
        new_name: redis.replication.offset
      - include: redis_repl_backlog_first_byte_offset
        action: update
        new_name: redis.replication.backlog_first_byte_offset
      - include: redis_commands_total
        action: update
        new_name: redis.cmd.calls
      - include: redis_commands_duration_seconds_total
        action: update
        new_name: redis.cmd.usec
      - include: redis_cpu_sys_seconds_total
        action: update
        new_name: redis.cpu.time
        operations:
          - action: add_label
            new_label: state
            new_value: sys
      - include: redis_cpu_user_seconds_total
        action: update
        new_name: redis.cpu.time
        operations:
          - action: add_label
            new_label: state
            new_value: user

  cumulativetodelta:
    include:
      match_type: regexp
      metrics:
        - redis\.commands\.processed
        - redis\.connections\.received
        - redis\.connections\.rejected
        - redis\.keys\.evicted
        - redis\.keys\.expired
        - redis\.keyspace\.hits
        - redis\.keyspace\.misses
        - redis\.net\.input
        - redis\.net\.output
        - redis\.cpu\.time
        - redis\.cmd\.calls
        - redis\.cmd\.usec
        - redis\.uptime

  filter/cardinality:
    metrics:
      datapoint:
        - 'metric.name == "redis.cpu.time" and attributes["state"] != "sys" and attributes["state"] != "user"'
        - 'metric.name == "redis.cmd.calls" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'
        - 'metric.name == "redis.cmd.usec" and attributes["cmd"] != "get" and attributes["cmd"] != "set" and attributes["cmd"] != "del" and attributes["cmd"] != "hget" and attributes["cmd"] != "hset" and attributes["cmd"] != "hgetall" and attributes["cmd"] != "lpush" and attributes["cmd"] != "rpop" and attributes["cmd"] != "zadd" and attributes["cmd"] != "expire"'

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

  batch:
    send_batch_size: 2048
    send_batch_max_size: 4096
    timeout: 10s

exporters:
  otlp_http:
    endpoint: ${env:OTEL_EXPORTER_OTLP_ENDPOINT}
    headers:
      api-key: ${env:NEW_RELIC_LICENSE_KEY}
    compression: gzip

service:
  extensions: [health_check]
  pipelines:
    metrics/redis:
      receivers: [prometheus]
      processors: [memory_limiter, resource_detection, resource/redis_identity, attributes/entity_tags, metricstransform, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]

O que esta configuração faz

Cada componente no pipeline tem uma função específica:

Componente	Descrição
`health_check`	Expõe um endpoint de integridade em `0.0.0.0:13133` para que você possa confirmar que o coletor está em execução.
`prometheus` receptor	Faz o scrape do endpoint `redis_exporter` (padrão `redis-exporter:9121`) a cada 10 segundos e descarta as próprias métricas `go_`, `process_`, `promhttp_` e `redis_exporter_` do exporter.
`memory_limiter`	Limita o uso de memória do coletor (limite flexível de 512 MiB, pico de 128 MiB) para proteger o contêiner.
`resource_detection`	Detecta o host e adiciona `host.name` e `host.id`, vinculando as métricas do Redis à entidade de host subjacente.
`resource/redis_identity`	Define `redis.instance.id`, que identifica a entidade do Redis na New Relic. É necessário aqui porque o receptor do Prometheus não fornece `server.address` ou `server.port`.
`attributes/entity_tags`	Marca `instrumentation.provider: opentelemetry` em cada métrica para que você possa definir o escopo das consultas para o caminho do OpenTelemetry.
`metricstransform`	Renomeia as métricas do Prometheus do exportador (por exemplo, `redis_uptime_in_seconds`) para os nomes do Redis do New Relic (`redis.uptime`) e adiciona o rótulo `state` às métricas de CPU.
`cumulativetodelta`	Converte contadores cumulativos — comandos, acertos de keyspace, despejos e assim por diante — em valores delta para que a New Relic gere gráficos de taxas corretamente.
`filter/cardinality`	Descarta pontos de dados de cardinalidade alta (estados de CPU diferentes de `user` e `sys`, e métricas por comando para comandos incomuns) para controlar o custo de ingestão.
`transform/metadata_nullify`	Limpa as descrições e unidades de métricas para reduzir o tamanho da carga.
`batch`	Agrupa pontos de dados antes da exportação (2.048 por lote, até 4.096) e descarrega pelo menos a cada 10 segundos para reduzir a sobrecarga de rede.
`otlp_http`	Exporta as métricas processadas para o New Relic via OTLP com compactação gzip, autenticadas com sua chave de licença.

Importante

O processador resource/redis_identity com redis.instance.id é obrigatório para a abordagem do receiver do Prometheus. Ao contrário do receiver nativo do Redis, o receiver do Prometheus não fornece server.address ou server.port — portanto, redis.instance.id é a única maneira de identificar sua entidade do Redis no New Relic. Defina-o com um nome único e descritivo para cada instância (por exemplo, prod-redis-cache:6379).

Opcional: habilite o monitoramento do Redis Cluster

Se o seu Redis estiver sendo executado no modo Cluster, inicie redis_exporter com a flag --is-cluster para coletar automaticamente as métricas de integridade do cluster de todos os nós:

bash

$redis_exporter --redis.addr=redis://localhost:7000 --is-cluster

A configuração do receptor Prometheus acima já renomeia as métricas do cluster (por exemplo, redis_cluster_state → redis.cluster.state). Para criar uma entidade de cluster separada no New Relic, adicione um atributo de recurso redis.cluster.name a um pipeline separado que NÃO inclua redis.instance.id:

resource/cluster:
    attributes:
      - key: redis.cluster.name
        value: "my-redis-cluster"  # Update with your cluster name
        action: upsert

Adicione um pipeline de cluster à sua seção de serviço:

metrics/cluster:
      receivers: [prometheus]
      processors: [memory_limiter, resource_detection, resource/cluster, attributes/entity_tags, metricstransform, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]

Importante

A entidade de cluster requer que redis.cluster.name esteja presente E redis.instance.id esteja ausente. Se ambos estiverem definidos nas mesmas métricas, apenas a entidade de instância será criada. Use pipelines separados para métricas de instância e de cluster.

Opcional: coletar logs do Redis

Importante

Adicione isso ao seu serviço Redis em docker-compose.yml:

redis:
    image: redis:7
    command: >
      sh -c "touch /data/redis.log && chmod 644 /data/redis.log && redis-server --logfile /data/redis.log"
    volumes:
      - redis-logs:/data

E adicione o volume compartilhado ao seu serviço do coletor:

otel-collector:
    volumes:
      - redis-logs:/var/log/redis:ro

Em seguida, adicione no final do seu docker-compose.yml:

volumes:
  redis-logs:

Adicione o receptor filelog ao seu otel-collector-config.yaml:

receivers:
  # ... existing prometheus receiver ...
  file_log/redis:
    include:
      - /var/log/redis/redis.log
    start_at: end
    operators:
      - type: regex_parser
        regex: '^\d+:[XCSM] \d+ \w+ \d+ \d+:\d+:\d+\.\d+ (?P<level>.) '
        on_error: send
    resource:
      db.system: redis

processors:
  # ... existing processors ...
  resource/redis_logs:
    attributes:
      - key: redis.instance.id
        value: "my-redis-instance:6379"  # Must match the value in resource/redis_identity
        action: upsert
      - key: instrumentation.provider
        value: opentelemetry
        action: upsert

Adicione um pipeline de logs separado à seção de serviço:

service:
  pipelines:
    metrics/redis:
      receivers: [prometheus]
      processors: [memory_limiter, resource_detection, resource/redis_identity, attributes/entity_tags, metricstransform, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]
    logs/redis:
      receivers: [file_log/redis]
      processors: [memory_limiter, resource/redis_logs, batch]
      exporters: [otlp_http]

Opcional: coletar métricas do host

receivers:
  # ... existing receivers ...
  host_metrics:
    collection_interval: 10s
    root_path: /hostfs
    scrapers:
      cpu:
        metrics:
          system.cpu.utilization: {enabled: true}
          system.cpu.time: {enabled: true}
      load:
        metrics:
          system.cpu.load_average.1m: {enabled: true}
          system.cpu.load_average.5m: {enabled: true}
          system.cpu.load_average.15m: {enabled: true}
      memory:
        metrics:
          system.memory.usage: {enabled: true}
          system.memory.utilization: {enabled: true}
      disk:
        metrics:
          system.disk.io: {enabled: true}
          system.disk.operations: {enabled: true}
      filesystem:
        metrics:
          system.filesystem.usage: {enabled: true}
          system.filesystem.utilization: {enabled: true}
      network:
        metrics:
          system.network.io: {enabled: true}
          system.network.packets: {enabled: true}

Adicione um pipeline metrics/host separado para métricas de host (não adicione host_metrics ao pipeline do Redis):

service:
  pipelines:
    metrics/redis:
      receivers: [prometheus]
      processors: [memory_limiter, resource_detection, resource/redis_identity, attributes/entity_tags, metricstransform, cumulativetodelta, filter/cardinality, transform/metadata_nullify, batch]
      exporters: [otlp_http]
    metrics/host:
      receivers: [host_metrics]
      processors: [memory_limiter, resource_detection, attributes/entity_tags, batch]
      exporters: [otlp_http]

Crie o arquivo do Docker Compose

Crie docker-compose.yml para executar o redis_exporter e o coletor junto com o seu Redis existente. O arquivo .env no mesmo diretório é carregado automaticamente pelo Docker Compose:

services:
  redis-exporter:
    image: oliver006/redis_exporter:latest
    environment:
      - REDIS_ADDR=redis://redis:6379  # Update with your Redis service name:port
      # Uncomment if using Redis authentication:
      # - REDIS_PASSWORD=${REDIS_PASSWORD}
      # - REDIS_USER=${REDIS_USERNAME}
    ports:
      - "9121:9121"
    healthcheck:
      test: ["CMD-SHELL", "redis_exporter --version || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 3

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    env_file: .env
    volumes:
      - ./otel-collector-config.yaml:/etc/otelcol-contrib/config.yaml:ro
      - /etc/machine-id:/etc/machine-id:ro
    environment:
      - NEW_RELIC_LICENSE_KEY=${NEW_RELIC_LICENSE_KEY}
      - OTEL_EXPORTER_OTLP_ENDPOINT=${OTEL_EXPORTER_OTLP_ENDPOINT}
    command: ["--config=/etc/otelcol-contrib/config.yaml"]
    ports:
      - "13133:13133"
    depends_on:
      redis-exporter:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:13133"]
      interval: 10s
      timeout: 5s
      retries: 3

Dica

Para usar o coletor NRDOT em vez disso, substitua a imagem otel-collector por newrelic/nrdot-collector:latest e atualize o caminho de montagem da configuração para /etc/otel/config.yaml.

Crie o arquivo de ambiente

bash

$NEW_RELIC_LICENSE_KEY=YOUR_LICENSE_KEY
$OTEL_EXPORTER_OTLP_ENDPOINT=YOUR_OTLP_ENDPOINT
$# Set the New Relic OTLP endpoint for your region.
$# See https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp

Substitua os espaços reservados pelos seus próprios valores:

Variável	Obrigatório	Descrição
`NEW_RELIC_LICENSE_KEY`	Sim	Sua chave de licença de ingestão da New Relic.
`OTEL_EXPORTER_OTLP_ENDPOINT`	Sim	Endpoint OTLP da New Relic para sua região. Para mais informações, consulte o endpoint OTLP da New Relic.

Inicie e verifique

Inicie o coletor e redis_exporter em segundo plano:

bash

$docker compose up -d

Confirme se os contêineres estão em execução com docker compose ps — tanto o coletor quanto redis-exporter devem mostrar um status running. Se o coletor foi encerrado, verifique seus logs com docker compose logs otel-collector — as causas mais comuns são erros de indentação YAML, um redis_exporter inacessível ou o exportador não estar em execução.

Em seguida, confirme se suas métricas estão chegando à New Relic. Aguarde cerca de um minuto após a inicialização e, em seguida, execute esta consulta no criador de consulta:

SELECT count(*) FROM Metric WHERE metricName LIKE 'redis.%' AND instrumentation.provider = 'opentelemetry' SINCE 5 minutes ago

Uma contagem diferente de zero confirma que as métricas do Redis estão fluindo. Se retornar 0, consulte Solucionar problemas do Redis (OpenTelemetry).

Dica

Correlacione o APM com o Redis: para conectar seu aplicativo APM e a instância do Redis em mapas de serviço, inclua db.system="redis" junto com o padrão de identificador de entidade escolhido — seja redis.instance.id ou server.address e server.port — como atributos de recurso em suas métricas do APM. Os valores devem corresponder ao que você configurou no coletor. Isso permite a visibilidade entre serviços e uma solução de problemas mais rápida no New Relic.

Próximos passos

Instalação auto-hospedada: Monitore o Redis em VMs/bare metal
Instalação do Kubernetes: Implantar no Kubernetes com DaemonSet
Visualize seus dados: Explore dashboards e configure alertas
Referência de métricas: lista completa de métricas disponíveis
Resolução de problemas: Problemas e soluções comuns

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

Monitore o Redis com o Docker Compose (OpenTelemetry)

Antes de você começar .css-21sua1{background:none;border:none;width:0;padding:0;}

Opções de instalação

Crie a configuração do coletor

O que esta configuração faz

Dica

Opcional: configurar autenticação

Nome de usuário + senha da ACL (Redis 6+)

Conexão criptografada por TLS/SSL

Opcional: coletar logs do Redis

Importante

Dica

Importante

Opcional: coletar métricas do host

Opcional: Adicionar metadados personalizados

Opcional: habilite o monitoramento do Redis Cluster

Crie o arquivo do Docker Compose

Dica

Crie o arquivo de ambiente

Inicie e verifique

Crie a configuração do coletor

O que esta configuração faz

Dica

Opcional: configurar autenticação

Senha legada (requirepass)

Nome de usuário + senha da ACL (Redis 6+)

Conexão criptografada por TLS/SSL

Opcional: coletar logs do Redis

Importante

Dica

Importante

Opcional: coletar métricas do host

Opcional: Adicionar metadados personalizados

Opcional: habilite o monitoramento do Redis Cluster

Crie o arquivo do Docker Compose

Dica

Crie o arquivo de ambiente

Inicie e verifique

Crie a configuração do coletor

O que esta configuração faz

Importante

Opcional: habilite o monitoramento do Redis Cluster

Importante

Opcional: coletar logs do Redis

Importante

Opcional: coletar métricas do host

Crie o arquivo do Docker Compose

Dica

Crie o arquivo de ambiente

Inicie e verifique

Dica

Próximos passos

Antes de você começar