Alertas de Prometheus

Introducción

La monitorización efectiva no se trata solo de recopilar métricas; se trata de ser notificado cuando algo sale mal. Prometheus tiene un potente sistema de alertas integrado que te permite definir condiciones de alerta utilizando el mismo lenguaje de consulta PromQL que usas para graficar. Cuando se cumple la condición de una alerta, esta entra en un estado de "activación" (firing).

En este laboratorio, aprenderás los fundamentos de las alertas de Prometheus. Comenzarás con un entorno preconfigurado que ejecuta Prometheus y un Node Exporter. Tu tarea será crear un archivo de reglas de alerta separado, definir una regla para detectar un alto uso de CPU, configurar Prometheus para cargar este archivo y, finalmente, simular una alta carga de CPU para observar cómo se activa tu alerta en la interfaz de usuario de Prometheus.

Comprender el Entorno de Alertas

En este paso, te familiarizarás con el entorno del laboratorio. El script de configuración ya ha iniciado dos contenedores Docker para ti: uno para Prometheus y otro para Node Exporter.

Primero, verifiquemos que ambos contenedores se están ejecutando. Abre una terminal y ejecuta el comando docker ps:

docker ps

Deberías ver una salida similar a la siguiente, mostrando los contenedores prometheus y node-exporter en estado "Up" (En ejecución).

CONTAINER ID   IMAGE                           COMMAND                  CREATED          STATUS          PORTS                                       NAMES
...            prom/prometheus                 "/bin/prometheus --c…"   15 seconds ago   Up 14 seconds   0.0.0.0:9090->9090/tcp, :::9090->9090/tcp   prometheus
...            prom/node-exporter               "/bin/node_exporter …"   16 seconds ago   Up 15 seconds   0.0.0.0:9100->9100/tcp, :::9100->9100/tcp   node-exporter

El contenedor node-exporter expone métricas sobre el sistema anfitrión (nuestra VM de laboratorio), y el contenedor prometheus está configurado para hacer scrape (recopilar) esas métricas.

Ahora, revisemos la interfaz de usuario (UI) de Prometheus. Para acceder a ella:

1. En la interfaz de LabEx, haz clic en el botón + (Nueva Pestaña) en la barra de navegación superior.
2. Elige Web Service del menú desplegable.
3. Introduce 9090 como número de puerto.
4. Haz clic en Open para lanzar la interfaz web de Prometheus.

Cuando se abra la nueva pestaña, deberías ver la página de inicio del Navegador de Expresiones (Expression Browser) de Prometheus. Navega a Status -> Targets desde el menú de navegación superior. Deberías ver que el trabajo (job) node_exporter tiene un estado verde "UP", lo que confirma que Prometheus está recopilando datos de él con éxito. Esta conexión es la base para nuestra regla de alerta.

Crear alert-rules.yml para la Alerta de CPU Alta

En este paso, crearás un archivo dedicado para tus reglas de alerta. Es una buena práctica mantener las reglas separadas de la configuración principal de Prometheus para una mejor organización.

Crearemos un archivo llamado alert-rules.yml dentro de tu directorio de proyecto. Utiliza el editor nano para crear y editar el archivo:

nano ~/project/alert-rules.yml

Ahora, copia y pega el siguiente contenido YAML en el editor nano. Esto define un grupo de reglas que contiene una única alerta que se activa cuando el uso de la CPU es alto.

groups:
  - name: node_alerts
    rules:
      - alert: HighCpuLoad
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[1m])) * 100) > 10
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "High CPU load on {{ $labels.instance }}"
          description: "CPU load is > 10% (current value: {{ $value }}%)"

Analicemos esta regla:

• groups: Las reglas se organizan en grupos. Todas las reglas dentro de un grupo se evalúan secuencialmente.
• alert: El nombre de nuestra alerta, HighCpuLoad.
• expr: La expresión PromQL que se evalúa. Si devuelve un valor, la alerta se activa. Aquí, calculamos el porcentaje de tiempo de CPU no inactivo (non-idle) durante el último minuto. Si es mayor que 10%, se cumple la condición.
• for: Esta cláusula especifica que la condición debe ser verdadera durante una duración continua (1 minuto) antes de que la alerta pase al estado "Firing" (Activada). Esto evita que las alertas se disparen por picos breves.
• annotations: Estas añaden información legible por humanos a la alerta. summary y description son anotaciones estándar. Puedes usar variables de plantilla como {{ $labels.instance }} y {{ $value }} para incluir datos dinámicos en tus mensajes de alerta.

Después de pegar el contenido, guarda el archivo y sal de nano presionando Ctrl+X, luego Y, y finalmente Enter.

Ejecutar el Contenedor de Prometheus con el Archivo de Reglas Montado

En este paso, indicarás a Prometheus que cargue tu nuevo archivo de reglas y reiniciarás el contenedor con la configuración actualizada.

Primero, debes editar el archivo de configuración principal, prometheus.yml, para incluir una referencia a tu archivo de reglas. Ábrelo con nano:

nano ~/project/prometheus.yml

Añade la directiva rule_files bajo la sección global. El archivo debería verse así después de tus cambios:

global:
  scrape_interval: 15s
  rule_files:
    - "alert-rules.yml"

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["prometheus:9090"]
  - job_name: "node_exporter"
    static_configs:
      - targets: ["node-exporter:9100"]

Guarda el archivo y sal de nano (Ctrl+X, Y, Enter).

Ahora que la configuración está actualizada, debes reiniciar el contenedor de Prometheus para aplicar los cambios. Primero, detén y elimina el contenedor antiguo:

docker stop prometheus

docker rm prometheus

Finalmente, ejecuta un nuevo contenedor de Prometheus. Este comando es similar al del script de configuración, pero incluye una segunda bandera -v para montar tu archivo alert-rules.yml dentro del contenedor.

docker run -d --name prometheus -p 9090:9090 \
  --network monitoring \
  -v /home/labex/project/prometheus.yml:/etc/prometheus/prometheus.yml \
  -v /home/labex/project/alert-rules.yml:/etc/prometheus/alert-rules.yml \
  prom/prometheus

Este comando asegura que tanto la configuración principal como las reglas de alerta estén disponibles dentro del contenedor de Prometheus.

Verificar las Reglas de Alerta Cargadas en la Interfaz de Usuario (UI) de Prometheus

En este paso, confirmarás que Prometheus ha cargado exitosamente tu nueva regla de alerta.

Vuelve a la pestaña de la Interfaz de Usuario (UI) de Prometheus en tu navegador (o abre una nueva pestaña de Servicio Web en el puerto 9090 si es necesario). Si la página no carga, espera unos segundos a que el nuevo contenedor se inicie y luego actualiza la página.

En la barra de navegación superior, haz clic en el elemento del menú Alerts (Alertas).

Ahora deberías ver tu alerta HighCpuLoad listada. La alerta estará en la sección Inactive (Inactiva), indicada por un fondo verde. Este es el estado esperado porque la carga de CPU en el sistema es actualmente baja, por lo que la expresión (expr) de la alerta se evalúa como falsa.

Es importante entender los tres estados de una alerta:

• Inactive (Verde): La condición de la alerta es falsa.
• Pending (Amarillo): La condición de la alerta se ha vuelto verdadera, pero la duración especificada en for aún no ha transcurrido. Prometheus está esperando a ver si la condición persiste.
• Firing (Rojo): La condición de la alerta ha sido verdadera durante toda la duración especificada en for. En una configuración de producción, este es el momento en que Prometheus enviaría la alerta a un Alertmanager.

Tu alerta está actualmente inactiva, lo cual es correcto. En el siguiente paso, haremos que se active (pase a estado Firing).

Simular Carga para Probar el Disparo de la Alerta

En este paso final, aumentarás intencionalmente la carga de CPU en el sistema para probar si tu alerta se dispara correctamente.

Podemos generar carga de CPU usando un bucle simple e infinito en la shell. En tu terminal, ejecuta el siguiente comando. El & al final ejecutará el proceso en segundo plano, permitiéndote seguir usando tu terminal.

while true; do true; done &

Este comando inicia un proceso que consume el 100% de un núcleo de CPU. Ahora, cambia rápidamente a la página Alerts (Alertas) en la UI de Prometheus (accesible a través de la pestaña Web Service en el puerto 9090).

Observarás que el estado de la alerta HighCpuLoad cambia:

1. En unos 15 a 30 segundos, la expresión de la alerta se volverá verdadera. La alerta se moverá a la sección Pending (Pendiente) y se pondrá amarilla. Esto significa que Prometheus ha detectado la alta carga de CPU pero está esperando el tiempo de 1m especificado en la cláusula for.
2. Después de estar en estado Pendiente durante un minuto, la alerta se moverá a la sección Firing (Activa/Disparada) y se pondrá roja. ¡Esto confirma que tu regla de alerta funciona como se espera! Puedes expandir la alerta para ver las anotaciones que definiste, completas con el valor actual.

Una vez que hayas visto que la alerta se dispara, puedes detener la generación de carga. Vuelve a tu terminal y ejecuta el siguiente comando para terminar el proceso del bucle en segundo plano:

Importante: Para ahorrar recursos del servidor VM de LabEx, asegúrate de ejecutar el siguiente comando para detener la generación de carga.

kill $!

Después de detener la carga, observa nuevamente la UI de Prometheus. La alerta pronto volverá al estado Inactive (verde), completando el ciclo de prueba.

Resumen

¡Felicidades! Has configurado y probado exitosamente una alerta de Prometheus.

En este laboratorio, aprendiste a:

• Estructurar las reglas de alerta en un archivo YAML separado.
• Escribir una expresión PromQL para definir una condición de alerta para el uso elevado de CPU.
• Usar anotaciones (annotations) para crear mensajes de alerta significativos y legibles por humanos.
• Configurar Prometheus para cargar tus archivos de reglas y reiniciarlo para aplicar los cambios.
• Observar el ciclo de vida de una alerta en la UI de Prometheus, desde Inactiva hasta Pendiente y Activa (Firing).
• Simular una condición para activar y probar tu alerta.

Esta es la primera mitad del panorama de las alertas. El siguiente paso lógico, que está fuera del alcance de este laboratorio, sería configurar una instancia de Alertmanager. Prometheus enviaría sus alertas activas al Alertmanager, el cual sería entonces responsable de deducir, agrupar y enrutarlas a canales de notificación reales como correo electrónico, Slack o PagerDuty.