Bot para monitorar serviços da web em meia hora: telegram + bash + cron

Às vezes, é necessário realizar rapidamente uma monitorização para um novo serviço, e não se tem infraestrutura/expertise disponível. Neste guia, criaremos em meia hora uma ferramenta para monitorar qualquer serviço da web, utilizando apenas os recursos embutidos do Ubuntu: bash, cron e curl. Para enviar as notificações, utilizaremos o telegram.

O "toque final" será o envolvimento emocional dos usuários. Testado em pessoas — funciona.

Quando criamos um chatbot para determinar o nível de estresse dos usuários no serviço de telemedicina Doutor Perto, precisávamos de monitoramento. Em algumas horas, foi feito um mini-projeto que não apenas funciona bem, mas também traz positividade com suas mensagens.

Para começar, vamos obter o repositório com os scripts:

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

Entramos na pasta msms e trabalhamos nela.

Se o telegram estiver bloqueado, utilize proxy. A opção mais simples e confiável é o torsocks:

sudo apt install tor
sudo apt install torsocks

Como exemplo, vamos configurar em três etapas o monitoramento da página inicial google.com

PASSO 1. Criamos um bot no telegram e obtemos o id do usuário

• Na barra de busca de contatos do telegram, procuramos por @botfather:

  

• Iniciamos com o botão Iniciar, digitamos o comando /newbot e respondemos às perguntas. É importante lembrar que o nome é o nome do bot, que será exibido para os usuários, enquanto o username é único e deve terminar com "bot":

  
  
  Entre outras coisas, o bot fornecerá um token secreto para a API HTTP, que deve ser copiado e salvo no arquivo telegram-api-key.txt na pasta msms.

• Digitemos na barra de busca do telegram o nome do nosso bot e o iniciamos.
• Como um toque final, vamos nos adicionar à lista de destinatários das notificações de monitoramento:

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

  O script imprimirá uma lista das últimas interações com o bot, devendo haver uma linha com nosso id e nome no telegram. Pegamos esse id e o salvamos no arquivo services/google-recipients.txt. O formato do arquivo: cada linha — um id. Exemplo:

  123456789
  987654321

Para adicionar um novo destinatário, é necessário pedir que ele inicie o bot no telegram, execute o recipients-setup.sh e adicione o id ao arquivo.

PASSO 2. Configuramos o monitoramento

A descrição do serviço é feita criando um arquivo ini na pasta services. Precisamos definir cinco parâmetros:

1. MSMS_SERVICE_NAME: o nome do serviço — será usado nas notificações e no log de monitoramento.
2. MSMS_SERVICE_ENDPOINT: endpoint do serviço, que iremos acessar com o curl.
3. MSMS_CURL_PARAMS: parâmetros adicionais do curl, veja o exemplo abaixo.
4. MSMS_EXPECTED: resposta esperada do serviço. Usado quando a resposta é curta.
5. MSMS_EXPECTED_FILE: nome do arquivo com a resposta esperada do serviço. Se especificado, sobrescreve MSMS_EXPECTED.
6. MSMS_RECIPIENTS: arquivo com a lista de destinatários de notificações.

A solicitação para google.com retorna um html fixo com redirecionamento, vamos usá-lo como resposta esperada do servidor:

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

Vamos criar o arquivo services/google.ini:

MSMS_SERVICE_NAME='página inicial do google'

# ponto de extremidade do serviço
MSMS_SERVICE_ENDPOINT='google.com'

# parâmetros do curl
MSMS_CURL_PARAMS='-s --connect-timeout 3 -m 7'

# resposta esperada do serviço
MSMS_EXPECTED_FILE='google-response.html'

# arquivo da lista de destinatários
MSMS_RECIPIENTS='google-recipients.txt'

Em MSMS_CURL_PARAMS é possível definir tudo que o curl é capaz, incluindo:

1. Desativar mensagens do curl para não poluir o console e o log: -s
2. Definir o tempo de espera para se conectar ao serviço verificado (em segundos): --connect-timeout 3
3. Definir o tempo de espera para receber a resposta: -m 7
4. Desativar a verificação do certificado para SSL (por exemplo, se um certificado autoassinado estiver sendo usado): --insecure
5. Especificar o tipo de solicitação HTTP: -X POST
6. Especificar os cabeçalhos: -H "Content-Type: application/json"
7. Especificar o corpo da solicitação como uma string ou arquivo. Exemplo para arquivo: -d @request.json

Desativamos as notificações e definimos tempos de espera de 3 s para conexão e 7 s para receber a resposta do serviço.

Atenção: indique os valores dos parâmetros entre aspas simples, como no exemplo. Infelizmente, o bash é bastante frágil nesse sentido, e uma aspa colocada de forma errada pode causar erros complexos e difíceis de diagnosticar.

Configuramos o monitoramento. Vamos verificar se está tudo OK:

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

O script deve exibir uma mensagem do tipo:

2020-01-10 12:14:31
health-check "página inicial do google": OK

PASSO 3. Configurando a agenda

Vamos configurar a agenda de monitoramento no cron:

sudo crontab -e

Vamos adicionar a linha para verificar google.com a cada minuto:

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

Vamos adicionar uma notificação diária às 11:00, confirmando o funcionamento do próprio monitoramento. Para isso, passaremos o parâmetro DAILY para o script:

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

2>&1 — técnica padrão para redirecionar erros para o fluxo de saída principal. Assim, eles também são registrados no log de monitoramento.

Vamos salvar as alterações e aplicá-las com o comando:

 sudo service cron reload

Para mais informações sobre a configuração do cron, você pode ler, por exemplo, aqui.

Dessa forma, um script de monitoramento será executado a cada minuto, que fará uma chamada curl para google.com. Se a resposta recebida for diferente da esperada, o script enviará uma notificação para a lista de destinatários no Telegram. O log das verificações é mantido no arquivo monitoring.log

Se precisar adicionar mais um serviço, basta criar um novo arquivo ini para ele na pasta services e, se necessário, formar uma lista separada de destinatários. Todo o resto funcionará automaticamente.

Se o serviço verificado se tornar indisponível, a notificação será enviada a cada minuto. Se não for possível restaurar rapidamente o serviço, é possível desativar temporariamente as notificações nas configurações do bot no Telegram.

Agora vamos analisar em detalhes as funcionalidades adicionais e a implementação dos scripts.

Templates de mensagens e envolvimento emocional

Para tornar a interação com o bot mais dinâmica, nomeamos ele de Manecinha, adicionamos uma imagem de avatar adequada e envolvemos profissionais de PR para criar os textos das mensagens. Você pode usar nossas criações ou personalizá-las ao seu gosto.

Por exemplo assim:

ou até mesmo assim:

Por que não?

O nome do bot e a foto de perfil são configurados através de @botfather.
Os templates de mensagens estão na pasta templates:

• curl-fail.txt: mensagem enviada quando o curl retorna um código de erro diferente de zero. Geralmente indica que não foi possível acessar o serviço.
• daily.txt: mensagem enviada diariamente, confirmando que o monitoramento do serviço está funcionando.
• service-fail.txt: mensagem enviada quando a resposta do serviço é diferente da esperada.

Vamos analisar as possibilidades de personalização usando os templates de mensagens integradas como exemplo.
Nos templates, são usados emojis. Infelizmente, o Habr não os exibe.
Para encontrar emojis, é conveniente usar a pesquisa em emojipedia.org:

Basta copiar e colar o símbolo apropriado no texto do template (é um unicode normal).

1. curl-fail.txt:

   Gatinho, me ajude... 
   Não consigo acessar o serviço "$MSMS_SERVICE_NAME" 
   `CURL EXIT CODE: $EXIT_CODE`

   Usamos o nome do serviço que definimos (variável MSMS_SERVICE_NAME) e uma variável interna do script com o código de saída do curl (EXIT_CODE). Também formatamos a mensagem usando a marcação telegram markdown: os símbolos "`" delimitam texto de largura fixa. Como as aspas e apóstrofos são caracteres especiais do bash, os escapamos com "". Nomes de variáveis são precedidos pelo símbolo "$".

   Resultado:

   

2. service-fail.txt:

   Cachorrinho, me ajude... 
   O serviço "$MSMS_SERVICE_NAME" me deixou chateado
   Ele está funcionando incorretamente, aqui está o que ele me responde:
   `$RESPONSE`

   Resultado:

   
   
   Aqui usamos mais uma variável de script: RESPONSE. Ela contém a resposta do serviço.

3. daily.txt:

   Oi, menino!
   Estou bem, monitorando o serviço:
   "$MSMS_SERVICE_NAME" a cada minuto...
   E como você está?
   

   Resultado:

   

Vamos passar para a implementação dos scripts.

Script de monitoramento

monitoring.sh faz uma auto-descoberta simples — pega todos os arquivos ini da pasta services e para cada um executa o script principal com a lógica de verificação e envio de notificações:

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

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

Para gerar uma mensagem diária sobre o status de monitoramento, o script pode receber o parâmetro DAILY.

Observe que ao iniciar o script, a pasta atual muda para services. Isso permite que nos arquivos ini possamos especificar os caminhos relativos a services.

Script de verificação e envio de notificações

msms.sh contém a lógica principal de verificação do serviço e envio de notificações.

Trabalho com o 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
}

Formamos a URL para acessar a API REST do telegram, usando a chave secreta salva no arquivo.

A função send_message usa curl para enviar mensagens para essa API REST, retirando os IDs dos destinatários do arquivo que especificamos no ini. Nos dados enviados, indicamos que estamos usando a formatação de mensagens: parse_mode="Markdown".

Vamos exibir a data e hora atuais e carregar o arquivo ini.

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

# carregar variáveis do arquivo .ini:
. $2

A linha mágica . $2 executa o arquivo ini passado como segundo parâmetro como um script normal, armazenando os valores definidos nele em variáveis de ambiente.

Carregaremos a resposta esperada do arquivo, se o parâmetro for definido MSMS_EXPECTED_FILE:

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

Executaremos a verificação do serviço e o envio de notificações, se necessário:

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

Primeiro, atribuímos à variável RESPONSE o resultado da execução do comando curl para este serviço.

Expressão EXIT_CODE=$? armazena o resultado da execução do último comando, ou seja, curl. Se necessário enviar uma notificação, o modelo é lido do arquivo correspondente e é enviado para os destinatários com o auxílio de send_message.

O último bloco processa o parâmetro 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

Ele envia uma mensagem confirmando o funcionamento da própria monitorização.

Obtendo a lista de ids dos usuários

recipients-setup.sh faz uma chamada à API do telegram para obter as últimas mensagens enviadas ao bot:

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

Aqui, a mágica do python é usada para uma bonita saída da lista. Isso não é obrigatório, você pode simplesmente pegar o id necessário do json que o comando vai gerar:

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

Conclusão

Dessa forma, você pode usar scripts prontos e modelos de mensagens, apenas configurando os serviços observados e as listas de notificações; você pode criar uma "nova identidade" para o bot; ou pode desenvolver sua própria solução com base na proposta.

Como opções para um desenvolvimento posterior, a configuração e gestão da monitoração dentro do próprio bot se apresentam, mas aqui já não se pode fugir do python. Se alguém conseguir fazer isso antes de mim — você sabe para onde enviar o pull request 🙂

Fonte: habr.com