Does aiobotocore allow you to pre-initialize clients to deal with Lambda cold starts?

[tibbe]

We're currently using regular boto3 and to avoid Lambda cold start overhead we are creating sessions/clients at import time and store them in global variables. Something like:

# Simplified from actual code:
dynamodb_resource = boto3.Session().resource('dynamodb')

(We also use Lambda provisioned concurrency so not even the first request sees cold start overheads.)

What's the equivalent in aiobotocore? The examples seem to create the client just before making the request, which presumably incurs the cost of client creation.

(If it matter we use FastAPI to create our server. Perhaps we should try to hold some state in our server object.)

[thehesiod]

see https://github.com/terrycain/aioboto3 for boto3 equivalents

[tibbe]

Note that I'm not looking for boto3 APIs. I'm looking for caching of async clients. The aioboto3 examples do the same thing I described above, namely initialize clients just before using them.

[thehesiod]

remember each thread can only have one run loop, so you don't need to worry about multiple run loops

[flpStrri]

@thehesiod, will the aexit be called? I mean in the lambda runtime. I know that if you use the Globals as an async context manager on pytest it exit the context and clean the whole "context"... but not in lambda right?

[tibbe]

Related question. Does it have to be an async context in this situation? It seems like you call __aenter__ manually.

[flpStrri]

@tibbe thats basically what I asked but more clearly. But I think that the context managers is used to be easier to handle globals on tests. I would do it. 😄

[thehesiod]

It's mostly there for integration tests to avoid unclosed sockets. What I've found is that aws can terminate your instance at any moment so any sort of shutdown is just for testing.

[vasily-kartashov]

@tibbe I was wondering if you've got anywhere with this one? I am rather surprised there's no information on this question. For example timestream client takes ages to initialize, so keeping the client between "warm" invocations would be obviously beneficial. After all the only reason we use aiobotocore is performance.

[thehesiod]

this is more of a botocore question

[vasily-kartashov]

With boto3 I can just create a client in a module outside the handler, et voila:

client = boto3.client('...')

def handle(event, context):
    ...

I ended up making default loop waiting for

client = wait session.create_client().__aenter__()

Which is not pretty to say the least.