В эпоху высокоразвитых мессенджеров Telegram стал предпочтительной платформой для разработчиков благодаря своему мощному Bot API и открытой экосистеме. Интеграция Nano Banana Pro (модель Gemini 3 Pro Image) с Telegram позволяет пользователям генерировать высококачественные AI-изображения прямо в интерфейсе чата, без необходимости переходить в другие приложения или веб-страницы. В этой статье мы подробно разберем техническую архитектуру Telegram Bot API и предоставим полное решение на основе платформы APIYI.
Технический анализ Telegram Bot API
Telegram Bot API — это открытый интерфейс, предоставляемый официально Telegram, позволяющий разработчикам создавать автоматизированные программы для взаимодействия с пользователями. По сравнению с ботами других платформ мессенджеров, Telegram Bot обладает уникальными техническими преимуществами.
Основные архитектурные характеристики
1. Полностью открытый HTTP API
Telegram Bot API основан на стандартном протоколе HTTPS, все взаимодействия осуществляются через RESTful API. Разработчикам достаточно отправить HTTP-запрос на https://api.telegram.org/bot<token>/method для вызова различных функций, без необходимости сложной интеграции SDK.
2. Двойной режим: Webhook и Long Polling
Telegram поддерживает два способа получения сообщений:
- Long Polling (длительный опрос): Бот активно запрашивает обновления сообщений с сервера Telegram, подходит для разработки и тестирования
- Webhook: Сервер Telegram активно отправляет сообщения на указанный HTTPS-адрес, подходит для продакшен-среды, обеспечивает более высокую скорость реагирования
3. Поддержка разнообразных типов сообщений
Бот может отправлять и получать различные типы сообщений:
- Текстовые сообщения, изображения, видео, документы
- Встроенные клавиатуры (Inline Keyboard) и пользовательские клавиатуры (Reply Keyboard)
- Группы медиафайлов (Media Group)
- Опросы, геолокация и др.
4. Возможности обработки файлов
Telegram Bot поддерживает загрузку и скачивание файлов:
- Ограничение на скачивание файлов: ≤20 МБ
- Ограничение на загрузку файлов: ≤50 МБ
- Поддержка быстрого обращения к уже загруженным файлам через file_id
Почему стоит выбрать Telegram для интеграции AI-генерации изображений?
Преимущества пользовательского опыта:
- Бесшовная интеграция: Пользователям не нужно скачивать дополнительные приложения, генерация доступна в привычном чат-инструменте
- Высокая конфиденциальность: Telegram поддерживает сквозное шифрование, защищая приватность пользователей
- Кроссплатформенная синхронизация: Сгенерированные изображения автоматически синхронизируются на всех устройствах
- Групповое сотрудничество: Можно использовать в группах, члены команды совместно используют возможности генерации
Преимущества технической реализации:
- Простое развертывание: Не требуется фронтенд-разработка, Bot API обрабатывает все взаимодействия с интерфейсом
- Низкая стоимость: Telegram Bot полностью бесплатен, без ограничений на количество одновременных запросов
- Высокая масштабируемость: Легко добавить дополнительные AI-функции (генерация текста, распознавание речи и др.)
- Глобальная доступность: Telegram доступен в большинстве регионов мира, большая пользовательская база
🎯 Техническая рекомендация: Интеграция Nano Banana Pro с Telegram — идеальное решение для построения сервиса AI-генерации изображений. Рекомендуем использовать API через платформу API易 apiyi.com для вызова Gemini 3 Pro Image API. Платформа предоставляет интерфейс
gemini-3-pro-image-previewс поддержкой множества разрешений: 1K, 2K, 4K. Стоимость одного вызова составляет всего $0.05, что на 80% дешевле официального API, без ограничений на параллельные запросы, что идеально подходит для высокочастотных вызовов в Telegram Bot.
3 способа подключения Nano Banana Pro к Telegram
Способ 1: Прямая разработка на Python — полностью управляемое пользовательское решение
Сценарии применения: глубокая кастомизация функциональности, полный контроль над логикой кода, долгосрочное обслуживание и эксплуатация
Это наиболее гибкий вариант, подходящий для разработчиков с базовыми знаниями Python. Создание полноценного Bot-приложения с использованием библиотеки python-telegram-bot.
Технологический стек:
- Язык: Python 3.9+
- Основная библиотека: python-telegram-bot (асинхронная версия 20.x)
- AI интерфейс: Gemini 3 Pro Image API платформы API易
- Развертывание: Docker + облачный сервер (или локальный сервер)
Полная реализация кода:
Ниже представлена полнофункциональная реализация Telegram-бота для генерации изображений:
import os
import asyncio
import requests
import base64
from telegram import Update
from telegram.ext import (
Application,
CommandHandler,
MessageHandler,
filters,
ContextTypes
)
class NanoBananaBot:
def __init__(self, telegram_token: str, apiyi_key: str):
"""Инициализация бота"""
self.telegram_token = telegram_token
self.apiyi_key = apiyi_key
self.apiyi_base_url = "https://api.apiyi.com"
async def start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Обработка команды /start"""
welcome_message = """
🎨 Добро пожаловать в бот генерации изображений Nano Banana Pro!
На базе модели Google Gemini 3 Pro Image создаем высококачественные AI-изображения для вас.
📝 Способы использования:
1. Просто отправьте текстовое описание, например: "милый рыжий кот дремлет на солнце"
2. Используйте команду /generate, например: /generate футуристический ночной город в технологичном стиле
3. Используйте /hd для генерации изображений 4K высокой четкости, например: /hd обои космического звездного неба
⚙️ Доступные команды:
/start - показать приветственное сообщение
/generate <промпт> - генерация изображения 2K (по умолчанию)
/hd <промпт> - генерация изображения 4K высокой четкости
/help - просмотр справочной документации
💡 Подсказка: чем подробнее описание, тем лучше результат генерации!
"""
await update.message.reply_text(welcome_message)
async def help_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Обработка команды /help"""
help_text = """
🔍 Советы по использованию Nano Banana Pro:
📌 Базовый шаблон промпта:
- Описание объекта + стиль + детали
- Пример: "японский сад, стиль анимации Миядзаки, падающая сакура, мягкое освещение"
🎨 Популярные ключевые слова стилей:
- Фотостиль: профессиональная фотография, макро, широкоугольная съемка, портретная фотография
- Художественный стиль: масляная живопись, акварель, иллюстрация, киберпанк, vaporwave
- 3D-стиль: 3D-рендеринг, C4D, Blender, реалистичный 3D
⚡ Выбор разрешения:
- /generate - 2048x2048 (подходит для быстрого просмотра)
- /hd - 4096x4096 (подходит для печати и обоев)
💰 Тарификация:
- Разрешение 2K: $0.05/изображение
- Разрешение 4K: $0.05/изображение (единая цена API易)
"""
await update.message.reply_text(help_text)
async def generate_image(
self,
prompt: str,
resolution: str = "2048x2048",
reference_image: str = None
) -> tuple[str, str]:
"""Вызов платформы API易 для генерации изображения"""
url = f"{self.apiyi_base_url}/v1/images/generations"
headers = {
"Authorization": f"Bearer {self.apiyi_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gemini-3-pro-image-preview",
"prompt": prompt,
"resolution": resolution,
"num_images": 1
}
# Если есть референсное изображение, добавить в запрос
if reference_image:
payload["reference_images"] = [reference_image]
try:
response = requests.post(url, headers=headers, json=payload, timeout=60)
response.raise_for_status()
result = response.json()
image_url = result["data"][0]["url"]
# Скачать изображение
img_response = requests.get(image_url, timeout=30)
img_response.raise_for_status()
return img_response.content, image_url
except requests.exceptions.RequestException as e:
raise Exception(f"Ошибка вызова API: {str(e)}")
async def handle_generate_command(
self,
update: Update,
context: ContextTypes.DEFAULT_TYPE,
resolution: str = "2048x2048"
):
"""Обработка команды генерации изображения"""
# Получение промпта
if context.args:
prompt = " ".join(context.args)
else:
await update.message.reply_text(
"❌ Пожалуйста, предоставьте описание изображения, например:\n/generate милый рыжий кот"
)
return
# Отправка уведомления об обработке
processing_msg = await update.message.reply_text(
f"🎨 Генерация изображения...\n"
f"📝 Промпт: {prompt}\n"
f"📐 Разрешение: {resolution}\n"
f"⏱️ Ориентировочное время: 5-10 секунд"
)
try:
# Вызов API для генерации изображения
image_data, image_url = await asyncio.to_thread(
self.generate_image,
prompt=prompt,
resolution=resolution
)
# Отправка изображения
await update.message.reply_photo(
photo=image_data,
caption=f"✅ Генерация успешна!\n\n📝 Промпт: {prompt}\n📐 Разрешение: {resolution}"
)
# Удаление сообщения об обработке
await processing_msg.delete()
except Exception as e:
await processing_msg.edit_text(
f"❌ Ошибка генерации: {str(e)}\n\n"
f"💡 Пожалуйста, проверьте промпт или повторите попытку позже"
)
async def generate_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Обработка команды /generate (разрешение 2K)"""
await self.handle_generate_command(update, context, "2048x2048")
async def hd_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Обработка команды /hd (разрешение 4K)"""
await self.handle_generate_command(update, context, "4096x4096")
async def handle_text_message(
self,
update: Update,
context: ContextTypes.DEFAULT_TYPE
):
"""Обработка обычных текстовых сообщений (прямая генерация изображения)"""
prompt = update.message.text
# Игнорировать слишком короткие сообщения
if len(prompt) < 3:
await update.message.reply_text(
"💡 Промпт слишком короткий, пожалуйста, предоставьте более подробное описание"
)
return
# Вызов логики генерации (по умолчанию 2K)
context.args = [prompt]
await self.handle_generate_command(update, context, "2048x2048")
async def handle_photo_message(
self,
update: Update,
context: ContextTypes.DEFAULT_TYPE
):
"""Обработка сообщений с изображениями (функция image-to-image)"""
# Получение изображения, отправленного пользователем
photo = update.message.photo[-1] # Получение версии с наивысшим разрешением
file = await context.bot.get_file(photo.file_id)
# Скачивание изображения
photo_data = await file.download_as_bytearray()
photo_base64 = base64.b64encode(photo_data).decode()
# Получение подписи к изображению (если есть)
caption = update.message.caption or "сохранить стиль оригинального изображения, создать похожее изображение"
processing_msg = await update.message.reply_text(
f"🎨 Генерация на основе референсного изображения...\n"
f"📝 Промпт: {caption}\n"
f"⏱️ Ориентировочное время: 5-10 секунд"
)
try:
# Вызов API (с референсным изображением)
image_data, image_url = await asyncio.to_thread(
self.generate_image,
prompt=caption,
resolution="2048x2048",
reference_image=photo_base64
)
await update.message.reply_photo(
photo=image_data,
caption=f"✅ Генерация на основе референсного изображения успешна!\n\n📝 Промпт: {caption}"
)
await processing_msg.delete()
except Exception as e:
await processing_msg.edit_text(
f"❌ Ошибка генерации: {str(e)}"
)
def run(self):
"""Запуск бота"""
# Создание Application
app = Application.builder().token(self.telegram_token).build()
# Регистрация обработчиков команд
app.add_handler(CommandHandler("start", self.start_command))
app.add_handler(CommandHandler("help", self.help_command))
app.add_handler(CommandHandler("generate", self.generate_command))
app.add_handler(CommandHandler("hd", self.hd_command))
# Регистрация обработчиков сообщений
app.add_handler(MessageHandler(
filters.TEXT & ~filters.COMMAND,
self.handle_text_message
))
app.add_handler(MessageHandler(
filters.PHOTO,
self.handle_photo_message
))
# Запуск Bot (режим long polling)
print("🤖 Запуск бота Nano Banana Pro...")
print("✅ Бот запущен, ожидание сообщений...")
app.run_polling(allowed_updates=Update.ALL_TYPES)
# Пример использования
if __name__ == "__main__":
# Чтение конфигурации из переменных окружения
TELEGRAM_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "your_telegram_bot_token_here")
APIYI_API_KEY = os.getenv("APIYI_API_KEY", "your_apiyi_api_key_here")
# Создание и запуск Bot
bot = NanoBananaBot(
telegram_token=TELEGRAM_TOKEN,
apiyi_key=APIYI_API_KEY
)
bot.run()
Шаги развертывания:
-
Создание Telegram Bot:
# В Telegram начните диалог с @BotFather # Отправьте команду /newbot # Следуйте инструкциям для установки имени и username бота # Получите Bot Token (формат: 123456789:ABCdefGHIjklMNOpqrsTUVwxyz) -
Установка зависимостей:
pip install python-telegram-bot requests -
Настройка переменных окружения:
export TELEGRAM_BOT_TOKEN="your_bot_token_here" export APIYI_API_KEY="your_apiyi_api_key_here" -
Запуск Bot:
python nano_banana_bot.py
Преимущества:
- ✅ Полный контроль над логикой кода
- ✅ Возможность глубокой кастомизации функциональности (например, image-to-image, перенос стиля)
- ✅ Поддержка статистики данных и управления пользователями
- ✅ Контролируемая стоимость, вызов интерфейса API易 по требованию
Ограничения:
- ⚠️ Требуется определенный уровень навыков разработки на Python
- ⚠️ Необходим сервер, работающий 24/7
- ⚠️ Требуется самостоятельная обработка ошибок и исключений
💡 Оптимизация затрат: Вызов Gemini 3 Pro Image API через платформу API易 apiyi.com, единая цена для разрешений 2K и 4K — $0.05/изображение, что на 80% дешевле официального API. Если бот генерирует 1000 изображений в день, месячные затраты составят всего $50 (около ¥350), что значительно ниже стоимости собственного GPU-сервера или использования официального API.
Способ 2: Визуальный рабочий процесс n8n — быстрое создание без кода
Сценарии применения: отсутствие навыков программирования, быстрая проверка прототипа, легковесное приложение
n8n — это инструмент автоматизации рабочих процессов с открытым исходным кодом, предоставляющий визуальный интерфейс для создания сложных автоматизированных процессов путем перетаскивания узлов.
Основные шаги:
-
Развертывание n8n:
docker run -d --restart unless-stopped \ -p 5678:5678 \ -v ~/.n8n:/home/node/.n8n \ n8nio/n8n -
Создание рабочего процесса:
- Узел Telegram Trigger: прием сообщений от пользователя
- Узел HTTP Request: вызов Gemini Image API платформы API易
- Узел Telegram: отправка сгенерированного изображения
-
Настройка вызова API:
{ "url": "https://api.apiyi.com/v1/images/generations", "method": "POST", "headers": { "Authorization": "Bearer {{ $env.APIYI_API_KEY }}", "Content-Type": "application/json" }, "body": { "model": "gemini-3-pro-image-preview", "prompt": "{{ $json.message.text }}", "resolution": "2048x2048" } }
Доступные шаблоны n8n:
- "Text-to-image generation with Google Gemini & enhanced prompts via Telegram Bot"
- "AI image generation & editing with Google Gemini and Telegram Bot"
- "Generate AI Images via Telegram using Gemini & Pollinations"
Преимущества:
- ✅ Без кода, создание путем перетаскивания
- ✅ Быстрое создание, прототип за 10 минут
- ✅ Визуальная отладка, ясность и наглядность
- ✅ Поддержка множественной интеграции (база данных, уведомления, мониторинг и т.д.)
Ограничения:
- ⚠️ Ограниченная кастомизация функциональности
- ⚠️ Сложности с реализацией сложной логики
- ⚠️ Необходимость запуска сервиса n8n
🚀 Быстрый старт: Сообщество n8n уже имеет готовые шаблоны рабочих процессов Gemini + Telegram, посетите «n8n workflows» n8n.io/workflows, найдите "Gemini Telegram", и импортируйте одним кликом. В сочетании с низкозатратным API платформы API易 apiyi.com можно быстро проверить бизнес-идею.
Способ 3: Использование проектов с открытым исходным кодом — готовое к использованию решение
Сценарии применения: быстрый запуск, обучение на примерах, вторичная разработка
На GitHub уже есть множество зрелых проектов с открытым исходным кодом Gemini + Telegram, которые можно сразу развернуть или использовать в качестве примера.
Рекомендуемые проекты:
1. GeminiTelegramBot
- GitHub: jiaweing/GeminiTelegramBot
- Особенности: на базе Gemini 2.0 Flash, поддержка диалогов и генерации изображений
- Язык: Python
- Функции: текстовая генерация, генерация изображений, мультимодальные диалоги
2. Gemini-Telegram-Bot
- GitHub: H-T-H/Gemini-Telegram-Bot
- Особенности: легковесный, простое развертывание
- Язык: Python
- Функции: взаимодействие с Gemini API
Способ развертывания:
# Клонирование проекта
git clone https://github.com/jiaweing/GeminiTelegramBot.git
cd GeminiTelegramBot
# Установка зависимостей
pip install -r requirements.txt
# Настройка переменных окружения
cp .env.example .env
# Отредактируйте файл .env, укажите Telegram Token и API key
# Изменение API endpoint (на платформу API易)
# В коде замените https://generativelanguage.googleapis.com
# на https://api.apiyi.com
# Запуск
python main.py
Преимущества:
- ✅ Готов к использованию, быстрое развертывание
- ✅ Стандартизированный код, можно использовать для обучения
- ✅ Активное сообщество, постоянные обновления
- ✅ Возможность вторичной разработки на основе исходного кода
Ограничения:
- ⚠️ Необходимо понимание структуры проекта
- ⚠️ Может потребоваться адаптация интерфейса платформы API易
- ⚠️ Зависимость от поддержки автора
🎯 Рекомендации по вторичной разработке: Проекты с открытым исходным кодом обычно вызывают официальный Gemini API, можно изменить API endpoint на платформу API易 apiyi.com, сохранив логику кода без изменений, снизив затраты на вызовы на 80%. Необходимо заменить только два параметра:
base_urlиapi_key.
Сравнительная матрица трех способов подключения
Способ 1: Python разработка
Полностью управляемое решение
Сценарии применения
• Сложная бизнес-логика
• Высокая кастомизация
• Есть команда разработчиков
Анализ затрат
Разработка: ⭐⭐⭐⭐
Эксплуатация: ⭐⭐⭐
API: $0.05/изобр.
Эффективность разработки
Первоначальная настройка: 2-3 дня
Скорость итерации: быстрая
Кастомизируемость
★★★★★ Полный контроль
Технический порог: Python + Async программирование
Способ 2: Рабочие процессы n8n
Быстрое создание без кода
Сценарии применения
• Проверка прототипа
• Нетехническая команда
• Простая автоматизация
Анализ затрат
Разработка: ⭐
Эксплуатация: ⭐⭐
API: $0.05/изобр.
Эффективность разработки
Первоначальная настройка: 1-2 часа
Скорость итерации: очень быстрая
Кастомизируемость
★★★☆☆ Модульная настройка
Продвинутые функции
Функция 1: Генерация изображения из изображения (перенос стиля)
Nano Banana Pro поддерживает генерацию на основе референсного изображения, что позволяет реализовать перенос стиля и создание вариаций изображения.
Пример реализации:
async def handle_photo_with_caption(
update: Update,
context: ContextTypes.DEFAULT_TYPE
):
"""Обработка изображения с подписью (img2img)"""
# Получаем изображение
photo = update.message.photo[-1]
file = await context.bot.get_file(photo.file_id)
photo_bytes = await file.download_as_bytearray()
photo_base64 = base64.b64encode(photo_bytes).decode()
# Получаем текстовое описание пользователя
prompt = update.message.caption or "generate similar image"
# Вызов API (с референсным изображением)
payload = {
"model": "gemini-3-pro-image-preview",
"prompt": prompt,
"reference_images": [photo_base64],
"resolution": "2048x2048"
}
# ... остальной код как выше
Сценарии применения:
- Преобразование стиля: превращение фото в масляную живопись/акварель/аниме стиль
- Изменение сцены: сохранение объекта с изменением фона или окружения
- Оптимизация деталей: сохранение композиции с улучшением качества или изменением деталей
Функция 2: Массовая генерация (несколько изображений за раз)
Для сценариев, требующих несколько версий, можно генерировать несколько изображений одновременно.
Пример реализации:
async def batch_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Массовая генерация (4 изображения за раз)"""
if not context.args:
await update.message.reply_text("❌ Пожалуйста, предоставьте промпт")
return
prompt = " ".join(context.args)
processing_msg = await update.message.reply_text(
f"🎨 Массовая генерация 4 изображений...\n⏱️ Ожидаемое время: 15-30 секунд"
)
# Параллельная генерация 4 изображений
tasks = [
asyncio.to_thread(generate_image, prompt, "2048x2048")
for _ in range(4)
]
try:
results = await asyncio.gather(*tasks)
# Отправка группы изображений (Media Group)
media_group = [
InputMediaPhoto(media=img_data)
for img_data, _ in results
]
await update.message.reply_media_group(media=media_group)
await processing_msg.delete()
except Exception as e:
await processing_msg.edit_text(f"❌ Ошибка массовой генерации: {str(e)}")
Расчет стоимости:
- Стоимость одного изображения: $0.05
- 4 изображения одновременно: $0.20
- По сравнению с последовательной генерацией, параллельные вызовы экономят 60% времени
Функция 3: Управление квотами пользователей
Для публичных ботов необходимо контролировать использование каждого пользователя.
Пример реализации:
import json
from datetime import datetime, timedelta
class QuotaManager:
def __init__(self, quota_file="user_quotas.json"):
self.quota_file = quota_file
self.quotas = self.load_quotas()
def load_quotas(self):
"""Загрузка пользовательских квот"""
try:
with open(self.quota_file, "r") as f:
return json.load(f)
except FileNotFoundError:
return {}
def save_quotas(self):
"""Сохранение пользовательских квот"""
with open(self.quota_file, "w") as f:
json.dump(self.quotas, f, indent=2)
def check_quota(self, user_id: int, daily_limit: int = 10) -> bool:
"""Проверка пользовательской квоты"""
user_id_str = str(user_id)
today = datetime.now().strftime("%Y-%m-%d")
if user_id_str not in self.quotas:
self.quotas[user_id_str] = {"date": today, "count": 0}
user_data = self.quotas[user_id_str]
# Сброс ежедневной квоты
if user_data["date"] != today:
user_data["date"] = today
user_data["count"] = 0
# Проверка превышения лимита
if user_data["count"] >= daily_limit:
return False
# Увеличение счетчика
user_data["count"] += 1
self.save_quotas()
return True
def get_remaining(self, user_id: int, daily_limit: int = 10) -> int:
"""Получение остаточной квоты"""
user_id_str = str(user_id)
if user_id_str not in self.quotas:
return daily_limit
user_data = self.quotas[user_id_str]
today = datetime.now().strftime("%Y-%m-%d")
if user_data["date"] != today:
return daily_limit
return max(0, daily_limit - user_data["count"])
# Интеграция в класс Bot
class NanoBananaBot:
def __init__(self, telegram_token, apiyi_key):
# ... остальная инициализация
self.quota_manager = QuotaManager()
self.daily_limit = 10 # 10 изображений на пользователя в день
async def handle_generate_command(self, update, context, resolution):
user_id = update.effective_user.id
# Проверка квоты
if not self.quota_manager.check_quota(user_id, self.daily_limit):
remaining = self.quota_manager.get_remaining(user_id, self.daily_limit)
await update.message.reply_text(
f"❌ Ваша дневная квота исчерпана!\n"
f"📊 Дневной лимит: {self.daily_limit} изображений\n"
f"🔄 Автоматический сброс в 00:00"
)
return
remaining = self.quota_manager.get_remaining(user_id, self.daily_limit)
# ... исходная логика генерации
# Уведомление об остаточной квоте после успешной генерации
await update.message.reply_text(
f"✅ Генерация успешна!\n📊 Остаток квоты на сегодня: {remaining}/{self.daily_limit}"
)
Функция 4: Многоязычная поддержка
Предоставление локализованного опыта для пользователей разных языков.
Пример реализации:
MESSAGES = {
"zh": {
"welcome": "🎨 欢迎使用 Nano Banana Pro 生图机器人!",
"generating": "🎨 正在生成图片...",
"success": "✅ 生成成功!",
"error": "❌ 生成失败: {error}",
"quota_exceeded": "❌ 您今日的配额已用完!"
},
"en": {
"welcome": "🎨 Welcome to Nano Banana Pro Image Bot!",
"generating": "🎨 Generating image...",
"success": "✅ Generated successfully!",
"error": "❌ Generation failed: {error}",
"quota_exceeded": "❌ Daily quota exceeded!"
}
}
def get_user_language(user_id: int) -> str:
"""Получение языковых предпочтений пользователя (можно читать из БД)"""
# Упрощенный пример, по умолчанию возвращает китайский
return "zh"
def get_message(user_id: int, key: str, **kwargs) -> str:
"""Получение локализованного сообщения"""
lang = get_user_language(user_id)
message = MESSAGES.get(lang, MESSAGES["zh"]).get(key, key)
return message.format(**kwargs)
# Пример использования
await update.message.reply_text(
get_message(user_id, "generating")
)
Развертывание и эксплуатация
Выбор способа развертывания
Вариант 1: Развертывание на облачном сервере (рекомендуется)
Преимущества:
- Высокая стабильность, работа 24/7
- Достаточная пропускная способность, быстрая передача изображений
- Хорошая масштабируемость
Рекомендуемые провайдеры:
- Международные: AWS EC2, Google Cloud, DigitalOcean
- Китайские: Alibaba Cloud, Tencent Cloud, Huawei Cloud
Рекомендуемая конфигурация:
- CPU: 2 ядра
- Память: 2GB
- Пропускная способность: 3Mbps+
- Хранилище: 20GB
- Месячная стоимость: $5-10
Развертывание через Docker:
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "nano_banana_bot.py"]
# Сборка образа
docker build -t nano-banana-bot .
# Запуск контейнера
docker run -d --restart unless-stopped \
-e TELEGRAM_BOT_TOKEN="your_token" \
-e APIYI_API_KEY="your_key" \
--name nano-bot \
nano-banana-bot
Вариант 2: Локальный сервер/Raspberry Pi
Подходит для личного использования или небольшого тестирования:
- Низкая стоимость (одноразовые инвестиции в оборудование)
- Полный контроль
- Требуется стабильное сетевое окружение
Вариант 3: Serverless развертывание
Использование AWS Lambda, Google Cloud Functions и т.д.:
- Оплата по факту использования, минимальная стоимость
- Автоматическое масштабирование
- Требуется адаптация для режима Webhook
Мониторинг и логирование
Логирование:
import logging
# Настройка логирования
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO,
handlers=[
logging.FileHandler("bot.log"),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
# Логирование в ключевых местах
async def handle_generate_command(self, update, context, resolution):
user_id = update.effective_user.id
username = update.effective_user.username
prompt = " ".join(context.args)
logger.info(
f"User {user_id}(@{username}) generated image: "
f"prompt='{prompt}', resolution={resolution}"
)
try:
# ... логика генерации
logger.info(f"Image generated successfully for user {user_id}")
except Exception as e:
logger.error(f"Generation failed for user {user_id}: {str(e)}")
raise
Мониторинг производительности:
import time
async def generate_image_with_timing(prompt, resolution):
"""Генерация изображения с мониторингом производительности"""
start_time = time.time()
try:
result = await generate_image(prompt, resolution)
duration = time.time() - start_time
logger.info(
f"Generation completed: "
f"prompt_length={len(prompt)}, "
f"resolution={resolution}, "
f"duration={duration:.2f}s"
)
return result
except Exception as e:
duration = time.time() - start_time
logger.error(
f"Generation failed after {duration:.2f}s: {str(e)}"
)
raise
Оповещения об ошибках:
async def send_admin_alert(error_message: str):
"""Отправка оповещения об ошибке администратору"""
admin_chat_id = "your_admin_telegram_id"
try:
await context.bot.send_message(
chat_id=admin_chat_id,
text=f"⚠️ Bot Error Alert:\n\n{error_message}"
)
except:
logger.error("Failed to send admin alert")
Стратегии оптимизации затрат
1. Интеллектуальное кэширование:
import hashlib
from functools import lru_cache
# Кэширование результатов для идентичных промптов
@lru_cache(maxsize=100)
def get_cached_image(prompt_hash: str):
"""Получение кэшированного изображения"""
# Чтение из БД или файловой системы
pass
def generate_with_cache(prompt: str, resolution: str):
"""Генерация с кэшированием"""
# Вычисление хэша промпта
prompt_hash = hashlib.md5(
f"{prompt}_{resolution}".encode()
).hexdigest()
# Проверка кэша
cached = get_cached_image(prompt_hash)
if cached:
logger.info(f"Cache hit for prompt: {prompt}")
return cached
# Промах кэша, вызов API
result = generate_image(prompt, resolution)
# Сохранение в кэш
save_to_cache(prompt_hash, result)
return result
2. Уровни квот:
USER_TIERS = {
"free": {"daily_limit": 5, "max_resolution": "2048x2048"},
"premium": {"daily_limit": 50, "max_resolution": "4096x4096"},
"enterprise": {"daily_limit": -1, "max_resolution": "4096x4096"} # без ограничений
}
def get_user_tier(user_id: int) -> str:
"""Получение уровня пользователя (можно читать из БД)"""
# Упрощенный пример
premium_users = [123456, 789012] # список платных пользователей
return "premium" if user_id in premium_users else "free"
3. Сжатие при передаче:
from PIL import Image
import io
def compress_image(image_data: bytes, max_size_kb: int = 500) -> bytes:
"""Сжатие изображения для уменьшения трафика"""
img = Image.open(io.BytesIO(image_data))
# Конвертация в RGB (если RGBA)
if img.mode == "RGBA":
img = img.convert("RGB")
# Постепенное снижение качества до достижения требуемого размера
for quality in range(95, 50, -5):
buffer = io.BytesIO()
img.save(buffer, format="JPEG", quality=quality, optimize=True)
compressed = buffer.getvalue()
if len(compressed) / 1024 <= max_size_kb:
logger.info(
f"Compressed from {len(image_data)/1024:.1f}KB "
f"to {len(compressed)/1024:.1f}KB (quality={quality})"
)
return compressed
return compressed
💰 Анализ затрат: Предположим, бот обслуживает 100 пользователей в день, каждый генерирует 5 изображений (всего 500 изображений/день):
- Стоимость API: 500 × $0.05 = $25/день = $750/месяц (цены платформы API易)
- Стоимость сервера: $10/месяц (облачный сервер 2 ядра 2GB)
- Общая стоимость: $760/месяц
- Сравнение с официальным API: 500 × $0.25 = $125/день = $3,750/месяц
- Экономия: $2,990/месяц (примерно ¥21,000/месяц)
Часто задаваемые вопросы
Как получить Token для Telegram Bot?
Шаги:
- Найдите @BotFather в Telegram
- Отправьте команду
/newbot - Следуя подсказкам, установите имя бота (отображаемое имя)
- Установите имя пользователя бота (должно заканчиваться на bot, например my_image_bot)
- BotFather вернет Token (формат:
123456789:ABCdefGHIjklMNOpqrsTUVwxyz)
Важные моменты:
- Token — конфиденциальная информация, не делитесь ею публично
- Если Token скомпрометирован, его можно перегенерировать через команду
/revokeв @BotFather - Храните Token в переменных окружения или конфигурационных файлах, не используйте hardcode
Как обрабатывать ошибки генерации?
Распространенные причины сбоев:
- Таймаут API: Nano Banana Pro требует 5-15 секунд для генерации изображений высокого разрешения
- Нарушение правил промптов: Неприемлемый контент отклоняется API
- Исчерпана квота API: Превышен баланс аккаунта или лимит скорости
- Проблемы с сетью: Нестабильное соединение сервера с API
Стратегии обработки:
async def generate_with_retry(prompt, resolution, max_retries=3):
"""Генерация с механизмом повторных попыток"""
for attempt in range(max_retries):
try:
return await generate_image(prompt, resolution)
except requests.exceptions.Timeout:
if attempt < max_retries - 1:
logger.warning(f"Timeout, retrying ({attempt + 1}/{max_retries})")
await asyncio.sleep(2) # Ожидание 2 секунды перед повтором
else:
raise Exception("Таймаут генерации, попробуйте позже")
except requests.exceptions.HTTPError as e:
if e.response.status_code == 429: # Лимит скорости
raise Exception("Слишком много запросов, попробуйте позже")
elif e.response.status_code == 400: # Ошибка запроса
raise Exception("Промпт может содержать неприемлемый контент, измените и попробуйте снова")
else:
raise Exception(f"Ошибка вызова API: {e.response.status_code}")
Как выбрать между Webhook и Long Polling?
Long Polling (Длинный опрос):
- Преимущества: Прост в использовании, не требует настройки HTTPS, подходит для разработки и тестирования
- Недостатки: Немного выше задержка (1-2 секунды), сервер активно запрашивает сообщения
- Применение: Среда разработки, небольшие приложения (< 100 пользователей)
Webhook:
- Преимущества: Высокая скорость отклика (< 100ms), Telegram активно отправляет сообщения, эффективен и экономичен
- Недостатки: Требуется HTTPS домен и сертификат, сложная настройка
- Применение: Производственная среда, средние и крупные приложения (> 100 пользователей)
Пример настройки Webhook:
from flask import Flask, request
app = Flask(__name__)
@app.route(f"/{TELEGRAM_BOT_TOKEN}", methods=["POST"])
async def webhook():
"""Обработка запросов Telegram Webhook"""
update = Update.de_json(request.get_json(), bot)
await application.process_update(update)
return "OK"
# Установка Webhook
url = f"https://yourdomain.com/{TELEGRAM_BOT_TOKEN}"
bot.set_webhook(url=url)
# Запуск Flask
app.run(host="0.0.0.0", port=8443, ssl_context=(cert_path, key_path))
Как оптимизировать скорость генерации изображений?
Стратегии оптимизации:
-
Выбор подходящего разрешения:
- Повседневное общение: 1024×1024 (примерно 2-3 секунды)
- Социальные сети: 2048×2048 (примерно 5-8 секунд)
- Печать/обои: 4096×4096 (примерно 10-15 секунд)
-
Параллельная обработка:
# Используйте асинхронную параллельную обработку вместо синхронной последовательной tasks = [generate_image(prompt, res) for prompt in prompts] results = await asyncio.gather(*tasks) -
Оптимизация предзагрузки:
# Начинайте подготовку при вводе пользователя (предиктивная генерация) async def on_typing(update, context): # Пользователь печатает, прогреваем соединение с API await prepare_api_connection() -
Использование CDN:
# Загрузите в CDN после генерации для ускорения последующего доступа image_url = upload_to_cdn(image_data) await update.message.reply_photo(photo=image_url)
💡 Совет по производительности: Используя платформу API易 apiyi.com для вызова Gemini 3 Pro Image API, вы получаете доступ к глобально развернутым узлам со средним временем отклика < 100ms (без учета времени генерации изображения). По сравнению с прямым вызовом официального API это сокращает сетевую задержку на 30-50%.
Как защитить бота от злоупотреблений?
Меры защиты от злоупотреблений:
-
Ограничение скорости:
from datetime import datetime, timedelta user_last_request = {} async def check_rate_limit(user_id, cooldown_seconds=10): """Проверка ограничения скорости""" now = datetime.now() if user_id in user_last_request: last_time = user_last_request[user_id] elapsed = (now - last_time).total_seconds() if elapsed < cooldown_seconds: remaining = cooldown_seconds - elapsed raise Exception(f"Пожалуйста, подождите {remaining:.0f} секунд перед повторной попыткой") user_last_request[user_id] = now -
Модерация контента:
BANNED_KEYWORDS = [ "насилие", "порнография", "политически чувствительные слова" # ... больше запрещенных слов ] def check_prompt(prompt: str) -> bool: """Проверка соответствия промпта правилам""" prompt_lower = prompt.lower() for keyword in BANNED_KEYWORDS: if keyword in prompt_lower: return False return True -
Черный список пользователей:
BLACKLIST = set() async def check_blacklist(user_id): """Проверка наличия пользователя в черном списке""" if user_id in BLACKLIST: raise Exception("Вы заблокированы. При возникновении вопросов обратитесь к администратору") -
Проверка CAPTCHA:
import random async def request_captcha(update, context): """Отправка капчи""" code = random.randint(1000, 9999) context.user_data["captcha"] = code await update.message.reply_text( f"🔐 Введите код подтверждения: {code}\n" f"(Действителен в течение 60 секунд)" )
Как получить и настроить платформу API易?
Процесс регистрации:
- Посетите «Официальный сайт API易» apiyi.com
- Нажмите "Регистрация" для создания аккаунта
- Подтвердите email
- Войдите в консоль и получите API Key
Настройка API Key:
# Метод 1: Переменные окружения (рекомендуется)
export APIYI_API_KEY="sk-xxxxxxxxxxxx"
# Метод 2: Конфигурационный файл
# config.json
{
"apiyi_key": "sk-xxxxxxxxxxxx",
"telegram_token": "123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
}
# Метод 3: Служба управления секретами (рекомендуется для производства)
from azure.keyvault.secrets import SecretClient
client = SecretClient(vault_url, credential)
apiyi_key = client.get_secret("apiyi-key").value
Тарификация:
- Оплата по количеству вызовов
- Разрешение 2K: $0.05/изображение
- Разрешение 4K: $0.05/изображение (единая цена)
- Без скрытых платежей, без минимального расхода
- Поддержка предупреждений о балансе и автоматического пополнения
Заключение и перспективы
Интеграция Nano Banana Pro в Telegram — одна из лучших практик создания AI-сервиса генерации изображений. Три метода, представленные в этой статье, имеют свои особенности:
- Прямая разработка на Python: Полный контроль, мощный функционал, подходит для долгосрочной эксплуатации
- Визуальный рабочий процесс n8n: Без кода, быстрая настройка, подходит для быстрой валидации
- Open-source проекты: Готовые решения, быстрый запуск, подходят для обучения и справки
Выбор метода зависит от конкретных потребностей: технических навыков, бюджета времени, функциональных требований. Для команд с навыками разработки рекомендуется метод 1; для предпринимателей без технического бэкграунда — метод 2; для разработчиков, желающих быстро запуститься, — метод 3.
С непрерывным развитием технологий AI-генерации изображений будущие Telegram-боты станут более интеллектуальными:
- Генерация в реальном времени: Сокращение с 5-10 секунд до 1-2 секунд
- Генерация видео: Расширение от статичных изображений до коротких видео
- Голосовое взаимодействие: Генерация изображений через голосовое описание
- AR-интеграция: Прямое использование сгенерированных изображений для AR-фильтров
🎯 Рекомендация к действию: Посетите платформу API易 apiyi.com прямо сейчас, зарегистрируйте аккаунт и получите API Key, чтобы начать создание своего Telegram-бота для генерации изображений. Платформа предоставляет $5 бесплатного кредита, которого хватит на генерацию 100 изображений для тестирования. В сочетании с полным кодом из этой статьи вы сможете запустить своего первого AI-бота за 30 минут и начать свое AI-предпринимательство!
