← volver

Prometheus con Thanos: query remoto y alta disponibilidad multi-cluster

Por · · [Admin-Sistemas] · lectura estimada: ~5 min

El problema: Prometheus no escala horizontalmente

Prometheus es el estándar de facto para monitorización en Kubernetes, pero tiene una limitación arquitectónica fundamental: es un sistema de una sola instancia. Cada servidor Prometheus almacena sus métricas localmente y no existe replicación nativa. Si el nodo cae, pierdes visibilidad. Si tienes diez clústeres, debes consultar diez dashboards. Y la retención local (típicamente 15 días) es insuficiente para análisis de tendencias o auditorías.

Thanos resuelve esto proporcionando una capa de alta disponibilidad y consulta global sobre Prometheus, sin modificar tu configuración actual. Su arquitectura se basa en componentes que se conectan a los Prometheus existentes y exponen una API unificada. En este artículo exploraremos los componentes críticos y los comandos reales para implementar una solución multi-cluster funcional.

Arquitectura de Thanos: componentes esenciales

Thanos no reemplaza a Prometheus; lo extiende. Los componentes principales son:

  • Sidecar: se ejecuta como contenedor junto a Prometheus. Sube bloques de datos a un almacenamiento de objetos (S3, GCS) y expone la API de Prometheus para consultas remotas.
  • Query: el "front-end" que recibe PromQL, la reenvía a múltiples Sidecars/Stores y combina los resultados de forma transparente.
  • Store: lee datos históricos desde el bucket de objetos y los sirve a Query.
  • Compactor: aplica deduplicación y downsampling a los bloques del bucket.
  • Ruler: evaluación de alertas con HA (opcional pero recomendado).

Para alta disponibilidad, ejecutas al menos dos réplicas de Prometheus con el mismo conjunto de targets, cada una con su Sidecar. Thanos Query deduplica las series usando una etiqueta de réplica (por ejemplo, replica="A" y replica="B").

Configuración del Sidecar: exponer datos al Query

El Sidecar se anexa al deployment de Prometheus. Ejemplo de fragmento de manifiesto Kubernetes:

containers:
- name: prometheus
  image: prom/prometheus:v2.53.0
  args:
    - --storage.tsdb.retention.time=2h
    - --storage.tsdb.min-block-duration=2h
    - --storage.tsdb.max-block-duration=2h
- name: thanos
  image: quay.io/thanos/thanos:v0.35.0
  args:
    - sidecar
    - --tsdb.path=/prometheus
    - --objstore.config-file=/etc/thanos/bucket.yaml
    - --http-address=0.0.0.0:10902
    - --grpc-address=0.0.0.0:10901
    - --prometheus.url=http://localhost:9090
    - --reloader.config-file=/etc/prometheus/prometheus.yml
  volumeMounts:
    - name: data
      mountPath: /prometheus
    - name: config
      mountPath: /etc/thanos

Nota: fija --storage.tsdb.min-block-duration y --storage.tsdb.max-block-duration a 2h. Esto fuerza que Prometheus escriba bloques de 2 horas, que el Sidecar sube inmediatamente al bucket. Sin este ajuste, los bloques de 2h se compactan a 2h y el Sidecar espera más tiempo.

El archivo bucket.yaml define el almacenamiento. Para GCS:

type: GCS
config:
  bucket: "my-metrics-bucket"
  service_account: /etc/thanos/credentials.json

Thanos Query: consultas globales con deduplicación

El Query es el punto de entrada para Grafana o la CLI. Debe conocer las direcciones de los Sidecars y Stores. Lo configuramos con --store estático o usando el Service Discovery de Kubernetes.

thanos query \
  --http-address=0.0.0.0:19192 \
  --grpc-address=0.0.0.0:10901 \
  --store=dnssrv+_grpc._tcp.thanos-sidecar.monitoring.svc.cluster.local \
  --store=dnssrv+_grpc._tcp.thanos-store.monitoring.svc.cluster.local \
  --query.replica-label=replica \
  --query.auto-downsampling

Explicación de flags clave:

  • --query.replica-label: indica qué etiqueta distingue réplicas. Query la eliminará al deduplicar.
  • --query.auto-downsampling: permite devolver datos de resolución 5m o 1h en lugar de crudos si la consulta lo requiere.
  • --store: acepta múltiples; para descubrimiento dinámico se usa el formato dnssrv+.

Prueba inmediata desde la máquina del Query:

curl -g 'http://localhost:19192/api/v1/query?query=up{cluster="prod"}'

Este endpoint devuelve el resultado combinado de todos los clústeres, con deduplicación según la etiqueta replica. Si usas Grafana, añade la URL http://thanos-query:19192 como fuente de datos Prometheus.

Thanos Store: consulta de datos históricos

El Store lee bloques del bucket y los sirve al Query. No necesita conexión directa con Prometheus. Un ejemplo de despliegue:

thanos store \
  --data-dir=/var/thanos/store \
  --objstore.config-file=/etc/thanos/bucket.yaml \
  --http-address=0.0.0.0:10902 \
  --grpc-address=0.0.0.0:10901

El Store mantiene un índice en --data-dir de todos los bloques del bucket. No descarga datos completos; solo metadatos y bloqueos. Cuando Query le pide series, el Store lee los bloques relevantes y los transmite por gRPC.

Un detalle importante: el Store no hace deduplicación. Eso es responsabilidad del Query. Por eso el Sidecar sube bloques idénticos de ambas réplicas (A y B). El Query, al recibir las mismas series con diferente valor en replica, elige una arbitrariamente basada en el hash.

Compactor: retención y downsampling

Sin Compactor, tu bucket crecería indefinidamente. El Compactor aplica las reglas de retención y reduce la resolución de datos antiguos:

thanos compact \
  --data-dir=/var/thanos/compact \
  --objstore.config-file=/etc/thanos/bucket.yaml \
  --retention.resolution-raw=30d \
  --retention.resolution-5m=180d \
  --retention.resolution-1h=2y \
  --http-address=0.0.0.0:10902

Esto mantiene datos crudos durante 30 días, downsampling a 5 minutos durante 6 meses y a 1 hora durante 2 años. El Compactor también maneja la deduplicación de bloques, fusionando los bloques de réplicas (A y B) en uno solo, reduciendo el almacenamiento a la mitad.

Importante: solo debe existir una única instancia de Compactor por bucket, ya que usa bloqueos distribuidos. Si lo escalas, asegúrate de que el bucket soporte bloqueos (GCS y S3 lo hacen).

Alta disponibilidad real: tolerancia a fallos del Query

El Query en sí es stateless; puedes escalarlo horizontalmente detrás de un Service. Para que Grafana siempre tenga un endpoint disponible, despliega un Service de tipo ClusterIP y un Ingress con balanceo. Pero hay una trampa: el Query necesita conocer todos los Store y Sidecar. Si uno de ellos está caído, el Query debe seguir funcionando.

Thanos Query tiene lógica de staleness: si un Store no responde en 5 segundos, lo marca como no disponible y continúa consultando los demás. Puedes ajustar con --store.response-timeout=5s y --store.unhealthy-timeout=5m.

Para probar la HA, simula una caída de un Sidecar:

kubectl scale deployment prometheus-prod-a --replicas=0
# Después de 1 minuto, consulta:
curl -g 'http://thanos-query:19192/api/v1/query?query=up{cluster="prod"}'

Verás que la respuesta sigue llegando, usando los datos del Sidecar B y del Store (si la retención local de 2h pasó). La deduplicación elimina las series huérfanas.

Integración con Ruler y alertas

Para alertas globales (por ejemplo, reglas que requieren datos de varios clústeres), usa Thanos Ruler. Se conecta a Query para evaluar PromQL

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal