Monitoramento e visualização de métricas com Docker Compose, Prometheus e Grafana.
Published: 2024-05-31 10:07:57



![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pulqr7pwcnimxqkaobk2.png)




**Introdução:**

Prometheus e Grafana são duas ferramentas utilizadas no monitoramento e visualização de métricas de aplicações, porem têm propósitos e funcionalidades diferentes. Durante este tutorial, vamos ver quais a diferenças e como utilizadas.


**Prometheus:**
O Prometheus é uma ferramenta de monitoramento e sistema de alerta. Ele é projetado para coletar e armazenar métricas de sistemas e aplicações.

O Prometheus possui um sistema de alertas embutido, onde você pode definir regras de alerta que serão analisadas, e se uma condição for atendida, o Prometheus enviará alertas para várias integrações, como e-mail, Slack por exemplo.

**Grafana:**
O Grafana é uma plataforma de visualização de métricas. Ele é usado para criar dashboards interativos e gráficos a partir de várias fontes de dados como o Prometheus, InfluxDB, Graphite, Elasticsearch.

Para começar a monitorar uma aplicação Spring Boot com Prometheus e Grafana, vamos configurar um ambiente usando Docker Compose. Primeiro, precisamos criar um arquivo _docker-compose.yml_ com os serviços do Prometheus e Grafana.

```
prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - "./src/main/resources/prometheus.yml:/etc/prometheus/prometheus.yml"
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:9.5.15
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - ./grafana/provisioning:/etc/grafana/provisioning
    depends_on:
      - prometheus
    healthcheck:
      test: [ "CMD", "nc", "-z", "localhost", "3000" ]
```

Vamos, precisar também configurar o arquivo prometheus.ym do Prometheus, ele e o responsável por coletar o onde configuramos os alvos de scraping, ou seja, os endpoints que o Prometheus irá coletar métricas.

Para o Grafana, precisamos configurar um painel para visualizar as métricas coletadas pelo Prometheus.

```
# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).


# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.
    static_configs:
      - targets: ['127.0.0.1:9090']

    - job_name: 'spring-boot-actuator'
    scrape_interval: 5s # Define a frequência com que o Prometheus deve coletar métricas
    metrics_path: '/actuator/prometheus' # O caminho onde as métricas do Micrometer são expostas
    static_configs:
      - targets: ['host.docker.internal:8080'] # O endpoint da sua aplicação Spring Boot
        labels:
          application: book-api

  - job_name: 'grafana'
    metrics_path: '/'
    scrape_interval: 5s
    static_configs:
      - targets: ['127.0.0.1:3000']
```

OBS: Na minha tag targets, eu configurei o host da minha aplicação desta da seguinte forma host.docker.internal, isso por que minha aplicação esta rodando em um container docker.

Vamos configurar o _application.yml_ da nossa aplicação.

```
management:
  endpoints:
    web:
      base-path: /actuator
      exposure:
        include: "*"
  endpoint:
    prometheus:
        enabled: true
    metrics:
        enabled: true
```

Vamos também adicionar duas dependências no nosso POM.xml.
A dependencia do actuator e a dependencia do prometheus.

A dependência _spring-boot-starter-actuator_ é uma dependência que fornece recursos de monitoramento e gerenciamento.

A dependência _micrometer-registry-prometheus_ é utilizada para integrar o Spring Boot Actuator com o Micrometer e o Prometheus.


```
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

<dependency>
   <groupId>io.micrometer</groupId>
   <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
```

Feito isso vamos executar o comando docker-compose up -d e veremos os containers iniciados.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bcq9p0gb61rp8djvvy0w.png)


Acessando a url do Prometheus http://localhost:9090, podemos ver que os serviços estão com o status “UP”, ou seja, estão saudáveis e funcionando.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uw2t9ye8o2mh1qpiqcho.png)


Agora, vamos configurar os gráficos de monitoramento do Grafana. Acesse a url http://localhost:3000/connections/connect-data, e pesquise por Prometheus


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p0gbt9qui9o4uwm0qpmg.png)


Clique na opção “Create a Prometheus data source”, preencha o campo URL com a url do Prometheus, no caso como meu Prometheus esta em um container Docker precisamos pegar o IP do nosso container.

Execute o seguinte comando docker inspect <id_do_container>

Na seção Networks > IPAddress: “192.168.240.3”, feito isso adicione do campo URL e clique em salvar.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hnrpsevag8nsz8uruplh.png)

Agora vamos configurar os gráficos de monitoramento do Grafana.

Acesse a url http://localhost:3000/dashboards

Acesse a opção New > Import e adicione a url http://grafana.com/grafana/dashboards/4701, essa URL e um gráfico disponibilizado no próprio site do Grafana, mas você pode escolher outros tipos de gráfico conforme a sua necessidade. Feito isso clique em load.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2a9q4c71y24yran07n2x.png)


Depois disso, selecione Prometheus no campo de datasource e clique em Import.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/to0h73mn4z3pw467ixrm.png)


Em seguida, podemos ver o gráfico com os dados do coletados pelo nosso Prometheus. Lindo não é mesmo ?


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lfeiyily7x1tjb1ddwrs.png)



**Conclusão:**

O monitoramento de uma aplicação é uma maneira de garantir que sua aplicação esteja funcionando de forma confiável e eficiente. Ao coletar e visualizar métricas importantes, você pode identificar problemas de desempenho, capacidade e disponibilidade antes que eles afetem os usuários finais. Estas ferramentas oferecem uma solução poderosa e flexível para monitorar e manter a saúde de suas aplicações em produção.