---
title: "Cómo instalar Node Exporter en Ubuntu 24.04 para Prometheus"
description: "Instala Node Exporter en Ubuntu 24.04 como servicio systemd, protégelo con TLS y autenticación básica, y añádelo a Prometheus con reglas de alerta básicas."
category: "Monitoring Logging"
language: es
source: https://cubepath.com/es/docs/monitoring-logging/instalacion-de-node-exporter-para-prometheus
updated: 2026-09-25
---

# Cómo instalar Node Exporter en Ubuntu 24.04 para Prometheus

Node Exporter es el exportador oficial de Prometheus para métricas del sistema: CPU, memoria, disco, sistemas de archivos, red y carga. Expone esas métricas por HTTP en el puerto 9100 para que un servidor Prometheus las recoja periódicamente. En este tutorial instalarás la última versión de Node Exporter en Ubuntu 24.04 como servicio systemd, lo protegerás con TLS y usuario y contraseña, y lo añadirás a Prometheus junto con un par de reglas de alerta.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS que quieras monitorizar, por ejemplo un VPS de CubePath, con un usuario no root con privilegios `sudo`.
- Un servidor Prometheus ya instalado que pueda llegar a este servidor por red (en la misma máquina o en otra). En los ejemplos, su IP es `prometheus_server_ip` y su configuración está en `/etc/prometheus/prometheus.yml`.
- La IP del servidor monitorizado, que aparece como `your_server_ip`.

## Paso 1: Crear un usuario de sistema

Node Exporter no necesita privilegios, así que se ejecutará con un usuario propio sin shell ni directorio personal:

```bash
sudo useradd --system --no-create-home --shell /usr/sbin/nologin node_exporter
```

Comprueba que existe:

```bash
id node_exporter
```

```output
uid=998(node_exporter) gid=998(node_exporter) groups=998(node_exporter)
```

## Paso 2: Descargar e instalar el binario

Ubuntu incluye el paquete `prometheus-node-exporter`, pero trae una versión antigua. El proyecto publica binarios estáticos en GitHub, que es la forma recomendada de tener una versión actual. Consulta la última versión en la [página de releases](https://github.com/prometheus/node_exporter/releases) y guárdala en una variable (en el momento de escribir esto es la 1.12.1). En servidores ARM, cambia `amd64` por `arm64`:

```bash
VERSION=1.12.1
ARCH=amd64
cd /tmp
curl -LO "https://github.com/prometheus/node_exporter/releases/download/v${VERSION}/node_exporter-${VERSION}.linux-${ARCH}.tar.gz"
curl -LO "https://github.com/prometheus/node_exporter/releases/download/v${VERSION}/sha256sums.txt"
```

Verifica la suma de comprobación antes de instalar nada:

```bash
sha256sum --check --ignore-missing sha256sums.txt
```

```output
node_exporter-1.12.1.linux-amd64.tar.gz: OK
```

Extrae el archivo e instala el binario en `/usr/local/bin`:

```bash
tar xzf "node_exporter-${VERSION}.linux-${ARCH}.tar.gz"
sudo install -m 0755 "node_exporter-${VERSION}.linux-${ARCH}/node_exporter" /usr/local/bin/
node_exporter --version
```

La primera línea de la salida muestra la versión instalada:

```output
node_exporter, version 1.12.1 (branch: HEAD, revision: ...)
```

Limpia los archivos temporales:

```bash
rm -rf /tmp/node_exporter-* /tmp/sha256sums.txt
```

## Paso 3: Crear el servicio systemd

Crea también el directorio del recolector `textfile`, que usarás más adelante para publicar métricas propias:

```bash
sudo install -d -o node_exporter -g node_exporter -m 0755 /var/lib/node_exporter/textfile_collector
```

Crea la unidad de systemd:

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

```ini
[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter \
    --web.listen-address=:9100 \
    --collector.systemd \
    --collector.textfile.directory=/var/lib/node_exporter/textfile_collector
Restart=on-failure
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=read-only

[Install]
WantedBy=multi-user.target
```

La mayoría de recolectores (CPU, memoria, disco, red, sistemas de archivos) vienen activados por defecto. `--collector.systemd` añade el estado de cada unidad de systemd, útil para alertar de servicios caídos. Las opciones `NoNewPrivileges` y `Protect*` limitan lo que el proceso puede tocar, ya que solo necesita leer.

Recarga systemd, habilita el servicio y arráncalo:

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter
systemctl status node_exporter --no-pager
```

```output
● node_exporter.service - Prometheus Node Exporter
     Loaded: loaded (/etc/systemd/system/node_exporter.service; enabled; preset: enabled)
     Active: active (running) since Fri 2026-09-25 10:40:12 UTC; 3s ago
   Main PID: 5120 (node_exporter)
```

Si no arranca, revisa el motivo con `journalctl -u node_exporter -n 50 --no-pager`.

## Paso 4: Comprobar las métricas

Pide el endpoint `/metrics` desde el propio servidor y filtra algunas métricas conocidas:

```bash
curl -s http://localhost:9100/metrics | grep -E '^node_(load1|memory_MemAvailable_bytes|filesystem_avail_bytes\{.*mountpoint="/")'
```

```output
node_filesystem_avail_bytes{device="/dev/vda1",device_error="",fstype="ext4",mountpoint="/"} 3.1784534016e+10
node_load1 0.08
node_memory_MemAvailable_bytes 1.702846464e+09
```

Cada línea es una serie: nombre de la métrica, etiquetas entre llaves y valor actual. Prometheus guardará estos valores cada vez que haga un scrape.

## Paso 5: Publicar métricas propias con el recolector textfile

El recolector `textfile` lee cualquier archivo `*.prom` del directorio configurado. Es la forma sencilla de exponer datos de tus propios scripts, por ejemplo la hora de la última copia de seguridad correcta. Añade al final de tu script de backup, tras comprobar que ha terminado bien:

```bash
DIR=/var/lib/node_exporter/textfile_collector
printf 'backup_last_success_timestamp_seconds %s\n' "$(date +%s)" > "$DIR/backup.prom.$$"
mv "$DIR/backup.prom.$$" "$DIR/backup.prom"
```

Escribir en un archivo temporal y renombrarlo después evita que Node Exporter lea un archivo a medio escribir. El script debe poder escribir en el directorio: ejecútalo como root o da permisos a su usuario.

Compruébalo:

```bash
curl -s http://localhost:9100/metrics | grep ^backup_
```

```output
backup_last_success_timestamp_seconds 1.790332812e+09
```

## Paso 6: Proteger Node Exporter con TLS y autenticación

Las métricas revelan información del servidor (versión del kernel, servicios, discos), así que no deben quedar abiertas a Internet. Node Exporter soporta TLS y autenticación básica mediante un archivo de configuración web.

### Generar un certificado

Crea un certificado autofirmado válido para la IP del servidor. Prometheus confiará en él de forma explícita:

```bash
sudo install -d -o root -g node_exporter -m 0750 /etc/node_exporter
sudo openssl req -x509 -newkey rsa:4096 -nodes -days 3650 \
  -keyout /etc/node_exporter/node_exporter.key \
  -out /etc/node_exporter/node_exporter.crt \
  -subj "/CN=your_server_ip" \
  -addext "subjectAltName=IP:your_server_ip"
sudo chgrp node_exporter /etc/node_exporter/node_exporter.key
sudo chmod 640 /etc/node_exporter/node_exporter.key
```

Si el servidor tiene nombre DNS, usa `DNS:your_domain` en `subjectAltName` y apunta Prometheus a ese nombre.

### Crear la contraseña

Node Exporter guarda las contraseñas como hash bcrypt. Instala `apache2-utils` y genera el hash de una contraseña robusta (te la pedirá dos veces):

```bash
sudo apt install apache2-utils
htpasswd -nBC 12 "" | tr -d ':\n'; echo
```

```output
New password:
Re-type new password:
$2y$12$Qx0p9...resto_del_hash
```

### Crear el archivo de configuración web

```bash
sudo nano /etc/node_exporter/web.yml
```

Pega el hash que has generado:

```yaml
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$Qx0p9...resto_del_hash
```

Ajusta los permisos y añade la opción `--web.config.file` al servicio:

```bash
sudo chgrp node_exporter /etc/node_exporter/web.yml
sudo chmod 640 /etc/node_exporter/web.yml
sudo nano /etc/systemd/system/node_exporter.service
```

```ini
ExecStart=/usr/local/bin/node_exporter \
    --web.listen-address=:9100 \
    --web.config.file=/etc/node_exporter/web.yml \
    --collector.systemd \
    --collector.textfile.directory=/var/lib/node_exporter/textfile_collector
```

Reinicia y prueba. Sin credenciales debes recibir un 401; con ellas, las métricas:

```bash
sudo systemctl daemon-reload
sudo systemctl restart node_exporter
curl -s -o /dev/null -w '%{http_code}\n' --cacert /etc/node_exporter/node_exporter.crt https://your_server_ip:9100/metrics
curl -s --cacert /etc/node_exporter/node_exporter.crt -u prometheus https://your_server_ip:9100/metrics | head -n 3
```

```output
401
Enter host password for user 'prometheus':
# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 2.1e-05
```

### Abrir el puerto solo al servidor Prometheus

Con UFW, permite el puerto 9100 solo desde la IP de Prometheus. Si UFW no está activo todavía, permite SSH antes de activarlo para no perder el acceso:

```bash
sudo ufw allow OpenSSH
sudo ufw allow from prometheus_server_ip to any port 9100 proto tcp
sudo ufw enable
sudo ufw status
```

```output
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
9100/tcp                   ALLOW       prometheus_server_ip
OpenSSH (v6)               ALLOW       Anywhere (v6)
```

## Paso 7: Añadir el objetivo en Prometheus

Los siguientes comandos se ejecutan **en el servidor Prometheus**. Copia allí el certificado del servidor monitorizado (por ejemplo con `scp`) a `/etc/prometheus/node_exporter.crt` y guarda la contraseña en un archivo que solo pueda leer Prometheus.

```bash
sudo nano /etc/prometheus/node_exporter.pass
```

Escribe en él solo la contraseña en texto plano (la misma que usaste con `htpasswd`), guarda y ajusta los permisos:

```bash
sudo chown prometheus:prometheus /etc/prometheus/node_exporter.pass
sudo chmod 600 /etc/prometheus/node_exporter.pass
```

Edita la configuración de Prometheus:

```bash
sudo nano /etc/prometheus/prometheus.yml
```

Añade un trabajo dentro de `scrape_configs`:

```yaml
scrape_configs:
  - job_name: "node"
    scheme: https
    tls_config:
      ca_file: /etc/prometheus/node_exporter.crt
    basic_auth:
      username: prometheus
      password_file: /etc/prometheus/node_exporter.pass
    static_configs:
      - targets: ["your_server_ip:9100"]
        labels:
          instance_name: "web01"
```

Valida la configuración y recarga Prometheus:

```bash
promtool check config /etc/prometheus/prometheus.yml
sudo systemctl reload prometheus
```

```output
Checking /etc/prometheus/prometheus.yml
 SUCCESS: /etc/prometheus/prometheus.yml is valid prometheus config file syntax
```

Comprueba el estado del objetivo con la API de Prometheus. `health` debe ser `up`:

```bash
curl -s 'http://localhost:9090/api/v1/targets?state=active' | grep -o '"health":"[a-z]*"'
```

```output
"health":"up"
```

También puedes abrir la interfaz web de Prometheus, ir a **Status > Target health** y lanzar la consulta `up{job="node"}`, que devuelve `1` cuando el scrape funciona.

## Paso 8: Añadir reglas de alerta

Con las métricas en Prometheus ya puedes definir alertas. Crea un archivo de reglas en el servidor Prometheus:

```bash
sudo mkdir -p /etc/prometheus/rules
sudo nano /etc/prometheus/rules/node.yml
```

```yaml
groups:
  - name: node
    rules:
      - alert: NodeDown
        expr: up{job="node"} == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.instance }} no responde"

      - alert: DiskAlmostFull
        expr: |
          node_filesystem_avail_bytes{fstype!~"tmpfs|overlay|squashfs"}
            / node_filesystem_size_bytes{fstype!~"tmpfs|overlay|squashfs"} < 0.10
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Menos del 10 % libre en {{ $labels.mountpoint }} de {{ $labels.instance }}"

      - alert: HighMemoryUsage
        expr: node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes < 0.10
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Menos del 10 % de memoria disponible en {{ $labels.instance }}"
```

Referencia el archivo en `prometheus.yml` (si aún no hay una sección `rule_files`, créala al nivel superior):

```yaml
rule_files:
  - /etc/prometheus/rules/*.yml
```

Valida las reglas y recarga:

```bash
promtool check rules /etc/prometheus/rules/node.yml
sudo systemctl reload prometheus
```

```output
Checking /etc/prometheus/rules/node.yml
  SUCCESS: 3 rules found
```

Las reglas aparecen en **Alerts** en la interfaz de Prometheus. Para recibir notificaciones por correo, Slack u otros canales necesitas Alertmanager.

## Solución de problemas

**El objetivo aparece como `down` con `connection refused` o `context deadline exceeded`.** El puerto no es accesible desde Prometheus. Comprueba que Node Exporter escucha (`sudo ss -tlnp | grep 9100`) y la regla de UFW para la IP de Prometheus.

**`x509: certificate is valid for ..., not ...`.** La dirección de `targets` no coincide con el `subjectAltName` del certificado. Regenera el certificado con la IP o el nombre que usa Prometheus.

**`server returned HTTP status 401 Unauthorized`.** La contraseña de `password_file` no coincide con el hash de `web.yml`. Vuelve a generar el hash y reinicia Node Exporter.

**No aparecen las métricas `node_systemd_*`.** El recolector necesita acceso a D-Bus; revisa `journalctl -u node_exporter` en busca de errores del recolector `systemd`.

## Conclusión

Node Exporter ya se ejecuta como servicio sin privilegios, expone las métricas solo por TLS con autenticación y únicamente al servidor Prometheus, que las recoge y evalúa reglas de alerta sobre ellas. Repite los pasos 1 a 6 en cada servidor que quieras monitorizar y añade su IP a `targets`.

Como siguientes pasos puedes instalar Grafana e importar el dashboard "Node Exporter Full" para visualizar las métricas, configurar Alertmanager para recibir las alertas, o automatizar la instalación en todos tus servidores con Ansible.