Bot de monitoring de services Web en 30 minutes : telegram + bash + cron

Parfois, il est nécessaire d'effectuer rapidement une surveillance d'un nouveau service, mais il n'y a pas d'infrastructure ou d'expertise prête à l'emploi. Dans ce guide, nous allons mettre en place en une demi-heure un outil de surveillance pour tous les services web, en utilisant uniquement les outils intégrés d'ubuntu : bash, cron et curl. Pour l'envoi des notifications, nous utiliserons telegram.

L'« cerise sur le gâteau » sera l'engagement émotionnel des utilisateurs. Testé sur des gens — ça fonctionne.

Lorsque nous avons créé un chatbot pour évaluer le niveau de stress des utilisateurs dans notre service de télémédecine, Docteur Près de Vous, nous avions besoin de surveillance. Un mini-projet a été réalisé en quelques heures, qui non seulement fonctionne très bien, mais apporte également de la positivité avec ses messages.

Pour commencer, récupérons le référentiel contenant les scripts :

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

Passons dans le dossier msms et travaillons à l'intérieur.

Si telegram est bloqué, utilisez un proxy. La méthode la plus simple et fiable est torsocks :

sudo apt install tor
sudo apt install torsocks

Comme exemple, configurons la surveillance de la page d'accueil google.com en trois étapes.

ÉTAPE 1. Créez un bot sur telegram et obtenez l'ID utilisateur.

• Dans la barre de recherche des contacts sur telegram, recherchez @botfather:

  

• Lancez-le avec le bouton Start, tapez la commande /newbot et répondez aux questions. Il est important de noter que le nom est le nom du bot, qui sera affiché aux utilisateurs, tandis que le nom d'utilisateur doit être unique et se terminer par « bot » :

  
  
  Entre autres, le bot vous fournira un token secret pour l'API HTTP, que vous devez copier et enregistrer dans le fichier telegram-api-key.txt dans le dossier msms.

• Tapez dans la barre de recherche telegram le nom de notre bot et lancez-le.
• Pour terminer, ajoutons-nous à la liste des destinataires des notifications de surveillance :

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

  Le script affichera la liste des dernières interactions avec le bot, il devrait y avoir une ligne avec notre ID et notre nom sur telegram. Prenez cet ID et enregistrez-le dans le fichier services/google-recipients.txt. Le format du fichier : chaque ligne - un ID. Exemple :

  123456789
  987654321

Pour ajouter un nouveau destinataire, demandez-lui de démarrer le bot sur telegram, de lancer recipients-setup.sh et d'ajouter l'ID au fichier.

ÉTAPE 2. Configurons la surveillance.

La description du service se fait en créant un fichier ini dans le dossier services. Nous devons définir cinq paramètres :

1. MSMS_SERVICE_NAME: le nom du service — sera utilisé dans les notifications et dans le journal de surveillance.
2. MSMS_SERVICE_ENDPOINT: endpoint du service, vers lequel nous allons faire des requêtes avec curl.
3. MSMS_CURL_PARAMS: paramètres supplémentaires pour curl, voir exemple ci-dessous.
4. MSMS_EXPECTED: réponse attendue du service. Utilisé si la réponse est courte.
5. MSMS_EXPECTED_FILE: nom du fichier contenant la réponse attendue du service. Si spécifié, remplace MSMS_EXPECTED.
6. MSMS_RECIPIENTS: fichier contenant la liste des destinataires des notifications.

La requête sur google.com renvoie un html fixe avec redirection, nous allons l'utiliser comme réponse attendue du serveur :

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

Créons le fichier services/google.ini :

MSMS_SERVICE_NAME='page d'accueil google'

# point de terminaison du service
MSMS_SERVICE_ENDPOINT='google.com'

# paramètres curl
MSMS_CURL_PARAMS='-s --connect-timeout 3 -m 7'

# réponse attendue du service
MSMS_EXPECTED_FILE='google-response.html'

# fichier de liste des destinataires
MSMS_RECIPIENTS='google-recipients.txt'

Dans MSMS_CURL_PARAMS tout ce que curl peut faire peut être spécifié, y compris :

1. Désactiver les messages curl pour éviter d'encombrer la console et le journal : -s
2. Définir le délai de connexion avec le service vérifié (en secondes) : --connect-timeout 3
3. Définir le délai d'attente pour recevoir une réponse : -m 7
4. Désactiver la vérification du certificat pour SSL (par exemple, si un certificat auto-signé est utilisé) : --insecure
5. Indiquer le type de requête http : -X POST
6. Indiquer les en-têtes : -H "Content-Type: application/json"
7. Indiquer le corps de la requête sous forme de chaîne ou de fichier. Exemple pour un fichier : -d @request.json

Nous avons désactivé les notifications et défini des délais de 3 s pour la connexion et de 7 s pour recevoir la réponse du service.

Attention: indiquez les valeurs des paramètres entre guillemets simples, comme dans l'exemple. Malheureusement, bash est assez fragile à cet égard, et un guillemet mal placé peut entraîner des erreurs difficiles à diagnostiquer.

Nous avons configuré la surveillance. Vérifions que tout va bien :

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

Le script doit afficher un message sous cette forme :

2020-01-10 12:14:31
health-check "page d'accueil google": OK

ÉTAPE 3. Configurer le calendrier

Configurons le calendrier de surveillance dans cron :

sudo crontab -e

Ajoutons une ligne pour vérifier google.com chaque minute :

*/1 * * * * torsocks /monitoring.sh >> /monitoring.log 2>&1

Ajoutons une notification quotidienne à 11h00 confirmant la fonctionnalité de la surveillance elle-même. Pour cela, nous passerons le paramètre DAILY au script :

0 11 * * * torsocks /monitoring.sh DAILY >> /monitoring.log 2>&1

2>&1 — méthode standard redirigeant les erreurs vers le flux de sortie principal. En fin de compte, elles seront également enregistrées dans le journal de surveillance.

Enregistrons les modifications et appliquons-les avec la commande :

 sudo service cron reload

Vous pouvez lire davantage sur la configuration de cron, par exemple, ici.

Ainsi, un script de surveillance sera exécuté chaque minute, qui interrogera google.com via curl. Si la réponse obtenue diffère de celle attendue, le script enverra une notification à la liste des destinataires sur Telegram. Le journal des vérifications est conservé dans le fichier monitoring.log.

Si vous devez ajouter un autre service, il vous suffit de créer un nouveau fichier ini pour lui dans le dossier services et, si nécessaire, de former une liste distincte de destinataires. Tout le reste fonctionnera automatiquement.

Si le service vérifié devient indisponible, la notification arrivera chaque minute. Si vous ne parvenez pas à rétablir rapidement le service, vous pouvez temporairement désactiver les notifications dans les paramètres du bot sur Telegram.

Voyons maintenant en détail les fonctionnalités supplémentaires et la mise en œuvre des scripts.

Modèles de messages et engagement émotionnel

Pour rendre la communication avec le bot plus vivante, nous l'avons appelé Manечка, ajouté une image d'avatar correspondante et engagé des professionnels des relations publiques pour créer les textes des messages. Vous pouvez utiliser nos travaux ou les changer selon vos goûts.

Par exemple comme ceci :

ou même comme ça :

Pourquoi pas ?

Le nom du bot et l'avatar sont définis via @botfather.
Les modèles de messages se trouvent dans le dossier templates:

• curl-fail.txt: message envoyé lorsque curl renvoie un code d'erreur non nul. Cela indique généralement qu'il est impossible d'accéder au service.
• daily.txt: message quotidien confirmant que la surveillance du service fonctionne.
• service-fail.txt: message envoyé lorsque la réponse du service diffère de celle attendue.

Examinons les possibilités de personnalisation à l'aide des modèles de messages intégrés.
Les modèles utilisent des émojis. Malheureusement, habr ne les affiche pas.
Pour trouver des émojis, il est pratique d'utiliser la recherche sur emojipedia.org:

Il vous suffit de copier et coller le symbole approprié dans le texte du modèle (c'est un unicode ordinaire).

1. curl-fail.txt :

   Petit chat, aide-moi... 
   Je ne peux pas accéder au service "$MSMS_SERVICE_NAME" 
   `CODE DE SORTIE CURL : $EXIT_CODE`

   Nous avons utilisé le nom du service que nous avons défini (variable MSMS_SERVICE_NAME) et une variable interne du script avec le code de sortie de curl (EXIT_CODE). Nous avons également formaté le message à l'aide du balisage telegram markdown: les symboles "`" encadrent le texte à largeur fixe. Étant donné que les guillemets et les apostrophes sont des caractères spéciaux en bash, nous les échappons avec le caractère "". Les noms de variables sont précédés du signe "$".

   Résultat :

   

2. service-fail.txt :

   Petit chaton, aide-moi... 
   Le service "$MSMS_SERVICE_NAME" m'a déçu
   Il ne fonctionne pas correctement, voici ce qu'il me répond :
   `$RESPONSE`

   Résultat :

   
   
   Ici, nous utilisons une autre variable de script : RESPONSE. Elle contient la réponse du service.

3. daily.txt :

   Salut, petit !
   Je vais bien, je surveille le service :
   "$MSMS_SERVICE_NAME" chaque minute...
   Et toi, comment ça va ?
   

   Résultat :

   

Passons à la mise en œuvre des scripts.

Script de surveillance

monitoring.sh effectue une simple découverte automatique — récupère tous les fichiers ini du dossier services et exécute le script principal avec la logique de vérification et d'envoi d'alertes pour chacun :

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

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

Pour générer un message quotidien sur l'état de la surveillance, le script peut recevoir le paramètre DAILY.

Notez qu'au démarrage du script, le dossier actuel est changé à services. Cela permet de spécifier les chemins des fichiers à partir des fichiers ini par rapport à services.

Script de vérification et d'envoi d'alertes

msms.sh contient la logique principale de vérification du service et d'envoi d'alertes.

Travail avec telegram :

# 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
}

Nous formons l'URL pour accéder à l'API REST de telegram, en utilisant la clé secrète enregistrée dans le fichier.

La fonction send_message utilise curl pour envoyer des messages à cette API REST, en récupérant les ids des destinataires à partir du fichier que nous avons indiqué dans ini. Dans les données envoyées, nous précisons que nous utilisons le formatage des messages : parse_mode="Markdown".

Affichons la date-heure actuelle et chargeons le fichier ini.

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

# charger les variables depuis le fichier .ini :
. $2

La chaîne magique . $2 exécute le fichier ini passé en second paramètre comme un script ordinaire, stockant les valeurs définies dans des variables d'environnement.

Récupérons la réponse attendue à partir du fichier, si le paramètre est défini MSMS_EXPECTED_FILE:

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

Effectuons la vérification du service avec envoi d'alertes, si nécessaire :

RESPONSE="$(eval curl $MSMS_CURL_PARAMS "$MSMS_SERVICE_ENDPOINT")"
EXIT_CODE=$?
if [[ $EXIT_CODE != 0 ]]; then
    echo health-check "$MSMS_SERVICE_NAME" ÉCHOUÉ : CURL EXIT AVEC $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" ÉCHOUÉ : "$RESPONSE"
    MESSAGE="$(cat ..\/templates\/service-fail.txt)"
    MESSAGE=$(eval echo $MESSAGE)
    send_message "$MESSAGE"
else
    echo health-check "$MSMS_SERVICE_NAME" : OK
fi

Nous commençons par attribuer à la variable RESPONSE le résultat de l'exécution de la commande curl pour ce service.

Expression EXIT_CODE=$? stocke le résultat de la dernière commande, c'est-à-dire curl. En cas de besoin d'envoi d'une notification, le modèle est lu depuis le fichier correspondant et l'envoi est effectué aux destinataires via send_message.

Le dernier bloc traite le paramètre DAILY :

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

Il envoie un message confirmant le bon fonctionnement de la surveillance elle-même.

Obtention de la liste des ids utilisateurs

recipients-setup.sh se connecte à l'API de telegram pour récupérer les derniers messages adressés au bot :

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

Ici, la magie de python est utilisée pour un affichage soigné de la liste. Ce n'est pas obligatoire, on peut simplement prendre le bon id depuis le json qui sera affiché par la commande :

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

Conclusion

Ainsi, vous pouvez utiliser des scripts et des modèles de messages prêts à l'emploi, en configurant simplement les services surveillés et les listes pour les alertes ; vous pouvez créer une nouvelle « identité » pour le bot ; ou vous pouvez créer votre propre solution basée sur celle proposée.

Parmi les options d'évolution, on pourrait envisager la configuration et la gestion de la surveillance directement dans le bot, mais ici, il est impossible de faire sans python. Si quelqu'un trouve le temps avant moi — vous savez où envoyer la pull request 🙂

Source : habr.com