AWS re:Invent 2022 : Introducing AWS Lambda SnapStart

Introduction

AWS Lambda is a popular serverless computing platform that allows developers to run code without worrying about infrastructure management. However, one issue with serverless computing is the “cold start” problem, where the first execution of a function after it has been idle for a period of time can take longer than subsequent executions. This can be a problem for applications requiring low latency or strict performance requirements.

What is SnapStart?

• SnapStart is a feature that enables AWS Lambda to pre-warm function instances by keeping them active and ready to respond to incoming requests.
• SnapStar can improve the performance of latency sensitive applications by up to 10% without extra cost.
• Snap Start allows Lambda to keep a pool of warm function instances that can handle requests immediately without any delay.
• When a function is invoked, Lambda checks if any pre-warmed instances are available in the pool. If there are, it uses one of them to handle the request. If no pre-warmed instances are available, Lambda creates a new instance and adds it to the pool for future requests. This helps to reduce the cold start time by ensuring that warm instances are always available to handle requests.

How Does SnapStar Works?

• Lambda takes a snapshot of the initialized function’s memory and disk state, encrypts the snapshot, and keeps it as a cache for low-latency access.
• So, whenever we invoke the function version for the first time, the new invocation scales up, and lambda uses the cached snapshot for execution instead of creating the execution environment from scratch, as it reduces the latency.
• SnapStart also uses a new feature called “start-up tracing”. Start-up tracing allows Lambda to capture detailed performance metrics during the initialization phase of a function. These metrics optimize the warm-up process and ensure that the pre-warmed instances are always ready to respond to requests.

Benefits of SnapStar

• Reduced cold start time: By keeping a pool of pre-warmed function instances by creating a snapshot, SnapStart can significantly reduce the cold start time for Lambda functions.
• Improved performance: SnapStart can help improve the performance of applications that require low latency or have strict performance requirements.
• Cost savings: By reducing the cold start time and improving performance, SnapStart can help reduce the number of function instances needed to handle requests, leading to cost savings.
• Simplified management: SnapStart simplifies the management of Lambda functions by automating the warm-up process and ensuring that pre-warmed instances are always available to handle requests.

Step-by-Step Guide to Enable lambda SnapStar

• Navigate to AWS Lambda from the AWS Management Console.
• Click on the create function button to create a Lambda Function.

• Select Author from Scratch under Basic information to provide any function name, and in Runtime, select Java11(corretto) and architecture as To create our lambda function, click the Create Function button.

• We are using a default Java function that gives hello world as output after the execution of a function.

• After our lambda function is created, we will test it by invoking our lambda function.

• Under the details, as we can see, the output is Hello from lambda, and the duration time to execute the function is 39.37 ms.
• Now to enable the SnapStar feature, we need to select the Configuration under that, we have General Configuration. We need to click on the Edit option.

• In Basic Settings, we have a Description, where we can describe the modifications we have done in the configuration (optional).
• The Memory (MB) parameter controls how much memory will be available to your Lambda function when invoked. The CPU power allotment likewise increases as memory is increased. A value between 128 and 10240 MB can be chosen (10 GB).
• Ephemeral Storage allots 512 MB for the /tmp directory of a function. The Ephemeral storage (MB) parameter allows us to change this quantity. In 1-MB increments, we can set a value between 512 MB and 10,240 (10 GB) MB to specify the size of a function’s /tmp directory.
• SnapStart A performance improvement called Lambda SnapStart helps reduce starting latency without adding extra costs.
• SnapStart for published versions can be activated on supported runtimes.
• When you publish a function version, Lambda creates an encrypted snapshot for low-latency access and takes a snapshot of the memory and disc state of the initialized execution environment.
• Lambda restarts the initialized snapshot and then calls the function handler when you call the function version for the first time and as the number of calls increases.

• We can keep the default 512 MB as Memory and Ephemeral Storage.
• In SnapStart, we need to select Published Versions.

• In the Execution role, select an existing role and click on save.
• Now go to the Test tab, provide an event name, select private in the Event sharing Settings, and then click Test.

• After the test execution status is succeeded, click Details to see the logs.

• We can see the output as Hello from lambda, and the execution duration of the lambda function (i.e., 22 ms) is quite less compared to before enabling the SnapStar feature.

• By having Lambda cache a snapshot of your function after the function has initialized, SnapStar typically reduces startup time.

Conclusion

SnapStart is a powerful new feature that can help reduce the cold start time for AWS Lambda functions. By using provisioned concurrency and start-up tracing, SnapStart can keep a pool of pre-warmed function instances ready to respond to incoming requests, improving the performance of serverless applications. If you’re using AWS Lambda, take advantage of this powerful new feature to help optimize your serverless applications.

About CloudThat