Bot de Telegram en Servidor VPS: Guía Completa de Configuración

Introducción

Los bots de Telegram han revolucionado cómo las empresas, comunidades e individuos automatizan tareas, entregan servicios e interactúan con usuarios en una de las plataformas de mensajería de más rápido crecimiento del mundo. Con más de 700 millones de usuarios activos, Telegram proporciona una API de bots poderosa que permite a los desarrolladores crear asistentes automatizados, sistemas de notificación, herramientas de servicio al cliente, bots de juegos, ayudantes de productividad e innumerables otras aplicaciones.

A diferencia de las aplicaciones web tradicionales que requieren interfaces de usuario complejas, los bots de Telegram aprovechan la interfaz de mensajería familiar que los usuarios ya conocen, reduciendo la fricción de adopción mientras proporcionan funcionalidad rica a través de teclados en línea, comandos personalizados, compartir archivos y soporte multimedia. Ejecutar bots en servidores VPS garantiza disponibilidad 24/7, escalabilidad e independencia de la infraestructura local.

Esta guía completa te lleva paso a paso por el despliegue de bots de Telegram listos para producción en un servidor VPS. Aprenderás creación y registro de bots, opciones de lenguajes de programación (Python, Node.js, PHP), configuraciones de webhook y long-polling, integración de bases de datos, mejores prácticas de seguridad, gestión de procesos, monitoreo y automatización del despliegue.

Ya sea que estés construyendo un bot de soporte al cliente, sistema de notificaciones, herramienta de gestión comunitaria, asistente de comercio electrónico, servicio automatizado de entrega de contenido o juego interactivo, esta guía proporciona todo lo necesario para desplegar y mantener exitosamente bots de Telegram en infraestructura VPS.

Vista General de Casos de Uso

¿Por Qué Desplegar un Bot de Telegram?

Los bots de Telegram ofrecen ventajas únicas para diversas aplicaciones:

Soporte al Cliente Automatizado: Proporciona respuestas instantáneas a preguntas frecuentes, creación de tickets, verificación de estado de pedidos y solución básica de problemas sin intervención humana.

Notificaciones y Alertas: Envía notificaciones en tiempo real para eventos del sistema, alertas de monitoreo, confirmaciones de pedidos, recordatorios de citas o cualquier información sensible al tiempo directamente a los usuarios.

Entrega de Contenido: Distribuye automáticamente actualizaciones de noticias, publicaciones de blog, anuncios de productos o contenido educativo a suscriptores en un horario o activado por eventos.

Recolección de Datos: Recopila retroalimentación de usuarios, respuestas de encuestas, información de registro o envíos de formularios a través de interfaces conversacionales sin construir formularios separados.

Integración de Comercio Electrónico: Permite navegación de productos, realización de pedidos, procesamiento de pagos y servicio al cliente completamente dentro de Telegram.

Gestión de Comunidad: Modera grupos, da la bienvenida a nuevos miembros, aplica reglas, gestiona permisos y rastrea actividad en comunidades de Telegram.

Herramientas de Productividad: Gestión de tareas, recordatorios, toma de notas, almacenamiento de archivos, servicios de traducción o cálculos accesibles desde cualquier dispositivo con Telegram.

Juegos y Entretenimiento: Juegos interactivos, concursos de trivia, adivinos, reproductores de música u otras características de entretenimiento que involucran a usuarios a través del chat.

Interfaces de API: Proporciona interfaces de chat fáciles de usar para APIs complejas, bases de datos o servicios, haciendo sistemas técnicos accesibles a usuarios no técnicos.

Tipos Comunes de Bots

Bots de Comandos: Responden a comandos específicos (/start, /help, /status) con respuestas o acciones predefinidas.

Bots Conversacionales: Bots de procesamiento de lenguaje natural que participan en conversaciones contextuales usando IA o árboles de decisión.

Bots en Línea: Activados al escribir @nombrebot en cualquier chat, proporcionando resultados de búsqueda, medios o acciones rápidas sin salir de la conversación.

Bots de Pago: Procesan pagos por productos o servicios usando el sistema de pago integrado de Telegram.

Bots de Juegos: Juegos interactivos que van desde trivia simple hasta experiencias multijugador complejas.

Bots Administrativos: Bots de gestión de grupos que manejan moderación, bienvenida, verificación de usuarios y tareas administrativas.

Bots de Webhook: Reciben notificaciones de servicios externos (GitHub, sistemas de monitoreo, pipelines de CI/CD) y las reenvían a Telegram.

Opciones de Stack Tecnológico

Python:

• Bibliotecas: python-telegram-bot, aiogram, pyrogram
• Ventajas: Bibliotecas de bots extensas, integración de aprendizaje automático, amigable para principiantes
• Casos de uso: Propósito general, bots de IA, aplicaciones de ciencia de datos

Node.js:

• Bibliotecas: node-telegram-bot-api, telegraf, Grammy
• Ventajas: Rápido, procesamiento asíncrono, ecosistema JavaScript
• Casos de uso: Aplicaciones en tiempo real, integraciones de webhook, proyectos full-stack

PHP:

• Bibliotecas: telegram-bot-sdk, TelegramBot
• Ventajas: Despliegue simple, compatibilidad con hosting web
• Casos de uso: Bots simples, integración web, integración de sistemas legacy

Go:

• Bibliotecas: telebot, tgbotapi
• Ventajas: Alto rendimiento, binarios compilados, bajo uso de recursos
• Casos de uso: Bots de alto tráfico, automatización de sistemas

Requisitos

Requisitos del Sistema

Requisitos Mínimos (Bot Simple, < 1000 usuarios):

• CPU: 1 núcleo a 1.5+ GHz
• RAM: 512MB
• Almacenamiento: 10GB
• Red: 1 Mbps
• SO: Ubuntu 20.04/22.04, Debian 11/12

Requisitos Recomendados (Bot Medio, 1000-10000 usuarios):

• CPU: 2 núcleos a 2.0+ GHz
• RAM: 2GB
• Almacenamiento: 20GB SSD
• Red: 10 Mbps
• SO: Ubuntu 22.04 LTS

Requisitos de Alto Rendimiento (Bot Grande, 10000+ usuarios):

• CPU: 4+ núcleos a 2.5+ GHz
• RAM: 8GB+
• Almacenamiento: 50GB SSD
• Red: 100 Mbps
• SO: Ubuntu 22.04 LTS

Requisitos de Software

Componentes Core:

• Runtime del lenguaje de programación (Python 3.9+, Node.js 16+, PHP 8+)
• Gestor de procesos (systemd, PM2 o supervisord)
• Base de datos (SQLite, MySQL, PostgreSQL, MongoDB)
• Opcional: Redis para caché y almacenamiento de sesiones

Herramientas de Desarrollo:

• Git para control de versiones
• Editor de texto o IDE
• Cliente SSH para acceso al servidor

Requisitos de Telegram

Token del Bot: Obtenido de @BotFather en Telegram.

Cuenta de Telegram: Cuenta válida de Telegram para crear y gestionar bots.

Dominio (Opcional): Para modo webhook, dominio HTTPS con certificado SSL válido.

Conocimientos Previos

• Programación básica en el lenguaje elegido
• Fundamentos de línea de comandos de Linux
• Comprensión básica de HTTP/HTTPS y APIs
• Fundamentos de control de versiones Git
• Uso de la app Telegram

Configuración Paso a Paso

Paso 1: Crear Bot de Telegram

Abre Telegram y busca @BotFather.

Inicia conversación y crea nuevo bot:

/newbot

Sigue las instrucciones:

1. Ingresa nombre del bot (ej., "Mi Bot Increíble")
2. Ingresa nombre de usuario del bot (debe terminar en 'bot', ej., "mi_bot_increible_bot")

@BotFather proporciona el token del bot:

1234567890:ABCdefGHIjklMNOpqrsTUVwxyz-ABCDEFG

Guarda este token de forma segura - es la clave de autenticación de tu bot.

Configura ajustes del bot:

/setdescription - Establece descripción del bot
/setabouttext - Establece texto "acerca de"
/setuserpic - Sube imagen de perfil del bot
/setcommands - Establece lista de comandos

Ejemplo de lista de comandos:

start - Inicia el bot
help - Muestra mensaje de ayuda
status - Verifica estado del bot
settings - Configura ajustes

Paso 2: Preparar Servidor VPS

Actualiza sistema:

sudo apt update && sudo apt upgrade -y

Instala herramientas esenciales:

sudo apt install -y git curl wget build-essential

Paso 3: Instalar Bot Python (Ejemplo)

Instala Python y pip:

sudo apt install -y python3 python3-pip python3-venv

Crea directorio del proyecto:

mkdir -p ~/telegram-bots/mybot
cd ~/telegram-bots/mybot

Crea entorno virtual:

python3 -m venv venv
source venv/bin/activate

Instala python-telegram-bot:

pip install python-telegram-bot python-dotenv

Paso 4: Crear Bot Simple

Crea script del bot:

nano bot.py

Agrega código básico del bot:

#!/usr/bin/env python3

import os
import logging
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
from dotenv import load_dotenv

# Cargar variables de entorno
load_dotenv()
BOT_TOKEN = os.getenv('BOT_TOKEN')

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

# Manejadores de comandos
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Envía un mensaje cuando se emite el comando /start."""
    user = update.effective_user
    await update.message.reply_text(
        f'¡Hola {user.first_name}! Bienvenido a Mi Bot Increíble.\n\n'
        f'Usa /help para ver comandos disponibles.'
    )

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Envía un mensaje cuando se emite el comando /help."""
    help_text = """
Comandos disponibles:

/start - Inicia el bot
/help - Muestra este mensaje de ayuda
/status - Verifica estado del bot
/echo <texto> - Repite tu mensaje

¡Envíame cualquier mensaje y te lo repetiré!
    """
    await update.message.reply_text(help_text)

async def status(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Envía estado del bot cuando se emite /status."""
    await update.message.reply_text('¡Bot funcionando! 🤖 Todos los sistemas operacionales.')

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Repite el mensaje del usuario."""
    await update.message.reply_text(update.message.text)

async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Registra errores causados por Updates."""
    logger.error(f'Update {update} causó error {context.error}')

def main():
    """Inicia el bot."""
    # Crear la Application
    application = Application.builder().token(BOT_TOKEN).build()

    # Registrar manejadores de comandos
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("help", help_command))
    application.add_handler(CommandHandler("status", status))

    # Registrar manejador de mensajes para eco
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

    # Registrar manejador de errores
    application.add_error_handler(error_handler)

    # Iniciar el Bot
    logger.info("Bot iniciado - esperando actualizaciones")
    application.run_polling(allowed_updates=Update.ALL_TYPES)

if __name__ == '__main__':
    main()

Crea archivo de entorno:

nano .env

Agrega:

BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz-ABCDEFG

Haz el bot ejecutable:

chmod +x bot.py

Paso 5: Probar Bot Localmente

Ejecuta bot:

python bot.py

Abre Telegram, busca tu bot y prueba:

/start
/help
/status
¡Hola bot!

El bot debe responder a comandos y repetir mensajes.

Detén el bot con Ctrl+C.

Paso 6: Crear Servicio Systemd

Desactiva entorno virtual:

deactivate

Crea servicio systemd:

sudo nano /etc/systemd/system/telegram-bot.service

Agrega:

[Unit]
Description=Bot de Telegram
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/telegram-bots/mybot
Environment="PATH=/home/ubuntu/telegram-bots/mybot/venv/bin"
ExecStart=/home/ubuntu/telegram-bots/mybot/venv/bin/python bot.py
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Ajusta rutas y usuario según sea necesario.

Habilita e inicia servicio:

sudo systemctl daemon-reload
sudo systemctl enable telegram-bot
sudo systemctl start telegram-bot

Verifica estado:

sudo systemctl status telegram-bot

Ver logs:

sudo journalctl -u telegram-bot -f

Configuración

Integración de Base de Datos

Instala bibliotecas de base de datos:

pip install sqlalchemy psycopg2-binary

Crea modelos de base de datos:

from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    telegram_id = Column(Integer, unique=True)
    username = Column(String)
    first_name = Column(String)
    created_at = Column(DateTime, default=datetime.utcnow)

# Configuración de base de datos
engine = create_engine('sqlite:///bot.db')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

Guarda usuario en /start:

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.effective_user

    # Guardar en base de datos
    session = Session()
    db_user = session.query(User).filter_by(telegram_id=user.id).first()

    if not db_user:
        db_user = User(
            telegram_id=user.id,
            username=user.username,
            first_name=user.first_name
        )
        session.add(db_user)
        session.commit()

    session.close()

    await update.message.reply_text(f'¡Bienvenido {user.first_name}!')

Configuración de Webhook

El modo webhook es más eficiente para bots de alto tráfico.

Requisitos:

• Dominio HTTPS con certificado SSL válido
• IP pública o dominio apuntando al servidor

Configura proxy reverso Nginx:

sudo apt install nginx certbot python3-certbot-nginx -y

Obtén certificado SSL:

sudo certbot --nginx -d bot.ejemplo.com

Configura Nginx:

sudo nano /etc/nginx/sites-available/telegram-bot

Agrega:

server {
    listen 443 ssl http2;
    server_name bot.ejemplo.com;

    ssl_certificate /etc/letsencrypt/live/bot.ejemplo.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/bot.ejemplo.com/privkey.pem;

    location /webhook {
        proxy_pass http://localhost:8443;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Habilita sitio:

sudo ln -s /etc/nginx/sites-available/telegram-bot /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Actualiza código del bot para webhook:

def main():
    application = Application.builder().token(BOT_TOKEN).build()

    # Registrar manejadores
    application.add_handler(CommandHandler("start", start))
    # ... otros manejadores

    # Configuración de webhook
    application.run_webhook(
        listen="127.0.0.1",
        port=8443,
        url_path="webhook",
        webhook_url=f"https://bot.ejemplo.com/webhook"
    )

Botones de Teclado en Línea

Agrega botones interactivos:

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton("Opción 1", callback_data='1')],
        [InlineKeyboardButton("Opción 2", callback_data='2')],
        [InlineKeyboardButton("Ayuda", callback_data='help')]
    ]

    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.message.reply_text('Elige una opción:', reply_markup=reply_markup)

async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    await query.answer()

    if query.data == '1':
        await query.edit_message_text('¡Seleccionaste Opción 1!')
    elif query.data == '2':
        await query.edit_message_text('¡Seleccionaste Opción 2!')
    elif query.data == 'help':
        await query.edit_message_text('Información de ayuda aquí')

# Registrar manejadores
application.add_handler(CommandHandler('menu', menu))
application.add_handler(CallbackQueryHandler(button_handler))

Manejo de Archivos

Maneja cargas de archivos:

async def handle_photo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    photo_file = await update.message.photo[-1].get_file()
    await photo_file.download_to_drive(f'downloads/{photo_file.file_id}.jpg')
    await update.message.reply_text('¡Foto recibida y guardada!')

async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE):
    document = update.message.document
    doc_file = await document.get_file()
    await doc_file.download_to_drive(f'downloads/{document.file_name}')
    await update.message.reply_text(f'¡Archivo {document.file_name} recibido!')

# Registrar manejadores
application.add_handler(MessageHandler(filters.PHOTO, handle_photo))
application.add_handler(MessageHandler(filters.Document.ALL, handle_document))

Envía archivos a usuarios:

async def send_file(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_document(document=open('reporte.pdf', 'rb'))
    await update.message.reply_photo(photo=open('imagen.jpg', 'rb'))

Tareas Programadas

Envía mensajes periódicos:

from telegram.ext import JobQueue
from datetime import time

async def daily_reminder(context: ContextTypes.DEFAULT_TYPE):
    chat_id = context.job.data
    await context.bot.send_message(
        chat_id=chat_id,
        text="Recordatorio diario: ¡No olvides revisar tus tareas!"
    )

async def set_reminder(update: Update, context: ContextTypes.DEFAULT_TYPE):
    chat_id = update.effective_chat.id

    # Programar recordatorio diario a las 9:00 AM
    context.job_queue.run_daily(
        daily_reminder,
        time=time(hour=9, minute=0),
        data=chat_id
    )

    await update.message.reply_text('¡Recordatorio diario configurado para las 9:00 AM!')

application.add_handler(CommandHandler('remind', set_reminder))

Comandos de Administrador

Restringe comandos a usuarios específicos:

ADMIN_IDS = [123456789, 987654321]  # Tus IDs de usuario de Telegram

def admin_only(func):
    async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE):
        user_id = update.effective_user.id
        if user_id not in ADMIN_IDS:
            await update.message.reply_text('Este comando es solo para administradores.')
            return
        return await func(update, context)
    return wrapper

@admin_only
async def broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
    message = ' '.join(context.args)

    session = Session()
    users = session.query(User).all()

    for user in users:
        try:
            await context.bot.send_message(chat_id=user.telegram_id, text=message)
        except Exception as e:
            logger.error(f'Fallo al enviar a {user.telegram_id}: {e}')

    await update.message.reply_text(f'¡Difusión enviada a {len(users)} usuarios!')

application.add_handler(CommandHandler('broadcast', broadcast))

Monitoreo y Mantenimiento

Configuración de Logging

Logging mejorado:

import logging
from logging.handlers import RotatingFileHandler

# Crear directorio de logs
os.makedirs('logs', exist_ok=True)

# Configurar logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

# Manejador de archivo con rotación
file_handler = RotatingFileHandler(
    'logs/bot.log',
    maxBytes=10485760,  # 10MB
    backupCount=5
)
file_handler.setFormatter(
    logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
)

# Manejador de consola
console_handler = logging.StreamHandler()
console_handler.setFormatter(
    logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
)

logger.addHandler(file_handler)
logger.addHandler(console_handler)

Endpoint de Health Check

Agrega verificación de salud:

from flask import Flask
import threading

app = Flask(__name__)

@app.route('/health')
def health():
    return {'status': 'ok', 'bot': 'running'}, 200

def run_flask():
    app.run(host='127.0.0.1', port=5000)

# Inicia Flask en hilo de fondo
threading.Thread(target=run_flask, daemon=True).start()

Estadísticas del Bot

Rastrea uso:

from collections import defaultdict
import json

stats = defaultdict(int)

async def track_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    stats['total_messages'] += 1
    stats[f'user_{update.effective_user.id}'] += 1

    # Guardar estadísticas periódicamente
    with open('stats.json', 'w') as f:
        json.dump(dict(stats), f)

async def get_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    if user_id not in ADMIN_IDS:
        return

    total = stats['total_messages']
    unique_users = len([k for k in stats.keys() if k.startswith('user_')])

    await update.message.reply_text(
        f'📊 Estadísticas del Bot:\n\n'
        f'Total de mensajes: {total}\n'
        f'Usuarios únicos: {unique_users}'
    )

Notificaciones de Errores

Envía errores al admin:

async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    logger.error(f'Update {update} causó error {context.error}')

    # Notificar admin
    error_message = f'⚠️ Ocurrió un error:\n\n{context.error}'
    for admin_id in ADMIN_IDS:
        try:
            await context.bot.send_message(chat_id=admin_id, text=error_message)
        except Exception as e:
            logger.error(f'Fallo al notificar admin: {e}')

Mejores Prácticas de Seguridad

Variables de Entorno

Nunca codifiques datos sensibles:

nano .env

BOT_TOKEN=tu_token_de_bot_aquí
DATABASE_URL=postgresql://usuario:contraseña@localhost/botdb
ADMIN_IDS=123456789,987654321

Carga en el bot:

from dotenv import load_dotenv
load_dotenv()

BOT_TOKEN = os.getenv('BOT_TOKEN')
ADMIN_IDS = [int(id) for id in os.getenv('ADMIN_IDS').split(',')]

Agrega .env a .gitignore:

echo ".env" >> .gitignore

Validación de Entrada

Valida entrada de usuario:

async def process_age(update: Update, context: ContextTypes.DEFAULT_TYPE):
    try:
        age = int(context.args[0])
        if age < 0 or age > 120:
            raise ValueError("Rango de edad inválido")
        await update.message.reply_text(f'¡Edad {age} registrada!')
    except (IndexError, ValueError):
        await update.message.reply_text('Por favor proporciona una edad válida: /age <número>')

Limitación de Tasa

Previene spam:

from collections import defaultdict
from datetime import datetime, timedelta

user_last_message = defaultdict(lambda: datetime.min)

async def rate_limit(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    now = datetime.now()

    if now - user_last_message[user_id] < timedelta(seconds=2):
        await update.message.reply_text('¡Por favor ve más despacio!')
        return False

    user_last_message[user_id] = now
    return True

Manejo Seguro de Archivos

Valida archivos cargados:

ALLOWED_EXTENSIONS = {'.pdf', '.jpg', '.png', '.docx'}
MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB

async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE):
    document = update.message.document

    # Verificar tamaño de archivo
    if document.file_size > MAX_FILE_SIZE:
        await update.message.reply_text('¡Archivo demasiado grande! Máximo 10MB.')
        return

    # Verificar extensión
    file_ext = os.path.splitext(document.file_name)[1].lower()
    if file_ext not in ALLOWED_EXTENSIONS:
        await update.message.reply_text(f'Tipo de archivo no permitido. Permitidos: {ALLOWED_EXTENSIONS}')
        return

    # Procesar archivo
    doc_file = await document.get_file()
    await doc_file.download_to_drive(f'uploads/{document.file_id}{file_ext}')
    await update.message.reply_text('¡Archivo cargado exitosamente!')

Resolución de Problemas

Bot No Responde

Verificar estado del servicio:

sudo systemctl status telegram-bot

Ver logs:

sudo journalctl -u telegram-bot -n 100

Probar token del bot:

curl https://api.telegram.org/bot<TU_TOKEN>/getMe

Debe devolver información del bot.

Verificar conectividad de red:

ping api.telegram.org

Alto Uso de Memoria

Monitorear memoria:

htop

Optimizar consultas de base de datos:

# Usar pooling de conexiones
engine = create_engine('postgresql://...', pool_size=10, max_overflow=20)

# Cerrar sesiones
session.close()

Limitar actualizaciones concurrentes:

application = Application.builder().token(BOT_TOKEN).concurrent_updates(True).build()

Webhook No Funciona

Verificar certificado SSL:

sudo certbot certificates

Probar URL de webhook:

curl https://bot.ejemplo.com/webhook

Verificar que webhook esté configurado:

curl https://api.telegram.org/bot<TOKEN>/getWebhookInfo

Eliminar y resetear webhook:

curl https://api.telegram.org/bot<TOKEN>/deleteWebhook

Conclusión

Ahora tienes un bot de Telegram listo para producción ejecutándose en un servidor VPS con prácticas profesionales de despliegue, monitoreo y seguridad. Esta base soporta la construcción de aplicaciones de bots sofisticadas que sirven a miles de usuarios de manera confiable.

Logros clave:

• Disponibilidad 24/7 del bot a través de gestión de servicio systemd
• Integración de base de datos para datos de usuarios persistentes y estado
• Características interactivas con teclados en línea y manejo de archivos
• Implementación de seguridad con validación de entrada y limitación de tasa
• Monitoreo profesional con logging y estadísticas
• Arquitectura escalable lista para modo webhook y alto tráfico

El mantenimiento regular incluye monitorear logs, actualizar dependencias, respaldar bases de datos y mejorar características del bot basándose en retroalimentación de usuarios.

¡Construye bots increíbles!