Redis

Neste documento, descrevemos como configurar a implantação do Google Kubernetes Engine para usar o Google Cloud Managed Service para Prometheus a fim de coletar métricas do Redis. Esta página mostra como fazer o seguinte:

• Configurar o exportador do Redis para gerar relatórios de métricas.
• Configurar um recurso PodMonitoring para o serviço gerenciado para Prometheus a fim de coletar as métricas exportadas.
• Instalar um painel no Cloud Monitoring para ver as métricas.
• Configure regras de alertas para monitorar as métricas.

Estas instruções se aplicam somente ao usar a coleção gerenciada com o serviço gerenciado para Prometheus. Se você estiver usando a coleção autoimplantada, consulte o repositório de origem do exportador do Redis para ver informações da instalação.

Estas instruções são um exemplo e devem funcionar na maioria dos ambientes do Kubernetes. Se você estiver com problemas para instalar um aplicativo ou exportador devido a políticas restritivas de segurança ou da organização, recomendamos consultar a documentação de código aberto para receber suporte.

Para saber mais sobre o Redis, consulte o Redis.

Pré-requisitos

Para coletar métricas do Redis usando o Managed Service para Prometheus e a coleta gerenciada, sua implantação precisa atender aos seguintes requisitos:

• O cluster precisa executar a versão 1.21.4-gke.300 ou posterior do Google Kubernetes Engine.
• É necessário executar o Managed Service para Prometheus com a coleta gerenciada ativada. Para mais informações, consulte Começar a usar a coleta gerenciada.

• Para usar os painéis disponíveis no Cloud Monitoring para a integração Redis, use a versão 1.43.1 ou posterior do redis_exporter.

  Para mais informações sobre os painéis disponíveis, consulte Visualizar painéis.

Instalar o exportador do Redis

Recomendamos instalar o exportador do Redis, redis_exporter, como um arquivo secundário para a carga de trabalho do Redis. Para informações sobre o uso de arquivos secundários, consulte Aplicativos estendidos no Kubernetes com pods de múltiplos contêineres.

Para instalar o redis_exporter como um arquivo secundário para o Redis, modifique a configuração do Redis, conforme mostrado no exemplo a seguir:

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https:#www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis
  labels:
    app.kubernetes.io/name: redis
spec:
  selector:
    matchLabels:
+     app.kubernetes.io/name: redis
  template:
    metadata:
      labels:
+       app.kubernetes.io/name: redis
    spec:
      containers:
      - name: redis
        image: "redis:6.2"
        ...
+     - name: redis-exporter
+       image: oliver006/redis_exporter:v1.43.1
+       args: [--include-system-metrics]
+       resources:
+         requests:
+           cpu: 100m
+           memory: 100Mi
+       ports:
+       - containerPort: 9121
    ...

Adicione à sua configuração todas as linhas precedidas pelo símbolo +.

Essas instruções presumem que você já tenha uma instalação funcional do Redis e queira modificá-la para incluir um exportador. Se você também precisar configurar o Redis, poderá configurar e aplicar o gráfico do Bitnami Helm. Transmita os seguintes valores de configuração:

• metrics.enabled = true
• metrics.podLabels = {app.kubernetes.io/name: redis}

Para aplicar as alterações de configuração de um arquivo local, execute o seguinte comando:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Também é possível usar o Terraform para gerenciar as configurações.

Definir um recurso do PodMonitoring

Para descobrir o destino, o operador do Managed Service para Prometheus, é necessário um recurso PodMonitoring que corresponde ao exportador do Redis no mesmo namespace.

É possível usar a seguinte configuração do PodMonitoring:

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: redis
  labels:
    app.kubernetes.io/name: redis
    app.kubernetes.io/part-of: google-cloud-managed-prometheus
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: redis
  endpoints:
  - port: 9121
    interval: 30s

Verifique se os seletores do identificador e a porta correspondem aos seletores e à porta usados em Instalar o exportador do Redis.

Para aplicar as alterações de configuração de um arquivo local, execute o seguinte comando:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Também é possível usar o Terraform para gerenciar as configurações.

Definir regras e alertas

Use a configuração Rules a seguir para definir alertas nas métricas do Redis:

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: monitoring.googleapis.com/v1
kind: Rules
metadata:
  name: redis-rules
  labels:
    app.kubernetes.io/component: rules
    app.kubernetes.io/name: redis-rules
    app.kubernetes.io/part-of: google-cloud-managed-prometheus
spec:
  groups:
  - name: redis
    interval: 30s
    rules:
    - alert: RedisDown
      annotations:
        description: |-
          Redis instance is down
            VALUE = {{ $value }}
            LABELS: {{ $labels }}
        summary: Redis down (instance {{ $labels.instance }})
      expr: redis_up{job="redis"} == 0
      for: 5m
      labels:
        severity: critical
    - alert: RedisOutOfMemory
      annotations:
        description: |-
          Redis is running out of memory (> 90%)
            VALUE = {{ $value }}
            LABELS: {{ $labels }}
        summary: Redis out of memory (instance {{ $labels.instance }})
      expr: redis_memory_used_bytes{job="redis"} / redis_total_system_memory_bytes{job="redis"}
        * 100 > 90
      for: 5m
      labels:
        severity: warning
    - alert: RedisTooManyConnections
      annotations:
        description: |-
          Redis instance has too many connections
            VALUE = {{ $value }}
            LABELS: {{ $labels }}
        summary: Redis too many connections (instance {{ $labels.instance }})
      expr: redis_connected_clients{job="redis"} > 100
      for: 5m
      labels:
        severity: warning
    - alert: RedisClusterSlotFail
      annotations:
        description: |-
          Redis cluster has slots fail
            VALUE = {{ $value }}
            LABELS: {{ $labels }}
        summary: Number of hash slots mapping to a node in FAIL state (instance {{ $labels.instance }})
      expr: redis_cluster_slots_fail{job="redis"} > 0
      for: 5m
      labels:
        severity: warning
    - alert: RedisClusterSlotPfail
      annotations:
        description: |-
          Redis cluster has slots pfail
            VALUE = {{ $value }}
            LABELS: {{ $labels }}
        summary: Number of hash slots mapping to a node in PFAIL state (instance {{ $labels.instance }})
      expr: redis_cluster_slots_pfail{job="redis"} > 0
      for: 5m
      labels:
        severity: warning
    - alert: RedisClusterStateNotOk
      annotations:
        description: |-
          Redis cluster is not ok
            VALUE = {{ $value }}
            LABELS: {{ $labels }}
        summary: Redis cluster state is not ok (instance {{ $labels.instance }})
      expr: redis_cluster_state{job="redis"} == 0
      for: 5m
      labels:
        severity: critical
    - expr: redis_memory_used_rss_bytes{job="redis"} / redis_memory_used_bytes{job="redis"}
      record: redis_memory_fragmentation_ratio

Para aplicar as alterações de configuração de um arquivo local, execute o seguinte comando:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Também é possível usar o Terraform para gerenciar as configurações.

Para mais informações sobre como aplicar regras ao cluster, consulte Avaliação e alerta de regras gerenciadas.

Essa configuração do Rules foi adaptada das regras e alertas enviados ao repositório redis_exporter.

Verificar a configuração

Use o Metrics Explorer para verificar se você configurou corretamente o exportador do Redis. Pode levar um ou dois minutos para que o Cloud Monitoring transfira as métricas.

Para verificar se as métricas foram transferidas, faça o seguinte:

1. No console do Google Cloud, acesse a página do  Metrics Explorer:

   Acesse o Metrics explorer

   Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoramento.

2. Na barra de ferramentas do painel do criador de consultas, selecione o botão  MQL ou  PromQL.
3. Verifique se PromQL está selecionado na opção de ativar/desativar Idioma. A alternância de idiomas está na mesma barra de ferramentas que permite formatar sua consulta.
4. Digite e execute a seguinte consulta:
   

   up{job="redis", cluster="CLUSTER_NAME", namespace="NAMESPACE_NAME"}
   

Ver painéis

A integração com o Cloud Monitoring inclui o painel Visão geral do Redis Prometheus. Os painéis são instalados automaticamente ao configurar a integração. Também é possível visualizar visualizações estáticas de painéis sem instalar a integração.

Para ver um painel instalado, faça o seguinte:

1. No console do Google Cloud, acesse a página  Painéis:

   Ir para Painéis

   Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoramento.

2. Selecione a guia Lista de painéis.
3. Escolha a categoria Integrações.
4. Clique no nome do painel, por exemplo, Visão geral do Redis Prometheus.

Para acessar uma visualização estática do painel, faça o seguinte:

1. No console do Google Cloud, acesse a página  Integrações:

   Acessar Integrações

   Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoramento.

2. Clique no filtro de plataforma de implantação do Kubernetes Engine.
3. Localize a integração com o Redis e clique em Visualizar detalhes.
4. Selecione a guia Painéis.

Solução de problemas

Para resolver problemas de transferências de métricas, consulte Problemas com a coleta de exportadores em Resolver problemas no processamento.