Thanos: Almacenamiento a Largo Plazo para Prometheus

Thanos extiende Prometheus para ofrecer retención ilimitada de métricas mediante almacenamiento en objetos (S3, GCS, Azure Blob), alta disponibilidad con múltiples instancias de Prometheus y una vista global unificada de métricas dispersas en varios clústeres. Al integrarse como sidecar junto a Prometheus, Thanos requiere cambios mínimos en la infraestructura existente mientras añade capacidades de almacenamiento, compactación y downsampling que Prometheus no ofrece de forma nativa. Esta guía cubre el despliegue completo en Linux con S3/MinIO como backend de almacenamiento.

Requisitos Previos

  • Ubuntu 20.04/22.04 o CentOS 8+/Rocky Linux 8+
  • Prometheus 2.0+ instalado y en funcionamiento
  • Acceso a un bucket S3 (AWS S3 o MinIO compatible)
  • 2 GB de RAM por componente Thanos
  • Prometheus configurado con --storage.tsdb.min-block-duration=2h y --storage.tsdb.max-block-duration=2h

Arquitectura de Thanos

Thanos se compone de varios binarios independientes que trabajan juntos:

  • Sidecar: corre junto a Prometheus, sube bloques TSDB a object storage y expone los datos recientes vía gRPC
  • Store Gateway: sirve datos históricos desde object storage
  • Query: capa de consulta unificada que agrega datos de Sidecar y Store Gateway
  • Compactor: compacta y crea downsamplings de los datos en object storage
  • Query Frontend: caché opcional de consultas para mejorar el rendimiento
[Prometheus + Sidecar] --> [Object Storage (S3/MinIO)]
         |                           |
         v                           v
    [Thanos Query] <--- [Thanos Store Gateway]
         |
         v
     [Grafana]

Instalación de Thanos

# Descargar la última versión de Thanos
THANOS_VERSION=0.35.1
wget "https://github.com/thanos-io/thanos/releases/download/v${THANOS_VERSION}/thanos-${THANOS_VERSION}.linux-amd64.tar.gz" -P /tmp

cd /tmp && tar xzf thanos-${THANOS_VERSION}.linux-amd64.tar.gz

# Instalar el binario (es un único binario para todos los componentes)
sudo mv thanos-${THANOS_VERSION}.linux-amd64/thanos /usr/local/bin/
sudo chmod +x /usr/local/bin/thanos

# Verificar la instalación
thanos --version

# Crear usuario y directorios
sudo useradd -r -s /bin/false thanos
sudo mkdir -p /etc/thanos /var/lib/thanos
sudo chown -R thanos:thanos /var/lib/thanos

Configurar el Almacenamiento de Objetos

Crea el archivo de configuración del bucket:

# /etc/thanos/bucket.yaml

# Configuración para AWS S3
type: S3
config:
  bucket: "mi-bucket-metricas-thanos"
  endpoint: "s3.amazonaws.com"
  region: "eu-west-1"
  access_key: "TU_ACCESS_KEY"
  secret_key: "TU_SECRET_KEY"
  insecure: false
  signature_version2: false

# Configuración para MinIO (S3 compatible self-hosted)
type: S3
config:
  bucket: "thanos"
  endpoint: "minio.tu-servidor.com:9000"
  access_key: "minio_access_key"
  secret_key: "minio_secret_key"
  insecure: false
  # Para MinIO sin SSL:
  # insecure: true

# Configuración para Google Cloud Storage
type: GCS
config:
  bucket: "mi-bucket-thanos"
  service_account: |-
    {
      "type": "service_account",
      "project_id": "mi-proyecto",
      ...
    }

# Proteger el archivo de configuración
sudo chmod 600 /etc/thanos/bucket.yaml
sudo chown thanos:thanos /etc/thanos/bucket.yaml

Thanos Sidecar

El sidecar debe correr en el mismo servidor que Prometheus y acceder a su directorio de datos TSDB:

# Primero, configurar Prometheus para bloquear correctamente
sudo nano /etc/prometheus/prometheus.yml

# Añadir flags de retención a Prometheus (si no están ya)
# En el servicio systemd de Prometheus:
sudo systemctl edit prometheus

[Service]
ExecStart=
ExecStart=/usr/local/bin/prometheus \
    --config.file=/etc/prometheus/prometheus.yml \
    --storage.tsdb.path=/var/lib/prometheus \
    --storage.tsdb.min-block-duration=2h \
    --storage.tsdb.max-block-duration=2h \
    --storage.tsdb.retention.time=48h \
    --web.listen-address=:9090 \
    --web.enable-lifecycle

# Crear el servicio del Thanos Sidecar
sudo tee /etc/systemd/system/thanos-sidecar.service > /dev/null <<EOF
[Unit]
Description=Thanos Sidecar
After=network.target prometheus.service

[Service]
Type=simple
User=thanos
ExecStart=/usr/local/bin/thanos sidecar \
    --tsdb.path=/var/lib/prometheus \
    --prometheus.url=http://localhost:9090 \
    --grpc-address=0.0.0.0:10901 \
    --http-address=0.0.0.0:10902 \
    --objstore.config-file=/etc/thanos/bucket.yaml
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable thanos-sidecar --now

# Verificar que el sidecar está subiendo bloques al almacenamiento de objetos
sudo journalctl -u thanos-sidecar -f

Thanos Store Gateway

El Store Gateway sirve datos históricos desde el almacenamiento de objetos. Se despliega en un servidor separado o en el mismo:

sudo tee /etc/systemd/system/thanos-store.service > /dev/null <<EOF
[Unit]
Description=Thanos Store Gateway
After=network.target

[Service]
Type=simple
User=thanos
ExecStart=/usr/local/bin/thanos store \
    --data-dir=/var/lib/thanos/store \
    --grpc-address=0.0.0.0:10903 \
    --http-address=0.0.0.0:10904 \
    --objstore.config-file=/etc/thanos/bucket.yaml
Restart=on-failure
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

sudo mkdir -p /var/lib/thanos/store
sudo chown -R thanos:thanos /var/lib/thanos/store
sudo systemctl enable thanos-store --now

Thanos Query

El componente Query proporciona una vista global y una API PromQL sobre todos los datos:

sudo tee /etc/systemd/system/thanos-query.service > /dev/null <<EOF
[Unit]
Description=Thanos Query
After=network.target

[Service]
Type=simple
User=thanos
ExecStart=/usr/local/bin/thanos query \
    --grpc-address=0.0.0.0:10905 \
    --http-address=0.0.0.0:10906 \
    --endpoint=prometheus-1:10901 \
    --endpoint=prometheus-2:10901 \
    --endpoint=thanos-store:10903 \
    --query.replica-label=replica \
    --query.auto-downsampling
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable thanos-query --now

Accede a la interfaz web de Thanos Query en http://tu-ip:10906. Ofrece una interfaz similar a Prometheus donde puedes ejecutar consultas PromQL sobre todos los datos, incluyendo los históricos.

Thanos Compactor

El Compactor reduce el tamaño del almacenamiento y crea downsamplings para consultas rápidas de rangos largos:

sudo tee /etc/systemd/system/thanos-compactor.service > /dev/null <<EOF
[Unit]
Description=Thanos Compactor
After=network.target

[Service]
Type=simple
User=thanos
# Solo puede haber UNA instancia del compactor ejecutándose
ExecStart=/usr/local/bin/thanos compact \
    --data-dir=/var/lib/thanos/compactor \
    --objstore.config-file=/etc/thanos/bucket.yaml \
    --http-address=0.0.0.0:10907 \
    --retention.resolution-raw=30d \
    --retention.resolution-5m=90d \
    --retention.resolution-1h=365d \
    --wait
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

sudo mkdir -p /var/lib/thanos/compactor
sudo chown -R thanos:thanos /var/lib/thanos/compactor
sudo systemctl enable thanos-compactor --now

Los parámetros de retención:

  • --retention.resolution-raw: retención de datos en resolución original (1 punto/15s)
  • --retention.resolution-5m: retención de datos con resolución de 5 minutos (downsampling)
  • --retention.resolution-1h: retención de datos con resolución de 1 hora (downsampling)

Integración con Grafana

# Añadir Thanos Query como datasource en Grafana
curl -X POST http://grafana:3000/api/datasources \
  -u admin:contraseña_grafana \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Thanos",
    "type": "prometheus",
    "url": "http://thanos-query:10906",
    "access": "proxy",
    "isDefault": true,
    "jsonData": {
      "timeInterval": "15s",
      "queryTimeout": "60s",
      "httpMethod": "POST"
    }
  }'

Con esta configuración, Grafana consulta directamente a Thanos Query, que retorna datos tanto recientes (desde los sidecars de Prometheus) como históricos (desde el Store Gateway y el almacenamiento de objetos).

Solución de Problemas

El Sidecar no sube bloques al almacenamiento:

# Revisar logs del sidecar
sudo journalctl -u thanos-sidecar -n 100 --no-pager | grep -i "error\|upload"

# Verificar acceso al bucket S3
# El usuario thanos debe tener permisos s3:PutObject y s3:GetObject

# Verificar que Prometheus está accesible
curl http://localhost:9090/api/v1/status/config

Thanos Query no puede conectar a los endpoints:

# Verificar conectividad de red a los puertos gRPC
nc -zv prometheus-1 10901
nc -zv thanos-store 10903

# Ver el estado de los endpoints en la interfaz web de Thanos Query
# http://thanos-query:10906/stores

El Store Gateway tarda mucho en sincronizar:

# El primer inicio puede tardar mucho si hay muchos datos en el bucket
# Ver el progreso en los logs
sudo journalctl -u thanos-store -f

# El Store Gateway descarga los meta-datos del bucket y cachea los índices
# En /var/lib/thanos/store se almacena el caché local

Datos duplicados en Thanos Query:

# Si múltiples Prometheus tienen las mismas métricas (HA), configurar deduplicación
# Añadir a ExecStart del query:
--query.replica-label=replica

# En Prometheus, añadir la etiqueta externa:
# En prometheus.yml:
global:
  external_labels:
    replica: 'prometheus-1'

Conclusión

Thanos transforma Prometheus en una solución de monitoreo con retención ilimitada y alta disponibilidad sin reemplazar el flujo de trabajo existente. El patrón sidecar permite adoptar Thanos de forma incremental, añadiendo los componentes de forma gradual según las necesidades crecen. Para infraestructuras multi-clúster, la capacidad de Thanos para agregar métricas de múltiples instancias de Prometheus en una vista global única simplifica enormemente la correlación y el análisis de incidentes.