Persistence with AWS Lambda

[ubertao]

I'm creating a webhook bot running on AWS Lambda, referring to @jojo786's sample here: ptb/ptb_lambda.py.

I added a custom persistence class DdbPersistence to store user data in DynamoDB.

import json
import asyncio
from telegram import Update
from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
from persistence import DdbPersistence

ddb_persistence = DdbPersistence()
app = ApplicationBuilder().token("BOT-TOKEN").persistence(ddb_persistence).build()

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(chat_id=update.effective_chat.id, text=update.message.text)

def lambda_handler(event, context):
    return asyncio.get_event_loop().run_until_complete(main(event, context))

async def main(event, context):    
    echo_handler = MessageHandler(filters.TEXT & (~filters.COMMAND), echo)
    app.add_handler(echo_handler)
    
    try:    
        await app.initialize()
        await app.process_update(
            Update.de_json(json.loads(event["body"]), application.bot)
        )
    
        return {
            'statusCode': 200,
            'body': 'Success'
        }

    except Exception as exc:
        return {
            'statusCode': 500,
            'body': 'Failure'
        }

The problem is DdbPersistence.flush() never get called before the lambda function exits.

So what is the best approach to save the data?

I added await app.shutdown(), it worked, but wondering is there a better solution?

[jojo786]

you probably want to interact with DynamoDB in one of your handlers, eg, in the echo handler, you will retrieve or save to DynamoDB, then call flush().

[Bibo-Joshi]

Calling application.shutdown is the correct thing to do and should be done independently of whether you want to you persistence. This has little to do with support for serverless setups IMO. A clean shutdown and releasing of resources should be done in any environment.

[ubertao]

Yes however it impacts serverless mode the most.

In server mode or long running mode, persistence methods will get called periodically to save data. You only lose last bit of data if you don't call app.shutdown() when terminating the server.

But in serverless mode, chances are handlers exits sooner than persistence methods get called. You could lose everything.

[Bibo-Joshi]

But in serverless mode, chances are handlers exits sooner than persistence methods get called. You could lose everything.

that's my point though. By calling app.shutdown you ensure a clean shutdown on handler exit and persist the data …

[ubertao]

I just found out Application is an async context manager, so I'm now using async with app: without explicit call to app.shutdown().

Now let's go a bit off topic... because persistence is only part of the problem with my PTB learning experience. I think the overarching issue for me is PTB doesn't provide a straight foward way of developing a serverless webhook bot, and there's no documentation to guide me.

Let's look at some other popular frameworks:

grammY

• server mode

import { Bot } from "grammy";

const bot = new Bot("TOKEN");

bot.on("message", (ctx) => ctx.reply("Got another message!"));

bot.start();

• serverless mode

import { Bot } from "grammy";
import express from "express";

const bot = new Bot("TOKEN");

bot.on("message", (ctx) => ctx.reply("Got another message!"));

const app = express();
app.use(express.json());
app.use(webhookCallback(bot, "express"));

telegraph.js

• server mode

import { Telegraf } from "telegraf";
import { message } from 'telegraf/filters';

const bot = new Telegraf("TOKEN");

bot.on("text", ctx => ctx.reply(ctx.message.text));

bot.launch();

• serverless mode

import http from "serverless-http";
import { Telegraf } from "telegraf";

const bot = new Telegraf("TOKEN");

bot.on("text", ctx => ctx.reply(ctx.message.text));

export const echobot = http(bot.webhookCallback("/telegraf"));

New users can easily find and understand these examples from both projects' website, and create their own serverless bots within an hour. Plus they both provide examples or adapters for popular platform like AWS or Google Cloud.

Meanwhile as a new PTB user, it's much harder for me to figure out how to adapt server mode PTB code to serverless mode. I could stuck there for days if I didn't stumble upon @jojo786's example.

Since serverless can largely lower the bar of hosting a bot, addressing this issue could potentially drive more developers to PTB community.

[Bibo-Joshi]

Thanks for the input. I guess one main difference between PTB and grammy/telegraph.js is that PTB is a Python lib, which is (at least from my experience) far less common in serverless setups. Several pointers to serverless setups can still be found in the PTB resources:

• a more-or-leess dedeciated section in the webhooks page https://github.com/python-telegram-bot/python-telegram-bot/wiki/Webhooks#custom-solution
• several issues and discussions on this topic
• explicit mentions of AWS and GAE on this wiki page (which you actually found)

Additionally the docs of run_polling/webhook explicitly point out that they are not right for every use case.

Nevertheless, I do agree that explicit pointers to serverless setups can be made more prominent. One could e.g. mention them explicitly in the docs of run_polling/webhook, add a quick-link to the last section in the introduction of the webhooks page and add notes to the tutorial and/or the examples page stating that we use run_polling there for the sake of simplicity and that custom setups (such as serverless setups) need different handling.
You are very welcome to improve the wiki on your own and propose changes to the documentation via a PR :)

[ubertao]

Adding async with app: will get app.shutdown() called and data gets flushed:

...

async with app:
    await app.initialize()
    await app.process_update(
        Update.de_json(json.loads(event["body"]), application.bot)
    )

...

Would suggest enhance documentation and all examples with such usage.

[Bibo-Joshi]

If you have specific suggestions where to add additional examples, I'm happy for your input.

just to clarify: calling app.initialize within the context manager is superfluous, as that's exactly what the context manager does on enter. And using the context manager is basically equivalent to manually calling initialize and shutdown