Meu Bot do Telegram Me Salvou Horas a Cada Semana

Oi pessoal, Marcus aqui do ai7bot.com. Espero que todos estejam tendo uma semana produtiva!

Hoje, quero falar sobre algo que tem sido um verdadeiro economizador de tempo e, francamente, um pouco de sanidade para mim ultimamente: usar bots do Telegram para automatizar aquelas tarefas chatas e repetitivas que aparecem em projetos pessoais ou até mesmo em pequenas equipes. Todos nós temos, não é? As pequenas coisas que levam 30 segundos aqui, um minuto ali, mas somam um pedaço frustrante do seu dia. Para mim, sempre foi manter o controle dos meus desafios diários de programação e garantir que meu servidor de desenvolvimento estava realmente funcionando como eu esperava.

Há um tempo atrás, eu estava lidando com alguns projetos paralelos – um novo bot para acompanhar minhas flexões diárias (não pergunte), um aplicativo web simples para gerenciar minha lista crescente de artigos de tecnologia para ler, e claro, mantendo ai7bot.com atualizado. Me vi constantemente verificando logs, pingando servidores e atualizando manualmente uma planilha com meu progresso diário no bot de flexões. Não era um trabalho difícil, mas era um trabalho *interruptivo*. Toda vez que eu mudava de contexto, mesmo que por um minuto, perdia mais tempo para voltar ao fluxo. Eu sabia que tinha que haver uma maneira melhor do que ter 17 abas abertas ou ficar atualizando meu terminal constantemente.

Nesse momento, lembrei do poder dos bots do Telegram. Eu já tinha criado alguns para interações simples antes, principalmente por diversão, mas nunca tinha pensado neles como ferramentas sérias de automação para *meu próprio* fluxo de trabalho. A maioria das pessoas pensa em chatbots como agentes de atendimento ao cliente ou ferramentas de marketing, mas a verdadeira mágica deles, especialmente para nós, construtores, está na automação pessoal. Eles são como ter um pequeno assistente dedicado vivendo no seu aplicativo de chat.

Portanto, hoje, quero mostrar como venho usando bots do Telegram para automatizar verificações de status do servidor e o registro de tarefas pessoais, e como você pode aplicar princípios semelhantes para suas próprias dores de cabeça repetitivas. Vamos nos concentrar em construir um bot simples baseado em Python que envia notificações diretamente para o seu chat do Telegram. Nada de interfaces complicadas, nada de painéis complexos – apenas informações rápidas e acionáveis onde você já passa seu tempo.

Por que Bots do Telegram para Automação Pessoal?

Antes de entrarmos nos detalhes, vamos falar sobre por que o Telegram é uma ótima opção para esse tipo de automação:

• Onipresença: Chances são que você já tenha o Telegram aberto no seu telefone ou desktop. As notificações chegam bem onde você vê.
• Simplicidade: A API de Bot do Telegram é incrivelmente direta. Você pode criar um bot básico em minutos.
• Recursos Ricos: Além de texto simples, você pode enviar imagens, arquivos, teclados embutidos e até botões personalizados. Isso abre muitas possibilidades para automação interativa.
• Gratuito e Confiável: A infraestrutura do Telegram é sólida, e criar bots é gratuito.
• Privado: Para automação pessoal, você é geralmente o único interagindo com o bot. Isso mantém as coisas seguras e organizadas.

Considerei o Discord por um minuto, mas para notificações rápidas e pessoais e interações simples, o Telegram parecia mais leve e direto. Além disso, o processo do BotFather é bem fácil.

Começando: Seu Primeiro Bot do Telegram

Se você nunca fez um bot do Telegram antes, não se preocupe. É muito fácil. Aqui está um resumo rápido:

1. Abra o Telegram e procure por @BotFather.
2. Inicie uma conversa com o BotFather e digite /newbot.
3. Siga as instruções: dê um nome ao seu bot (por exemplo, “MarcusDevMonitorBot”) e um nome de usuário (por exemplo, “MarcusDevMonitor_bot”).
4. O BotFather lhe dará um Token de API. Isso é crucial! Mantenha-o seguro; é como a senha do seu bot.

Uma vez que você tenha esse token, você está quase lá!

Enviando sua Primeira Mensagem

Para enviar uma mensagem, seu bot precisa saber para quem enviá-la. Isso é o seu chat_id. A maneira mais fácil de obtê-lo é iniciar uma conversa com seu novo bot, depois vá para esta URL em seu navegador, substituindo YOUR_BOT_TOKEN pelo seu token real:

https://api.telegram.org/botYOUR_BOT_TOKEN/getUpdates

Você verá uma resposta JSON. Procure pelo objeto "chat" e, dentro dele, o campo "id". Esse é o seu chat_id. Será um número longo.

Agora, vamos escrever um pequeno script em Python para enviar uma mensagem:

import requests

BOT_TOKEN = "YOUR_BOT_TOKEN_HERE" # Substitua pelo token do seu bot
CHAT_ID = "YOUR_CHAT_ID_HERE" # Substitua pelo seu chat_id

def send_telegram_message(message):
 url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
 payload = {
 "chat_id": CHAT_ID,
 "text": message,
 "parse_mode": "Markdown" # Permite negrito, itálico, etc.
 }
 try:
 response = requests.post(url, json=payload)
 response.raise_for_status() # Lança uma exceção para erros HTTP
 print("Mensagem enviada com sucesso!")
 except requests.exceptions.RequestException as e:
 print(f"Erro ao enviar a mensagem: {e}")

if __name__ == "__main__":
 send_telegram_message("Olá do seu novo bot de automação! 👋")

Execute esse script e você deve ver uma mensagem aparecendo em seu chat do Telegram. Bem legal, certo? Esta função simples é o núcleo de toda a nossa automação.

Exemplo Prático 1: Monitoramento de Uptime do Servidor

Meu maior ponto de dor sempre foi me perguntar se meu servidor de desenvolvimento ainda estava funcionando, especialmente para aquelas tarefas mais longas ou trabalhos agendados. Eu não precisava de monitoramento em tempo real, milissegundo a milissegundo, apenas um alerta se algo desse errado.

Aqui está como eu abordei isso: um script simples em Python que pinga uma URL ou uma porta específica e envia uma mensagem pelo Telegram se detectar um problema. Eu então configurei esse script para rodar a cada 15 minutos através de um cron job em meu servidor.

O Script de Verificação de Uptime

import requests
import socket
import time
from datetime import datetime

# --- Configuração do Bot do Telegram ---
BOT_TOKEN = "YOUR_BOT_TOKEN_HERE"
CHAT_ID = "YOUR_CHAT_ID_HERE"

def send_telegram_message(message):
 url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
 payload = {
 "chat_id": CHAT_ID,
 "text": message,
 "parse_mode": "Markdown"
 }
 try:
 response = requests.post(url, json=payload)
 response.raise_for_status()
 # print("Notificação enviada.") # Descomente apenas para depuração
 except requests.exceptions.RequestException as e:
 print(f"Erro ao enviar mensagem pelo Telegram: {e}")

# --- Lógica de Monitoramento ---
def check_website(url):
 try:
 response = requests.get(url, timeout=10) # timeout de 10 segundos
 response.raise_for_status() # Lança para erros 4xx/5xx
 return True, f"Website *{url}* está ONLINE! (Status: {response.status_code})"
 except requests.exceptions.RequestException as e:
 return False, f"Website *{url}* está OFFLINE! Erro: `{e}`"

def check_port(host, port):
 try:
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sock.settimeout(5) # timeout de 5 segundos
 result = sock.connect_ex((host, port))
 if result == 0:
 return True, f"A porta *{port}* em *{host}* está ABERTA."
 else:
 return False, f"A porta *{port}* em *{host}* está FECHADA. Código de erro: {result}"
 except socket.error as e:
 return False, f"Erro ao verificar a porta *{port}* em *{host}*: `{e}`"

def main():
 now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
 # Monitorar um site
 website_url = "https://ai7bot.com" # Substitua pela sua URL
 is_up, message = check_website(website_url)
 if not is_up:
 send_telegram_message(f"🚨 *ALERTA URGENTE ({now})* 🚨\n{message}")
 # else:
 # send_telegram_message(f"✅ Verificação do Website: {message}") # Descomente para notificações de sucesso

 # Monitorar uma porta específica (ex: SSH ou uma porta de aplicativo personalizado)
 server_host = "127.0.0.1" # Ou o IP/hostname público do seu servidor
 server_port = 22 # Exemplo: porta SSH
 is_open, port_message = check_port(server_host, server_port)
 if not is_open:
 send_telegram_message(f"🚨 *ALERTA URGENTE ({now})* 🚨\n{port_message}")
 # else:
 # send_telegram_message(f"✅ Verificação da Porta: {port_message}") # Descomente para notificações de sucesso

if __name__ == "__main__":
 main()

Algumas coisas a notar aqui:

• Estou usando requests para verificações HTTP e socket para verificações de porta. Bibliotecas simples e padrão.
• O tratamento de erros é fundamental. Queremos capturar problemas de rede e timeouts.
• Adicionei um parse_mode="Markdown" à carga útil de sendMessage, que permite texto em negrito (*texto*) e blocos de código (`código`) nas mensagens, tornando os alertas muito mais fáceis de ler.
• Eu só envio uma notificação se algo estiver *fora do ar*. Receber uma mensagem “tudo está bem” a cada 15 minutos seria irritante. No entanto, deixei as linhas comentadas ali caso você *queira* notificações de sucesso para depuração ou cenários específicos.

Configurando o Cron Job

Uma vez que você tenha esse script (vamos chamá-lo de monitor_bot.py) em seu servidor, você precisa agendá-lo. Para servidores Linux, cron é seu amigo:

1. Salve o script (por exemplo, em /home/youruser/bots/monitor_bot.py).
2. Abra seu crontab para edição: crontab -e
3. Adicione uma linha como esta para executá-lo a cada 15 minutos:

   */15 * * * * /usr/bin/python3 /home/youruser/bots/monitor_bot.py >> /home/youruser/bots/monitor_log.txt 2>&1

   Isso informa ao cron para executar seu script usando python3 a cada 15 minutos e direcionar toda a saída (incluindo erros) para um arquivo de log, o que é super útil para depuração.

Agora, se meu site ou uma porta crítica cair, recebo um alerta imediato no meu telefone. Nada mais de verificações manuais, nada mais de “esqueci de reiniciar aquele serviço?” panico.

Exemplo Prático 2: Registrador de Tarefas Diárias Simples

Além do monitoramento de servidores, eu também uso um bot para um sistema de registro pessoal muito simples. Lembra do acompanhamento diário de flexões? Ou de ficar de olho em quantos artigos eu escrevi para ai7bot.com esta semana?

Eu construí um bot que me permite enviar um comando rápido como /log artigo_escrito ou /log 50_flexões, e isso é adicionado a um arquivo de texto simples ou a uma Google Sheet. Para simplificar, vamos manter um arquivo de texto para este exemplo, mas expandir para a API do Google Sheets é definitivamente possível.

Para isso, precisamos de um framework de bot mais avançado do que apenas enviar mensagens. Eu geralmente confio em python-telegram-bot para tudo que é interativo. Ele lida com mensagens recebidas, comandos e respostas de forma muito mais elegante.

Instalando python-telegram-bot

pip install python-telegram-bot --pre

O --pre é importante porque a biblioteca está atualmente em um estado pré-lançamento para a versão 20, que tem algumas mudanças significativas, mas é geralmente melhor.

O Script do Bot Registrador de Tarefas

import logging
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters
from datetime import datetime
import os

# --- Configuração ---
BOT_TOKEN = "SEU_TOKEN_DO_BOT_AQUI"
CHAT_ID = int("SEU_CHAT_ID_AQUI") # Certifique-se de que isso é um inteiro para comparação
LOG_FILE = "tarefas_diarias.log"

# Configurando o logging
logging.basicConfig(
 format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
)
logger = logging.getLogger(__name__)

# --- Comandos do Bot ---
async def start(update: Update, context):
 """Envia uma mensagem de saudação quando o comando /start é emitido."""
 user = update.effective_user
 await update.message.reply_html(
 f"Oi {user.mention_html()}! Envie-me /log seguido pela sua tarefa (ex: `/log escrevi_post_no_blog`)."
 )

async def log_task(update: Update, context):
 """Registra uma tarefa em um arquivo."""
 # Certifique-se de que apenas o usuário autorizado pode registrar tarefas
 if update.effective_chat.id != CHAT_ID:
 logger.warning(f"Tentativa de acesso não autorizada de chat_id: {update.effective_chat.id}")
 await update.message.reply_text("Desculpe, sou um bot privado apenas para Marcus! 🤫")
 return

 if not context.args:
 await update.message.reply_text("Uso: `/log sua_descrição_da_tarefa`")
 return

 task_description = " ".join(context.args)
 timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

 try:
 with open(LOG_FILE, "a") as f:
 f.write(f"{timestamp} | {task_description}\n")
 await update.message.reply_text(f"Tarefa registrada: `{task_description}`")
 logger.info(f"Tarefa registrada para {update.effective_user.first_name}: {task_description}")
 except IOError as e:
 await update.message.reply_text(f"Erro ao registrar tarefa: `{e}`")
 logger.error(f"Erro ao escrever no arquivo de log: {e}")

async def echo(update: Update, context):
 """Responde qualquer mensagem de texto não reconhecida como comando."""
 # Apenas responda para o usuário autorizado
 if update.effective_chat.id == CHAT_ID:
 await update.message.reply_text(f"Você quis usar /log? Eu recebi: `{update.message.text}`")
 else:
 await update.message.reply_text("Eu só respondo a comandos do meu dono.")


async def error_handler(update: Update, context):
 """Registra o erro e envia uma mensagem para o usuário."""
 logger.error(f"Atualização {update} causou erro {context.error}")
 if update.effective_chat:
 await update.effective_chat.send_message(
 f"Ocorreu um erro: `{context.error}`. Por favor, tente novamente ou verifique os logs."
 )

def main():
 """Inicia o bot."""
 application = Application.builder().token(BOT_TOKEN).build()

 # Registra os manipuladores
 application.add_handler(CommandHandler("start", start))
 application.add_handler(CommandHandler("log", log_task))

 # Registra todos os erros
 application.add_error_handler(error_handler)

 # Em mensagens que não são comandos, responda com a mensagem (apenas para o chat autorizado)
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

 # Executa o bot até que o usuário pressione Ctrl-C
 logger.info("Bot iniciado. Pressione Ctrl-C para parar.")
 application.run_polling(allowed_updates=Update.ALL_TYPES)

if __name__ == "__main__":
 main()

Vamos analisar algumas partes-chave deste bot registrador:

• Application.builder().token(BOT_TOKEN).build(): É assim que você inicializa o bot usando python-telegram-bot.
• CommandHandler("start", start): Isso diz ao bot para chamar a função start quando alguém envia o comando /start.
• log_task function: Este é o núcleo. Ele pega o que vem após /log, junta em uma única string, adiciona um timestamp e o acrescenta ao tarefas_diarias.log.
• CHAT_ID Autorização: Crucialmente, eu adicionei uma verificação if update.effective_chat.id != CHAT_ID:. Isso garante que *somente meu chat específico* possa interagir com os recursos de registro. Você não quer que pessoas aleatórias registrem tarefas no seu arquivo pessoal!
• MessageHandler(filters.TEXT & ~filters.COMMAND, echo): Este é um catch-all para quaisquer mensagens de texto que não sejam comandos. Eu o uso para me lembrar gentilmente (ou avisar aos outros) sobre o uso correto.

Para executar este bot, basta executar o script Python: python3 logger_bot.py. Ele ficará em execução e ouvindo suas mensagens. Para uma configuração mais avançada, você deve executar isso usando um gerenciador de processos como systemd ou supervisor no seu servidor, garantindo que ele reinicie se travar.

Agora, quando eu termino de escrever um artigo, eu apenas digito /log artigo_finalizado_ai7bot_automatização_telegram no meu chat do Telegram, e isso é registrado. Mais tarde, eu posso apenas usar cat tarefas_diarias.log no meu servidor para ver um resumo. É muito menos complicado do que abrir uma planilha ou um aplicativo separado.

Conselhos Práticos para Sua Própria Automação de Bot

Espero que esses exemplos despertem algumas ideias para você. A beleza da automação pessoal com bots é que não precisa ser complexa ou de nível empresarial. Aqui está o que eu recomendo:

1. Identifique Seus “Cortes de Papel”

   Quais são aquelas pequenas tarefas repetitivas que drenam seu foco? Registrar horas, verificar endpoints específicos da API, ser notificado quando um script agendado termina, rastrear pequenas métricas? Faça uma lista.

2. Comece Pequeno e Simples

   Não tente construir um assistente de IA completo no primeiro dia. Comece enviando uma única mensagem quando um evento específico ocorrer. Meu monitor de servidor começou apenas enviando “Servidor está fora do ar!” quando um ping falhou. Expanda a partir daí.

3. Use Bibliotecas Existentes

   Python com requests e python-telegram-bot cobre uma enorme gama de possibilidades. Não reinvente a roda para interações de API ou manipulação de bots.

4. Priorize Segurança e Privacidade

   Especialmente para bots pessoais, certifique-se de que seu token de API não esteja exposto. Para bots que lidam com informações sensíveis ou controlam ações, implemente verificações de ID de chat para garantir que apenas *você* pode interagir com ele, como mostrado no exemplo do registrador.

5. Pense Além das Notificações

   Embora notificações sejam ótimas, considere como você poderia adicionar interações simples. Seu bot poderia acionar uma reinicialização do servidor? Buscar um relatório rápido? Alternar uma configuração? A biblioteca python-telegram-bot facilita a adição de comandos.

6. Use um Gerenciador de Processos para Longevidade

   Se seu bot está rodando continuamente (como o bot registrador), use systemd (no Linux) ou uma ferramenta como supervisor para garantir que ele reinicie se travar e rode de forma confiável em segundo plano.

Construir esses pequenos bots realmente tornou meu fluxo de trabalho de desenvolvimento mais suave e menos distrativo. É um testemunho de como até mesmo uma automação simples pode liberar espaço mental para um trabalho mais interessante e criativo. Então, pegue seu token do BotFather, identifique uma pequena irritação e comece a construir!

Deixe-me saber nos comentários que tipo de automação pessoal você construiu ou está planejando construir com bots do Telegram. Estou sempre procurando novas ideias!

Feliz construção de bots!

Marcus Rivera

ai7bot.com

🕒 Published: April 2, 2026