Il mio bot di Telegram mi ha salvato ore ogni settimana

Ciao a tutti, Marcus qui da ai7bot.com. Spero che stiate passando una settimana produttiva!

Oggi voglio parlare di qualcosa che è stato davvero un risparmiatore di tempo e, francamente, un po’ un salvavita per me ultimamente: utilizzare i bot di Telegram per automatizzare quelle fastidiose e ripetitive attività che sorgono nei progetti personali o persino nelle piccole configurazioni di team. Anche noi abbiamo tutti dei piccoli compiti, giusto? Le piccole cose che richiedono 30 secondi qui, un minuto là, ma che si sommano in un frustrante pezzetto della tua giornata. Per me, è sempre stata la necessità di tenere traccia delle mie sfide quotidiane di coding e assicurarmi che il mio server di sviluppo stesse effettivamente funzionando come mi aspettavo.

Un po’ di tempo fa, stavo gestendo alcuni progetti secondari – un nuovo bot per tenere traccia delle mie flessioni quotidiane (non chiedete), una semplice web app per gestire la mia lista in continua crescita di articoli tecnologici da leggere, e ovviamente, mantenere ai7bot.com aggiornato. Mi ritrovavo costantemente a controllare i log, a pingare i server e a aggiornare manualmente un foglio di calcolo con i miei progressi quotidiani sul bot delle flessioni. Non era un lavoro difficile, ma era un lavoro *interrompente*. Ogni volta che cambiavo contesto, anche solo per un minuto, mi costava più tempo tornare nel flusso di lavoro. Sapevo che doveva esserci un modo migliore rispetto ad avere 17 schede aperte o a rinfrescare continuamente il mio terminale.

È allora che mi sono ricordato del potere dei bot di Telegram. Ne ho creati alcuni per interazioni semplici in passato, per lo più per divertimento, ma non li avevo davvero considerati come strumenti di automazione seri per *il mio* flusso di lavoro. La maggior parte delle persone pensa ai chatbot come agenti di servizio clienti o strumenti di marketing, ma la loro vera magia, soprattutto per noi costruttori, è nell’automazione personale. Sono come avere un piccolo assistente dedicato che vive nella tua app di chat.

Quindi, oggi voglio mostrarti come ho utilizzato i bot di Telegram per automatizzare i controlli dello stato del server e il log delle attività personali, e come puoi applicare principi simili ai tuoi stessi mal di testa ripetitivi. Ci concentreremo sulla costruzione di un semplice bot basato su Python che ti invia notifiche direttamente nella tua chat di Telegram. Niente interfacce utente elaborate, niente dashboard complesse – solo informazioni rapide e utili dove trascorri già il tuo tempo.

Perché Bot di Telegram per l’Automazione Personale?

Prima di entrare nei dettagli, parliamo del perché Telegram sia così adatto per questo tipo di automazione:

• Ubiquità: È probabile che tu abbia già Telegram aperto sul tuo telefono o desktop. Le notifiche arrivano proprio dove le vedi.
• Semplicità: L’API dei Bot di Telegram è incredibilmente semplice. Puoi far funzionare un bot di base in pochi minuti.
• Funzionalità Ricche: Oltre al semplice testo, puoi inviare immagini, file, tastiere inline e persino pulsanti personalizzati. Questo apre molte possibilità per un’automazione interattiva.
• Gratuito e Affidabile: L’infrastruttura di Telegram è solida e creare bot è gratuito.
• Privato: Per l’automazione personale, di solito sei l’unico a interagire con il bot. Questo mantiene le cose sicure e prive di ingombri.

Ho considerato Discord per un attimo, ma per notifiche rapide e personali e interazioni semplici, Telegram sembrava più leggero e diretto. Inoltre, il processo con BotFather è una passeggiata.

Iniziare: Il Tuo Primo Bot di Telegram

Se non hai mai creato un bot di Telegram prima, non preoccuparti. È super facile. Ecco un riepilogo veloce:

1. Apri Telegram e cerca @BotFather.
2. Inizia una chat con BotFather e digita /newbot.
3. Segui le istruzioni: dai un nome al tuo bot (ad esempio, “MarcusDevMonitorBot”) e un nome utente (ad esempio, “MarcusDevMonitor_bot”).
4. BotFather ti darà un API Token. Questo è cruciale! Tienilo al sicuro; è come la password per il tuo bot.

Una volta che hai quel token, sei a metà strada!

Inviare il Tuo Primo Messaggio

Per inviare un messaggio, il tuo bot deve sapere a chi inviarlo. Questo è il tuo chat_id. Il modo più semplice per ottenerlo è avviare una conversazione con il tuo nuovo bot, quindi andare a questo URL nel tuo browser, sostituendo YOUR_BOT_TOKEN con il tuo token reale:

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

Vedrai una risposta JSON. Cerca l’oggetto "chat", e all’interno di esso, il campo "id". Quello è il tuo chat_id. Sarà un numero lungo.

Ora, scriviamo un piccolo script in Python per inviare un messaggio:

import requests

BOT_TOKEN = "YOUR_BOT_TOKEN_HERE" # Sostituisci con il token del tuo bot
CHAT_ID = "YOUR_CHAT_ID_HERE" # Sostituisci con il tuo 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" # Consente grassetto, corsivo, ecc.
 }
 try:
 response = requests.post(url, json=payload)
 response.raise_for_status() # Solleva un'eccezione per errori HTTP
 print("Messaggio inviato con successo!")
 except requests.exceptions.RequestException as e:
 print(f"Errore nell'invio del messaggio: {e}")

if __name__ == "__main__":
 send_telegram_message("Ciao dal tuo nuovo bot di automazione! 👋")

Esegui quel script e dovresti vedere un messaggio apparire nella tua chat di Telegram. Piuttosto cool, vero? Questa funzione semplice è il cuore di tutta la nostra automazione.

Esempio Pratico 1: Monitoraggio dell’Uptime del Server

Il mio maggiore problema era sempre chiedermi se il mio server di sviluppo fosse ancora attivo, specialmente per quelle attività più lunghe o lavori programmati. Non avevo bisogno di monitoraggio in tempo reale, millisecondo per millisecondo, solo un avviso se qualcosa andava storto.

Ecco come l’ho affrontato: uno script Python semplice che pinge un URL o una porta specifica e invia un messaggio di Telegram se rileva un problema. Ho poi impostato questo script per eseguire ogni 15 minuti tramite un lavoro cron sul mio server.

Lo Script di Controllo dell’Uptime

import requests
import socket
import time
from datetime import datetime

# --- Configurazione del Bot di 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 inviata.") # Scommenta solo per il debug
 except requests.exceptions.RequestException as e:
 print(f"Errore nell'invio del messaggio di Telegram: {e}")

# --- Logica di Monitoraggio ---
def check_website(url):
 try:
 response = requests.get(url, timeout=10) # Timeout di 10 secondi
 response.raise_for_status() # Solleva per errori 4xx/5xx
 return True, f"Sito Web *{url}* è ATTIVO! (Stato: {response.status_code})"
 except requests.exceptions.RequestException as e:
 return False, f"Sito Web *{url}* è SPENTO! Errore: `{e}`"

def check_port(host, port):
 try:
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sock.settimeout(5) # Timeout di 5 secondi
 result = sock.connect_ex((host, port))
 if result == 0:
 return True, f"Porta *{port}* su *{host}* è APERTA."
 else:
 return False, f"Porta *{port}* su *{host}* è CHIUSA. Codice errore: {result}"
 except socket.error as e:
 return False, f"Errore nel controllo della porta *{port}* su *{host}*: `{e}`"

def main():
 now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
 # Monitora un sito web
 website_url = "https://ai7bot.com" # Sostituisci con il tuo URL
 is_up, message = check_website(website_url)
 if not is_up:
 send_telegram_message(f"🚨 *ALLERTA URGENTE ({now})* 🚨\n{message}")
 # else:
 # send_telegram_message(f"✅ Controllo Sito: {message}") # Scommenta per notifiche di successo

 # Monitora una porta specifica (ad es., SSH o una porta app personalizzata)
 server_host = "127.0.0.1" # O l'indirizzo IP/pubblico del tuo server
 server_port = 22 # Esempio: porta SSH
 is_open, port_message = check_port(server_host, server_port)
 if not is_open:
 send_telegram_message(f"🚨 *ALLERTA URGENTE ({now})* 🚨\n{port_message}")
 # else:
 # send_telegram_message(f"✅ Controllo Porta: {port_message}") # Scommenta per notifiche di successo

if __name__ == "__main__":
 main()

Alcune cose da notare qui:

• Utilizzo requests per controlli HTTP e socket per controlli sulle porte. Librerie semplici e standard.
• La gestione degli errori è fondamentale. Vogliamo intercettare problemi di rete e timeout.
• Ho aggiunto un parse_mode="Markdown" al payload di sendMessage, che consente testo in grassetto (*text*) e blocchi di codice (`code`) nei messaggi, rendendo le allerte molto più facili da leggere.
• Invio una notifica solo se qualcosa è *giù*. Ricevere un messaggio di “tutto è a posto” ogni 15 minuti sarebbe fastidioso. Tuttavia, ho lasciato le linee commentate se vuoi *effettivamente* le notifiche di successo per il debug o scenari specifici.

Impostazione del Lavoro Cron

Una volta che hai questo script (chiamiamolo monitor_bot.py) sul tuo server, devi programmarlo. Per i server Linux, cron è il tuo amico:

1. Salva lo script (ad esempio, in /home/youruser/bots/monitor_bot.py).
2. Apri il tuo crontab per l’editing: crontab -e
3. Aggiungi una riga come questa per eseguirlo ogni 15 minuti:

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

   Questo dice a cron di eseguire il tuo script utilizzando python3 ogni 15 minuti e di indirizzare tutto l’output (inclusi gli errori) a un file di log, che è super utile per il debug.

Ora, se il mio sito web o una porta critica va giù, ricevo immediatamente un’alert sul mio telefono. Niente più controlli manuali, niente più panico da “ho dimenticato di riavviare quel servizio?”.

Esempio Pratico 2: Registratore di Attività Giornaliero Semplice

Oltre al monitoraggio del server, utilizzo anche un bot per un sistema di registrazione personale molto semplice. Ricordi il monitoraggio quotidiano delle flessioni? O tenere traccia di quanti articoli ho scritto per ai7bot.com questa settimana?

Ho costruito un bot che mi permette di inviare un comando veloce come /log article_written o /log 50_pushups, e lo aggiunge a un semplice file di testo o a un Google Sheet. Per semplicità, rimaniamo su un file di testo per questo esempio, ma espandere a un’API di Google Sheet è sicuramente fattibile.

Per questo, avremo bisogno di un framework bot più avanzato di un semplice invio di messaggi. Di solito mi affido a python-telegram-bot per tutto ciò che è interattivo. Gestisce i messaggi in arrivo, i comandi e le risposte in modo molto più elegante.

Installazione di python-telegram-bot

pip install python-telegram-bot --pre

Il --pre è importante perché la libreria è attualmente in uno stato di pre-rilascio per la versione 20, che ha alcune modifiche significative ma è generalmente migliore.

Script del Bot Registratore di Attività

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

# --- Configurazione ---
BOT_TOKEN = "IL_TUO_BOT_TOKEN_QUI"
CHAT_ID = int("IL_TUO_CHAT_ID_QUI") # Assicurati che sia un intero per il confronto
LOG_FILE = "daily_tasks.log"

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

# --- Comandi del Bot ---
async def start(update: Update, context):
 """Invia un messaggio di saluto quando viene emesso il comando /start."""
 user = update.effective_user
 await update.message.reply_html(
 f"Ciao {user.mention_html()}! Inviami /log seguito dalla tua attività (ad esempio, `/log wrote_blog_post`)."
 )

async def log_task(update: Update, context):
 """Registra un'attività su un file."""
 # Assicurati che solo l'utente autorizzato possa registrare attività
 if update.effective_chat.id != CHAT_ID:
 logger.warning(f"Tentativo di accesso non autorizzato da chat_id: {update.effective_chat.id}")
 await update.message.reply_text("Spiacente, sono un bot privato solo per Marcus! 🤫")
 return

 if not context.args:
 await update.message.reply_text("Utilizzo: `/log tua_descrizione_attività`")
 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"Attività registrata: `{task_description}`")
 logger.info(f"Attività registrata per {update.effective_user.first_name}: {task_description}")
 except IOError as e:
 await update.message.reply_text(f"Errore nella registrazione dell'attività: `{e}`")
 logger.error(f"Errore nella scrittura del file di registro: {e}")

async def echo(update: Update, context):
 """Risponde a qualsiasi messaggio di testo non riconosciuto come comando."""
 # Rispondi solo per l'utente autorizzato
 if update.effective_chat.id == CHAT_ID:
 await update.message.reply_text(f"Volevi usare /log? Ho ricevuto: `{update.message.text}`")
 else:
 await update.message.reply_text("Rispondo solo ai comandi del mio proprietario.")


async def error_handler(update: Update, context):
 """Registra l'errore e invia un messaggio all'utente."""
 logger.error(f"L'aggiornamento {update} ha causato l'errore {context.error}")
 if update.effective_chat:
 await update.effective_chat.send_message(
 f"Si è verificato un errore: `{context.error}`. Per favore riprova o controlla i registri."
 )

def main():
 """Avvia il bot."""
 application = Application.builder().token(BOT_TOKEN).build()

 # Registra i gestori
 application.add_handler(CommandHandler("start", start))
 application.add_handler(CommandHandler("log", log_task))

 # Registra tutti gli errori
 application.add_error_handler(error_handler)

 # Per i messaggi non di comando, ripeti il messaggio (solo per chat autorizzate)
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

 # Esegui il bot finché l'utente non preme Ctrl-C
 logger.info("Bot avviato. Premi Ctrl-C per fermarlo.")
 application.run_polling(allowed_updates=Update.ALL_TYPES)

if __name__ == "__main__":
 main()

Analizziamo alcune parti chiave di questo bot registratore:

• Application.builder().token(BOT_TOKEN).build(): Questo è il modo in cui inizializzi il bot usando python-telegram-bot.
• CommandHandler("start", start): Questo dice al bot di chiamare la funzione start quando qualcuno invia il comando /start.
• log_task funzione: Questa è la parte centrale. Prende ciò che segue /log, lo unisce in una singola stringa, aggiunge un timestamp e lo aggiunge a daily_tasks.log.
• CHAT_ID Autorizzazione: Fondamentale, ho aggiunto un controllo if update.effective_chat.id != CHAT_ID:. Questo assicura che *solo la mia chat specifica* possa interagire con le funzioni di registrazione. Non vuoi che persone a caso registrino attività nel tuo file personale!
• MessageHandler(filters.TEXT & ~filters.COMMAND, echo): Questo è un catch-all per qualsiasi messaggio di testo che non è un comando. Lo utilizzo per ricordare gentilmente (o avvisare gli altri) circa l’uso corretto.

Per eseguire questo bot, basta eseguire lo script Python: python3 logger_bot.py. Rimarrà in esecuzione e ascolterà i tuoi messaggi. Per un’impostazione più avanzata, dovresti eseguirlo usando un gestore di processi come systemd o supervisor sul tuo server, assicurandoti che si riavvii se va in crash.

Ora, quando finisco di scrivere un articolo, digito semplicemente /log finished_ai7bot_article_telegram_automation nella mia chat di Telegram, e viene registrato. Più tardi, posso semplicemente usare cat daily_tasks.log sul mio server per vedere un riepilogo. È molto meno macchinoso che aprire un foglio di calcolo o un’app separata.

Consigli Utili per la Tua Automazione con Bot

Spero che questi esempi ispirino alcune idee per te. La bellezza dell’automazione personale con i bot è che non deve essere complessa o di livello aziendale. Ecco cosa ti consiglio:

1. Identifica i Tuoi “Tagli di Carta” Personali

   Quali sono quei piccoli compiti ripetitivi che drenano il tuo focus? Registrare ore, controllare specifici endpoint API, ricevere notifiche quando uno script programmato termina, monitorare piccole metriche? Fai una lista.

2. Inizia Piccolo e Semplice

   Non cercare di costruire un assistente AI completo il primo giorno. Inizia inviando un singolo messaggio quando si verifica un evento specifico. Il mio monitor di server iniziò solo inviando “Il server è giù!” quando un ping falliva. Espandi da lì.

3. Usa Librerie Esistenti

   Python con requests e python-telegram-bot copre un’enorme gamma di possibilità. Non reinventare la ruota per le interazioni API o la gestione dei bot.

4. Prioritizza Sicurezza e Privacy

   Soprattutto per i bot personali, assicurati che il tuo token API non sia esposto. Per i bot che gestiscono informazioni sensibili o controllano azioni, implementa controlli dell’ID chat per garantire che solo *tu* possa interagire, come mostrato nell’esempio del registratore.

5. Pensa Oltre le Notifiche

   Sebbene le notifiche siano utili, considera come potresti aggiungere interazioni semplici. Il tuo bot potrebbe attivare un riavvio del server? Recuperare un report veloce? Attivare un’impostazione? La libreria python-telegram-bot rende l’aggiunta di comandi piuttosto semplice.

6. Usa un Gestore di Processi per Longevità

   Se il tuo bot sta funzionando continuamente (come il bot registratore), usa systemd (su Linux) o uno strumento come supervisor per assicurarti che si riavvii se va in crash e funzioni in modo affidabile in background.

Costruire questi piccoli bot ha reso davvero più fluido e meno distratto il mio flusso di lavoro di sviluppo. È una testimonianza di come anche una semplice automazione possa liberare spazio mentale per lavorazioni più interessanti e creative. Quindi, prendi il tuo token da BotFather, identifica un piccolo fastidio e inizia a costruire!

Fammi sapere nei commenti che tipo di automazione personale hai costruito o stai pianificando di costruire con i bot di Telegram. Sono sempre alla ricerca di nuove idee!

Buona costruzione di bot!

Marcus Rivera

ai7bot.com

🕒 Published: April 4, 2026