RetroDash // TRAFFIC — Guía de Personalización

Requisitos

Para métricas de tráfico necesitas:

node_exporter — network metrics (interface rx/tx)
http_requests_total — contador de requests HTTP
container_network_* — si usas Docker/Kubernetes
O métricas custom de tu app (ej: requests_per_second)

Notas de Compatibilidad

Intervalo de rate

Al igual que en el dashboard de Latencia: la variable $rate_interval tiene un valor por defecto de 5m. Para homelabs con tráfico esporádico, configúrelo en 15m o 30m para que los paneles de tasa de requests muestren datos continuos en lugar de ventanas vacías.

Mapeo de métricas por controlador de ingress

El dashboard utiliza nombres de métricas genéricos. Mapéelos a su controlador de ingress real a continuación:

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 Paneles

┌────────────────────────────────────────┐
│    TRAFFIC — REQUESTS & BANDWIDTH      │
├────────────────────────────────────────┤
│  Requests/s  │  Connections  │ Network │
│  (stat)      │  (gauge)      │ Status  │
├────────────────────────────────────────┤
│  Request Rate — Time Series [12 cols] │
│  (evolución de requests por segundo)   │
├────────────────────────────────────────┤
│  Throughput (In/Out) [6 cols]         │
│  Network by Node [6 cols]             │
├────────────────────────────────────────┤
│  Top Talkers [12 cols]                │
│  (hosts con mayor tráfico)             │
└────────────────────────────────────────┘

Personalización por Panel

Requests/sec Stat

Número actual de requests por segundo.

Query default (HTTP requests):

sum(rate(http_requests_total[5m]))

Si usas Nginx:

rate(nginx_http_requests_total[5m])

Si usas Traefik:

rate(traefik_entrypoint_requests_total[5m])

Si usas API Gateway (Kong, etc):

rate(kong_requests_total[5m])

Connections Gauge

Número de conexiones activas.

Query base:

sum(node_tcp_connection_states{state="established"})

Para Kubernetes:

sum(container_network_tcp_usage_total) / 1000

Filtrar por interfaz específica:

sum(node_network_transmit_bytes_total{device="eth0"})

Request Rate — Time Series

Evolución de requests por segundo en el tiempo.

Query multi-serie (por método HTTP):

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

Por código de estado:

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

Por servicio/instancia:

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

Cambiar granularidad: Edita [5m] → [1m] (más responsivo) o [15m] (más suavizado)

Throughput — Network In/Out

Ancho de banda de entrada y salida en bytes.

Network In (recibido):

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

Network Out (enviado):

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

Nota: Dividir por 1024/1024 convierte bytes a MB. Para Gbps, usa /1000/1000/125

Excluir interfaces virtuales (docker0, veth*):

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

Network by Node

Tabla con tráfico de cada nodo.

Query con breakdown por instancia:

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

Cambiar agrupación:

Por servicio: sum by (job, instance)
Por zona: sum by (zone, instance)
Por interfaz: sum by (device, instance)

Filtrar nodos específicos:

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

Top Talkers

Hosts/ips con mayor volumen de tráfico.

Query default:

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 dominio (si tienes label):

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

Cambiar top N: Reemplaza topk(10 con topk(20 o topk(5

Filtrar por rango de IP:

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

Cambiar Tema de Color

Tema	UP Color	DOWN Color
GREEN	`#33FF00` (healthy)	#FF4444 (congested)
AMBER	`#FFB000` (warning)	#FF6C00 (critical)
BLUE	`#00BFFF` (flowing)	#FF1493 (blocked)

Adaptar a tu Resolución

Dispositivo	Ancho Óptimo	Alto Paneles
Mobile	6 cols (stack)	8-10 rows
iPad 10.9"	12 cols (full)	10-12 rows
iPad Pro 12.9"	12 cols (full)	12-14 rows
Desktop 1920×1080	24 cols (2x)	8-9 rows

Importar en Grafana

Ve a Dashboards → Import
Copia el JSON de TRAFFIC dashboard
Verifica datasource Prometheus está seleccionado
Importa y guarda
Comprueba que todas las métricas están disponibles en tu Prometheus
Si falta alguna métrica, edita la query según tu exporter

Tips Avanzados

Detectar spikes de tráfico

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

Alerta si la tasa actual supera 150% del promedio de la última hora.

Ratio de request/byte (eficiencia)

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

Muestra cuántos requests por KB de datos transmitidos (mayor = más eficiente).

Predicción de saturación de ancho

predict_linear(node_network_transmit_bytes_total[1h], 3600)

Predice el valor en 1 hora, útil para detectar crecimiento no controlado.