Monitoreo con Prometheus: Configuración completa y mejores prácticas

Prometheus ha se convertido en el estándar de facto para monitorear aplicaciones y infraestructura nativas en la nube, ofreciendo recolección de métricas, consulta e integración con herramientas de visualización.

¿Qué es Prometheus?

Prometheus es una herramienta de monitoreo y alertas de código abierto originalmente desarrollada en SoundCloud en 2012 y ahora un proyecto graduado de la Fundación Cloud Native Computing (CNCF). Está diseñada específicamente para fiabilidad y escalabilidad en entornos en la nube dinámicos, siendo la solución ideal para monitorear microservicios, contenedores y clústeres de Kubernetes.

Características clave

Base de datos en serie de tiempo: Prometheus almacena todos los datos como series temporales, identificadas por nombres de métricas y pares clave-valor (etiquetas), lo que permite consultas flexibles y poderosas.

Modelo basado en extracción: A diferencia de los sistemas tradicionales basados en emisión, Prometheus extrae activamente métricas de objetivos configurados en intervalos especificados, lo que lo hace más confiable y más fácil de configurar.

Lenguaje de consulta PromQL: Un potente lenguaje de consulta funcional permite cortar y analizar tus datos de métricas en tiempo real, realizando agregaciones, transformaciones y cálculos complejos.

Descubrimiento de servicios: Descubrimiento automático de objetivos de monitoreo a través de varios mecanismos, incluyendo Kubernetes, Consul, EC2 y configuraciones estáticas.

Sin dependencias externas: Prometheus opera como un único binario sin dependencias externas necesarias, simplificando la implementación y reduciendo la complejidad operativa.

Alertas integradas: AlertManager maneja alertas de Prometheus, proporcionando deduplicación, agrupamiento y enrutamiento a canales de notificación como correo electrónico, PagerDuty o Slack.

Visión general de la arquitectura

Entender la arquitectura de Prometheus es crucial para una implementación efectiva. Los componentes principales incluyen:

• Servidor de Prometheus: Extrae y almacena métricas, evalúa reglas y sirve consultas
• Bibliotecas de cliente: Instrumenta el código de la aplicación para exponer métricas
• Exporters: Actúan como puente entre sistemas de terceros y el formato de Prometheus
• AlertManager: Maneja alertas y notificaciones
• Pushgateway: Acepta métricas de trabajos de corta duración que no pueden ser extraídos

El flujo típico de datos: Las aplicaciones exponen puntos de extremo de métricas → Prometheus extrae estos puntos de extremo → Los datos se almacenan en la base de datos en serie de tiempo → Las consultas PromQL recuperan y analizan los datos → Se generan alertas según reglas → AlertManager procesa y enruta las notificaciones.

Cuando se implementa infraestructura en Ubuntu 24.04, Prometheus proporciona una excelente base para un monitoreo integral.

Instalando Prometheus en Ubuntu

Vamos a pasar por el proceso de instalar Prometheus en un sistema Linux. Usaremos Ubuntu como ejemplo, pero el proceso es similar para otras distribuciones.

Descargar e instalar

Primero, cree un usuario dedicado para Prometheus:

sudo useradd --no-create-home --shell /bin/false prometheus

Descargue la última versión de Prometheus:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.48.0/prometheus-2.48.0.linux-amd64.tar.gz
tar xvf prometheus-2.48.0.linux-amd64.tar.gz
cd prometheus-2.48.0.linux-amd64

Copie los binarios y cree directorios:

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

sudo cp -r consoles /etc/prometheus
sudo cp -r console_libraries /etc/prometheus
sudo cp prometheus.yml /etc/prometheus/prometheus.yml
sudo chown -R prometheus:prometheus /etc/prometheus

Para la gestión de paquetes en Ubuntu, consulte nuestra completa guía de gestión de paquetes en Ubuntu.

Configurar Prometheus

Edite /etc/prometheus/prometheus.yml:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

rule_files:
  - 'alert_rules.yml'

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

Crear un servicio systemd

Cree /etc/systemd/system/prometheus.service:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --storage.tsdb.retention.time=30d

[Install]
WantedBy=multi-user.target

Inicie y habilite Prometheus:

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus
sudo systemctl status prometheus

Acceda a la interfaz web de Prometheus en http://localhost:9090.

Configuración del Node Exporter

El Node Exporter expone métricas de hardware y sistema operativo para sistemas Linux. Instálelo para monitorear sus servidores:

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/node_exporter

Crear servicio systemd /etc/systemd/system/node_exporter.service:

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

Iniciar Node Exporter:

sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter

El Node Exporter ahora expone métricas en el puerto 9100.

Entendiendo PromQL

PromQL (Prometheus Query Language) es el corazón de la consulta de datos de Prometheus. Aquí hay patrones de consulta esenciales:

Consultas básicas

Seleccionar todas las series temporales para una métrica:

node_cpu_seconds_total

Filtrar por etiqueta:

node_cpu_seconds_total{mode="idle"}

Varios filtros de etiqueta:

node_cpu_seconds_total{mode="idle",cpu="0"}

Vectores de rango y agregaciones

Calcular la tasa en el tiempo:

rate(node_cpu_seconds_total{mode="idle"}[5m])

Sumar en todos los CPUs:

sum(rate(node_cpu_seconds_total{mode="idle"}[5m]))

Agrupar por etiqueta:

sum by (mode) (rate(node_cpu_seconds_total[5m]))

Ejemplos prácticos

Porcentaje de uso de CPU:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Uso de memoria:

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Uso de disco:

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Tasa de tráfico de red:

rate(node_network_receive_bytes_total[5m])

Despliegue en Docker

Ejecutar Prometheus en contenedores de Docker ofrece flexibilidad y gestión más fácil:

Crear docker-compose.yml:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  node_exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    command:
      - '--path.rootfs=/host'
    volumes:
      - '/:/host:ro,rslave'
    ports:
      - "9100:9100"
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
      - alertmanager_data:/alertmanager
    ports:
      - "9093:9093"
    restart: unless-stopped

volumes:
  prometheus_data:
  alertmanager_data:

Iniciar el stack:

docker-compose up -d

Monitoreo de Kubernetes

Prometheus destaca en el monitoreo de clústeres de Kubernetes. El chart Helm kube-prometheus-stack proporciona una solución de monitoreo completa.

Instalar con Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack

Esto instala:

• Operador de Prometheus
• Instancia de Prometheus
• AlertManager
• Grafana
• Node Exporter
• kube-state-metrics
• Dashboards y alertas preconfiguradas

Acceder a Grafana:

kubectl port-forward svc/prometheus-grafana 3000:80

Credenciales por defecto: admin/prom-operator

Para varias distribuciones de Kubernetes, el proceso de implementación es similar con ajustes menores para características específicas de la plataforma.

Configuración de alertas

AlertManager maneja las alertas enviadas por Prometheus. Configure reglas de alerta y canales de notificación.

Reglas de alerta

Crear /etc/prometheus/alert_rules.yml:

groups:
  - name: system_alerts
    interval: 30s
    rules:
      - alert: AltoUsoDeCPU
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severidad: advertencia
        annotations:
          resumen: "Alto uso de CPU en {{ $labels.instance }}"
          descripción: "El uso de CPU está por encima del 80% (valor actual: {{ $value }}%)"

      - alert: AltoUsoDeMemoria
        expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severidad: advertencia
        annotations:
          resumen: "Alto uso de memoria en {{ $labels.instance }}"
          descripción: "El uso de memoria está por encima del 85% (valor actual: {{ $value }}%)"

      - alert: EspacioEnDiscoBajo
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severidad: crítico
        annotations:
          resumen: "Espacio en disco bajo en {{ $labels.instance }}"
          descripción: "El espacio disponible en disco está por debajo del 15% en {{ $labels.mountpoint }}"

      - alert: InstanciaDeshabilitada
        expr: up == 0
        for: 2m
        labels:
          severidad: crítico
        annotations:
          resumen: "La instancia {{ $labels.instance }} está deshabilitada"
          descripción: "La instancia {{ $labels.job }} {{ $labels.instance }} ha estado deshabilitada durante más de 2 minutos"

Configuración de AlertManager

Crear /etc/prometheus/alertmanager.yml:

global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alerts@example.com'
  smtp_auth_username: 'alerts@example.com'
  smtp_auth_password: 'your-password'

route:
  group_by: ['alertname', 'cluster', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 12h
  receiver: 'team-email'
  routes:
    - match:
        severity: critical
      receiver: 'team-pagerduty'
    - match:
        severity: warning
      receiver: 'team-slack'

receivers:
  - name: 'team-email'
    email_configs:
      - to: 'team@example.com'
        headers:
          Subject: '{{ .GroupLabels.alertname }}: {{ .Status | toUpper }}'

  - name: 'team-slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Alerta: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

  - name: 'team-pagerduty'
    pagerduty_configs:
      - service_key: 'your-pagerduty-key'

Integración con Grafana

Aunque Prometheus tiene una interfaz web básica, Grafana proporciona una visualización superior para crear dashboards integrales.

Añadir Prometheus como fuente de datos

1. Abra Grafana y navegue a Configuración → Fuentes de datos
2. Haga clic en “Añadir fuente de datos”
3. Seleccione “Prometheus”
4. Establezca la URL en http://localhost:9090 (o su servidor de Prometheus)
5. Haga clic en “Guardar y probar”

IDs de dashboard populares

Importe dashboards preconstruidos desde grafana.com:

• Node Exporter Full (ID: 1860): Métricas completas de Linux
• Kubernetes Cluster Monitoring (ID: 7249): Visión general de K8s
• Docker Container Monitoring (ID: 193): Métricas de contenedores
• Prometheus Stats (ID: 2): Métricas internas de Prometheus

Crear dashboards personalizados

Crear paneles usando consultas PromQL:

{
  "title": "Uso de CPU",
  "targets": [{
    "expr": "100 - (avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
  }]
}

Exporters populares

Extienda el monitoreo de Prometheus con exporters especializados:

Blackbox Exporter

Prueba endpoints a través de HTTP, HTTPS, DNS, TCP y ICMP:

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: localhost:9115

Exporters de base de datos

• mysqld_exporter: Métricas de MySQL/MariaDB
• postgres_exporter: Métricas de PostgreSQL
• mongodb_exporter: Métricas de MongoDB
• redis_exporter: Métricas de Redis

Exporters de aplicaciones

• nginx_exporter: Métricas del servidor web NGINX
• apache_exporter: Métricas del servidor HTTP Apache
• haproxy_exporter: Métricas del balanceador de carga HAProxy

Exporters de nube

• cloudwatch_exporter: Métricas de AWS CloudWatch
• stackdriver_exporter: Métricas de Google Cloud
• azure_exporter: Métricas de Azure Monitor

Buenas prácticas

Retención de datos

Configure la retención adecuada según sus necesidades:

--storage.tsdb.retention.time=30d
--storage.tsdb.retention.size=50GB

Reglas de grabación

Pre-calcule expresiones consultadas con frecuencia:

groups:
  - name: example_rules
    interval: 30s
    rules:
      - record: job:node_cpu_utilization:avg
        expr: 100 - (avg by (job) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Gestión de etiquetas

• Mantenga la cardinalidad de etiquetas baja
• Use convenciones de nombrado consistentes
• Evite etiquetas con alta cardinalidad (identificadores de usuario, marcas de tiempo)

Seguridad

• Active autenticación y HTTPS
• Restrinja el acceso a la API de Prometheus
• Use políticas de red en Kubernetes
• Implemente RBAC para métricas sensibles

Alta disponibilidad

• Ejecute múltiples instancias de Prometheus
• Use Thanos o Cortex para almacenamiento a largo plazo
• Implemente federación para configuraciones jerárquicas

Solución de problemas comunes

Alto uso de memoria

• Reduzca la frecuencia de extracción
• Disminuya el período de retención
• Optimice las consultas PromQL
• Implemente reglas de grabación

Métricas faltantes

• Compruebe el estado de los objetivos en /targets
• Verifique la conectividad de red
• Valide la configuración de extracción
• Revise los registros del exporter

Consultas lentas

• Use reglas de grabación para agregaciones complejas
• Optimice los filtros de etiqueta
• Reduzca el rango de tiempo
• Añada índices si usa almacenamiento remoto

Optimización del rendimiento

Optimización de consultas

# Mala: Alta cardinalidad
sum(rate(http_requests_total[5m]))

# Buena: Agrupar por etiquetas relevantes
sum by (status, method) (rate(http_requests_total[5m]))

Límites de recursos

Para implementaciones en Kubernetes:

resources:
  requests:
    memory: "2Gi"
    cpu: "1000m"
  limits:
    memory: "4Gi"
    cpu: "2000m"

Conclusión

Prometheus proporciona una solución robusta y escalable de monitoreo para la infraestructura moderna. Su arquitectura basada en extracción, poderoso lenguaje de consulta y ecosistema extenso de exporters lo hacen ideal para monitorear desde servidores físicos hasta complejos clústeres de Kubernetes.

Al combinar Prometheus con Grafana para visualización y AlertManager para notificaciones, creas una plataforma de observabilidad integral capaz de manejar los requisitos de monitoreo a escala empresarial. La comunidad activa y el respaldo de la CNCF garantizan desarrollo continuo y soporte.

Empiece con la recolección de métricas básicas, agregue gradualmente exporters para sus servicios específicos y refine sus reglas de alerta según la experiencia real. Prometheus se escala con su infraestructura, desde implementaciones en un solo servidor hasta arquitecturas de monitoreo en múltiples centros de datos.

Recursos relacionados

• Cómo instalar Ubuntu 24.04 y herramientas útiles
• Gestión de paquetes en Ubuntu: Guía de APT y dpkg
• Instale y use Grafana en Ubuntu: Guía completa
• Guía de Kubernetes
• Visión general de las distribuciones de Kubernetes
• Guía de Docker

Referencias externas

• Documentación oficial de Prometheus
• Ejemplos de consultas PromQL
• Lista de exporters de Prometheus
• Guía de integración de Prometheus con Grafana
• Chart Helm kube-prometheus-stack
• Mejores prácticas de Prometheus
• Configuración de AlertManager