Monitorea tus servicios con Uptime Kuma

PDF

Uno de los principales fuertes de un sysadmins es ser pro-activo antes cualquier fallo o caída de un servicio y para lograrlo debes tener todos tus servicios monitoreados. En Internet existe muchos sistemas para lograrlo. En este artículo vamos a enseñarles cómo montar un sistema de monitoreo al estilo de UptimeRobot llamado Uptime Kuma con notificación mediante telegram o correo y otros servicios de una forma fácil.

Uptime Kuma Es una herramienta de monitorización auto hospedada es decir que puedes montarla en tu red y de esa forma monitorear servicios que no están publicados para Internet. Este proyecto utiliza completamente socket.io como backend y Vue 3 como frontend. Deberías sentir la interactividad tan rápida en comparación con las aplicaciones web tradicionales.

Características

• Monitorización del tiempo de actividad para HTTP(s) / TCP / Ping / Registro DNS.
• UI/UX elegante, reactivo y rápido.
• Notificaciones vía Telegram, Discord, Gotify, Slack, Pushover, Email (SMTP), y más de 70 servicios de notificación, haz clic aquí para ver la lista completa.
• Intervalo de 20 segundos.
• Multi Idiomas

Preparación del servidor

Para esta instalación usaremos ubuntu 20.04 como base y una vez iniciado el Servidor accedemos al mismo y preparamos los requerimientos mínimos que en este caso será docker

sudo -- sh -c 'apt-get update; apt-get upgrade -y; apt-get dist-upgrade -y; apt-get autoremove -y; apt-get autoclean -y'

Instalamos Docker

sudo apt-get install -y docker.io

Una vez instalado docker procedemos a configurar algunos mirror por si estas instalando desde un lugar donde docker no está permitido libremente
sudo nano /etc/docker/daemon.json

{ 
    "registry-mirrors": [ 
    "https://rw21enj1.mirror.aliyuncs.com",
    "https://dockerhub.azk8s.cn",
    "https://reg-mirror.qiniu.com",
    "https://hub-mirror.c.163.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://1nj0zren.mirror.aliyuncs.com",
    "https://quay.io",
    "https://docker.mirrors.ustc.edu.cn",
    "http://f1361db2.m.daocloud.io",
    "https://registry.docker-cn.com"
    ]
}

Si desea agregar un registro de mirror inseguro aquí les dejo el enlace de cómo hacerlo. Reiniciamos para que se vean los cambios.

sudo systemctl daemon-reload 
sudo systemctl restart docker

Este paso a continuación es para aquellos que están detrás de un proxy padre y es opcional.

Crear la carpeta docker.service.d

sudo mkdir -p /etc/systemd/system/docker.service.d

Creamos el fichero http-proxy.conf

sudo nano /etc/systemd/system/docker.service.d/http-proxy.conf

Dentro agregamos:
[Service]
Environment="HTTP_PROXY=http://user:password@proxyip:port/"
Environment="HTTPS_PROXY=http://user:password@proxyip:port/"
Environment="NO_PROXY= hostname.example.com,localhost,127.0.0.1"

Recargamos la config y reiniciamos el servicio:

sudo systemctl daemon-reload
sudo systemctl restart docker

Ahora comprobaremos que todo está bien.
Usaremos el comando:
docker info

Nos dará una salida similar a la siguiente:

Client:
 Context:    default
 Debug Mode: false

Server:
 Containers: 0
  Running: 0
  Paused: 0
  Stopped: 0
 Images: 0
 Server Version: 20.10.7
 Storage Driver: overlay2
  Backing Filesystem: extfs
  Supports d_type: true
  Native Overlay Diff: true
  userxattr: false
 Logging Driver: json-file
 Cgroup Driver: cgroupfs
 Cgroup Version: 1
 Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
 Swarm: inactive
 Runtimes: io.containerd.runc.v2 io.containerd.runtime.v1.linux runc
 Default Runtime: runc
 Init Binary: docker-init
 containerd version: 
 runc version: 
 init version: 
 Security Options:
  apparmor
  seccomp
   Profile: default
 Kernel Version: 5.4.0-81-generic
 Operating System: Ubuntu 20.04.3 LTS
 OSType: linux
 Architecture: x86_64
 CPUs: 1
 Total Memory: 981.2MiB
 Name: uptime.syscu.net
 ID: DQWD:AVNL:VTLK:C4CI:CUWS:JWEK:ASBY:UV46:BVPB:TUV3:5SKY:2MN6
 Docker Root Dir: /var/lib/docker
 Debug Mode: false
 Registry: https://index.docker.io/v1/
 Labels:
 Experimental: false
 Insecure Registries:
  127.0.0.0/8
 Registry Mirrors:
  https://rw21enj1.mirror.aliyuncs.com/
  https://dockerhub.azk8s.cn/
  https://reg-mirror.qiniu.com/
  https://hub-mirror.c.163.com/
  https://docker.mirrors.ustc.edu.cn/
  https://1nj0zren.mirror.aliyuncs.com/
  https://quay.io/
  http://f1361db2.m.daocloud.io/
  https://registry.docker-cn.com/
 Live Restore Enabled: false

WARNING: No swap limit support
Aquí solo deben fijarse si les reconoce el proxy(si se lo pusieron) y los mirrors alternos(Registry Mirrors).

Configuramos docker para que inicie automáticamente

sudo systemctl enable docker

Comprobamos que docker este iniciado sin problema

sudo sudo systemctl status docker

Instalación del Servidor Uptime Kuma

Mediante CLI

Podemos emplear una instalación mediante un cli que facilita su despliegue, ya que permite escoger si deseas con Docker o mediante git de forma local

curl -o kuma_install.sh http://git.kuma.pet/install.sh && sudo bash kuma_install.sh

Mediante Docker

# Start the container
docker volume create uptime-kuma

# Iniciar el contenedor
docker run -d --restart=always -p 3001:3001 -v uptime-kuma:/app/data --name uptime-kuma louislam/uptime-kuma:1

Una vez instalado podran acceder al mismo mediante la url http://IP_DEL_SERVER:3001

Puedes si deseas puedes cambiar dicho puerto y volumen a la hora de crear el contenedor docker

docker run -d --restart=always -p :3001 -v :/app/data --name uptime-kuma louislam/uptime-kuma:1

Sin Docker (recomendado sólo para x86/x64)

Herramientas necesarias: Node.js >= 14, git y pm2.

(No se recomienda para usuarios de CPUs ARM. Dado que no hay un prebuilt para node-sqlite3, es difícil hacerlo funcionar)

git clone https://github.com/louislam/uptime-kuma.git
cd uptime-kuma
npm run setup

# Opción 1. Pruébalo
node server/server.js

# (Recomendado)
# Opción 2. Ejecutar en segundo plano utilizando PM2
# Instala PM2 si no tienes: npm install pm2 -g
pm2 start server/server.js --name uptime-kuma

Navega a http://IP_DEL_SERVER:3001 después de iniciarlo.

# Escuchar en un puerto o nombre de host diferente
pm2 start server/server.js --name uptime-kuma -- --port=80 --hostname=0.0.0.0

Comandos útiles

pm2 start uptime-kuma
pm2 stop uptime-kuma
pm2 restart uptime-kuma

# Ejecutar en el arranque
pm2 startup

Proxy Inverso

Esto es opcional para alguien que quiera hacer proxy inverso.

A diferencia de otras aplicaciones web, Uptime Kuma se basa en WebSocket. Necesitas dos cabeceras más “Upgrade” y “Connection” para poder hacer proxy inverso de WebSocket.

En este manual usaremos nginx + certbot para asegurar un poco más nuestro uptime

Instalamos nginx

sudo apt-get install nginx

Instalando snap

sudo apt-get install snap

sudo snap install core

Instalando Certbot via snap

sudo snap install --classic certbot

Prepare the Certbot command

sudo ln -s /snap/bin/certbot /usr/bin/certbot

Una vez ya instalado el certbot Pasamos a crear el certificado

sudo certbot certonly --preferred-chain="ISRG Root X1" --standalone -d uptime.syscu.net --agree-tos --no-bootstrap --manual-public-ip-logging-ok --server https://acme-v02.api.letsencrypt.org/directory

Una vez instalado el nginx y el certbot pasamos a configurar el virtualhost
nano /etc/nginx/sites-available/uptime

server {
     listen 80 ;
     server_name uptime.syscu.net;
     return 301 https://$host$request_uri;
 }

server {
  listen 443 ssl http2;
  server_name uptime.syscu.net;
     ssl_certificate /etc/letsencrypt/live/uptime.syscu.net/fullchain.pem;
     ssl_certificate_key /etc/letsencrypt/live/uptime.syscu.net/privkey.pem;
     ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
     ssl_prefer_server_ciphers on;
     ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
     ssl_ecdh_curve secp384r1;
     ssl_session_cache shared:SSL:10m;
     ssl_session_tickets off;
     ssl_stapling on;
     ssl_stapling_verify on;
     resolver 8.8.8.8 8.8.4.4 valid=300s;
     resolver_timeout 5s;
     add_header Strict-Transport-Security "max-age=63072000; includeSubdomains";
     add_header X-Frame-Options DENY;
     add_header X-Content-Type-Options nosniff;
     

  location / {
    proxy_set_header   X-Real-IP $remote_addr;
    proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass         http://localhost:3001/;
    proxy_http_version 1.1;
    proxy_set_header   Upgrade $http_upgrade;
    proxy_set_header   Connection "upgrade";
  }
}

Una vez creado el virtualhost procedemos a habilitarlo y reiniciar el nginx

ln -s /etc/nginx/sites-available/uptime /etc/nginx/sites-enabled/uptime ; /etc/init.d/nginx restart

Como notaran usamos el dominio uptime.syscu.net ahi podran el dominio suyo tanto para sacar el certificado como para el virtualhost.

Al acceder por primera vez al Uptime Kuma te pedirá para crear la cuenta de acceso al mismo como notaras en la siguiente imagen.
Nota: Recomendamos no usar ninguno de los nombres comunes de admin, administrador o root.

Una vez dentro procedemos a Ajustes y procedemos a configurar varios aspectos:
Zona Horario pones la zona de tu país, en este caso America/Havana

Procedemos a agregar los sistemas por los cuales Notificara

Notificaciones

Telegram Personal

Para que el sistema notifique por telegram debes crear un bot para dicha tarea.

En nombre sencillo ponemos el nombre de nosotros seguidamente de Telegram ya que puedes crear varias Notificaciones por telegram con el mismo bot cambiando solamente el CHAT ID de otro usuario, yo usare Telegram Armando

Para crear el bot en telegram deben ir a BotFather, en dicho bot ejecutaran el comando /newbot

Ahi les preguntara el Nombre y seguidamente el username que tendrá el mismo, una vez introducido estos datos te dara el TOKEN de acceso como se los muestro en la imagen siguiente:

Una vez obtenido eso necesitaremos nuestro CHAT ID, para eso necesitamos entrar a nuestro bot y darle /start
Realizada esta opción accedemos a el link que nos aparece en Uptime Kuma para sacar ese dato deben darle click a donde dice api.telegram.org

De ese link cogemos el valor id: y lo copiamos en Uptime Kuma.

Nos deberá quedar más menos así:

Para probar que dicho bot funciona le damos al botón Test y nos debería llegar un mensaje a telegram desde el Bot

Si vez que te llego el mensaje todo esta OK

Puedes habilitar «Habilitado por defecto» para que a cualquier monitoreo que agregues tenga esta notificación activada.

Telegram Grupo

Puedes notificar un servicio a más de una persona siguiendo los mismos pasos y solo cambiando el CHAT ID
Para ello no necesitamos crear otro bot ya que puedes usar el mismo lo que debes agregar el bot a dicho grupo y ejecutar @nombredelbot /start

una vez ejecutado eso procedemos al Uptime Kuma a agregarlo en notificaciones

En nombre sencillo ponemos el nombre del grupo donde lo agregaste para que sepas yo usare Grupo SysAdminsdecuba
Accedemos al link que usamos la otra vez para sacar el ID y lo copiamos, normalmente los grupos usan un Chat ID que empieza con –

Monitores

Ya una vez creadas las alertas procedemos a crear los monitores de los sistemas interesados, como el ejemplo que les muestro a continuación, ahi seleccionamos ese recurso como quiero que nos notifique en este caso tenemos 2 opciones, a nuestro chat privado o a un grupo.

En el mismo tenemos varios tipos de Monitor

• HTTP(s)
• TCP Port
• Ping
• HTTP(s) – Palabra clave
• DNS
• Push
• Steam Game Server

Ahi puedes usar el que le necesite.

Para una prueba tumbamos un momento uno de los servicios para probar que el mismo alerte cuando se cae y cuando vuelve a estar levantado

Una de las bondades del tipo de monitor HTTP(s) es que te muestra cuando vence el certificado SSL de tu web como lo notaran en la siguiente imagen, esta es una opción que puedes tener también para saber cuándo deberías renovarlo.

Histórico de un Monitor

Como notaran uptime kuma en su dashboard podrás ver los últimos eventos de los monitores que tengas con datos, de día, hora y cuál fue el error seguidamente de cuando se levantó, como les muestro en la imagen anterior.

Pagina de Status

Otra de las variantes que tiene el uptime Kuma es la facilidad de crear una página «publica» del estado de tus servicios y agruparlos por proyectos.
Nota: esta página de estatus como antes mencione es publica es decir cualquier puede verla.

Cómo Actualizar

Docker

Re-pull a la última imagen docker y crea otro contenedor con el mismo volumen.

Para alguien que uso los comandos de cómo instalar Uptime Kuma, puede actualizar por esto:

docker pull louislam/uptime-kuma:1
docker stop uptime-kuma
docker rm uptime-kuma
docker run -d --restart=always -p 3001:3001 -v uptime-kuma:/app/data --name uptime-kuma louislam/uptime-kuma:1

Sin Docker

cd 
git fetch --all
git checkout 1.6.2 --force
npm install --legacy-peer-deps
node node_modules/esbuild/install.js
npm run build
pm2 restart uptime-kuma

Motivación

(Palabras del autor)

• Estaba buscando una herramienta de monitorización auto-alojada como “Uptime Robot”, pero es difícil encontrar una adecuada. Una de las más cercanas es Statping. Desafortunadamente, no es estable y no tiene mantenimiento.
• Querer construir una interfaz de usuario de lujo.
• Aprender Vue 3 y vite.js.
• Mostrar el poder de Bootstrap 5.
• Intentar usar WebSocket con SPA en lugar de REST API.
• Desplegar mi primera imagen Docker en Docker Hub.

Bueno solo me queda decir que le den una oportunidad a esta herramienta, monitoreen toda su infraestructura y no esperen que le avisen que se cae un servicio, sean ustedes los primeros en saberlo gracias a Uptime Kuma.