Monitoramento de Métricas no Kubernetes com Kube-State-Metrics, Node Exporter, Prometheus, Grafana e Metric Server

Vamos configurar o monitoramento de métricas no nosso cluster Kubernetes. Utilizaremos o Metric Server, que fornece dados em tempo real sobre o consumo de CPU e memória, essenciais para escalonamento automático de recursos, como pods.

Além disso, o Kube-State-Metrics será responsável por coletar dados brutos sobre o estado dos recursos do Kubernetes, permitindo a análise histórica de consumo e o acompanhamento da integridade dos objetos internos, como implantações, nós e pods.

Diferença entre Kube-State-Metrics e Metric Server:

• Kube-State-Metrics: Focado em ouvir a API do Kubernetes para monitorar o estado e a integridade de diferentes objetos, como implantações, serviços, pods e nós. Ele é mais útil para análises de longo prazo e para rastrear o estado dos recursos.
• Metric Server: Coleta métricas em tempo real diretamente do Kubelet (nos nós) e as exporta para a API do Kubernetes. Essas métricas são usadas principalmente pelo Horizontal Pod Autoscaler (HPA) e Vertical Pod Autoscaler (VPA) para escalonamento automático. A Metrics API também pode ser acessada pelo comando kubectl top, facilitando a depuração e o monitoramento de recursos em tempo real.

Primeiro, vamos executar o seguinte comando para verificar se já existe algum Metric Server rodando no servidor:

kubectl top node

Esse comando lista todos os serviços de API no cluster e verifica se o Metric Server já está ativo. Isso vai nos ajudar a identificar se precisamos configurar ou ajustar alguma coisa antes de continuar.

Aqui no meu ambiente, o Metric Server não está em execução e também não está registrado no apiservice do Kubernetes.

kubectl get apiservice

No Lens Desktop, as métricas também estão exibindo N/A, indicando que o Metric Server não está ativo ou configurado corretamente.

Primeiro, vamos instalar o Metric Server no nosso cluster.

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Agora, vamos verificar os logs do nosso Metric Server.

kubectl logs  -n kube-system -l k8s-app=metrics-server

Como podemos ver nos logs, o Metric Server está enfrentando dificuldades para se conectar ao Kubelet. Isso geralmente acontece quando ele não consegue validar o certificado, o que é comum em ambientes onde o certificado não está configurado corretamente.

Vou mostrar duas opções para resolver isso, começando pela primeira solução: desativar a verificação do certificado.

Opção 1: Desativar a verificação do certificado

Vamos editar o deployment do Metric Server para adicionar uma configuração que desabilita a verificação de certificados SSL. Isso permite que ele se comunique com o Kubelet sem exigir um certificado válido, ideal para ambientes de desenvolvimento ou testes.

1. Editar o deployment:

Primeiro, execute o comando abaixo para abrir o deployment do Metric Server:

export KUBE_EDITOR=nano
kubectl edit deployment metrics-server -n kube-system

2. Adicionar a opção de ignorar certificado:

No arquivo que será aberto, procure pela seção args e adicione o seguinte argumento:

--kubelet-insecure-tls

Essa linha desativa a verificação do certificado TLS, permitindo que o Metric Server se conecte ao Kubelet sem problemas de validação.

3. Salvar e sair:

Após adicionar essa opção, salve o arquivo e saia do editor. O Kubernetes vai atualizar automaticamente o deployment com as novas configurações.

Depois disso, o Metric Server deverá conseguir acessar o Kubelet e coletar as métricas corretamente, sem o bloqueio causado pela validação do certificado.

Agora, vamos verificar novamente os logs do Metric Server para ver se o problema de acesso ao Kubelet foi resolvido. Use o seguinte comando:

kubectl logs  -n kube-system -l k8s-app=metrics-server

Isso nos permitirá analisar os logs atualizados e verificar se o Metric Server está funcionando corretamente.

E no Lens, os pods já começam a mostrar também o consumo de recursos. Isso indica que o Metric Server está coletando e disponibilizando as métricas corretamente, permitindo que você monitore o uso de CPU e memória dos pods em tempo real.

Agora, vamos explorar a segunda opção: adicionar o certificado do Kubelet ao Metric Server. Se você implementou a primeira opção, lembre-se de remover a linha - --kubelet-insecure-tls do deployment do Metric Server.

Opção 2: Adicionar o certificado do Kubelet

1. Remover a opção anterior:

Se você utilizou a primeira opção, edite o deployment do Metric Server e remova a seguinte linha:

- --kubelet-insecure-tls

2. Editar o arquivo de configuração do Kubelet:

Em seguida, vamos configurar o Kubelet para gerar um certificado assinado pelo Kubernetes. Para isso, adicione a seguinte configuração no arquivo de configuração do Kubelet (normalmente localizado em /var/lib/kubelet/config.yaml):

serverTLSBootstrap: true

3. Reiniciar o Kubelet:

Após adicionar a configuração, reinicie o Kubelet para que as alterações entrem em vigor:

systemctl restart kubelet

Agora, vamos aprovar o certificado que o Kubelet solicitou ao Kubernetes. Isso é necessário para que o Kubelet possa se autenticar corretamente e que o Metric Server possa acessar as métricas.

Aprovar o certificado do Kubelet

1. Verificar as solicitações de certificados:

Execute o seguinte comando para listar as solicitações de certificados pendentes:

kubectl get csr

2. Aprovar a solicitação:

Identifique a solicitação correspondente ao Kubelet. Ela geralmente terá um nome que inclui o nome do nó. Use o nome da solicitação (substitua <nome-da-solicitacao> pelo nome real) para aprová-la:

kubectl certificate approve <nome-da-solicitacao>

3 Verificar se a solicitação foi aprovada:

Você pode verificar se a solicitação foi aprovada com o seguinte comando:

kubectl get csr

A coluna STATUS deve mostrar Approved para a solicitação que você acabou de aprovar.

Após aprovar o certificado, o Kubelet deve ser capaz de se conectar corretamente ao Kubernetes, e o Metric Server poderá acessar as métricas do Kubelet.

Agora, se você verificar os pods no namespace kube-system, verá que o Metric Server está em execução. Isso indica que a configuração foi bem-sucedida e que o Metric Server está coletando e processando as métricas do cluster corretamente.

Para confirmar, você pode usar o seguinte comando:

kubectl get pod   -n kube-system -l k8s-app=metrics-server

E no Lens, agora você deve conseguir visualizar o consumo de memória e CPU dos pods. Com o Metric Server em funcionamento, as métricas estarão disponíveis em tempo real, permitindo que você monitore o uso de recursos no seu cluster Kubernetes diretamente pela interface do Lens. Isso facilita a análise de desempenho e a identificação de possíveis problemas relacionados a recursos.

Pronto! O Metric Server já está configurado. Agora, vamos instalar o Kube-State-Metrics e o Node Exporter.

Instalação do Kube-State-Metrics

1. Baixar o repositório do Kube-State-Metrics:

Execute o comando abaixo para clonar o repositório:

git clone https://github.com/kubernetes/kube-state-metrics.git

2. Entrar na pasta:

Navegue até o diretório do Kube-State-Metrics:

cd  kube-state-metrics

3. Mudar para a release mais recente:

No momento, a versão mais recente é a release-2.13. Altere para essa versão:

git checkout release-2.13

4. Atualizar o repositório:

Execute o comando a seguir para garantir que você tenha as atualizações mais recentes:

git pull origin

5. Navegar até o diretório de exemplos:

Agora, vá até o diretório onde estão as configurações padrão para instalar o Kube-State-Metrics:

cd examples/standard

6. Aplicar as configurações no cluster:

Por fim, aplique as configurações para instalar o Kube-State-Metrics:

kubectl apply -k .

Ótimo! Agora que o Metric Server e o Kube-State-Metrics estão instalados e coletando métricas dos pods, vamos prosseguir com a instalação do Node Exporter criando um arquivo node-exporter.yml para o deployment e o service.

Criar o arquivo node-exporter.yml

1. Criar o arquivo:

Crie um arquivo chamado node-exporter.yml com o seguinte comando:

touch node-exporter.yml

2. Adicionar a configuração de Deployment e Service:

Abra o arquivo em um editor de texto e adicione a seguinte configuração:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
  namespace: kube-system
spec:
  selector:
    matchLabels:
      app: node-exporter
  template:
    metadata:
      labels:
        app: node-exporter
    spec:
      containers:
      - name: node-exporter
        image: quay.io/prometheus/node-exporter:latest
        ports:
        - containerPort: 9100
        volumeMounts:
        - name: proc
          mountPath: /host/proc
          readOnly: true
        - name: sys
          mountPath: /host/sys
          readOnly: true
        - name: rootfs
          mountPath: /host/rootfs
          readOnly: true
      volumes:
      - name: proc
        hostPath:
          path: /proc
      - name: sys
        hostPath:
          path: /sys
      - name: rootfs
        hostPath:
          path: /
---
apiVersion: v1
kind: Service
metadata:
  name: node-exporter
  namespace: kube-system
spec:
  ports:
    - name: metrics
      port: 9100
      targetPort: 9100
  selector:
    app: node-exporter 

3. Aplicar a configuração no cluster

Após salvar as alterações, aplique a configuração no seu cluster Kubernetes usando o seguinte comando:

kubectl apply -f node-exporter.yml

Agora você deve ter o Node Exporter instalado e coletando métricas do seu nó, complementando as métricas do Metric Server e do Kube-State-Metrics!

Vamos prosseguir com a instalação do Prometheus no seu cluster Kubernetes, criando um arquivo prometheus.yml com a configuração necessária. Em seguida, aplicaremos essa configuração para habilitar o monitoramento.

Criar o arquivo prometheus.yml

1. Criar o arquivo:

Execute o seguinte comando para criar o arquivo prometheus.yml:

touch prometheus.yml

2. Adicionar a configuração:

Abra o arquivo em um editor de texto e adicione o seguinte conteúdo:

apiVersion: v1
kind: Namespace
metadata:
  name: prometheus
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: prometheus
rules:
- apiGroups: [""]
  resources:
  - nodes
  - nodes/proxy
  - services
  - endpoints
  - pods
  verbs: ["get", "list", "watch"]
- apiGroups:
  - extensions
  resources:
  - ingresses
  verbs: ["get", "list", "watch"]
- nonResourceURLs: ["/metrics"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
- kind: ServiceAccount
  name: default
  namespace: prometheus
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-server-conf
  namespace: prometheus
data:
  prometheus.yml: |-
    global:
      scrape_interval: 15s
      evaluation_interval: 15s
    scrape_configs:
      - job_name: 'kubernetes-apiservers'
        kubernetes_sd_configs:
        - role: endpoints
        scheme: https
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
        relabel_configs:
        - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
          action: keep
          regex: default;kubernetes;https
      - job_name: 'kubernetes-pods'
        kubernetes_sd_configs:
        - role: pod
        relabel_configs:
        - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
          action: keep
          regex: true
        - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
          action: replace
          target_label: __metrics_path__
          regex: (.+)
        - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
          action: replace
          regex: ([^:]+)(?::\d+)?;(\d+)
          replacement: $1:$2
          target_label: __address__
        - action: labelmap
          regex: __meta_kubernetes_pod_label_(.+)
        - source_labels: [__meta_kubernetes_namespace]
          action: replace
          target_label: kubernetes_namespace
        - source_labels: [__meta_kubernetes_pod_name]
          action: replace
          target_label: kubernetes_pod_name
      - job_name: 'kube-state-metrics'
        static_configs:
          - targets: ['kube-state-metrics.kube-system.svc.cluster.local:8080']
      - job_name: 'kubernetes-cadvisor'
        scheme: https
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
        kubernetes_sd_configs:
        - role: node
        relabel_configs:
        - action: labelmap
          regex: __meta_kubernetes_node_label_(.+)
        - target_label: __address__
          replacement: kubernetes.default.svc:443
        - source_labels: [__meta_kubernetes_node_name]
          regex: (.+)
          target_label: __metrics_path__
          replacement: /api/v1/nodes/${1}/proxy/metrics/cadvisor
      - job_name: 'kubernetes-service-endpoints'
        kubernetes_sd_configs:
        - role: endpoints
        relabel_configs:
        - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scrape]
          action: keep
          regex: true
        - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scheme]
          action: replace
          target_label: __scheme__
          regex: (https?)
        - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_path]
          action: replace
          target_label: __metrics_path__
          regex: (.+)
        - source_labels: [__address__, __meta_kubernetes_service_annotation_prometheus_io_port]
          action: replace
          target_label: __address__
          regex: ([^:]+)(?::\d+)?;(\d+)
          replacement: $1:$2
        - action: labelmap
          regex: __meta_kubernetes_service_label_(.+)
        - source_labels: [__meta_kubernetes_namespace]
          action: replace
          target_label: kubernetes_namespace
        - source_labels: [__meta_kubernetes_service_name]
          action: replace
          target_label: kubernetes_name
      - job_name: 'kubernetes-nodes'
        kubernetes_sd_configs:
          - role: node
        relabel_configs:
          - target_label: __address__
            replacement: node-exporter.kube-system.svc.cluster.local:9100
          - source_labels: [__meta_kubernetes_node_name]
            regex: (.+)
            target_label: __metrics_path__
            replacement: /metrics
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus-server
  namespace: prometheus
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prometheus-server
  template:
    metadata:
      labels:
        app: prometheus-server
    spec:
      containers:
        - name: prometheus
          image: prom/prometheus
          ports:
            - containerPort: 9090
          volumeMounts:
            - name: config-volume
              mountPath: /etc/prometheus
      volumes:
        - name: config-volume
          configMap:
            name: prometheus-server-conf
            defaultMode: 420    
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus-service
  namespace: prometheus
spec:
  selector:
    app: prometheus-server
  ports:
  - name: https
    protocol: TCP
    port: 443
    targetPort: 9090  
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: prometheus-ingress
  namespace: prometheus
  annotations:
    nginx.ingress.kubernetes.io/backend-protocol: HTTP
spec:      
  rules:
    - host: prometheus.meuservidor.com
      http:
        paths:
          - pathType: Prefix
            path: "/"
            backend:
              service:
                name: prometheus-service
                port:
                  number: 443

Aplicar a configuração do Prometheus

Após adicionar as configurações, aplique o arquivo no seu cluster Kubernetes:

kubectl apply -f prometheus.yml

Verificação

Agora que o Prometheus está instalado e configurado, você deve conseguir monitorar suas métricas.

Próximo Passo: Instalar o Grafana

Com o Prometheus em funcionamento, vamos instalar o Grafana para visualizar as métricas coletadas. Podemos proceder com a instalação do Grafana para obter gráficos e relatórios visuais das métricas do Kubernetes.

Agora vamos instalar o Grafana e visualizar nossas métricas.

1. Criar o arquivo:

Execute o seguinte comando para criar o arquivo prometheus.yml:

touch grafana.yml

2. Adicionar a configuração:

Abra o arquivo em um editor de texto e adicione o seguinte conteúdo:

apiVersion: v1
kind: ConfigMap
metadata:
  name: grafana-config
  namespace: grafana
data:
  grafana.ini: |
    [security]
    admin_user = admin
    admin_password = admin

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: grafana
  namespace: grafana
  labels:
    app: grafana
spec:
  replicas: 1
  selector:
    matchLabels:
      app: grafana
  template:
    metadata:
      labels:
        app: grafana
    spec:
      containers:
        - name: grafana
          image: grafana/grafana:latest
          ports:
            - containerPort: 3000
          volumeMounts:
            - name: grafana-storage
              mountPath: /var/lib/grafana
            - name: grafana-config
              mountPath: /etc/grafana/grafana.ini
              subPath: grafana.ini
      volumes:
        - name: grafana-storage
          emptyDir: {}
        - name: grafana-config
          configMap:
            name: grafana-config

---
apiVersion: v1
kind: Service
metadata:
  name: grafana-service
  namespace: grafana
  labels:
    app: grafana
spec:
  type: ClusterIP
  ports:
    - port: 443
      targetPort: 3000
  selector:
    app: grafana
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: grafana-ingress
  namespace: grafana
  annotations:
    nginx.ingress.kubernetes.io/backend-protocol: HTTP
spec:
  rules:
    - host: grafana.meuservidor.com
      http:
       paths:
          - pathType: Prefix
            path: "/"
            backend:
              service:
                name: grafana-service
                port:
                  number: 443

Aplicar a configuração do Prometheus

Após adicionar as configurações, aplique o arquivo no seu cluster Kubernetes:

kubectl apply -f grafana.yml

Com isso, já temos nosso Grafana disponível!

Vamos acessar grafana.meuservidor.com.

Acesso ao Grafana

1. Abrir o navegador: Digite o endereço grafana.meuservidor.com na barra de endereços.
2. Credenciais de Login:

• Usuário: admin
• Senha: admin

Com isso, o Grafana solicitará que você mude a senha. Você pode mudar se desejar, mas eu vou pular essa etapa.

Agora, vamos adicionar o Prometheus ao Grafana. Para isso, siga os passos abaixo:

1. Acesse a seção Data Sources no Grafana.

1. Clique em Add Data Source.

1. Selecione Prometheus na lista de opções disponíveis.

Após adicionar nossa URL do Prometheus,

Clique em Save & Test para verificar a conexão. Isso garantirá que o Grafana esteja se comunicando corretamente com o Prometheus e que os dados possam ser extraídos para visualização.

Se tudo estiver configurado corretamente, você verá uma mensagem de sucesso.

Agora, vamos criar um dashboard. Acesse a seção de Dashboards no Grafana para começar a configurar suas visualizações.

Vamos importar um novo dashboard. Isso nos permitirá visualizar as métricas de forma mais eficiente e personalizada.

Vamos adicionar o dashboard número 1860 e carregá-lo no Grafana. Isso nos proporcionará uma visualização detalhada das métricas de Kubernetes, ajudando na análise do desempenho do cluster.

Com isso, vamos adicionar nosso Prometheus ao dashboard. Isso permitirá que você visualize as métricas coletadas diretamente no Grafana. Siga os passos para configurar a fonte de dados e integrar as métricas do Prometheus ao seu dashboard.

Agora vamos importar nosso dashboard. Após a importação, o Grafana redirecionará automaticamente para o novo dashboard, onde você poderá visualizar as métricas e dados que configuramos anteriormente.

Pronto! Você agora tem um dashboard com informações sobre o seu cluster. Nele, você poderá monitorar métricas como consumo de CPU, memória e outros dados relevantes em tempo real.