D’accord, les amis, ici Marcus Rivera, de retour sur ai7bot.com, et aujourd’hui, nous allons nous plonger directement dans quelque chose qui fait du bruit dans mes cercles de développement, surtout lorsque j’essaie de mettre en place un bot rapidement sans toute la complexité. Nous parlons de l’API Bot de Telegram, souvent sous-estimée, parfois négligée, mais toujours présente. Plus précisément, je veux discuter de la manière de faire fonctionner un bot simple, mais étonnamment puissant, en quelques minutes en utilisant Python et l’API Bot de Telegram sans avoir besoin d’un serveur web complet ou d’un déploiement complexe.
Ouais, je sais. Les « bots Telegram » peuvent sembler un peu 2018 pour certains d’entre vous, mais écoutez-moi. Alors que les bots Discord sont très populaires (et pour une bonne raison, j’en ai construit beaucoup), il y a un créneau pour Telegram lorsque vous avez besoin de quelque chose de personnel, rapide et hautement interactif avec un minimum de frais généraux. Pensez-y : un bot de surveillance pour votre serveur à domicile, un utilitaire rapide pour votre groupe familial, ou même un simple système de notification pour votre stratégie de trading. Vous n’avez pas toujours besoin d’un conteneur Docker et de Kubernetes pour ça. Parfois, un script Python tournant sur un Raspberry Pi ou même un environnement d’hébergement partagé est tout ce dont vous avez besoin, et c’est là que Telegram brille vraiment.
Mon propre parcours avec cela a été ravivé il y a quelques mois. J’essayais de construire un petit bot pour un projet communautaire local – essentiellement, une manière simple pour les membres de demander des mises à jour sur des jalons spécifiques du projet. J’ai commencé à regarder Discord, mais la complexité de la configuration des intentions, des autorisations et des interactions potentielles complexes du serveur semblait exagérée pour ce qui était essentiellement un envoi d’informations unidirectionnel avec une simple requête. Je me suis rappelé un vieux bot Telegram que j’avais créé il y a des années pour suivre les commandes de café (ne demandez pas), et j’ai pensé : « Pourquoi pas ? » La simplicité de l’API, en particulier son mécanisme de long polling, m’a de nouveau séduit. Cela signifiait que je n’avais pas besoin d’exposer un serveur web à Internet, ce qui est un énorme gain en matière de sécurité et de déploiement pour de petits projets personnels.
Donc, aujourd’hui, nous allons construire un bot Telegram « Quick-Query ». Ce bot permettra essentiellement aux utilisateurs de demander des informations prédéfinies, agissant comme une FAQ super simple ou un récupérateur de données. Nous allons utiliser Python et la bibliothèque python-telegram-bot, qui, à mon avis, rend l’interaction avec l’API Bot de Telegram agréable.
Pourquoi le Long Polling de Telegram est Toujours Pratique pour les Petits Bots
Soyons clairs : Telegram propose deux façons principales d’obtenir des mises à jour de votre bot : Webhooks et Long Polling. Les Webhooks sont excellents lorsque vous avez un serveur public qui peut recevoir des requêtes HTTP POST de Telegram. Ils sont efficaces car Telegram vous envoie des mises à jour au fur et à mesure qu’elles se produisent. Cependant, si vous n’avez pas d’IP publique ou ne souhaitez pas gérer des proxies inverses, des certificats SSL et l’exposition de ports, les webhooks deviennent un casse-tête.
Entrez le Long Polling. Avec le long polling, votre script de bot fait une demande aux serveurs de Telegram et dit essentiellement : « Hé, as-tu des nouveaux messages pour moi ? » Telegram garde cette connexion ouverte un certain temps (jusqu’à 60 secondes par défaut). Si un nouveau message arrive pendant ce temps, Telegram le renvoie immédiatement. Sinon, la connexion finit par expirer, et votre script fait simplement une nouvelle demande. C’est comme frapper à une porte et attendre, mais la personne à l’intérieur est très rapide à répondre si elle vous entend. La beauté ici est que votre script initie la connexion, ce qui signifie qu’il peut fonctionner presque partout avec un accès Internet – votre ordinateur portable, un VPS bon marché, même un Raspberry Pi caché dans votre placard. Pas besoin de redirection de port ou d’exposition de quoi que ce soit à l’internet sauvage.
Configurer Votre Bot Telegram : Les Bases
Avant d’écrire du code, vous avez besoin d’un jeton de bot. C’est l’identité de votre bot et sa clé pour interagir avec l’API Telegram.
- Ouvrez Telegram et cherchez
@BotFather. - Démarrez une conversation avec BotFather et envoyez la commande
/newbot. - BotFather vous demandera un nom pour votre bot (par exemple, « AI7Bot Helper »).
- Ensuite, il demandera un nom d’utilisateur (doit se terminer par « bot », par exemple, « AI7BotHelper_bot »).
- Une fois que vous avez fourni ces informations, BotFather vous donnera un jeton API HTTP. Cela ressemble à quelque chose comme
1234567890:ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghij. Gardez ce jeton secret ! Si quelqu’un l’obtient, il peut contrôler votre bot.
C’est tout pour la partie Telegram ! Simple, non ?
Coder Notre Bot Quick-Query
Nous allons utiliser Python et la bibliothèque python-telegram-bot. D’abord, assurez-vous de l’avoir installée :
pip install python-telegram-bot==20.X # Utilisez la dernière version majeure stableJ’utilise la version 20.x pour cet exemple, qui a de belles fonctionnalités modernes asynchrones. Si vous êtes sur une version plus ancienne, certaines syntaxes peuvent différer légèrement, donc je recommande de mettre à jour.
Étape 1 : La Structure de Base et les Importations
Commençons avec le modèle de base pour une application python-telegram-bot.
import asyncio
import logging
import os # Pour les variables d'environnement
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
# Configurer la journalisation
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO
)
logger = logging.getLogger(__name__)
# --- Configuration ---
# Il est préférable de garder votre jeton de bot en dehors du code lui-même.
# Nous allons utiliser une variable d'environnement.
BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
if not BOT_TOKEN:
logger.error("La variable d'environnement TELEGRAM_BOT_TOKEN n'est pas définie. Fermeture.")
exit(1)
# --- Définir nos données de requête ---
# C'est ici que réside la connaissance de notre bot.
QUERY_DATA = {
"hello": "Salut ! Je suis votre assistant AI7Bot Quick-Query.",
"status": "Tous les systèmes sont normaux pour AI7Bot.com !",
"features": "Je peux vous parler de 'hello', 'status', et 'features'. Essayez de me demander quelque chose de spécifique !",
"marcus": "Marcus est le cerveau derrière ai7bot.com, toujours en train de bricoler de nouvelles idées de bot.",
"date": f"La date d'aujourd'hui est 2026-03-12. (Codé en dur pour cet exemple, mais pourrait être dynamique !)"
}
# --- Fonctions de gestionnaires ---
async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Envoie un message de bienvenue lorsque la commande /start est émise."""
user = update.effective_user
await update.message.reply_html(
f"Salut, {user.mention_html()} ! 👋 Je suis votre Bot Quick-Query. "
"Demandez-moi à propos de 'hello', 'status', 'features', 'marcus', ou 'date'."
)
async def query_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Répond aux requêtes des utilisateurs sur la base de données prédéfinies."""
user_message = update.message.text.lower().strip()
logger.info(f"Requête reçue de {update.effective_user.username} : {user_message}")
response = QUERY_DATA.get(user_message, "Désolé, je n'ai pas d'informations à ce sujet. Essayez 'features' pour voir ce que je sais !")
await update.message.reply_text(response)
async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Envoie un message d'aide lorsque la commande /help est émise."""
await update.message.reply_text(
"Je suis un simple Bot Quick-Query ! "
"Vous pouvez me poser des questions sur des sujets prédéfinis comme 'hello', 'status', 'features', 'marcus', ou 'date'.\n"
"Tapez simplement votre requête directement."
)
async def echo_unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Renvoyer les messages inconnus et inviter à demander de l'aide."""
await update.message.reply_text("Je n'ai pas compris ça. Essayez '/help' pour voir ce que je peux faire.")
async def main() -> None:
"""Démarre le bot."""
application = Application.builder().token(BOT_TOKEN).build()
# Enregistrer les gestionnaires
application.add_handler(CommandHandler("start", start_command))
application.add_handler(CommandHandler("help", help_command))
# Gestionnaire de messages pour nos requêtes - va correspondre à tout message texte
# qui n'est pas une commande.
application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, query_handler))
# Attraper tous les messages inconnus (non-commandes, non pris en charge par query_handler)
application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo_unknown)) # Cela peut nécessiter un ordre prudent
# Pour l'instant, si query_handler ne correspond pas, cela atteindra ici.
# Une meilleure approche pour les messages inconnus en général pourrait être de placer cela APRÈS le query_handler
# et s'assurer que query_handler a un filtre plus spécifique si nécessaire.
# Pour cet exemple simple, nous allons laisser query_handler traiter tout texte non-commandant et répondre.
logger.info("Bot démarrant en mode de long polling...")
application.run_polling(allowed_updates=Update.ALL_TYPES) # Commencer à interroger les mises à jour
if __name__ == "__main__":
asyncio.run(main())
Une petite note sur l’ordre du MessageHandler : la bibliothèque python-telegram-bot traite les gestionnaires dans l’ordre où ils sont ajoutés. Dans notre exemple, query_handler est conçu pour attraper tout message texte qui n’est pas une commande. Si une requête correspond, elle répond. Si elle ne correspond pas à nos QUERY_DATA, elle répond quand même avec un message « Désolé, je n’ai pas d’informations… ». Par conséquent, le gestionnaire echo_unknown qui attrape `filters.TEXT & ~filters.COMMAND` pourrait ne pas être strictement nécessaire en tant que gestionnaire distinct si `query_handler` gère déjà tous ces cas avec une réponse de secours. Je l’ai laissé avec un commentaire pour mettre en évidence comment vous pourriez l’utiliser pour une routage plus complexe plus tard, mais pour cet exemple spécifique, le `query_handler` est assez complet pour les messages texte.
Étape 2 : Exécuter Votre Bot
Avant de l’exécuter, vous devez définir votre jeton de bot en tant que variable d’environnement. Sur Linux/macOS :
export TELEGRAM_BOT_TOKEN="VOTRE_BOT_TOKEN_ICI"
python your_bot_script.pySur Windows (Invite de commandes) :
set TELEGRAM_BOT_TOKEN="VOTRE_BOT_TOKEN_ICI"
python your_bot_script.pyRemplacez VOTRE_BOT_TOKEN_ICI par le véritable token que vous avez reçu de BotFather. Ensuite, exécutez simplement votre script Python.
Ouvrez Telegram, recherchez le nom d’utilisateur de votre bot et commencez une discussion. Essayez d’envoyer /start, puis hello, status, ou n’importe lequel des mots-clés définis dans QUERY_DATA. Vous verrez votre bot répondre presque instantanément!
Étendre Votre Bot de Quick-Query : Idées Pratiques
Ce cadre simple est incroyablement flexible. Voici quelques façons dont j’ai utilisé ou envisagé d’utiliser ce modèle précis :
1. Moniteur de Statut de Serveur
Au lieu de coder en dur "Tous les systèmes sont opérationnels...", vous pourriez faire en sorte que le bot effectue un contrôle rapide. Par exemple, si vous surveillez un serveur local :
# À l'intérieur de query_handler, si user_message == "server_status":
import subprocess
async def get_server_status():
try:
# Exemple : vérifier si un service est en cours d'exécution (par exemple, Nginx)
result = subprocess.run(['systemctl', 'is-active', 'nginx'], capture_output=True, text=True, check=True)
if "active" in result.stdout:
return "Nginx fonctionne ! ✅"
else:
return "Nginx n'est pas actif. ❌"
except subprocess.CalledProcessError:
return "Impossible de vérifier le statut de Nginx. 'systemctl' est-il disponible ?"
except Exception as e:
return f"Une erreur s'est produite : {e}"
# Ensuite, dans votre query_handler :
if user_message == "server_status":
response = await get_server_status()
await update.message.reply_text(response)
Cela vous permettrait de demander le statut réel d’un service directement depuis Telegram. Imaginez en mettre cela en place sur un Raspberry Pi à la maison !
2. Bot de Rappel Simple
Vous pourriez ajouter une commande comme /remind me to [task] in [X] minutes. Cela impliquerait de parser le temps et la tâche, puis d’utiliser asyncio.sleep de Python pour attendre et renvoyer un message à l’ID de chat de l’utilisateur.
# (Exemple simplifié, gestion des erreurs et parsing approprié nécessaires)
import re
import asyncio
async def remind_me_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
args = context.args # Obtenir les arguments après la commande
if not args or len(args) < 4 or args[0] != "me" or args[1] != "to" or args[-2] != "in":
await update.message.reply_text("Utilisation : /remind me to [task] in [X] minutes")
return
try:
delay_minutes = int(args[-1])
task_parts = args[2:-2]
task = " ".join(task_parts)
await update.message.reply_text(f"D'accord, je vous rappellerai de '{task}' dans {delay_minutes} minutes.")
# Obtenir l'ID de chat pour envoyer le rappel plus tard
chat_id = update.effective_chat.id
# Planifier le rappel
await asyncio.sleep(delay_minutes * 60) # Convertir les minutes en secondes
await context.bot.send_message(chat_id=chat_id, text=f"Rappel : {task} !")
except ValueError:
await update.message.reply_text("Veuillez spécifier un nombre valide de minutes.")
except Exception as e:
logger.error(f"Erreur dans remind_me_command : {e}")
await update.message.reply_text("Un problème est survenu avec votre rappel.")
# Dans main():
# application.add_handler(CommandHandler("remind", remind_me_command))
Cela utilise context.bot.send_message ce qui permet à votre bot d'envoyer un message à un ID de chat spécifique, même si ce n'est pas en réponse à un message immédiat de l'utilisateur.
Conseils à Appliquer pour Votre Prochain Projet de Bot
Si vous cherchez à construire quelque chose de rapide, personnel, ou que vous ne voulez tout simplement pas des tracas de configuration de serveur, voici ce que je recommande :
- Adoptez le Long Polling pour la Simplicité : Pour les outils internes, assistants personnels, ou petits bots communautaires, le long polling est un excellent moyen d'éviter d'exposer des ports ou de gérer des déploiements complexes. Votre bot peut fonctionner sur presque n'importe quel appareil avec accès à Internet.
- Commencez Petit avec
python-telegram-bot: Cette bibliothèque est incroyablement bien documentée et rend l'interaction avec l'API Telegram très simple. N'essayez pas de tout construire d'un coup ; commencez par une seule commande ou une simple requête. - Utilisez des Variables d'Environnement pour les Tokens : Ne codez jamais votre token de bot en dur. Utiliser
os.getenv()est une pratique standard et sécurisée. - Pensez à Votre Cas d'Utilisation : Les bots Telegram excellent dans les interactions rapides, les notifications, et la récupération simple de données. Si vous avez besoin d'éléments d'interface utilisateur complexes, de partage de médias riches, ou d'une intégration approfondie avec d'autres services web nécessitant des points de terminaison publics constants, alors les webhooks ou d'autres plateformes pourraient être mieux adaptées. Mais pour de nombreux bots utilitaires, Telegram est parfait.
- Restez Asynchrone : La bibliothèque
python-telegram-botest basée surasyncio. Familiarisez-vous avecasync defetawait, surtout si votre bot doit effectuer des opérations qui prennent du temps (comme faire une requête web, vérifier une base de données, ou, comme dans notre exemple de rappel, attendre un délai).
Voilà. Un nouvel aperçu sur la construction d'un bot Telegram pratique qui évite les maux de tête de déploiement et se concentre immédiatement sur la délivrance de valeur. J'ai personnellement trouvé cette approche inestimable pour prototyper des idées et créer des utilitaires utiles sans être ralenti par l'infrastructure. Essayez-le, et faites-moi savoir quel type de bots Quick-Query vous finissez par construire !
🕒 Published: