Prometheus HA con Thanos Receive y Alertmanager en clúster
Introducción: el problema de la alta disponibilidad en Prometheus
Prometheus es el estándar de facto para métricas en Kubernetes y entornos cloud-native. Sin embargo, su diseño original asume que cada instancia es efímera y su almacenamiento local no es confiable a largo plazo. Cuando necesitamos garantías de alta disponibilidad (HA), surgen dos problemas inmediatos: el failover (si una instancia muere, otra debe tomar el relevo sin pérdida de datos) y la deduplicación de alertas (si tenemos dos Prometheus idénticos, ambos dispararán la misma alerta, saturando al operador).
La solución clásica es ejecutar dos réplicas de Prometheus con la misma configuración de scrape, y luego usar Thanos Receive como capa de agregación centralizada. Para las alertas, Alertmanager en modo clúster con mesh gossip permite deduplicar notificaciones. En este artículo, exploraremos una arquitectura de producción real, con comandos concretos y explicaciones profundas, pero sin convertirlo en un tutorial paso a paso: nos enfocaremos en por qué y cómo funciona cada pieza.
Arquitectura de referencia: dos Prometheus, un Thanos Receive, tres Alertmanagers
La topología recomendada es la siguiente:
- 2 instancias de Prometheus (por ejemplo,
prometheus-0yprometheus-1) con la misma configuración de scrape y reglas de alerta. - 1 clúster de Thanos Receive (puede ser 1 nodo activo + 1 nodo standby, o un StatefulSet de 3 réplicas) que recibe el remote write de ambos Prometheus.
- 3 réplicas de Alertmanager en modo clúster, conectadas entre sí mediante gossip (protocolo en el puerto 9094).
- Thanos Query para consultar las métricas agregadas, y opcionalmente Thanos Store para almacenamiento a largo plazo en S3 o GCS.
La clave está en que los dos Prometheus escriben al mismo receive, pero cada uno conserva su TSDB local para consultas rápidas. Si uno falla, el otro sigue alimentando el sistema, y Alertmanager deduplica las alertas entrantes.
Configuración de Prometheus para HA: remote write y etiquetas de réplica
Para que Thanos Receive pueda deduplicar correctamente, cada Prometheus debe añadir una etiqueta única, típicamente replica, al momento del remote write. Esto se logra con la acción hashmod en relabel_configs. Veamos un fragmento de prometheus.yml:
remote_write:
- url: http://thanos-receive:19291/api/v1/receive
queue_config:
max_samples_per_send: 1000
capacity: 10000
write_relabel_configs:
- source_labels: [__address__]
modulus: 2
target_label: __tmp_hash
action: hashmod
- source_labels: [__tmp_hash]
regex: "0"
target_label: replica
replacement: "prometheus-0"
- source_labels: [__tmp_hash]
regex: "1"
target_label: replica
replacement: "prometheus-1"
En este ejemplo, prometheus-0 solo enviará muestras con replica="prometheus-0", y el otro con su propio valor. Thanos Receive usa esta etiqueta para deduplicar: si recibe la misma serie con el mismo timestamp y valor de ambas réplicas, conserva solo una. Si una réplica cae, la otra sigue cubriendo el hueco.
Es fundamental que las reglas de alerta (archivo rules.yml) sean idénticas en ambas instancias. No uses external_labels diferentes, porque alterarían la identidad de las series. En su lugar, define external_labels solo con el cluster al que pertenecen, por ejemplo cluster: "prod".
Thanos Receive: el corazón de la ingesta distribuida
Thanos Receive implementa el API de remote write de Prometheus y lo convierte en escrituras a su TSDB local. A diferencia de un Thanos Sidecar, que requiere que Prometheus esté vivo, Receive es un proceso independiente que acepta escrituras de cualquier origen. Para HA, lo ejecutamos como un StatefulSet en Kubernetes con un volumen persistente. La comunicación entre Receive y Query se realiza mediante el protocolo gRPC en el puerto 10901.
Un detalle no trivial: el hashring. Thanos Receive puede dividir series entre nodos mediante un anillo hash. Para HA estricta, puedes configurar un hashring con replicación en dos nodos, de modo que si uno muere, el otro mantiene los datos. Ejemplo de hashrings.json:
[
{
"hashring": "default",
"endpoints": [
"thanos-receive-0:10901",
"thanos-receive-1:10901"
],
"tenants": []
}
]
Con este archivo, las series se distribuyen entre los dos Receive, y cada uno replica las del otro vía --receive.replication-factor=2. Esto añade complejidad operativa, pero para la mayoría de casos un solo Receive con almacenamiento en disco confiable es suficiente, dado que Prometheus local ya es una copia de respaldo.
Alertmanager en clúster: deduplicación y failover de notificaciones
El componente más delicado es Alertmanager. Si tenemos dos Prometheus que evalúan las mismas reglas, ambos enviarán alertas al Alertmanager. Sin deduplicación, recibirías el doble de emails, páginas en PagerDuty o mensajes en Slack. La solución es ejecutar un clúster de Alertmanager donde cada nodo conozca a los demás, y donde las alertas se propaguen y dedupliquen automáticamente.
Para iniciar el clúster, se usa la bandera --cluster.listen-address y se le pasan las direcciones de los peers con --cluster.peer. Ejemplo de comando para el primer nodo:
alertmanager --config.file=/etc/alertmanager/alertmanager.yml \
--cluster.listen-address=0.0.0.0:9094 \
--cluster.peer=alertmanager-0:9094 \
--cluster.peer=alertmanager-1:9094 \
--cluster.peer=alertmanager-2:9094 \
--storage.path=/data
Los tres nodos forman un mesh. Cuando una alerta llega a cualquier nodo, se propaga a los demás. La deduplicación se hace mediante un fingerprint de la alerta (nombre, etiquetas, anotaciones y tiempo de inicio). Si dos Prometheus disparan la misma alerta con el mismo fingerprint, Alertmanager solo envía una notificación. Esto funciona incluso si los Prometheus tienen diferentes external_labels; en ese caso, la alerta tendrá etiquetas distintas y no se deduplicará. Por eso es crítico que ambos Prometheus usen exactamente las mismas etiquetas, excepto la de réplica que se añade en remote write (y que no se incluye en las alertas, porque las reglas se aplican antes del relabeling).
Para el failover en Alertmanager, el clúster también sincroniza el estado de las alertas silenciadas y los inhibidores. Si un nodo muere, los otros dos continúan funcionando. Se recomienda al menos 3 nodos para evitar la división de cerebro; con 2, el quórum puede perder una mayoría. La regla es: nodos >= 3 y nodos impares.
Failover real: qué pasa cuando muere un Prometheus
Imaginemos que prometheus-0 se cae por un OOM o un desalojo de pod. El tráfico de scrape lo seguía haciendo prometheus-1, que sigue enviando datos a Thanos Receive. Thanos Query ahora devuelve métricas con la etiqueta replica="prometheus-1" (y las agregadas con replica="" tras la deduplicación). Las alertas que dependían de datos de prometheus-0 dejan de llegar, pero como prometheus-1 sigue evaluando las mismas reglas, las alertas se siguen generando y son enviadas al clúster de Alertmanager. La deduplicación funciona porque el fingerprint se calcula sobre el nombre de la alerta y las etiquetas de la regla, no sobre el valor de replica (que no está presente en las alertas).
Si prometheus-1 también fallara, entonces no habría alertas, pero eso ya es un escenario de desastre múltiple. Para mitigarlo, algunos equipos ejecutan un tercer Prometheus "canario" que solo scrapea objetivos críticos, o usan Thanos Ruler (que vemos a continuación).
Thanos Ruler: alertas centralizadas sin dependencia de Prometheus local
Una alternativa avanzada es usar Thanos Ruler en lugar de reglas en Prometheus. Thanos R
comentarios(0)
$ dejar comentario