Are there issues with accessing data in APIGatewayRestResolver and lambda concurrency

[mcsloe]

In the examples, APIGatewayRestResolver is a global object.

from aws_lambda_powertools.event_handler import APIGatewayRestResolver
app = APIGatewayRestResolver()

@app.get("/hello")
def get_hello_universe():
    return {"message": "hello universe"}

With concurrent lambda executions, this APIGatewayRestResolver instance would be shared by all the concurrent lambdas.
Does this pose an issue with accessing the current event inside the resolved method?
If we were to look at app.current_event inside get_hello_universe, is it possible that we could get an event for a different call if app.resolve is called by another lambda instance at the same time?
Or am I missing something with how lambda concurrency works?

[heitorlessa]

Hey @mcsloe - it's safe and allow me to clarify the Lambda concurrency model[1] for you.

A Lambda execution environment (container) can only process one request at a time. If a second request comes while the first hasn't completed yet, you now have a concurrency of 2.

This means you'll have two completely isolated memory shared space, process map, and disk.

When you try to access a request through the global object, you'll always get the request in read-only mode that belongs to that Lambda container handling that request - never shared.

What Lambda optimises for is to ensure an idle container doesn't get immediately thrown away - it may take a few minutes or seconds. This allows Lambda to reuse an existing container to handle a new incoming request.

Even in this scenario, your app.resolve(event, context) call will hydrate the global object with the new event, thus exposing an updated request details within your functions.

Hopefully that clarifies - let us know if you need more details.

[1] https://docs.aws.amazon.com/lambda/latest/dg/invocation-scaling.html

[mcsloe]

Thank you Heitor!

I was confused by the info on https://docs.aws.amazon.com/lambda/latest/operatorguide/execution-environment.html

"While data is never shared across AWS customers, it is possible for data from one Lambda function to be shared with another invocation of the same function."

I suppose it would be more accurate to say the invocations that share data are at different points in time?

For example, if we have a global cache LAMBDA_CACHE = {}.
Invocation 1 puts something in the dict.
Invocation 2 (that happens at the same time) will not see the data.
A 3rd invocation at a later time, after invocation 1 is complete, may see the data in LAMBDA_CACHE ?

[heitorlessa]

Exactly! If you search for "is_cold_start" in this repository, you'll notice that we leverage this exact mechanism in various ways.

Here's one example on how we capture cold start as a metric only once (follow is_cold_start global flag)

https://github.com/awslabs/aws-lambda-powertools-python/blob/develop/aws_lambda_powertools/metrics/metrics.py