Prometheus es una plataforma de monitorización y alerta de código abierto. Originalmente, Prometheus fue creado por Soundcloud en 2012. Desde entonces, el proyecto Prometheus, adoptado por algunas empresas famosas, se ha convertido en un proyecto mayor con desarrolladores y una comunidad muy activos. Y en 2016, el proyecto Prometheus se graduó en la Cloud Native Computing Foundation (CNCF).

Conceptos básicos que debes conocer

Básicamente, Prometheus recopila datos y métricas a través de puntos finales HTTP de los servidores de destino, y luego almacena todos los datos como series temporales. En Prometheus, los datos de las series temporales se identifican mediante el nombre de la métrica y pares clave/valor.

Prometheus proporciona flexibilidad mediante el Lenguaje de consulta de Prometheus (PromQL). Puedes utilizar PromQL para consultar la base de datos de series temporales de Prometheus.

En los servidores de destino, debes instalar la aplicación «exportador» que expone todos los datos y métricas a Prometheus. ‘Exportador de nodos’ es un exportador de uso común para supervisar máquinas Linux.

El exportador de nodos expone las métricas relacionadas con el hardware y el kernel de las máquinas Linux. Es un único archivo binario que expondrá métricas de datos finales al servidor Prometheus.

Instalación y configuración de Prometheus

Prometheus es un moderno sistema de supervisión y alerta de sistemas de código abierto. Puede instalarse en servidores Unix/Linux tradicionales mediante un paquete precompilado, utilizando tecnología de contenedores como Docker y Kubernetes, o herramientas de gestión de la configuración como Ansible, Chef, Puppet y Saltstack.

La siguiente sección te muestra cómo instalar Prometheus mediante un archivo binario precompilado en un servidor.

Sigue estos pasos para instalar con éxito Prometheus:

• Configurar usuario y directorios
• Descarga del paquete binario de Prometheus
• Configurar el servidor Prometheus
• Ejecutar Prometheus en segundo plano como servicio Systemd

Configurar usuario y directorios

Antes de instalar Prometheus, crearás un nuevo usuario y directorios en tu sistema. Este usuario se utilizará para ejecutar Prometheus, y algunos de los directorios se utilizarán para almacenar archivos de configuración y datos de Prometheus.

Ejecuta el siguiente comando para crear un nuevo usuario de sistema prometheus.

sudo adduser -M -r -s /sbin/nologin prometheus

Ejecuta el comando siguiente para crear un nuevo directorio /etc/prometheus que se utilizará para almacenar los archivos de configuración de Prometheus y el directorio /var/lib/prometheus que se utilizará como directorio de datos para Prometheus.

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus

Ahora ejecuta el siguiente comando para cambiar la propiedad de los directorios /etc/prometheus y /var/lib/prometheus al usuario prometheus y al grupo prometheus.

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

Descarga del paquete precompilado de prometheus

Ahora, instalarás prometheus en tu servidor. En esta demostración, instalarás Prometheus mediante un paquete binario precompilado.

cd /usr/src
wget https://github.com/prometheus/prometheus/releases/download/v2.54.1/prometheus-2.54.1.linux-amd64.tar.gz

Ahora extrae el archivo binario de Prometheus prometheus-2.44.0.linux-amd64.tar.gz utilizando el comando tar que aparece a continuación. Deberías obtener un nuevo directorio prometheus-2.44.0.linux-amd64 que contiene el archivo binario de Prometheus y algunas de las configuraciones por defecto.

 tar -xf prometheus-2.54.1.linux-amd64.tar.gz

Ejecuta el siguiente comando para copiar el archivo de configuración por defecto de Prometheus prometheus.yml y algunos directorios importantes en /etc/prometheus/.

sudo cp /usr/src/prometheus-*/prometheus.yml /etc/prometheus/
sudo cp -r /usr/src/prometheus-*/consoles /etc/prometheus
sudo cp -r /usr/src/prometheus-*/console_libraries /etc/prometheus

Después, cambia la propiedad del directorio /etc/prometheus/ al usuario promtheus y al grupo prometheus mediante el siguiente comando.

 sudo chown -R prometheus:prometheus /etc/prometheus

A continuación, ejecuta el siguiente comando para copiar el archivo binario de prometheus y promtool en el directorio /usr/bin/.

sudo cp /usr/src/prometheus-*/prometheus /usr/bin/
sudo cp /usr/src/prometheus-*/promtool /usr/bin/

A continuación, verifica el prometheus y el promtool utilizando el siguiente comando.

which prometheus
prometheus --version

Si la instalación se ha realizado correctamente, deberías ver la ruta completa del comando prometheus y promtool, que se encuentra en el directorio /usr/bin/. También verás la versión instalada de Prometheus.

Configurar Prometheus y añadir Node Exporter al servidor Prometheus

Una vez descargado e instalado Prometheus, comenzarás la configuración básica de Prometheus.

Abre el archivo de configuración de prometheus /etc/prometheus/prometheus.yml utilizando el editor nano.

nano /etc/prometheus/prometheus.yml

En el parámetro scrape_configs, añade el nuevo trabajo prometheus con el objetivo del propio servidor Prometheus.

# my global config
global:
  scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: "prometheus"

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
      - targets: ["localhost:9090"]


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

#  - job_name: 'node_exporter_metrics'
#    scrape_interval: 5s
#    static_configs:
#      - targets: ['localhost:9100']

Guarda y cierra el archivo cuando hayas terminado.

A continuación, crea un nuevo archivo de servicio systemd para prometheus en /etc/systemd/system/prometheus.service utilizando el comando editor nano.

sudo nano /etc/systemd/system/prometheus.service

Añade la siguiente configuración para ejecutar Prometheus como un servicio systemd.

Con el siguiente contenido

 [Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target
[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/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

[Install]
WantedBy=multi-user.target

Guarda el archivo y sal del editor cuando hayas terminado.

Ahora ejecuta el siguiente comando para recargar el gestor systemd y aplicar los cambios al systemd.

 sudo systemctl daemon-reload

A continuación, inicia y habilita el servicio prometheus mediante el comando systemctl que aparece a continuación.

sudo systemctl start prometheus
sudo systemctl enable prometheus

Verifica el servicio prometheus para asegurarte de que se está ejecutando.

sudo systemctl status prometheus

Por último, inicia tu navegador web y visita la dirección IP del servidor seguida del puerto 9090 (es decir, http://localhost:9090/). Si la instalación se ha realizado correctamente, deberías obtener la página gráfica de Prometheus como ésta:

También puedes verificar el estado del punto final de monitorización haciendo clic en Estado > Objetivos. Deberías ver el job_name prometheus con el estado UP.

Instalación y configuración de Node Exporter en la monitorización de objetivos

Node Exporter es una aplicación de Prometheus que expone las métricas del sistema de monitorización del objetivo. Te permite raspar una serie de métricas del sistema y puede exponerse para su posterior proceso a Prometheus.

También existe Node Exporter para sistemas Windows:

• https://github.com/prometheus-community/windows_exporter

En esta sección, instalarás Node Exporter en un servidor. Instalarás Node Exporter mediante un paquete binario precompilado proporcionado por Prometheus.

• https://prometheus.io/docs/guides/node-exporter/

Descarga e instalación de Node Exporter

Para instalar Node Exporter, debes crear un usuario del sistema dedicado a él y descargar el paquete binario de Node Exporter a tu sistema.

Primero, ejecuta el siguiente comando para crear un nuevo usuario de sistema node_exporter.

sudo adduser -M -r -s /sbin/nologin node_exporter

A continuación, desplázate al directorio /usr/src y descarga el archivo binario precompilado de Node Exporter mediante wget.

 cd /usr/src/
wget https://github.com/prometheus/node_exporter/releases/download/v1.8.2/node_exporter-1.8.2.linux-amd64.tar.gz

Descomprime

 tar -xf node_exporter-1.8.2.linux-amd64.tar.gz

A continuación, mueve el archivo binario de Node Exporter al directorio /usr/bin utilizando el comando que aparece a continuación.

 mv node_exporter-*/node_exporter /usr/bin

Ahora verifica Node Exporter utilizando el siguiente comando. Si tiene éxito, deberías obtener la ruta binaria completa y la versión de Node Exporter.

which node_exporter
node_exporter --version

sudo firewall-cmd --zone=public --add-port=9100/tcp --permanent

sudo firewall-cmd --reload

Ejecutar Node Exporter en segundo plano como un servicio

Una vez instalado Node Exporter, deberás configurar y ejecutar Node Exporter en segundo plano como un servicio systemd.

Para ello, crea un nuevo archivo de servicio systemd /etc/systemd/system/node_exporter.service utilizando el siguiente comando del editor nano. En este ejemplo, ejecutarás Node Exporter como un servicio systemd.

sudo nano /etc/systemd/system/node_exporter.service

Y añade:

[Unit]
Description=Node Exporter
After=network.target
[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/bin/node_exporter

[Install]
WantedBy=multi-user.target

Guarda y sal del archivo cuando hayas terminado.

Ahora ejecuta el siguiente comando systemctl para recargar el gestor systemd.

sudo systemctl daemon-reload

A continuación, inicia y habilita el servicio node_exporter mediante el siguiente comando.

sudo systemctl start node_exporter
sudo systemctl enable node_exporter

Una vez iniciado y habilitado node_exporter, ejecuta el siguiente comando para verificarlo y asegurarte de que el servicio se está ejecutando.

sudo systemctl status node_exporter

Si se está ejecutando, deberías ver el servicio node_exporter con el estado activo (en ejecución).

Por último, ejecuta el siguiente comando para verificar el puerto de Node Exporter. Por defecto, se ejecuta en el puerto 9100.

ss -tulpn | grep node

También puedes verificarlo a través del navegador web visitando la dirección IP del servidor seguida del puerto 9100 . Deberías ver los datos del punto final de la monitorización del servidor a través de Node Exporter.

 curl http://localhost:9100/metrics

curl http://localhost:9100/metrics | grep "node_"

Ahora abre el prometheus desde tu navegador web y haz clic en Estado > Objetivos para asegurarte de que se ha añadido el Nodo Exportador. Si se ha añadido correctamente, deberías ver el trabajo node_exporter_metrics con el estado UP.

 

 

A continuación, ve al menú Gráfico e introduce la consulta que empieza por nodo_ para obtener la lista de consultas proporcionadas por el Exportador de Nodos.

Haz clic en la pestaña Gráfico o Tabla e introduzca la consulta PromQL (Prometheus Querying Language) en la barra de búsqueda. He aquí un ejemplo:

Escribe la consulta node_load15 y haz clic en la pestaña Gráfico para obtener el estado de la carga del sistema durante los últimos 15 minutos.

 

Algunas métricas de ejemplo:

Métricas de la CPU

Aquí los puntos de datos relacionados con las métricas de la CPU:

•     node_cpu_seconds_total - la CPU ha pasado un total acumulado de segundos en cada modo (usuario, sistema, inactivo, etc.).
•     node_cpu_seconds_total{mode=«idle»} - tiempo total que la CPU ha pasado en modo inactivo.

Métricas de memoria

Aquí los elementos de datos relacionados con las métricas de memoria:

•     node_memory_MemTotal_bytes - la memoria total del sistema.
•     node_memory_MemFree_bytes - la cantidad de memoria libre del sistema.
•     node_memory_Cached_bytes - la cantidad de memoria usada para almacenar datos en caché.

Métricas de red

Aquí los valores de datos relacionados con las métricas de red:

•     node_network_receive_bytes_total - total de bytes recibidos en todas las interfaces de red.
•     node_network_transmit_bytes_total - total de bytes transmitidos en todas las interfaces de red.
•     node_network_receive_bytes{device="eth0″} - bytes recibidos en una interfaz de red específica.

Métricas de E/S de disco

Aquí los puntos de datos relacionados con las métricas de E/S de disco:

•     node_disk_io_time_seconds_total - segundos acumulados dedicados a realizar E/S.
•     node_disk_io_time_seconds_total{device=«sda»} - segundos acumulados dedicados a realizar E/S en un disco específico.

Métricas del sistema de archivos

Aquí se muestran los elementos de datos relacionados con las métricas del sistema de archivos:

•     node_filesystem_size_bytes - tamaño total del sistema de archivos.
•     node_filesystem_free_bytes - espacio libre en el sistema de archivos.

Métricas de tiempo de actividad

Aquí el valor de los datos relacionados con las métricas de tiempo de actividad:

•     node_boot_time_seconds - fecha y hora del último arranque del nodo.

Métricas de carga del sistema

Aquí los puntos de datos relacionados con las métricas de carga del sistema:

•     node_load1 - los promedios de carga de 1 minuto.
•     node_load5 - las medias de carga de 5 minutos.
•     node_load15 - los promedios de carga de 15 minutos.

Métricas de lectura/escritura del sistema de archivos

Aquí los elementos de datos relacionados con las métricas de lectura/escritura del sistema de archivos:

•     node_filesystem_read_bytes_total - total de bytes leídos de todos los sistemas de archivos.
•     node_filesystem_write_bytes_total - total de bytes escritos en todos los sistemas de archivos.

Common query metrics

The following table describes the common query metrics of node-exporter.

Category	Metric name	Type	Description
CPU	node_cpu_seconds_total	Counter	CPU use time of a node (unit: seconds)
Memory	node_memory_MemTotal_bytes	Gauge	Total memory size of a node (unit: bytes)
	node_memory_MemFree_bytes	Gauge	Idle memory size of a node (unit:bytes)
	node_memory_Buffers_bytes	Gauge	Cache size of a node (unit:bytes)
	node_memory_Cached_bytes	Gauge	Page cache size of a node (unit:bytes)
Disk	node_filesystem_avail_bytes	Gauge	User's remaining partition space (unit: bytes), indicating the remaining available space of the user
	node_filesystem_size_bytes	Gauge	Total partition capacity (unit:bytes)
	node_filesystem_free_bytes	Gauge	Remaining physical space of a partition (unit: bytes), indicating the available space of the physical layer
	node_disk_read_bytes_total	Counter	Total read bytes of a partition (unit:bytes)
	node_disk_written_bytes_total	Counter	Total write bytes of a partition (unit:bytes)
	node_disk_reads_completed_total	Counter	Total reads of a partition
	node_disk_writes_completed_total	Counter	Total writes of a partition
Network	node_network_receive_bytes_total	Counter	Total bytes in received traffic (unit:bytes)
	node_network_transmit_bytes_total	Counter	Total bytes in sent traffic (unit:bytes)
	node_network_receive_packets_total	Counter	Total packets in received traffic (unit: packets)
	node_network_transmit_packets_total	Counter	Total packets in sent traffic (unit:packets)
	node_network_receive_drop_total	Counter	Total lost packets in received traffic (unit:packets)
	node_network_transmit_drop_total	Counter	Total lost packets in sent traffic (unit:packets)

Grafana

 

• Grafana es una plataforma de código abierto para la monitorización y la observabilidad.

Permite crear, explorar y compartir cuadros de mando y paneles para visualizar datos de diversas fuentes, incluidas bases de datos de series temporales como Prometheus.

Grafana se comunica con Prometheus a través de HTTP, normalmente utilizando el lenguaje de consulta de Prometheus (PromQL) para recuperar y mostrar métricas.
Instalación:

    Instalar Grafana
    Accede a la interfaz web de Grafana.
    Abre navegador web y navegua hasta http://localhost:3000.
    Añade Prometheus como fuente de datos.

 

 

    Configura la fuente de datos de Prometheus.
    a. Nombre
    b. HTTP
    c. Acceso
    Crear cuadros de mando y paneles.

Para instalar Grafana podemos usar Docker.

Importación de cuadros de mando preconstruidos:

    Abrir Grafana

    Ir a Dashboard
    Haga clic en nuevo
    importar
    https://grafana.com/grafa a/dashboards/
    selecciona dashboard compatible con tu instalación
    como tenemos instalado Node_exporter selecciona dashboard node exporter full
    poner dashboard id (1860) y cargar (load) el dashboard
    Ahora ve al dashboard puedes ver el dashboard pre-construido recién creado.


 

Y el resultado:

Cómo actualizar Prometheus y todos los componentes de software relacionados

Copia de seguridad de los datos y detalles de configuración de Prometheus

Para realizar una copia de seguridad de los datos y detalles de configuración de Prometheus, utilice el siguiente comando:

sudo cp -r /etc/prometheus /etc/prometheus_backup

o en /var/lib/prometheus

Parar los servicios y actualizar los binarios con las nuevas versiones.

Fuentes:

https://howtoforge.es/como-instalar-prometheus-y-node-exporter-en-almalinux-9/ 

https://medium.com/@vedantk.mail/local-linux-system-monitoring-using-prometheus-node-exporter-and-grafana-9fbd8ba0370d

https://www.liquidweb.com/blog/install-prometheus-node-exporter-on-linux-almalinux/