Bot zur Überwachung von Webdiensten in einer halben Stunde: telegram + bash + cron

Manchmal muss man schnell ein Monitoring für einen neuen Dienst einrichten, und es gibt keine fertige Infrastruktur oder Expertise zur Hand. In diesem Leitfaden werden wir in einer halben Stunde ein Tool zum Monitoring beliebiger Webdienste erstellen, wobei wir nur die integrierten Mittel von Ubuntu: bash, cron und curl verwenden. Zur Zustellung von Benachrichtigungen werden wir Telegram verwenden.

Das "Tüpfelchen auf dem i" wird das emotionale Engagement der Nutzer sein. Auf Menschen getestet - es funktioniert.

Als wir im telemedizinischen Dienst Doktor Rядом einen Chatbot zur Bestimmung des Stressniveaus der Nutzer erstellten, benötigten wir ein Monitoring. Innerhalb weniger Stunden wurde ein Mini-Projekt erstellt, das nicht nur hervorragend funktioniert, sondern auch mit seinen Nachrichten gute Laune verbreitet.

Zunächst holen wir das Repository mit den Skripten:

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

Wir wechseln in den Ordner msms und arbeiten dort weiter.

Wenn Telegram blockiert ist, verwenden Sie einen Proxy. Die einfachste und zuverlässigste Option ist torsocks:

sudo apt install tor
sudo apt install torsocks

Als Beispiel richten wir in drei Schritten das Monitoring der Startseite google.com ein.

SCHRITT 1. Erstellen Sie einen Bot in Telegram und erhalten Sie die Benutzer-ID.

• Im Suchfeld für Kontakte in Telegram suchen wir nach @botfather:

  

• Starten Sie ihn mit der Schaltfläche Start, geben Sie den Befehl /newbot ein und beantworten Sie die Fragen. Man sollte bedenken, dass name der Name des Bots ist, der den Benutzern angezeigt wird, während username einzigartig ist und mit „bot“ enden muss:

  
  
  Unter anderem gibt der Bot ein geheimes Token für die HTTP API aus, das Sie kopieren und in der Datei telegram-api-key.txt im Ordner msms speichern müssen.

• Geben Sie im Suchfeld von Telegram den Namen unseres Bots ein und starten Sie ihn.
• Als abschließenden Schliff fügen wir uns der Liste der Empfänger für die Monitoring-Benachrichtigungen hinzu:

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

  Das Skript gibt eine Liste der letzten Anfragen an den Bot aus; dort sollte eine Zeile mit unseren IDs und Namen in Telegram sein. Wir nehmen diese ID und speichern sie in der Datei services/google-recipients.txt. Das Format der Datei: jede Zeile - eine ID. Beispiel:

  123456789
  987654321

Um einen neuen Empfänger hinzuzufügen, muss man ihn bitten, den Bot in Telegram zu starten, recipients-setup.sh auszuführen und die ID in die Datei hinzuzufügen.

SCHRITT 2. Monitoring einrichten.

Die Beschreibung des Dienstes erfolgt durch die Erstellung einer ini-Datei im Ordner services. Es müssen fünf Parameter festgelegt werden:

1. MSMS_SERVICE_NAME: der Name des Dienstes - wird in den Benachrichtigungen und im Monitoring-Journal verwendet.
2. MSMS_SERVICE_ENDPOINT: der Endpoint des Dienstes, auf den wir mit curl zugreifen werden.
3. MSMS_CURL_PARAMS: zusätzliche curl-Parameter, siehe Beispiel unten.
4. MSMS_ERWARTET: die erwartete Antwort des Dienstes. Wird verwendet, wenn die Antwort kurz ist.
5. MSMS_ERWARTETE_DATEI: der Name der Datei mit der erwarteten Antwort des Dienstes. Wenn angegeben, überschreibt sie MSMS_ERWARTET.
6. MSMS_EMPFÄNGER: Datei mit der Liste der Empfänger von Benachrichtigungen.

Die Anfrage an google.com gibt ein festes HTML mit einer Umleitung zurück, wir werden es als erwartete Antwort des Servers verwenden:

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

Wir erstellen die Datei services/google.ini:

MSMS_DIENSTNAME='google-Startseite'

# Dienstendpunkt
MSMS_DIENSTENDPUNKT='google.com'

# curl-Parameter
MSMS_CURL_PARAM='-s --connect-timeout 3 -m 7'

# erwartete Dienstantwort
MSMS_ERWARTETE_DATEI='google-response.html'

# Datei mit der Empfängerliste
MSMS_EMPFÄNGER='google-recipients.txt'

Im MSMS_CURL_PARAMS man kann alles angeben, was curl kann, einschließlich:

1. Curl-Nachrichten deaktivieren, um die Konsole und das Log nicht zu verstopfen: -s
2. Den Timeout für die Verbindung mit dem zu überprüfenden Dienst (in Sekunden) festlegen: --connect-timeout 3
3. Den Timeout für den Empfang der Antwort festlegen: -m 7
4. Die Zertifikatprüfung für SSL deaktivieren (zum Beispiel, wenn ein selbstsigniertes Zertifikat verwendet wird): --insecure
5. Den Typ der HTTP-Anfrage angeben: -X POST
6. Köpfe angeben: -H "Content-Type: application/json"
7. Den Anfragebody als String oder Datei angeben. Beispiel für eine Datei: -d @request.json

Wir haben die Benachrichtigungen deaktiviert und die Timeouts auf 3 Sekunden für die Verbindung und 7 Sekunden für den Empfang der Dienstantwort festgelegt.

Achtung: geben Sie Parameterwerte in einfachen Anführungszeichen an, wie im Beispiel. Leider ist bash in dieser Hinsicht ziemlich anfällig, und eine versehentlich eingeklemmte Anführungszeichen kann zu schwierig diagnostizierbaren Fehlern führen.

Wir haben das Monitoring eingerichtet. Überprüfen wir, ob alles in Ordnung ist:

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

Das Skript sollte eine Nachricht des folgenden Typs ausgeben:

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

SCHRITT 3. Zeitplan einrichten

Wir richten den Überwachungszeitplan in cron ein:

sudo crontab -e

Fügen wir eine Zeile für die minütliche Überprüfung von google.com hinzu:

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

Fügen wir jeden Tag um 11:00 Uhr eine Benachrichtigung hinzu, die die Funktionsfähigkeit des Monitorings bestätigt. Dazu übergeben wir dem Skript den Parameter DAILY:

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

2>&1 — ein Standardansatz, der Fehler in den Hauptausgabestrom umleitet. So gelangen sie ebenfalls in das Überwachungsprotokoll.

Wir speichern die Änderungen und übernehmen sie mit dem Befehl:

 sudo service cron reload

Weitere Informationen zur Konfiguration von cron finden Sie beispielsweise hier.

Somit wird jede Minute ein Überwachungsskript gestartet, das über curl an google.com sendet. Wenn die erhaltene Antwort von der erwarteten abweicht, sendet das Skript eine Benachrichtigung an die Empfängerliste in Telegram. Das Protokoll der Überprüfungen wird in der Datei monitoring.log geführt.

Wenn ein weiterer Dienst hinzugefügt werden muss, erstellen wir einfach eine neue ini-Datei dafür im Ordner services und, falls erforderlich, erstellen wir eine separate Empfängerliste. Alles andere wird automatisch abgewickelt.

Wenn der überprüfte Dienst nicht mehr verfügbar ist, wird die Benachrichtigung jede Minute gesendet. Wenn der Dienst nicht schnell wiederhergestellt werden kann, können die Benachrichtigungen vorübergehend in den Einstellungen des Bots in Telegram deaktiviert werden.

Jetzt lassen Sie uns die zusätzlichen Möglichkeiten und die Implementierung der Skripte im Detail betrachten.

Nachrichtenschablonen und emotionales Engagement

Um die Interaktion mit dem Bot lebendiger zu gestalten, haben wir ihm den Namen Manjeka gegeben, ein passendes Avatarbild hinzugefügt und professionelle PR-Mitarbeiter für die Erstellung von Nachrichtentexten engagiert. Sie können unsere Entwicklungen verwenden oder nach Ihrem Geschmack ändern.

Zum Beispiel so:

oder sogar so:

Warum nicht?

Der Name des Bots und das Avatarbild werden über @botfather.
Die Nachrichtenschablonen befinden sich im Ordner templates:

• curl-fail.txt: eine Nachricht, die gesendet wird, wenn curl einen nicht-null Fehlercode zurückgibt. Dies deutet normalerweise darauf hin, dass der Dienst nicht erreichbar ist.
• daily.txt: tägliche Nachricht, die bestätigt, dass die Überwachung des Dienstes funktioniert.
• service-fail.txt: eine Nachricht, die gesendet wird, wenn die Antwort des Dienstes von der erwarteten abweicht.

Wir erläutern die Anpassungsmöglichkeiten am Beispiel der integrierten Nachrichtenschablonen.
In den Schablonen werden Emojis verwendet. Leider werden sie nicht von Habr angezeigt.
Um Emojis auszuwählen, ist es praktisch, die Suche auf emojipedia.org:

zu verwenden. Das passende Symbol wird einfach kopiert und in den Text der Schablone eingefügt (dies ist gewöhnlicher Unicode).

1. curl-fail.txt:

   Kätzchen, hilf mir... 
   Ich kann nicht zum Dienst "$MSMS_SERVICE_NAME" gelangen 
   `CURL EXIT CODE: $EXIT_CODE`

   Wir haben den von uns festgelegten Dienstnamen (Variable MSMS_SERVICE_NAME) und die interne Variable des Skripts mit dem curl-Abschlusscode (EXIT_CODE). Außerdem haben wir die Nachricht mit der Formatierung telegram markdown: Die Zeichen "`" umschließen Text fester Breite. Da Anführungszeichen und Apostrophe Befehlssymbole in Bash sind, maskieren wir sie mit "". Variablenamen werden mit "$" vorangestellt.

   Ergebnis:

   

2. service-fail.txt:

   Kätzchen, hilf mir... 
   Der Dienst "$MSMS_SERVICE_NAME" hat mich enttäuscht
   Er funktioniert nicht richtig, das sagt er mir:
   `$RESPONSE`

   Ergebnis:

   
   
   Hier verwenden wir eine weitere Skriptvariablen: RESPONSE. Sie enthält die Antwort des Dienstes.

3. daily.txt:

   Baby, hallo!
   Mir geht es gut, ich überwache den Dienst:
   "$MSMS_SERVICE_NAME" jede Minute...
   Wie läuft es bei dir?
   

   Ergebnis:

   

Kommen wir zur Implementierung der Skripte.

Überwachungs-Skript

monitoring.sh führt eine einfache automatische Entdeckung durch - nimmt alle ini-Dateien aus dem Ordner Dienste und führt für jede das Hauptskript mit der Prüflogik und Benachrichtigung durch:

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

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

Um eine tägliche Statusmeldung zur Überwachung zu erstellen, kann dem Skript der Parameter DAILY übergeben werden.

Bitte beachten Sie, dass beim Start des Skripts das aktuelle Verzeichnis auf Dienste geändert wird. Dadurch können in ini-Dateien Pfade relativ zu Dienste angegeben werden.

Skript zur Überprüfung und Benachrichtigung

msms.sh enthält die Hauptlogik zur Überprüfung des Dienstes und zur Benachrichtigung.

Arbeiten mit 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
}

Wir erstellen die URL für den Zugriff auf das REST API von Telegram, indem wir den im Datei gespeicherten geheimen Schlüssel verwenden.

Die Funktion send_message nutzt curl, um Nachrichten an dieses REST API zu senden und die IDs der Empfänger aus der in ini angegebenen Datei zu holen. In den gesendeten Daten geben wir an, dass wir die Nachrichtenformatierung verwenden: parse_mode="Markdown".

Lassen Sie uns das aktuelle Datum und die Uhrzeit ausgeben und die ini-Datei laden.

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

# Variablen aus der .ini-Datei laden:
. $2

Magische Zeile . $2 führt die zweite übergebene ini-Datei wie ein reguläres Skript aus und speichert die darin angegebenen Werte in Umgebungsvariablen.

Laden wir die erwartete Antwort aus der Datei, wenn der Parameter festgelegt ist MSMS_ERWARTETE_DATEI:

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

Führen wir die Dienstüberprüfung mit Benachrichtigungen aus, wenn nötig:

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

Zuerst weisen wir der Variablen RESPONSE das Ergebnis des curl-Befehls für diesen Dienst zu.

Ausdruck EXIT_CODE=$? Speichert in einer Variablen das Ergebnis der letzten ausgeführten Befehle, d.h. von curl. Bei Bedarf wird die Vorlage aus der entsprechenden Datei gelesen und an die Empfänger gesendet mit Hilfe von send_message.

Der letzte Block verarbeitet den Parameter 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

Es wird eine Nachricht gesendet, die die Funktionsfähigkeit des Monitorings selbst bestätigt.

Abrufen der Liste der Benutzer-ID

recipients-setup.sh ruft die API von Telegram auf, um die letzten an den Bot gerichteten Nachrichten zu erhalten:

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

Hier wird die Magie von Python verwendet, um die Liste schön auszugeben. Das ist nicht notwendig, man kann einfach die benötigte ID aus dem JSON nehmen, das der Befehl ausgibt:

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

Fazit

Auf diese Weise können Sie fertige Skripte und Nachrichtenschablonen verwenden, während Sie lediglich die zu überwachenden Dienste und die Listen für Benachrichtigungen anpassen; Sie können eine neue "Identität" für den Bot erstellen; oder Sie können Ihre eigene Lösung auf der Grundlage des Vorgeschlagenen entwickeln.

Als Optionen für die Weiterentwicklung bietet sich die Konfiguration und Verwaltung des Monitorings im Bot selbst an, aber dafür kommt man nicht ohne Python aus. Wenn jemand früher als ich dazu kommt — Sie wissen, wo Sie den Pull Request abgeben können 🙂

Quelle: habr.com