Cómo configurar una paágina de estado autohospedada para monitorear tus sitios web con una computadora monoplaca • Linux Boards

Ya sea que tengas un blog personal o un sitio web para tu negocio principal o secundario, asegurar que tus sitios web estén funcionando sin problemas es crucial. Una página de estado autohospedada te ayuda a monitorear el tiempo de actividad y el rendimiento de tus sitios.

Esta guía te mostrará cómo configurar una página de estado autohospedada usando el proyecto Gatus en una computadora de placa única (SBC) como una Raspberry Pi, aprovechando Docker Compose para una configuración sencilla. También cubriremos la configuración de alertas por correo electrónico y Telegram para notificaciones instantáneas.

Aunque el proceso es muy sencillo, si tienes dificultades en alguna parte de esta guía, todo el código visto en esta guía estará alojado en el siguiente repositorio de GitHub para que puedas probarlo tú mismo.

LinuxBoards/status-page-project

¿Por qué usar una página de estado?

Una página de estado proporciona una forma transparente de comunicar el estado de tus servicios. Ayuda en:

Monitorear el tiempo de actividad y el rendimiento del sitio web
Alertarte instantáneamente sobre cualquier tiempo de inactividad.
Generar confianza con los usuarios al mostrarles el estado del servicio en tiempo real.

Configurar la página de estado

Para este proyecto utilizaremos Gatus.

Gatus es un tablero de salud orientado a desarrolladores para monitorizar servicios utilizando consultas HTTP, ICMP, TCP y DNS. Evalúa los resultados con condiciones en códigos de estado, tiempos de respuesta, expiración de certificados y más. También soporta alertas a través de correo electrónico, Telegram, Slack, Teams, PagerDuty, Discord, Twilio y otras plataformas.

Prerrequisitos

Antes de comenzar, asegúrate de tener lo siguiente:

Una computadora de placa única (por ejemplo, Raspberry Pi) con un sistema operativo Linux en funcionamiento.
Docker y Docker Compose instalados en tu SBC.
Acceso a un servidor de correo electrónico y una cuenta de Telegram con token de bot para alertas.

1. Instalar Docker y Docker Compose

Primero, instalemos Docker y Docker Compose en tu SBC. Abre una terminal y ejecuta los siguientes comandos:

# Actualizar la lista de paquetes
sudo apt update -y && sudo apt upgrade -y

# Instalar Docker
curl -fsSL https://get.docker.com -o get-docker.sh && sudo sh get-docker.sh

# Instalar Docker Compose
sudo apt install -y docker-compose

# Iniciar el servicio de Docker
sudo systemctl restart docker.service

Verifica la instalación:

docker --version
docker-compose --version

2. Crear un repositorio local de Git

Crea un directorio donde crearemos todos los archivos necesarios para la página de estado. También rastrearemos todos los cambios del proyecto en un repositorio Git para gestionar mejor los cambios.

# Crear el directorio del proyecto
mkdir -p status-page
cd status-page

# Inicializar el repositorio git
git init

# Crear tu rama principal
git checkout -b main

Si decides empujar este repositorio local a un repositorio remoto público o privado en GitHub, GitLab, Bitbucket u otro servicio de repositorios git alojados, puedes empujar tus cambios con lo siguiente:

# Establecer tu origen. Usando URL SSH dirigido a GitHub
git remote add origin [email protected]:<USUARIO>/<REPOSITORIO>.git

Donde <USUARIO> es tu nombre de usuario de GitHub y <REPOSITORIO> es el repositorio que creaste para este proyecto.

3. Crear un archivo Docker Compose

Crea un archivo docker-compose.yml en el directorio con el siguiente contenido:

services:
  gatus:
    image: twinproduction/gatus:latest
    restart: unless-stopped
    ports:
      - 8080:8080
    env_file:
      - .env
    volumes:
      - ./config:/config
    networks:
      - backend
      - database
    depends_on:
      - postgresql

  postgresql:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: "${DB_NAME}"
      POSTGRES_USER: "${DB_USER}"
      POSTGRES_PASSWORD: "${DB_PASS}"
      POSTGRES_INITDB_ARGS: --auth-host=scram-sha-256 --auth-local=scram-sha-256
      POSTGRES_HOST_AUTH_METHOD: scram-sha-256
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U '${DB_USER}' -h '${DB_HOST}' -d '${DB_NAME}'"]
      interval: 1m
      timeout: 30s
      retries: 3
      start_period: 1m30s
    networks:
      - database
    volumes:
      - pgsqldata:/var/lib/postgresql/data

networks:
  backend: {}
  database: {}

volumes:
  pgsqldata: {}

3.1. Configurar variables de entorno

Las siguientes variables de entorno se utilizarán, desde el archivo .env, para configurar algunas partes de la aplicación, incluyendo el logotipo y la conexión a la base de datos.

APP_TITLE='Página de estado'
APP_DESCRIPTION='Página de estado para mis sitios web personales'
APP_HEADER='Mi página de estado'
APP_LOGO='https://i.imgur.com/lYVCvAG.png'
APP_LINK='https://linuxboards.com'

DB_HOST=postgresql
DB_PORT=5432
DB_NAME=
DB_USER=
DB_PASS=
DATABASE_DSN="postgres://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}?sslmode=disable"

DNS_RESOLVER=1.1.1.1

TELEGRAM_BOT_TOKEN=
TELEGRAM_USER_ID=

EMAIL_HOST=
EMAIL_PORT=587
EMAIL_FROM=
EMAIL_USERNAME=
EMAIL_PASSWORD=
EMAIL_INSECURE=false
EMAIL_TO=

4. Configurar Gatus

Crea un archivo config.yaml dentro de un directorio config. Este archivo definirá los servicios que deseas monitorizar y los mecanismos de alerta.

mkdir -p config && touch config/config.yaml

Here is an example configuration file:

ui:
  title: '${APP_TITLE}'
  description: '${APP_DESCRIPTION}'
  header: '${APP_HEADER}'
  logo: '${APP_LOGO}'
  link: '${APP_LINK}'

storage:
  type: postgres
  path: '${DATABASE_DSN}'

x-uptime-options: &uptime-options
  interval: 1m
  conditions:
    - '[STATUS] == 200'
    - '[RESPONSE_TIME] < 1000'
  alerts:
    - type: email
      description: 'Validación del tiempo de actividad del sitio web'
      send-on-resolved: true

x-domain-options: &domain-options
  client:
    dns-resolver: 'tcp://${DNS_RESOLVER}:53'
  interval: 5m
  conditions:
    - '[DOMAIN_EXPIRATION] > 720h'
  alerts:
    - type: email
      description: 'Validación del dominio del sitio web'
      send-on-resolved: true

x-cert-options: &cert-options
  client:
    dns-resolver: 'tcp://${DNS_RESOLVER}:53'
  interval: 5m
  conditions:
    - '[CERTIFICATE_EXPIRATION] > 48h'
  alerts:
    - type: email
      description: 'Validación del certificado SSL/TLS del sitio web'
      send-on-resolved: true

alerting:
  email:
    host: '${EMAIL_HOST}'
    port: ${EMAIL_PORT}
    username: '${EMAIL_USERNAME}'
    password: '${EMAIL_PASSWORD}'
    from: '${EMAIL_FROM}'
    to: '${EMAIL_TO}'
    client:
      insecure: ${EMAIL_INSECURE}

  telegram:
    token: '${TELEGRAM_BOT_TOKEN}'
    id: '${TELEGRAM_USER_ID}'

endpoints:
  # Tiempo de actividad
  - name: Linux Boards
    group: 01. Web
    url: 'https://linuxboards.com'
    <<: *uptime-options

  # Dominio
  - name: Duck Duck Go
    group: 02. Dominios
    url: 'https://duckduckgo.com'
    <<: *domain-options

  # Certificados
  - name: Example Domain
    group: 03. Certificados
    url: 'https://example.org'
    <<: *cert-options

4.2. Configuración de alertas por correo electrónico

Para enviar alertas por correo electrónico necesitarás configurar un servidor SMTP. Puedes usar el de cualquier servicio de correo electrónico existente que uses como Zoho Mail, o para pruebas puedes usar servicios como Mailtrap o Mailpit.

EMAIL_HOST=
EMAIL_PORT=587
EMAIL_FROM=
EMAIL_USERNAME=
EMAIL_PASSWORD=
EMAIL_INSECURE=false
EMAIL_TO=

Información como el host, puerto, de, nombre de usuario y contraseña son proporcionados por el servicio de correo electrónico. La variable de entorno EMAIL_INSECURE controla si debe omitir la validación TLS. La mayoría de los servicios SMTP soportan esto por lo que puedes dejarlo como false (no omitir validación).

El valor de EMAIL_TO es una cadena texto con direcciones de correo electrónico separadas por coma a las que se enviará la notificación.

4.3. Configuración de alertas por Telegram

Para las alertas por Telegram necesitarás crear un bot con @BotFather para obtener un token de bot.

Luego necesitarás tu ID de usuario para que las notificaciones se envíen solo a ti. Puedes usar algunos bots que te dan esta información como @MissRose_bot.

5. Iniciar Gatus

Ahora la parte más emocionante de la guía: ejecutar nuestra propia página de estado.

sudo docker-compose up --remove-orphans --force-recreate -d

Gatus ahora estará en funcionamiento, y puedes acceder a la página de estado visitando http://localhost:8080 en tu navegador web.

6. Verificar tu configuración

Visita la página de estado para verificar que tu sitio web está siendo monitorizado. Deberías ver el servicio que definiste y su estado actual. Prueba las alertas tomando temporalmente tu sitio web fuera de línea y verifica si recibes notificaciones por correo electrónico y Telegram.

También puedes ver los registros de Docker Compose para verificar que todo esté funcionando correctamente.

sudo docker-compose logs --tail 250 -f

Detalles del sitio en la página de estado

Conclusión

Configurar una página de estado autohospedada para monitorizar tus sitios web usando una computadora de placa única es sencillo con Gatus y Docker Compose. Esta configuración asegura que te alerten instantáneamente sobre cualquier problema, permitiéndote mantener un alto tiempo de actividad y confiabilidad para tus usuarios. ¡Mantente proactivo y mantén tus servicios funcionando sin problemas!

Para configuraciones y opciones más detalladas, consulta la documentación de Gatus.

Conozca Gatus - Un panel de control avanzado de estado de actividad

Siguiendo esta guía, aseguras que tus sitios web se monitoricen de manera efectiva, aprovechando el poder de las soluciones autohospedadas en computadoras de placa única y mecanismos de alerta modernos. ¡Feliz monitorización!