Instalación de Node Exporter para Prometheus

Introducción

Prometheus se ha convertido en el estándar de facto para la recopilación de métricas y monitoreo en infraestructura moderna, particularmente en entornos nativos de la nube y Kubernetes. Node Exporter es un componente crucial del ecosistema Prometheus, diseñado para exponer métricas a nivel de hardware y sistema operativo desde servidores Linux en un formato que Prometheus puede recopilar y procesar.

Node Exporter transforma tus servidores Linux en endpoints observables al recopilar cientos de métricas del sistema, incluyendo uso de CPU, consumo de memoria, E/S de disco, estadísticas de red, uso del sistema de archivos y mucho más. A diferencia de las soluciones de monitoreo basadas en agentes, Node Exporter se ejecuta como un daemon ligero que simplemente expone métricas a través de HTTP, siguiendo la arquitectura basada en pull de Prometheus.

Esta guía completa te acompaña en el proceso completo de instalar, configurar y asegurar Node Exporter en sistemas Linux. Aprenderás cómo desplegar Node Exporter, configurar recolectores personalizados, integrar con Prometheus, asegurar el endpoint de métricas e implementar mejores prácticas para monitoreo en producción. Ya sea que estés construyendo una nueva infraestructura de monitoreo o migrando desde herramientas heredadas, Node Exporter proporciona la base para una observabilidad integral del sistema.

Requisitos Previos

Antes de instalar Node Exporter, asegúrate de tener:

• Un servidor Linux (Ubuntu 20.04/22.04, Debian 10/11, CentOS 7/8, Rocky Linux 8/9 o similar)
• Acceso root o sudo para instalación y configuración
• Comprensión básica de la arquitectura de Prometheus
• Acceso al firewall para permitir recopilación de métricas (puerto predeterminado 9100)
• Un servidor Prometheus para recopilar métricas (puede configurarse después)

Conocimiento Recomendado:

• Comprensión de la gestión de servicios systemd
• Conocimiento básico de HTTP y APIs REST
• Familiaridad con métricas y datos de series temporales
• Comprensión de conceptos de monitoreo

Requisitos del Sistema:

• RAM mínima: 50 MB
• CPU mínima: Sobrecarga muy baja
• Espacio en disco: ~20 MB para binario y datos

Entendiendo Node Exporter

¿Qué es Node Exporter?

Node Exporter es un exportador de Prometheus para métricas de hardware y sistema operativo expuestas por kernels *NIX. Recopila métricas de los sistemas de archivos /proc y /sys y las expone a través de un endpoint HTTP para que Prometheus las recopile.

Características Clave:

• Más de 100 recolectores diferentes para métricas del sistema
• Huella de recursos mínima
• Sin dependencias externas
• Recolectores configurables
• Recolector de archivos de texto para métricas personalizadas
• Soporte para múltiples arquitecturas

Métricas Expuestas

Node Exporter proporciona métricas para:

• CPU: Uso, tiempo inactivo, espera de E/S
• Memoria: Disponible, usada, en caché, en búfer
• Disco: Estadísticas de E/S, uso de espacio
• Red: Ancho de banda, errores, paquetes
• Sistema de archivos: Puntos de montaje, uso
• Carga: Promedios de carga del sistema
• Estadísticas de Red: Conexiones TCP/UDP
• Tiempo: Hora del sistema y sincronización NTP
• Hardware: Temperatura, estado RAID (con recolectores adicionales)

Instalando Node Exporter

Método 1: Instalación Binaria (Recomendado)

Este método instala el binario oficial precompilado del repositorio GitHub de Prometheus.

Paso 1: Descargar Node Exporter

# Crear usuario para Node Exporter
sudo useradd --no-create-home --shell /bin/false node_exporter

# Descargar última versión (verifica https://prometheus.io/download/ para la última)
cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz

# Extraer archivo
tar xvfz node_exporter-1.7.0.linux-amd64.tar.gz

# Mover binario a /usr/local/bin
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/

# Establecer propiedad
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

# Limpiar
rm -rf node_exporter-1.7.0.linux-amd64*

Paso 2: Verificar Instalación

# Verificar versión
/usr/local/bin/node_exporter --version

# Ejecutar prueba (Ctrl+C para detener)
/usr/local/bin/node_exporter

Método 2: Instalación con Gestor de Paquetes

En Ubuntu/Debian:

# Nota: Puede no ser la última versión
sudo apt update
sudo apt install prometheus-node-exporter -y

# Verificar estado
sudo systemctl status prometheus-node-exporter

En CentOS/Rocky Linux (Repositorio EPEL):

# Habilitar repositorio EPEL
sudo yum install epel-release -y

# Instalar Node Exporter
sudo yum install golang-github-prometheus-node-exporter -y

# Verificar estado
sudo systemctl status node_exporter

Método 3: Instalación con Docker

# Ejecutar Node Exporter como contenedor Docker
docker run -d \
  --name node-exporter \
  --net="host" \
  --pid="host" \
  -v "/:/host:ro,rslave" \
  quay.io/prometheus/node-exporter:latest \
  --path.rootfs=/host

# Verificar que el contenedor esté en ejecución
docker ps | grep node-exporter

# Ver métricas
curl http://localhost:9100/metrics

Creando Servicio Systemd

Para instalación binaria, crea un servicio systemd para inicio automático y gestión.

Crear archivo de servicio:

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

Configuración del servicio:

[Unit]
Description=Node Exporter
Documentation=https://prometheus.io/docs/guides/node-exporter/
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
Restart=on-failure
RestartSec=5s
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

Habilitar e iniciar servicio:

# Recargar daemon de systemd
sudo systemctl daemon-reload

# Habilitar Node Exporter para iniciar al arrancar
sudo systemctl enable node_exporter

# Iniciar Node Exporter
sudo systemctl start node_exporter

# Verificar estado
sudo systemctl status node_exporter

# Ver registros
sudo journalctl -u node_exporter -f

Configurando Node Exporter

Configuración Básica

Node Exporter se configura mediante banderas de línea de comandos. Modifica el archivo de servicio systemd para agregar opciones de configuración.

Editar archivo de servicio:

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

Agregar banderas de configuración:

[Service]
ExecStart=/usr/local/bin/node_exporter \
  --web.listen-address=:9100 \
  --collector.filesystem.mount-points-exclude='^/(dev|proc|sys|var/lib/docker/.+|var/lib/kubelet/.+)($|/)' \
  --collector.filesystem.fs-types-exclude='^(autofs|binfmt_misc|bpf|cgroup2?|configfs|debugfs|devpts|devtmpfs|fusectl|hugetlbfs|iso9660|mqueue|nsfs|overlay|proc|procfs|pstore|rpc_pipefs|securityfs|selinuxfs|squashfs|sysfs|tracefs)$'

Banderas de configuración comunes:

# Cambiar dirección y puerto de escucha
--web.listen-address=:9100

# Especificar qué recolectores habilitar
--collector.systemd
--collector.processes

# Deshabilitar recolectores específicos
--no-collector.hwmon
--no-collector.nfs

# Establecer directorio del recolector de archivos de texto
--collector.textfile.directory=/var/lib/node_exporter/textfile_collector

# Establecer duración máxima de solicitud
--web.max-requests=40

# Habilitar TLS
--web.config.file=/etc/node_exporter/web-config.yml

Recargar y reiniciar:

sudo systemctl daemon-reload
sudo systemctl restart node_exporter
sudo systemctl status node_exporter

Habilitar Recolectores Específicos

Ver recolectores disponibles:

/usr/local/bin/node_exporter --help | grep collector

Habilitar recolector systemd (deshabilitado por defecto):

# Editar archivo de servicio
sudo nano /etc/systemd/system/node_exporter.service

# Agregar a ExecStart
--collector.systemd

# Recargar y reiniciar
sudo systemctl daemon-reload
sudo systemctl restart node_exporter

Habilitar recolector de procesos:

# Agregar a ExecStart
--collector.processes

sudo systemctl daemon-reload
sudo systemctl restart node_exporter

Recolector de Archivos de Texto para Métricas Personalizadas

El recolector de archivos de texto te permite exponer métricas personalizadas escribiéndolas en archivos.

Configurar recolector de archivos de texto:

# Crear directorio para recolector de archivos de texto
sudo mkdir -p /var/lib/node_exporter/textfile_collector
sudo chown node_exporter:node_exporter /var/lib/node_exporter/textfile_collector

# Habilitar en configuración del servicio
sudo nano /etc/systemd/system/node_exporter.service

Agregar a ExecStart:

--collector.textfile.directory=/var/lib/node_exporter/textfile_collector

Crear script de métricas personalizadas:

#!/bin/bash
# /usr/local/bin/custom_metrics.sh

OUTPUT_FILE="/var/lib/node_exporter/textfile_collector/custom_metrics.prom"

{
    # Métrica personalizada: cantidad de usuarios conectados
    USER_COUNT=$(who | wc -l)
    echo "# HELP logged_in_users Número de usuarios conectados"
    echo "# TYPE logged_in_users gauge"
    echo "logged_in_users $USER_COUNT"

    # Métrica personalizada: intentos de inicio de sesión fallidos
    FAILED_LOGINS=$(grep "Failed password" /var/log/auth.log 2>/dev/null | wc -l)
    echo "# HELP failed_login_attempts Total de intentos de inicio de sesión fallidos"
    echo "# TYPE failed_login_attempts counter"
    echo "failed_login_attempts $FAILED_LOGINS"

    # Métrica personalizada: procesos en ejecución
    PROCESS_COUNT=$(ps aux | wc -l)
    echo "# HELP total_processes Número total de procesos"
    echo "# TYPE total_processes gauge"
    echo "total_processes $PROCESS_COUNT"
} > "$OUTPUT_FILE.$$"

# Movimiento atómico para evitar lecturas parciales
mv "$OUTPUT_FILE.$$" "$OUTPUT_FILE"

Hacer ejecutable y programar:

sudo chmod +x /usr/local/bin/custom_metrics.sh

# Agregar a crontab
sudo crontab -e

# Ejecutar cada 5 minutos
*/5 * * * * /usr/local/bin/custom_metrics.sh

Reiniciar Node Exporter:

sudo systemctl daemon-reload
sudo systemctl restart node_exporter

Accediendo a Métricas

Ver Endpoint de Métricas

# Ver todas las métricas
curl http://localhost:9100/metrics

# Filtrar métricas específicas
curl http://localhost:9100/metrics | grep node_cpu

# Ver métricas del sistema de archivos
curl http://localhost:9100/metrics | grep node_filesystem

# Ver métricas de memoria
curl http://localhost:9100/metrics | grep node_memory

# Verificar métricas del recolector de archivos de texto
curl http://localhost:9100/metrics | grep custom_

Entendiendo el Formato de Métricas

Las métricas se exponen en formato de texto de Prometheus:

# HELP node_cpu_seconds_total Segundos que las CPUs pasaron en cada modo.
# TYPE node_cpu_seconds_total counter
node_cpu_seconds_total{cpu="0",mode="idle"} 123456.78
node_cpu_seconds_total{cpu="0",mode="system"} 1234.56
node_cpu_seconds_total{cpu="0",mode="user"} 2345.67

Componentes:

• # HELP: Descripción de la métrica
• # TYPE: Tipo de métrica (counter, gauge, histogram, summary)
• Nombre de métrica: node_cpu_seconds_total
• Etiquetas: {cpu="0",mode="idle"}
• Valor: 123456.78

Probando Recopilación de Métricas

# Script de prueba para verificar métricas
cat > /tmp/test_metrics.sh <<'EOF'
#!/bin/bash

echo "Probando Métricas de Node Exporter..."
echo ""

# Probar conexión
if curl -s http://localhost:9100/metrics > /dev/null; then
    echo "✓ Node Exporter es accesible"
else
    echo "✗ Node Exporter no es accesible"
    exit 1
fi

# Contar métricas totales
METRIC_COUNT=$(curl -s http://localhost:9100/metrics | grep -c "^node_")
echo "✓ Total de métricas: $METRIC_COUNT"

# Verificar métricas de CPU
if curl -s http://localhost:9100/metrics | grep -q "node_cpu_seconds_total"; then
    echo "✓ Métricas de CPU disponibles"
fi

# Verificar métricas de memoria
if curl -s http://localhost:9100/metrics | grep -q "node_memory_MemTotal_bytes"; then
    echo "✓ Métricas de memoria disponibles"
fi

# Verificar métricas de disco
if curl -s http://localhost:9100/metrics | grep -q "node_disk_io_time_seconds_total"; then
    echo "✓ Métricas de disco disponibles"
fi

# Verificar métricas del sistema de archivos
if curl -s http://localhost:9100/metrics | grep -q "node_filesystem_avail_bytes"; then
    echo "✓ Métricas del sistema de archivos disponibles"
fi

# Verificar métricas de red
if curl -s http://localhost:9100/metrics | grep -q "node_network_receive_bytes_total"; then
    echo "✓ Métricas de red disponibles"
fi

echo ""
echo "¡Node Exporter está funcionando correctamente!"
EOF

chmod +x /tmp/test_metrics.sh
/tmp/test_metrics.sh

Configurando Prometheus para Recopilar de Node Exporter

Agregar Configuración de Recopilación

Editar configuración de Prometheus:

sudo nano /etc/prometheus/prometheus.yml

Agregar trabajo de recopilación:

scrape_configs:
  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']
        labels:
          instance: 'server1'
          environment: 'production'

Múltiples servidores:

scrape_configs:
  - job_name: 'node_exporter'
    static_configs:
      - targets:
          - 'server1.example.com:9100'
          - 'server2.example.com:9100'
          - 'server3.example.com:9100'
        labels:
          environment: 'production'

Con descubrimiento de servicios (basado en archivos):

scrape_configs:
  - job_name: 'node_exporter'
    file_sd_configs:
      - files:
          - '/etc/prometheus/targets/node_exporter_*.yml'
        refresh_interval: 5m

Crear archivo de objetivos:

sudo mkdir -p /etc/prometheus/targets
sudo nano /etc/prometheus/targets/node_exporter_prod.yml

- targets:
    - 'server1.example.com:9100'
    - 'server2.example.com:9100'
  labels:
    environment: 'production'
    region: 'us-east'

- targets:
    - 'server3.example.com:9100'
  labels:
    environment: 'production'
    region: 'us-west'

Recargar Prometheus:

# Verificar configuración
promtool check config /etc/prometheus/prometheus.yml

# Recargar Prometheus
sudo systemctl reload prometheus

# O enviar SIGHUP
sudo killall -HUP prometheus

Asegurando Node Exporter

Configuración del Firewall

Usando UFW (Ubuntu/Debian):

# Permitir desde servidor Prometheus específico
sudo ufw allow from 192.168.1.100 to any port 9100

# Permitir desde subred
sudo ufw allow from 192.168.1.0/24 to any port 9100

# Verificar reglas
sudo ufw status

Usando firewalld (CentOS/Rocky Linux):

# Agregar regla enriquecida para IP específica
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.100" port port="9100" protocol="tcp" accept'

# Agregar regla enriquecida para subred
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port port="9100" protocol="tcp" accept'

# Recargar firewall
sudo firewall-cmd --reload

# Listar reglas
sudo firewall-cmd --list-all

Usando iptables:

# Permitir desde IP específica
sudo iptables -A INPUT -p tcp -s 192.168.1.100 --dport 9100 -j ACCEPT

# Permitir desde subred
sudo iptables -A INPUT -p tcp -s 192.168.1.0/24 --dport 9100 -j ACCEPT

# Descartar todas las otras conexiones al puerto 9100
sudo iptables -A INPUT -p tcp --dport 9100 -j DROP

# Guardar reglas
sudo netfilter-persistent save

Configuración TLS/HTTPS

Crear certificados TLS:

# Crear directorio para certificados
sudo mkdir -p /etc/node_exporter

# Generar certificado auto-firmado (o usar Let's Encrypt)
sudo openssl req -new -newkey rsa:2048 -days 365 -nodes -x509 \
    -keyout /etc/node_exporter/node_exporter.key \
    -out /etc/node_exporter/node_exporter.crt \
    -subj "/CN=node-exporter"

# Establecer permisos
sudo chown -R node_exporter:node_exporter /etc/node_exporter
sudo chmod 400 /etc/node_exporter/node_exporter.key

Crear archivo de configuración web:

sudo nano /etc/node_exporter/web-config.yml

tls_server_config:
  cert_file: /etc/node_exporter/node_exporter.crt
  key_file: /etc/node_exporter/node_exporter.key

Actualizar servicio systemd:

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

[Service]
ExecStart=/usr/local/bin/node_exporter \
  --web.config.file=/etc/node_exporter/web-config.yml

sudo systemctl daemon-reload
sudo systemctl restart node_exporter

Probar endpoint HTTPS:

curl -k https://localhost:9100/metrics

Autenticación Básica

Crear archivo de contraseña:

# Instalar htpasswd
sudo apt install apache2-utils -y  # Ubuntu/Debian
sudo yum install httpd-tools -y    # CentOS/Rocky

# Generar hash de contraseña
htpasswd -nBC 12 "" | tr -d ':\n'
# Ingresa contraseña cuando se solicite
# Copia la salida del hash

Actualizar configuración web:

sudo nano /etc/node_exporter/web-config.yml

tls_server_config:
  cert_file: /etc/node_exporter/node_exporter.crt
  key_file: /etc/node_exporter/node_exporter.key

basic_auth_users:
  prometheus: $2y$12$HASH_FROM_HTPASSWD_COMMAND

sudo systemctl restart node_exporter

Probar autenticación:

# Sin autenticación (debería fallar)
curl -k https://localhost:9100/metrics

# Con autenticación (debería tener éxito)
curl -k -u prometheus:password https://localhost:9100/metrics

Actualizar configuración de Prometheus:

scrape_configs:
  - job_name: 'node_exporter'
    scheme: https
    tls_config:
      insecure_skip_verify: true
    basic_auth:
      username: 'prometheus'
      password: 'password'
    static_configs:
      - targets: ['localhost:9100']

Monitoreo y Alertas

Reglas de Alerta de Prometheus

Crear archivo de reglas de alerta:

sudo nano /etc/prometheus/rules/node_exporter_alerts.yml

groups:
  - name: node_exporter_alerts
    interval: 30s
    rules:
      # Alertas de CPU
      - alert: HighCPUUsage
        expr: (100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Alto uso de CPU en {{ $labels.instance }}"
          description: "El uso de CPU está por encima del 80% (valor actual: {{ $value }}%)"

      # Alertas de memoria
      - alert: HighMemoryUsage
        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Alto uso de memoria en {{ $labels.instance }}"
          description: "El uso de memoria está por encima del 85% (valor actual: {{ $value }}%)"

      # Alertas de espacio en disco
      - alert: LowDiskSpace
        expr: (node_filesystem_avail_bytes{fstype!="tmpfs"} / node_filesystem_size_bytes{fstype!="tmpfs"}) * 100 < 15
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Poco espacio en disco en {{ $labels.instance }}:{{ $labels.mountpoint }}"
          description: "El espacio en disco está por debajo del 15% (valor actual: {{ $value }}%)"

      # Alerta de nodo caído
      - alert: NodeDown
        expr: up{job="node_exporter"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Node Exporter caído en {{ $labels.instance }}"
          description: "Node Exporter ha estado caído durante más de 1 minuto"

      # Promedio de carga alto
      - alert: HighLoadAverage
        expr: node_load15 / count without (cpu, mode) (node_cpu_seconds_total{mode="system"}) > 2
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Promedio de carga alto en {{ $labels.instance }}"
          description: "El promedio de carga está por encima de 2.0 por CPU (valor actual: {{ $value }})"

Incluir reglas en Prometheus:

sudo nano /etc/prometheus/prometheus.yml

rule_files:
  - "/etc/prometheus/rules/node_exporter_alerts.yml"

# Validar configuración
promtool check config /etc/prometheus/prometheus.yml

# Recargar Prometheus
sudo systemctl reload prometheus

Solución de Problemas

Problemas Comunes

Problema 1: Node Exporter no inicia

# Verificar estado del servicio
sudo systemctl status node_exporter

# Ver registros
sudo journalctl -u node_exporter -n 50

# Verificar si el binario existe
ls -l /usr/local/bin/node_exporter

# Verificar permisos
ls -l /usr/local/bin/node_exporter
# Debería ser propiedad del usuario node_exporter

# Probar inicio manual
sudo -u node_exporter /usr/local/bin/node_exporter

Problema 2: Endpoint de métricas no accesible

# Verificar si el servicio está escuchando
sudo ss -tlnp | grep 9100

# Probar conexión local
curl http://localhost:9100/metrics

# Verificar reglas del firewall
sudo iptables -L -n | grep 9100
sudo ufw status

# Verificar dirección de escucha
ps aux | grep node_exporter

Problema 3: Métricas faltantes

# Verificar recolectores habilitados
curl http://localhost:9100/metrics | grep "# HELP" | wc -l

# Verificar que el recolector específico esté habilitado
ps aux | grep node_exporter | grep collector

# Verificar errores en registros
sudo journalctl -u node_exporter | grep -i error

Problema 4: Prometheus no está recopilando

# Verificar objetivos de Prometheus
# Visitar: http://prometheus-server:9090/targets

# Verificar configuración de recopilación
cat /etc/prometheus/prometheus.yml | grep -A 5 node_exporter

# Verificar registros de Prometheus
sudo journalctl -u prometheus | grep node_exporter

# Probar conectividad desde servidor Prometheus
curl http://node-exporter-host:9100/metrics

Conclusión

Node Exporter es un componente esencial para monitorear servidores Linux con Prometheus, proporcionando métricas integrales del sistema con sobrecarga mínima. Siguiendo esta guía, has aprendido cómo instalar, configurar, asegurar e integrar Node Exporter en tu infraestructura de monitoreo.

Puntos clave:

1. Monitoreo ligero - Node Exporter agrega sobrecarga mínima mientras proporciona métricas extensas
2. Configuración flexible - Habilita solo los recolectores que necesitas para tu caso de uso
3. Métricas personalizadas - Usa el recolector de archivos de texto para exponer métricas específicas de aplicaciones
4. Seguridad - Implementa TLS, autenticación y reglas de firewall para proteger el endpoint de métricas
5. Integración - Se integra perfectamente con Prometheus para alertas y visualización

Mejores prácticas para despliegue en producción:

• Usa systemd para gestión confiable del servicio
• Implementa reglas de firewall para restringir el acceso
• Habilita TLS y autenticación básica para seguridad
• Configura reglas de alerta apropiadas en Prometheus
• Usa el recolector de archivos de texto para métricas personalizadas de aplicaciones
• Monitorea el propio Node Exporter para asegurar la recopilación de métricas
• Documenta tu configuración de recolectores y métricas personalizadas
• Actualiza regularmente a la última versión estable

Node Exporter, combinado con Prometheus y Grafana, forma un potente stack de monitoreo que escala desde servidores únicos hasta grandes sistemas distribuidos. Las métricas recopiladas por Node Exporter proporcionan la base para comprender el rendimiento del sistema, planificación de capacidad y detección proactiva de problemas en entornos de infraestructura modernos.