Bot per monitorare i servizi web in mezz'ora: telegram + bash + cron

A volte è necessario monitorare rapidamente un nuovo servizio, e non si ha a disposizione un'infrastruttura/preparazione 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 useremo telegram.

La "ciliegina sulla torta" sarà il coinvolgimento emotivo degli utenti. Provato sulla pelle delle persone - funziona.

Quando abbiamo creato un chatbot per determinare il livello di stress degli utenti nel servizio di telemedicina Doctor Nearby, abbiamo avuto bisogno del monitoraggio. In poche ore è stato realizzato un mini-progetto che non solo funziona alla grande, ma aggiunge anche positività con i suoi messaggi.

Per iniziare, otteniamo il repository con gli script:

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

Accediamo alla cartella msms e lavoriamo al suo interno.

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

sudo apt install tor
sudo apt install torsocks

Come esempio, configuriamo in tre passaggi il monitoraggio della pagina iniziale google.com

PASSO 1. Creiamo un bot in telegram e otteniamo l'id utente

• Nella barra di ricerca dei contatti in telegram cerchiamo @botfather:

  

• Avviamolo con il pulsante Start, inseriamo il comando /newbot e rispondiamo alle domande. Ricorda che name è il nome del bot che sarà visibile agli utenti, mentre username è unico e deve terminare con "bot":

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

• Digitiamo nella barra di ricerca di telegram il nome del nostro bot e avviamolo.
• Come tocco finale, aggiungiamoci alla lista dei destinatari delle notifiche di monitoraggio:

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

  Lo script presenterà un elenco delle ultime interazioni con il bot; ci dovrebbe essere una riga con il nostro id e il nome in telegram. Prendiamo questo id e salviamolo nel file services/google-recipients.txt. Il formato del file: ogni riga contiene un id. Esempio:

  123456789
  987654321

Per aggiungere un nuovo destinatario, è necessario chiedergli di avviare il bot in telegram, avviare 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. Dobbiamo impostare cinque parametri:

1. MSMS_SERVICE_NAME: il nome del servizio - verrà utilizzato nelle notifiche e nel registro di monitoraggio.
2. MSMS_SERVICE_ENDPOINT: l'endpoint del servizio a cui ci connetteremo tramite curl.
3. MSMS_CURL_PARAMS: parametri aggiuntivi curl, vedere l'esempio qui sotto.
4. MSMS_EXPECTED: risposta attesa dal servizio. Utilizzato se la risposta è breve.
5. MSMS_EXPECTED_FILE: nome del file con la risposta attesa dal 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 useremo come risposta attesa del server:

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

Creiamo il file services/google.ini:

MSMS_SERVICE_NAME='pagina principale di google'

# endpoint del servizio
MSMS_SERVICE_ENDPOINT='google.com'

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

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

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

In MSMS_CURL_PARAMS è possibile impostare tutto ciò che curl può fare, incluso:

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

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

Attenzione: specifica i valori dei parametri tra apici singoli, come nell'esempio. Purtroppo, bash in questo senso è piuttosto fragile, e un'apostrofo mal posizionato può portare a errori difficili da diagnosticare.

Abbiamo impostato il monitoraggio. Verifichiamo che tutto sia OK:

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

Lo script deve restituire un messaggio del tipo:

2020-01-10 12:14:31
health-check "pagina principale di google": OK

FASE 3. Configuriamo il programma

Configuriamo il programma di monitoraggio in cron:

sudo crontab -e

Aggiungiamo una riga per controllare google.com ogni minuto:

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

Aggiungeremo una notifica quotidiana alle 11:00 che conferma il funzionamento stesso del monitoraggio. Per questo, passeremo al secondo script il parametro DAILY:

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

2>&1 — prassi standard, reindirizzando gli errori nel flusso principale di output. Alla fine, anche loro saranno nel registro di monitoraggio.

Salviamo le modifiche e applichiamo il comando:

 sudo service cron reload

Ulteriori informazioni sulla configurazione di cron possono essere lette, ad esempio, qui.

In questo modo, ogni minuto verrà eseguito uno script di monitoraggio che utilizzerà curl per contattare google.com. Se la risposta ottenuta differisce da quella prevista, lo script invierà una notifica all'elenco dei destinatari su telegram. Il registro dei controlli viene mantenuto nel file monitoring.log.

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

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

Ora esaminiamo in dettaglio le ulteriori possibilità e l'implementazione degli script.

Modelli di messaggi e coinvolgimento emotivo

Per rendere la comunicazione con il bot più viva, lo abbiamo chiamato Maneczka, abbiamo aggiunto un'immagine del profilo corrispondente e coinvolto professionisti delle PR per creare testi di messaggi. Puoi utilizzare i nostri modelli o cambiarli a tuo piacimento.

Ad esempio così:

o addirittura così:

Perché no?

Il nome del bot e l'avatar sono impostati tramite @botfather.
I modelli di 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 giornaliero che conferma che il monitoraggio del servizio è attivo.
• service-fail.txt: messaggio inviato quando la risposta del servizio differisce da quella attesa.

Analizziamo le opzioni di personalizzazione utilizzando i modelli di messaggi integrati come esempio.
Nei modelli vengono utilizzate emoji. Purtroppo, habr non le visualizza.
Per trovare le emoji più adatte, è comodo utilizzare la ricerca su emojipedia.org:

Puoi semplicemente copiare e incollare il simbolo appropriato nel testo del modello (è un normale unicode).

1. curl-fail.txt:

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

   Abbiamo utilizzato il nome del servizio fornito da noi (variabile MSMS_SERVICE_NAME) e una variabile interna dello script con il codice di uscita di curl (EXIT_CODE). Abbiamo anche formattato il messaggio utilizzando la markup telegram markdown: i caratteri "`" racchiudono un testo a larghezza fissa. Poiché le virgolette e gli apostrofi sono caratteri speciali di bash, li sfuggiamo 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 di script: RESPONSE. Contiene la risposta del servizio.

3. daily.txt:

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

   Risultato:

   

Passiamo all'implementazione degli script.

Script di monitoraggio

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

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

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

Per formare un messaggio quotidiano sullo stato del monitoraggio, allo script si può passare il parametro DAILY.

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

Script di controllo e invio di notifiche

msms.sh contiene la logica principale di controllo del servizio e invio di notifiche.

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

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

La funzione send_message utilizza curl per inviare messaggi a questo REST API, prelevando gli id dei destinatari dal file specificato in ini. Nei dati inviati indichiamo che utilizziamo la formattazione dei messaggi: parse_mode="Markdown".

Stamperemo la data e l'ora correnti e caricheremo 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, assegnando i valori specificati alle variabili d'ambiente.

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

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

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

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

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

Espressione EXIT_CODE=$? assegna alla variabile il risultato dell'ultima esecuzione del comando, cioè curl. Se è necessario inviare una notifica, il modello viene letto dal file corrispondente e viene effettuata la distribuzione ai destinatari tramite send_message.

L'ultimo blocco elabora il parametro 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

Viene inviato un messaggio che conferma il funzionamento stesso del monitoraggio.

Ricezione dell'elenco degli id utenti

recipients-setup.sh si rivolge all'API di telegram per ottenere gli ultimi messaggi indirizzati al bot:

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

Qui viene utilizzata la magia del python per una bella visualizzazione dell'elenco. Non è necessario, è possibile semplicemente prendere l'id necessario dal 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 opzioni per un ulteriore sviluppo si propone la configurazione e la gestione del monitoraggio direttamente nel bot, ma qui senza python non si riesce. Se qualcuno riesce a farlo prima di me — sapete dove inviare la pull request 🙂

Fonte: habr.com