Cómo instalar Statping en Ubuntu 22.04

Statping es un monitor de tiempo de actividad de código abierto que realiza un seguimiento de sitios web y aplicaciones alojadas en múltiples servidores. Puede generar una hermosa página de estado al obtener datos en tiempo real de varias fuentes. Puede trabajar con múltiples sistemas de bases de datos, incluyendo SQLite, MySQL y Postgres. Para nuestro tutorial, utilizaremos el fork de Statping, llamado Statping-ng ya que la aplicación original ya no está en desarrollo.

En este tutorial, aprenderás cómo instalar Statping en un servidor Ubuntu 22.04 utilizando Docker y Nginx como proxy.

Requisitos previos

• Un servidor que ejecute Ubuntu 22.04.
• Un usuario no root con privilegios sudo.
• El Firewall sin complicaciones (UFW) está habilitado y en funcionamiento.
• Un nombre de dominio completamente calificado (FQDN) apuntando al servidor como status.example.com.
• Todo está actualizado. $ sudo apt update && sudo apt upgrade

Paso 1 - Configurar el Firewall

Antes de instalar cualquier paquete, el primer paso es configurar el firewall para permitir conexiones HTTP y HTTPS.

Verifica el estado del firewall.

$ sudo ufw status

Deberías ver algo como lo siguiente.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Permite los puertos HTTP y HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Verifica el estado nuevamente para confirmar.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Paso 2 - Instalar Docker

Agrega la clave GPG oficial de Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Ejecuta el siguiente comando para agregar el repositorio de Docker.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualiza el sistema para incluir el repositorio de Docker.

$ sudo apt update

Instala Docker y el plugin de Docker compose.

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Este tutorial utilizará el plugin de Docker Compose v2 en lugar del binario legado anterior. Por lo tanto, el comando para ejecutarlo ha cambiado de docker-compose a docker compose y esto se refleja aquí.

Docker se ejecuta con privilegios elevados, por lo que necesitarás usar sudo con frecuencia para ejecutar comandos. La mejor opción es agregar tu cuenta de usuario de Linux al grupo de usuarios docker.

$ sudo usermod -aG docker ${USER}

La variable ${USER} recoge la cuenta del sistema actualmente iniciada. Si no has iniciado sesión con el usuario al que deseas otorgar privilegios, reemplaza ${USER} con el nombre de usuario.

Para aplicar la nueva membresía del grupo, cierra sesión del servidor y vuelve a iniciar sesión, o utiliza el siguiente comando. Se te pedirá la contraseña del usuario.

$ su - ${USER}

Paso 3 - Instalar Nginx

Ubuntu 22.04 viene con una versión más antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.

Importa la clave de firma de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Agrega el repositorio para la versión estable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Actualiza los repositorios del sistema.

$ sudo apt update

Instala Nginx.

$ sudo apt install nginx

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.22.0

Paso 4 - Instalar SSL

Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot utilizando el repositorio de Ubuntu o obtener la última versión utilizando la herramienta Snapd. Usaremos la versión de Snapd.

Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd esté actualizada.

$ sudo snap install core

Instala Certbot.

$ sudo snap install --classic certbot

Utiliza el siguiente comando para asegurarte de que el comando Certbot se pueda ejecutar creando un enlace simbólico al directorio /usr/bin.

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

Ejecuta el siguiente comando para generar un certificado SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d status.example.com

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/status.example.com en tu servidor.

Genera un certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Abre el archivo /etc/letsencrypt/renewal/status.example.com.conf para editar.

$ sudo nano /etc/letsencrypt/renewal/status.example.com.conf

Pega el siguiente código al final.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Hemos generado el certificado SSL utilizando la opción independiente de Certbot. Ejecuta su servidor web para crear el certificado, lo que significa que Nginx debe estar apagado durante la renovación. Los comandos pre_hook y post_hook se ejecutan antes y después de la renovación para apagar y reiniciar automáticamente el servidor Nginx, por lo que no se requiere intervención manual.

Para verificar si la renovación de SSL está funcionando bien, haz una prueba del proceso.

$ sudo certbot renew --dry-run

Si no ves errores, estás listo. Tu certificado se renovará automáticamente.

Paso 5 - Configurar el archivo Docker Compose

Crea un directorio para el archivo Docker compose.

$ mkdir ~/statping

Cambia al directorio.

$ cd ~/statping

Crea y abre el archivo docker compose para editar.

$ nano docker-compose.yml

Pega el siguiente código en él.

services:
  statping:
    container_name: statping
    image: adamboutcher/statping-ng
    restart: always
    ports:
      - 8080:8080
    volumes:
      - ./statping_data:/app
    links:
      - postgres
    depends_on:
      - postgres
    environment:
      DB_CONN: postgres
      DB_HOST: postgres
      DB_PORT: 5432
      DB_DATABASE: statping
      DB_USER: root
      DB_PASS: password123
      NAME: 'Página de Statping de Howtoforge'
      DESCRIPTION: 'Página de demostración de Statping'
      USE_ASSETS: 'true'
      SAMPLE_DATA: 'false'
      ALLOW_REPORTS: 'false'
      ADMIN_USER: navjot
      ADMIN_PASSWORD: yourpassword

  postgres:
    container_name: postgres
    image: postgres:14-alpine
    ports:
      - 5432:5432
    volumes:
      - ./pg_data:/var/lib/postgresql/data/pg_data
    environment:
      POSTGRES_PASSWORD: password123
      POSTGRES_DB: statping
      POSTGRES_USER: root
      POSTGRES_PORT: 5432
      PGDATA: /var/lib/postgresql/data/pg_data

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Estamos configurando las imágenes de Docker de Statping y Postgres. La mayor parte del archivo docker es fácil de seguir. Estamos utilizando copias de seguridad en disco local para almacenar los datos de la aplicación y la base de datos de Postgres. También hemos configurado varias variables de entorno para configurar la aplicación y la base de datos. Echemos un vistazo a ellas. Para obtener una lista completa de las variables de entorno que puedes definir, consulta la lista oficial del repositorio de GitHub de Statping.

• La variable USE_ASSETS permite a la aplicación utilizar los activos de la carpeta assets.
• La variable SAMPLE_DATA está configurada como falsa para deshabilitar los monitores predeterminados que Statping configura durante la instalación.
• La variable ALLOW_REPORTS está configurada como falsa para deshabilitar los informes de errores anónimos que envía Statping.
• Las variables ADMIN_USER y ADMIN_PASSWORD se utilizan para establecer la información de inicio de sesión para el usuario predeterminado.
• Las variables DB_ se utilizan para establecer las credenciales de la base de datos que deben coincidir con las variables definidas para el contenedor de Postgres.

Paso 6 - Configurar Nginx

Abre el archivo /etc/nginx/nginx.conf para editar.

$ sudo nano /etc/nginx/nginx.conf

Agrega la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Crea y abre el archivo /etc/nginx/conf.d/statusping.conf para editar.

$ sudo nano /etc/nginx/conf.d/statusping.conf

Pega el siguiente código en él. Reemplaza status.example.com con tu nombre de dominio.

upstream backend {
   server 127.0.0.1:8080;
   keepalive 32;
}

server {
  listen 80 default_server;
  server_name status.example.com;
  return 301 https://$server_name$request_uri;
}

server {
   listen 443 ssl http2;
   server_name status.example.com;

   http2_push_preload on; # Habilitar HTTP/2 Server Push

   ssl_certificate /etc/letsencrypt/live/status.example.com/fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live/status.example.com/privkey.pem;
   ssl_trusted_certificate /etc/letsencrypt/live/status.example.com/chain.pem;
   ssl_session_timeout 1d;

   # Habilitar versiones de TLS (TLSv1.3 es requerido para el próximo HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Habilitar 0-RTT de TLSv1.3. Usa $ssl_early_data al hacer proxy inverso para
   # prevenir ataques de repetición.
   #
   # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
   ssl_early_data on;

   ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
   ssl_prefer_server_ciphers on;
   ssl_session_cache shared:SSL:50m;
   # OCSP Stapling --- obtener registros OCSP de la URL en ssl_certificate y almacenarlos en caché
   ssl_stapling on;
   ssl_stapling_verify on;
   ssl_dhparam /etc/ssl/certs/dhparam.pem;

   add_header X-Early-Data $tls1_3_early_data;

   access_log /var/log/nginx/statusping.access.log main;
   error_log  /var/log/nginx/statusping.error.log;

   location / {
       client_max_body_size 50M;
       proxy_set_header Connection "";
       proxy_set_header Host $http_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;
       proxy_set_header X-Frame-Options SAMEORIGIN;
       proxy_set_header X-Client-Verify  SUCCESS;
       proxy_set_header X-Client-DN      $ssl_client_s_dn;
       proxy_set_header X-SSL-Subject    $ssl_client_s_dn;
       proxy_set_header X-SSL-Issuer     $ssl_client_i_dn;
       proxy_buffers 256 16k;
       proxy_buffer_size 16k;
       proxy_read_timeout 1800s;
       proxy_connect_timeout 1800s;
       proxy_http_version 1.1;
       proxy_pass http://backend;
   }
}

# Este bloque es útil para depurar TLS v1.3. Siéntete libre de eliminar esto
# y usar la variable `$ssl_early_data` expuesta por NGINX directamente si así lo
# deseas.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Verifica tu configuración de Nginx.

$ sudo nginx -t

Reinicia el servidor Nginx.

$ sudo systemctl restart nginx

Paso 7 - Ejecutar Statping

Cambia al directorio Statping.

$ cd ~/statping

Crea y lanza el contenedor de Docker.

$ docker compose up -d

Verifica el estado del contenedor.

$ docker compose ps

Verás la siguiente salida.

NAME                COMMAND                  SERVICE             STATUS              PORTS
postgres            "docker-entrypoint.s…"   postgres            running             0.0.0.0:5432->5432/tcp
statping            "/bin/sh -c 'statpin…"   statping            running (healthy)   0.0.0.0:8080->8080/tcp

También puedes usar el comando docker ps para obtener un estado más detallado. Para verificar los registros del contenedor, utiliza el comando docker logs .

Paso 8 - Configurar Statping

Ahora que tu contenedor está en funcionamiento, lanza la URL https://status.example.com en tu navegador y verás una página de estado en blanco. Si omites la variable SAMPLE_DATA en el archivo docker compose, verás una página completa con diferentes servicios predefinidos.

Haz clic en el enlace Dashboard en la parte inferior para acceder a la pantalla de inicio de sesión.

Completa admin como nombre de usuario y contraseña predeterminados. Asegúrate de escribir el nombre de usuario también, aunque parezca que ya está prellenado. Haz clic en el botón Sign in para acceder al panel de control de Statping.

Para agregar un nuevo servicio, haz clic en el botón Create y completa los valores requeridos.

Haz clic en el botón Create service en la parte inferior para finalizar. Para configurar el correo electrónico y otras notificaciones, visita la página de configuración. También puedes darle un nuevo nombre a tu página de estadísticas.

Paso 9 - Actualizar Statping

Actualizar Statping es un paso simple. Cambia al directorio de Docker compose de Statping.

$ cd ~/statping

A continuación, detén y elimina el contenedor existente. Tus datos se conservarán.

$ docker compose down --remove-orphans

Descarga la última versión de la imagen de Docker de Statping.

$ docker compose pull

Inicia los contenedores nuevamente.

$ docker compose up -d

Tu instalación de Statping está actualizada y se ha iniciado nuevamente.

Conclusión

Esto concluye el tutorial donde aprendiste cómo instalar Statping en un servidor Ubuntu 22.04. Si tienes alguna pregunta, publícalas en los comentarios a continuación.