Monitoramento de métricas personalizadas usando o Prometheus

Restrições

Para usar o prometheus para monitorar métricas personalizadas, o aplicativo precisa fornecer uma API de monitoramento de métricas. Para mais detalhes, consulte Coleta de dados de monitoramento de Prometheus.

Coleta de dados de monitoramento de Prometheus

Prometheus chama periodicamente a API de monitoramento de métricas (/metrics por padrão) de uma aplicação para obter dados de monitoramento. A aplicação precisa fornecer a API de monitoramento de métricas para a chamada do Prometheus, e os dados de monitoramento devem atender às seguintes especificações do Prometheus:

# TYPE nginx_connections_active gauge
nginx_connections_active 2
# TYPE nginx_connections_reading gauge
nginx_connections_reading 0

Prometheus fornece clientes em vários idiomas. Para obter detalhes sobre os clientes, consulte Prometheus CLIENT LIBRARIES. Para obter detalhes sobre como desenvolver um exportador, consulte WRITING EXPORTERS. A comunidade de Prometheus fornece vários exportadores de terceiros que podem ser usados diretamente. Para obter detalhes, consulte EXPORTERS AND INTEGRATIONS.

Instalar o complemento

Instale o complemento com base na versão do cluster e nos requisitos reais.

• Monitoramento de cluster da nuvem nativa: suporta clusters de v1.17 ou posterior. Além dos recursos de monitoramento, esse complemento fornece interconexão entre os dados de monitoramento e o Container Intelligent Analysis (CIA).
• Prometheus (EOM): suporta apenas clusters da v1.21 ou anterior.

Acessar o Prometheus

Depois que o complemento for instalado, você poderá implementar cargas de trabalho e Serviços. O StatefulSet chamado prometheus refere-se ao Servidor Prometheus.

Pode criar um Serviço LoadBalancer de rede pública para que o Prometheus possa ser acedido a partir de uma rede externa.

1. Faça logon no console do CCE e clique no nome do cluster com o complemento prometheus instalado para acessar o console do cluster. Na página exibida, escolha Networking no painel de navegação.
2. Clique em Create from YAML no canto superior direito para criar um Serviço LoadBalancer de rede pública.

   apiVersion: v1
   kind: Service
   metadata:
     name: prom-lb     #Service name, which can be customized.
     namespace: monitoring
     labels:
       app: prometheus
       component: server
     annotations:
       kubernetes.io/elb.id: 038ff***     #Replace it with the ID of the public networkload balancer in the VPC to which the cluster belongs.
   spec:
     ports:
       - name: cce-service-0
         protocol: TCP
         port: 88     #Service port, which can be customized.
         targetPort: 9090     #Default port of Prometheus. Retain the default value.
     selector:
       app: prometheus
       component: server
       release: cceaddon-prometheus
     type: LoadBalancer

3. Após a criação, visite load balancer public IP:Service port para acessar o Prometheus.
   Figura 1 Acessar o Prometheus
   

4. Escolha Status > Targets para exibir os alvos monitorados pelo prometheus.
   Figura 2 Exibir alvos monitorados
   

Preparar uma aplicação

A aplicação deve fornecer uma API de monitoramento de métricas para o ICAgent coletar dados, e os dados de monitoramento devem estar em conformidade com as especificações do Prometheus. Para mais detalhes, consulte Coleta de dados de monitoramento de Prometheus.

Este documento usa o Nginx como um exemplo para descrever como coletar dados de monitoramento. Existe um módulo chamado ngx_http_stub_status_module no Nginx, que fornece funções básicas de monitoramento. Você pode configurar o arquivo nginx.conf para fornecer uma interface para que sistemas externos acessem dados de monitoramento do Nginx.

1. Faça logon em uma VM Linux que possa acessar a Internet e executar comandos do Docker.
2. Crie um arquivo nginx.conf. Adicione a configuração do servidor em http para permitir que o Nginx forneça uma interface para os sistemas externos acessarem os dados de monitoramento.

   user  nginx;
   worker_processes  auto;
   
   error_log  /var/log/nginx/error.log warn;
   pid        /var/run/nginx.pid;
   
   events {
       worker_connections  1024;
   }
   
   http {
       include       /etc/nginx/mime.types;
       default_type  application/octet-stream;
       log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                         '$status $body_bytes_sent "$http_referer" '
                         '"$http_user_agent" "$http_x_forwarded_for"';
   
       access_log  /var/log/nginx/access.log  main;
       sendfile        on;
       #tcp_nopush     on;
       keepalive_timeout  65;
       #gzip  on;
       include /etc/nginx/conf.d/*.conf;
   
       server {
         listen 8080;
         server_name  localhost;
         location /stub_status {
            stub_status on;
            access_log off;
         }
       }
   }

3. Use essa configuração para criar uma imagem e um arquivo Dockerfile.

   vi Dockerfile

   O conteúdo do Dockerfile é o seguinte:

   FROM nginx:1.21.5-alpine
   ADD nginx.conf /etc/nginx/nginx.conf
   EXPOSE 80
   CMD ["nginx", "-g", "daemon off;"]

4. Use este Dockerfile para criar uma imagem e enviá-la para o SWR. O nome da imagem é nginx:exporter. Para detalhes sobre como fazer upload de uma imagem, consulte Carregamento de uma imagem por meio de um cliente do Container Engine.
   1. No painel de navegação, escolha My Images e clique em Upload Through Client no canto superior direito. Na página exibida, clique em Generate a temporary login command e clique em para copiar o comando.
   2. Execute o comando de logon copiado na etapa anterior no nó. Se o logon for bem-sucedido, a mensagem "Login Succeeded" será exibida.
   3. Execute o seguinte comando para criar uma imagem chamada nginx. A versão da imagem é exportadora.

      docker build -t nginx:exporter .

   4. Marque a imagem e envie-a para o repositório de imagens. Altere o endereço do repositório de imagens e o nome da organização com base nos seus requisitos.

      docker tag nginx:exporter swr.ap-southeast-1.myhuaweicloud.com/dev-container/nginx:exporter
      docker push swr.ap-southeast-1.myhuaweicloud.com/dev-container/nginx:exporter

5. Veja as métricas da aplicação.
   1. Use nginx:exporter para criar uma carga de trabalho.
   2. Acesse o contêiner e use http://<ip_address>:8080/stub_status para obter dados de monitoramento do nginx. <ip_address> indica o endereço IP do contêiner. Informação semelhante à seguinte é exibida.

      # curl http://127.0.0.1:8080/stub_status
      Active connections: 3 
      server accepts handled requests
       146269 146269 212 
      Reading: 0 Writing: 1 Waiting: 2

Monitorar métricas personalizadas

O formato dos dados de monitorização fornecidos pelo nginx:exporter não cumpre os requisitos do Prometheus. Converta o formato de dados para o formato exigido pelo Prometheus. Para converter o formato das métricas do Nginx, use nginx-prometheus-exporter. Implemente nginx:exporter e nginx-prometheus-exporter no mesmo pod e adicione as seguintes anotações durante a implementação. Em seguida, o Prometheus pode coletar métricas automaticamente.

kind: Deployment
apiVersion: apps/v1
metadata:
  name: nginx-exporter
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-exporter
  template:
    metadata:
      labels:
        app: nginx-exporter
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "9113"
        prometheus.io/path: "/metrics"
        prometheus.io/scheme: "http"
    spec:
      containers:
        - name: container-0
          image: 'nginx:exporter'      # Replace it with the address of the image you uploaded to SWR.
          resources:
            limits:
              cpu: 250m
              memory: 512Mi
            requests:
              cpu: 250m
              memory: 512Mi
        - name: container-1
          image: 'nginx/nginx-prometheus-exporter:0.9.0'
          command:
            - nginx-prometheus-exporter
          args:
            - '-nginx.scrape-uri=http://127.0.0.1:8080/stub_status'
      imagePullSecrets:
        - name: default-secret

Na descrição anterior:

• prometheus.io/scrape indica se deve ativar o Prometheus para coletar dados de monitoramento do pod. O valor é true.
• prometheus.io/port indica a porta para coletar dados de monitoramento.
• prometheus.io/path indica o URL da API para coletar dados de monitoramento. Se este parâmetro não for definido, o valor padrão /metrics é usado.
• prometheus.io/scheme: protocolo usado para coleta de dados. O valor pode ser http ou https.

Depois que a aplicação é implementada, um pod com um caminho de coleção da porta 9113 pode ser encontrado em Status > Targets.

Figura 3 Visualizar o caminho da coleção do pod

Na guia Graph, insira nginx. As métricas relacionadas são exibidas.

Figura 4 Métricas relacionadas ao Nginx

Configurar regras de coleta para métricas personalizadas

O complemento kube-prometheus-stack da nova versão não fornece métricas personalizadas. Ou seja, as regras de coleta de métricas não são mais configuradas na ConfigMap user-adapter-config (adapter-config em versões anteriores). Adicione regras de coleta de métricas. Para obter detalhes, consulte Detecção de métricas e configuração de apresentação. Se você atualizou o complemento, as configurações originais são herdadas e usadas.

Para usar o prometheus para monitorar métricas personalizadas, o aplicativo precisa fornecer uma API de monitoramento de métricas. Para mais detalhes, consulte Coleta de dados de monitoramento de Prometheus.

1. Efetue logon no console do CCE e clique no nome do cluster para acessar o console do cluster. No painel de navegação, escolha ConfigMaps and Secrets.
2. Alterne para o namespace de monitoring, localize a ConfigMap user-adapter-config (adapter-config em versões anteriores) na guia ConfigMaps e clique em Update.
   Figura 5 Atualizar um ConfigMap
   

3. Na janela que desliza para fora da direita, clique em Edit na coluna de operação de Data para o arquivo config.yaml. Em seguida, adicione uma regra de coleta de métricas personalizadas no campo rules. Clique em OK.

   Você pode adicionar várias regras de coleta adicionando várias configurações no campo rules. Para obter detalhes, consulte Detecção de métricas e configuração de apresentação.

   Este é um exemplo de personalização de uma regra de coleta para o nginx:export:

   rules:
   - seriesQuery: '{__name__=~"^nginx_.*",container!="POD",namespace!="",pod!=""}'
     resources:
       overrides:
         namespace:
           resource: namespace
         pod:
           resource: pod
     name:
       matches: (.*)
     metricsQuery: 'sum(<<.Series>>{<<.LabelMatchers>>,container!="POD"}) by (<<.GroupBy>>)'

   

   O exemplo anterior aplica-se somente à aplicação nginx:export neste exemplo. Se você precisar coletar métricas personalizadas, adicione ou altere regras de acordo com o guia oficial.

   Figura 6 Editar dados do ConfigMap
   

4. Reimplante o custom-metrics-apiserver no namespace de monitoring.
   Figura 7 Reimplantação de custom-metrics-apiserver
   

5. Depois que custom-metrics-apiserver é executado com êxito, você pode selecionar as métricas personalizadas relatadas pela aplicação nginx:export ao criar uma política HPA. Para mais detalhes, consulte Criação de uma política HPA para dimensionamento automático da carga de trabalho.
   Figura 8 Criar uma política HPA usando métricas personalizadas
   

Acessar ao Grafana

O complemento prometheus tem Grafana (uma ferramenta de visualização de código aberto) instalado e interconectado com o Prometheus. Você pode criar um Serviço LoadBalancer de rede pública para acessar o Grafana da rede pública e visualizar os dados de monitoramento do Prometheus no Grafana.

Clique no endereço de acesso para acessar o Grafana e selecione um painel adequado para visualizar o conteúdo agregado.

1. Faça logon no console do CCE e clique no nome do cluster com o complemento prometheus instalado para acessar o console do cluster. Na página exibida, escolha Networking no painel de navegação.
2. Clique em Create from YAML no canto superior direito para criar um Serviço LoadBalancer de rede pública para o Grafana.

   apiVersion: v1
   kind: Service
   metadata:
     name: grafana-lb     #Service name, which can be customized.
     namespace: monitoring
     labels:
       app: grafana
     annotations:
       kubernetes.io/elb.id: 038ff***     #Replace it with the ID of the public networkload balancer in the VPC to which the cluster belongs.
   spec:
     ports:
       - name: cce-service-0
         protocol: TCP
         port: 80     #Service port, which can be customized.
         targetPort: 3000     #Default port of Grafana. Retain the default value.
     selector:
       app: grafana
     type: LoadBalancer

3. Após a criação, visite load balancer public IP:Service port para acessar o Grafana e selecione um painel adequado para visualizar os dados agregados.
   Figura 9 Painel de Grafana
   

Apêndice: persistência dos dados de Grafana

Se os dados do Grafana não forem persistentes, os dados podem ser perdidos quando o contêiner do Grafana for reiniciado. Você pode montar o armazenamento em nuvem no contêiner do Grafana para obter persistência de dados do Grafana.

Por padrão, o complemento kube-prometheus-stack cria um volume de armazenamento de 5 GiB para o Grafana. Desinstalar o complemento não excluirá esse volume. Você não precisa montar manualmente o armazenamento em nuvem.

1. Use o kubectl para se conectar ao cluster onde o cluster Grafana reside. Para mais detalhes, consulte Conexão a um cluster usando o kubectl.
2. Crie a PVC de um disco EVS.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: grafana-pvc
     namespace: monitoring
     annotations:
       everest.io/disk-volume-type: SSD
     labels:
       failure-domain.beta.kubernetes.io/region: ap-southeast-3
       failure-domain.beta.kubernetes.io/zone: ap-southeast-3a
   spec:
     accessModes:
     - ReadWriteOnce
     resources:
       requests:
         storage: 10Gi
     storageClassName: csi-disk

   O disco EVS e o nó onde o Grafana reside devem estar na mesma AZ. Caso contrário, o disco EVS não pode ser conectado.

   • failure-domain.beta.kubernetes.io/region: região onde reside o disco EVS.
   • failure-domain.beta.kubernetes.io/zone: a AZ onde o disco EVS reside.
   • storage: tamanho do disco EVS. Defina este parâmetro conforme necessário.

   Você também pode criar discos EVS no console do CCE. Para mais detalhes, consulte (Console) Criar automaticamente um disco EVS.

3. Modifique a configuração da carga de trabalho do Grafana e monte o disco EVS.

   kubectl edit deploy grafana -n monitoring

   Adicione o disco EVS ao contêiner no arquivo YAML, conforme mostrado na figura a seguir. O nome da PVC deve ser o mesmo em 2, e o caminho de montagem deve ser /var/lib/grafana.

   Além disso, a política de atualização deve ser modificada para a carga de trabalho do Grafana. O número máximo de pods é 1.

   ...
     template:
       spec:
         volumes:
           - name: cce-pvc-grafana
             persistentVolumeClaim:
               claimName: grafana-pvc
   ...
         containers:
           - volumeMounts:
               - name: cce-pvc-grafana
                 mountPath: /var/lib/grafana
   ...
     strategy:
       type: RollingUpdate
       rollingUpdate:
         maxUnavailable: 1
         maxSurge: 1

   Salve a configuração. A carga de trabalho do Grafana será atualizada e o disco EVS será montado.