ProHoster > Blog > administração > Bot para monitorar serviços web em meia hora: telegrama + bash + cron

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

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

Às vezes, você precisa implementar rapidamente o monitoramento de um novo serviço, mas não possui a infraestrutura ou a experiência necessárias. Neste guia, vamos implementar uma ferramenta para monitorar qualquer serviço web em meia hora, usando apenas ferramentas integradas. ubuntu: bash, cron e curl. Usaremos o Telegram para enviar notificações.

A “cereja do bolo” será o envolvimento emocional dos utilizadores. Testado em pessoas - funciona.

Quando nós do serviço de telemedicina Doutor Perto criamos um chatbot para determinar o nível de estresse dos usuários, precisávamos de monitoramento. Em algumas horas, foi criado um miniprojeto que não só funciona muito bem, mas também agrega positividade com suas mensagens.

Primeiro, vamos obter um repositório com scripts:

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

Vá para a pasta msms e trabalhe nela.

Se o telegrama estiver bloqueado, use um proxy. A opção mais simples e confiável são as torsocks:

sudo apt install tor
sudo apt install torsocks

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

PASSO 1. Crie um bot no telegrama e obtenha o ID do usuário

  • Na barra de pesquisa de contatos no telegrama procuramos @botfather:

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

  • Lançamos com o botão Iniciar, digitamos o comando /newbot e respondemos às perguntas. Você precisa ter em mente que nome é o nome do bot que será exibido aos usuários, e nome de usuário é único e deve terminar com “bot”:

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

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

  • Digitamos o nome do nosso bot na barra de pesquisa do telegrama e o iniciamos.
  • Como toque final, vamos nos adicionar à lista de destinatários de alertas de monitoramento:
    sudo chmod +x ./recipients-setup.sh
torsocks ./recipients-setup.sh

    O script exibirá uma lista de chamadas recentes para o bot; deve haver uma linha com nosso id e nome no telegrama. Pegamos esse ID e o salvamos no arquivo services/google-recipients.txt. Formato do arquivo: cada linha é um id. Exemplo:

    123456789
987654321

Para adicionar um novo destinatário, você precisa pedir a ele para iniciar o bot no telegrama, executar destinatários-setup.sh e adicionar o id ao arquivo.

ETAPA 2. Configurar o monitoramento

O serviço é descrito criando um arquivo ini na pasta de serviços. Você precisa definir cinco parâmetros:

  1. MSMS_SERVICE_NAME: nome do serviço - será usado em alertas e log de monitoramento.
  2. MSMS_SERVICE_ENDPOINT: endpoint do serviço com o qual entraremos em contato com curl.
  3. MSMS_CURL_PARAMS: opções adicionais de curl, veja o exemplo abaixo.
  4. MSMS_EXPECTED: resposta esperada do serviço. Usado se a resposta for curta.
  5. MSMS_EXPECTED_FILE: nome do arquivo com a resposta de serviço esperada. Se especificado, substitui MSMS_EXPECTED.
  6. MSMS_RECIPIENTES: arquivo com uma lista de destinatários da notificação.

Uma solicitação para google.com retorna html fixo com um redirecionamento, usaremos isso como a resposta esperada do servidor:

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

Vamos criar o arquivo services/google.ini:

MSMS_SERVICE_NAME='google front page'

# service endpoint
MSMS_SERVICE_ENDPOINT='google.com'

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

# expected service response
MSMS_EXPECTED_FILE='google-response.html'

# recipients list file
MSMS_RECIPIENTS='google-recipients.txt'

В MSMS_CURL_PARAMS você pode definir tudo o que o curl pode fazer, incluindo:

  1. Desative as mensagens curl para evitar sobrecarregar o console e o log: -s
  2. Defina o tempo limite de conexão com o serviço que está sendo verificado (em segundos): --connect-timeout 3
  3. Defina o tempo limite de resposta: -m 7
  4. Desative a verificação de certificado para SSL (por exemplo, se você estiver usando um certificado autoassinado): --insecure
  5. Especifique o tipo de solicitação http: -X POST
  6. Especifique os títulos: -H "Content-Type: application/json"
  7. Especifique o corpo da solicitação como uma string ou arquivo. Exemplo para um arquivo: -d @request.json

Desativamos as notificações e definimos o tempo limite para 3 segundos. para conectar e 7 seg. para receber uma resposta de serviço.

Atenção: Especifique os valores dos parâmetros entre aspas simples, como no exemplo. Infelizmente, o bash é bastante frágil nesse sentido, e uma borboleta acidental com aspas erradas pode levar à morte do universo com erros difíceis de diagnosticar.

Montamos o monitoramento. Vamos verificar se está tudo bem:

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

O script deve exibir uma mensagem como:

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

ETAPA 3. Configurando um cronograma

Vamos configurar um cronograma de monitoramento no cron:

sudo crontab -e

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

*/1 * * * * torsocks <ПУТЬ К ПАПКЕ РЕПОЗИТОРИЯ>/monitoring.sh >> <ПУТЬ К ПАПКЕ РЕПОЗИТОРИЯ>/monitoring.log 2>&1

Adicionaremos um alerta todos os dias às 11.00h, confirmando a funcionalidade 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 - uma técnica padrão que redireciona erros para o fluxo de saída principal. Como resultado, eles também irão parar no log de monitoramento.

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

 sudo service cron reload

Você pode ler mais sobre como configurar o cron, por exemplo, aqui.

Assim, a cada minuto será lançado um script de monitoramento, que entrará em contato com google.com via curl. Caso a resposta recebida seja diferente da esperada, o script enviará uma notificação por telegrama para a lista de destinatários. O log de auditoria é mantido no arquivo monitoração.log

Se precisarmos adicionar outro serviço, simplesmente criamos um novo arquivo ini para ele na pasta de serviços e, se necessário, criamos uma lista separada de destinatários. Todo o resto funcionará automaticamente.

Caso o serviço verificado fique indisponível, um alerta será enviado a cada minuto. Se não for possível restaurar o serviço rapidamente, você pode desativar temporariamente as notificações nas propriedades do telegrama do bot.

Agora vamos dar uma olhada mais de perto nos recursos adicionais e na implementação de scripts.

Padrões de mensagens e envolvimento emocional

Para tornar a comunicação com o bot mais dinâmica, chamamos-lhe Manechka, adicionamos uma imagem de avatar apropriada e contratamos especialistas profissionais em relações públicas para criar textos de mensagens. Você pode usar nossa experiência ou alterá-la ao seu gosto.

Por exemplo:

Bot para monitorar serviços web em meia hora: telegrama + bash + cron
ou até mesmo assim:

Bot para monitorar serviços web em meia hora: telegrama + bash + cron
Por que não?

O nome do bot e o avatar são definidos via @botfather.
Os modelos de mensagens estão na pasta modelos:

  • curl-fail.txt: mensagem enviada quando curl retorna um código de erro diferente de zero. Geralmente fala da impossibilidade de chegar ao serviço.
  • diário.txt: Mensagem diária confirmando que o monitoramento do serviço está funcionando.
  • falha de serviço.txt: uma mensagem enviada quando a resposta do serviço é diferente do esperado.

Vejamos as opções de personalização usando modelos de mensagens integrados como exemplo.
Os modelos usam emoji. Infelizmente, o habr não os exibe.
Para selecionar emoji, é conveniente usar a pesquisa em emojipedia.org:

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

Você simplesmente copia e cola o símbolo apropriado no texto do modelo (este é o Unicode normal).

  1. curl-fail.txt:
    Котёнок,  помоги мне... 
Не могу достучаться до сервиса "$MSMS_SERVICE_NAME" 
`CURL EXIT CODE: $EXIT_CODE`

    Usamos o nome do serviço que especificamos (variável MSMS_SERVICE_NAME) e uma variável de script interna com código de saída curl (EXIT_CODE). Também formatamos a mensagem usando marcação redução de telegrama: caracteres "`" circundam texto de largura fixa. Como aspas e apóstrofos são símbolos bash, nós os escapamos com "". Os nomes das variáveis ​​são precedidos por um sinal “$”.

    Resultado:

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

  2. falha de serviço.txt:
    Котёнок, помоги мне... 
Сервис "$MSMS_SERVICE_NAME" меня расстроил
Он работает неправильно, вот что он мне отвечает:
`$RESPONSE`

    Resultado:

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

    Aqui usamos outra variável de script: RESPONSE. Ele contém a resposta do serviço.

  3. diário.txt:
    Малыш, привет!
У меня всё хорошо, cлежу за сервисом:
"$MSMS_SERVICE_NAME" каждую минутку...
А как у тебя дела?

    Resultado:

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

Vamos passar para a implementação dos scripts.

Roteiro de monitoramento

monitoramento.sh faz uma descoberta automática simples - pega todos os arquivos ini da pasta de serviços e para cada um executa o script principal com a lógica de verificação e envio de alertas:

#!/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 do monitoramento, pode-se passar o parâmetro DAILY para o script.

Observe que quando o script é iniciado, a pasta atual muda para serviços. Isso permite especificar caminhos de arquivos relativos a serviços em arquivos ini.

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

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

Trabalhando com telegrama:

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

Geramos uma URL para acessar a API REST do telegrama usando a chave secreta salva no arquivo.

A função send_message usa curl para enviar mensagens para esta API REST, obtendo os IDs dos destinatários do arquivo que especificamos no arquivo ini. Nos dados que enviamos, indicamos que utilizamos marcação de mensagem: parse_mode="Markdown".

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

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

# load variables from .ini file:
. $2

Corda mágica . $2 executa o arquivo ini passado para a entrada como segundo parâmetro como um script normal, inserindo os valores nele especificados nas variáveis ​​​​de ambiente.

Carregue a resposta esperada do arquivo se o parâmetro for especificado MSMS_EXPECTED_FILE:

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

Verificaremos o serviço e enviaremos alertas 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=$? coloca o resultado do último comando em uma variável, ou seja, ondulação. Caso seja necessário enviar um alerta, o modelo é lido do arquivo correspondente e enviado aos destinatários através 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

Envia uma mensagem confirmando a funcionalidade do próprio monitoramento.

Obtendo uma lista de IDs de usuários

destinatários-setup.sh chama a API do Telegram para obter as mensagens mais recentes endereçadas ao bot:

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

Isso usa a magia python para exibir uma lista lindamente. Isso não é necessário, você pode simplesmente pegar o id desejado do json, que o comando irá gerar:

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

Conclusão

Assim, você pode utilizar scripts e modelos de mensagens prontos, configurando apenas serviços monitorados e listas para alertas; você pode criar uma nova “personalidade” para o bot; ou você pode tomar sua própria decisão com base no que foi proposto.

Opções para desenvolvimento adicional sugerem configurar e gerenciar o monitoramento no próprio bot, mas aqui você não pode prescindir do python. Se alguém conseguir antes de mim, você sabe onde enviar a solicitação pull :)

Fonte: habr.com

Compre hospedagem confiável para sites com proteção DDoS, servidores VPS VDS 🔥 Compre hospedagem de sites confiável com proteção contra DDoS, servidores VPS/VDS | ProHoster