Mon bot Python : Configuration rapide avec l’API Telegram

D’accord, les amis, Marcus Rivera ici, de retour sur ai7bot.com, et aujourd’hui nous allons nous plonger tête la première dans quelque chose qui fait buzz dans mes cercles de développement, surtout quand j’essaie de mettre en place un bot rapidement sans faire tout un plat. Nous parlons de l’API Telegram Bot, souvent sous-estimée, parfois négligée, mais toujours présente. Plus précisément, je veux aborder la façon de créer un bot simple mais étonnamment puissant en quelques minutes en utilisant Python et l’API Telegram Bot sans avoir besoin d’un serveur web complet ou d’un déploiement complexe.

Oui, je sais. Les « bots Telegram » peuvent sembler un peu 2018 pour certains d’entre vous, mais écoutez-moi. Alors que les bots Discord reçoivent beaucoup d’amour (et pour de bonnes raisons, j’en ai construit pas mal), il y a un créneau pour Telegram quand 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 domestique, un utilitaire rapide pour votre groupe familial, ou même un simple système de notifications 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 fonctionnant 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, un moyen simple pour les membres de demander des mises à jour sur des étapes spécifiques du projet. J’ai commencé à regarder Discord, mais la complexité de la mise en place des intentions, des permissions et la gestion des interactions serveur potentiellement complexes semblait excessif pour ce qui était essentiellement une diffusion d’informations à sens unique avec une simple requête. Je me suis souvenu d’un ancien 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 avantage en matière de sécurité et de déploiement pour de petits projets personnels.

Alors, aujourd’hui, nous allons construire un bot Telegram appelé « 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 utiliserons Python et la bibliothèque python-telegram-bot, qui, à mon avis, rend l’interaction avec l’API Telegram Bot très agréable.

Pourquoi le Long Polling de Telegram est Toujours Idéal pour les Petits Bots

Soyons clairs : Telegram propose deux façons principales d’obtenir des mises à jour de votre bot : les Webhooks et le Long Polling. Les Webhooks sont excellents lorsque vous avez un serveur public qui peut recevoir des demandes HTTP POST de Telegram. Ils sont efficaces car Telegram vous envoie des mises à jour à mesure qu’elles se produisent. Cependant, si vous n’avez pas d’IP publique ou si vous ne voulez pas vous occuper des proxies inverses, des certificats SSL et de l’exposition des ports, les webhooks deviennent un véritable casse-tête.

Entrez le Long Polling. Avec le long polling, votre script bot fait une demande aux serveurs de Telegram et dit essentiellement : « Hé, as-tu des messages nouveaux pour moi ? » Telegram maintient cette connexion ouverte pendant un certain temps (jusqu’à 60 secondes par défaut). Si un nouveau message arrive pendant ce temps, Telegram le renvoie immédiatement. Si ce n’est pas le cas, la connexion finit par expirer, et votre script fait simplement une nouvelle demande. C’est comme frapper à la porte de façon répétée et attendre, mais la personne à l’intérieur est super 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 n’importe où 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.

1. Ouvrez Telegram et recherchez @BotFather.
2. Commencez une conversation avec BotFather et envoyez la commande /newbot.
3. BotFather vous demandera un nom pour votre bot (par exemple, « AI7Bot Helper »).
4. Ensuite, il demandera un nom d’utilisateur (doit se terminer par « bot », par exemple, « AI7BotHelper_bot »).
5. Une fois que vous avez fourni ces informations, BotFather vous donnera un jeton API HTTP. Cela ressemble à 1234567890:ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghij. Gardez ce jeton secret ! Si quelqu’un l’obtient, il peut contrôler votre bot.

C’est tout pour le côté 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 stable

J’utilise la version 20.x pour cet exemple, qui dispose de quelques fonctionnalités modernes asynchrones intéressantes. Si vous utilisez une version plus ancienne, certaines syntaxes peuvent légèrement différer, donc je recommande de mettre à jour.

Étape 1 : La Structure de Base et les Imports

Commençons par le code 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

# Configuration du logging
logging.basicConfig(
 format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 level=logging.INFO
)
logger = logging.getLogger(__name__)

# --- Configuration ---
# Il est recommandé de garder votre jeton de bot hors 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. Sortie.")
 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 poser une question spécifique !",
 "marcus": "Marcus est le cerveau derrière ai7bot.com, toujours en train de bricoler de nouvelles idées de bots.",
 "date": f"La date d'aujourd'hui est 2026-03-12. (Codée 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"Bonjour, {user.mention_html()} ! 👋 Je suis votre bot Quick-Query. "
 "Demandez-moi au sujet 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 basées sur des 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 demander des sujets prédéfinis comme 'hello', 'status', 'features', 'marcus', ou 'date'.\n"
 "Il suffit de taper votre requête directement."
 )

async def echo_unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Renvoie les messages inconnus et invite à demander de l'aide."""
 await update.message.reply_text("Je n'ai pas compris cela. Essayez '/help' pour voir ce que je peux faire.")

async def main() -> None:
 """Démarrer 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))

 # Catch all pour les messages inconnus (non-commandes, non gérés par query_handler)
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo_unknown)) # Cela pourrait nécessiter un ordre soigneux
 # 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 le placer APRÈS le query_handler
 # et de s'assurer que query_handler a un filtre plus spécifique si nécessaire.
 # Pour cet exemple simple, nous laisserons query_handler traiter tout texte non commande et répondre.

 logger.info("Bot démarrant en mode long polling...")
 application.run_polling(allowed_updates=Update.ALL_TYPES) # Démarrer le polling pour 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 encore 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 séparé si `query_handler` gère déjà tous ces cas avec une réponse de secours. Je l’ai laissé là avec un commentaire pour souligner comment vous pourriez l’utiliser pour un 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 comme variable d’environnement. Sur Linux/macOS :

export TELEGRAM_BOT_TOKEN="VOTRE_BOT_TOKEN_ICI"
python your_bot_script.py

Sur Windows (Invite de commandes) :

set TELEGRAM_BOT_TOKEN="VOTRE_BOT_TOKEN_ICI"
python your_bot_script.py

Remplacez VOTRE_BOT_TOKEN_ICI par le 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 conversation. Essayez d’envoyer /start, puis hello, status, ou n’importe quel mot-clé défini dans QUERY_DATA. Vous verrez votre bot répondre presque instantanément !

Élargir Votre Bot de Requête Rapide : Idées Pratiques

Ce cadre simple est incroyablement flexible. Voici quelques façons dont j’ai utilisé ou envisagé d’utiliser ce modèle exact :

1. Moniteur de Statut du Serveur

Au lieu de coder en dur "Tous les systèmes sont opérationnels...", vous pourriez faire en sorte que le bot effectue une vérification rapide. Par exemple, si vous surveillez un serveur local :

# Dans 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 vérifier le statut réel d’un service directement depuis Telegram. Imaginez mettre cela en place sur un Raspberry Pi chez vous !

2. Bot de Rappel Simple

Vous pourriez ajouter une commande comme /remind me to [task] in [X] minutes. Cela impliquerait d’analyser le temps et la tâche, puis d’utiliser asyncio.sleep de Python pour attendre et envoyer un message au chat ID de l’utilisateur.

# (Exemple simplifié, gestion des erreurs et bonne analyse nécessaires)
import re
import asyncio

async def remind_me_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 args = context.args # Obtenez 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("Usage : /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 te rappellerai de '{task}' dans {delay_minutes} minutes.")
 
 # Obtenez l'ID de chat pour envoyer le rappel plus tard
 chat_id = update.effective_chat.id 

 # Planifiez 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 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 utilisateur immédiat.

Conseils Pratiques pour Votre Prochain Projet de Bot

Si vous cherchez à construire quelque chose de rapide, personnel, ou si vous ne voulez tout simplement pas vous compliquer la vie avec la configuration du serveur, voici ce que je recommande :

1. Adoptez le Long Polling pour la Simplicité : Pour les outils internes, les assistants personnels ou les petits bots communautaires, le long polling est une excellente façon d'éviter d'exposer des ports ou de gérer un déploiement complexe. Votre bot peut fonctionner sur pratiquement n'importe quel appareil avec accès à Internet.
2. Commencez Petit avec python-telegram-bot : Cette bibliothèque est incroyablement bien documentée et facilite l'interaction avec l'API Telegram. Ne tentez pas de tout construire d'un coup ; commencez par une seule commande ou une requête simple.
3. Utilisez des Variables d'Environnement pour les Tokens : Ne codez jamais en dur votre token de bot. Utiliser os.getenv() est une pratique standard et sécurisée.
4. Pensez à Votre Cas d'Utilisation : Les bots Telegram excellent dans les interactions rapides, les notifications et la récupération de données simples. Si vous avez besoin d'éléments d'interface utilisateur complexes, de partage de médias riches, ou d'une intégration profonde avec d'autres services web nécessitant des points d'accès publics constants, alors les webhooks ou d'autres plateformes pourraient mieux convenir. Mais pour de nombreux bots utilitaires, Telegram est parfait.
5. Restez Asynchrone : La bibliothèque python-telegram-bot est construite sur asyncio. Familiarisez-vous avec async def et await, 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à, une nouvelle approche pour créer un bot Telegram pratique qui évite les tracas de déploiement et se concentre sur la création de valeur. J'ai personnellement trouvé cette méthode inestimable pour prototyper des idées et créer des utilitaires utiles sans être submergé par l'infrastructure. Essayez et faites-moi savoir quels types de bots de requête rapide vous finissez par créer !

🕒 Published: March 26, 2026