Dashboards são ferramentas essenciais no contexto DevOps para consolidar métricas e logs em uma interface visual, permitindo que equipes monitorem a saúde dos sistemas, identifiquem tendências e reajam rapidamente a incidentes. Nesta aula, vamos explorar o Grafana, uma das plataformas mais populares para visualização de dados, e discutir como criar dashboards que realmente ajudam na tomada de decisão.

Uma boa visualização vai além de gráficos bonitos: ela deve responder a perguntas específicas, destacar anomalias e facilitar a ação. Vamos aprender a escolher o que mostrar, como organizar painéis e como transformar dados brutos em insights acionáveis.

Grafana (visão geral)

O Grafana é uma plataforma de código aberto para monitoramento e observabilidade, que permite consultar, visualizar, alertar e explorar métricas de diversas fontes de dados, como Prometheus, InfluxDB, Elasticsearch, CloudWatch, entre outros. Ele é amplamente utilizado no ecossistema DevOps por sua flexibilidade, integrações e comunidade ativa.

Com o Grafana, você pode criar dashboards interativos com gráficos de séries temporais, tabelas, heatmaps, mapas e muito mais. Além disso, ele suporta alertas baseados em métricas, permitindo que você seja notificado quando condições específicas forem atingidas. A interface é intuitiva, e os dashboards podem ser compartilhados ou exportados como JSON para versionamento.

Exemplo de um painel simples no Grafana, configurado via arquivo JSON:

{
  "dashboard": {
    "title": "Visão Geral",
    "panels": [
      {
        "title": "CPU Usage",
        "type": "graph",
        "targets": [
          {
            "expr": "100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)",
            "legendFormat": "CPU"
          }
        ]
      },
      {
        "title": "Memória",
        "type": "graph",
        "targets": [
          {
            "expr": "node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes",
            "legendFormat": "Memória usada"
          }
        ]
      }
    ]
  }
}

Esse JSON pode ser importado no Grafana via API ou interface. Embora a interface gráfica seja a mais comum, o versionamento de dashboards como código é uma prática recomendada para infraestrutura como código.

O que mostrar

Decidir o que exibir em um dashboard é uma tarefa estratégica. É fácil cair na armadilha de mostrar todas as métricas disponíveis, mas isso pode poluir a visualização e dificultar a identificação de problemas reais. Uma boa abordagem é seguir o princípio de "métricas orientadas a objetivos": cada painel deve responder a uma pergunta específica sobre a saúde do sistema.

No contexto DevOps, alguns indicadores-chave são:

  • Latência: tempo de resposta das requisições (p95, p99).
  • Taxa de erros: percentual de requisições com falha.
  • Throughput: número de requisições por segundo.
  • Saturação: utilização de recursos (CPU, memória, disco, rede).
  • Disponibilidade: tempo de atividade (uptime) e tempo de inatividade (downtime).

Além desses, métricas de negócio como usuários ativos, taxa de conversão e tempo de carregamento podem ser incluídas para alinhar a operação com os objetivos da empresa. No entanto, é importante segmentar os dashboards por público: um dashboard para desenvolvedores pode focar em detalhes técnicos, enquanto um para gestores pode apresentar um resumo executivo.

Exemplo de uma consulta PromQL que mostra a taxa de erros de uma aplicação:

sum(rate(http_requests_total{status=~"5.."}[5m])) / sum(rate(http_requests_total[5m])) * 100

Essa expressão pode ser usada em um painel de gráfico para exibir a porcentagem de erros ao longo do tempo.

Dashboards acionáveis

Um dashboard acionável é aquele que não apenas mostra dados, mas também orienta o observador a tomar uma decisão ou ação imediata. Isso significa que ele deve ter alertas claros, destacar anomalias e fornecer contexto suficiente para o diagnóstico inicial.

Para criar dashboards acionáveis, considere:

  • Alerta integrado: configure alertas no Grafana para enviar notificações (e-mail, Slack, PagerDuty) quando uma métrica ultrapassar um limite.
  • Thresholds: use cores (verde, amarelo, vermelho) para indicar níveis de severidade nos painéis.
  • Links contextuais: inclua links para logs, traces ou runbooks para acelerar a investigação.
  • Anotações: adicione anotações em eventos de deploy ou incidentes para correlacionar com as métricas.

Exemplo de configuração de alerta no Grafana via arquivo de provisionamento:

apiVersion: 1
alerts:
  - name: "CPU alta"
    conditions:
      - evaluator:
          type: gt
          params: [80]
        query:
          params: [A, 5m, now]
        reducer:
          type: avg
    frequency: "1m"
    noDataState: "no_data"
    notifications: []
    for: "5m"

Esse alerta verifica se a média de CPU nos últimos 5 minutos é maior que 80% e, se persistir por 5 minutos, dispara uma notificação.

Um dashboard acionável também deve ser organizado por seções, como "Visão Geral", "Erros", "Desempenho" e "Capacidade", para que o observador possa navegar rapidamente até a área relevante.

Boas práticas

Existem várias boas práticas para criar dashboards eficazes e sustentáveis no longo prazo:

  • Menos é mais: evite sobrecarregar o dashboard com muitos painéis; priorize as métricas mais importantes.
  • Consistência visual: use a mesma escala de cores, unidades e convenções de nomenclatura em todos os painéis.
  • Documentação: adicione descrições e links para documentação ou runbooks em cada painel.
  • Versionamento: mantenha os dashboards como código (JSON) em um repositório Git para facilitar revisões e rollbacks.
  • Testes: valide os dashboards com dados históricos para garantir que as consultas estão corretas e que os painéis não quebram.
  • Acessibilidade: escolha cores e contrastes que sejam legíveis para todos os usuários.
  • Atualização: revise periodicamente os dashboards para remover painéis desnecessários e adicionar novas métricas relevantes.

Além disso, é importante lembrar que dashboards são uma ferramenta de comunicação. Eles devem ser compartilhados com a equipe e alinhados com os objetivos do projeto. Uma prática comum é realizar revisões periódicas dos dashboards em reuniões de equipe para garantir que continuam úteis e precisos.

Observações finais

Nesta aula, vimos como o Grafana pode ser usado para criar dashboards poderosos, o que mostrar neles e como torná-los acionáveis. Lembre-se de que a visualização é apenas uma parte do monitoramento; é preciso integrar os dashboards com alertas e processos de resposta a incidentes para que realmente ajudem no dia a dia. Pratique a criação de dashboards com dados simulados ou reais e explore as integrações do Grafana com outras ferramentas do seu stack.

Referências

Exercícios

  1. Explique a diferença entre métricas de latência, taxa de erros e throughput e dê um exemplo de como cada uma pode ser visualizada em um dashboard do Grafana.

    ✓ Resposta: Latência mede o tempo de resposta de uma requisição, tipicamente representado por percentis (p95, p99) em gráficos de linha. Taxa de erros é a porcentagem de requisições que falham, geralmente mostrada como um gráfico de área ou linha. Throughput é o número de requisições por segundo, visualizado como um gráfico de linha ou barra. Por exemplo, no Grafana, você pode ter um painel com a expressão histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le)) para latência, sum(rate(http_requests_total{status=~"5.."}[5m])) / sum(rate(http_requests_total[5m])) para erros, e sum(rate(http_requests_total[5m])) para throughput.
  2. Cite três boas práticas para criar dashboards eficazes e explique por que cada uma é importante.

    ✓ Resposta: 1. Menos é mais: evita sobrecarga de informações, permitindo que o observador se concentre no que é crítico. 2. Versionamento: permite rastrear mudanças, reverter alterações e colaborar via revisão de código. 3. Documentação: ajuda novos membros da equipe a entender o significado de cada painel e a agir corretamente. Essas práticas aumentam a clareza, a confiabilidade e a colaboração.
  3. Escreva uma consulta PromQL que calcule a utilização de memória de um servidor (percentual) e explique como você a usaria em um painel do Grafana.

    ✓ Resposta: A consulta seria: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100. No Grafana, você adicionaria um painel do tipo "Graph" ou "Time series", selecionaria a fonte de dados Prometheus e colaria essa expressão no campo de consulta. O painel mostraria a porcentagem de memória usada ao longo do tempo, permitindo identificar tendências e picos.
  4. Descreva como você configuraria um alerta no Grafana para notificar quando a taxa de erros de uma aplicação ultrapassar 5% por mais de 10 minutos.

    ✓ Resposta: No Grafana, crie uma regra de alerta. Na condição, use a consulta sum(rate(http_requests_total{status=~"5.."}[5m])) / sum(rate(http_requests_total[5m])) * 100. Defina o evaluator como "gt" e o valor 5. Configure a condição para avaliar a média por 5m, e defina o parâmetro "for" como "10m" para exigir que a condição persista por 10 minutos. Em seguida, configure as notificações para Slack, e-mail ou PagerDuty. O alerta será disparado quando a taxa de erros média nos últimos 5 minutos for maior que 5% por 10 minutos consecutivos.
  5. Dê um exemplo de um dashboard acionável para um serviço web, incluindo os painéis que ele teria e como eles ajudam na tomada de decisão.

    ✓ Resposta: Um dashboard acionável para um serviço web poderia ter: 1) Latência (p95) por endpoint - ajuda a identificar quais rotas estão lentas; 2) Taxa de erros por status code - mostra se há um aumento de erros 5xx; 3) Throughput (req/s) - indica picos de tráfego; 4) Utilização de CPU/memória por instância - ajuda a detectar saturação de recursos; 5) Alertas de threshold com cores - quando a latência ou erros excedem limites, o painel fica vermelho e envia notificação. Isso permite que o operador rapidamente veja o que está errado e tome ações como escalar recursos ou investigar logs.