--- title: "Cómo instalar y configurar Prometheus en Ubuntu 24.04" description: "Instala Prometheus 3 en Ubuntu 24.04 como servicio systemd, recoge métricas con Node Exporter, fija la retención, protege el acceso y consulta con PromQL." category: "Stack de Observabilidad" language: es source: https://cubepath.com/es/docs/stack-de-observabilidad/instalacion-y-configuracion-de-prometheus updated: 2026-09-25 --- # 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: ```bash 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: ```bash 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: ```bash 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: ```bash sha256sum --ignore-missing -c sha256sums.txt ``` ```output 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`: ```bash 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: ```bash prometheus --version ``` ```output 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: ```bash sudo nano /etc/prometheus/prometheus.yml ``` ```yaml 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: ```bash promtool check config /etc/prometheus/prometheus.yml ``` ```output 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: ```bash sudo nano /etc/systemd/system/prometheus.service ``` ```ini [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: ```bash sudo systemctl daemon-reload sudo systemctl enable --now prometheus ``` Comprueba que está activo: ```bash sudo systemctl status prometheus ``` ```output ● 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: ```bash curl -s http://localhost:9090/-/ready ``` ```output 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: ```bash sudo ufw allow from your_admin_ip to any port 9090 proto tcp sudo ufw status ``` ```output 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`: ```bash 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: ```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 Restart=on-failure [Install] WantedBy=multi-user.target ``` Arráncalo y comprueba que publica métricas: ```bash sudo systemctl daemon-reload sudo systemctl enable --now node_exporter curl -s http://localhost:9100/metrics | grep '^node_load1' ``` ```output 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`: ```bash sudo nano /etc/prometheus/prometheus.yml ``` ```yaml 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: ```bash 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`): ```bash curl -s http://localhost:9090/api/v1/targets | jq -r '.data.activeTargets[] | "\(.labels.job) \(.health)"' ``` ```output 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): ```promql up ``` Memoria disponible en GB. Las métricas se pueden combinar con operaciones aritméticas: ```promql 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: ```promql 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: ```promql 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: ```promql 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): ```bash sudo apt install apache2-utils htpasswd -nBC 10 "" | tr -d ':\n'; echo ``` ```output 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: ```bash sudo nano /etc/prometheus/web.yml ``` ```yaml basic_auth_users: admin: "$2y$10$Vq7bQ0Xn3rK1c9mZ8Hh2UeQ2m1c7rY6pT0aVbF3sL5dW9xN4kJ8eG" ``` Valídalo: ```bash promtool check web-config /etc/prometheus/web.yml ``` ```output /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: ```bash 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`: ```yaml - 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: ```bash sudo nano /etc/systemd/system/prometheus.service ``` ```ini 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: ```bash sudo systemctl daemon-reload sudo systemctl restart prometheus ``` Comprueba que sin credenciales recibes un `401` y con ellas la API responde: ```bash 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)"' ``` ```output 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: ```bash 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: ```bash 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.