Bot para monitorear servicios web en media hora: telegram + bash + cron

A veces, necesitas implementar rápidamente la monitorización de un nuevo servicio, pero no dispones de la infraestructura ni de los conocimientos necesarios. En esta guía, implementaremos una herramienta para monitorizar cualquier servicio web en media hora, utilizando únicamente herramientas integradas. ubuntu: bash, cron y curl. Usaremos Telegram para enviar notificaciones.

La “guinda del pastel” será la implicación emocional de los usuarios. Probado en personas: funciona.

Cuando en el servicio de telemedicina Doctor Near creamos un chatbot para determinar el nivel de estrés de los usuarios, necesitábamos seguimiento. En un par de horas se creó un miniproyecto que no sólo funciona muy bien, sino que además aporta positividad con sus mensajes.

Primero, consigamos un repositorio con scripts:

git clone https://github.com/rshekhovtsov/msms.git

Vaya a la carpeta msms y luego trabaje en ella.

Si Telegram está bloqueado, use un proxy. La opción más sencilla y fiable son los torsocks:

sudo apt install tor
sudo apt install torsocks

Como ejemplo, configuremos el seguimiento de la página de inicio de google.com en tres pasos.

PASO 1. Crea un bot en Telegram y obtén la identificación del usuario.

• En la barra de búsqueda de contactos en telegram buscamos @botpadre:

  

• Lo lanzamos con el botón Inicio, ingresamos el comando /newbot y respondemos las preguntas. Debes tener en cuenta que nombre es el nombre del bot que se mostrará a los usuarios, y el nombre de usuario es único y debe terminar con "bot":

  
  
  Entre otras cosas, el bot emitirá un token secreto para la API HTTP, que debe copiarse y guardarse en el archivo telegram-api-key.txt en la carpeta msms.

• Escribimos el nombre de nuestro bot en la barra de búsqueda de Telegram y lo ejecutamos.
• Como toque final, añadimosnos a la lista de destinatarios de alertas de seguimiento:

  sudo chmod +x ./recipients-setup.sh
  torsocks ./recipients-setup.sh

  El script mostrará una lista de llamadas recientes al bot; debe haber una línea con nuestra identificación y nombre en Telegram. Tomamos esta identificación y la guardamos en el archivo services/google-recipients.txt. Formato de archivo: cada línea es una identificación. Ejemplo:

  123456789
  987654321

Para agregar un nuevo destinatario, debe pedirle que inicie el bot en Telegram, ejecute destinatarios-setup.sh y agregue la identificación al archivo.

PASO 2. Configurar el monitoreo

El servicio se describe creando un archivo ini en la carpeta de servicios. Debe configurar cinco parámetros:

1. MSMS_SERVICE_NAME: nombre del servicio: se utilizará en las alertas y el registro de seguimiento.
2. MSMS_SERVICE_ENDPOINT: punto final del servicio al que contactaremos con curl.
3. MSMS_CURL_PARAMS: opciones de rizo adicionales, consulte el ejemplo a continuación.
4. MSMS_EXPECTED: respuesta esperada del servicio. Se utiliza si la respuesta es corta.
5. MSMS_EXPECTED_FILE: nombre de archivo con la respuesta de servicio esperada. Si se especifica, sobrescribe MSMS_EXPECTED.
6. MSMS_RECIPIENTS: archivo con una lista de destinatarios de notificaciones.

Una solicitud a google.com devuelve un HTML fijo con una redirección, lo usaremos como la respuesta esperada del servidor:

curl google.com > services/google-response.html

Creemos el archivo services/google.ini:

MSMS_SERVICE_NAME='google front page'

# service endpoint
MSMS_SERVICE_ENDPOINT='google.com'

# curl parameters
MSMS_CURL_PARAMS='-s --connect-timeout 3 -m 7'

# expected service response
MSMS_EXPECTED_FILE='google-response.html'

# recipients list file
MSMS_RECIPIENTS='google-recipients.txt'

В MSMS_CURL_PARAMS puedes configurar todo lo que curl puede hacer, incluyendo:

1. Deshabilite los mensajes curl para evitar saturar la consola y el registro: -s
2. Establezca el tiempo de espera de la conexión con el servicio que se está verificando (en segundos): --connect-timeout 3
3. Establecer tiempo de espera de respuesta: -m 7
4. Deshabilite la verificación de certificado para SSL (por ejemplo, si está utilizando un certificado autofirmado): --insecure
5. Especifique el tipo de solicitud http: -X POST
6. Especificar encabezados: -H "Content-Type: application/json"
7. Especifique el cuerpo de la solicitud como una cadena o archivo. Ejemplo de un archivo: -d @request.json

Desactivamos las notificaciones y establecimos tiempos de espera de 3 segundos. para conectar y 7 seg. para recibir una respuesta de servicio.

¡Atención: especifique los valores de los parámetros entre comillas simples, como en el ejemplo. Desafortunadamente, bash es bastante frágil en este sentido, y una mariposa accidental con unas comillas incorrectas puede provocar la muerte del universo con errores difíciles de diagnosticar.

Hemos configurado el seguimiento. Comprobemos que todo está bien:

sudo chmod +x ./monitoring.sh
torsocks ./monitoring.sh

El script debería mostrar un mensaje como:

2020-01-10 12:14:31
health-check "google front page": OK

PASO 3. Configurar un horario

Configuremos un cronograma de monitoreo en cron:

sudo crontab -e

Agreguemos una línea para verificar google.com cada minuto:

*/1 * * * * torsocks <ПУТЬ К ПАПКЕ РЕПОЗИТОРИЯ>/monitoring.sh >> <ПУТЬ К ПАПКЕ РЕПОЗИТОРИЯ>/monitoring.log 2>&1

Agregaremos una alerta todos los días a las 11.00:XNUMX am, confirmando la funcionalidad del monitoreo en sí. Para hacer esto, pasaremos el parámetro DIARIO al script:

0 11 * * * torsocks <ПУТЬ К ПАПКЕ РЕПОЗИТОРИЯ>/monitoring.sh DAILY >> <ПУТЬ К ПАПКЕ РЕПОЗИТОРИЯ>/monitoring.log 2>&1

2>&1 - una técnica estándar que redirige los errores al flujo de salida principal. Como resultado, también terminarán en el registro de seguimiento.

Guardemos los cambios y retomemos con el comando:

 sudo service cron reload

Puede leer más sobre cómo configurar cron, por ejemplo, aquí.

Así, cada minuto se lanzará un script de seguimiento que contactará con google.com a través de curl. Si la respuesta recibida difiere de la esperada, el script enviará una notificación de telegrama a la lista de destinatarios. El registro de auditoría se guarda en el archivo Monitoring.log.

Si necesitamos agregar otro servicio, simplemente creamos un nuevo archivo ini en la carpeta de servicios y, si es necesario, creamos una lista separada de destinatarios. Todo lo demás funcionará automáticamente.

Si el servicio que se está verificando deja de estar disponible, se enviará una alerta cada minuto. Si no puede restaurar rápidamente el servicio, puede desactivar temporalmente las notificaciones en las propiedades de Telegram del bot.

Ahora echemos un vistazo más de cerca a las funciones adicionales y la implementación de scripts.

Patrones de mensajes y compromiso emocional

Para que la comunicación con el bot sea más animada, lo llamamos Manechka, le agregamos una imagen de avatar adecuada y contratamos especialistas profesionales en relaciones públicas para crear los textos de los mensajes. Puedes utilizar nuestra experiencia o cambiarla a tu gusto.

Por ejemplo:

o incluso así:

¿Por qué no?

El nombre del bot y el avatar se configuran a través de @botpadre.
Las plantillas de mensajes están en la carpeta. plantillas:

• curl-fail.txt: mensaje enviado cuando curl devuelve un código de error distinto de cero. Suele hablar de la imposibilidad de llegar al servicio.
• diario.txt: Mensaje diario confirmando que el monitoreo del servicio está funcionando.
• servicio-fallo.txt: Un mensaje enviado cuando la respuesta del servicio es diferente a lo esperado.

Veamos las opciones de personalización usando plantillas de mensajes integradas como ejemplo.
Las plantillas usan emoji. Desafortunadamente, habr no los muestra.
Para seleccionar emoji, es conveniente utilizar la búsqueda en emojipedia.org:

Simplemente copie y pegue el símbolo apropiado en el texto de la plantilla (esto es Unicode normal).

1. curl-fail.txt:

   Котёнок,  помоги мне... 
   Не могу достучаться до сервиса "$MSMS_SERVICE_NAME" 
   `CURL EXIT CODE: $EXIT_CODE`

   Usamos el nombre del servicio que especificamos (variable MSMS_SERVICE_NAME) y una variable de script interna con código de salida curl (EXIT_CODE). También formateamos el mensaje usando marcado. rebaja de telegramas: Los caracteres "`" rodean el texto de ancho fijo. Dado que las comillas y los apóstrofes son símbolos bash, los escapamos con "". Los nombres de las variables están precedidos por un signo "$".

   Resultado:

   

2. servicio-fallo.txt:

   Котёнок, помоги мне... 
   Сервис "$MSMS_SERVICE_NAME" меня расстроил
   Он работает неправильно, вот что он мне отвечает:
   `$RESPONSE`

   Resultado:

   
   
   Aquí usamos otra variable de script: RESPONSE. Contiene la respuesta del servicio.

3. diario.txt:

   Малыш, привет!
   У меня всё хорошо, cлежу за сервисом:
   "$MSMS_SERVICE_NAME" каждую минутку...
   А как у тебя дела?
   

   Resultado:

   

Pasemos a la implementación de scripts.

Guión de seguimiento

monitoreo.sh realiza un descubrimiento automático simple: toma todos los archivos ini de la carpeta de servicios y para cada uno ejecuta el script principal con la lógica para verificar y enviar alertas:

#!/bin/bash
cd $(dirname "$0")/services

for service_ini  in $(ls *.ini); do
    bash ../msms.sh "$1" "$service_ini"
done

Para generar un mensaje diario sobre el estado de monitoreo, puede pasar el parámetro DIARIO al script.

Tenga en cuenta que cuando se inicia el script, la carpeta actual cambia a servicios. Esto le permite especificar rutas de archivos relativas a los servicios en archivos ini.

Script para comprobar y enviar notificaciones.

msms.sh Contiene la lógica principal para verificar el servicio y enviar alertas.

Trabajando con telegrama:

# telegram endpoint
TG_API_URL="https://api.telegram.org/bot$(cat ../telegram-api-key.txt)/sendMessage"

#################################################################
# send message to telegram
# parameter: message text
#################################################################
function send_message {
    for chat_id  in $(cat ../$MSMS_RECIPIENTS); do
	curl -s -X POST --connect-timeout 10 $TG_API_URL -d chat_id=$chat_id -d parse_mode="Markdown" -d text="$1"
	echo
    done
}

Generamos una URL para acceder a la API REST de Telegram utilizando la clave secreta guardada en el archivo.

La función send_message usa curl para enviar mensajes a esta API REST, tomando los identificadores de destinatario del archivo que especificamos en el archivo ini. En los datos que enviamos, indicamos que utilizamos marcado de mensajes: parse_mode="Markdown".

Mostremos la fecha y hora actuales y carguemos el archivo ini.

echo $(date '+%Y-%m-%d %H:%M:%S')

# load variables from .ini file:
. $2

cuerda magica . $2 ejecuta el archivo ini pasado a la entrada como segundo parámetro como un script normal, ingresando los valores especificados en él en las variables de entorno.

Cargue la respuesta esperada del archivo si se especifica el parámetro MSMS_EXPECTED_FILE:

if [ -n "$MSMS_EXPECTED_FILE" ]; then
 MSMS_EXPECTED="$(cat "$MSMS_EXPECTED_FILE")"
fi

Comprobaremos el servicio y enviaremos alertas si es necesario:

RESPONSE="$(eval curl $MSMS_CURL_PARAMS "$MSMS_SERVICE_ENDPOINT")"
EXIT_CODE=$?
if [[ $EXIT_CODE != 0 ]]; then
    echo health-check "$MSMS_SERVICE_NAME" FAILED: CURL EXIT WITH $EXIT_CODE
    MESSAGE="$(cat ../templates/curl-fail.txt)"
    MESSAGE=$(eval echo $MESSAGE)
    send_message "$MESSAGE"
elif [[ "$RESPONSE" != "$MSMS_EXPECTED" ]]; then
    echo health-check "$MSMS_SERVICE_NAME" FAILED: "$RESPONSE"
    MESSAGE="$(cat ../templates/service-fail.txt)"
    MESSAGE=$(eval echo $MESSAGE)
    send_message "$MESSAGE"
else
    echo health-check "$MSMS_SERVICE_NAME": OK
fi

Primero asignamos a la variable. RESPONSE el resultado de ejecutar el comando curl para este servicio.

Expresión EXIT_CODE=$? pone el resultado del último comando en una variable, es decir rizo. Si es necesario enviar una alerta, la plantilla se lee del archivo correspondiente y se envía a los destinatarios mediante send_message.

El último bloque procesa el parámetro DIARIO:

if test "$1" = "DAILY"; then
    echo health-check "$MSMS_SERVICE_NAME" DAILY
    MESSAGE="$(cat ../templates/daily.txt)"
    MESSAGE=$(eval echo $MESSAGE)
    send_message "$MESSAGE"
fi

Envía un mensaje confirmando la funcionalidad del propio seguimiento.

Obtener una lista de ID de usuario

destinatarios-setup.sh llama a la API de Telegram para obtener los últimos mensajes dirigidos al bot:

curl -s https://api.telegram.org/bot$(cat telegram-api-key.txt)/getUpdates 
| python recipients-setup.py

Esto utiliza la magia de Python para mostrar una lista de manera hermosa. Esto no es necesario, simplemente puede tomar la identificación deseada de json, que el comando generará:

torsocks curl -s https://api.telegram.org/bot$(cat telegram-api-key.txt)/getUpdates

Conclusión

Por lo tanto, puede utilizar scripts y plantillas de mensajes ya preparados, configurando solo servicios monitoreados y listas para alertas; puedes crear una nueva "personalidad" para el bot; o puedes tomar tu propia decisión en base a lo propuesto.

Las opciones para un mayor desarrollo sugieren configurar y administrar el monitoreo en el propio bot, pero aquí no puedes prescindir de Python. Si alguien lo recibe antes que yo, sabrá dónde enviar la solicitud de extracción :)

Fuente: habr.com