🌗 ← Índice

🐍 Python P24 — Projeto: Bot de Notificações (Telegram)

Data: 14/08/2026

Nível: Projeto (Mês 3 — Projetos Reais)

🎯 Objetivos

• Criar um bot no Telegram com o BotFather
• Enviar mensagens via API do Telegram (`requests`)
• Enviar para um chat específico (chat_id)
• **Projeto real**: bot que envia alertas — conecta com seus cron jobs!

📖 Teoria

1. Criar o bot (uma vez só)

1. 1. No Telegram, procure **@BotFather**
2. 2. Envie `/newbot` → escolha um nome → escolha um username (termina em `bot`)
3. 3. O BotFather entrega um **token** (ex: `123456:ABC-DEF...`) — guarde no `.env`!

2. Descobrir seu chat_id

import requests

token = "SEU_TOKEN"
resposta = requests.get(
    f"https://api.telegram.org/bot{token}/getUpdates",
    timeout=10,
)
print(resposta.json())
# envie uma mensagem para o seu bot antes, e o chat_id aparecerá aqui

💡 `chat_id` fica em `result[0]["message"]["chat"]["id"]` — é um número (ex: `123456789`).

3. Enviar mensagem

import requests

TOKEN = "SEU_TOKEN"
CHAT_ID = 123456789

resposta = requests.post(
    f"https://api.telegram.org/bot{TOKEN}/sendMessage",
    json={"chat_id": CHAT_ID, "text": "🔔 Olá! Isso é um alerta."},
    timeout=10,
)
print(resposta.status_code)   # 200 = enviado

4. Seguro com .env

import os
from dotenv import load_dotenv

load_dotenv()
TOKEN = os.getenv("TELEGRAM_TOKEN")
CHAT_ID = int(os.getenv("TELEGRAM_CHAT_ID"))

TELEGRAM_TOKEN=123456:ABC-DEF...
TELEGRAM_CHAT_ID=123456789

5. Markdown e formatação

resposta = requests.post(
    f"https://api.telegram.org/bot{TOKEN}/sendMessage",
    json={
        "chat_id": CHAT_ID,
        "text": "*Atenção!*\n_Disco 90% cheio_\n`df -h`",
        "parse_mode": "Markdown",
    },
    timeout=10,
)

🏗️ O Projeto: `alerta_disco.py`

Bot que monitora o disco da VPS e envia alerta quando passa de um limite:

import os
import shutil
import requests
from dotenv import load_dotenv

load_dotenv()

TOKEN = os.getenv("TELEGRAM_TOKEN")
CHAT_ID = int(os.getenv("TELEGRAM_CHAT_ID"))
LIMITE_PERCENTUAL = float(os.getenv("LIMITE_DISCO", "80"))


def uso_disco(caminho="/") -> float:
    uso = shutil.disk_usage(caminho)
    return uso.used / uso.total * 100


def enviar_telegram(texto: str) -> bool:
    resposta = requests.post(
        f"https://api.telegram.org/bot{TOKEN}/sendMessage",
        json={"chat_id": CHAT_ID, "text": texto, "parse_mode": "Markdown"},
        timeout=10,
    )
    return resposta.status_code == 200


def main():
    percentual = uso_disco()
    mensagem = f"💾 *Disco da VPS:* {percentual:.1f}% usado"

    if percentual >= LIMITE_PERCENTUAL:
        mensagem += "\n\n⚠️ *ATENÇÃO:* limite de {:.0f}% excedido!".format(LIMITE_PERCENTUAL)

    if enviar_telegram(mensagem):
        print("Mensagem enviada com sucesso")
    else:
        print("Falha ao enviar mensagem")


if __name__ == "__main__":
    main()

Rodar manualmente e testar

python alerta_disco.py
# 💾 Disco da VPS: 62.3% usado

Agendar no cron (ex: todo dia às 9h)

0 9 * * * cd /home/ubuntu/projetos/alerta && /usr/bin/python3 alerta_disco.py

🔗 **Conexão com sua infra:** você já tem crons no Hermes — esse é o mesmo padrão para alertas no Telegram.

✍️ Exercícios

1. 1. Envie uma mensagem de teste com `parse_mode="Markdown"` usando **negrito** e `code`.
2. 2. Adicione o IP da VPS à mensagem (`socket.gethostname()` ou IP fixo).
3. 3. Envie uma mensagem com emoji de status (✅/⚠️/❌) conforme o percentual.

🧪 Desafio

Crie um bot alerta_precos.py que verifica um preço numa API pública (ex: preço do Bitcoin na CoinGecko) e envia alerta quando subir ou descer mais de X% em relação ao último valor salvo:

python alerta_precos.py --limite 5
# 📈 BTC subiu 5.3% — novo preço: R$ 450.000

Requisitos:

• Salvar o último preço em `ultimo_preco.json`
• Comparar com o atual e alertar só se a variação passar do limite
• Usar `requests` + Telegram + `.env`

✅ Correção (desafio — resumo)

import json
import os
import requests
from dotenv import load_dotenv

load_dotenv()
TOKEN = os.getenv("TELEGRAM_TOKEN")
CHAT_ID = int(os.getenv("TELEGRAM_CHAT_ID"))


def preco_btc() -> float:
    resposta = requests.get(
        "https://api.coingecko.com/api/v3/simple/price",
        params={"ids": "bitcoin", "vs_currencies": "brl"},
        timeout=10,
    )
    return resposta.json()["bitcoin"]["brl"]


def carregar_anterior() -> float | None:
    try:
        with open("ultimo_preco.json") as f:
            return json.load(f)["preco"]
    except (FileNotFoundError, KeyError):
        return None


def salvar_atual(preco: float) -> None:
    with open("ultimo_preco.json", "w") as f:
        json.dump({"preco": preco}, f)


def main(limite: float):
    atual = preco_btc()
    anterior = carregar_anterior()

    if anterior is not None and anterior > 0:
        variacao = (atual - anterior) / anterior * 100
        if abs(variacao) >= limite:
            sinal = "📈 subiu" if variacao > 0 else "📉 caiu"
            requests.post(
                f"https://api.telegram.org/bot{TOKEN}/sendMessage",
                json={"chat_id": CHAT_ID, "text": f"BTC {sinal} {abs(variacao):.1f}% — R$ {atual:,.0f}"},
                timeout=10,
            )

    salvar_atual(atual)
    print(f"BTC: R$ {atual:,.0f} (anterior: {anterior})")


if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("--limite", type=float, default=5.0)
    args = parser.parse_args()
    main(args.limite)

💡 Resultado: rodado via cron a cada hora, o bot avisa só quando há movimento relevante — sem spam.

HB Estudos · ← Voltar ao índice de Python