> For the complete documentation index, see [llms.txt](https://devops.nataliagranato.xyz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://devops.nataliagranato.xyz/monitorando-nosso-gerador-de-senhas-com-prometheus-e-grafana.md).

# Monitorando nosso gerador de senhas com Prometheus e Grafana

No Kubernetes o Prometheus coleta métricas do Kubernetes de várias maneiras:

* Exportadores: O Prometheus utiliza exportadores para coletar métricas de diferentes componentes do Kubernetes, como:
* kube-state-metrics: Coleta métricas sobre o estado dos objetos do Kubernetes, como Pods, Nós, Deployments, etc.
* node-exporter: Coleta métricas sobre o hardware e sistema operacional dos nós do Kubernetes.
* Endpoints de métricas: Alguns componentes do Kubernetes, como o API server, controller manager e scheduler, expõem seus próprios endpoints de métricas que o Prometheus pode scrape diretamente.
* Descoberta de serviço: O Prometheus utiliza a descoberta de serviço do Kubernetes para encontrar automaticamente os alvos (targets) a serem monitorados, como Pods e Serviços.
* Regras de alerta: O Prometheus permite definir regras de alerta com base nas métricas coletadas, que podem ser usadas para notificar sobre problemas no cluster Kubernetes.

Então, em resumo, o Prometheus utiliza uma combinação de exportadores, endpoints de métricas e descoberta de serviço para coletar as métricas do Kubernetes de forma abrangente e automatizada.

O Prometheus utiliza uma combinação de exportadores, endpoints de métricas e descoberta de serviço para coletar as métricas do Kubernetes de forma abrangente e automatizada.

Em nosso projeto criamos dois objetos Kubernetes, o `PodMonitor` e o `ServiceMonitor` para monitorar a nossa aplicação.

### Definição dos objetos

### Instalando o Prometheus e o Grafana

Para fazer a instalação do Prometheus use os comandos abaixo:

```
git clone https://github.com/prometheus-operator/kube-prometheus.git
cd kube-prometheus
kubectl create -f manifests/setup
kubectl create -f manifests/
```

### Acessando o Prometheus

```
kubectl get service -n monitoring

kubectl port-forward -n monitoring service/prometheus-k8s 9090:9090
```

### Acessando o Grafana

```
kubectl port-forward -n monitoring service/grafana 3000:3000
```

Por padrão a senha e o usuário do Grafana é `admin`, posteriormente será solicitada a troca de senha. Foram criados manifestos de ingress para acessar o Prometheus e o Grafana, disponíveis na pasta `/monitoring`.

As aplicações estão acessíveis através dos seguintes endereços:

* Prometheus: <https://prom.nataliagranato.xyz/>
* Grafana: <https://grafana.nataliagranato.xyz>

### Criando um service monitor e um pod monitor

Para monitorar a nossa aplicação, criamos um `ServiceMonitor` e um `PodMonitor`. O `ServiceMonitor` monitora os serviços da aplicação e o `PodMonitor` monitora os pods da aplicação. As definições dos objetos estão disponíveis na pasta `/monitoring`.

O nosso ServiceMonitor monitora o serviço `giropops-senhas` no namespace `giropops-senhas`:

```yaml
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  labels:
    app: giropops-senhas
  name: sm-giropops-senhas
  namespace: giropops-senhas
spec:
  endpoints:
  - port: tcp-app
  selector:
    matchLabels:
      app: giropops-senhas
```

O nosso PodMonitor monitora os pods do deployment `giropops-senhas` no namespace `giropops-senhas`:

```yaml
apiVersion: monitoring.coreos.com/v1
kind: PodMonitor
metadata:
  labels:
    app: giropops-senhas
  name: pd-giropops-senhas
  namespace: giropops-senhas
spec:
  selector:
    matchLabels:
      app: giropops-senhas
  podMetricsEndpoints:
  - port: tcp-app
```

Para encontrar o `service` e o `pod` corretos o Prometheus utiliza o `selector` e o `port` definidos no `ServiceMonitor` e no `PodMonitor`.

Para verificar se o Prometheus começou a monitorar a aplicação, acesse a aba `Status` do Prometheus e verifique se o `ServiceMonitor` e o `PodMonitor` estão aparecendo na lista de `Service Discovery`.

Vamos aplicar os manifestos:

```
cd monitoring
kubectl apply -f service-monitor.yaml -n giropops-senhas
kubectl apply -f pod-monitor.yaml -n giropops-senhas
```

### Criando um alerta no Prometheus com o Alertmanager

Para criar um alerta no Prometheus, precisamos definir uma regra de alerta e configurar o Alertmanager para enviar notificações. Vamos criar um alerta para monitorar caso o nosso `deployment` fique fora do ar por mais de 1 minuto.

```yaml
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: giropops-senhas-rules
  namespace: monitoring
  labels:
    app.kubernetes.io/name: prometheus
spec:
  groups:
  - name: giropops-senhas
    rules:
    - alert: GiropopsSenhasDown
      expr: up{namespace="giropops-senhas", app="giropops-senhas"} == 0
      for: 1m
      labels:
        severity: critical
      annotations:
        summary: "A aplicação Giropops Senhas está fora do ar"
        description: "A aplicação Giropops Senhas no namespace giropops-senhas está fora do ar por mais de 1 minutos."
```

Vamos aplicar o manifesto:

```
kubectl apply -f prometheus-rule.yaml -n monitoring
```

É possível visualizar o alerta no Prometheus, acessando a aba `Alerts` do Prometheus.

### Integrando o Alertmanager com o Grafana

Para integrar o Alertmanager com o Grafana, precisamos configurar Alertmanager como datasource no Grafana e criar um painel para exibir os alertas. Siga os passos abaixo:

1. Acesse o Grafana em <https://grafana.nataliagranato.xyz> e faça login com o usuário `admin` e a senha definida anteriormente.
2. No menu lateral clique em Configuration > Data Sources.
3. Clique em `Add data source`.
4. Selecione `Alertmanager` como tipo de data source.
5. Dê um nome para a nova data source, por exemplo `Alertmanager`.
6. Selecione a `Implementation` como `Prometheus` e habilite a opção `Receive Grafana alerts` para receber os alertas do Grafana no Alertmanager.
7. Configure o endereço do Alertmanager como `http://alertmanager-main.monitoring.svc.cluster.local:9093`. Estamos usando o DNS interno do Kubernetes para fazer a conexão entre o Grafana e o Alertmanager. O tipo de `Access` deve ser `Server`.
8. Clique em `Save & Test` para salvar a data source.

Agora é possível visualizar os alertas do Prometheus no Grafana. Acesse Alerting > Alerts rules e procure pelo nome do alerta `GiropopsSenhasDown`. Clique no botão `Create Alert` para criar um painel com o alerta.

A dashboard está acessível em [**Painel do Grafana**](https://grafana.nataliagranato.xyz/public-dashboards/56431da54e9143438ef8e5da78258347)

### Observação

No painel `status da aplicação` usamos a opção de `Value mapping` para mapear os valores de `up` para `1` e `0` para `up` e `down`, respectivamente. Isso permite exibir o status da aplicação como `up` ou `down` no painel.

A `query` usada para o painel `status da aplicação` é `up{namespace="giropops-senhas", app="giropops-senhas"}`.