Turbocharge Java Lambda Performance: Priming with CRaC Runtime Hooks

Want faster Java Lambda functions? Learn how to prime your Lambdas using CRaC runtime hooks. This guide provides practical steps to significantly reduce latency for demanding applications.

What is Lambda Priming and Why Should You Care?

Lambda priming optimizes the performance of your Lambda functions. It's especially useful for applications needing consistent low latency, like real-time data processing and APIs. Lambda priming leverages CRaC (Coordinated Restore at Checkpoint) runtime hooks to minimize cold starts and improve overall responsiveness.

Benefits of Lambda Priming:

• Reduced latency for API calls.
• Improved responsiveness for real-time data processing.
• Consistent performance, even after scaling events.

Understanding CRaC Runtime Hooks

CRaC runtime hooks offer a way to execute code at key points in the Lambda lifecycle. The beforeCheckpoint() hook runs just before a snapshot is taken, while the afterRestore() hook executes immediately after a snapshot is restored. This allows for techniques like java lambda priming optimizing the environment before function execution.

These hooks are part of the open-source CRaC project and AWS Lambda now supports them.

Prerequisites for Java Lambda Priming

Before starting, ensure you have these tools installed and configured:

• AWS Account and IAM User with sufficient permissions
• AWS CLI
• Git
• AWS Cloud Development Kit (CDK)
• Java 21
• Maven
• curl

Step-by-Step Guide: Deploying Primed Java Lambdas

Follow these steps to deploy a stack showcasing CRaC Java Lambda priming:

1. Clone the GitHub Repository:

   git clone https://github.com/aws-samples/lambda-priming-crac-java-cdk
   

   Copy

2. Navigate to the Infrastructure Directory:

   cd lambda-priming-crac-java-cdk/infrastructure
   

   Copy

3. Deploy the Stack:

   cdk deploy --require-approval never --all 2>&1 | tee cdk_output.txt
   

   Copy

This command deploys the necessary AWS resources.

Testing Your Primed Lambdas

To test the deployed Lambdas and measure the latency improvements, follow these steps:

1. Extract URLs: Obtain the URLs for the different Lambda functions from the cdk_output.txt file. These URLs correspond to Lambda functions with and without priming.

   ONDEMAND_URL=$(grep -oE 'https://[a-zA-Z0-9.-]+\.execute-api\.[a-zA-Z0-9-]+\.amazonaws\.com/prod/' "cdk_output.txt" | head -n 1)
   NOPRIMING_URL=$(grep -oE 'https://[a-zA-Z0-9.-]+\.execute-api\.[a-zA-Z0-9-]+\.amazonaws\.com/prod/' "cdk_output.txt" | head -n 2 | tail -n 1)
   INVOKEPRIMING_URL=$(grep -oE 'https://[a-zA-Z0-9.-]+\.execute-api\.[a-zA-Z0-9-]+\.amazonaws\.com/prod/' "cdk_output.txt" | head -n 3 | tail -n 1)
   CLASSPRIMING_URL=$(grep -oE 'https://[a-zA-Z0-9.-]+\.execute-api\.[a-zA-Z0-9-]+\.amazonaws\.com/prod/' "cdk_output.txt" | head -n 4 | tail -n 1)
   SETUP_URL=$(grep -oE 'https://[a-zA-Z0-9.-]+\.execute-api\.[a-zA-Z0-9-]+\.amazonaws\.com/prod/' "cdk_output.txt" | head -n 5 | tail -n 1)
   

   Copy

2. Initialize the Database:

   curl "$SETUP_URL"
   

   Copy

   Verify that the command returns: {"message":"Database schema initialized and data loaded"}

3. Run Load Tests: Use artillery to send traffic to each of the Lambda functions.

   artillery run -t "$ONDEMAND_URL" -v '{ "url": "/unicorn" }' ./loadtest.yaml && \
   artillery run -t "$NOPRIMING_URL" -v '{ "url": "/unicorn" }' ./loadtest.yaml && \
   artillery run -t "$INVOKEPRIMING_URL" -v '{ "url": "/unicorn" }' ./loadtest.yaml && \
   artillery run -t "$CLASSPRIMING_URL" -v '{ "url": "/unicorn" }' ./loadtest.yaml
   

   Copy

Measuring Lambda Performance with CloudWatch Insights

Use CloudWatch Insights to analyze the performance of your SnapStart Lambda functions. Specifically, focus on the restore duration to gauge the effectiveness of priming lambda functions java.

1. CloudWatch Insights Query: Use the following query in CloudWatch Insights:

   filter @type = "REPORT"
   | parse @log /\d+:\/aws\/lambda\/(?<function>.*)/
   | parse @message /Restore Duration: (?<restoreDuration>.*?) ms/
   | stats
       count(*) as invocations,
       pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 50) as p50,
       pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 90) as p90,
       pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 99) as p99,
       pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 99.9) as p99.9
   group by function, (ispresent(@initDuration) or ispresent(restoreDuration)) as coldstart
   | sort by function asc | sort by coldstart desc
   

2. Select Log Groups: Choose the following log groups:

   • /aws/lambda/PrimingLogGroup-1_ON_DEMAND
   • /aws/lambda/PrimingLogGroup-2_SnapStart_NO_PRIMING
   • /aws/lambda/PrimingLogGroup-3_SnapStart_INVOKE_PRIMING
   • /aws/lambda/PrimingLogGroup-4_SnapStart_CLASS_PRIMING

Local Testing Setup

You can also test Lambda functions locally:

1. Additional Requirements:

   • Docker
   • AWS SAM CLI

2. Start Postgres with Docker:

   docker-compose --file local/docker-compose.yml up
   

   Copy

3. Initialize the Database:

   sam local invoke PrimingJavaLambdaFunction-5_DB_LOADER --env-vars local/env-vars.json --template cdk.out/LambdaPrimingCracJavaCdkStack.template.json --docker-network host
   

   Copy

4. Test Lambdas Locally:

   sam local invoke PrimingJavaLambdaFunction-1_ON_DEMAND --env-vars local/env-vars.json --template cdk.out/LambdaPrimingCracJavaCdkStack.template.json --docker-network host
   sam local invoke PrimingJavaLambdaFunction-2_SnapStart_NO_PRIMING --env-vars local/env-vars.json --template cdk.out/LambdaPrimingCracJavaCdkStack.template.json --docker-network host
   sam local invoke PrimingJavaLambdaFunction-3_SnapStart_INVOKE_PRIMING --env-vars local/env-vars.json --template cdk.out/LambdaPrimingCracJavaCdkStack.template.json --docker-network host
   sam local invoke PrimingJavaLambdaFunction-4_SnapStart_CLASS_PRIMING --env-vars local/env-vars.json --template cdk.out/LambdaPrimingCracJavaCdkStack.template.json --docker-network host
   

   Copy

Clean Up Resources

To avoid incurring unnecessary costs, clean up the deployed resources:

cdk destroy --require-approval never --all

Follow these steps to optimize the latency and performance of your Java Lambda functions using CRaC and AWS Lambda priming.