Cómo instalar Statping-ng con Docker en Ubuntu 24.04

Statping-ng es una herramienta de monitorización de disponibilidad escrita en Go que comprueba periódicamente tus servicios (HTTP, TCP o UDP) y publica una página de estado con el uptime, los tiempos de respuesta y el historial de caídas. Es la continuación mantenida por la comunidad del proyecto Statping original. En este tutorial desplegarás Statping-ng con Docker Compose y PostgreSQL en Ubuntu 24.04, lo publicarás con Nginx y HTTPS, añadirás servicios desde el panel y la API, configurarás una notificación y programarás copias de seguridad.

Requisitos previos

Para seguir esta guía necesitas:

Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 1 GB de RAM.
Un usuario no root con privilegios sudo.
Docker Engine y el plugin Docker Compose instalados desde el repositorio oficial.
Un subdominio, por ejemplo status.your_domain, con un registro DNS A apuntando a la IP del servidor.
Los puertos 80 y 443 abiertos.

Aloja la página de estado en un servidor distinto al de los servicios que monitoriza: si todo está en la misma máquina, una caída se llevaría también la página que debe informar de ella.

Paso 1: Preparar el directorio y los secretos

Crea el directorio del proyecto:

sudo mkdir -p /opt/statping
sudo chown "$USER":"$USER" /opt/statping
cd /opt/statping

Genera la contraseña de PostgreSQL, la del usuario administrador y el secreto de la API, y guárdalos en un archivo .env que Docker Compose lee automáticamente:

cat > .env <<EOF
DB_PASSWORD=$(openssl rand -hex 24)
ADMIN_PASSWORD=$(openssl rand -base64 18)
API_SECRET=$(openssl rand -hex 32)
EOF
chmod 600 .env
cat .env

DB_PASSWORD=4c1f...
ADMIN_PASSWORD=Qm7d...
API_SECRET=b82e...

Anota ADMIN_PASSWORD: la usarás para entrar en el panel.

Paso 2: Crear el archivo de Docker Compose

Crea compose.yaml con PostgreSQL y Statping-ng. La imagen adamboutcher/statping-ng es la que publica el proyecto y escucha en el puerto 8080:

nano /opt/statping/compose.yaml

services:
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: statping
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: statping
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U statping"]
      interval: 10s
      timeout: 5s
      retries: 5

  statping:
    image: adamboutcher/statping-ng:latest
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    ports:
      - "127.0.0.1:8080:8080"
    environment:
      DB_CONN: postgres
      DB_HOST: postgres
      DB_PORT: "5432"
      DB_USER: statping
      DB_PASS: ${DB_PASSWORD}
      DB_DATABASE: statping
      NAME: "Estado de servicios"
      DESCRIPTION: "Disponibilidad de nuestra plataforma en tiempo real"
      DOMAIN: https://status.your_domain
      ADMIN_USER: admin
      ADMIN_PASSWORD: ${ADMIN_PASSWORD}
      API_SECRET: ${API_SECRET}
      SAMPLE_DATA: "false"
    volumes:
      - statping_data:/app

volumes:
  pgdata:
  statping_data:

Qué hace cada bloque:

Con DB_CONN y las credenciales definidas, Statping-ng se configura solo en el primer arranque, sin asistente web, y crea el usuario admin con la contraseña de ADMIN_PASSWORD.
SAMPLE_DATA: "false" evita que se creen servicios de ejemplo.
API_SECRET fija el secreto con el que se autentica la API.
El puerto se publica solo en 127.0.0.1. Docker gestiona sus propias reglas de iptables, así que un puerto publicado en todas las interfaces quedaría abierto aunque UFW lo bloquee. Nginx será el único punto de entrada público.

Paso 3: Arrancar Statping-ng

Arranca los contenedores:

docker compose up -d
docker compose ps

NAME                  IMAGE                             SERVICE    STATUS                   PORTS
statping-postgres-1   postgres:16-alpine                postgres   Up 30 seconds (healthy)
statping-statping-1   adamboutcher/statping-ng:latest   statping   Up 19 seconds            127.0.0.1:8080->8080/tcp

Comprueba en los logs que se ha conectado a la base de datos y que no hay errores:

docker compose logs --tail 30 statping

Verifica que responde en local:

curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/

Paso 4: Publicar Statping-ng con Nginx y HTTPS

Instala Nginx y Certbot y permite el tráfico web en UFW:

sudo apt update
sudo apt install -y nginx certbot python3-certbot-nginx
sudo ufw allow 'Nginx Full'

Crea el bloque de servidor, sustituyendo status.your_domain por tu subdominio:

sudo nano /etc/nginx/sites-available/statping

server {
    listen 80;
    listen [::]:80;
    server_name status.your_domain;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Activa el sitio, valida la sintaxis y recarga Nginx:

sudo ln -s /etc/nginx/sites-available/statping /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Obtén el certificado de Let's Encrypt. Certbot añadirá la configuración de TLS y la redirección de HTTP a HTTPS:

sudo certbot --nginx -d status.your_domain

Abre https://status.your_domain. Verás la página pública, todavía sin servicios. Entra en el panel con Dashboard (o en https://status.your_domain/login) con el usuario admin y la contraseña del paso 1.

Paso 5: Añadir servicios desde el panel

En el panel, ve a Services y pulsa Create. Para monitorizar una web configura:

Service Type: HTTP Service.
Service Endpoint (URL): https://your_domain.
Expected Status Code: 200.
Check Interval: cada cuánto se comprueba, por ejemplo 60 segundos.
Request Timeout: por ejemplo 15 segundos.
Public: activado si quieres que aparezca en la página de estado.

Para un servicio que no es HTTP, como una base de datos o un servidor de correo, elige TCP Service e indica el host y el puerto. Guarda el servicio y, pasado el primer intervalo, la página pública mostrará su estado, el uptime y una gráfica de latencia.

Consejo

marca como no públicos los servicios internos (bases de datos, paneles de administración). Seguirán monitorizándose y enviando alertas, pero no revelarás su existencia en la página pública.

Paso 6: Gestionar servicios con la API

La API REST es útil para dar de alta servicios de forma automática, por ejemplo desde un script de aprovisionamiento. Se autentica con la cabecera Authorization: Bearer y el valor de API_SECRET. Carga el secreto en tu sesión:

export STATPING_URL="https://status.your_domain"
export API_SECRET=$(grep '^API_SECRET=' /opt/statping/.env | cut -d= -f2)

Lista los servicios existentes:

curl -s "$STATPING_URL/api/services" -H "Authorization: Bearer $API_SECRET" | jq '.[] | {id, name, online}'

{
  "id": 1,
  "name": "Web principal",
  "online": true
}

Crea un servicio TCP que compruebe el puerto SSH de otro servidor cada minuto:

curl -s -X POST "$STATPING_URL/api/services" \
  -H "Authorization: Bearer $API_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
        "name": "SSH servidor de backups",
        "domain": "backup.your_domain",
        "port": 22,
        "type": "tcp",
        "check_interval": 60,
        "timeout": 10,
        "public": false
      }'

La respuesta devuelve el servicio creado con su id. Consulta su detalle, incluidos el estado y las métricas de uptime:

curl -s "$STATPING_URL/api/services/2" -H "Authorization: Bearer $API_SECRET" | jq '{name, online, online_24_hours, avg_response}'

Si necesitas instalar jq, ejecuta sudo apt install jq.

Paso 7: Configurar las notificaciones

Statping-ng puede avisar cuando un servicio cae y cuando se recupera. Los canales disponibles (correo SMTP, Slack, Discord, Telegram, webhooks, entre otros) se configuran en Settings > Notifiers. Por ejemplo, para correo:

Abre el notificador Email.
Introduce el host SMTP, el puerto (587), el usuario, la contraseña, el remitente y el destinatario de las alertas.
Activa Enable y guarda.
Pulsa Test para enviar un mensaje de prueba y confirma que llega.

Para Slack o Discord basta con pegar la URL del webhook entrante del canal. En cada servicio, la opción Notify All Changes controla si se envía un aviso en cada cambio de estado.

Para comprobar que las alertas funcionan, crea un servicio HTTP de prueba contra una URL que no exista, por ejemplo https://your_domain/no-existe con código esperado 200. Tras el primer intervalo se marcará como caído y recibirás la notificación. Bórralo después.

Paso 8: Programar copias de seguridad

Los servicios, el historial y la configuración se guardan en PostgreSQL. Crea un script que haga un volcado comprimido y conserve los últimos 14 días:

sudo nano /usr/local/bin/statping-backup.sh

#!/usr/bin/env bash
set -euo pipefail

backup_dir="/var/backups/statping"
mkdir -p "$backup_dir"

docker compose -f /opt/statping/compose.yaml exec -T postgres \
  pg_dump -U statping statping | gzip > "$backup_dir/statping-$(date +%F).sql.gz"

find "$backup_dir" -name 'statping-*.sql.gz' -mtime +14 -delete

Hazlo ejecutable y pruébalo:

sudo chmod 755 /usr/local/bin/statping-backup.sh
sudo /usr/local/bin/statping-backup.sh
ls -lh /var/backups/statping

-rw-r--r-- 1 root root 38K Sep 25 03:00 statping-2026-09-25.sql.gz

Prográmalo cada noche a las 03:00 con cron:

echo '0 3 * * * root /usr/local/bin/statping-backup.sh' | sudo tee /etc/cron.d/statping-backup

Guarda también una copia de /opt/statping/.env fuera del servidor, y lleva los volcados a otro sitio (otro servidor o almacenamiento de objetos) para que sobrevivan a la pérdida de la máquina.

Paso 9: Actualizar Statping-ng

Para actualizar a una imagen más reciente, haz antes una copia de seguridad y después descarga las imágenes y recrea los contenedores:

sudo /usr/local/bin/statping-backup.sh
cd /opt/statping
docker compose pull
docker compose up -d
docker compose logs --tail 30 statping

Solución de problemas

Statping-ng se reinicia en bucle. Revisa docker compose logs statping. Si el error es de conexión a la base de datos, comprueba que postgres está healthy y que DB_PASSWORD no ha cambiado desde el primer arranque: PostgreSQL solo aplica POSTGRES_PASSWORD al crear el volumen.

Todos los servicios aparecen caídos. El contenedor no resuelve DNS o no tiene salida a Internet. Prueba desde dentro con docker compose exec statping wget -qO- https://your_domain | head -c 100. Si falla, revisa la configuración de red de Docker y el firewall de salida del servidor.

Nginx devuelve 502 Bad Gateway. Statping-ng no está en marcha o no escucha en 127.0.0.1:8080. Comprueba docker compose ps y curl -I http://127.0.0.1:8080/.

La API responde 401. Falta la cabecera Authorization: Bearer o el valor no coincide con API_SECRET del archivo .env.

Conclusión

Tienes Statping-ng monitorizando tus servicios desde Ubuntu 24.04, con PostgreSQL, una página de estado pública con HTTPS, alertas por correo o chat y copias de seguridad diarias. Como siguientes pasos, puedes agrupar servicios en la página pública desde Groups, añadir comprobaciones de palabras clave en la respuesta HTTP o integrar la API en tu herramienta de aprovisionamiento para que cada nuevo servidor se monitorice automáticamente.

On this page