Manter a estabilidade de um servidor é uma tarefa contínua que exige monitoramento constante. Para sysadmins e desenvolvedores, esperar até que um serviço caia ou que a CPU atinja 100% não é uma estratégia viável. A proatividade é a chave para a infraestrutura resiliente. Neste tutorial, vamos construir um bot do Telegram em Python que monitora o uso da CPU e envia alertas imediatos para seu smartphone quando os limites são ultrapassados.
Por que automatizar alertas de servidor?
O monitoramento tradicional muitas vezes depende de dashboards web ou logs que precisam ser inspecionados manualmente. Em cenários de alta disponibilidade ou em ambientes de desenvolvimento, isso cria uma janela de latência entre o incidente e a detecção. O Telegram oferece um canal push instantâneo, confiável e fácil de configurar.
Ao combinar scripts Python com a API do Telegram, você cria uma ferramenta leve, customizável e gratuita para monitoramento de CPU. Diferente de soluções pesadas como Prometheus ou Grafana, este script roda em segundos, consome recursos mínimos e entrega exatamente o que importa: o estado atual do seu sistema quando algo sai do normal.
Pré-requisitos
Antes de iniciar a codificação, certifique-se de ter o seguinte no seu ambiente:
- Um servidor Linux (Ubuntu, Debian ou CentOS) com acesso SSH.
- Python 3.6+ instalado.
- Uma conta no Telegram e permissão para criar bots.
- A biblioteca
python-telegram-botou a API requests básica (utilizaremos requests para manter o script leve sem dependências pesadas).
Etapa 1: Configurar o Bot no Telegram
O primeiro passo é obter as credenciais necessárias para que seu script se comunique com a plataforma. Vamos usar o BotFather, o bot oficial do Telegram para gerenciamento de bots.
- Abra o Telegram e procure por
@BotFather. - Inicie uma conversa enviando o comando
/start. - Envie o comando
/newbot. - O BotFather pedirá um nome para o seu bot (ex: "Alerta CPU") e depois um username que deve terminar em "bot" (ex: "meu_alerta_cpu_bot").
- Após a criação, o BotFather enviará uma mensagem contendo o TOKEN do seu bot. Copie este token e guarde-o em um local seguro. Ele é a senha do seu bot.
Agora, você precisa saber qual é o seu ID de usuário para direcionar os alertas apenas para você. Envie uma mensagem qualquer para o novo bot que você criou.
- Vá até o Telegram e envie uma mensagem para o seu novo bot (ex: "oi").
- Abra uma nova aba ou janela no navegador e acesse
https://api.telegram.org/bot./getUpdates - Procure pelo campo
chat>id. Esse número é o seu CHAT_ID. Copie-o.
Etapa 2: Preparar o Ambiente Python
Vamos criar uma estrutura de diretórios limpa e isolar as dependências para evitar conflitos com outros projetos.
mkdir monitoramento-cpu
cd monitoramento-cpu
python3 -m venv venv
source venv/bin/activate
pip install requests psutilUtilizaremos duas bibliotecas principais:
- requests: Para fazer chamadas HTTP à API do Telegram.
- psutil: Uma biblioteca multiplataforma para obter informações de processos e utilitários do sistema, incluindo o uso da CPU em tempo real.
Etapa 3: Estruturando o Script Python
Crie um arquivo chamado cpu_monitor.py. A lógica será simples: verificar a CPU, comparar com um limite configurado e enviar mensagem se necessário. Para evitar spam, implementaremos uma lógica de "cooldown" ou verificação única por intervalo.
import psutil
import requests
import time
import sys
# Configurações
TELEGRAM_BOT_TOKEN = 'SEU_TOKEN_AQUI'
CHAT_ID = 'SEU_CHAT_ID_AQUI'
CPU_THRESHOLD = 80.0 # Porcentagem de alerta
CHECK_INTERVAL = 60 # Segundos entre verificações
def get_cpu_usage():
"""Retorna a utilização atual da CPU em porcentagem."""
return psutil.cpu_percent(interval=1)
def send_telegram_alert(message):
"""Envia uma mensagem para o Telegram."""
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
payload = {
'chat_id': CHAT_ID,
'text': message,
'parse_mode': 'HTML'
}
try:
response = requests.post(url, json=payload)
if response.status_code == 200:
print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Alerta enviado com sucesso.")
else:
print(f"Erro ao enviar alerta: {response.text}")
except Exception as e:
print(f"Exceção na requisição: {e}")
def main():
print("Iniciando monitor de CPU...")
# Variável para controlar o último alerta enviado (evitar spam)
last_alert_time = 0
while True:
try:
cpu_usage = get_cpu_usage()
current_time = time.time()
# Formatação da mensagem com HTML para negrito e cores (se suportado)
status_icon = "????" if cpu_usage > CPU_THRESHOLD else "????"
message = f"{status_icon} Alerta de CPU\n\n"
message += f"Uso atual: {cpu_usage}%\n"
message += f"Limite configurado: {CPU_THRESHOLD}%\n"
message += f"Servidor: {sys.platform}"
# Lógica de envio: apenas se a CPU estiver acima do limite
# E se passou mais de 10 minutos desde o último alerta (cooldown)
if cpu_usage > CPU_THRESHOLD:
if (current_time - last_alert_time) > 600:
send_telegram_alert(message)
last_alert_time = current_time
else:
print(f"CPU alta ({cpu_usage}%), mas pulando envio por cooldown.")
else:
print(f"CPU normal: {cpu_usage}%")
except Exception as e:
print(f"Erro no loop principal: {e}")
# Espera o intervalo definido antes da próxima verificação
time.sleep(CHECK_INTERVAL)
if __name__ == "__main__":
main()Etapa 4: Explicação Técnica do Código
Entender como o código funciona é crucial para manutenção futura. Vamos detalhar os componentes principais:
1. Coleta de Dados (psutil.cpu_percent):
A função get_cpu_usage() utiliza o módulo psutil. O parâmetro interval=1 faz a função bloquear a execução por 1 segundo para calcular uma média precisa da CPU, em vez de retornar um valor instantâneo que pode ser enganoso.
2. Comunicação com Telegram (requests.post):
A API do Telegram usa endpoints RESTful simples. A URL base é https://api.telegram.org/bot{TOKEN}/sendMessage. Enviamos os dados como JSON, incluindo o chat_id (destinatário) e o text (conteúdo). O uso de parse_mode='HTML' permite formatar a mensagem com tags simples, tornando o alerta mais legível no celular.
3. Prevenção de Spam (last_alert_time):
Este é um ponto crítico para scripts de automação. Se você deixar a CPU acima do limite por horas, seu Telegram ficará inundado com centenas de mensagens. A variável last_alert_time armazena o timestamp do último envio. O script só envia uma nova mensagem se (current_time - last_alert_time) > 600 (10 minutos). Isso garante que você receba o alerta, mas não seja assediado por ele.
Etapa 5: Tornando o Serviço Persistente com Systemd
Rodar o script manualmente via terminal é ineficiente. Se o servidor reiniciar ou você fechar o SSH, o monitoramento para. A solução profissional é usar systemd, o gerenciador de processos do Linux, para rodar o script como um serviço em segundo plano.
Crie um arquivo de unidade chamado cpu-monitor.service em /etc/systemd/system/:
sudo nano /etc/systemd/system/cpu-monitor.serviceInsira o seguinte conteúdo, ajustando os caminhos conforme sua instalação:
[Unit]
Description=Monitor de CPU via Telegram Bot
After=network.target
[Service]
Type=simple
User=root
WorkingDirectory=/root/monitoramento-cpu
ExecStart=/root/monitoramento-cpu/venv/bin/python /root/monitoramento-cpu/cpu_monitor.py
Restart=on-failure
RestartSec=10
[Install]
WantedBy=multi-user.targetDetalhes importantes:
User=root: O script precisa de acesso ao sistema para obter métricas precisas, embora seja possível rodar como usuário comum.ExecStart: Aponte para o Python dentro do seu virtualenv (venv/bin/python) para garantir que as dependências estejam disponíveis.Restart=on-failure: Se o script quebrar, o systemd tentará reiniciá-lo automaticamente após 10 segundos.
Agora, ative e inicie o serviço:
sudo systemctl daemon-reload
sudo systemctl enable cpu-monitor.service
sudo systemctl start cpu-monitor.serviceEtapa 6: Testando e Verificando
Para validar se tudo está funcionando corretamente, verifique o status do serviço:
sudo systemctl status cpu-monitor.serviceVocê deve ver uma linha verde indicando que o serviço está ativo (running). Se houver erros, verifique os logs com:
sudo journalctl -u cpu-monitor.service -fPara testar o alerta de CPU, você pode forçar um pico de processamento em outro terminal para saturar uma das CPUs do servidor. Um comando simples como yes > /dev/null (em um subshell) pode ajudar a aumentar a carga rapidamente.
# Em outro terminal, rode isto para gerar carga
for i in {1..4}; do yes > /dev/null & doneAguarde alguns segundos. Você deve receber uma notificação no Telegram informando que o limite de 80% foi ultrapassado. Pare os processos de carga e espere a CPU baixar para ver se o status volta ao normal (embora o script atual não envie mensagem de "resolução", apenas de alerta crítico).
Otimizações Avançadas
Este tutorial fornece uma base sólida, mas em produção, considere as seguintes melhorias:
- Configuração Externa: Substitua as variáveis hardcoded no script por um arquivo
.envou JSON para não expor tokens no código-fonte. - Múltiplos Destinatários: Modifique a função de envio para aceitar uma lista de chat IDs, permitindo alertar toda a equipe de DevOps.
- Alertas de Memória e Disco: O módulo
psutiltambém oferecepsutil.virtual_memory()epsutil.disk_usage('/'). Você pode expandir o script para monitorar todos os recursos do sistema. - Webhooks vs Polling: Para sistemas muito complexos, considere usar Webhooks do Telegram em vez de polling constante, embora para scripts simples de servidor, a abordagem acima seja suficiente e robusta.
Conclusão
A automação não precisa ser complicada. Com apenas algumas linhas de Python e a API do Telegram, você criou uma ferramenta poderosa de monitoramento de CPU. Esta abordagem é ideal para pequenos servidores VPS, instâncias de desenvolvimento ou como complemento leve a sistemas de monitoramento maiores.
Ao implementar este script e integrá-lo ao seu fluxo de trabalho via systemd, você garante que nunca mais ficará cego em relação à saúde do seu servidor. Lembre-se sempre de ajustar os limites (CPU_THRESHOLD) e os intervalos (CHECK_INTERVAL) conforme a carga real da sua aplicação.
Pronto para subir? Implemente este script hoje e tenha paz de espírito com seus servidores.
