Monitoramento: Prometheus, Grafana e .Net Core 3.1 — Parte 2
Desenvolver aplicações que serão utilizadas por milhares de usuários não é uma tarefa fácil, ainda mais quando falamos de cenários de micro serviços escaláveis onde poderemos ter diversos tipos de comunicação entre esses serviços. Como acompanhar a saúde, comportamento da aplicação e sua infraestrutura?
Podemos utilizar alguns recursos que nos auxiliam nesta tarefa e um desses é o Prometheus, uma solução que oferece monitoramento e alerta de código aberto.
O que é o Prometheus?
Conforme informado no github do prometheus, Prometheus é um projeto da Cloud Native Computing Foundation, é um sistema de monitoramento de sistemas e serviços. Ele coleta métricas de destinos configurados em determinados intervalos de tempo, avalia expressões de regra, exibe os resultados e pode acionar alertas quando condições especificadas são observadas.
Suas principais características são:
- É um modelo de dados multidimensional — time series
- Possui uma linguagem de consulta poderosa e flexível chamada PromQL
- Possui diversos modos de suporte para gráficos e painéis.
- Possui um modelo de pull HTTP para coleta de série temporal
- É autônomo, sem dependência de armazenamento externo
- Os alvos (APIs) são descobertos por meio de descoberta de serviço ou configuração estática.
A configuração do Prometheus é totalmente textual. O servidor é configurado a partir de arquivos de extensão .yaml, neste arquivo podemos adicionar nossos alvos (APIs) ao monitoramento, entre outras diversas funcionalidades.
YAML é um formato de serialização (codificação de dados) de dado legíveis por humanos inspirado em linguagens como XML, C, Python, Perl. Esse formato de arquivo de tecnologia é usado em documentos.
Abaixo segue um exemplo do arquivo de configuração do servidor Prometheus monitorando nossa api criada no primeiro artigo dessa série.
O Prometheus é agnóstico a linguagens de programação e possui bibliotecas clientes oficiais que são compatíveis e estão disponíveis para as linguagens Go, Java, Scala, Python e Ruby. Há algumas bibliotecas não oficiais disponíveis paras as linguagens .Net C#, Dart, Node.Js, PHP, R entre outros, sendo ainda possível desenvolver sua própria biblioteca.
Entre os principais componentes do Prometheus incluem o servidor Prometheus (que lida com descoberta de serviços, recuperação e armazenamento de métricas de aplicações monitoradas, análise de dados de séries temporais usando a linguagem de consulta PromQL).
O Prometheus é excelente para monitorar métricas e indicadores, esse é o objetivo que ele se propõe a fazer. Não é uma ferramenta de gerenciamento de desempenho de aplicações, porque se concentra exclusivamente em métricas do lado do servidor. A ferramenta não oferece rastreamento de chamada distribuída, descobrimento e visualização de topologia de serviço, análise de desempenho ou monitoramento da experiência do usuário final.
O fluxo da informação no Prometheus é unidirecional, então, não pode ser usado para controle ativo.
Chega de teoria, bora pra prática.
Mão na massa
Agora que sabemos o que é o Prometheus e o seu propósito, vamos ver ele trabalhando na prática. O objetivo é entendermos como o Prometheus Server funciona e como podemos configurá-lo para coletar métricas da nossa api.
Pré-requisitos
Afim de termos uma boa experiência com o laboratório proposto neste artigo, será necessário a instalação de algumas ferramentas que são o Docker e Docker Compose.
Segue abaixo os links das instalações oficiais:
Recapitulando
No primeiro artigo criamos nossa api, porém fiz algumas atualizações nela afim de melhorar nossa experiência com os testes que iremos fazer nesse artigo. Algumas atualizações foram:
- Criamos uma controle para Listagem de Clientes e Buscar Cliente por Id
- Configuramos o Swagger para termos nossos endpoints documentados
- Criamos uma configuração para abrir o swagger no start da aplicação.
- Criamos um Dockerfile para fazer o deploy da aplicação dentro de um container.
Segue link da api com as atualizações no github: clique aqui
Após as atualizações, ao iniciarmos nosso projeto, no endpoint localhost:8888/swagger/index.html, ele irá abrir nosso swagger, conforme imagem abaixo.
Configurando o Prometheus
No diretório onde se encontra a pasta Root da nosso serviço web-api-metrics, iremos criar uma nova pasta com nome prometheus e também iremos criar um arquivo chamado docker-compose.yml. O diretório deverá ficar conforme imagem abaixo.
Na pasta prometheus iremos incluir as configurações do prometheus para ele rodar dentro do conteiner do docker.
Não se preocupe com o conteúdo do arquivo docker-compose.yml, mais a frente iremos incluir algumas configurações e cada uma dessas configurações será explicada e detalhada.
Dentro da pasta prometheus iremos criar alguns arquivos e diretórios que seguem:
- crie um arquivo chamado Dockerfile (perceba que o arquivo Dockerfile não tem extensão)
- crie um arquivo chamado prometheus.yml
- crie uma pasta chamada data
No arquivo Dockerfile iremos configurar a imagem do prometheus como segue abaixo:
Neste arquivo estamos:
- Buscando a imagem do prometheus prom/prometheus:v2.17.1
- Copiando nosso arquivo prometheus.yml para dentro do diretório /etc/prometheus que irá se econtrar dentro do contêiner
- Definimos um volume na pasta /data para persitir nossas informações do prometheus no host caso percamos nosso container.
- Estamos expondo a imagem na porta 9090
No arquivo prometheus.yml iremos incluir algumas configurações.
Neste arquivos estamos:
- Setando o intervalo de 5 segundos para que o prometheus realize o pull das métricas
- Estamos dando o nome web-api-metrics-job para o job do prometheus
- Incluindo o endereço que o nosso serviço estará rodando e qual caminho ele irá encontrar as métricas /metrics
- observação: Onde está o endereço IP, você deverá coloca o IP da sua máquina. Estamos utilizando o IP por que o prometheus e a nossa api irão se comunicar via containers do docker.
A princípio, essa são as configurações que devemos fazer no Prometheus para ele passar a buscar as informações que nossa api está gerando no endpoint /metrics
Agora voltaremos para o diretório raiz do nosso projeto, para incluir as configurações necessárias no nosso arquivo docker-compose.yml
Vamos entrar um pouco mais no detalhe desse arquivo.
Dentro de services, temos dois serviços configurados que são api e prometheus.
No service api, estamos fazendo o seguinte:
- Na tag context estamos dizendo nosso contexto é dentro do diretório /web-api-metrics, e que dentro desse diretório existe um arquivo Dockerfile.
- Na tag image estamos dando um nome para a nossa imagem, que é web-api-metrics-image
- Na tag port estamos fazendo o mapeamento das portas, onde o serviço roda na porta 80 dentro do container, e iremos expor a porta 8888 para o host.
- Na tag networks estamos apontando pra nossa configuração de rede web_api_metrics_networks onde os containeres irão se comunicar.
No service prometheus, estamos fazendo o seguinte:
- Na tag context estamos dizendo nosso contexto é dentro do diretório /prometheus, e que dentro desse diretório existe um arquivo Dockerfile.
- Na tag image estamos dando um nome para a nossa imagem, que é prometheus-local-image
- Na tag restart quando colocamos always significa que o contêiner será reinicializado sempre que houver alguma atualização.
- Na tag port estamos fazendo o mapeamento das portas, onde o serviço roda na porta 9090 dentro do container, e iremos expor a porta 9090.
- Na tag networks estamos apontando pra nossa configuração de rede web_api_metrics_networks onde os containeres irão se comunicar.
Em networks, estamos fazendo o seguinte:
- criamos uma rede com o nome web_api_metrics_network
- e colocamos o driver como overlay, isso significa que criamos uma rede distribuída em vários hosts daemon do Docker. Essa rede fica no topo (sobrepõe) as redes especificas do host.
Em teoria é isso, com as configurações que temos até o momento, já podemos rodar nosso projeto e ver o prometheus coletando as informações.
Antes de executar os próximos comandos do Docker, certifique-se que o Docker da sua máquina esteja rodando, blz?
Vamos lá, abra um Command Line da sua preferença, navegue até o diretório onde está nosso arquivo docker-compose.yml no diretório raiz do nosso projeto.
Após isso execute o seguinte comando:
- docker-compose up
Após a execução do comando docker-compose up, a construção dos containeres da nossa api e do prometheus deverão ser construidos.
No Windows temos um recurso bem interessante para gerenciarmos nossos conteineres que é o Docker Desktop. Ele oferece uma forma visual para conseguirmos analisar nossos conteineres conforme imagem abaixo.
Nesta tela podemos ver nossos dois conteineres em execução, o contêiner da api e o contêiner do prometheus.
Testando nosso cenário
Nossa API web-api-metrics está rodando na porta 8888, conforme configuramos no arquivo docker-compose.yml.
Se abrimos no navegador a url http:localhost:8888/metrics iremos ver as metricas geradas pela biblioteca do prometheus para o .Net Core.
Para acessarmos o swagger da API, devemos navegar na url: http:localhost:8888/swagger/index.hml . então veremos a documentação da API, onde iremos realizar nossos testes.
Podemos observar que nossa api tem dois endpoints, o endpoint /api/customers é onde iremos realizar a listagem de clientes, e o endpoint /api/customers/customer é onde iremos buscar o cliente pelo seu codigo de identificação.
A ideia é que, sempre que recebermos alguma requisição nesses endpoints, o prometheus contabilize pra gente quantas requisições esses endpoints receberam, entre outras métricas que veremos a seguir.
Vamos ver agora a interface do prometheus que estamos executando pelo Docker na porta 9090
Podemos perceber que o prometheus está observando nossa api no endpont e porta que configuramos, localhost:8888/metrics
Após realizar algumas requisições nos endpoints de listagem de clientes, e busca de cliente por id, podemos ver as seguintes informações no prometheus:
- Quantidade de requisições por endpoint
- Gráfico de quantidade de requisições por endpoint
- Gráfico que verifica se nossa api está funcionando
- Gráfico que mostra o processamento da CPU por segundo
Existem diversos tipos de métricas que podemos capturar com o Prometheus, as métricas apresentadas acima são apenas algumas.
Com apenas algumas configurações, podemos tirar métricas valiosas dos nossos serviços com o objetivo de prover disponibilidade e qualidade para os mesmos.
Você deve estar se perguntando, ok entendi, mas e ai?
- Só conseguimos gerar esse tipo de gráfico?
- E se eu quiser customizar os gráfico e criar um dashboard com as informações que eu achar importante de forma consolidada, como eu faço isso?
Para responder essas perguntas, eu vou lhe apresentar o Grafana, mas isso será em outro momento, enquanto isso, absorva o conteúdo que discutimos nesse artigo e compartilhe com seus amigos caso ache o tema relevante.
No próximo artigo, iremos entender o que é o Grafana e como podemos configurá-lo para consumir os dados que o Prometheus coleta e como podemos criar e customizar nosso dashboard afim de consolidar todas as informações importantes da nossa api.
Nos vemos no próximo artigo, até lá galera! 😀
Link do projeto no github:
Artigo — Parte 1
Artigo — Parte 3
Referências
https://medium.com/tech-grupozap/prometheus-monitorando-a-sa%C3%BAde-da-sua-aplica%C3%A7%C3%A3o-bd9b3b63e7b1
https://movile.blog/monitoramento-de-servicos-com-prometheus/
https://www.infoq.com/br/articles/prometheus-monitor-applications-at-scale/#:~:text=O%20Prometheus%20%C3%A9%20%C3%B3timo%20para,m%C3%A9tricas%20do%20lado%20do%20servidor.
