Estructura de navegación

Tabla de contenidos

• Visión de las métricas
• Service discovery

Visión de las métricas

Una vez que hemos configurado en nuestro dominio los exporters, si nos dirigimos a la interfaz web de Prometheus en el puerto 9090 y vamos a la opción de status > targets, veremos que ha detectado los DCs.

Si pulsamos sobre alguno de los endpoints nos redirigirá a la página creada por los exporters y podremos ver las métricas.

Como sólo hemos configurado la recolección de métricas de los servidores no detecta los clientes, por lo que a continuación crearemos un servicio de descubrimiento para prometheus.

Service discovery

Para crear la configuración de service discovery en Prometheus tenemos que indicarle como vamos a añadirla en el fichero prometheus.yml, en mi caso he decidido usar un file_sd_discovery, que consiste en añadir direcciones IP a un archivo en formato yaml que serán scrapeadas por Prometheus, para ello añadiremos la siguiente configuración en el fichero prometheus.yml

global:
  scrape_interval: 90s

scrape_configs:
  scrape_configs:
  - job_name: 'Server 1'
  scrape_interval: 60s
  scrape_timeout: 5s
  static_configs:
    - targets: ['172.19.0.10:9182'] #El exporter que usaremos expone las métricas en el puerto 9182
      labels: #Usamos esta opción para indicar que vamos a crear etiquetas para asociar una IP a un nombre concreto
       hostname: 'DC-01' #Nombre asociado a la IP
       type: 'server' #Esta etiqueta asigna el tipo "server" al servidor de destino.
  - job_name: 'Server 2'
  scrape_interval: 60s
  scrape_timeout: 5s
  static_configs:
    - targets: ['172.19.0.11:9182']
      labels:
       hostname: 'DC-02'
       type: 'server'

  - job_name: 'Clientes'
    file_sd_configs:
      - files:
        - clientes.yml

Para crear ese archivo vamos a crear un script en Python que se ejecute mediante una tarea cron en caso de que más adelante se añadan nuevos equipos, el script será el siguiente:

#!/usr/bin/python3
import subprocess
import concurrent.futures

def ping(ip):
    command = f"ping -c 1 -W 1 -l 64 {ip}"
    result = subprocess.run(command, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    return f"'{ip}:9182'" if result.returncode == 0 else None

def main():
    ip_range = [f"172.19.0.{i}" for i in range(20, 250)]

    results = []
    with concurrent.futures.ThreadPoolExecutor() as executor:
        future_to_ip = {executor.submit(ping, ip): ip for ip in ip_range}
        for future in concurrent.futures.as_completed(future_to_ip):
            ip = future_to_ip[future]
            if future.result() is not None:
                results.append(future.result())

    output = "- targets: [" + ", ".join(results) + "]\n"

    with open("/etc/prometheus/clientes.yml", "w") as output_file:
        output_file.write(output)

if __name__ == "__main__":
    main()

Por defecto prometheus escanea el archivo yml para añadir nuevos targets cada 300 segundos, por lo que crearemos un script para un servicio que se ejecute en bucle cada 300 segundos.

#!/bin/bash
while true;do

	/usr/bin/python3 /etc/prometheus/targets.py
	sleep 300
	
done

Y para ejecutarlo crearemos el servicio targets.service, con el siguiente contenido:

[Unit]
Description=Script para la actualización de targets

[Service]
ExecStart=/etc/prometheus/scripts/targets.sh
Restart=on-failure

[Install]
WantedBy=multi-user.target

Una vez que comprobamos que el servicio funciona lo activamos para que se ejecute automáticamente con el inicio del sistema.

Si ahora miramos en la interfaz web de Prometheus veremos ahora esta obteniendo métricas también de los clientes.

Con todo esto ya estamos listos para empezar a crear nuestros Dashboards en Grafana.