Laboratorio - Dashboards y visualización¶

Este laboratorio integra los principales conceptos de la sección de dashboards y visualización de Grafana.

Durante la práctica, el alumno creará un dashboard operativo utilizando diferentes tipos de paneles, consultas PromQL, transformaciones, variables, documentación y, si está disponible, un plugin de panel.

El laboratorio está diseñado para trabajar con:

Grafana.
Prometheus.
Node Exporter.
Métricas de infraestructura.
Paneles estándar de Grafana.
Transformaciones.
Variables de dashboard.
Paneles Text y Canvas.
Exportación e importación de dashboards.
Diagnóstico de errores.

El objetivo no es únicamente crear gráficos. El objetivo es construir un dashboard comprensible, documentado, reutilizable y útil para la operación.

Objetivos¶

Al finalizar este laboratorio, el alumno podrá:

Crear un dashboard completo en Grafana.
Configurar una fuente de datos Prometheus.
Utilizar consultas PromQL de infraestructura.
Crear paneles Stat, Gauge, Bar Gauge, Time series, Table, Heatmap, Text y Canvas.
Configurar unidades, títulos, descripciones y umbrales.
Crear variables de dashboard.
Utilizar transformaciones.
Comparar valores actuales y tendencias.
Documentar el propósito del dashboard.
Crear una vista visual de la infraestructura.
Analizar disponibilidad, CPU, memoria, almacenamiento y red.
Simular una incidencia controlada.
Observar el cambio de las métricas.
Diagnosticar paneles sin datos.
Exportar el dashboard.
Importar una copia del dashboard.
Documentar las dependencias y las consultas.
Evaluar la calidad y mantenibilidad del resultado.
Comprender cuándo utilizar paneles integrados o plugins.

Introducción¶

Un dashboard de monitorización debe responder rápidamente a preguntas operativas como:

¿Los objetivos están disponibles?
¿Qué servidor consume más CPU?
¿Cuánta memoria está utilizada?
¿Qué sistemas de ficheros están cerca del límite?
¿Cómo ha evolucionado el consumo?
¿Existe tráfico de red?
¿Se ha producido una degradación reciente?
¿Qué procedimiento debe seguirse ante una incidencia?

En este laboratorio se construirá un dashboard con la siguiente estructura:

+------------------------------------------------------+
| Portada y documentación                              |
+------------------------------------------------------+
| Disponibilidad       | Objetivos monitorizados       |
+------------------------------------------------------+
| CPU por instancia    | Memoria por instancia         |
+------------------------------------------------------+
| Uso de disco         | Carga del sistema             |
+------------------------------------------------------+
| Tendencia de CPU                                    |
+------------------------------------------------------+
| Tráfico de red                                      |
+------------------------------------------------------+
| Tabla operativa de recursos                          |
+------------------------------------------------------+
| Canvas de infraestructura                            |
+------------------------------------------------------+
| Procedimiento y conclusiones                         |
+------------------------------------------------------+

La estructura puede adaptarse al entorno de prácticas.

Arquitectura del laboratorio¶

La arquitectura mínima recomendada es:

+-------------+       +-------------+
| Grafana     | ----> | Prometheus  |
+-------------+       +-------------+
                             |
                             v
                     +---------------+
                     | Node Exporter|
                     +---------------+
                             |
                             v
                     +---------------+
                     | Servidor Linux|
                     +---------------+

Componentes¶

Grafana¶

Se utiliza para:

Crear dashboards.
Consultar Prometheus.
Configurar paneles.
Crear variables.
Aplicar transformaciones.
Exportar e importar dashboards.

Prometheus¶

Se utiliza para:

Recoger métricas.
Almacenar series temporales.
Ejecutar consultas PromQL.
Proporcionar los datos a Grafana.

Node Exporter¶

Se utiliza para exponer métricas del sistema operativo:

CPU.
Memoria.
Disco.
Sistema de ficheros.
Red.
Carga del sistema.
Tiempo de actividad.

Requisitos previos¶

Antes de comenzar, comprobar:

Grafana está iniciado.
Prometheus está iniciado.
Node Exporter está iniciado.
Grafana puede acceder a Prometheus.
Prometheus está recogiendo métricas.
El alumno tiene permisos para crear dashboards.
Existe un entorno de laboratorio autorizado.

Comprobar servicios¶

Los nombres pueden variar según la instalación.

sudo systemctl status grafana-server

sudo systemctl status prometheus

sudo systemctl status node_exporter

Comprobar Node Exporter¶

curl http://localhost:9100/metrics

La respuesta debe contener métricas como:

node_cpu_seconds_total
node_memory_MemTotal_bytes
node_filesystem_size_bytes
node_network_receive_bytes_total

Comprobar Prometheus¶

Abrir:

http://localhost:9090

Ejecutar:

up

El objetivo monitorizado debe devolver:

Interpretación:

1 = disponible
0 = no disponible

Preparar el directorio de evidencias¶

Crear un directorio para conservar las evidencias:

mkdir -p ~/laboratorio-grafana/evidencias/laboratorio-dashboards

Crear un fichero inicial:

cat > ~/laboratorio-grafana/evidencias/laboratorio-dashboards/informe.txt <<'EOF'
Laboratorio: Dashboards y visualización

Alumno:

Fecha:

Entorno:

URL de Grafana:

URL de Prometheus:

Fuente de datos utilizada:

Dashboard creado:

Paneles creados:

Variables creadas:

Transformaciones utilizadas:

Pruebas realizadas:

Problemas encontrados:

Soluciones aplicadas:

Conclusiones:
EOF

Fase 1: comprobar la fuente de datos¶

Objetivo¶

Verificar que Grafana puede consultar Prometheus.

Pasos¶

Acceder a Grafana.
Abrir la configuración.
Acceder a Data sources.
Seleccionar Prometheus.
Comprobar la URL configurada.
Ejecutar la prueba de conexión.
Confirmar que la fuente de datos responde correctamente.

La URL puede ser similar a:

http://localhost:9090

o:

http://prometheus:9090

La URL depende de la arquitectura utilizada.

Actividades¶

Anota el nombre de la fuente de datos.
Anota su tipo.
Anota la URL.
Guarda una captura de la conexión correcta.
Comprueba la consulta:

up

Evidencia¶

Guardar:

01-fuente-datos-prometheus.png

Fase 2: crear el dashboard¶

Objetivo¶

Crear el dashboard principal del laboratorio.

Pasos¶

Crear un dashboard nuevo.
Asignar el nombre:

Laboratorio - Dashboards y visualización

Seleccionar la fuente de datos Prometheus.
Configurar un rango temporal inicial:

Last 1 hour

Configurar una actualización automática razonable:

30s

Guardar el dashboard.
Añadir una descripción general.

Descripción recomendada¶

Dashboard de prácticas para analizar disponibilidad,
CPU, memoria, almacenamiento, red y evolución temporal
de un entorno Linux monitorizado mediante Prometheus.

Actividades¶

Crea el dashboard.
Guarda una primera versión.
Comprueba el nombre.
Comprueba el rango temporal.
Registra la URL o el identificador del dashboard.

Fase 3: crear variables de dashboard¶

Objetivo¶

Permitir que el usuario seleccione dinámicamente un objetivo o una instancia.

Las variables evitan tener que modificar manualmente cada consulta.

Variable `job`¶

Crear una variable llamada:

job

Consulta posible:

label_values(up, job)

Según la versión de Grafana, la consulta de variables puede utilizar un editor o una sintaxis equivalente.

Valores habituales:

node_exporter
prometheus

Variable `instance`¶

Crear una variable llamada:

instance

Consulta posible:

label_values(up{job=~"$job"}, instance)

Configurar:

Multi-value: activado
Include All option: activado

Actividades¶

Crea la variable job.
Crea la variable instance.
Comprueba los valores disponibles.
Selecciona una instancia.
Selecciona varias instancias.
Selecciona All.
Documenta el resultado.

Evidencia¶

Guardar:

02-variables-dashboard.png

Fase 4: panel Text de portada¶

Objetivo¶

Crear una portada que explique el dashboard.

Contenido¶

## Laboratorio - Dashboards y visualización

Este dashboard permite analizar el estado y el rendimiento
de los servidores Linux del entorno de prácticas.

### Fuente de datos

- Prometheus
- Node Exporter

### Métricas principales

- Disponibilidad.
- CPU.
- Memoria.
- Almacenamiento.
- Carga del sistema.
- Tráfico de red.

### Orden recomendado de lectura

1. Comprobar la disponibilidad.
2. Revisar los recursos actuales.
3. Analizar las tendencias.
4. Consultar la tabla operativa.
5. Revisar el Canvas de infraestructura.
6. Seguir el procedimiento si se detecta una anomalía.

> Los datos representan un entorno de laboratorio.
> No utilizar estos umbrales directamente en producción.

Pasos¶

Añadir un panel.
Seleccionar Text.
Seleccionar Markdown.
Introducir el contenido.
Colocar el panel en la parte superior.
Ajustar su anchura.
Guardar el panel.

Actividades¶

Añade el nombre del alumno.
Añade la instancia seleccionada:

**Instancia seleccionada:** `$instance`

Añade un enlace a la documentación de Grafana.
Añade una tabla con la información del entorno.

Evidencia¶

Guardar:

03-panel-text-portada.png

Fase 5: panel Stat de disponibilidad¶

Objetivo¶

Mostrar el número de objetivos disponibles.

Consulta¶

sum(up{job=~"$job"})

Configuración¶

Título: Objetivos disponibles
Visualización: Stat
Unidad: None

Umbrales conceptuales¶

Verde: todos los objetivos disponibles
Amarillo: disponibilidad parcial
Rojo: ningún objetivo disponible

Si se desea mostrar el total de objetivos, crear una segunda consulta:

count(up{job=~"$job"})

El resultado puede configurarse como texto auxiliar o utilizarse en un panel adicional.

Actividades¶

Crea el panel Stat.
Utiliza la variable $job.
Configura el título.
Añade una descripción:

Número de objetivos disponibles para el job seleccionado.

Comprueba el valor.
Detén temporalmente un exporter en el laboratorio.
Observa el cambio.
Inicia de nuevo el exporter.

Evidencia¶

Guardar:

04-panel-stat-disponibilidad.png

Fase 6: panel Stat de disponibilidad porcentual¶

Objetivo¶

Mostrar el porcentaje de objetivos disponibles.

Consulta¶

100 * avg(up{job=~"$job"})

Configuración¶

Título: Disponibilidad
Visualización: Stat
Unidad: Percent (0-100)

Umbrales¶

Verde: 100
Amarillo: >= 90 y < 100
Rojo: < 90

Actividades¶

Crea el panel.
Configura la unidad.
Configura los umbrales.
Añade la descripción:

Porcentaje de objetivos disponibles para el job seleccionado.

Prueba el comportamiento con un objetivo detenido.
Documenta el valor antes y después.

Fase 7: panel Gauge de CPU¶

Objetivo¶

Mostrar el uso actual de CPU.

Consulta¶

100 - (
  avg by (instance) (
    rate(
      node_cpu_seconds_total{
        mode="idle",
        instance=~"$instance"
      }[5m]
    )
  ) * 100
)

Configuración¶

Título: Uso de CPU
Visualización: Gauge
Unidad: Percent (0-100)
Min: 0
Max: 100

Umbrales¶

Verde: 0 - 69
Amarillo: 70 - 89
Rojo: 90 - 100

Actividades¶

Crea el panel.
Utiliza la variable $instance.
Configura la unidad como porcentaje.
Configura los umbrales.
Genera carga controlada en el laboratorio.
Observa el valor.
Detén la carga.
Observa la recuperación.

Carga controlada¶

Utilizar únicamente en un entorno autorizado.

Una herramienta habitual es:

stress-ng --cpu 1 --timeout 60s

Si stress-ng no está instalado, seguir el procedimiento definido por el instructor.

Evidencias¶

Guardar:

05-cpu-normal.png
06-cpu-durante-carga.png
07-cpu-recuperacion.png

Fase 8: panel Bar Gauge de CPU por instancia¶

Objetivo¶

Comparar el uso de CPU entre instancias.

Consulta¶

100 - (
  avg by (instance) (
    rate(
      node_cpu_seconds_total{
        mode="idle",
        instance=~"$instance"
      }[5m]
    )
  ) * 100
)

Configuración¶

Título: CPU por instancia
Visualización: Bar Gauge
Unidad: Percent (0-100)
Orientación: Horizontal

Recomendaciones¶

Mostrar el nombre de la instancia.
Ordenar de mayor a menor.
Configurar umbrales.
Limitar el número de instancias si el entorno es grande.
Utilizar nombres legibles.

Actividades¶

Crea el panel.
Selecciona varias instancias.
Ordena los valores.
Identifica la instancia con mayor CPU.
Añade una descripción.
Compara el resultado con el Gauge individual.

Fase 9: panel Gauge de memoria¶

Objetivo¶

Mostrar el porcentaje de memoria utilizada.

Consulta¶

100 * (
  1 -
  (
    node_memory_MemAvailable_bytes{
      instance=~"$instance"
    }
    /
    node_memory_MemTotal_bytes{
      instance=~"$instance"
    }
  )
)

Configuración¶

Título: Memoria utilizada
Visualización: Gauge
Unidad: Percent (0-100)
Min: 0
Max: 100

Umbrales¶

Verde: 0 - 69
Amarillo: 70 - 89
Rojo: 90 - 100

Actividades¶

Crea el panel.
Configura los umbrales.
Selecciona una instancia.
Selecciona todas las instancias.
Comprueba cómo se comporta el panel con varias series.
Ajusta la consulta o crea un panel por instancia si es necesario.

Fase 10: panel Bar Gauge de memoria por instancia¶

Objetivo¶

Comparar el consumo de memoria.

Consulta¶

100 * (
  1 -
  (
    node_memory_MemAvailable_bytes
    /
    node_memory_MemTotal_bytes
  )
)

Configuración¶

Título: Memoria por instancia
Visualización: Bar Gauge
Unidad: Percent (0-100)

Actividades¶

Crea el panel.
Ordena por valor descendente.
Identifica la instancia con mayor uso.
Configura los umbrales.
Añade una transformación para mejorar los nombres si es necesario.

Fase 11: panel Time series de CPU¶

Objetivo¶

Analizar la evolución temporal del uso de CPU.

Consulta¶

100 - (
  avg by (instance) (
    rate(
      node_cpu_seconds_total{
        mode="idle",
        instance=~"$instance"
      }[5m]
    )
  ) * 100
)

Configuración¶

Título: Evolución de CPU
Visualización: Time series
Unidad: Percent (0-100)
Rango temporal: Last 1 hour

Recomendaciones¶

Utilizar una línea por instancia.
Configurar el eje vertical entre 0 y 100.
Añadir una leyenda.
Utilizar colores diferenciados.
Mostrar puntos o líneas según el objetivo.
Revisar el intervalo de consulta.

Actividades¶

Crea el panel.
Selecciona varias instancias.
Cambia el rango temporal a 15 minutos.
Cambia el rango a 6 horas.
Genera carga controlada.
Observa la evolución.
Identifica el inicio y el final de la carga.

Fase 12: panel Time series de memoria¶

Objetivo¶

Analizar la evolución de la memoria utilizada.

Consulta¶

100 * (
  1 -
  (
    node_memory_MemAvailable_bytes
    /
    node_memory_MemTotal_bytes
  )
)

Configuración¶

Título: Evolución de memoria
Visualización: Time series
Unidad: Percent (0-100)

Actividades¶

Crea el panel.
Selecciona varias instancias.
Añade una descripción.
Configura una línea de referencia en el 80 %.
Configura otra línea de referencia en el 90 %.
Interpreta la tendencia.

Fase 13: panel Time series de almacenamiento¶

Objetivo¶

Analizar la evolución del uso de los sistemas de ficheros.

Consulta¶

100 * (
  1 -
  node_filesystem_avail_bytes{
    instance=~"$instance",
    fstype!~"tmpfs|overlay"
  }
  /
  node_filesystem_size_bytes{
    instance=~"$instance",
    fstype!~"tmpfs|overlay"
  }
)

Configuración¶

Título: Uso de sistemas de ficheros
Visualización: Time series
Unidad: Percent (0-100)

Recomendaciones¶

Filtrar, si es necesario:

mountpoint="/"

Consulta para el sistema de ficheros raíz:

100 * (
  1 -
  node_filesystem_avail_bytes{
    instance=~"$instance",
    mountpoint="/",
    fstype!~"tmpfs|overlay"
  }
  /
  node_filesystem_size_bytes{
    instance=~"$instance",
    mountpoint="/",
    fstype!~"tmpfs|overlay"
  }
)

Actividades¶

Crea el panel.
Muestra únicamente /.
Después, muestra todos los puntos de montaje.
Identifica los sistemas con mayor uso.
Explica por qué se excluyen tmpfs y overlay.

Fase 14: panel de red¶

Objetivo¶

Mostrar el tráfico recibido y transmitido.

Tráfico recibido¶

rate(
  node_network_receive_bytes_total{
    instance=~"$instance",
    device!~"lo"
  }[5m]
)

Tráfico transmitido¶

rate(
  node_network_transmit_bytes_total{
    instance=~"$instance",
    device!~"lo"
  }[5m]
)

Configuración¶

Título: Tráfico de red
Visualización: Time series
Unidad: bytes/sec

Recomendaciones¶

Excluir la interfaz lo.
Filtrar interfaces virtuales si es necesario.
Separar tráfico recibido y transmitido.
Revisar los nombres de las interfaces.
Utilizar una leyenda clara.

Actividades¶

Crea el panel.
Añade el tráfico recibido.
Añade el tráfico transmitido.
Genera tráfico controlado en el laboratorio.
Observa el cambio.
Identifica la interfaz con actividad.

Fase 15: panel Table de disponibilidad¶

Objetivo¶

Crear una tabla con el estado de cada objetivo.

Consulta¶

up{job=~"$job", instance=~"$instance"}

Visualización¶

Table

Transformaciones¶

Aplicar:

1. Labels to fields.
2. Organize fields by name.

Renombrar:

instance → Instancia
job → Servicio
Value → Estado

Ocultar:

Time

Resultado esperado¶

Instancia	Servicio	Estado
server-01:9100	node_exporter	1
server-02:9100	node_exporter	1

Actividades¶

Crea el panel.
Renombra los campos.
Oculta los campos innecesarios.
Configura los mapas de valores:

1 → UP
0 → DOWN

Configura colores.
Detén un exporter.
Comprueba el cambio.

Fase 16: tabla de CPU y memoria¶

Objetivo¶

Crear una tabla operativa combinando dos consultas.

Consulta A: CPU¶

100 - (
  avg by (instance) (
    rate(node_cpu_seconds_total{mode="idle"}[5m])
  ) * 100
)

Consulta B: memoria¶

100 * (
  1 -
  node_memory_MemAvailable_bytes
  /
  node_memory_MemTotal_bytes
)

Transformaciones¶

1. Labels to fields.
2. Join by field utilizando instance.
3. Organize fields by name.
4. Rename fields.
5. Sort by CPU descendente.

Resultado esperado¶

Instancia	CPU	Memoria
server-02:9100	82.1	74.5
server-01:9100	42.3	61.2

Actividades¶

Crea las dos consultas.
Une los resultados.
Renombra los campos.
Ordena por CPU.
Añade una columna calculada:

Promedio de recursos = (CPU + Memoria) / 2

Explica por qué este promedio es únicamente un indicador orientativo.

Fase 17: panel Heatmap opcional¶

Objetivo¶

Crear un Heatmap a partir de una métrica de histograma.

Este panel requiere que Prometheus disponga de una métrica con buckets.

Buscar histogramas¶

{__name__=~".*_bucket"}

Ejemplo de métrica¶

http_request_duration_seconds_bucket

Consulta¶

sum by (le) (
  rate(
    http_request_duration_seconds_bucket[5m]
  )
)

Configuración¶

Título: Distribución de latencias
Visualización: Heatmap
Unidad: Seconds

Actividades¶

Busca una métrica _bucket.
Comprueba sus valores de le.
Confirma que existe +Inf.
Crea el Heatmap.
Identifica la zona de mayor densidad.
Calcula el percentil 95:

histogram_quantile(
  0.95,
  sum by (le) (
    rate(
      http_request_duration_seconds_bucket[5m]
    )
  )
)

Compara el percentil con el Heatmap.
Documenta si el laboratorio dispone de un histograma real.

Si no existe una métrica de histograma, documentar la limitación y continuar con el resto de la práctica.

Fase 18: panel Canvas¶

Objetivo¶

Crear una vista visual de la infraestructura.

Diseño propuesto¶

+------------------------------------------------------+
| Infraestructura de laboratorio                       |
+------------------------------------------------------+
|                                                      |
| +------------+       +-------------+                 |
| | Grafana    | ----> | Prometheus  |                 |
| | UP         |       | UP          |                 |
| +------------+       +-------------+                 |
|                              |                       |
|                      +-------+-------+               |
|                      |               |               |
|                      v               v               |
|                +-----------+   +-----------+          |
|                | Servidor 1|   | Servidor 2|          |
|                | UP        |   | UP        |          |
|                | CPU: 42 % |   | CPU: 78 % |          |
|                +-----------+   +-----------+          |
|                                                      |
+------------------------------------------------------+

Elementos¶

Añadir:

Título.
Formas para los componentes.
Textos.
Líneas o conexiones.
Estados.
Valores de CPU.
Leyenda de colores.

Consultas¶

Estado de Prometheus:

up{job="prometheus"}

Estado de Node Exporter:

up{job="node_exporter"}

CPU:

100 - (
  avg by (instance) (
    rate(node_cpu_seconds_total{mode="idle"}[5m])
  ) * 100
)

Actividades¶

Crea el Canvas.
Añade los componentes.
Añade las conexiones.
Configura los estados.
Añade la CPU de los servidores.
Detén un exporter.
Cambia el color del componente afectado.
Inicia de nuevo el exporter.
Comprueba la recuperación.

Fase 19: panel Text de procedimiento¶

Objetivo¶

Añadir instrucciones operativas al dashboard.

Contenido¶

## Procedimiento ante una incidencia

### 1. Disponibilidad

Comprueba el panel de objetivos y la consulta:

```promql
up

2. Recursos¶

Revisa:

CPU.
Memoria.
Almacenamiento.
Red.

3. Tendencia¶

Amplía el rango temporal para identificar cuándo comenzó el problema.

4. Sistema¶

Ejecuta únicamente las comprobaciones autorizadas:

uptime
free -h
df -h

5. Documentación¶

Registra:

Hora.
Instancia.
Métrica afectada.
Valor observado.
Acción realizada.

Resultado.

### Actividades

1. Añade el panel al final del dashboard.
2. Colócalo cerca de los paneles de recursos.
3. Añade un enlace a un runbook si existe.
4. Comprueba que los comandos son adecuados para el laboratorio.

---

## Fase 20: plugin de panel opcional

### Objetivo

Conocer cómo integrar un plugin de panel en un dashboard.

Esta fase debe realizarse únicamente con un plugin aprobado por el instructor.

### Actividades

1. Consultar los plugins disponibles.
2. Seleccionar un plugin de panel aprobado.
3. Registrar:
   - Nombre.
   - Identificador.
   - Versión.
   - Firma.
   - Compatibilidad.
4. Instalarlo en laboratorio.
5. Reiniciar Grafana si es necesario.
6. Revisar los logs.
7. Crear un panel de prueba.
8. Utilizar la consulta:

```promql
100 * avg(up)

Configurar la unidad.
Exportar el dashboard.
Documentar la dependencia.

Información que debe registrarse¶

### Plugin utilizado

Nombre:

Identificador:

Versión:

Estado de firma:

Fuente de instalación:

Versión de Grafana:

Panel creado:

Consulta utilizada:

Problemas encontrados:

Solución:

No instalar plugins no verificados en producción.

Fase 21: pruebas controladas¶

Objetivo¶

Observar cómo responde el dashboard ante diferentes situaciones.

Todas las pruebas deben ejecutarse en un entorno autorizado.

Prueba A: detener Node Exporter¶

Detener:

sudo systemctl stop node_exporter

Esperar al menos un intervalo de scraping y revisar:

up{job="node_exporter"}

Resultado esperado:

Comprobar:

Panel de disponibilidad.
Tabla de objetivos.
Canvas.
Paneles de CPU y memoria.
Comportamiento de No data.

Iniciar de nuevo:

sudo systemctl start node_exporter

Prueba B: carga de CPU¶

Ejecutar:

stress-ng --cpu 1 --timeout 60s

Comprobar:

Gauge de CPU.
Bar Gauge.
Time series.
Canvas.
Umbrales.

Prueba C: tráfico de red¶

Generar tráfico únicamente según las reglas del laboratorio.

Observar:

Tráfico recibido.
Tráfico transmitido.
Interfaz utilizada.
Evolución temporal.

Prueba D: cambio de rango temporal¶

Comparar:

Last 15 minutes
Last 1 hour
Last 6 hours
Last 24 hours

Documentar:

Qué detalle aparece.
Qué información se comprime.
Qué rango resulta más útil.
Qué rango genera más datos.

Fase 22: diagnóstico de un panel sin datos¶

Objetivo¶

Aprender a resolver problemas de visualización.

Procedimiento general¶

Abrir el panel.
Revisar la consulta.
Ejecutarla en Explore.
Comprobar la fuente de datos.
Comprobar las variables.
Revisar el rango temporal.
Revisar las etiquetas.
Revisar las transformaciones.
Abrir el inspector.
Revisar los logs si procede.

Ejemplo de consulta incorrecta¶

metric_que_no_existe

Corrección¶

Utilizar una métrica real:

up

Documentación del problema¶

Panel afectado:

Consulta inicial:

Resultado observado:

Causa:

Corrección aplicada:

Resultado final:

Actividades¶

Crea una consulta incorrecta de forma intencionada.
Observa el resultado.
Diagnostica el problema.
Corrige la consulta.
Completa el registro.

Fase 23: revisar el dashboard¶

Lista de comprobación visual¶

Comprobar:

Los títulos son claros.
Las unidades son correctas.
Las leyendas son legibles.
Los colores tienen significado.
No existen paneles superpuestos.
Las variables funcionan.
Las tablas muestran la identificación del recurso.
Los valores no están truncados.
El Canvas es legible.
El panel Text está actualizado.
Los enlaces funcionan.
No existen secretos.
No hay consultas innecesarias.

Lista de comprobación técnica¶

Comprobar:

La fuente de datos responde.
Las consultas devuelven datos.
Las transformaciones están justificadas.
Los umbrales coinciden con la documentación.
Los paneles aceptan varias instancias.
Las variables funcionan con All.
El rango temporal es adecuado.
El dashboard carga en un tiempo razonable.
Las dependencias están documentadas.
El JSON puede exportarse.

Fase 24: exportar el dashboard¶

Objetivo¶

Guardar una copia del dashboard.

Pasos¶

Abrir el menú del dashboard.
Seleccionar la opción de compartir o exportar.
Exportar la definición JSON.
Guardar el archivo como:

laboratorio-dashboards-visualizacion.json

Crear una copia en el directorio de evidencias.

cp laboratorio-dashboards-visualizacion.json \
  ~/laboratorio-grafana/evidencias/laboratorio-dashboards/

Validar el JSON:

jq empty \
  ~/laboratorio-grafana/evidencias/laboratorio-dashboards/laboratorio-dashboards-visualizacion.json

Comprobar referencias¶

Buscar paneles Canvas:

grep -n '"canvas"' \
  laboratorio-dashboards-visualizacion.json

Buscar paneles Text:

grep -n '"text"' \
  laboratorio-dashboards-visualizacion.json

Buscar un plugin concreto:

grep -n "ID_DEL_PLUGIN" \
  laboratorio-dashboards-visualizacion.json

Fase 25: importar una copia¶

Objetivo¶

Comprobar que el dashboard puede restaurarse.

Pasos¶

Crear un dashboard nuevo o utilizar otra instancia de laboratorio.
Seleccionar Import dashboard.
Cargar el archivo JSON.
Seleccionar la fuente de datos Prometheus.
Confirmar la importación.
Revisar los paneles.
Revisar las variables.
Revisar las transformaciones.
Revisar el Canvas.
Revisar los paneles que dependan de plugins.

Actividades¶

Comparar el dashboard original y el restaurado:

Elemento	Original	Restaurado	Observaciones
Panel Text
Variables
Paneles Stat
Gauges
Time series
Tables
Heatmap
Canvas
Plugins
Transformaciones

Fase 26: documentar el dashboard¶

Crear un panel Text o un fichero externo con las dependencias.

Contenido recomendado¶

## Dependencias del dashboard

### Grafana

Versión utilizada:

### Fuente de datos

- Prometheus

### Exporter

- Node Exporter

### Variables

- `job`
- `instance`

### Paneles

- Stat de disponibilidad.
- Gauge de CPU.
- Bar Gauge de CPU por instancia.
- Gauge de memoria.
- Time series de CPU.
- Time series de memoria.
- Time series de red.
- Table de disponibilidad.
- Table de recursos.
- Canvas de infraestructura.
- Text de documentación.

### Transformaciones

- Labels to fields.
- Organize fields by name.
- Join by field.
- Sort by.
- Limit.
- Reduce.

### Plugins

Indicar si se utiliza alguno.

### Rango temporal recomendado

```text
Last 1 hour

Actualización¶

30s

---

## Sesión práctica completa 1: crear el dashboard mínimo

### Objetivo

Crear una primera versión funcional.

### Tareas

1. Comprobar Prometheus.
2. Crear el dashboard.
3. Añadir la variable `job`.
4. Añadir la variable `instance`.
5. Crear un panel Text.
6. Crear un Stat de disponibilidad.
7. Crear un Gauge de CPU.
8. Crear un Gauge de memoria.
9. Guardar el dashboard.

### Resultado esperado

```text
Dashboard funcional con:
- Variables.
- Documentación.
- Disponibilidad.
- CPU.
- Memoria.

Evidencias¶

01-dashboard-minimo.png
02-variables.png
03-paneles-basicos.png

Sesión práctica completa 2: ampliar el dashboard¶

Objetivo¶

Añadir tendencias y tablas operativas.

Tareas¶

Crear Time series de CPU.
Crear Time series de memoria.
Crear Time series de disco.
Crear Time series de red.
Crear Table de disponibilidad.
Crear Table de CPU y memoria.
Aplicar transformaciones.
Ordenar las tablas.
Limitar resultados.
Guardar el dashboard.

Resultado esperado¶

Dashboard con:
- Valores actuales.
- Tendencias.
- Tablas operativas.

Sesión práctica completa 3: crear el Canvas¶

Objetivo¶

Representar visualmente la infraestructura.

Tareas¶

Crear un panel Canvas.
Añadir Prometheus.
Añadir Grafana.
Añadir un servidor.
Añadir un Node Exporter.
Crear conexiones.
Añadir estados.
Añadir CPU.
Añadir una leyenda.
Probar un estado DOWN.
Guardar el panel.

Resultado esperado¶

Vista visual de alto nivel de la infraestructura.

Sesión práctica completa 4: investigar una incidencia¶

Objetivo¶

Utilizar el dashboard para analizar una incidencia simulada.

Escenario¶

Uno de los objetivos deja de estar disponible.

Procedimiento¶

Detener Node Exporter:

sudo systemctl stop node_exporter

Esperar el siguiente intervalo de scraping.
Revisar el Stat de disponibilidad.
Revisar la tabla de objetivos.
Identificar la instancia afectada.
Revisar el Canvas.
Consultar Prometheus:

up

Revisar el servicio:

sudo systemctl status node_exporter

Iniciar el servicio:

sudo systemctl start node_exporter

Confirmar la recuperación.
Documentar el incidente.

Informe¶

Hora de inicio:

Instancia afectada:

Valor de up antes:

Valor de up durante la incidencia:

Causa simulada:

Acción realizada:

Hora de recuperación:

Resultado:

Sesión práctica completa 5: analizar carga de CPU¶

Objetivo¶

Observar el comportamiento del dashboard ante una carga controlada.

Pasos¶

Registrar el valor inicial de CPU.
Ejecutar:

stress-ng --cpu 1 --timeout 60s

Observar el Gauge.
Observar el Bar Gauge.
Observar el Time series.
Capturar el dashboard durante la carga.
Esperar a que finalice.
Observar la recuperación.
Comparar los valores.

Preguntas¶

¿Qué panel muestra el valor actual?
¿Qué panel muestra la tendencia?
¿Qué panel permite comparar instancias?
¿Qué umbral se ha superado?
¿Cuánto tardó en reflejarse el cambio?
¿Cuánto tardó en recuperarse?

Sesión práctica completa 6: solucionar un panel incorrecto¶

Objetivo¶

Diagnosticar una consulta o transformación incorrecta.

Situación¶

La tabla de CPU no muestra el nombre de las instancias.

Procedimiento¶

Abrir el panel.
Revisar el resultado original.
Comprobar si se ha ocultado instance.
Revisar Organize fields by name.
Volver a mostrar el campo.
Renombrarlo como Instancia.
Revisar la tabla.
Guardar la corrección.

Informe¶

Problema:

Transformación responsable:

Campo afectado:

Corrección:

Resultado:

Sesión práctica completa 7: comparar paneles¶

Objetivo¶

Comprender qué información aporta cada visualización.

Utilizar la métrica de CPU¶

100 - (
  avg by (instance) (
    rate(node_cpu_seconds_total{mode="idle"}[5m])
  ) * 100
)

Crear los paneles¶

Stat
Gauge
Bar Gauge
Time series
Table
Canvas

Comparar¶

Panel	Información principal
Stat	Valor resumido
Gauge	Valor frente a límites
Bar Gauge	Comparación
Time series	Evolución
Table	Detalle estructurado
Canvas	Contexto visual

Actividades¶

Coloca los paneles en el mismo dashboard.
Utiliza la misma unidad.
Compara su utilidad.
Explica cuál utilizarías para una alerta.
Explica cuál utilizarías para un informe.
Explica cuál utilizarías para investigar una tendencia.

Sesión práctica completa 8: evaluar la calidad del dashboard¶

Objetivo¶

Revisar el dashboard como si fuera a entregarse a otro equipo.

Criterios¶

Claridad¶

¿Los títulos son comprensibles?
¿Las unidades están visibles?
¿Los colores tienen significado?
¿El orden de los paneles es lógico?

Corrección¶

¿Las consultas son válidas?
¿Los cálculos son correctos?
¿Las variables funcionan?
¿Los umbrales coinciden?

Mantenibilidad¶

¿Las consultas están documentadas?
¿Las transformaciones están justificadas?
¿Las dependencias están registradas?
¿Los plugins están identificados?

Seguridad¶

¿Existen secretos?
¿Los enlaces son adecuados?
¿Las imágenes contienen información sensible?
¿Los permisos son correctos?

Rendimiento¶

¿Carga rápidamente?
¿Hay demasiadas consultas?
¿Se solicitan demasiadas series?
¿El rango temporal es razonable?

Rúbrica de evaluación¶

Criterio	Insuficiente	Básico	Correcto	Excelente
Fuente de datos	No configurada	Configurada parcialmente	Funciona	Documentada y comprobada
Variables	No existen	Una variable	Funcionan correctamente	Incluyen filtros y `All`
Disponibilidad	No creada	Muestra datos	Tiene umbrales	Incluye tabla y pruebas
CPU	No creada	Valor actual	Valor y tendencia	Comparación y prueba de carga
Memoria	No creada	Valor actual	Tiene unidad	Incluye tendencia y umbrales
Almacenamiento	No creado	Consulta parcial	Panel funcional	Filtra sistemas irrelevantes
Red	No creada	Datos parciales	Recibido y transmitido	Interpreta interfaces
Transformaciones	No utilizadas	Uso parcial	Correctas	Documentadas y ordenadas
Canvas	No creado	Diseño incompleto	Vista funcional	Vista clara e interactiva
Text	No creado	Texto básico	Documenta el dashboard	Incluye procedimiento y dependencias
Heatmap	No creado	Intento parcial	Funciona con histograma	Comparado con percentiles
Plugins	Sin documentación	Revisados	Utilizados correctamente	Dependencias y seguridad documentadas
Exportación	No realizada	Archivo creado	Importación correcta	Recuperación verificada
Informe	Incompleto	Parcial	Completo	Claro y reproducible

Entregables¶

El alumno debe entregar:

1. Dashboard de Grafana.
2. Exportación JSON.
3. Informe de prácticas.
4. Consultas PromQL.
5. Capturas de pantalla.
6. Registro de variables.
7. Registro de transformaciones.
8. Documentación de plugins, si se utilizan.
9. Evidencia de una incidencia simulada.
10. Conclusiones.

Estructura recomendada¶

entrega/
├── dashboard/
│   └── laboratorio-dashboards-visualizacion.json
├── consultas/
│   └── consultas-promql.txt
├── evidencias/
│   ├── 01-fuente-datos-prometheus.png
│   ├── 02-variables-dashboard.png
│   ├── 03-panel-text-portada.png
│   ├── 04-panel-stat-disponibilidad.png
│   ├── 05-cpu-normal.png
│   ├── 06-cpu-durante-carga.png
│   ├── 07-cpu-recuperacion.png
│   ├── 08-dashboard-final.png
│   └── 09-incidencia.png
├── documentacion/
│   ├── dependencias.md
│   └── transformaciones.md
└── informe.txt

Consultas de referencia¶

Disponibilidad¶

up

Objetivos disponibles¶

sum(up)

Porcentaje de disponibilidad¶

100 * avg(up)

CPU por instancia¶

100 - (
  avg by (instance) (
    rate(node_cpu_seconds_total{mode="idle"}[5m])
  ) * 100
)

Memoria utilizada¶

100 * (
  1 -
  node_memory_MemAvailable_bytes
  /
  node_memory_MemTotal_bytes
)

Almacenamiento utilizado¶

100 * (
  1 -
  node_filesystem_avail_bytes{
    fstype!~"tmpfs|overlay"
  }
  /
  node_filesystem_size_bytes{
    fstype!~"tmpfs|overlay"
  }
)

Carga del sistema¶

node_load1

Tráfico recibido¶

rate(
  node_network_receive_bytes_total{
    device!="lo"
  }[5m]
)

Tráfico transmitido¶

rate(
  node_network_transmit_bytes_total{
    device!="lo"
  }[5m]
)

Buscar histogramas¶

{__name__=~".*_bucket"}

Tabla de resultados¶

Comprobación	Resultado	Observaciones
Grafana disponible
Prometheus disponible
Node Exporter disponible
Fuente de datos comprobada
Dashboard creado
Variable `job` creada
Variable `instance` creada
Panel Text creado
Stat de disponibilidad creado
Gauge de CPU creado
Bar Gauge de CPU creado
Gauge de memoria creado
Time series de CPU creado
Time series de memoria creado
Panel de disco creado
Panel de red creado
Tabla de disponibilidad creada
Tabla de recursos creada
Transformaciones aplicadas
Canvas creado
Heatmap probado
Plugin revisado
Incidencia simulada
Carga de CPU simulada
Dashboard exportado
Dashboard importado
Evidencias guardadas
Informe completado

Puntos clave¶

Un dashboard debe facilitar la interpretación de las métricas.
La fuente de datos debe comprobarse antes de crear paneles.
Las variables permiten reutilizar un dashboard con diferentes instancias.
Stat muestra valores resumidos.
Gauge muestra valores frente a umbrales.
Bar Gauge facilita la comparación.
Time series muestra la evolución temporal.
Table muestra información detallada.
Heatmap representa distribuciones cuando existen histogramas.
Text documenta el propósito, las unidades y los procedimientos.
Canvas ofrece una vista visual personalizada.
Las transformaciones preparan los datos para la visualización.
Los plugins deben instalarse únicamente cuando aportan valor.
Las pruebas controladas ayudan a comprobar que el dashboard responde.
Los paneles deben probarse con estados normales, caídos y sin datos.
Las consultas PromQL deben estar documentadas.
Las unidades y los umbrales deben ser coherentes.
Las tablas deben conservar la identificación del recurso.
El dashboard debe poder exportarse e importarse.
Las dependencias deben documentarse.
No se deben incluir secretos ni información sensible.
La sencillez mejora la mantenibilidad.
Un dashboard útil no es el que tiene más paneles, sino el que permite tomar decisiones con menos esfuerzo.

Preguntas de comprobación¶

¿Qué componentes forman la arquitectura del laboratorio?
¿Qué función cumple Prometheus?
¿Qué función cumple Node Exporter?
¿Qué consulta permite comprobar la disponibilidad?
¿Qué significa el valor 1 en la métrica up?
¿Qué diferencia existe entre un Stat y un Gauge?
¿Cuándo utilizarías un Bar Gauge?
¿Qué información muestra un Time series?
¿Qué utilidad tiene una tabla operativa?
¿Qué consulta permite calcular el uso de CPU?
¿Qué consulta permite calcular el uso de memoria?
¿Por qué se excluyen tmpfs y overlay en algunas consultas de disco?
¿Qué función cumple una variable de dashboard?
¿Qué ocurre cuando se selecciona All?
¿Qué utilidad tiene un panel Text?
¿Qué utilidad tiene un panel Canvas?
¿Qué diferencia existe entre una consulta y una transformación?
¿Por qué es importante el orden de las transformaciones?
¿Qué debe comprobarse antes de utilizar un plugin?
¿Qué pasos realizarías si un panel no muestra datos?
¿Cómo simularías la caída de un objetivo en el laboratorio?
¿Cómo comprobarías la recuperación?
¿Qué evidencias deben entregarse?
¿Por qué debe exportarse el dashboard?
¿Qué información debe incluir la documentación de dependencias?
¿Qué riesgos existen al incluir secretos en un dashboard?
¿Qué criterios utilizarías para evaluar la calidad del dashboard?
¿Qué panel utilizarías para analizar una tendencia?
¿Qué panel utilizarías para comparar instancias?
¿Qué panel utilizarías para representar la topología de la infraestructura?

Resultado esperado¶

Al finalizar el laboratorio, el alumno debe haber creado un dashboard funcional, documentado y reproducible.

El proceso completo será:

Comprobar la arquitectura
        |
        v
Configurar la fuente de datos
        |
        v
Crear variables
        |
        v
Añadir documentación
        |
        v
Crear paneles de disponibilidad
        |
        v
Crear paneles de recursos
        |
        v
Crear tendencias
        |
        v
Crear tablas
        |
        v
Aplicar transformaciones
        |
        v
Crear Canvas
        |
        v
Probar Heatmap y plugins
        |
        v
Simular incidencias
        |
        v
Diagnosticar errores
        |
        v
Exportar e importar
        |
        v
Documentar y evaluar

El resultado final debe ser un dashboard capaz de mostrar:

Qué está funcionando
Qué recurso presenta mayor consumo
Cómo evoluciona el sistema
Qué instancia está afectada
Qué procedimiento debe seguirse
Cómo recuperar el dashboard
Qué dependencias necesita

Un buen dashboard no sustituye al análisis técnico, pero permite comenzar ese análisis con información clara, ordenada y contextualizada.

Laboratorio - Dashboards y visualización¶

Objetivos¶

Introducción¶

Arquitectura del laboratorio¶

Componentes¶

Grafana¶

Prometheus¶

Node Exporter¶

Requisitos previos¶

Comprobar servicios¶

Comprobar Node Exporter¶

Comprobar Prometheus¶

Preparar el directorio de evidencias¶

Fase 1: comprobar la fuente de datos¶

Objetivo¶

Pasos¶

Actividades¶

Evidencia¶

Fase 2: crear el dashboard¶

Objetivo¶

Pasos¶

Descripción recomendada¶

Actividades¶

Fase 3: crear variables de dashboard¶

Objetivo¶

Variable job¶

Variable instance¶

Actividades¶

Evidencia¶

Fase 4: panel Text de portada¶

Objetivo¶

Contenido¶

Pasos¶

Actividades¶

Evidencia¶

Fase 5: panel Stat de disponibilidad¶

Objetivo¶

Consulta¶

Configuración¶

Umbrales conceptuales¶

Actividades¶

Evidencia¶

Fase 6: panel Stat de disponibilidad porcentual¶

Objetivo¶

Consulta¶

Configuración¶

Umbrales¶

Actividades¶

Fase 7: panel Gauge de CPU¶

Objetivo¶

Consulta¶

Configuración¶

Umbrales¶

Actividades¶

Carga controlada¶

Evidencias¶

Fase 8: panel Bar Gauge de CPU por instancia¶

Objetivo¶

Consulta¶

Configuración¶

Recomendaciones¶

Actividades¶

Fase 9: panel Gauge de memoria¶

Objetivo¶

Consulta¶

Configuración¶

Umbrales¶

Actividades¶

Fase 10: panel Bar Gauge de memoria por instancia¶

Objetivo¶

Consulta¶

Configuración¶

Actividades¶

Fase 11: panel Time series de CPU¶

Objetivo¶

Consulta¶

Configuración¶

Recomendaciones¶

Actividades¶

Fase 12: panel Time series de memoria¶

Variable `job`¶

Variable `instance`¶