AWS Lambda does not run independently

Question

I am using the nodejs to use AWS Lambda.

As I know each function of lambda is handled in independent and parallel process.

However, following example shows different result than I expected.

// test.js
const now = new Date();

module.exports = () => {
    console.log(now);
};

// handler.js
const test = require('./test');

module.exports.hello = async (event, context) => {
    test();
    return {
        statusCode: 200,
        body: null
    };
};

RESULT: hello handler log

As I intended, each function was executed independently, so the value of console.log(now) should always be the point at which it was executed.

However, in the actual log, the value of now is continuously recorded at the point of the very first execution - rather than each function’s execution.

The log’s value after 5 minutes was the same. However, the value changed after 12 hours, but after that, it shows the same problem.

This result gives us serious consideration of how to manage the DB connection.

There are two assumption for each case of lambda’s recycling

If lambda recycles like test.js,

better to use connection pool
also recommends to use a orm such as sequelize which requires initialization

If not,

better to use simple connections and regular queries to quickly consume connections

How can we use lambda within maximum performance?

How can we interpret the test results above?

user_271415 · Answer

AWS Lambda creates and reuses the containers, so you need to understand the impact of this practice on the programming model.

The first time a function executes, a new container will be created to execute it.

Let’s say your function finishes, and some time passes, then you call it again. Lambda may create a new container all over again. However, if you haven’t changed the Lambda function code and not too much time has gone by, Lambda may reuse the previous container. This offers performance advantages: Lambda gets to skip the nodejs language initialization, and you get to skip initialization in your code (so you can reuse DB connections, for example); files that you wrote to /tmp last time around will still be there if the container gets reused; anything you initialized globally outside of the Lambda function handler persists.

For more see Understanding Container Reuse in AWS Lambda.

user_1602433 · Answer

The behavior that you have described is a result of AWS optimizations. It looks like your lambda is very fast and it is more efficient to use only one unit of execution (process/container/instance) fro AWS. So try to simulate a long running process and see that the actual timestamps are different in this case.

AWS Lambda does not run independently

2 Answers