Bot per il monitoraggio dei servizi web in mezz'ora: telegram + bash + cron

A volte è necessario impostare rapidamente un monitoraggio per un nuovo servizio, ma non abbiamo a disposizione un'infrastruttura o un'esperienza pronta. In questa guida realizzeremo in mezz'ora uno strumento per monitorare qualsiasi servizio web, utilizzando solo gli strumenti integrati di ubuntu: bash, cron e curl. Per inviare le notifiche utilizzeremo telegram.

La ‘ciliegina sulla torta’ sarà il coinvolgimento emozionale degli utenti. Provato su persone: funziona.

Quando nel nostro servizio di telemedicina Dottor Vicino abbiamo creato un chatbot per determinare il livello di stress degli utenti, avevamo bisogno di monitoraggio. In poche ore è stato realizzato un mini-progetto, che non solo funziona benissimo, ma porta anche positività con i suoi messaggi.

Per cominciare, otteniamo il repository con gli script:

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

Accediamo alla cartella msms e lavoriamo all'interno di essa.

Se telegram è bloccato, utilizza un proxy. L'opzione più semplice e affidabile è torsocks:

sudo apt install tor
sudo apt install torsocks

Come esempio, impostiamo in tre fasi il monitoraggio della pagina iniziale di google.com

PASSO 1. Creiamo un bot su telegram e otteniamo l'ID utente

• Nella barra di ricerca contatti di Telegram cerchiamo @botfather:

  

• Avviamolo premendo il pulsante Start, inseriamo il comando /newbot e rispondiamo alle domande. Ricordiamo che name è il nome del bot che verrà visualizzato dagli utenti, mentre username deve essere unico e deve terminare con «bot»:

  
  
  Tra le altre cose, il bot fornirà un token segreto per l'API HTTP, che deve essere copiato e salvato nel file telegram-api-key.txt nella cartella msms.

• Nella barra di ricerca di Telegram digitiamo il nome del nostro bot e lo avviamo.
• Come tocco finale, aggiungiamo noi stessi all'elenco dei destinatari delle notifiche di monitoraggio:

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

  Lo script mostrerà un elenco delle ultime interazioni con il bot, in cui dovrebbe esserci una riga con il nostro id e nome su Telegram. Prendiamo questo id e lo salviamo nel file services/google-recipients.txt. Formato del file: ogni riga contiene un id. Esempio:

  123456789
  987654321

Per aggiungere un nuovo destinatario, è necessario chiedere di avviare il bot su Telegram, eseguire recipients-setup.sh e aggiungere l'id nel file.

PASSO 2. Configuriamo il monitoraggio

La descrizione del servizio avviene creando un file ini nella cartella services. È necessario impostare cinque parametri:

1. MSMS_SERVICE_NAME: il nome del servizio — verrà utilizzato nelle notifiche e nel registro di monitoraggio.
2. MSMS_SERVICE_ENDPOINT: endpoint del servizio a cui ci connetteremo tramite curl.
3. MSMS_CURL_PARAMS: parametri aggiuntivi per curl, vedi esempio qui sotto.
4. MSMS_EXPECTED: risposta attesa del servizio. Utilizzato se la risposta è breve.
5. MSMS_EXPECTED_FILE: nome del file con la risposta attesa del servizio. Se specificato, sovrascrive MSMS_EXPECTED.
6. MSMS_RECIPIENTS: file con l'elenco dei destinatari delle notifiche.

La richiesta a google.com restituisce un html fisso con reindirizzamento, lo utilizzeremo come risposta attesa del server:

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

Creiamo il file services/google.ini:

MSMS_SERVICE_NAME='pagina principale google'

# endpoint del servizio
MSMS_SERVICE_ENDPOINT='google.com'

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

# risposta attesa del servizio
MSMS_EXPECTED_FILE='google-response.html'

# file elenco destinatari
MSMS_RECIPIENTS='google-recipients.txt'

In MSMS_CURL_PARAMS puoi specificare tutto ciò che curl può fare, inclusi:

1. Disabilitare i messaggi curl per non riempire la console e il log: -s
2. Impostare il timeout della connessione con il servizio controllato (in secondi): --connect-timeout 3
3. Impostare il timeout per ricevere la risposta: -m 7
4. Disabilitare la verifica del certificato per SSL (ad esempio, se si utilizza un certificato autofirmato): --insecure
5. Specificare il tipo di richiesta http: -X POST
6. Specificare le intestazioni: -H "Content-Type: application/json"
7. Specificare il corpo della richiesta come stringa o file. Esempio per file: -d @request.json

Abbiamo disabilitato le notifiche e impostato timeout di 3 secondi per la connessione e 7 secondi per ricevere la risposta dal servizio.

Attenzione: specificare i valori dei parametri tra apostrofi, come nell'esempio. Sfortunatamente, il bash è piuttosto fragile in questo senso, e un'apostrofo casualmente posizionato può portare a errori difficile da diagnosticare.

Abbiamo configurato il monitoraggio. Verifichiamo che tutto sia a posto:

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

Lo script dovrebbe restituire un messaggio del tipo:

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

PASSO 3. Configuriamo la pianificazione

Configuriamo la pianificazione del monitoraggio in cron:

sudo crontab -e

Aggiungiamo una riga per il controllo ogni minuto di google.com:

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

Aggiungiamo ogni giorno alle 11.00 una notifica che confermi il funzionamento del monitoraggio stesso. Per farlo, passeremo il parametro DAILY allo script:

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

2>&1 — una funzione standard che reindirizza gli errori nel flusso principale di output. Di conseguenza, anche questi finiranno nel registro di monitoraggio.

Salviamo le modifiche e le applicheremo con il comando:

 sudo service cron reload

Puoi trovare ulteriori informazioni sulla configurazione di cron, ad esempio, qui.

In questo modo, ogni minuto verrà eseguito uno script di monitoraggio che effettuerà una richiesta curl a google.com. Se la risposta ricevuta differisce da quella attesa, lo script invierà una notifica a un elenco di destinatari su telegram. Il registro dei controlli è mantenuto nel file monitoring.log.

Se è necessario aggiungere un altro servizio, creiamo semplicemente un nuovo file ini per esso nella cartella services e, se necessario, formiamo un elenco separato di destinatari. Tutto il resto funzionerà automaticamente.

Se il servizio controllato diventa non disponibile, la notifica arriverà ogni minuto. Se non si riesce a ripristinare rapidamente il servizio, è possibile disattivare temporaneamente le notifiche nelle proprietà del bot su telegram.

Ora esaminiamo in dettaglio le funzionalità aggiuntive e l'implementazione degli script.

Modelli di messaggi e coinvolgimento emotivo

Per rendere la comunicazione con il bot più vivace, lo abbiamo chiamato Manec'ka, aggiunto un'immagine avatar appropriata e coinvolto professionisti della comunicazione per creare i testi dei messaggi. Puoi utilizzare i nostri modelli o modificarli a tuo piacimento.

Ad esempio così:

o addirittura così:

Perché no?

Il nome del bot e l'avatar possono essere impostati tramite @botfather.
I modelli dei messaggi si trovano nella cartella templates:

• curl-fail.txt: messaggio inviato quando curl restituisce un codice di errore diverso da zero. Di solito indica l'impossibilità di contattare il servizio.
• daily.txt: messaggio quotidiano che conferma che il monitoraggio del servizio è attivo.
• service-fail.txt: messaggio inviato quando la risposta del servizio differisce da quella attesa.

Esaminiamo le possibilità di personalizzazione utilizzando i modelli di messaggi incorporati come esempio.
Nei modelli vengono utilizzate emoji. Sfortunatamente, habr non le visualizza.
Per scegliere le emoji, è conveniente utilizzare la ricerca su emojipedia.org:

Copia semplicemente il simbolo che ti piace e incollalo nel testo del modello (è un normale unicode).

1. curl-fail.txt:

   Gattino, aiutami... 
   Non riesco a contattare il servizio "$MSMS_SERVICE_NAME" 
   `CODICE EXIT CURL: $EXIT_CODE`

   Abbiamo utilizzato il nome del servizio fornito da noi (variabile MSMS_SERVICE_NAME) e la variabile interna dello script con il codice di uscita curl (EXIT_CODE). Abbiamo anche formattato il messaggio utilizzando il markup telegram markdown: i caratteri "`" racchiudono il testo a larghezza fissa. Poiché le virgolette e gli apostrofi sono caratteri speciali nel bash, li escapiamo con il carattere "". I nomi delle variabili sono preceduti dal simbolo "$".

   Risultato:

   

2. service-fail.txt:

   Gattino, aiutami...
   Il servizio "$MSMS_SERVICE_NAME" mi ha deluso.
   Non funziona correttamente, ecco cosa mi risponde:
   `$RESPONSE`

   Risultato:

   
   
   Qui usiamo un'altra variabile dello script: RESPONSE. Contiene la risposta del servizio.

3. daily.txt:

   Ciao, piccolo!
   Va tutto bene, controllo il servizio:
   "$MSMS_SERVICE_NAME" ogni minuto...
   E tu come stai?
   

   Risultato:

   

Passiamo all'implementazione degli script.

Lo script di monitoraggio

monitoring.sh effettua una semplice auto-scoperta: prende tutti i file ini dalla cartella services e per ciascuno esegue lo script principale con la logica di controllo e invio notifiche:

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

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

Per generare il messaggio giornaliero sullo stato del monitoraggio, allo script può essere passato il parametro DAILY.

Si prega di notare che all'avvio dello script la cartella corrente cambia in services. Questo consente di specificare i percorsi dei file nei file ini rispetto a services.

Script di verifica e invio notifiche

msms.sh contiene la logica principale per il controllo del servizio e l'invio delle notifiche.

Lavorare con 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
}

Generiamo l'URL per accedere al REST API di telegram, utilizzando la chiave segreta memorizzata nel file.

La funzione send_message utilizza curl per inviare messaggi a questo REST API, prelevando gli ID dei destinatari dal file specificato da noi nell'ini. Nei dati inviati indichiamo che utilizziamo il markup dei messaggi: parse_mode="Markdown".

Stampiamo la data-ora corrente e carichiamo il file ini.

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

# carica le variabili dal file .ini:
. $2

Stringa magica . $2 esegue il file ini passato come secondo parametro come uno script normale, memorizzando i valori specificati in esso nelle variabili d'ambiente.

Caricheremo la risposta attesa dal file, se il parametro è specificato MSMS_EXPECTED_FILE:

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

Eseguiamo il controllo del servizio con l'invio delle notifiche, se necessario:

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

Iniziamo assegnando alla variabile RESPONSE il risultato dell'esecuzione del comando curl per questo servizio.

Espressione EXIT_CODE=$? memorizza nella variabile il risultato dell'ultima comando eseguito, cioè curl. Se è necessario inviare una notifica, il modello viene letto dal file corrispondente e inviato ai destinatari tramite send_message.

L'ultimo blocco gestisce il parametro DAILY:

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

Invia un messaggio che conferma il funzionamento stesso del monitoraggio.

Ottenere l'elenco degli ID utenti

recipients-setup.sh interagisce con l'API telegram per ottenere i messaggi recenti destinati al bot:

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

Qui viene utilizzata la magia di Python per una presentazione elegante dell'elenco. Non è obbligatorio, è possibile semplicemente prendere l'id necessario da json, che verrà restituito dal comando:

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

Conclusione

In questo modo, puoi utilizzare script e modelli di messaggi pronti, configurando solo i servizi monitorati e le liste per le notifiche; puoi creare una nuova "identità" per il bot; oppure puoi realizzare la tua soluzione basata su quanto proposto.

Come ulteriori opzioni di sviluppo, si propone la configurazione e la gestione del monitoraggio direttamente nel bot, ma qui non si può prescindere da Python. Se qualcuno riesce a farsi avanti prima di me, sapete dove inviare la pull request 🙂

Fonte: habr.com