RetroDash // TRAFFIC — Guia de Personalização

Requisitos

Para métricas de tráfego você precisa:

node_exporter — métricas de rede (interface rx/tx)
http_requests_total — contador de requisições HTTP
container_network_* — se você usa Docker/Kubernetes
Ou métricas customizadas da sua aplicação (ex: requests_per_second)

Notas de Compatibilidade

Intervalo de rate

Igual ao dashboard de Latência: a variável $rate_interval tem valor padrão 5m. Para homelabs com tráfego esporádico, configure como 15m ou 30m para que os painéis de taxa de requisições exibam dados contínuos em vez de janelas vazias.

Mapeamento de métricas por controlador de ingress

O dashboard utiliza nomes de métricas genéricos. Mapeie-os para o seu controlador de ingress real conforme abaixo:

Métrica Genérica	Traefik	Nginx Ingress	Istio
`http_requests_total`	`traefik_entrypoint_requests_total`	`nginx_ingress_controller_requests`	`istio_requests_total`
label status	`code`	`status`	`response_code`
`http_request_duration_seconds_*`	`traefik_service_request_duration_seconds_*`	`nginx_ingress_controller_request_duration_seconds_*`	`istio_request_duration_milliseconds_*`

Mapa de Painéis

┌────────────────────────────────────────┐
│    TRÁFEGO — REQUISIÇÕES & LARGURA     │
├────────────────────────────────────────┤
│  Req/s    │  Conexões  │ Rede         │
│  (stat)   │  (gauge)   │ Status       │
├────────────────────────────────────────┤
│  Taxa de Requisições — Série [12 cols]│
│  (evolução de requisições por segundo) │
├────────────────────────────────────────┤
│  Throughput (In/Out) [6 cols]         │
│  Rede por Nó [6 cols]                 │
├────────────────────────────────────────┤
│  Top Talkers [12 cols]                │
│  (hosts com maior tráfego)             │
└────────────────────────────────────────┘

Personalização por Painel

Requisições/sec Stat

Número atual de requisições por segundo.

Query padrão (requisições HTTP):

sum(rate(http_requests_total[5m]))

Se você usa Nginx:

rate(nginx_http_requests_total[5m])

Se você usa Traefik:

rate(traefik_entrypoint_requests_total[5m])

Se você usa API Gateway (Kong, etc):

rate(kong_requests_total[5m])

Gauge de Conexões

Número de conexões ativas.

Query base:

sum(node_tcp_connection_states{state="established"})

Para Kubernetes:

sum(container_network_tcp_usage_total) / 1000

Filtrar por interface específica:

sum(node_network_transmit_bytes_total{device="eth0"})

Taxa de Requisições — Série Temporal

Evolução de requisições por segundo ao longo do tempo.

Query multi-série (por método HTTP):

sum by (method) (rate(http_requests_total[5m]))

Por código de status:

sum by (status) (rate(http_requests_total[5m]))

Por serviço/instância:

sum by (job) (rate(http_requests_total[5m]))

Mudar granularidade: Edite [5m] → [1m] (mais responsivo) ou [15m] (mais suavizado)

Throughput — Rede In/Out

Largura de banda de entrada e saída em bytes.

Rede Entrada (recebida):

sum(rate(node_network_receive_bytes_total[5m])) / 1024 / 1024

Rede Saída (enviada):

sum(rate(node_network_transmit_bytes_total[5m])) / 1024 / 1024

Nota: Dividir por 1024/1024 converte bytes para MB. Para Gbps, use /1000/1000/125

Excluir interfaces virtuais (docker0, veth*):

sum(rate(node_network_receive_bytes_total{device!~"docker.*|veth.*"}[5m]))

Rede por Nó

Tabela com tráfego de cada nó.

Query com desglose por instância:

sum by (instance) (rate(node_network_receive_bytes_total[5m]))

Mudar agrupamento:

Por serviço: sum by (job, instance)
Por zona: sum by (zone, instance)
Por interface: sum by (device, instance)

Filtrar nós específicos:

sum by (instance) (rate(node_network_receive_bytes_total{instance=~"prod.*"}[5m]))

Top Talkers

Hosts/IPs com maior volume de tráfego.

Query padrão:

topk(10, sum by (remote_addr) (rate(http_requests_total[5m])))

Para Docker/Kubernetes (container_network_*):

topk(10, sum by (pod_name) (rate(container_network_transmit_bytes_total[5m])))

Por domínio (se você tem label):

topk(10, sum by (domain) (rate(http_requests_total[5m])))

Mudar top N: Substitua topk(10 com topk(20 ou topk(5

Filtrar por faixa de IP:

topk(10, sum by (remote_addr) (rate(http_requests_total{remote_addr=~"192\\.168\\..*"}[5m])))

Mudar Tema de Cor

Tema	Cor UP	Cor DOWN
GREEN	`#33FF00` (saudável)	#FF4444 (congestionado)
AMBER	`#FFB000` (aviso)	#FF6C00 (crítico)
BLUE	`#00BFFF` (fluindo)	#FF1493 (bloqueado)

Adaptar à sua Resolução

Dispositivo	Largura Ideal	Altura dos Painéis
Mobile	6 cols (stack)	8-10 rows
iPad 10.9"	12 cols (completo)	10-12 rows
iPad Pro 12.9"	12 cols (completo)	12-14 rows
Desktop 1920×1080	24 cols (2x)	8-9 rows

Importar no Grafana

Vá para Dashboards → Import
Copie o JSON do painel TRÁFEGO
Verifique se datasource Prometheus está selecionado
Importe e salve
Verifique que todas as métricas estão disponíveis no seu Prometheus
Se faltar alguma métrica, edite a query conforme seu exporter

Dicas Avançadas

Detectar picos de tráfego

rate(http_requests_total[5m]) >
  avg_over_time(rate(http_requests_total[5m])[1h:5m]) * 1.5

Alerta se a taxa atual supera 150% do promédio da última hora.

Razão requisição/byte (eficiência)

sum(rate(http_requests_total[5m])) /
  (sum(rate(node_network_transmit_bytes_total[5m])) / 1024)

Mostra quantas requisições por KB de dados transmitidos (maior = mais eficiente).

Previsão de saturação de largura de banda

predict_linear(node_network_transmit_bytes_total[1h], 3600)

Prevê o valor em 1 hora, útil para detectar crescimento descontrolado.

RetroDash // TRÁFEGO