Monitoramento: Prometheus, Grafana e .Net Core 3.1 — Parte 3
Chegamos na última etapa dessa nossa pequena jornada e espero que o conteúdo compartilhado aqui possa lhe ajudar de alguma forma no trabalho ou nos estudos.
Se você ainda não viu os primeiros dois artigos, vou deixar os links abaixo
Então, vamos lá.
Poder visualizar as métricas e informações de negócio são essenciais para a empresa. Analisar os dados permite entender o que está acontecendo e ter uma ação proativa com intuito de otimizar processos e melhorar a tomada de decisão.
Para isso temos o Grafana para nos ajudar.
O Grafana é um excelente recurso para visualização de dados em tempo real, possui mecanismos para elaboração de dashboards customizáveis e flexiveis. Vamos entender melhor.
O que é o grafana?
Grafana é uma aplicação web que fornece visualização interativa dos dados. Ele fornece diversos recursos de visualização como tabelas, gráficos, mapas de calor, painéis de textos livre e alertas. É expansível através de um sistema de plug-ins, os usuários finais podem criar painéis de monitoramento complexos usando consultas interativas representando métricas específicas em um determinado período de tempo, como veremos a seguir.
Por que utilizar o Grafana?
Com essa ferramenta poderosa podemos compartilhar informações importantes com toda a equipe, informações que podem vir de diferentes fontes de dados, como bancos de dados, planilhas de excel, plugins entre outras tantas, e com isso consolidar todas essas informaçõe em um lugar centralizado por meio de uma única interface intuitiva e completa. Isso pode facilitar o gerenciamento dos indicadores e facilitar a tomada de decisão de forma rápida e eficiente.
Mão na massa
Agora que sabemos que é o Grafana e o seu propósito, assim como fizemos com o prometheus no artigo anterior, vamos ver ele trabalhando na prática. Nosso objetivo será entender como o Grafana funciona e como podemos criar dashboards customizáveis de forma rápida e eficiente.
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 segundo artigo configuramos o prometheus para buscar as métricas da API criada no primeiro artigo e com isso gerar um gráfico de linha dentro do prometheus, porém os gráficos fornecidos pelo prometheus não nos oferece uma boa experiência e isso é o motivo de estarmos aqui. Caso não tenha visto os dois primeiros artigos, sugiro que o faça ou então baixe o projeto que foi disponibilizado no github para acompanhar nosso laboratório.
Configurando o Grafana
No diretório onde se encontra a pasta Root do nosso projeto web-api-metrics, iremos criar uma nova pasta com nome grafana.
Dentro dela, criaremos as seguintes pastas e arquivos (vamos detalhar um-por-um a seguir):
Na pasta grafana iremos incluir as configurações do grafana para ele rodar dentro de um contêiner do docker.
Dentro da pasta grafana 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 três pastas com os seguintes nomes:
- config
- dashboards
- provisioning
- dentro do diretório config crie um arquivo com nome grafana.ini
- dentro do diretório dashboards crie um arquivo com nome dashboard-webmetric.json
- dentro do diretório provisioning crie os seguintes diretórios
- dashboards
- datasource
- notifiers
- dentro do diretório dashboards em provisioning crie um arquivo com nome dashboard.yml
- dentro do diretório datasource crie um arquivo com nome datasource.yml
- dentro do diretório notifiers crie um arquivo com nome alertNotificationChannel.yml
No arquivo Dockerfile iremos configurar a imagem do grafana como segue abaixo:
Neste arquivo estamos:
- Buscando a imagem do grafana grafana/grafana:7.3.1
- Copiando nosso arquivo grafana.ini para dentro do diretório /etc/grafana que irá se encontrar dentro do contêiner.
- Copiando o diretório provisioning para substituir o diretório provisioning dentro do contêiner.
- Copiando o diretório dashboards para subistituir o diretório dashboards dentro do contêiner.
- Estamos expondo a imagem na porta 3000.
No arquivo grafana.ini dentro do diretório config iremos inserir algumas configurações para o grafana como segue imagem abaixo:
Nesse arquivo estamos:
- inserindo nosso usuário e senha para podermos acessar o grafana.
- setando o caminho de onde será feito o provisionamento dentro da imagem do grafana.
- setando o tema do grafana para dark
No arquivo dashboard.yml dentro do diretório provisioning/dashboards iremos incluir as seguintes configurações:
As configurações mais importantes são::
- colocando o intervalo de atualização dos dashboards a cada 10 segundos.
- incluindo o caminho de onde irá ficar os dasboards criados.
No arquivo datasource.yml dentro do diretório provisioning/datasources iremos incluir as seguintes configurações:
As configurações mais importantes são:
- colocar a url do prometheus que subimos
- setar o nome do datasource prometheus-metrics
- setar que o dashboard será editável
- setar o tipo de acesso será proxy
No arquivo alertNotificationChannel.yml dentro do diretório provisioning/notifiers iremos incluir as seguintes configurações:
As configurações mais importantes são::
- setar o tipo de alerta como teams, que será o canal que receberá o alerta.
- setar a frequência de 15 horas que é o tempo que o alerta será disparado para o canal do teams.
- setar a url do web hook gerado pelo teams.
Acredito que tenha percebido que não incluimos nenhuma configuração para o arquivo dasboard-webmetric.json dentro do diretório config/dashboards. Não se preocupe, mais pra frente iremos incluir as configurações nesse arquivo.
Vamos colocar nosso grafana pra rodar, pra isso iremos incluir as configurações de inicialização do grafana no arquivo docker-compose.yml
No arquivo docker-compose.yml, vamos focar na configuração do grafana.
No service grafana, estamos fazendo o seguinte:
- Na tag context estamos dizendo que nosso contexto é dentro do diretório /grafana, e que dentro desse diretório existe um arquivo Dockerfile.
- Na tag image estamos dando um nome para a nossa imagem, que é grafana-local
- Na tag port estamos fazendo o mapeamento das portas, onde o serviço roda na porta 3000 dentro do container, e iremos expor a porta 3000 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.
Com as configurações acima, podemos rodar nosso projeto e ver a api rodando na porta 8080, o prometheus rodando na porta 9090 e o grafana rodando na porta 3000.
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 preferência, 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, prometheus e do grafana 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 três conteineres em execução, o contêiner da api o contêiner do prometheus e o contêiner do grafana.
Testando nosso cenário
Nossa API web-api-metrics está rodando na porta 8080, conforme configuramos no arquivo docker-compose.yml.
Se abrimos no navegador a url http:localhost:8080/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:8080/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/{id} é 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
Vamos ver agora a interface do grafana que estamos executando pelo Docker na porta 3000.
O usuário e senha é o mesmo que configuramos no arquivo granfa.ini
- username: admin
- password: @admin
Após logar, iremos ver a seguinte tela:
Primeiramente, vamos verficar se nossa configuração do datasource que fizemos anteriormente funcionou.
Siga os passos da imagem acima para saber se o datasource está configurado.
- 1. Vá em ferramentas
- 2. Clique em datasource
- 3. Veja que nosso datasource com o nome prometheus-metrics está devidamente configurado e pronto pra uso.
No grafana há diversos dashboards pré montados que só precisamos importar para o nosso grafana e utilizá-lo, vamos utilizar um deles.
- clique no sinal de mais (+)
- clique em “import”
- no campo de texto informe o código 10427
- clique em load
Deveremos ver a seguinte tela:
- 1. no campo name é mostrado o nome do dashboard, caso deseje pode alterar o nome do seus dashboard, nesse exemplo deixaremos esse mesmo nome.
- 2. selecione nosso datasource do prometheus
- 3. clique em import para concluir.
Após clicar em import iremos ver o seguinte dashboard:
Agora temos um dashboard apresentando informações importantes do nosso serviço, como por exemplo:
- Consumo de memória
- Numéro de Threads abertas
- Duração das requisições Http
Essa são apenas algumas métricas extraídas da nossa api, poderiamos extrair diversas informações da nossa api e criar novos quadros para nosso dashboard.
Para finalizar, para não perdermos nosso dashboard caso nosso container seja encerrado, vou mostrar como exportar nosso dashboard e incluir nas configurções do grafana, pra sempre que inciarmos nosso contêiner nosso dashboard fique persistido.
No menu superior, clique no icone de ferramentas. Deverá aparecer a seguinte tela:
clique em JSON Model, copie todo conteúdo que irá aparecer no quadro ao lado, conforme imagem abaixo:
Lembre-se que durante a configuração do nosso projeto, não incluimos nenhuma informação no arquivo dasboard-webmetric.json dentro do diretório config/dashboards, vamos colar todo o conteudo dentro desse arquivo.
Com isso, sempre que executar seu contêiner, nosso dashboard estará salvo. Um ponto bem importante é que sempre que atualizar o seu dashboard você deverá extrair o json novamente e colar nesse arquivo para não perder suas mudanças caso seu contêiner fique fora do ar.
Conclusão
O grafana é um recurso poderoso para podermos visualizar informações importantes de nossos serviços integrada com diversas fontes de dados como Elastic Search, AWS Cloud Watch, Azure Monitor, Prometheus entre outros tantos.
Pudemos acompanhar nessa jornada a criação de uma API com dotnet Core 3.1 e sua configuração para gerar métricas que o Prometheus pudesse capturar.
Realizamos também a configuração do Prometheus no Docker para que pudesse capturar as informações geradas pelo nosso serviço.
E por fim, configuramos o Grafana no Docker para que usasse o prometheus como fonte de dados e importamos um dasboard totalmente útilizável sem que nos preocupassemos em criar alguma Prom Query pra buscar as informações do Prometheus.
Então é isso pessoal, espero que tenha curtido essa nossa trajetória até aqui. E fique avontade para compartilhar sua opinião nos comentários.
Me siga aqui no medium e no linkedIn para não perder nenhum artigo. Está vindo coisas boas por ai. =]
Até a próxima galera, um abraço.
Link do projeto no github.
Segue o links dos primeiros dois artigos dessa série:
Artigo — Parte 1
Artigo — Parte 2
Referências:
https://pt.wikipedia.org/wiki/Grafana
