टेलीग्राम बॉट को पाइथन और जावास्क्रिप्ट में लागू करना और AWS पर तैनात करना

यहाँ मेरे नोट्स हैं जिनमें चरण-दर-चरण ट्यूटोरियल है कि कैसे Telegram bot को AWS पर लागू और तैनात करें। मैंने एक तेज़ शुरुआत (लॉन्ग पोलिंग) और एक उत्पादन-तैयार पथ (वेबहुक) जोड़ा है, जिसमें Python और Node.js के उदाहरण हैं।

टेलीग्राम बोट्स वे ऐप्स हैं जो आपके सर्वरों पर चलते हैं और टेलीग्राम के माध्यम से उपयोगकर्ताओं से बात करते हैं। हम एक बोट रजिस्टर करेंगे, एक छोटा प्रोग्राम लिखेंगे, और इसे टेलीग्राम के बोट API से कनेक्ट करेंगे।

TL;DR

1. @BotFather के माध्यम से एक बोट बनाएं → टोकन प्राप्त करें।
2. python-telegram-bot या Telegraf के साथ एक छोटा ऐप बनाएं।
3. स्थानीय रूप से लॉन्ग पोलिंग से शुरू करें; उत्पादन के लिए वेबहुक पर स्विच करें।

आपको क्या चाहिए

• एक टेलीग्राम अकाउंट (मोबाइल या डेस्कटॉप)

• बुनियादी टर्मिनल + कोड एडिटर

• इनमें से एक:

  • Python 3.10+ और pip
  • Node.js 18+ और npm/pnpm/yarn

BotFather के साथ अपना बोट बनाएं (टोकन प्राप्त करें)

1. टेलीग्राम में @BotFather खोजें और एक चैट शुरू करें।
2. /newbot भेजें और संकेतों का पालन करें अपने बोट का नाम दें और एक अनूठा यूज़रनेम चुनें (यह bot से समाप्त होना चाहिए), उदाहरण के लिए example_helper_bot।
3. BotFather एक API टोकन भेजता है जैसे 123456:ABC-DEF...। इसे एक पासवर्ड की तरह संभालें; इसे Git में कमिट न करें। अगर यह लीक हो जाता है तो आप हमेशा BotFather के माध्यम से इसे पुनः उत्पन्न कर सकते हैं।

टिप: टेलीग्राम का आधिकारिक ट्यूटोरियल इन ही चरणों को समझाता है और getMe के साथ टोकन सत्यापित करने के बारे में।

अपना स्टैक चुनें

आप स्वयं Bot API को कॉल कर सकते हैं, लेकिन एक बनाए रखे गए लाइब्रेरी का उपयोग करना तेज़ है।

• Python: python-telegram-bot (async, modern). ([https://docs.python-telegram-bot.org])
• Node.js: telegraf (mature, TypeScript-friendly). ([https://telegraf.js.org])

Bot API स्वयं यहाँ दस्तावेज़ीकृत है और यह getUpdates और setWebhook जैसे विधियों के लिए सत्यापन स्रोत है।

तेज़ शुरुआत: स्थानीय रूप से लॉन्ग पोलिंग के साथ चलाएं

लॉन्ग पोलिंग स्थानीय विकास के लिए आदर्श है: आपका बोट टेलीग्राम से नए अपडेट्स के लिए बार-बार पूछता है getUpdates के माध्यम से। (उत्पादन में, आप संभवतः वेबहुक पर स्विच करेंगे।)

टेलीग्राम दो परस्पर विरोधी तरीकों का समर्थन करता है अपडेट्स प्राप्त करने के लिए: getUpdates (पोलिंग) या वेबहुक; अपडेट्स को 24 घंटे तक रखा जाता है।

विकल्प A: Python (python-telegram-bot के साथ)

इंस्टॉल & स्कैफोल्ड

python -m venv .venv && source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install python-telegram-bot

कोड: bot.py

import os
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, ContextTypes, filters

TOKEN = os.environ["TELEGRAM_BOT_TOKEN"]  # export TELEGRAM_BOT_TOKEN=123:ABC

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("👋 नमस्ते! मुझे कुछ भेजें और मैं इसे दोहराऊंगा।")

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

def main():
    app = ApplicationBuilder().token(TOKEN).build()
    app.add_handler(CommandHandler("start", start))
    app.add_handler(MessageHandler(filters.TEXT & filters.COMMAND, echo))
    app.run_polling()  # लॉन्ग पोलिंग

if __name__ == "__main__":
    main()

इसे चलाएं:

export TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
python bot.py

यह वर्तमान स्थिर दस्तावेज़ों से ApplicationBuilder का उपयोग करता है।

विकल्प B: Node.js (telegraf के साथ)

इंस्टॉल & स्कैफोल्ड

npm init -y
npm i telegraf

कोड: index.js

const { Telegraf } = require('telegraf');

const bot = new Telegraf(process.env.BOT_TOKEN); // BOT_TOKEN env var सेट करें
bot.start((ctx) => ctx.reply('👋 नमस्ते! मुझे कुछ भेजें और मैं इसे दोहराऊंगा।'));
bot.on('text', (ctx) => ctx.reply(ctx.message.text));

bot.launch();

// graceful stop
process.once('SIGINT', () => bot.stop('SIGINT'));
process.once('SIGTERM', () => bot.stop('SIGTERM'));

इसे चलाएं:

export BOT_TOKEN=123456:ABC-DEF...
node index.js

यह आधिकारिक Telegraf “Getting started” उदाहरण का प्रतिबिंब है।

इसे उपयोगी बनाएं (कमांड्स & बटन)

एक /help कमांड जोड़ें

Python

from telegram.ext import CommandHandler

async def help_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("/start – अभिवादन\n/help – यह मदद")

app.add_handler(CommandHandler("help", help_cmd))

CommandHandler /commands बाइंड करने का मानक तरीका है।

Node (Telegraf)

bot.help((ctx) => ctx.reply('/start – अभिवादन\n/help – यह मदद'));

त्वरित प्रतिक्रिया बटन (कस्टम कीबोर्ड)

Python

from telegram import ReplyKeyboardMarkup

async def start(update: Update, context):
    keyboard = [["Help", "About"]]
    await update.message.reply_text(
        "एक विकल्प चुनें:",
        reply_markup=ReplyKeyboardMarkup(keyboard, resize_keyboard=True)
    )

Node (Telegraf)

const { Markup } = require('telegraf');
bot.start((ctx) => {
  ctx.reply("एक विकल्प चुनें:", Markup.keyboard([["Help", "About"]]).resize());
});

उत्पादन: वेबहुक पर स्विच करें

उत्पादन में, टेलीग्राम **अपडेट्स को आपके HTTPS एंडपॉइंट पर पुश करता है। आप इसे setWebhook के साथ सेट कर सकते हैं, वैकल्पिक रूप से एक स्रेक्ट टोकन प्रदान करके ताकि आप X-Telegram-Bot-Api-Secret-Token हेडर के माध्यम से अनुरोध सत्यापित कर सकें।

curl के साथ एक वेबहुक सेट करें:

TOKEN=123456:ABC-DEF...
WEBHOOK_URL="https://your-domain.com/telegram/${TOKEN}"  # एक स्रेक्ट पथ शामिल करें
SECRET="my-secret-42"

curl -X POST "https://api.telegram.org/bot${TOKEN}/setWebhook" \
  -d url="${WEBHOOK_URL}" \
  -d secret_token="${SECRET}" \
  -d drop_pending_updates=true

विशेष सेक्शन से मुख्य बिंदु:

• setWebhook एक HTTPS URL की आवश्यकता है और secret_token का समर्थन करता है।
• जब एक वेबहुक सेट किया जाता है, तो आप getUpdates नहीं उपयोग कर सकते।
• समर्थित पोर्ट में 443, 80, 88, 8443 शामिल हैं।

वेबहुक सर्वर विकल्प

• Node (Telegraf) बिल्ट-इन वेबहुक:

bot.launch({
  webhook: {
    domain: "your-domain.com",
    port: 8080,
    // वैकल्पिक स्रेक्ट हेडर
    secretToken: process.env.WEBHOOK_SECRET
  }
});

Telegraf वेबहुक विकल्पों को प्रथम श्रेणी का प्रदर्शन करता है और Express/Fastify/Cloudflare Workers, आदि के साथ एकीकरण करता है।

• Python (python-telegram-bot) PTB ASGI/WSGI फ्रेमवर्क (FastAPI, Starlette, Flask) के साथ अच्छी तरह से काम करता है। ApplicationBuilder().token(...).build() का उपयोग करें, एक POST रूट एक्सपोज करें जो आने वाली JSON अपडेट्स को आपकी एप्लिकेशन में फीड करता है, और bot.set_webhook(...) को कॉल करें। ApplicationBuilder दस्तावेज़ों के लिए निर्माण पैटर्न देखें। ([docs.python-telegram-bot.org][2])

स्थानीय रूप से परीक्षण कर रहे हैं? एक टनल (उदाहरण के लिए, ngrok) का उपयोग करें https://... को टेलीग्राम के लिए एक्सपोज करने के लिए, फिर setWebhook को सार्वजनिक URL के साथ कॉल करें।

बोट कमांड्स को कॉन्फ़िगर करें (वैकल्पिक लेकिन उपयोगकर्ता-मित्र)

आप बोट कमांड्स की सूची को परिभाषित कर सकते हैं (जो उपयोगकर्ता देखते हैं जब वे / टाइप करते हैं):

• BotFather के माध्यम से /mybots → Edit Bot → Edit Commands, या
• अपने लाइब्रेरी या कच्चे Bot API के साथ setMyCommands का उपयोग करके प्रोग्रामेटिक रूप से।

टेलीग्राम का आधिकारिक “From BotFather to Hello World” गाइड अधिक उन्नत कमांड हैंडलिंग और उदाहरणों की ओर लिंक करता है अगर आप गहराई में जाना चाहते हैं।

तैनाती विचार

किसी भी HTTPS-सक्षम होस्ट पर काम करता है:

• एक छोटा VM (Ubuntu + systemd)
• सर्वरलेस (AWS Lambda/Cloud Functions) वेबहुक एकीकरण के साथ
• Fly.io/Render/Heroku-जैसी प्लेटफॉर्म पर कंटेनर

Telegraf के दस्तावेज़ों में Lambda, GCF, Express, Fastify, आदि के लिए उदाहरण शामिल हैं।

सुरक्षा और विश्वसनीयता चेकलिस्ट

• टोकन को गुप्त रखें (env vars, secrets manager)। अगर लीक हो जाता है तो BotFather में रद्द करें।
• वेबहुक के साथ secret_token का उपयोग करें और X-Telegram-Bot-Api-Secret-Token हेडर सत्यापित करें।
• पोलिंग और वेबहुक को मिलाएं नहीं; एक बार में एक चुनें।
• त्रुटियों और पुन: प्रयासों का हैंडल करें: टेलीग्राम 2xx नहीं होने वाले वेबहुक प्रतिक्रियाओं को पुन: प्रयास करेगा। उचित रूप से लॉग करें।
• अपडेट प्रकारों के बारे में सावधान रहें (संदेश, कॉलबैक्स, इनलाइन क्वेरी, भुगतान, आदि) और केवल उन अपडेट्स के लिए सब्सक्राइब करें जिन्हें आप चाहते हैं (allowed_updates)।

HTTP API के साथ सीधे काम करना (वैकल्पिक)

आप एंडपॉइंट्स जैसे को कॉल कर सकते हैं:

https://api.telegram.org/bot<token>/getMe
https://api.telegram.org/bot<token>/getUpdates
https://api.telegram.org/bot<token>/sendMessage

GET या POST का उपयोग करें JSON या फॉर्म डेटा के साथ जैसे विशेष सेक्शन के अनुसार।

अगला क्या करना और पढ़ना है

• आधिकारिक Bot API संदर्भ: विधियाँ, वस्तुएँ, सीमाएँ, प्रारूपण, भुगतान, इनलाइन मोड।
• आधिकारिक “From BotFather to ‘Hello World’” गाइड: गहरी वॉकथ्रू और बहु-भाषा उदाहरण।
• python-telegram-bot दस्तावेज़ (स्थिर): आधुनिक async पैटर्न।
• Telegraf दस्तावेज़: तेज़ रेसिपी, वेबहुक हेल्पर, और TS टाइप्स।

AWS deployment steps for the Python version

हमारे पास Telegram bot को AWS infrastructure पर deployment करने के दो मुख्य विकल्प हैं:

• A) Serverless (API Gateway + Lambda + Secrets Manager) — सबसे सस्ता/सबसे आसान चलाने के लिए, मध्यम ट्रैफिक के लिए अच्छा।
• B) Containerized (ECS Fargate + ALB + ACM) — स्थिर ट्रैफिक और लंबे समय तक चलने वाले लाइब्रेरीज जैसे python-telegram-bot को वेबहुक मोड में चलाने के लिए प्रोडक्शन-ग्रेड।

A) AWS पर Serverless (API Gateway + Lambda)

इस विकल्प का उपयोग तब करें जब आप जीरो सर्वर और लगभग जीरो आइडल कॉस्ट चाहते हैं। नीचे का कोड Telegram वेबहुक्स को सीधे हैंडल करता है (कोई लंबे समय तक चलने वाला इवेंट लूप नहीं है)।

1. एक मिनिमल Lambda handler (Python) तैयार करें

handler.py बनाएं:

import json, os, urllib.request

BOT_TOKEN = os.environ["TELEGRAM_BOT_TOKEN"]
SECRET_HEADER = os.environ.get("WEBHOOK_SECRET", "")  # must match Bot API setWebhook secret_token

API_BASE = f"https://api.telegram.org/bot{BOT_TOKEN}"

def reply(chat_id: int, text: str):
    data = json.dumps({"chat_id": chat_id, "text": text}).encode()
    req = urllib.request.Request(f"{API_BASE}/sendMessage", data=data, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req) as resp:
        return resp.read()

def lambda_handler(event, context):
    # 1) Telegram की secret header की पुष्टि करें (जब आप वेबहुक कॉन्फ़िगर करते हैं तो सेट की जाती है)
    if SECRET_HEADER:
        if event.get("headers", {}).get("X-Telegram-Bot-Api-Secret-Token") != SECRET_HEADER:
            return {"statusCode": 401, "body": "invalid secret"}

    # 2) update parse करें
    body = event.get("body") or "{}"
    update = json.loads(body)

    message = update.get("message") or update.get("edited_message")
    if not message:
        # अभी के लिए नॉन-मेसेज अपडेट्स (callback_query, inline_query, आदि) को इग्नोर करें
        return {"statusCode": 200, "body": "ok"}

    chat_id = message["chat"]["id"]
    text = (message.get("text") or "").strip()

    # 3) सरल रूटिंग
    if text.startswith("/start"):
        reply(chat_id, "👋 Hello from AWS Lambda! Send any text and I’ll echo it.")
    elif text.startswith("/help"):
        reply(chat_id, "/start – greet\n/help – help\n(Deployed on AWS Lambda)")
    elif text:
        reply(chat_id, text)  # echo

    return {"statusCode": 200, "body": "ok"}

यह Lambda को lean और cold-start-friendly रखने के लिए raw HTTPS calls का उपयोग करता है। आप बाद में रूटिंग को बढ़ा सकते हैं।

2. Lambda को पैकेज और डिप्लॉय करें

# प्रोजेक्ट लेआउट
# .
# ├─ handler.py
# └─ requirements.txt   # (इस मिनिमल उदाहरण के लिए खाली छोड़ दें)

zip -r function.zip handler.py
aws lambda create-function \
  --function-name telegram-bot-webhook \
  --runtime python3.11 \
  --role arn:aws:iam::<ACCOUNT_ID>:role/<LambdaExecutionRole> \
  --handler handler.lambda_handler \
  --timeout 10 \
  --memory-size 256 \
  --zip-file fileb://function.zip \
  --environment Variables='{TELEGRAM_BOT_TOKEN=<TOKEN_FROM_BOTFATHER>,WEBHOOK_SECRET=my-secret-42}'

IAM role (<LambdaExecutionRole>) को CloudWatch Logs के लिए AWSLambdaBasicExecutionRole की आवश्यकता होती है।

AWS Secrets Manager में अपने टोकन को स्टोर करने का प्रयास करें और इसे init पर लोड करें—इस उदाहरण में brevity के लिए env vars का उपयोग किया गया है।

3. एक HTTPS endpoint बनाएं (API Gateway)

# HTTP API (REST नहीं) कम लेटेंसी के लिए
API_ID=$(aws apigatewayv2 create-api \
  --name telegram-webhook \
  --protocol-type HTTP \
  --target arn:aws:lambda:<REGION>:<ACCOUNT_ID>:function:telegram-bot-webhook \
  --query 'ApiId' --output text)

# एक डिफ़ॉल्ट रूट POST /webhook जोड़ें
aws apigatewayv2 create-integration \
  --api-id $API_ID \
  --integration-type AWS_PROXY \
  --integration-uri arn:aws:lambda:<REGION>:<ACCOUNT_ID>:function:telegram-bot-webhook \
  --payload-format-version 2.0

aws apigatewayv2 create-route \
  --api-id $API_ID \
  --route-key "POST /webhook" \
  --target "integrations/$(
    aws apigatewayv2 get-integrations --api-id $API_ID --query 'Items[0].IntegrationId' --output text
  )"

aws apigatewayv2 create-deployment --api-id $API_ID
GW_URL=$(aws apigatewayv2 get-apis --query "Items[?ApiId=='$API_ID'].ApiEndpoint" --output text)
echo $GW_URL  # उदाहरण: https://abc123.execute-api.ap-somewhere.amazonaws.com

सुनिश्चित करें कि Lambda permission स्वचालित रूप से जोड़ी गई है; अगर नहीं:

aws lambda add-permission \
  --function-name telegram-bot-webhook \
  --statement-id apigw \
  --action lambda:InvokeFunction \
  --principal apigateway.amazonaws.com \
  --source-arn "arn:aws:execute-api:<REGION>:<ACCOUNT_ID>:$API_ID/*/*/webhook"

4. Telegram को आपकी वेबहुक की ओर निर्देशित करें

TOKEN=<TOKEN_FROM_BOTFATHER>
WEBHOOK_URL="$GW_URL/webhook"
SECRET="my-secret-42"

curl -X POST "https://api.telegram.org/bot${TOKEN}/setWebhook" \
  -d url="${WEBHOOK_URL}" \
  -d secret_token="${SECRET}" \
  -d drop_pending_updates=true

अपने बॉट को /start भेजें—संदेश API Gateway → Lambda के माध्यम से प्रवाहित होंगे।

5. लॉग्स, रिट्राइज़, और अपडेट्स

• लॉग्स देखें: aws logs tail /aws/lambda/telegram-bot-webhook --follow
• Telegram तब रिट्राइज़ करता है जब आपका endpoint 2xx नहीं होता; रिस्पॉन्स तेज रखें।
• नए कोड को रोल आउट करने के लिए: re-zip + aws lambda update-function-code --function-name telegram-bot-webhook --zip-file fileb://function.zip.

B) ECS Fargate + ALB पर Containerized python-telegram-bot

इस विकल्प का उपयोग तब करें जब आप python-telegram-bot (PTB) के एर्गोनॉमिक्स चाहते हैं जिसमें एक सही async app और स्थायी कनेक्शन्स। हम PTB को एक HTTPS लोड बैलेंसर के पीछे चलाएंगे।

1. App code (FastAPI + PTB webhook)

app.py:

import os, asyncio
from fastapi import FastAPI, Request, Header
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, ContextTypes, filters

TOKEN = os.environ["TELEGRAM_BOT_TOKEN"]
SECRET = os.environ.get("WEBHOOK_SECRET", "")

app = FastAPI()
tg_app = None  # PTB application

async def start_cmd(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("🚀 Hello from ECS Fargate + PTB!")

async def echo(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(update.message.text)

@app.on_event("startup")
async def on_startup():
    global tg_app
    tg_app = ApplicationBuilder().token(TOKEN).build()
    tg_app.add_handler(CommandHandler("start", start_cmd))
    tg_app.add_handler(MessageHandler(filters.TEXT &   filters.COMMAND, echo))
    # No run_polling(); हम वेबहुक्स को मैन्युअल रूप से फीड करेंगे।

@app.post("/telegram/webhook")
async def telegram_webhook(request: Request, x_telegram_bot_api_secret_token: str | None = Header(default=None)):
    if SECRET and (x_telegram_bot_api_secret_token != SECRET):
        return {"ok": True}  # silently ignore

    data = await request.json()
    update = Update.de_json(data, tg_app.bot)
    await tg_app.process_update(update)
    return {"ok": True}

uvicorn entrypoint: uvicorn app:app --host 0.0.0.0 --port 8080

2. Dockerfile

FROM python:3.11-slim
WORKDIR /app
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
RUN pip install --no-cache-dir fastapi uvicorn[standard] python-telegram-bot==21.*
COPY app.py .
EXPOSE 8080
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8080"]

बिल्ड और पुश करें:

aws ecr create-repository --repository-name telegram-ptb || true
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
REGION=<REGION>
ECR="$ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/telegram-ptb"

aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin "$ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com"
docker build -t telegram-ptb .
docker tag telegram-ptb:latest $ECR:latest
docker push $ECR:latest

3. ALB के पीछे ECS Fargate service

• एक Security Group बनाएं जो ALB पर 443 के लिए इनबाउंड अनुमति देता है; ECS tasks ALB SG से 8080 की अनुमति देते हैं।
• एक Application Load Balancer (ALB) बनाएं जिसमें एक HTTPS listener (443) और एक ACM certificate आपके डोमेन के लिए।
• टारगेट ग्रुप: HTTP 8080 (IP target type), हेल्थ चेक पाथ / (FastAPI 404 सर्व करता है; आप @app.get("/") हेल्थ रूट जोड़ सकते हैं)।

एक Task Definition (Fargate) बनाएं जिसमें:

• कंटेनर इमेज: $ECR:latest
• पोर्ट मैपिंग: 8080
• एन्वायर्नमेंट वेरिएबल्स: TELEGRAM_BOT_TOKEN, WEBHOOK_SECRET
• टास्क रोल: बेसिक CloudWatch लॉगिंग।

एक ECS Service बनाएं:

• लॉन्च टाइप Fargate, डिज़ायर्ड काउंट 1+।
• ALB टारगेट ग्रुप से जोड़ें।

ALB के पब्लिक HTTPS domain का नोट करें (या Route 53 का उपयोग करके अपने DNS नाम को पॉइंट करें)।

4. Telegram को आपकी वेबहुक URL बताएं

TOKEN=<TOKEN_FROM_BOTFATHER>
SECRET="my-secret-42"
WEBHOOK_URL="https://your.domain.com/telegram/webhook"

curl -X POST "https://api.telegram.org/bot${TOKEN}/setWebhook" \
  -d url="${WEBHOOK_URL}" \
  -d secret_token="${SECRET}" \
  -d drop_pending_updates=true \
  -d allowed_updates='["message","edited_message","callback_query"]'

5. स्केल और ऑपरेट

• ECS tasks को स्केल अप/डाउन करें; ALB ट्रैफिक को फैलाएगा।
• Secrets Manager में टोकन रोटेट करें, नए टास्क एन्वायर्नमेंट के साथ सेवा अपडेट करें।
• CloudWatch Logs के लिए app logs और ALB access logs (S3) का उपयोग करें।

हम किसे चुनना चाहिए?

• Lambda + API Gateway: सबसे सरल, कम वॉल्यूम पर सबसे सस्ता; उन बॉट्स के लिए अच्छा जो प्रति मिनट कुछ कॉल करते हैं।
• ECS Fargate + ALB: जब आप पूरे python-telegram-bot अनुभव चाहते हैं, कस्टम मिडलवेयर, बैकग्राउंड जॉब्स, और स्थिर ट्रैफिक।

Quick checklist (both approaches)

• HTTPS endpoint + secret_token का उपयोग करें और X-Telegram-Bot-Api-Secret-Token header की पुष्टि करें।
• webhook OR polling में से एक चुनें (दोनों नहीं)।
• Secrets Manager में config को persist करें, कोड में नहीं।
• observability जोड़ें: CloudWatch Logs + metrics (5xx alarms)।
• केवल उन update types को हैंडल करें जिन्हें आप चाहते हैं; बाद में बढ़ाएं।

उपयोगी लिंक

• https://docs.python-telegram-bot.org
• https://telegraf.js.org
• https://core.telegram.org/bots/tutorial
• https://core.telegram.org/bots/api
• AWS CDK Overview, TypeScript और Python Examples और Performance Conciderations
• AWS lambda performance: JavaScript vs Python vs Golang
• Layered Lambdas with AWS SAM और Python
• AWS SAM + AWS SQS + Python PowerTools
• Python Cheatsheet
• uv - New Python Package, Project, और Environment Manager
• Install Node.js