Cómo instalar y configurar Prometheus en Ubuntu 24.04

Prometheus es un sistema de monitorización de código abierto que recoge métricas de sus objetivos a intervalos regulares (modelo pull), las guarda en una base de datos de series temporales y permite consultarlas con el lenguaje PromQL. En este tutorial instalarás Prometheus 3 en Ubuntu 24.04 desde los binarios oficiales, lo ejecutarás como servicio systemd con un usuario sin privilegios, añadirás Node Exporter para obtener métricas del sistema, configurarás la retención, limitarás el acceso con UFW y autenticación básica, y harás tus primeras consultas.

Requisitos previos

Para seguir esta guía necesitas:

• Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 2 GB de RAM y espacio en disco suficiente para las métricas (unos pocos GB bastan para monitorizar decenas de servidores durante 30 días).
• Un usuario no root con privilegios sudo.
• UFW activo con el acceso SSH permitido (sudo ufw allow OpenSSH antes de sudo ufw enable).
• La dirección IP pública desde la que accederás a la interfaz web, que en esta guía se llama your_admin_ip.

Ubuntu 24.04 incluye un paquete prometheus en sus repositorios, pero es de la rama 2.x. Esta guía usa los binarios oficiales para instalar la versión 3 actual.

Paso 1: Crear el usuario y los directorios

Prometheus no necesita privilegios de root. Crea un usuario de sistema sin shell ni directorio personal para ejecutarlo:

sudo useradd --system --no-create-home --shell /usr/sbin/nologin prometheus

Crea el directorio de configuración y el de datos, y asigna este último al nuevo usuario:

sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

La configuración queda como propiedad de root: Prometheus solo necesita leerla.

Paso 2: Descargar e instalar Prometheus

Consulta la última versión en la página de releases de prometheus/prometheus en GitHub y ajusta la variable si hay una más reciente. Descarga el archivo para linux-amd64 junto con la lista de sumas de verificación:

cd /tmp
PROM_VERSION=3.15.0
curl -LO "https://github.com/prometheus/prometheus/releases/download/v${PROM_VERSION}/prometheus-${PROM_VERSION}.linux-amd64.tar.gz"
curl -LO "https://github.com/prometheus/prometheus/releases/download/v${PROM_VERSION}/sha256sums.txt"

Comprueba que la descarga no está corrupta. --ignore-missing hace que solo se verifiquen los archivos que has descargado:

sha256sum --ignore-missing -c sha256sums.txt

prometheus-3.15.0.linux-amd64.tar.gz: OK

Descomprime el archivo y copia los dos binarios, prometheus y promtool, a /usr/local/bin, y la configuración de ejemplo a /etc/prometheus:

tar xzf "prometheus-${PROM_VERSION}.linux-amd64.tar.gz"
sudo install -m 0755 "prometheus-${PROM_VERSION}.linux-amd64/prometheus" "prometheus-${PROM_VERSION}.linux-amd64/promtool" /usr/local/bin/
sudo cp "prometheus-${PROM_VERSION}.linux-amd64/prometheus.yml" /etc/prometheus/

Verifica la instalación:

prometheus --version

prometheus, version 3.15.0 (branch: HEAD, revision: 4d1e0a5c2b8f)
  build user:       root@a1b2c3d4e5f6
  go version:       go1.25.1
  platform:         linux/amd64

En servidores arm64 descarga el archivo linux-arm64 en lugar de linux-amd64.

Paso 3: Configurar Prometheus

Toda la configuración está en /etc/prometheus/prometheus.yml. Sustituye el archivo de ejemplo por una configuración mínima que solo se monitoriza a sí misma:

sudo nano /etc/prometheus/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

• scrape_interval es cada cuánto se consultan los objetivos. 15 segundos es un buen punto de partida.
• evaluation_interval es cada cuánto se evalúan las reglas de alertas y de grabación.
• Cada entrada de scrape_configs es un job: un grupo de objetivos del mismo tipo. Prometheus añade a cada serie las etiquetas job e instance.

Valida la sintaxis antes de arrancar el servicio. promtool detecta errores de indentación y claves desconocidas:

promtool check config /etc/prometheus/prometheus.yml

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

Paso 4: Crear el servicio systemd

Crea la unidad de systemd para que Prometheus arranque con el sistema y se reinicie si falla:

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

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus \
  --storage.tsdb.retention.time=30d \
  --web.listen-address=0.0.0.0:9090
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure

[Install]
WantedBy=multi-user.target

--storage.tsdb.retention.time=30d borra automáticamente los datos de más de 30 días. Si prefieres limitar por espacio en disco, añade también --storage.tsdb.retention.size=20GB; cuando se definen ambas, se aplica la que se alcance antes. ExecReload permite recargar la configuración con systemctl reload sin perder datos ni reiniciar el proceso.

Recarga systemd, habilita el servicio y arráncalo:

sudo systemctl daemon-reload
sudo systemctl enable --now prometheus

Comprueba que está activo:

sudo systemctl status prometheus

● prometheus.service - Prometheus
     Loaded: loaded (/etc/systemd/system/prometheus.service; enabled; preset: enabled)
     Active: active (running) since Fri 2026-09-25 10:12:04 UTC; 5s ago
   Main PID: 2841 (prometheus)

Y que responde a sus comprobaciones de salud:

curl -s http://localhost:9090/-/ready

Prometheus Server is Ready.

Si el servicio no arranca, revisa el motivo con sudo journalctl -u prometheus -n 50.

Paso 5: Permitir el acceso a la interfaz web

Prometheus escucha en el puerto 9090. No lo abras a todo Internet: permite solo tu IP de administración. Sustituye your_admin_ip por la tuya:

sudo ufw allow from your_admin_ip to any port 9090 proto tcp
sudo ufw status

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
9090/tcp                   ALLOW       your_admin_ip

Abre http://your_server_ip:9090 en el navegador. En Status, Target health deberías ver el job prometheus con estado UP.

Consejo

si no tienes una IP fija, no abras el puerto y accede a través de un túnel SSH: ssh -L 9090:localhost:9090 your_user@your_server_ip, y luego visita http://localhost:9090 en tu equipo.

Paso 6: Añadir Node Exporter para métricas del sistema

Prometheus no mide por sí mismo el uso de CPU, memoria o disco del servidor: eso lo hace un exporter. Node Exporter es el exporter oficial para métricas de hosts Linux y expone sus datos en el puerto 9100.

Crea su usuario de sistema y descarga la última versión desde la página de releases de prometheus/node_exporter:

sudo useradd --system --no-create-home --shell /usr/sbin/nologin node_exporter
cd /tmp
NE_VERSION=1.12.1
curl -LO "https://github.com/prometheus/node_exporter/releases/download/v${NE_VERSION}/node_exporter-${NE_VERSION}.linux-amd64.tar.gz"
tar xzf "node_exporter-${NE_VERSION}.linux-amd64.tar.gz"
sudo install -m 0755 "node_exporter-${NE_VERSION}.linux-amd64/node_exporter" /usr/local/bin/

Crea su unidad de systemd:

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

[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
Restart=on-failure

[Install]
WantedBy=multi-user.target

Arráncalo y comprueba que publica métricas:

sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter
curl -s http://localhost:9100/metrics | grep '^node_load1'

node_load1 0.08

Como Prometheus y Node Exporter están en el mismo servidor, no hace falta abrir el puerto 9100 en UFW. Añade el nuevo job al final de scrape_configs:

sudo nano /etc/prometheus/prometheus.yml

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "node"
    static_configs:
      - targets: ["localhost:9100"]
        labels:
          env: "production"

Las etiquetas que añades en labels se guardan en todas las series de ese objetivo y sirven después para filtrar. Valida y recarga la configuración:

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

Comprueba que los dos objetivos están activos consultando la API. Instala antes jq si no lo tienes (sudo apt install jq):

curl -s http://localhost:9090/api/v1/targets | jq -r '.data.activeTargets[] | "\(.labels.job) \(.health)"'

node up
prometheus up

Para monitorizar otros servidores, instala Node Exporter en cada uno siguiendo los mismos pasos, permite en su firewall el puerto 9100 solo desde la IP de Prometheus (sudo ufw allow from your_prometheus_ip to any port 9100 proto tcp) y añade su IP:9100 a la lista targets.

Paso 7: Consultar métricas con PromQL

Abre la interfaz web, ve a Query y prueba estas consultas. Cada una muestra un concepto básico de PromQL.

Qué objetivos están disponibles (1) y cuáles no (0):

up

Memoria disponible en GB. Las métricas se pueden combinar con operaciones aritméticas:

node_memory_MemAvailable_bytes / 1024 / 1024 / 1024

Uso de CPU en porcentaje por servidor. rate() calcula la velocidad por segundo de un contador en la ventana indicada, y avg by (instance) agrupa todos los núcleos:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Porcentaje de disco usado en la raíz. El filtro entre llaves selecciona series por etiqueta:

100 * (1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"})

Tráfico de red recibido en bits por segundo, excluyendo la interfaz de loopback:

rate(node_network_receive_bytes_total{device!="lo"}[5m]) * 8

Cambia a la pestaña Graph para ver cualquiera de ellas en el tiempo. Para paneles permanentes, lo habitual es conectar Grafana a Prometheus.

Paso 8: Proteger la interfaz con autenticación básica

Prometheus no tiene usuarios por defecto: cualquiera que llegue al puerto 9090 puede consultar todas las métricas. Además de filtrar por IP, puedes exigir usuario y contraseña con el archivo de configuración web nativo, que usa contraseñas cifradas con bcrypt.

Instala htpasswd y genera el hash de la contraseña que elijas (te la pedirá dos veces):

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

New password:
Re-type new password:
$2y$10$Vq7bQ0Xn3rK1c9mZ8Hh2UeQ2m1c7rY6pT0aVbF3sL5dW9xN4kJ8eG

Crea el archivo de configuración web con el usuario admin y el hash que acabas de obtener:

sudo nano /etc/prometheus/web.yml

basic_auth_users:
  admin: "$2y$10$Vq7bQ0Xn3rK1c9mZ8Hh2UeQ2m1c7rY6pT0aVbF3sL5dW9xN4kJ8eG"

Valídalo:

promtool check web-config /etc/prometheus/web.yml

/etc/prometheus/web.yml SUCCESS

Como Prometheus se monitoriza a sí mismo, el job prometheus también tendrá que autenticarse. Guarda la contraseña en claro en un archivo que solo pueda leer el usuario prometheus, sustituyendo your_strong_password por la contraseña que acabas de cifrar:

echo -n 'your_strong_password' | sudo tee /etc/prometheus/self_password > /dev/null
sudo chown prometheus:prometheus /etc/prometheus/self_password
sudo chmod 600 /etc/prometheus/self_password

Añade las credenciales al job prometheus en /etc/prometheus/prometheus.yml:

  - job_name: "prometheus"
    basic_auth:
      username: "admin"
      password_file: "/etc/prometheus/self_password"
    static_configs:
      - targets: ["localhost:9090"]

Por último, añade la opción --web.config.file a la unidad de systemd:

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

ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --web.config.file=/etc/prometheus/web.yml \
  --storage.tsdb.path=/var/lib/prometheus \
  --storage.tsdb.retention.time=30d \
  --web.listen-address=0.0.0.0:9090

Aplica los cambios con un reinicio, porque las opciones de línea de comandos no se recargan:

sudo systemctl daemon-reload
sudo systemctl restart prometheus

Comprueba que sin credenciales recibes un 401 y con ellas la API responde:

curl -s -o /dev/null -w '%{http_code}\n' http://localhost:9090/api/v1/targets
curl -s -u admin http://localhost:9090/api/v1/targets | jq -r '.data.activeTargets[] | "\(.labels.job) \(.health)"'

401
Enter host password for user 'admin':
node up
prometheus up

La autenticación básica viaja en claro sobre HTTP. Si accedes desde fuera de tu red, combínala con el filtrado por IP o un túnel SSH, o publica Prometheus detrás de un proxy inverso con TLS.

Solución de problemas

El servicio no arranca tras un cambio. Casi siempre es un error de YAML. Valida y lee el log:

promtool check config /etc/prometheus/prometheus.yml
sudo journalctl -u prometheus -n 50 --no-pager

Un objetivo aparece como DOWN. En Status, Target health se muestra el error concreto. connection refused indica que el exporter no está en marcha o escucha en otro puerto; context deadline exceeded suele ser un firewall que bloquea el puerto entre Prometheus y el objetivo. Pruébalo desde el servidor de Prometheus con curl -s http://target_ip:9100/metrics | head.

El disco se llena. Comprueba cuánto ocupa la base de datos y ajusta la retención:

sudo du -sh /var/lib/prometheus

Reduce --storage.tsdb.retention.time o añade --storage.tsdb.retention.size en la unidad de systemd y reinicia el servicio. Prometheus borra los bloques antiguos por sí mismo al aplicar la nueva retención.

Conclusión

Tienes Prometheus 3 funcionando en Ubuntu 24.04 como servicio systemd, recogiendo métricas propias y del sistema con Node Exporter, con retención de 30 días y acceso restringido por IP y contraseña. Como siguientes pasos puedes instalar Grafana y conectarlo a Prometheus como fuente de datos para crear paneles, añadir Alertmanager y reglas de alerta para recibir avisos cuando un servidor caiga o se quede sin disco, e incorporar otros exporters como el de MySQL, PostgreSQL o Nginx para monitorizar tus servicios.