Alertas de Prometheus

Introducción

Un monitoreo efectivo no se trata solo de recopilar métricas; se trata de recibir notificaciones cuando algo sale mal. Prometheus cuenta con un potente sistema de alertas integrado que te permite definir condiciones de alerta utilizando el mismo lenguaje de consulta PromQL que empleas para generar gráficos. Cuando se cumple la condición de una alerta, esta entra en estado "firing" (disparada).

En este laboratorio, aprenderás los fundamentos de las alertas en Prometheus. Comenzarás con un entorno preconfigurado que ejecuta Prometheus y un Node Exporter. Tu tarea consistirá en crear un archivo de reglas de alerta independiente, definir una regla para detectar un uso elevado de CPU, configurar Prometheus para cargar este archivo y, finalmente, simular una carga alta de CPU para observar cómo se activa la 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 estén en ejecución. Abre una terminal y ejecuta el comando docker ps:

docker ps

Deberías ver una salida similar a la siguiente, que muestra los contenedores prometheus y node-exporter con un estado "Up".

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 host (nuestra máquina virtual de laboratorio), y el contenedor prometheus está configurado para recopilar (scrape) dichas métricas.

Ahora, revisemos la interfaz de usuario 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. Selecciona Web Service en el menú desplegable.
3. Ingresa 9090 como número de puerto.
4. Haz clic en Open para iniciar la interfaz web de Prometheus.

Cuando se abra la nueva pestaña, verás la página de inicio del explorador de expresiones de Prometheus. Navega a Status -> Targets desde el menú de navegación superior. Deberías ver que el job node_exporter tiene un estado "UP" en color verde, lo que confirma que Prometheus está recopilando datos correctamente. Esta conexión es la base para nuestra regla de alerta.

Crear alert-rules.yml para la alerta de alta CPU

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. Usa 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 CPU es elevado.

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 durante el último minuto. Si es mayor al 10%, se cumple la condición.
• for: Esta cláusula especifica que la condición debe ser verdadera durante un periodo continuo (1 minuto) antes de que la alerta pase a estado "Firing". Esto evita que las alertas se disparen por picos breves.
• annotations: Añaden información legible para 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, le 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 en el nivel superior del archivo, no dentro del bloque 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 que las reglas de alerta se cargaron en la interfaz de Prometheus

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

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

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

Ahora deberías ver tu alerta HighCpuLoad listada. La alerta estará en la sección Inactive, indicada por un fondo verde. Este es el estado esperado, ya que la carga de CPU en el sistema es actualmente baja, por lo que la expresión de la alerta (expr) 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 for aún no ha transcurrido. Prometheus está esperando para ver si la condición persiste.
• Firing (Rojo): La condición de la alerta ha sido verdadera durante toda la duración for. En un entorno 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 dispare.

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 activa correctamente.

Podemos generar carga de CPU usando un bucle simple e infinito en la shell. En tu terminal, ejecuta el siguiente comando. El símbolo & al final ejecutará el proceso en segundo plano, para que puedas 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 en la interfaz de Prometheus (accesible a través de la pestaña Web Service en el puerto 9090).

Observarás cómo cambia el estado de la alerta HighCpuLoad:

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

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

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

kill $!

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

Resumen

¡Felicidades! Has configurado y probado con éxito una alerta de Prometheus.

En este laboratorio, aprendiste a:

• Estructurar reglas de alerta en un archivo YAML independiente.
• Escribir una expresión PromQL para definir una condición de alerta por uso elevado de CPU.
• Usar anotaciones para crear mensajes de alerta significativos y legibles para 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 interfaz de Prometheus, desde Inactive hasta Pending y 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 queda fuera del alcance de este laboratorio, sería configurar una instancia de Alertmanager. Prometheus enviaría sus alertas disparadas al Alertmanager, el cual se encargaría de desduplicar, agrupar y enrutar las alertas a canales de notificación reales como correo electrónico, Slack o PagerDuty.