Instalación de Prometheus mediante binarios¶

Prometheus es el componente central del sistema de monitorización que se construirá durante este bloque.

En esta práctica se instalará Prometheus como un servicio de systemd, se configurará su almacenamiento local y se comprobará que responde correctamente mediante la interfaz web, la API HTTP y los endpoints de salud.

La instalación seguirá este recorrido:

Comprobación del sistema
        |
        v
Descarga del binario
        |
        v
Creación del usuario de servicio
        |
        v
Creación de directorios
        |
        v
Instalación de los binarios
        |
        v
Instalación de la configuración
        |
        v
Creación del servicio systemd
        |
        v
Inicio del servicio
        |
        v
Comprobaciones

Objetivos¶

Al finalizar esta práctica, el alumno podrá:

Identificar los requisitos necesarios para instalar Prometheus.
Consultar la arquitectura del sistema operativo.
Descargar una versión concreta de Prometheus.
Crear un usuario de servicio sin acceso interactivo.
Crear los directorios de configuración y almacenamiento.
Instalar los binarios de Prometheus y promtool.
Crear un fichero básico prometheus.yml.
Validar una configuración de Prometheus.
Crear una unidad de systemd.
Iniciar, detener y reiniciar Prometheus.
Habilitar Prometheus para que se inicie automáticamente.
Comprobar el puerto de escucha.
Consultar el endpoint de salud.
Consultar el endpoint de preparación.
Acceder a la interfaz web.
Consultar los registros del servicio.
Diagnosticar errores básicos de instalación y configuración.
Documentar las evidencias de la instalación.

Introducción¶

Prometheus puede instalarse mediante paquetes, contenedores o binarios precompilados.

En este laboratorio se utilizará el binario oficial distribuido como archivo comprimido. Este método permite:

Elegir una versión concreta.
Mantener separadas la aplicación, la configuración y los datos.
Comprender qué componentes forman la instalación.
Crear manualmente el servicio de systemd.
Practicar la administración de servicios Linux.

La instalación resultante tendrá esta estructura:

/usr/local/bin/
├── prometheus
└── promtool

/etc/prometheus/
├── prometheus.yml
├── consoles/
└── console_libraries/

/var/lib/prometheus/
└── Datos de series temporales

/etc/systemd/system/
└── prometheus.service

El servicio se ejecutará con el usuario:

prometheus

El puerto web habitual será:

La URL local será:

http://localhost:9090

Arquitectura de la instalación¶

+------------------------------------------------------+
| Servidor Ubuntu                                      |
|                                                      |
|  Usuario de servicio: prometheus                     |
|                                                      |
|  /usr/local/bin/prometheus                           |
|  /usr/local/bin/promtool                             |
|                                                      |
|  Configuración: /etc/prometheus/prometheus.yml       |
|  Datos:        /var/lib/prometheus                   |
|                                                      |
|  Servicio systemd: prometheus.service                |
|  Interfaz web:    http://localhost:9090              |
+------------------------------------------------------+

Directorios principales¶

Directorio	Función
`/usr/local/bin`	Binarios ejecutables
`/etc/prometheus`	Configuración y recursos web
`/var/lib/prometheus`	Datos almacenados por Prometheus
`/etc/systemd/system`	Unidad de servicio

Requisitos previos¶

Antes de comenzar, comprobar que se dispone de:

Ubuntu instalado.
Arquitectura compatible.
Usuario con permisos de sudo.
Conectividad a Internet.
Al menos 2 GB de memoria disponible.
Espacio libre suficiente.
Puerto 9090 disponible.
Hora del sistema sincronizada.

Comprobar la distribución¶

lsb_release -ds

También puede utilizarse:

cat /etc/os-release

Comprobar la arquitectura¶

uname -m

Arquitecturas habituales:

x86_64
aarch64
armv7l

Prometheus utiliza nombres de arquitectura diferentes para los paquetes:

Salida de `uname -m`	Arquitectura del paquete
`x86_64`	`amd64`
`aarch64`	`arm64`
`armv7l`	`armv7`

En esta práctica se utilizará principalmente amd64.

Comprobar permisos administrativos¶

sudo -v

Comprobar el espacio disponible¶

df -h /

Comprobar el puerto¶

sudo ss -lntp | grep ':9090' || true

Si no aparece ninguna salida, el puerto probablemente está disponible.

Comprobar la hora¶

timedatectl status

Comprobar la sincronización:

timedatectl show -p NTPSynchronized --value

Resultado esperado:

yes

Preparar las variables de instalación¶

Para evitar repetir valores, se definirán algunas variables.

Sustituye la versión de ejemplo por la versión autorizada para el laboratorio.

export PROMETHEUS_VERSION="3.5.0"
export PROMETHEUS_ARCH="amd64"
export PROMETHEUS_PLATFORM="linux-${PROMETHEUS_ARCH}"
export PROMETHEUS_PACKAGE="prometheus-${PROMETHEUS_VERSION}.${PROMETHEUS_PLATFORM}.tar.gz"
export PROMETHEUS_URL="https://github.com/prometheus/prometheus/releases/download/v${PROMETHEUS_VERSION}/${PROMETHEUS_PACKAGE}"
export PROMETHEUS_DIR="/tmp/prometheus-${PROMETHEUS_VERSION}.${PROMETHEUS_PLATFORM}"

Comprobar las variables:

echo "$PROMETHEUS_VERSION"
echo "$PROMETHEUS_PLATFORM"
echo "$PROMETHEUS_PACKAGE"
echo "$PROMETHEUS_URL"
echo "$PROMETHEUS_DIR"

Ejemplo:

$ echo "$PROMETHEUS_PACKAGE"
prometheus-3.5.0.linux-amd64.tar.gz

Comprobar la URL de descarga¶

curl -I "$PROMETHEUS_URL"

La respuesta debe indicar que el recurso existe. Si devuelve un error 404, revisa la versión, la arquitectura y el nombre del archivo.

Descargar el paquete¶

cd /tmp
curl -fLO "$PROMETHEUS_URL"

Comprobar que el archivo existe:

ls -lh "/tmp/$PROMETHEUS_PACKAGE"

Crear el usuario de servicio¶

Prometheus no debería ejecutarse con el usuario personal del alumno ni como root.

Crear el usuario de forma segura:

if ! getent passwd prometheus >/dev/null; then
  sudo useradd \
    --system \
    --no-create-home \
    --shell /usr/sbin/nologin \
    prometheus
fi

Comprobar la cuenta:

getent passwd prometheus

Ejemplo:

$ getent passwd prometheus
prometheus:x:995:995::/home/prometheus:/usr/sbin/nologin

Explicación de las opciones¶

Opción	Función
`--system`	Crea un usuario de sistema
`--no-create-home`	No crea un directorio personal
`--shell /usr/sbin/nologin`	Impide el inicio de sesión interactivo

Comprobar el identificador:

id prometheus

Resultado esperado:

uid=995(prometheus) gid=995(prometheus) groups=995(prometheus)

Comprobar el shell:

getent passwd prometheus | cut -d: -f7

Resultado esperado:

/usr/sbin/nologin

Crear los directorios¶

Crear el directorio de configuración:

sudo mkdir -p /etc/prometheus

Crear el directorio de datos:

sudo mkdir -p /var/lib/prometheus

Crear los directorios para las plantillas y las consolas:

sudo mkdir -p \
  /etc/prometheus/consoles \
  /etc/prometheus/console_libraries

Función de cada directorio¶

Directorio	Uso
`/etc/prometheus`	Configuración de Prometheus
`/etc/prometheus/consoles`	Consolas web
`/etc/prometheus/console_libraries`	Bibliotecas de las consolas
`/var/lib/prometheus`	Base de datos local de series temporales

Extraer el paquete¶

Extraer el archivo descargado:

cd /tmp
tar -xzf "$PROMETHEUS_PACKAGE"

Comprobar el directorio creado:

ls -ld "$PROMETHEUS_DIR"

Listar su contenido:

find "$PROMETHEUS_DIR" \
  -maxdepth 2 \
  -type f \
  -printf '%P\n'

El paquete contiene normalmente:

prometheus
promtool
prometheus.yml
consoles/
console_libraries/
LICENSE
NOTICE

Instalar los binarios¶

Instalar el binario de Prometheus:

sudo install \
  -m 0755 \
  "$PROMETHEUS_DIR/prometheus" \
  /usr/local/bin/prometheus

Instalar promtool:

sudo install \
  -m 0755 \
  "$PROMETHEUS_DIR/promtool" \
  /usr/local/bin/promtool

Comprobar las versiones:

prometheus --version

promtool --version

Ejemplo:

$ prometheus --version
prometheus, version 3.5.0
  branch: release-3.5
  revision: ...
  build user: ...
  build date: ...
  go version: ...
  platform: linux/amd64

Comprobar la ubicación de los binarios:

command -v prometheus
command -v promtool

Resultado esperado:

/usr/local/bin/prometheus
/usr/local/bin/promtool

Instalar los recursos de configuración¶

Copiar el fichero de configuración de ejemplo:

sudo install \
  -m 0644 \
  "$PROMETHEUS_DIR/prometheus.yml" \
  /etc/prometheus/prometheus.yml

Copiar las consolas:

sudo cp -r \
  "$PROMETHEUS_DIR/consoles/." \
  /etc/prometheus/consoles/

Copiar las bibliotecas:

sudo cp -r \
  "$PROMETHEUS_DIR/console_libraries/." \
  /etc/prometheus/console_libraries/

Comprobar el contenido:

sudo find /etc/prometheus -maxdepth 2 -type f

Crear una configuración inicial¶

Antes de conectar Node Exporter, se utilizará una configuración mínima.

Crear una copia de seguridad¶

sudo cp \
  /etc/prometheus/prometheus.yml \
  /etc/prometheus/prometheus.yml.orig

Crear la configuración¶

sudo tee /etc/prometheus/prometheus.yml > /dev/null <<'EOF'
---
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets:
          - localhost:9090
EOF

Mostrar el contenido:

sudo cat /etc/prometheus/prometheus.yml

La configuración será:

---
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets:
          - localhost:9090

Explicación de la configuración¶

Bloque `global`¶

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_interval: intervalo entre recopilaciones.
evaluation_interval: intervalo de evaluación de reglas.

Bloque `scrape_configs`¶

scrape_configs:

Contiene los trabajos de recopilación.

Propiedad `job_name`¶

job_name: prometheus

Identifica el trabajo de monitorización.

Propiedad `targets`¶

targets:
  - localhost:9090

Define el endpoint que Prometheus debe consultar.

Validar la configuración¶

Antes de iniciar el servicio, validar el fichero:

promtool check config /etc/prometheus/prometheus.yml

Resultado esperado:

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

El mensaje exacto puede variar según la versión, pero debe indicar que la configuración es válida.

Validar también la sintaxis YAML¶

Si yamllint está instalado:

yamllint /etc/prometheus/prometheus.yml

yamllint comprueba la sintaxis general de YAML. promtool comprueba además que la estructura sea válida para Prometheus.

Practicar con un error de YAML¶

Crear una copia incorrecta:

sudo cp \
  /etc/prometheus/prometheus.yml \
  /tmp/prometheus.yml.incorrecto

Editar la copia:

sudo nano /tmp/prometheus.yml.incorrecto

Introducir, por ejemplo, una indentación incorrecta:

---
global:
  scrape_interval: 15s
 evaluation_interval: 15s

Validar el fichero incorrecto:

promtool check config /tmp/prometheus.yml.incorrecto

El comando debe informar de un error de sintaxis.

Restaurar la configuración correcta si fuera necesario:

sudo cp \
  /etc/prometheus/prometheus.yml.orig \
  /etc/prometheus/prometheus.yml

Volver a validar:

promtool check config /etc/prometheus/prometheus.yml

Configurar los permisos¶

El usuario prometheus debe poder leer la configuración y escribir en el directorio de datos.

Asignar la propiedad de los datos¶

sudo chown -R \
  prometheus:prometheus \
  /var/lib/prometheus

Asignar la propiedad de la configuración¶

sudo chown -R \
  root:prometheus \
  /etc/prometheus

Configurar los permisos¶

sudo find /etc/prometheus \
  -type d \
  -exec chmod 0750 {} \;

sudo find /etc/prometheus \
  -type f \
  -exec chmod 0640 {} \;

Comprobar los permisos:

sudo ls -ld \
  /etc/prometheus \
  /var/lib/prometheus

Comprobar el fichero principal:

sudo ls -l /etc/prometheus/prometheus.yml

Comprobar que el usuario puede escribir en el directorio de datos:

sudo -u prometheus test -w /var/lib/prometheus \
  && echo "El usuario puede escribir en el directorio de datos" \
  || echo "El usuario no puede escribir en el directorio de datos"

Comprobar que puede leer la configuración:

sudo -u prometheus test -r /etc/prometheus/prometheus.yml \
  && echo "El usuario puede leer la configuración" \
  || echo "El usuario no puede leer la configuración"

Crear el servicio de systemd¶

Crear la unidad:

sudo tee /etc/systemd/system/prometheus.service > /dev/null <<'EOF'
[Unit]
Description=Prometheus Monitoring
Documentation=https://prometheus.io/docs/
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 \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries

Restart=on-failure
RestartSec=5s

NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/lib/prometheus

[Install]
WantedBy=multi-user.target
EOF

Explicación de las opciones¶

Opción	Función
`User=prometheus`	Ejecuta el proceso con el usuario de servicio
`Group=prometheus`	Utiliza el grupo del servicio
`ExecStart`	Define el comando de inicio
`--config.file`	Indica el fichero de configuración
`--storage.tsdb.path`	Indica dónde guardar los datos
`--web.console.templates`	Indica las plantillas web
`--web.console.libraries`	Indica las bibliotecas web
`Restart=on-failure`	Reinicia el servicio si termina con error
`ProtectSystem=strict`	Reduce las posibilidades de modificar el sistema
`ProtectHome=true`	Protege los directorios personales
`ReadWritePaths`	Permite escribir en el directorio de datos

Las opciones de protección de systemd pueden variar según la distribución y su versión. Si el servicio no inicia, consulta primero los registros antes de modificar la unidad.

Recargar la configuración de systemd¶

Después de crear o modificar una unidad, recargar la configuración:

sudo systemctl daemon-reload

Comprobar que la unidad se reconoce:

systemctl cat prometheus

Consultar la configuración resumida:

systemctl show prometheus \
  -p User \
  -p Group \
  -p ExecStart \
  -p FragmentPath

Iniciar Prometheus¶

Iniciar el servicio:

sudo systemctl start prometheus

Consultar el estado:

sudo systemctl status prometheus --no-pager

Resultado esperado:

● prometheus.service - Prometheus Monitoring
     Loaded: loaded (...)
     Active: active (running)

Comprobar mediante un comando breve:

systemctl is-active prometheus

Resultado esperado:

active

Habilitar el inicio automático¶

sudo systemctl enable prometheus

Comprobar:

systemctl is-enabled prometheus

Resultado esperado:

enabled

Comandos habituales¶

Detener:

sudo systemctl stop prometheus

Iniciar:

sudo systemctl start prometheus

Reiniciar:

sudo systemctl restart prometheus

Consultar el estado:

sudo systemctl status prometheus

Verificar el puerto de escucha¶

Comprobar que Prometheus escucha en el puerto 9090:

sudo ss -lntp | grep ':9090'

Ejemplo:

LISTEN 0 4096 0.0.0.0:9090 0.0.0.0:* users:(("prometheus",pid=...,fd=...))

También puede consultarse el proceso:

ps -ef | grep '[p]rometheus'

Ejemplo:

prometheus  1234  1  0 16:20 ?  00:00:02 /usr/local/bin/prometheus ...

Comprobar los endpoints HTTP¶

Endpoint principal¶

curl -I http://localhost:9090

Endpoint de salud¶

curl http://localhost:9090/-/healthy

Resultado esperado:

Prometheus is Healthy.

Endpoint de preparación¶

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

Resultado esperado:

Prometheus is Ready.

Información de versión¶

Si jq está instalado:

curl -s http://localhost:9090/api/v1/status/buildinfo | jq

Sin jq:

curl -s http://localhost:9090/api/v1/status/buildinfo

Consultar la métrica `up`¶

curl -sG http://localhost:9090/api/v1/query \
  --data-urlencode 'query=up' \
  | jq

Al principio debería aparecer el objetivo de Prometheus:

up{instance="localhost:9090",job="prometheus"} 1

Acceder a la interfaz web¶

Abrir desde el propio servidor:

http://localhost:9090

Desde otro equipo de la red:

http://IP_DEL_SERVIDOR:9090

Ejemplo:

http://192.168.1.50:9090

Desde la interfaz web se pueden consultar:

Expresiones PromQL.
Series temporales.
Objetivos.
Reglas.
Configuración.
Estado del servicio.
Información de compilación.

Primera consulta¶

Ejecutar:

up

Otras consultas iniciales:

prometheus_build_info

process_resident_memory_bytes

prometheus_tsdb_head_series

Consultar los registros¶

Consultar los últimos registros:

sudo journalctl -u prometheus --no-pager -n 50

Seguir los registros en tiempo real:

sudo journalctl -u prometheus -f

Consultar los registros desde el último arranque:

sudo journalctl -u prometheus -b --no-pager

Mostrar únicamente los errores:

sudo journalctl -u prometheus \
  -p err \
  --no-pager

Consultar los registros de los últimos diez minutos:

sudo journalctl -u prometheus \
  --since "10 minutes ago" \
  --no-pager

Añadir Node Exporter posteriormente¶

En esta práctica se instala inicialmente Prometheus con su propio objetivo.

Cuando Node Exporter esté instalado, se añadirá un segundo trabajo.

Configuración¶

---
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets:
          - localhost:9090

  - job_name: node_exporter
    static_configs:
      - targets:
          - localhost:9100

Validar y aplicar la configuración¶

promtool check config /etc/prometheus/prometheus.yml

sudo systemctl restart prometheus

Comprobar los objetivos¶

curl -s http://localhost:9090/api/v1/targets \
  | jq -r '
    .data.activeTargets[]
    | [
        .labels.job,
        .labels.instance,
        .health,
        .lastError
      ]
    | @tsv
  '

Resultado esperado:

prometheus      localhost:9090  up
node_exporter   localhost:9100  up

Comprobar desde PromQL:

up

up{job="node_exporter"}

Sesiones prácticas¶

Sesión 1: preparar el sistema¶

Objetivo¶

Comprobar que el sistema cumple los requisitos previos.

Comandos¶

lsb_release -ds
uname -m
nproc
free -h
df -h /
sudo ss -lntp | grep ':9090' || true
timedatectl status

Actividades¶

Anota la versión de Ubuntu.
Anota la arquitectura.
Anota el número de CPUs.
Anota la memoria disponible.
Anota el espacio libre.
Comprueba que el puerto 9090 está disponible.
Comprueba que el reloj está sincronizado.

Sesión 2: crear el usuario y los directorios¶

Objetivo¶

Crear la base de la instalación.

Comandos¶

if ! getent passwd prometheus >/dev/null; then
  sudo useradd \
    --system \
    --no-create-home \
    --shell /usr/sbin/nologin \
    prometheus
fi

sudo mkdir -p \
  /etc/prometheus \
  /var/lib/prometheus

sudo chown -R \
  prometheus:prometheus \
  /var/lib/prometheus

Comprobaciones¶

getent passwd prometheus

sudo ls -ld \
  /etc/prometheus \
  /var/lib/prometheus

Actividades¶

Comprueba que existe el usuario.
Comprueba su shell.
Comprueba los directorios.
Explica por qué Prometheus necesita escribir en /var/lib/prometheus.
Explica por qué la configuración debe estar separada de los datos.

Sesión 3: descargar e instalar los binarios¶

Objetivo¶

Instalar prometheus y promtool.

Comandos¶

export PROMETHEUS_VERSION="3.5.0"
export PROMETHEUS_ARCH="amd64"
export PROMETHEUS_PLATFORM="linux-${PROMETHEUS_ARCH}"
export PROMETHEUS_PACKAGE="prometheus-${PROMETHEUS_VERSION}.${PROMETHEUS_PLATFORM}.tar.gz"
export PROMETHEUS_URL="https://github.com/prometheus/prometheus/releases/download/v${PROMETHEUS_VERSION}/${PROMETHEUS_PACKAGE}"
export PROMETHEUS_DIR="/tmp/prometheus-${PROMETHEUS_VERSION}.${PROMETHEUS_PLATFORM}"

cd /tmp
curl -fLO "$PROMETHEUS_URL"

tar -xzf "$PROMETHEUS_PACKAGE"

sudo install \
  -m 0755 \
  "$PROMETHEUS_DIR/prometheus" \
  /usr/local/bin/prometheus

sudo install \
  -m 0755 \
  "$PROMETHEUS_DIR/promtool" \
  /usr/local/bin/promtool

Comprobaciones¶

prometheus --version

promtool --version

command -v prometheus

command -v promtool

Actividades¶

Anota la versión instalada.
Anota la arquitectura del binario.
Comprueba que los binarios están en /usr/local/bin.
Explica la función de promtool.

Sesión 4: crear y validar la configuración¶

Objetivo¶

Crear una configuración mínima y comprobar su sintaxis.

Crear el fichero¶

sudo tee /etc/prometheus/prometheus.yml > /dev/null <<'EOF'
---
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets:
          - localhost:9090
EOF

Validar¶

promtool check config /etc/prometheus/prometheus.yml

Actividades¶

Ejecuta la validación.
Comprueba que no aparecen errores.
Modifica temporalmente la indentación.
Vuelve a validar.
Corrige el error.
Explica por qué la indentación es importante en YAML.

Sesión 5: crear el servicio¶

Objetivo¶

Crear una unidad de systemd para gestionar Prometheus.

Crear la unidad¶

sudo tee /etc/systemd/system/prometheus.service > /dev/null <<'EOF'
[Unit]
Description=Prometheus Monitoring
Documentation=https://prometheus.io/docs/
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 \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries

Restart=on-failure
RestartSec=5s

NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/lib/prometheus

[Install]
WantedBy=multi-user.target
EOF

Recargar y habilitar¶

sudo systemctl daemon-reload

sudo systemctl enable prometheus

sudo systemctl start prometheus

Comprobar¶

systemctl is-enabled prometheus

systemctl is-active prometheus

sudo systemctl status prometheus --no-pager

Actividades¶

Comprueba que la unidad existe.
Comprueba que está habilitada.
Comprueba que el servicio está activo.
Consulta el usuario de ejecución:

systemctl show prometheus -p User -p Group

Consulta el comando de inicio:

systemctl show prometheus -p ExecStart

Sesión 6: verificar la instalación¶

Objetivo¶

Comprobar Prometheus desde la terminal.

Comandos¶

sudo ss -lntp | grep ':9090'

curl http://localhost:9090/-/healthy

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

curl -sG http://localhost:9090/api/v1/query \
  --data-urlencode 'query=up' \
  | jq

Ejemplo de sesión¶

$ systemctl is-active prometheus
active

$ curl http://localhost:9090/-/healthy
Prometheus is Healthy.

$ curl http://localhost:9090/-/ready
Prometheus is Ready.

$ curl -sG http://localhost:9090/api/v1/query \
    --data-urlencode 'query=up' \
    | jq -r '.data.result[] | [.metric.job, .value[1]] | @tsv'
prometheus      1

Actividades¶

Comprueba el estado del servicio.
Comprueba el endpoint de salud.
Comprueba el endpoint de preparación.
Ejecuta la consulta up.
Explica el valor 1.
Accede a la interfaz web desde un navegador.

Sesión 7: modificar la configuración de forma segura¶

Objetivo¶

Aprender a modificar la configuración y reiniciar el servicio de forma controlada.

Crear una copia:

sudo cp \
  /etc/prometheus/prometheus.yml \
  "/etc/prometheus/prometheus.yml.$(date +%Y%m%d-%H%M%S).bak"

Editar:

sudo nano /etc/prometheus/prometheus.yml

Validar:

promtool check config /etc/prometheus/prometheus.yml

Si la validación es correcta, reiniciar:

sudo systemctl restart prometheus

Comprobar:

systemctl is-active prometheus

Consultar los registros:

sudo journalctl -u prometheus \
  --since "1 minute ago" \
  --no-pager

Actividades¶

Crea una copia de seguridad.
Añade un comentario al fichero YAML.
Valida la configuración.
Reinicia Prometheus.
Comprueba que continúa activo.
Consulta los registros.

Diagnóstico de problemas¶

El servicio no inicia¶

Consultar el estado:

sudo systemctl status prometheus --no-pager

Consultar los registros:

sudo journalctl -u prometheus \
  --no-pager \
  -n 100

Validar la configuración:

promtool check config /etc/prometheus/prometheus.yml

Comprobar la existencia de los binarios:

ls -l /usr/local/bin/prometheus
ls -l /usr/local/bin/promtool

Comprobar los directorios:

sudo ls -ld \
  /etc/prometheus \
  /var/lib/prometheus

Error de permisos en el directorio de datos¶

Comprobar el propietario:

sudo stat -c '%U:%G %A %n' \
  /var/lib/prometheus

Corregir:

sudo chown -R \
  prometheus:prometheus \
  /var/lib/prometheus

Comprobar la escritura:

sudo -u prometheus \
  test -w /var/lib/prometheus \
  && echo "Escritura permitida" \
  || echo "Escritura no permitida"

Error de permisos en la configuración¶

Comprobar la lectura:

sudo -u prometheus \
  test -r /etc/prometheus/prometheus.yml \
  && echo "Lectura permitida" \
  || echo "Lectura no permitida"

Corregir propietario y permisos:

sudo chown root:prometheus \
  /etc/prometheus/prometheus.yml

sudo chmod 0640 \
  /etc/prometheus/prometheus.yml

El puerto `9090` está ocupado¶

Identificar el proceso:

sudo ss -lntp | grep ':9090'

También:

sudo lsof -nP -iTCP:9090 -sTCP:LISTEN

No detengas el proceso sin identificarlo previamente.

El servicio aparece activo, pero no responde¶

Comprobar el puerto:

sudo ss -lntp | grep ':9090'

Probar localmente:

curl -v http://localhost:9090/-/healthy

Comprobar los registros:

sudo journalctl -u prometheus --no-pager -n 100

Comprobar que ExecStart es correcto:

systemctl show prometheus -p ExecStart

La URL de descarga devuelve un error¶

Comprobar las variables:

echo "$PROMETHEUS_VERSION"
echo "$PROMETHEUS_ARCH"
echo "$PROMETHEUS_PACKAGE"
echo "$PROMETHEUS_URL"

Comprobar la respuesta:

curl -I "$PROMETHEUS_URL"

Posibles causas:

Versión inexistente.
Arquitectura incorrecta.
Error en el nombre del paquete.
Problemas de conectividad.
Red corporativa o proxy.
URL no autorizada en el laboratorio.

`promtool` indica un error de configuración¶

Mostrar el fichero con números de línea:

sudo nl -ba /etc/prometheus/prometheus.yml

Validar de nuevo:

promtool check config /etc/prometheus/prometheus.yml

Revisar especialmente:

Indentación.
Dos puntos.
Guiones de listas.
Espacios.
Nombres de propiedades.
Dirección de los targets.
Comillas incompletas.
Tabuladores.

Seguridad y mantenimiento¶

Ejecutar con un usuario sin privilegios¶

El servicio debe ejecutarse como:

prometheus

Comprobar:

systemctl show prometheus -p User -p Group

Proteger el fichero de configuración¶

Comprobar los permisos:

sudo stat -c '%A %U:%G %n' \
  /etc/prometheus/prometheus.yml

No exponer Prometheus directamente a Internet¶

Prometheus no debe publicarse directamente en Internet sin controles adicionales.

Recomendaciones:

Utilizar un cortafuegos.
Limitar el acceso a la red de administración.
Utilizar un proxy inverso cuando sea necesario.
Aplicar autenticación y autorización.
No incluir credenciales en ficheros públicos.
Mantener el software actualizado.
Revisar los registros.
Utilizar una VPN cuando corresponda.

Crear copias de seguridad¶

Copia de la configuración:

sudo cp \
  /etc/prometheus/prometheus.yml \
  ~/prometheus.yml.backup

Copia de la unidad de servicio:

sudo cp \
  /etc/systemd/system/prometheus.service \
  ~/prometheus.service.backup

El directorio /var/lib/prometheus contiene datos de series temporales. Su copia de seguridad requiere planificación y espacio suficiente.

Informe de instalación¶

Crear un directorio de evidencias:

mkdir -p ~/laboratorio-grafana/evidencias

Generar un informe:

{
  echo "===== INSTALACIÓN DE PROMETHEUS ====="
  echo "Fecha: $(date)"
  echo
  echo "===== SISTEMA ====="
  echo "Hostname: $(hostname)"
  echo "Sistema: $(lsb_release -ds)"
  echo "Arquitectura: $(uname -m)"
  echo "Kernel: $(uname -r)"
  echo
  echo "===== VERSIONES ====="
  prometheus --version 2>&1
  promtool --version 2>&1
  echo
  echo "===== SERVICIO ====="
  echo "Inicio automático: $(systemctl is-enabled prometheus 2>/dev/null || echo no-disponible)"
  echo "Estado: $(systemctl is-active prometheus 2>/dev/null || echo no-disponible)"
  echo
  echo "===== PUERTO ====="
  sudo ss -lntp | grep ':9090' || true
  echo
  echo "===== SALUD ====="
  curl -s http://localhost:9090/-/healthy || true
  echo
  echo "===== PREPARACIÓN ====="
  curl -s http://localhost:9090/-/ready || true
  echo
  echo "===== CONFIGURACIÓN ====="
  promtool check config /etc/prometheus/prometheus.yml 2>&1
} | tee ~/laboratorio-grafana/evidencias/instalacion-prometheus.txt

Consultar el informe:

cat ~/laboratorio-grafana/evidencias/instalacion-prometheus.txt

Actividad integradora¶

Objetivo¶

Instalar Prometheus como servicio y demostrar que funciona correctamente.

Tareas¶

Comprobar los requisitos previos.
Crear el usuario prometheus.
Crear los directorios de configuración y datos.
Descargar la versión indicada.
Instalar prometheus y promtool.
Copiar los recursos de configuración.
Crear el fichero prometheus.yml.
Validar la configuración.
Configurar los permisos.
Crear la unidad de systemd.
Recargar la configuración de systemd.
Habilitar el inicio automático.
Iniciar Prometheus.
Comprobar el estado del servicio.
Comprobar el puerto 9090.
Comprobar /-/healthy.
Comprobar /-/ready.
Acceder a la interfaz web.
Ejecutar la consulta up.
Consultar los registros.
Guardar las evidencias.

Resultado esperado¶

El alumno debe obtener:

Servicio: activo
Inicio automático: habilitado
Puerto: 9090
Endpoint de salud: correcto
Endpoint de preparación: correcto
Interfaz web: accesible
Consulta up: devuelve el objetivo de Prometheus

Ejemplo de sesión completa¶

La siguiente sesión resume una instalación funcional:

$ uname -m
x86_64

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

$ sudo mkdir -p /etc/prometheus /var/lib/prometheus

$ sudo chown -R prometheus:prometheus /var/lib/prometheus

$ prometheus --version
prometheus, version 3.5.0

$ sudo tee /etc/prometheus/prometheus.yml > /dev/null <<'EOF'
---
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets:
          - localhost:9090
EOF

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

$ sudo systemctl daemon-reload

$ sudo systemctl enable prometheus
Created symlink ...

$ sudo systemctl start prometheus

$ systemctl is-active prometheus
active

$ curl http://localhost:9090/-/healthy
Prometheus is Healthy.

$ curl http://localhost:9090/-/ready
Prometheus is Ready.

$ curl -sG http://localhost:9090/api/v1/query \
    --data-urlencode 'query=up' \
    | jq -r '.data.result[] | [.metric.job, .value[1]] | @tsv'
prometheus      1

Puntos clave¶

Prometheus se instalará como un servicio de systemd.
El binario principal se instalará en /usr/local/bin/prometheus.
promtool permite validar configuraciones.
La configuración principal estará en /etc/prometheus/prometheus.yml.
Los datos se almacenarán en /var/lib/prometheus.
El servicio debe ejecutarse con el usuario prometheus.
El puerto web habitual es el 9090.
La configuración debe validarse antes de reiniciar el servicio.
systemctl permite gestionar el servicio.
journalctl permite revisar los registros.
/-/healthy comprueba la salud básica.
/-/ready comprueba si Prometheus está preparado.
La consulta up permite comprobar los objetivos recopilados.
Los permisos de configuración y datos son fundamentales.
Un error de YAML puede impedir el inicio del servicio.
El puerto 9090 debe estar disponible.
La versión y la arquitectura deben coincidir con el sistema.
Las copias de seguridad facilitan la recuperación.
Prometheus no debe exponerse directamente a Internet sin protección.
La instalación debe documentarse mediante evidencias reproducibles.

Preguntas de comprobación¶

¿Qué función cumple Prometheus?
¿Qué función cumple promtool?
¿Dónde se instala el binario de Prometheus en esta práctica?
¿Dónde se almacena la configuración?
¿Dónde se almacenan los datos de Prometheus?
¿Qué usuario debe ejecutar el servicio?
¿Por qué no se recomienda ejecutar Prometheus como root?
¿Qué puerto utiliza normalmente Prometheus?
¿Qué comando permite validar la configuración?
¿Qué comando permite consultar el estado del servicio?
¿Qué comando permite consultar los registros?
¿Qué función cumple systemctl daemon-reload?
¿Qué diferencia existe entre start y enable?
¿Qué endpoint permite comprobar la salud de Prometheus?
¿Qué endpoint permite comprobar si Prometheus está preparado?
¿Qué indica un resultado up = 1?
¿Qué puede provocar que Prometheus no se inicie?
¿Qué puede provocar un error de permisos?
¿Cómo comprobarías si el puerto 9090 está ocupado?
¿Por qué es importante validar el fichero YAML antes de reiniciar?
¿Qué comando muestra la versión de Prometheus?
¿Qué directorio debe tener permisos de escritura para el usuario prometheus?
¿Qué información se puede obtener mediante journalctl?
¿Por qué debe realizarse una copia de seguridad de prometheus.yml?
¿Qué comprobaciones realizarías antes de añadir Node Exporter?

Criterios de finalización¶

La instalación se considera correcta cuando:

El usuario prometheus existe.
El usuario no tiene acceso interactivo.
Existe /etc/prometheus.
Existe /var/lib/prometheus.
prometheus está instalado.
promtool está instalado.
La configuración es válida.
La unidad de systemd existe.
El servicio está habilitado.
El servicio está activo.
El proceso utiliza el usuario prometheus.
El puerto 9090 está en escucha.
El endpoint /-/healthy responde correctamente.
El endpoint /-/ready responde correctamente.
La interfaz web es accesible.
La consulta up devuelve el objetivo de Prometheus.
Los registros no contienen errores críticos.
Se ha guardado el informe de evidencias.

Comprobación final¶

printf '%-35s %s\n' \
  "Servicio activo" \
  "$(systemctl is-active prometheus)"

printf '%-35s %s\n' \
  "Inicio automático" \
  "$(systemctl is-enabled prometheus)"

printf '%-35s ' \
  "Configuración válida"

promtool check config /etc/prometheus/prometheus.yml \
  >/dev/null 2>&1 \
  && echo "sí" \
  || echo "no"

printf '%-35s ' \
  "Endpoint saludable"

curl -fsS http://localhost:9090/-/healthy \
  >/dev/null \
  && echo "sí" \
  || echo "no"

printf '%-35s ' \
  "Endpoint preparado"

curl -fsS http://localhost:9090/-/ready \
  >/dev/null \
  && echo "sí" \
  || echo "no"

printf '%-35s ' \
  "Puerto 9090"

sudo ss -lnt '( sport = :9090 )' \
  | grep -q LISTEN \
  && echo "en escucha" \
  || echo "no disponible"

Resultado esperado:

Servicio activo                    active
Inicio automático                  enabled
Configuración válida               sí
Endpoint saludable                 sí
Endpoint preparado                 sí
Puerto 9090                        en escucha

Instalación de Prometheus mediante binarios¶

Objetivos¶

Introducción¶

Arquitectura de la instalación¶

Directorios principales¶

Requisitos previos¶

Comprobar la distribución¶

Comprobar la arquitectura¶

Comprobar permisos administrativos¶

Comprobar el espacio disponible¶

Comprobar el puerto¶

Comprobar la hora¶

Preparar las variables de instalación¶

Comprobar la URL de descarga¶

Descargar el paquete¶

Crear el usuario de servicio¶

Explicación de las opciones¶

Crear los directorios¶

Función de cada directorio¶

Extraer el paquete¶

Instalar los binarios¶

Instalar los recursos de configuración¶

Crear una configuración inicial¶

Crear una copia de seguridad¶

Crear la configuración¶

Explicación de la configuración¶

Bloque global¶

Bloque scrape_configs¶

Propiedad job_name¶

Propiedad targets¶

Validar la configuración¶

Validar también la sintaxis YAML¶

Practicar con un error de YAML¶

Configurar los permisos¶

Asignar la propiedad de los datos¶

Asignar la propiedad de la configuración¶

Configurar los permisos¶

Crear el servicio de systemd¶

Explicación de las opciones¶

Recargar la configuración de systemd¶

Iniciar Prometheus¶

Habilitar el inicio automático¶

Comandos habituales¶

Verificar el puerto de escucha¶

Comprobar los endpoints HTTP¶

Endpoint principal¶

Endpoint de salud¶

Endpoint de preparación¶

Información de versión¶

Consultar la métrica up¶

Acceder a la interfaz web¶

Primera consulta¶

Consultar los registros¶

Añadir Node Exporter posteriormente¶

Configuración¶

Validar y aplicar la configuración¶

Comprobar los objetivos¶

Sesiones prácticas¶

Sesión 1: preparar el sistema¶

Objetivo¶

Comandos¶

Actividades¶

Sesión 2: crear el usuario y los directorios¶

Objetivo¶

Comandos¶

Comprobaciones¶

Actividades¶

Sesión 3: descargar e instalar los binarios¶

Objetivo¶

Comandos¶

Comprobaciones¶

Actividades¶

Sesión 4: crear y validar la configuración¶

Objetivo¶

Crear el fichero¶

Validar¶

Actividades¶

Sesión 5: crear el servicio¶

Objetivo¶

Crear la unidad¶

Bloque `global`¶

Bloque `scrape_configs`¶

Propiedad `job_name`¶

Propiedad `targets`¶

Consultar la métrica `up`¶

El puerto `9090` está ocupado¶

`promtool` indica un error de configuración¶