Laboratorio: Prometheus, Node Exporter y Grafana¶

Este laboratorio integra los componentes principales de una plataforma de monitorización:

Prometheus: recopila y almacena métricas.
Node Exporter: expone métricas del sistema operativo.
Grafana: consulta Prometheus y representa la información.
PromQL: permite consultar y transformar las métricas.

Durante la práctica se construirá el siguiente flujo:

Sistema operativo
        |
        v
Node Exporter
        |
        | HTTP /metrics
        v
Prometheus
        |
        | PromQL / API HTTP
        v
Grafana
        |
        v
Dashboards

El objetivo no es únicamente ejecutar comandos. El alumno debe ser capaz de explicar qué componente participa en cada paso, comprobar el funcionamiento de la plataforma y diagnosticar los problemas más habituales.

Objetivos¶

Al finalizar este laboratorio, el alumno podrá:

Explicar la función de Prometheus, Node Exporter y Grafana.
Comprobar el estado de los servicios implicados.
Verificar los puertos utilizados por cada componente.
Comprobar el endpoint /metrics de Node Exporter.
Configurar Prometheus para realizar scraping de Node Exporter.
Validar el fichero prometheus.yml.
Consultar los objetivos desde Prometheus.
Interpretar la métrica up.
Ejecutar consultas PromQL.
Calcular el uso de CPU.
Calcular el uso de memoria.
Calcular el uso del sistema de ficheros.
Consultar el tráfico de red.
Añadir Prometheus como fuente de datos en Grafana.
Crear un dashboard básico.
Crear paneles de disponibilidad, CPU, memoria y almacenamiento.
Diagnosticar objetivos en estado DOWN.
Identificar errores de conectividad entre Grafana y Prometheus.
Configurar una fuente de datos mediante provisioning.
Guardar evidencias de la instalación y configuración.
Documentar el resultado final del laboratorio.

Arquitectura y componentes¶

Introducción¶

Una plataforma de monitorización está formada por varias piezas especializadas.

Prometheus¶

Prometheus consulta periódicamente los endpoints de métricas configurados, almacena los datos como series temporales y permite consultarlos mediante PromQL.

Su puerto habitual es:

URL local:

http://localhost:9090

Node Exporter¶

Node Exporter recopila información del sistema operativo Linux y la expone mediante HTTP.

Su puerto habitual es:

Endpoint de métricas:

http://localhost:9100/metrics

Grafana¶

Grafana consulta Prometheus y utiliza los resultados para crear dashboards y paneles.

Su puerto habitual es:

URL local:

http://localhost:3000

Flujo de trabajo¶

1. Node Exporter expone métricas.
2. Prometheus consulta /metrics.
3. Prometheus almacena las muestras.
4. PromQL consulta los datos almacenados.
5. Grafana ejecuta consultas PromQL.
6. Grafana representa los resultados.

Arquitectura del laboratorio¶

+----------------------------------------------------------+
| Servidor Linux                                           |
|                                                          |
|  Node Exporter                                          |
|  http://localhost:9100/metrics                          |
|              |                                           |
|              v                                           |
|  Prometheus                                              |
|  http://localhost:9090                                  |
|              |                                           |
|              v                                           |
|  Grafana                                                 |
|  http://localhost:3000                                  |
+----------------------------------------------------------+

Puertos utilizados¶

Componente	Puerto	Función
Prometheus	`9090`	Interfaz web y API
Node Exporter	`9100`	Endpoint de métricas
Grafana	`3000`	Interfaz web y API

Requisitos previos¶

Antes de comenzar, comprobar que se dispone de:

Un servidor Linux.
Un usuario con permisos de sudo.
Conectividad de red.
Prometheus instalado.
Node Exporter instalado.
Grafana instalado.
Un navegador web.
Al menos 2 GB de memoria disponible.
Los puertos 9090, 9100 y 3000 disponibles.
La hora del sistema sincronizada.

Comprobar la distribución¶

lsb_release -ds

También puede utilizarse:

cat /etc/os-release

Comprobar la arquitectura¶

uname -m

Comprobar la memoria¶

free -h

Comprobar el espacio disponible¶

df -h /

Comprobar la hora¶

timedatectl status

Comprobar los puertos¶

sudo ss -lntp | grep -E ':(3000|9090|9100)'

Si alguno de los puertos no aparece, el servicio correspondiente puede estar detenido o configurado con otro puerto.

Variables utilizadas¶

Durante el laboratorio se utilizarán estas variables:

export PROMETHEUS_URL="http://localhost:9090"
export NODE_EXPORTER_URL="http://localhost:9100"
export GRAFANA_URL="http://localhost:3000"

Comprobarlas:

echo "$PROMETHEUS_URL"
echo "$NODE_EXPORTER_URL"
echo "$GRAFANA_URL"

Comprobación inicial de los servicios¶

Comprobar Prometheus¶

systemctl is-active prometheus

Resultado esperado:

active

Comprobar el endpoint de salud:

curl "$PROMETHEUS_URL/-/healthy"

Resultado esperado:

Prometheus is Healthy.

Comprobar el endpoint de preparación:

curl "$PROMETHEUS_URL/-/ready"

Resultado esperado:

Prometheus is Ready.

Comprobar Node Exporter¶

Si Node Exporter se instaló manualmente:

systemctl is-active node_exporter

Si se instaló mediante el paquete de Ubuntu:

systemctl is-active prometheus-node-exporter

Comprobar el endpoint:

curl -I "$NODE_EXPORTER_URL/metrics"

Resultado esperado:

HTTP/1.1 200 OK

Comprobar Grafana¶

systemctl is-active grafana-server

Resultado esperado:

active

Comprobar la API:

curl -s "$GRAFANA_URL/api/health" | jq

Resultado conceptual:

{
  "database": "ok",
  "version": "...",
  "commit": "..."
}

Sesión 1: comprobar la instalación¶

Objetivo¶

Verificar que los tres componentes están instalados y activos.

Comprobar los servicios¶

systemctl is-active prometheus

Para una instalación manual de Node Exporter:

systemctl is-active node_exporter

Para una instalación mediante APT:

systemctl is-active prometheus-node-exporter

Comprobar Grafana:

systemctl is-active grafana-server

Consultar las versiones¶

prometheus --version

node_exporter --version

Consultar la versión de Grafana mediante la API:

curl -s "$GRAFANA_URL/api/health" \
  | jq -r '.version'

Consultar los puertos¶

sudo ss -lntp | grep -E ':(3000|9090|9100)'

Actividades¶

Anota el estado de cada servicio.
Anota las versiones.
Anota los puertos en escucha.
Identifica el proceso asociado a cada puerto.
Explica qué función cumple cada componente.

Completar:

Componente	Servicio	Puerto	Estado
Prometheus
Node Exporter
Grafana

Sesión 2: comprobar Node Exporter¶

Objetivo¶

Comprobar que Node Exporter expone métricas del sistema operativo.

Consultar las primeras líneas¶

curl -s "$NODE_EXPORTER_URL/metrics" \
  | head -n 20

Buscar métricas de CPU¶

curl -s "$NODE_EXPORTER_URL/metrics" \
  | grep '^node_cpu_seconds_total' \
  | head

Buscar métricas de memoria¶

curl -s "$NODE_EXPORTER_URL/metrics" \
  | grep '^node_memory_' \
  | head

Buscar métricas de almacenamiento¶

curl -s "$NODE_EXPORTER_URL/metrics" \
  | grep '^node_filesystem_' \
  | head

Buscar métricas de red¶

curl -s "$NODE_EXPORTER_URL/metrics" \
  | grep '^node_network_' \
  | head

Actividades¶

Localiza una métrica de CPU.
Localiza una métrica de memoria.
Localiza una métrica de disco.
Localiza una métrica de red.
Anota las etiquetas que aparecen.
Explica la diferencia entre una línea HELP, una línea TYPE y una muestra.

Completar:

Categoría	Métrica encontrada	Etiquetas
CPU
Memoria
Disco
Red

Sesión 3: configurar el scraping¶

Objetivo¶

Configurar Prometheus para consultar Node Exporter.

Crear una copia de seguridad¶

sudo cp \
  /etc/prometheus/prometheus.yml \
  "/etc/prometheus/prometheus.yml.$(date +%Y%m%d-%H%M%S).bak"

Crear la configuración¶

sudo tee /etc/prometheus/prometheus.yml > /dev/null <<'EOF'
---
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets:
          - localhost:9090

  - job_name: node_exporter
    static_configs:
      - targets:
          - localhost:9100
        labels:
          environment: laboratorio
          role: monitoring
EOF

Mostrar el fichero:

sudo cat /etc/prometheus/prometheus.yml

Validar la configuración¶

promtool check config /etc/prometheus/prometheus.yml

Resultado esperado:

SUCCESS

El texto exacto puede variar según la versión de Prometheus.

Reiniciar Prometheus¶

sudo systemctl restart prometheus

Comprobar:

systemctl is-active prometheus

Consultar los registros recientes:

sudo journalctl -u prometheus \
  --since "1 minute ago" \
  --no-pager

Sesión 4: comprobar los objetivos¶

Objetivo¶

Comprobar que Prometheus ha cargado los objetivos y puede consultarlos.

Comprobar desde la interfaz web¶

Abrir:

http://localhost:9090

Acceder a:

Status → Targets

Comprobar que aparecen:

prometheus
node_exporter

Ambos deben aparecer como:

UP

Comprobar mediante la API¶

curl -s "$PROMETHEUS_URL/api/v1/targets" \
  | jq

Mostrar un resumen:

curl -s "$PROMETHEUS_URL/api/v1/targets" \
  | jq -r '
    .data.activeTargets[]
    | [
        .labels.job,
        .labels.instance,
        .health,
        .scrapeUrl,
        .lastError
      ]
    | @tsv
  '

Resultado conceptual:

prometheus      localhost:9090  up  http://localhost:9090/metrics
node_exporter   localhost:9100  up  http://localhost:9100/metrics

Actividades¶

Anota los jobs.
Anota las instancias.
Comprueba la URL de scraping.
Comprueba el estado.
Comprueba que no hay errores.
Comprueba que aparecen las etiquetas personalizadas.

Sesión 5: consultar la métrica `up`¶

Objetivo¶

Utilizar PromQL para comprobar la disponibilidad de los objetivos.

Consultar todos los objetivos¶

up

Resultado conceptual:

up{instance="localhost:9090",job="prometheus"} 1
up{instance="localhost:9100",job="node_exporter"} 1

Consultar únicamente Node Exporter¶

up{job="node_exporter"}

Consultar los objetivos caídos¶

up == 0

Contar los objetivos¶

count(up)

Contar los objetivos disponibles¶

sum(up)

Calcular el porcentaje de disponibilidad¶

100 * avg(up)

Consultar mediante la API¶

curl -sG "$PROMETHEUS_URL/api/v1/query" \
  --data-urlencode 'query=up' \
  | jq

Mostrar únicamente job, instancia y valor:

curl -sG "$PROMETHEUS_URL/api/v1/query" \
  --data-urlencode 'query=up' \
  | jq -r '
    .data.result[]
    | [
        .metric.job,
        .metric.instance,
        .value[1]
      ]
    | @tsv
  '

Sesión 6: practicar consultas PromQL¶

Objetivo¶

Consultar métricas de Prometheus y Node Exporter.

Métricas de Prometheus¶

prometheus_build_info

process_resident_memory_bytes{job="prometheus"}

prometheus_tsdb_head_series

rate(process_cpu_seconds_total{job="prometheus"}[5m])

Métricas de memoria¶

node_memory_MemTotal_bytes

node_memory_MemAvailable_bytes

Métricas de carga¶

node_load1

node_load5

node_load15

Métricas de red¶

node_network_receive_bytes_total

node_network_transmit_bytes_total

Actividades¶

Ejecuta cada consulta.
Cambia entre las vistas Table y Graph.
Identifica qué métricas son gauge.
Identifica qué métricas son counter.
Anota las etiquetas de cada resultado.
Indica qué consultas son apropiadas para un gráfico temporal.

Sesión 7: calcular el uso de CPU¶

Objetivo¶

Construir una consulta PromQL para calcular el porcentaje de CPU utilizado.

Consultar el contador de CPU¶

node_cpu_seconds_total

Filtrar el modo inactivo¶

node_cpu_seconds_total{
  mode="idle"
}

Calcular la velocidad de cambio¶

rate(node_cpu_seconds_total{
  mode="idle"
}[5m])

Calcular la media por instancia¶

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

Calcular el porcentaje de CPU utilizado¶

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

Generar carga temporal¶

Ejecutar únicamente en el entorno de laboratorio:

yes > /dev/null &
yes > /dev/null &

Comprobar los procesos:

pgrep yes

Detener los procesos:

pkill yes

Actividades¶

Ejecuta la consulta de uso de CPU.
Visualízala como gráfico.
Genera carga durante un periodo corto.
Observa el aumento del uso.
Detén la carga.
Observa la recuperación.
Explica por qué se utiliza rate().

Sesión 8: calcular el uso de memoria¶

Objetivo¶

Calcular el porcentaje de memoria utilizada.

Memoria total¶

node_memory_MemTotal_bytes

Memoria disponible¶

node_memory_MemAvailable_bytes

Memoria utilizada en bytes¶

node_memory_MemTotal_bytes
-
node_memory_MemAvailable_bytes

Porcentaje disponible¶

100 *
node_memory_MemAvailable_bytes
/
node_memory_MemTotal_bytes

Porcentaje utilizado¶

100 * (
  1 -
  node_memory_MemAvailable_bytes
  /
  node_memory_MemTotal_bytes
)

Comparar con el sistema operativo¶

free -h

Actividades¶

Ejecuta las consultas.
Compara los resultados con free -h.
Configura la unidad como porcentaje.
Representa el porcentaje utilizado como un indicador.
Explica por qué el resultado puede cambiar entre consultas.

Sesión 9: calcular el uso del sistema de ficheros¶

Objetivo¶

Calcular el porcentaje de espacio utilizado en el sistema de ficheros raíz.

Consultar el tamaño total¶

node_filesystem_size_bytes{
  mountpoint="/"
}

Consultar el espacio disponible¶

node_filesystem_avail_bytes{
  mountpoint="/"
}

Calcular el porcentaje utilizado¶

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

Comparar con el sistema operativo¶

df -h /

Buscar sistemas con más del 80 % de uso¶

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

Actividades¶

Identifica el sistema de ficheros raíz.
Excluye tmpfs.
Excluye overlay.
Compara la consulta con df -h.
Configura la unidad del panel como porcentaje.
Explica por qué se excluyen algunos tipos de sistemas de ficheros.

Sesión 10: consultar el tráfico de red¶

Objetivo¶

Calcular el tráfico recibido y enviado por las interfaces.

Bytes recibidos¶

node_network_receive_bytes_total

Bytes enviados¶

node_network_transmit_bytes_total

Tráfico recibido por segundo¶

rate(node_network_receive_bytes_total[5m])

Tráfico enviado por segundo¶

rate(node_network_transmit_bytes_total[5m])

Excluir la interfaz de loopback¶

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

Sumar tráfico por instancia¶

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

Comparar con el sistema operativo¶

ip -s link

Actividades¶

Identifica las interfaces disponibles.
Excluye lo.
Representa el tráfico recibido.
Representa el tráfico enviado.
Configura la unidad como bytes/sec.
Explica por qué se utiliza rate().

Sesión 11: añadir Prometheus como fuente de datos en Grafana¶

Objetivo¶

Configurar Grafana para consultar Prometheus.

Acceder a Grafana¶

Abrir:

http://localhost:3000

Crear la fuente de datos¶

Acceder a:

Connections → Data sources

Seleccionar:

Add new data source → Prometheus

Configurar:

Name: Prometheus
URL: http://localhost:9090
Access: Server o Proxy

Activar:

Set as default

Pulsar:

Save & test

Resultado esperado¶

Grafana debe mostrar un mensaje indicando que la API de Prometheus responde correctamente.

Actividades¶

Anota el nombre de la fuente.
Anota la URL.
Anota el modo de acceso.
Comprueba si es la fuente predeterminada.
Guarda una captura de la prueba correcta.
Explica a qué equipo apunta localhost.

Sesión 12: crear un dashboard básico¶

Objetivo¶

Crear un dashboard con información de disponibilidad y recursos.

Crear un dashboard nuevo y añadir los siguientes paneles.

Panel de disponibilidad de los objetivos¶

Consulta:

up

Visualización recomendada:

Table

Título:

Estado de los objetivos

Panel de uso de CPU¶

Consulta:

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

Visualización recomendada:

Time series

Unidad:

Percent (0-100)

Título:

Uso de CPU

Panel de uso de memoria¶

Consulta:

100 * (
  1 -
  node_memory_MemAvailable_bytes
  /
  node_memory_MemTotal_bytes
)

Visualización recomendada:

Gauge

Unidad:

Percent (0-100)

Título:

Uso de memoria

Panel de uso del sistema de ficheros¶

Consulta:

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

Visualización recomendada:

Gauge

Unidad:

Percent (0-100)

Título:

Uso del sistema de ficheros raíz

Panel de carga del sistema¶

Consulta:

node_load1

Visualización recomendada:

Time series

Título:

Carga del sistema

Panel de tráfico recibido¶

Consulta:

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

Visualización recomendada:

Time series

Unidad:

bytes/sec

Título:

Tráfico recibido

Actividades¶

Crea los seis paneles.
Selecciona Prometheus como fuente.
Configura las unidades.
Guarda el dashboard.
Comprueba que los paneles muestran datos.
Anota el nombre del dashboard.

Sesión 13: probar un objetivo en estado `DOWN`¶

Objetivo¶

Comprobar cómo detecta Prometheus la caída de Node Exporter.

Comprobar el estado inicial¶

up{job="node_exporter"}

Resultado esperado:

Detener Node Exporter¶

Si se instaló manualmente:

sudo systemctl stop node_exporter

Si se instaló mediante APT:

sudo systemctl stop prometheus-node-exporter

Esperar más de un intervalo de scraping.

Consultar el estado¶

up{job="node_exporter"}

Consultar el objetivo desde la API:

curl -s "$PROMETHEUS_URL/api/v1/targets" \
  | jq -r '
    .data.activeTargets[]
    | select(.labels.job == "node_exporter")
    | [
        .labels.instance,
        .health,
        .lastError
      ]
    | @tsv
  '

Iniciar Node Exporter¶

Si se instaló manualmente:

sudo systemctl start node_exporter

Si se instaló mediante APT:

sudo systemctl start prometheus-node-exporter

Comprobar el servicio:

systemctl is-active node_exporter

Si se utiliza APT:

systemctl is-active prometheus-node-exporter

Esperar al siguiente scraping.

Verificar la recuperación¶

up{job="node_exporter"}

Resultado esperado:

Actividades¶

Anota el estado inicial.
Anota el error durante la interrupción.
Anota el tiempo aproximado de detección.
Anota el tiempo aproximado de recuperación.
Explica la relación con scrape_interval.

Sesión 14: diagnosticar una conexión incorrecta en Grafana¶

Objetivo¶

Diferenciar un problema de conexión de un problema de consulta.

Probar una URL incorrecta¶

Editar temporalmente la fuente de datos y sustituir:

http://localhost:9090

por:

http://localhost:9999

Pulsar:

Save & test

Debe aparecer un error de conexión.

Restaurar la URL¶

Volver a configurar:

http://localhost:9090

Pulsar:

Save & test

Probar una consulta inexistente¶

En un panel ejecutar:

metrica_que_no_existe

Esta consulta puede no devolver datos, pero la fuente puede estar funcionando correctamente.

Probar una consulta válida¶

up

Actividades¶

Compara el error de conexión con una consulta vacía.
Explica cómo se diagnostica cada caso.
Utiliza el inspector del panel.
Comprueba la API de Prometheus directamente.
Documenta las diferencias.

Configurar la fuente mediante provisioning¶

Objetivo¶

Crear la fuente de datos automáticamente mediante un fichero YAML.

Crear el directorio¶

sudo mkdir -p /etc/grafana/provisioning/datasources

Crear el fichero¶

sudo tee /etc/grafana/provisioning/datasources/prometheus.yml > /dev/null <<'EOF'
apiVersion: 1

datasources:
  - name: Prometheus
    uid: prometheus
    type: prometheus
    access: proxy
    url: http://localhost:9090
    isDefault: true
    editable: true
EOF

Reiniciar Grafana¶

sudo systemctl restart grafana-server

Comprobar:

systemctl is-active grafana-server

Acceder a:

Connections → Data sources

Comprobar que aparece:

Prometheus

Actividades¶

Crea el fichero de provisioning.
Reinicia Grafana.
Comprueba que la fuente existe.
Comprueba su UID.
Comprueba que es la fuente predeterminada.
Consulta los registros de Grafana.

Consultar errores de provisioning¶

sudo journalctl -u grafana-server \
  --since "5 minutes ago" \
  --no-pager

Revisar el fichero:

sudo cat /etc/grafana/provisioning/datasources/prometheus.yml

Diagnóstico de problemas¶

Prometheus no está activo¶

Comprobar:

sudo systemctl status prometheus

Consultar los registros:

sudo journalctl -u prometheus \
  --no-pager \
  -n 100

Validar la configuración:

promtool check config /etc/prometheus/prometheus.yml

Comprobar el puerto:

sudo ss -lntp | grep ':9090'

Node Exporter no está activo¶

Para una instalación manual:

sudo systemctl status node_exporter

Para una instalación mediante APT:

sudo systemctl status prometheus-node-exporter

Consultar los registros de una instalación manual:

sudo journalctl -u node_exporter \
  --no-pager \
  -n 100

Consultar los registros de una instalación mediante APT:

sudo journalctl -u prometheus-node-exporter \
  --no-pager \
  -n 100

Comprobar el endpoint:

curl -v http://localhost:9100/metrics

Comprobar el puerto:

sudo ss -lntp | grep ':9100'

El target aparece como `DOWN`¶

Comprobar directamente Node Exporter:

curl http://localhost:9100/metrics

Comprobar la configuración:

sudo grep -A10 -B2 'node_exporter' \
  /etc/prometheus/prometheus.yml

Consultar el último error:

curl -s "$PROMETHEUS_URL/api/v1/targets" \
  | jq -r '
    .data.activeTargets[]
    | select(.labels.job == "node_exporter")
    | .lastError
  '

Posibles causas:

Puerto incorrecto.
Servicio detenido.
Dirección incorrecta.
Firewall.
Error de YAML.
Prometheus no se ha reiniciado.
Node Exporter escucha solo en otra interfaz.
Grafana y Prometheus utilizan redes diferentes.

Grafana no conecta con Prometheus¶

Comprobar Prometheus desde el servidor de Grafana:

curl http://localhost:9090/-/healthy

Si están en servidores separados:

curl http://IP_DEL_SERVIDOR_PROMETHEUS:9090/-/healthy

Comprobar la conectividad:

nc -vz IP_DEL_SERVIDOR_PROMETHEUS 9090

Consultar los registros:

sudo journalctl -u grafana-server \
  --no-pager \
  -n 100

Revisar:

URL.
Puerto.
Nombre DNS.
Red de contenedores.
Firewall.
Modo de acceso.
TLS.
Autenticación.

Grafana conecta, pero el panel está vacío¶

Comprobar:

up

Después:

prometheus_build_info

Y:

node_memory_MemAvailable_bytes

Revisar:

Fuente seleccionada.
Consulta.
Rango temporal.
Variables del dashboard.
Filtros.
Unidades.
Estado de los targets.

Evidencias del laboratorio¶

Crear el directorio:

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

Guardar información del sistema¶

{
  echo "===== SISTEMA ====="
  echo "Fecha: $(date)"
  echo "Hostname: $(hostname)"
  echo "Sistema: $(lsb_release -ds)"
  echo "Arquitectura: $(uname -m)"
  echo "Kernel: $(uname -r)"
} | tee \
  ~/laboratorio-grafana/evidencias/laboratorio-integrador/sistema.txt

Guardar los estados de los servicios¶

{
  echo "===== PROMETHEUS ====="
  systemctl is-active prometheus
  systemctl is-enabled prometheus
  echo
  echo "===== NODE EXPORTER MANUAL ====="
  systemctl is-active node_exporter 2>/dev/null || true
  systemctl is-enabled node_exporter 2>/dev/null || true
  echo
  echo "===== NODE EXPORTER APT ====="
  systemctl is-active prometheus-node-exporter 2>/dev/null || true
  systemctl is-enabled prometheus-node-exporter 2>/dev/null || true
  echo
  echo "===== GRAFANA ====="
  systemctl is-active grafana-server
  systemctl is-enabled grafana-server
} | tee \
  ~/laboratorio-grafana/evidencias/laboratorio-integrador/servicios.txt

Guardar los puertos¶

sudo ss -lntp \
  | grep -E ':(3000|9090|9100)' \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/puertos.txt

Guardar la configuración de Prometheus¶

sudo cp \
  /etc/prometheus/prometheus.yml \
  ~/laboratorio-grafana/evidencias/laboratorio-integrador/prometheus.yml

Guardar los objetivos¶

curl -s "$PROMETHEUS_URL/api/v1/targets" \
  | jq \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/targets.json

Guardar la consulta `up`¶

curl -sG "$PROMETHEUS_URL/api/v1/query" \
  --data-urlencode 'query=up' \
  | jq \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/query-up.json

Guardar la salud de Grafana¶

curl -s "$GRAFANA_URL/api/health" \
  | jq \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/grafana-health.json

Guardar una muestra de Node Exporter¶

curl -s "$NODE_EXPORTER_URL/metrics" \
  | head -n 100 \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/node-exporter-sample.txt

Guardar los registros¶

sudo journalctl -u prometheus \
  --since "30 minutes ago" \
  --no-pager \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/prometheus.log

Para una instalación manual de Node Exporter:

sudo journalctl -u node_exporter \
  --since "30 minutes ago" \
  --no-pager \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/node-exporter.log

Para una instalación mediante APT:

sudo journalctl -u prometheus-node-exporter \
  --since "30 minutes ago" \
  --no-pager \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/node-exporter.log

sudo journalctl -u grafana-server \
  --since "30 minutes ago" \
  --no-pager \
  > ~/laboratorio-grafana/evidencias/laboratorio-integrador/grafana.log

Script de comprobación final¶

El siguiente script detecta automáticamente si Node Exporter utiliza la unidad manual o la unidad instalada mediante APT.

Crear el script¶

cat > /tmp/comprobar-laboratorio.sh <<'EOF'
#!/usr/bin/env bash

set -u

echo "===== COMPROBACIÓN DEL LABORATORIO ====="
echo

check_service() {
  local service="$1"

  printf '%-35s ' "$service"

  if systemctl is-active --quiet "$service"; then
    echo "ACTIVO"
  else
    echo "NO ACTIVO"
  fi
}

check_http() {
  local name="$1"
  local url="$2"

  printf '%-35s ' "$name"

  if curl -fsS "$url" >/dev/null 2>&1; then
    echo "OK"
  else
    echo "ERROR"
  fi
}

check_service prometheus

if systemctl is-active --quiet node_exporter; then
  check_service node_exporter
else
  check_service prometheus-node-exporter
fi

check_service grafana-server

check_http "Prometheus saludable" \
  "http://localhost:9090/-/healthy"

check_http "Prometheus preparado" \
  "http://localhost:9090/-/ready"

check_http "Node Exporter /metrics" \
  "http://localhost:9100/metrics"

check_http "API de Grafana" \
  "http://localhost:3000/api/health"

printf '%-35s ' "Configuración Prometheus"

if promtool check config \
    /etc/prometheus/prometheus.yml \
    >/dev/null 2>&1; then
  echo "VÁLIDA"
else
  echo "INVÁLIDA"
fi

printf '%-35s ' "Consulta up"

if curl -fsS -G \
    http://localhost:9090/api/v1/query \
    --data-urlencode 'query=up' \
    | jq -e '.status == "success"' \
    >/dev/null 2>&1; then
  echo "OK"
else
  echo "ERROR"
fi

printf '%-35s ' "Target node_exporter"

if curl -fsS -G \
    http://localhost:9090/api/v1/query \
    --data-urlencode 'query=up{job="node_exporter"}' \
    | jq -e '
        .data.result
        | length > 0
        and .[0].value[1] == "1"
      ' \
    >/dev/null 2>&1; then
  echo "UP"
else
  echo "DOWN O SIN DATOS"
fi
EOF

Dar permisos de ejecución¶

chmod +x /tmp/comprobar-laboratorio.sh

Ejecutar el script¶

/tmp/comprobar-laboratorio.sh

Resultado esperado:

===== COMPROBACIÓN DEL LABORATORIO =====

prometheus                         ACTIVO
node_exporter                      ACTIVO
grafana-server                     ACTIVO
Prometheus saludable               OK
Prometheus preparado               OK
Node Exporter /metrics             OK
API de Grafana                     OK
Configuración Prometheus           VÁLIDA
Consulta up                        OK
Target node_exporter               UP

Ejemplo de sesión completa¶

$ systemctl is-active prometheus
active

$ systemctl is-active node_exporter
active

$ systemctl is-active grafana-server
active

$ curl http://localhost:9090/-/healthy
Prometheus is Healthy.

$ curl -I http://localhost:9100/metrics
HTTP/1.1 200 OK

$ curl -s http://localhost:3000/api/health \
    | jq -r '.database'
ok

$ promtool check config /etc/prometheus/prometheus.yml
Checking /etc/prometheus/prometheus.yml
 SUCCESS: configuration is valid

$ curl -s http://localhost:9090/api/v1/targets \
    | jq -r '
      .data.activeTargets[]
      | [.labels.job, .labels.instance, .health]
      | @tsv
    '
prometheus      localhost:9090  up
node_exporter   localhost:9100  up

$ curl -sG http://localhost:9090/api/v1/query \
    --data-urlencode 'query=up' \
    | jq -r '
      .data.result[]
      | [.metric.job, .metric.instance, .value[1]]
      | @tsv
    '
prometheus      localhost:9090  1
node_exporter   localhost:9100  1

En Grafana se crea una fuente de datos:

Name: Prometheus
URL: http://localhost:9090
Access: Server o Proxy
Default: Yes

Después se crea un dashboard con los paneles:

Estado de los objetivos
Uso de CPU
Uso de memoria
Uso del sistema de ficheros raíz
Carga del sistema
Tráfico recibido

Actividad integradora¶

Objetivo¶

Construir una plataforma funcional de monitorización con Prometheus, Node Exporter y Grafana.

Parte 1: servicios¶

Comprobar el estado de Prometheus.
Comprobar el estado de Node Exporter.
Comprobar el estado de Grafana.
Comprobar los puertos 3000, 9090 y 9100.

Parte 2: Node Exporter¶

Consultar /metrics.
Localizar métricas de CPU.
Localizar métricas de memoria.
Localizar métricas de disco.
Localizar métricas de red.

Parte 3: Prometheus¶

Configurar el job prometheus.
Configurar el job node_exporter.
Añadir etiquetas personalizadas.
Validar la configuración.
Reiniciar Prometheus.
Comprobar los objetivos.
Consultar la métrica up.

Parte 4: PromQL¶

Consultar el uso de CPU.
Consultar el uso de memoria.
Consultar el uso de /.
Consultar el tráfico recibido.
Consultar la carga del sistema.

Parte 5: Grafana¶

Añadir Prometheus como fuente de datos.
Probar la conexión.
Establecer la fuente como predeterminada.
Crear un dashboard.
Crear al menos cuatro paneles.
Configurar las unidades.
Guardar el dashboard.

Parte 6: diagnóstico¶

Detener Node Exporter.
Observar el estado DOWN.
Consultar el mensaje de error.
Iniciar Node Exporter.
Comprobar la recuperación.
Provocar temporalmente un error de conexión en Grafana.
Restaurar la configuración.
Documentar las comprobaciones.

Entregables¶

El alumno debe entregar:

Fichero prometheus.yml.
Evidencia de los servicios activos.
Evidencia del endpoint /metrics.
Evidencia de los objetivos en estado UP.
Resultado de la consulta up.
Consultas PromQL utilizadas.
Capturas del dashboard.
Resultado del diagnóstico de un target DOWN.
Informe de comprobación final.
Explicación breve de la arquitectura.

Estructura recomendada:

laboratorio-prometheus-grafana/
├── prometheus.yml
├── consultas-promql.txt
├── dashboard/
│   └── dashboard-exportado.json
├── evidencias/
│   ├── servicios.txt
│   ├── puertos.txt
│   ├── targets.json
│   ├── query-up.json
│   ├── grafana-health.json
│   ├── prometheus.log
│   ├── node-exporter.log
│   └── grafana.log
└── informe.md

Tabla de resultados¶

Comprobación	Resultado	Observaciones
Prometheus activo
Node Exporter activo
Grafana activo
Puerto `9090`
Puerto `9100`
Puerto `3000`
Endpoint `/metrics`
Configuración válida
Target Prometheus
Target Node Exporter
Consulta `up`
Consulta de CPU
Consulta de memoria
Consulta de almacenamiento
Fuente de datos creada
Conexión de Grafana
Dashboard creado
Prueba `DOWN` realizada
Recuperación verificada
Evidencias guardadas

Puntos clave¶

Node Exporter expone métricas del sistema operativo.
Prometheus recopila y almacena las métricas.
Grafana consulta Prometheus y representa los resultados.
PromQL es el lenguaje de consulta de Prometheus.
El endpoint de Node Exporter es normalmente /metrics.
Prometheus utiliza normalmente el puerto 9090.
Node Exporter utiliza normalmente el puerto 9100.
Grafana utiliza normalmente el puerto 3000.
La configuración de scraping se encuentra en prometheus.yml.
promtool check config permite validar la configuración.
La sección Targets muestra el estado del scraping.
La métrica up indica si el último scraping fue correcto.
Los contadores suelen requerir rate() para calcular velocidades.
Las métricas de CPU, memoria, disco y red pueden transformarse mediante PromQL.
Grafana necesita una fuente de datos configurada.
La URL de Prometheus debe ser accesible desde Grafana.
localhost depende del equipo o contenedor que realiza la conexión.
El modo de acceso Server o Proxy es adecuado para este laboratorio.
El inspector de Grafana ayuda a diagnosticar consultas.
Una buena documentación debe incluir configuración, evidencias y resultados.

Preguntas de comprobación¶

¿Qué función cumple Node Exporter?
¿Qué función cumple Prometheus?
¿Qué función cumple Grafana?
¿Qué componente inicia normalmente el scraping?
¿Qué endpoint expone Node Exporter?
¿Qué puerto utiliza normalmente Prometheus?
¿Qué puerto utiliza normalmente Node Exporter?
¿Qué puerto utiliza normalmente Grafana?
¿Qué función cumple prometheus.yml?
¿Qué comando permite validar la configuración de Prometheus?
¿Qué información muestra la sección Targets?
¿Qué significa up = 1?
¿Qué significa up = 0?
¿Por qué se utiliza rate() con node_cpu_seconds_total?
¿Cómo calcularías el porcentaje de memoria utilizado?
¿Cómo calcularías el uso del sistema de ficheros raíz?
¿Cómo excluirías la interfaz lo?
¿Qué es una fuente de datos en Grafana?
¿Qué URL utilizarías si Grafana y Prometheus están en el mismo servidor?
¿Qué problema puede producirse al utilizar localhost en contenedores?
¿Qué diferencia existe entre un error de conexión y una consulta sin resultados?
¿Cómo comprobarías que Grafana puede consultar Prometheus?
¿Qué pasos seguirías si Node Exporter aparece como DOWN?
¿Qué pasos seguirías para comprobar la recuperación de un objetivo?
¿Qué evidencias incluirías en el informe final?

Criterios de evaluación¶

Criterio	Puntuación
Comprobación inicial de los servicios	1 punto
Verificación de Node Exporter	1 punto
Configuración correcta del scraping	2 puntos
Validación y diagnóstico en Prometheus	1 punto
Consultas PromQL	2 puntos
Configuración de Grafana	1 punto
Creación del dashboard	1 punto
Documentación y evidencias	1 punto
Total	10 puntos

El laboratorio se considera superado cuando¶

Los tres servicios están activos.
Node Exporter responde en /metrics.
Prometheus consulta correctamente Node Exporter.
Los objetivos aparecen como UP.
La consulta up devuelve valores correctos.
Se han ejecutado consultas de CPU, memoria, almacenamiento y red.
Grafana tiene configurada la fuente de datos Prometheus.
El dashboard muestra datos.
Se ha realizado una prueba de caída y recuperación.
Las evidencias son reproducibles y están documentadas.

Comprobación final¶

Ejecutar:

/tmp/comprobar-laboratorio.sh

Resultado esperado:

===== COMPROBACIÓN DEL LABORATORIO =====

prometheus                         ACTIVO
node_exporter                      ACTIVO
grafana-server                     ACTIVO
Prometheus saludable               OK
Prometheus preparado               OK
Node Exporter /metrics             OK
API de Grafana                     OK
Configuración Prometheus           VÁLIDA
Consulta up                        OK
Target node_exporter               UP

El flujo completo del laboratorio es:

Instalar Node Exporter
        |
        v
Exponer /metrics
        |
        v
Configurar scraping en Prometheus
        |
        v
Validar targets y métrica up
        |
        v
Ejecutar consultas PromQL
        |
        v
Añadir Prometheus en Grafana
        |
        v
Crear paneles
        |
        v
Probar errores y recuperación
        |
        v
Guardar evidencias

Laboratorio: Prometheus, Node Exporter y Grafana¶

Objetivos¶

Arquitectura y componentes¶

Introducción¶

Prometheus¶

Node Exporter¶

Grafana¶

Flujo de trabajo¶

Arquitectura del laboratorio¶

Puertos utilizados¶

Requisitos previos¶

Comprobar la distribución¶

Comprobar la arquitectura¶

Comprobar la memoria¶

Comprobar el espacio disponible¶

Comprobar la hora¶

Comprobar los puertos¶

Variables utilizadas¶

Comprobación inicial de los servicios¶

Comprobar Prometheus¶

Comprobar Node Exporter¶

Comprobar Grafana¶

Sesión 1: comprobar la instalación¶

Objetivo¶

Comprobar los servicios¶

Consultar las versiones¶

Consultar los puertos¶

Actividades¶

Sesión 2: comprobar Node Exporter¶

Objetivo¶

Consultar las primeras líneas¶

Buscar métricas de CPU¶

Buscar métricas de memoria¶

Buscar métricas de almacenamiento¶

Buscar métricas de red¶

Actividades¶

Sesión 3: configurar el scraping¶

Objetivo¶

Crear una copia de seguridad¶

Crear la configuración¶

Validar la configuración¶

Reiniciar Prometheus¶

Sesión 4: comprobar los objetivos¶

Objetivo¶

Comprobar desde la interfaz web¶

Comprobar mediante la API¶

Actividades¶

Sesión 5: consultar la métrica up¶

Objetivo¶

Consultar todos los objetivos¶

Consultar únicamente Node Exporter¶

Consultar los objetivos caídos¶

Contar los objetivos¶

Contar los objetivos disponibles¶

Calcular el porcentaje de disponibilidad¶

Consultar mediante la API¶

Sesión 6: practicar consultas PromQL¶

Objetivo¶

Métricas de Prometheus¶

Métricas de memoria¶

Métricas de carga¶

Métricas de red¶

Actividades¶

Sesión 7: calcular el uso de CPU¶

Objetivo¶

Consultar el contador de CPU¶

Filtrar el modo inactivo¶

Calcular la velocidad de cambio¶

Calcular la media por instancia¶

Calcular el porcentaje de CPU utilizado¶

Generar carga temporal¶

Actividades¶

Sesión 8: calcular el uso de memoria¶

Objetivo¶

Memoria total¶

Memoria disponible¶

Memoria utilizada en bytes¶

Porcentaje disponible¶

Porcentaje utilizado¶

Comparar con el sistema operativo¶

Sesión 5: consultar la métrica `up`¶

Sesión 13: probar un objetivo en estado `DOWN`¶

El target aparece como `DOWN`¶

Guardar la consulta `up`¶