Prometheus scale-out: sharding hashmod y service discovery dinámico
El problema del crecimiento: cuando un solo Prometheus no basta
Prometheus es, sin discusión, el estándar de facto para métricas en entornos Kubernetes y microservicios. Su modelo de extracción (pull) y su almacenamiento local basado en TSDB (Time Series Database) ofrecen una experiencia sencilla y potente. Sin embargo, esta simplicidad tiene un límite: el almacenamiento y la consulta viven en el mismo proceso. Cuando el número de series temporales crece (miles de contenedores, múltiples clústeres, exportadores de nodos, etc.), el rendimiento de las consultas se degrada y el disco se llena más rápido de lo que puedes rotar datos.
La solución clásica es el scale-up: más CPU, más RAM, discos más rápidos. Pero hay un techo físico y económico. La alternativa es el scale-out, es decir, repartir la carga entre varios Prometheus. Este artículo no es un tutorial paso a paso, sino una explicación técnica profunda de las dos piezas clave para lograrlo: sharding con hashmod y service discovery dinámico (SD). Al final, tendrás el mapa mental para implementar tu propia arquitectura distribuida.
Sharding con hashmod: repartir la carga de forma determinista
El sharding en Prometheus se refiere a dividir el conjunto de targets (objetivos de scraping) entre múltiples instancias. La forma más común y robusta de hacerlo es mediante la función hashmod en la configuración de relabel_configs. La idea es simple: se toma un identificador único de cada target (por ejemplo, la dirección IP o el nombre de host), se aplica una función hash (SHA-256 por defecto) y se calcula el módulo con el número total de shards. El resultado es un número entre 0 y N-1, que indica qué Prometheus debe scrapear ese target.
Veamos un ejemplo concreto. Supongamos que tienes 2 Prometheus (shard 0 y shard 1). En cada uno, añades el siguiente bloque en prometheus.yml:
scrape_configs:
- job_name: 'node_exporter'
static_configs:
- targets: ['node1:9100', 'node2:9100', 'node3:9100', 'node4:9100']
relabel_configs:
- source_labels: [__address__]
target_label: __tmp_hash
modulus: 2
action: hashmod
- source_labels: [__tmp_hash]
regex: '^0$'
action: keep
En el Prometheus que quieres que sea el shard 0, la regex es '^0$'; en el shard 1, será '^1$'. La clave está en modulus: 2, que indica el número total de shards. El __address__ se usa como fuente, pero podrías usar __meta_kubernetes_pod_name o cualquier otra etiqueta única.
Ventajas del hashmod:
- Determinismo: Un target siempre irá al mismo shard mientras no cambie el número total de shards. Esto es vital para la consistencia de alertas y el almacenamiento a largo plazo.
- Balanceo uniforme: La función hash distribuye los targets de manera casi uniforme, evitando cuellos de botella en un shard concreto.
- Sencillez: No requiere coordinación entre instancias; cada una decide de forma autónoma qué targets scrapear.
Pero hay un inconveniente: si añades o quitas un shard (por ejemplo, pasas de 2 a 3), todos los targets cambian de asignación. Esto significa que los datos históricos en cada instancia ya no son consistentes con el nuevo esquema. Para mitigarlo, se usa un hash ring (como en Cortex o Thanos), pero eso ya es otra arquitectura.
Service discovery dinámico: el pegamento para el scale-out
El hashmod por sí solo no basta si los targets cambian constantemente (como en Kubernetes, donde los pods nacen y mueren). Aquí es donde entra el service discovery. Prometheus soporta múltiples mecanismos de SD: Kubernetes, Consul, DNS, EC2, etc. El objetivo es que cada shard obtenga la lista actualizada de targets y aplique el hashmod sobre ella.
Para un entorno on-premise o de máquinas virtuales, Consul es una opción excelente. Supongamos que tienes un servicio de nodos registrados en Consul. La configuración sería:
scrape_configs:
- job_name: 'node_exporter'
consul_sd_configs:
- server: 'consul.service.consul:8500'
services: ['node-exporter']
relabel_configs:
- source_labels: [__meta_consul_service_id]
target_label: __tmp_hash
modulus: 4
action: hashmod
- source_labels: [__tmp_hash]
regex: '^0$'
action: keep
Aquí, __meta_consul_service_id es un identificador único para cada instancia registrada. Con modulus: 4, repartimos la carga entre 4 Prometheus. Cada uno solo conserva los targets cuyo hash sea igual a su número. El service discovery se ejecuta periódicamente (por defecto cada 30 segundos), por lo que los nuevos nodos se integran automáticamente en el shard correspondiente.
En Kubernetes, el SD es aún más nativo. Usamos kubernetes_sd_configs con roles de pod o endpoint. Por ejemplo, para scrapear todos los pods con la anotación prometheus.io/scrape: "true":
scrape_configs:
- job_name: 'kubernetes-pods'
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
action: keep
regex: true
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
target_label: __metrics_path__
regex: (.+)
- source_labels: [__address__]
target_label: __tmp_hash
modulus: 3
action: hashmod
- source_labels: [__tmp_hash]
regex: '^2$'
action: keep
En este caso, el shard 2 solo scrapeará un tercio de los pods. La combinación de SD dinámico y hashmod permite que el sistema se autoajuste sin intervención manual.
Gestión de la configuración: plantillas y reload
Un problema práctico es que cada shard necesita la misma configuración excepto por la regex del keep. No querrás mantener 5 archivos YAML casi idénticos. La solución es usar un sistema de plantillas como Helm (si estás en Kubernetes) o simplemente un script que genere el archivo a partir de una variable de entorno. Por ejemplo, en un entorno con systemd:
# /etc/systemd/system/prometheus.service
[Service]
Environment=SHARD_ID=0
ExecStart=/usr/local/bin/prometheus \
--config.file=/etc/prometheus/prometheus-${SHARD_ID}.yml
Y el script de generación (por ejemplo, en bash o Python) leería una plantilla y sustituiría {{SHARD_ID}}. Además, recuerda que Prometheus permite recargar la configuración sin reiniciar enviando una señal SIGHUP o usando el endpoint /-/reload (si está habilitado con --web.enable-lifecycle). Esto es esencial cuando el número de shards cambia o se modifica el SD.
Alertas y consultas: el lado oscuro del sharding
Ahora viene la parte que muchos olvidan: las alertas y las consultas globales. Si cada Prometheus solo tiene una parte de los datos, una alerta que necesite datos de dos shards distintos (por ejemplo, comparar la CPU de dos servicios diferentes) no funcionará. Hay dos soluciones clásicas:
- Alertas por shard: Duplicar las reglas de alerta en cada instancia. Cada una evalúa sus propios datos. Esto es válido para alertas que solo dependen de un target, como "este nodo está caído".
- Prometheus federado: Un Prometheus central (o un Thanos Query) que consulta a todos los shards y agrega los resultados. Se configura así en el Prometheus central:
scrape_configs:
- job_name: 'federate-shard0'
scrape_interval: 30s
metrics_path: '/federate'
params:
'match[]': ['{__name__=~".+"}']
static_configs:
- targets: ['shard0:9090']
- job_name: 'federate-shard1'
...
Este enfoque es sencillo pero tiene un coste: el Prometheus central consume memoria y CPU al agregar todas las series. Para un número grande de shards, lo recomendable es usar Thanos o Cortex, que implementan consultas distribuidas de verdad.
comentarios(0)
$ dejar comentario