Создание Telegram ботов на Python: от настройки до безопасности

# Создание виртуального окружения
python -m venv telegram_bot_env

# Активация виртуального окружения
# Для Windows
telegram_bot_env\Scripts\activate
# Для macOS/Linux
source telegram_bot_env/bin/activate

pip install pyTelegramBotAPI python-telegram-bot

pip install requests python-dotenv

telegram_bot/
│
├── .env # Файл с токеном и другими конфиденциальными данными
├── config.py # Файл с конфигурационными параметрами
├── bot.py # Основной файл бота
├── handlers/ # Директория с обработчиками команд и сообщений
│ └── __init__.py
├── utils/ # Директория с вспомогательными функциями
│ └── __init__.py
└── requirements.txt # Зависимости проекта

BOT_TOKEN=ваш_токен_от_botfather
WEBHOOK_URL=https://ваш_домен/webhook

import os
from dotenv import load_dotenv

# Загружаем переменные окружения из .env файла
load_dotenv()

# Получаем токен бота из переменных окружения
BOT_TOKEN = os.getenv('BOT_TOKEN')
WEBHOOK_URL = os.getenv('WEBHOOK_URL')

# Другие настройки
LOG_LEVEL = 'INFO'

Done! Congratulations on your new bot. You will find it at t.me/YourBot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.

Use this token to access the HTTP API:
1234567890:ABCDefGhIJKlmnOPQrsTUVwxyZ

Keep your token secure and store it safely, it can be used by anyone to control your bot.

BOT_TOKEN=1234567890:ABCDefGhIJKlmnOPQrsTUVwxyZ

start – Запустить бота
help – Получить справку
settings – Настроить параметры
subscribe – Подписаться на уведомления
unsubscribe – Отписаться от уведомлений

import requests

# Использование токена для получения информации о боте
token = "1234567890:ABCDefGhIJKlmnOPQrsTUVwxyZ"
url = f"https://api.telegram.org/bot{token}/getMe"

response = requests.get(url)
data = response.json()

if data["ok"]:
print(f"Бот успешно создан: @{data['result']['username']}")
else:
print("Ошибка при проверке токена:", data["description"])

import telebot
import logging
from config import BOT_TOKEN, LOG_LEVEL

# Настройка логирования
logging.basicConfig(
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
level=getattr(logging, LOG_LEVEL)
)
logger = logging.getLogger(__name__)

# Инициализация бота
bot = telebot.TeleBot(BOT_TOKEN)

# Обработчик команды /start
@bot.message_handler(commands=['start'])
def handle_start(message):
user_name = message.from_user.first_name
bot.reply_to(message, f"Привет, {user_name}! Я ваш новый Telegram бот. Используйте /help для получения списка команд.")
logger.info(f"Пользователь {message.from_user.id} запустил бота")

# Обработчик команды /help
@bot.message_handler(commands=['help'])
def handle_help(message):
help_text = """
Доступные команды:
/start – Начать работу с ботом
/help – Показать это сообщение
/echo текст – Отправить текст обратно
"""
bot.send_message(message.chat.id, help_text)
logger.info(f"Пользователь {message.from_user.id} запросил помощь")

# Обработчик команды /echo
@bot.message_handler(commands=['echo'])
def handle_echo(message):
# Получаем текст после команды /echo
args = message.text.split(' ', 1)
if len(args) > 1:
bot.reply_to(message, args[1])
else:
bot.reply_to(message, "Пожалуйста, укажите текст после команды /echo")

# Обработчик текстовых сообщений
@bot.message_handler(func=lambda message: True)
def handle_all_messages(message):
bot.reply_to(message, "Я получил ваше сообщение! Используйте /help для получения списка команд.")
logger.debug(f"Получено сообщение от пользователя {message.from_user.id}: {message.text}")

if __name__ == "__main__":
logger.info("Бот запущен")
bot.polling(none_stop=True)

from telebot import types

@bot.message_handler(commands=['keyboard'])
def handle_keyboard(message):
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
item1 = types.KeyboardButton("📝 Текстовая кнопка")
item2 = types.KeyboardButton("📞 Отправить контакт", request_contact=True)
item3 = types.KeyboardButton("📍 Отправить геопозицию", request_location=True)

markup.row(item1)
markup.row(item2, item3)

bot.send_message(message.chat.id, "Выберите действие:", reply_markup=markup)

@bot.message_handler(commands=['inline'])
def handle_inline(message):
markup = types.InlineKeyboardMarkup()
item1 = types.InlineKeyboardButton("Сайт Google", url="https://www.google.com")
item2 = types.InlineKeyboardButton("Ответить", callback_data="callback_button")

markup.row(item1)
markup.row(item2)

bot.send_message(message.chat.id, "Inline-клавиатура:", reply_markup=markup)

@bot.callback_query_handler(func=lambda call: call.data == "callback_button")
def handle_callback(call):
bot.answer_callback_query(call.id, "Вы нажали на кнопку!")
bot.send_message(call.message.chat.id, "Вы нажали на inline-кнопку")

# Обработка фото
@bot.message_handler(content_types=['photo'])
def handle_photo(message):
bot.reply_to(message, "Красивое фото! Я сохраню его.")

# Получение информации о фото
file_id = message.photo[-1].file_id
file_info = bot.get_file(file_id)

# Здесь можно скачать файл или обработать его
# downloaded_file = bot.download_file(file_info.file_path)

logger.info(f"Получено фото от пользователя {message.from_user.id}, file_id: {file_id}")

# Обработка документов
@bot.message_handler(content_types=['document'])
def handle_document(message):
bot.reply_to(message, "Спасибо за документ!")

file_id = message.document.file_id
file_name = message.document.file_name

logger.info(f"Получен документ от пользователя {message.from_user.id}, file_name: {file_name}")

# Обработка голосовых сообщений
@bot.message_handler(content_types=['voice'])
def handle_voice(message):
bot.reply_to(message, "Я получил ваше голосовое сообщение!")

file_id = message.voice.file_id

logger.info(f"Получено голосовое сообщение от пользователя {message.from_user.id}, duration: {message.voice.duration} секунд")

@bot.message_handler(commands=['photo'])
def send_photo(message):
# Отправка фото по URL
photo_url = "https://example.com/image.jpg"
bot.send_photo(message.chat.id, photo_url, caption="Фото по URL")

# Или отправка фото из файла
# with open('photo.jpg', 'rb') as photo:
# bot.send_photo(message.chat.id, photo, caption="Фото из файла")

@bot.message_handler(commands=['audio'])
def send_audio(message):
# Отправка аудио по URL или из файла
audio_url = "https://example.com/audio.mp3"
bot.send_audio(message.chat.id, audio_url, caption="Аудио по URL")

@bot.message_handler(commands=['video'])
def send_video(message):
# Отправка видео
video_url = "https://example.com/video.mp4"
bot.send_video(message.chat.id, video_url, caption="Видео по URL")

@bot.message_handler(commands=['location'])
def send_location(message):
# Отправка местоположения
lat = 55.7558
lon = 37.6173
bot.send_location(message.chat.id, lat, lon)

# Временное хранилище данных пользователей
user_data = {}

@bot.message_handler(commands=['set'])
def handle_set(message):
args = message.text.split(' ', 1)
if len(args) > 1:
# Сохраняем пользовательские данные
user_data[message.from_user.id] = args[1]
bot.reply_to(message, f"Данные сохранены: {args[1]}")
else:
bot.reply_to(message, "Пожалуйста, укажите данные после команды /set")

@bot.message_handler(commands=['get'])
def handle_get(message):
# Получаем сохраненные данные
if message.from_user.id in user_data:
bot.reply_to(message, f"Ваши данные: {user_data[message.from_user.id]}")
else:
bot.reply_to(message, "Данные не найдены. Используйте /set для сохранения данных.")

pip install python-telegram-bot

import logging
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import ApplicationBuilder, CommandHandler, CallbackQueryHandler, ContextTypes, MessageHandler, filters, ConversationHandler
from config import BOT_TOKEN

# Настройка логирования
logging.basicConfig(
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
level=logging.INFO
)
logger = logging.getLogger(__name__)

# Определяем состояния для ConversationHandler
CHOOSING, TYPING_REPLY, TYPING_CHOICE = range(3)

# Функции-обработчики команд
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Обработчик команды /start"""
user = update.effective_user
await update.message.reply_html(
f"Привет, {user.mention_html()}! Я продвинутый Telegram бот. Используйте /help для получения списка команд."
)
logger.info(f"Пользователь {user.id} запустил бота")

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Обработчик команды /help"""
help_text = """
Доступные команды:
/start – Начать работу с ботом
/help – Показать это сообщение
/keyboard – Показать интерактивную клавиатуру
/survey – Начать опрос
"""
await update.message.reply_text(help_text)

async def keyboard_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Обработчик команды /keyboard"""
keyboard = [
[InlineKeyboardButton("Опция 1", callback_data='option1')],
[InlineKeyboardButton("Опция 2", callback_data='option2')],
[InlineKeyboardButton("Посетить сайт", url='https://example.com')]
]

reply_markup = InlineKeyboardMarkup(keyboard)
await update.message.reply_text("Выберите опцию:", reply_markup=reply_markup)

async def button_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Обработчик нажатий на inline кнопки"""
query = update.callback_query
await query.answer()

if query.data == 'option1':
await query.edit_message_text(text="Вы выбрали Опцию 1!")
elif query.data == 'option2':
await query.edit_message_text(text="Вы выбрали Опцию 2!")

# Обработчики для ConversationHandler (опрос)
async def start_survey(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
"""Начинает опрос и запрашивает имя пользователя"""
await update.message.reply_text(
"Давайте проведем небольшой опрос. Как вас зовут?"
)
return TYPING_REPLY

async def received_name(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
"""Сохраняет имя и запрашивает возраст"""
user_name = update.message.text
context.user_data['name'] = user_name

await update.message.reply_text(f"Приятно познакомиться, {user_name}! Сколько вам лет?")
return TYPING_CHOICE

async def received_age(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
"""Сохраняет возраст и завершает опрос"""
user_age = update.message.text
context.user_data['age'] = user_age

user_name = context.user_data.get('name', 'Незнакомец')

await update.message.reply_text(
f"Спасибо за участие в опросе, {user_name}! Ваш возраст: {user_age}.\n"
"Опрос завершен."
)

# Очищаем данные пользователя
context.user_data.clear()
return ConversationHandler.END

async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
"""Отменяет опрос"""
await update.message.reply_text("Опрос отменен.")
context.user_data.clear()
return ConversationHandler.END

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Обработчик для всех остальных сообщений"""
await update.message.reply_text(f"Вы сказали: {update.message.text}")

def main() -> None:
"""Главная функция для запуска бота"""
# Создаем объект Application
application = ApplicationBuilder().token(BOT_TOKEN).build()

# Регистрируем обработчики
application.add_handler(CommandHandler("start", start))
application.add_handler(CommandHandler("help", help_command))
application.add_handler(CommandHandler("keyboard", keyboard_command))
application.add_handler(CallbackQueryHandler(button_callback))

# Создаем ConversationHandler для опроса
conv_handler = ConversationHandler(
entry_points=[CommandHandler("survey", start_survey)],
states={
TYPING_REPLY: [MessageHandler(filters.TEXT & ~filters.COMMAND, received_name)],
TYPING_CHOICE: [MessageHandler(filters.TEXT & ~filters.COMMAND, received_age)]
},
fallbacks=[CommandHandler("cancel", cancel)]
)

application.add_handler(conv_handler)

# Обработчик для всех остальных текстовых сообщений
application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

# Запускаем бота
logger.info("Бот запущен")
application.run_polling()

if __name__ == "__main__":
main()

telegram_bot/
│
├── handlers/
│ ├── __init__.py
│ ├── basic.py # Базовые команды (start, help)
│ ├── survey.py # Команды для опроса
│ └── admin.py # Административные команды
├── utils/
│ ├── __init__.py
│ └── keyboards.py # Функции для создания клавиатур
├── .env
├── config.py
└── main.py # Основной файл для запуска бота

from telegram import Update
from telegram.ext import ContextTypes
import logging

logger = logging.getLogger(__name__)

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
user = update.effective_user
await update.message.reply_html(
f"Привет, {user.mention_html()}! Я модульный Telegram бот."
)
logger.info(f"Пользователь {user.id} запустил бота")

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
help_text = """
Доступные команды:
/start – Начать работу с ботом
/help – Показать это сообщение
/survey – Начать опрос
"""
await update.message.reply_text(help_text)

import logging
from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters
from config import BOT_TOKEN
from handlers.basic import start, help_command
# Импортируем другие обработчики из других файлов...

def main() -> None:
# Настройка логирования
logging.basicConfig(
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
level=logging.INFO
)
logger = logging.getLogger(__name__)

# Создаем объект Application
application = ApplicationBuilder().token(BOT_TOKEN).build()

# Регистрируем обработчики из разных модулей
application.add_handler(CommandHandler("start", start))
application.add_handler(CommandHandler("help", help_command))
# Добавляем другие обработчики...

# Запускаем бота
logger.info("Бот запущен")
application.run_polling()

if __name__ == "__main__":
main()

from flask import Flask, request
import telegram
from telegram.ext import Application, CommandHandler, MessageHandler, filters
import logging
from config import BOT_TOKEN, WEBHOOK_URL, WEBHOOK_PATH

# Настройка логирования
logging.basicConfig(
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
level=logging.INFO
)
logger = logging.getLogger(__name__)

# Создаем Flask-приложение
app = Flask(__name__)

# Функции-обработчики команд
async def start(update, context):
await update.message.reply_text("Привет! Я бот, работающий через webhook.")

async def help_command(update, context):
await update.message.reply_text("Используйте /start для запуска бота.")

async def echo(update, context):
await update.message.reply_text(update.message.text)

# Настройка бота
async def setup():
# Создаем и настраиваем приложение
application = Application.builder().token(BOT_TOKEN).build()

# Регистрируем обработчики
application.add_handler(CommandHandler("start", start))
application.add_handler(CommandHandler("help", help_command))
application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

# Настраиваем webhook
await application.bot.set_webhook(url=WEBHOOK_URL)

return application

# Создаем экземпляр приложения
application = await setup()

# Обработчик веб-хука
@app.route(WEBHOOK_PATH, methods=['POST'])
async def webhook():
if request.method == "POST":
update = telegram.Update.de_json(request.get_json(force=True), application.bot)
await application.process_update(update)
return "OK"

# Обработчик для проверки работоспособности
@app.route('/')
def index():
return 'Бот работает!'

if __name__ == '__main__':
# Запускаем Flask-приложение
app.run(host='0.0.0.0', port=8443, ssl_context=('cert.pem', 'key.pem'))

# Список ID администраторов
ADMIN_IDS = [123456789, 987654321]

def admin_only(func):
"""Декоратор для ограничения доступа к функциям только для администраторов"""
async def wrapper(update, context):
user_id = update.effective_user.id
if user_id in ADMIN_IDS:
return await func(update, context)
else:
await update.message.reply_text("Извините, у вас нет доступа к этой команде.")
logger.warning(f"Пользователь {user_id} пытался получить доступ к административной команде")
return None
return wrapper

@admin_only
async def admin_command(update, context):
"""Административная команда, доступная только для администраторов"""
await update.message.reply_text("Вы выполнили административную команду.")

from flask import Flask
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)

# Настройка ограничителя скорости запросов
limiter = Limiter(
app,
key_func=get_remote_address,
default_limits=["200 per day", "50 per hour"]
)

@app.route(WEBHOOK_PATH, methods=['POST'])
@limiter.limit("10 per minute")
async def webhook():
# Обработка webhook...

server {
listen 443 ssl;
server_name your-domain.com;

ssl_certificate /path/to/cert.pem;
ssl_certificate_key /path/to/key.pem;

location /telegram-webhook {
proxy_pass http://localhost:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}

[program:telegram_bot]
command=/path/to/venv/bin/python /path/to/your/bot.py
directory=/path/to/your/bot
autostart=true
autorestart=true
stderr_logfile=/var/log/telegram_bot/error.log
stdout_logfile=/var/log/telegram_bot/output.log