Nesse artigo vamos alterar nossa API para fornecer métricas de uso, configurar o phometheus para coletar essas métricas e configurar um dashboard no grafana para acompanhar tudo isso de forma visual.

Instalando dependências

Primeiro precisamos instalar as dependências do App Metrics, biblioteca que utilizaremos para criar a monitoração, para isso executamos os seguintes comandos na pasta Products.API:

dotnet add package App.Metrics.AspNetCore.All --version 4.2.0
dotnet add package App.Metrics.Formatters.Prometheus --version 4.2.0

Configurando a API para fornecer métricas

Agora vamos ao arquivo Program.cs e configuraremos nosso host para usar métricas, o arquivo deve ficar como a seguir:

using App.Metrics;
using App.Metrics.AspNetCore;
using App.Metrics.Formatters.Prometheus;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace Products.API
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) {

            var hostBuilder = Host.CreateDefaultBuilder(args)
                                  .UseMetrics(options =>
                                      {
                                          options.EndpointOptions = endpointsOptions =>
                                          {
                                              endpointsOptions.MetricsTextEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
                                              endpointsOptions.MetricsEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
                                          };
                                      })
                                  .ConfigureWebHostDefaults(webBuilder =>
                                  {
                                      webBuilder.UseStartup<Startup>();
                                  });
            return hostBuilder;
        }            
    }
}

Para esse arquivo configuramos o método UseMetrics para os formatters do phometheus. Também precisamos adicionar a seguinte instrução dentro do método ConfigureServices do arquivo Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
  [...]
  services.AddMvc().AddMetrics();
}

Precisamos dessa configuração para que o App Metrics consiga capturar métricas de cada rota do nosso sistema.

Configurando o Phometheus

O prometheus será responsável por capturar as métricas na nossa API a cada intervalo de tempo, essa configuração é feita no arquivo prometheus.yml que deve ser criado no seguinte caminho:

docker\prometheus\prometheus.yml

O conteúdo desse arquivo deve ser:

scrape_configs:
- job_name: api
  scrape_interval: 5s
  static_configs:
  - targets:
    - api:80
  metrics_path: metrics-text

Nesse arquivo estamos configurando um job que será executado a cada 5 segundos e buscará informações no servidor API, na porta 80 e no endpoint metrics-text.

Também precisamos configurar nosso docker-compose.yml para subir um servidor Phometheus usando essas configurações:

 [...]
  prometheus:
    image: prom/prometheus:v2.26.0
    container_name: prometheus
    ports:
    - 9090:9090
    volumes:
    - ./docker/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
    depends_on:
    - api
    restart: always

Configurando o Grafana

Vou mostrar brevemente como realizar a configuração do grafana e depois como podemos automatizar esse processo. Começamos por adicionar ao docker-compose.yml nosso serviço grafana:

  [...]
  grafana:
    image: grafana/grafana:6.7.2
    container_name: grafana
    ports:
      - 3000:3000
    depends_on:
      - prometheus

Podemos também subir nossa infraestrutura com o comando:

docker-compose up --build -d

Ao fim do processo podemos acessar nosso servidor grafana no endereço http://localhost:3000:

O login padrão é admin e a senha padrão também é admin.

Após o login precisamos configurar as fontes de dados que serão utilizadas pelo grafana, podemos fazer isso no menu lateral Configuration > Data Sources:

Podemos clicar no botão Add Data Source e selecionar o Phometheus:

Precisamos informar a URL do phometheus como http://prometheus:9090.

Depois disso podemos clicar no botão Save & Test.

Importando o dashboard

O Grafana possui um repositório enorme de dashboards prontos para uso, no nosso exemplo vou utilizar um dashboard do App Metrics, ele pode ser encontrado no endereço https://grafana.com/grafana/dashboards/2204/revisions.

Para esse projeto vamos usar a revisão 3 do dashboard, podemos baixar esse arquivo:

Podemos começar a importação do dashboard pelo menu lateral Create > Import:

Na tela apresentada podemos clicar no botão Upload .json file e selecionar o arquivo app-metrics-web-monitoring-prometheus_rev3.json:

Para o campo “Prometheus App Metrics” selecionaremos nosso Data Source Phometheus.

Ao clicar em Import nosso dashboard é aberto:

Podemos abrir nosso frontend, fazer o login e cadastrar alguns produtos, e veremos que o relatório vai ser atualizado alguns segundos depois.

Também podemos acompanhar métricas por endpoint:

Exportando o dashboard configurado

Precisamos acessar a configuração do nosso dashboard:

Podemos clicar em JSON Model:

Podemos copiar esse JSON e criar um arquivo chamado dashboard_01.json.

Automatizando a configuração do Grafana

Nesse ultimo passo vamos criar arquivos para automatizar a criação do Data Source, fazemos isso no arquivo datasource.yml que deve ser criado no caminho:

docker\grafana\provisioning\datasources\datasource.yml

O conteúdo desse arquivo deve ser:

# config file version
apiVersion: 1

# list of datasources that should be deleted from the database
deleteDatasources:
  - name: Prometheus
    orgId: 1

# list of datasources to insert/update depending
# whats available in the database
datasources:
  # <string, required> name of the datasource. Required
- name: Prometheus
  # <string, required> datasource type. Required
  type: prometheus
  # <string, required> access mode. direct or proxy. Required
  access: proxy
  # <int> org id. will default to orgId 1 if not specified
  orgId: 1
  # <string> url
  url: http://prometheus:9090
  # <string> database password, if used
  password:
  # <string> database user, if used
  user:
  # <string> database name, if used
  database:
  # <bool> enable/disable basic auth
  basicAuth: true
  # <string> basic auth username
  basicAuthUser: admin
  # <string> basic auth password
  basicAuthPassword: foobar
  # <bool> enable/disable with credentials headers
  withCredentials:
  # <bool> mark as default datasource. Max one per org
  isDefault:
  # <map> fields that will be converted to json and stored in json_data
  jsonData:
     graphiteVersion: "1.1"
     tlsAuth: false
     tlsAuthWithCACert: false
  # <string> json object of data that will be encrypted.
  secureJsonData:
    tlsCACert: "..."
    tlsClientCert: "..."
    tlsClientKey: "..."
  version: 1
  # <bool> allow users to edit datasources from the UI.
  editable: true

Também criaremos um arquivo para automatizar a importação dos dashboards, esse arquivo se chamara dashboard.yml e deve ser criado no seguinte caminho:

docker\grafana\provisioning\dashboards\dashboard.yml

O conteúdo do arquivo dashboard.yml deve ser:

apiVersion: 1

providers:
- name: 'Prometheus'
  orgId: 1
  folder: ''
  type: file
  disableDeletion: false
  editable: true
  options:
    path: /etc/grafana/provisioning/dashboards

Também precisamos colocar o arquivo dashboard_01.json na pasta dashboards, ficando com o seguinte caminho:

docker\grafana\provisioning\dashboards\dashboard_01.json

O último passo é atualizar nosso service grafana no docker-compose.yml para utilizar esses arquivos:

  [...]
  grafana:
    image: grafana/grafana:6.7.2
    container_name: grafana
    ports:
      - 3000:3000
    volumes:
      - ./docker/grafana/provisioning/:/etc/grafana/provisioning/
    environment:
      GF_INSTALL_PLUGINS: grafana-piechart-panel,grafana-clock-panel,briangann-gauge-panel,natel-plotly-panel,grafana-simple-json-datasource
    depends_on:
      - prometheus

Também configuramos a variável de ambiente com plugins usados pelo nosso dashboard, assim serão instalados automaticamente.

Podemos agora derrubar toda nossa infraestrutura e subir novamente, já com todos os serviços configurados:

docker-compose down
docker-compose up --build -d 

Assim finalizamos nossa série, espero que tenha sido útil para entender um pouco de cada ferramenta e a forma como elas interagem!

Gostou? Tem alguma sugestão ou dúvida? Deixa ai nos comentários!

Segue o link do repositório no estado atual do projeto:

Repositório Products Management