← volver

Blackbox Exporter: Vigilancia proactiva de endpoints HTTPS y TCP

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

La monitorización tradicional basada en agentes que reportan métricas internas del sistema (CPU, memoria, disco) es esencial, pero insuficiente para garantizar la experiencia del usuario final. Un servidor puede tener todos sus recursos al 100% y, sin embargo, estar devolviendo errores 502 o tener el puerto 443 cerrado por un firewall mal configurado. Para cubrir este vacío, surge el Prometheus Blackbox Exporter, una herramienta que permite sondear servicios externos e internos mediante protocolos como HTTPS, TCP, ICMP y DNS, proporcionando una visión "desde fuera" de la infraestructura.

Este artículo no pretende ser un tutorial paso a paso, sino un análisis técnico profundo sobre cómo diseñar, desplegar y aprovechar Blackbox Exporter para construir una monitorización proactiva y orientada a la disponibilidad real de los servicios. Veremos su arquitectura, configuración avanzada, métricas clave, y cómo integrarlo con Alertmanager para actuar antes de que los usuarios perciban un fallo.

Arquitectura y flujo de trabajo

Blackbox Exporter actúa como un probe (sonda). Recibe una solicitud HTTP con un parámetro target (el endpoint a verificar) y un módulo de configuración que define cómo realizar la prueba. El exporter ejecuta la comprobación y expone los resultados en formato Prometheus (métricas con etiquetas). Esta arquitectura es centralizada: el exporter puede sondear múltiples objetivos desde un único punto de red, o bien desplegarse en distintas regiones geográficas para simular la perspectiva de usuarios de diferentes ubicaciones.

El flujo típico es el siguiente:

  1. Prometheus scrapea el endpoint /probe de Blackbox Exporter, pasando parámetros como module y target.
  2. El exporter resuelve DNS, establece conexión TCP/TLS, realiza la solicitud HTTP y mide tiempos.
  3. El exporter devuelve métricas como probe_success, probe_duration_seconds, probe_http_status_code, entre otras.
  4. Prometheus almacena estas métricas y las correlaciona con el objetivo mediante etiquetas como instance o target.

En lugar de configurar un scrape por cada endpoint, se utiliza un único job de Prometheus que itera sobre una lista de objetivos (o un descubrimiento de servicios) y reutiliza el mismo exporter. Esto facilita el escalado y la gestión de cientos de endpoints.

Configuración de módulos: el corazón del exporter

La configuración de Blackbox Exporter se define en un archivo YAML (normalmente blackbox.yml). Cada módulo especifica el protocolo, los tiempos de espera, la validación de certificados TLS y las reglas de éxito. Un ejemplo de módulo para HTTPS que valida un certificado y una respuesta HTTP 200 es:

modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2.0"]
      valid_status_codes: [200]
      method: GET
      preferred_ip_protocol: "ip4"
      tls_config:
        insecure_skip_verify: false
      ip_protocol_fallback: false

Para comprobaciones TCP simples, se define un módulo que solo verifique la apertura del puerto:

modules:
  tcp_connect:
    prober: tcp
    timeout: 3s
    tcp:
      query_response: []

La clave está en la validación. No basta con que la conexión se establezca; en HTTPS es crucial verificar la cadena de certificados, la fecha de expiración y la coherencia del nombre de dominio. Blackbox Exporter lo hace automáticamente si insecure_skip_verify es false (valor por defecto). Además, la métrica probe_ssl_earliest_cert_expiry permite alertar sobre certificados a punto de caducar, una causa común de fallos en producción.

Prometheus: cómo configurar el scrape

En el archivo de configuración de Prometheus (prometheus.yml), se define un job que apunta al exporter y que parametriza cada objetivo. Un patrón habitual es:

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

Explicación de los relabel_configs: el primer bloque toma la dirección original (el endpoint) y la asigna al parámetro __param_target. El segundo bloque copia ese valor a la etiqueta instance para identificar claramente cada objetivo en las métricas. El tercer bloque redirige el scrape al Blackbox Exporter en 127.0.0.1:9115 (o la IP real del exporter).

Este enfoque permite que Prometheus no contacte directamente con el endpoint, sino que sea el exporter quien realice la conexión real. Si se desea monitorizar servicios TCP, se define un segundo job con module: [tcp_connect] y targets con formato host:puerto.

Métricas clave más allá de probe_success

La métrica obvia es probe_success (1 si la sonda tuvo éxito, 0 si falló). Sin embargo, el valor real de la monitorización proactiva radica en las métricas de rendimiento y diagnóstico:

  • probe_duration_seconds: tiempo total de la sonda. Permite detectar latencias anómalas antes de que causen timeouts.
  • probe_http_status_code: código HTTP devuelto. Útil para diferenciar un 500 de un 503.
  • probe_http_content_length: tamaño de la respuesta. Un contenido truncado puede indicar un error de aplicación.
  • probe_ssl_earliest_cert_expiry: fecha de expiración del certificado. Alerta con días o semanas de antelación.
  • probe_tls_version_info: versión TLS negociada. Ayuda a detectar protocolos obsoletos.
  • probe_ip_protocol: indica si se usó IPv4 o IPv6. Útil para detectar fallos de resolución DNS.

Combinando estas métricas, se pueden construir consultas avanzadas. Por ejemplo, para calcular el percentil 95 de latencia de un endpoint en la última hora:

histogram_quantile(0.95, sum(rate(probe_duration_seconds_bucket[1h])) by (le, instance))

O para detectar certificados que caducan en menos de 7 días:

probe_ssl_earliest_cert_expiry - time() < 604800

Esta última consulta es una excelente base para una regla de alerta en Alertmanager.

Alertas proactivas: el salto de la monitorización a la acción

La monitorización sin alertas es un ejercicio académico. Para que la vigilancia sea realmente proactiva, se deben definir reglas de alerta en Prometheus que evalúen las métricas periódicamente y notifiquen a los responsables. Un ejemplo de regla para un endpoint HTTPS:

groups:
  - name: blackbox_endpoints
    rules:
      - alert: EndpointHTTPDown
        expr: probe_success{job="blackbox_http"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "El endpoint {{ $labels.instance }} no responde"
          description: "La sonda HTTP ha fallado durante más de 1 minuto. Código HTTP: {{ $value }}."

Una alerta más granular podría diferenciar entre un error HTTP 5xx y un error de conexión TCP:

      - alert: HTTPStatus5xx
        expr: probe_http_status_code{job="blackbox_http"} >= 500
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "HTTP 5xx en {{ $labels.instance }}"

La alerta de expiración de certificados es crítica y a menudo olvidada:

      - alert: CertificateExpiringSoon
        expr: probe_ssl_earliest_cert_expiry - time() < 604800
        for: 0m
        labels:
          severity: warning
        annotations:
          summary: "El certificado de {{ $labels.instance }} caduca en menos de 7 días"

Estas alertas deben integrarse con Alertmanager, que puede enrutarlas a Slack, PagerDuty o correo electrónico según su severidad y el equipo responsable. La clave de la proactividad es evaluar el trend de la latencia (probe_duration_seconds aumentando gradualmente) y no solo los fallos bin

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