How to develop, run and optimize Spring Boot 3 application on AWS Lambda at AWS User Group New York 2024

Vadym Kazulkin | @VKazulkin |ip.labs GmbH
How to develop, run and optimize Spring Boot 3
application on AWS Lambda
Vadym Kazulkin, ip.labs, AWS User Group New York, 13 August 2024
How to develop,
run and optimize
Spring Boot 3
1

Vadym Kazulkin
ip.labs GmbH Bonn, Germany
Co-Organizer of the Java User Group Bonn
v.kazulkin@gmail.com
@VKazulkin
https://dev.to/vkazulkin
https://github.com/Vadym79/
https://de.slideshare.net/VadymKazulkin/
https://www.linkedin.com/in/vadymkazulkin
https://www.iplabs.de/
Contact

About ip.labs
How to develop, run and optimize Spring Boot 3 application on AWS Lambda
4

▪ Your organization has profound Java and Spring Boot development skills
▪ You have an existing Spring Boot 3 (Web) application, or you want to develop
a new one
Current State
7

▪ You want to use AWS Lambda for hosting your Spring Boot 3 web application
▪ To benefit from the advantages of the Serverless architectures
▪ Scalability
▪ Less focus on classical operational tasks
▪ API Gateway and Lambda offer fully managed approach
▪ Less focus on the code maintenance
▪ Requires securing the application only
▪ With less possible engineering effort in the business logic
Desired State
8

▪ I can at best achieve acceptable performance by using pure Java on AWS Lambda
▪ Spring (Boot) performance on AWS Lambda would be bad
▪ Too much runtime annotation processing, reflection, dynamic class loading used
▪ As a result, high cold (application start up) and warm start times
Most frequent replies and assumptions
9

▪ I’ll use NoSQL Amazon DynamoDB for my examples
▪ You can make it work with the same introduced approaches by
managing your own database or using Amazon RDS (i.e. PostgreSQL)
▪ Challenges around managing database connection. Possible solutions are:
▪ Using Amazon RDS Proxy and putting Lambda functions into VPC
▪ Using (PostgreSQL) Aurora Serverless v2 Data API
▪ You need to re-measure performance
Database usage
10

Demo Application
12
https://github.com/Vadym79/AWSLambdaJavaWithSpringBoot
▪ PUT
https://{YOUR_API_GATEWAY_URL}/prod
/products/
▪ GET
https://{YOUR_API_GATEWAY_URL}/prod
/products/ {productId}

@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Spring Boot 3 Application class
13
https://github.com/Vadym79/AWSLambdaJavaSnapStart/tree/main/spring-boot-3.2

public record Product(String id, String name, BigDecimal price) { }
Product Entity class
14

@Repository
public class DynamoProductDao implements ProductDao {
private static final String PRODUCT_TABLE_NAME =
System.getenv("PRODUCT_TABLE_NAME");
private static final DynamoDbClient dynamoDbClient =
DynamoDbClient.builder().build();
@Override
public void putProduct(Product product) {
dynamoDbClient.putItem(PutItemRequest.builder()
.tableName(PRODUCT_TABLE_NAME)
.item(ProductMapper.productToDynamoDb(product))
.build());
}
Product Repository DAO class
15

@Override
public Optional<Product> getProduct(String id) {
GetItemResponse getItemResponse =
dynamoDbClient.getItem(GetItemRequest.builder().key(Map.of("PK",
AttributeValue.builder().s(id).build())).tableName(PRODUCT_TABLE_NAME).build())
;
if (getItemResponse.hasItem()) {
return
Optional.of(ProductMapper.productFromDynamoDB(getItemResponse.item()));
} else {
return Optional.empty();
}
}
..
}
Product Repository DAO class
16

▪ AWS Serverless Java Container
▪ AWS Lambda Web Adapter
▪ Spring Cloud Function (on AWS Lambda)
▪ Custom (Docker) Container Image
▪ Optimization techniques
▪ AWS (Lambda) SnapStart
▪ GraalVM Native Image
▪ Cold and warm start measurements for all approaches and optimizations
Agenda
17

AWS Serverless Java Container
18
https://github.com/aws/serverless-java-container/

▪ The AWS Serverless Java Container makes it
easier to run Java applications written with
frameworks such as Struts, Spring, Spring Boot
2 and 3, or JAX-RS/Jersey in Lambda.
▪ The container provides adapter logic to
minimize code changes. Incoming events are
translated to the Jakarta EE Servlet specification
so that frameworks work as before
19
https://github.com/aws/serverless-java-container/

@RestController @EnableWebMvc
public class ProductController {
@Autowired
private DynamoProductDao productDao;
@RequestMapping(path = “/products/{id}”, method = RequestMethod.GET, produces =
MediaType.APPLICATION_JSON_VALUE)
public Optional<Product> getProductById(@PathVariable(“id”) String id) {
return productDao.getProduct(id);
}
@RequestMapping(path = “/products/{id}”, method = RequestMethod.PUT, consumes =
public void createProduct(@PathVariable(“id”) String id, @RequestBody Product product) {
product.setId(id);
productDao.putProduct(product);
}
Spring Boot 3 Product (Rest)Controller class
20

pom.xml
<dependency>
<groupId>com.amazonaws.serverless</groupId>
<artifactId>aws-serverless-java-container-springboot3</artifactId>
<version>2.0.0</version>
</dependency>
21

Automatic proxying through AWS Serverless Java Container
AWS SAM Template (template.yaml)
GetProductByIdFunction:
Type: AWS::Serverless::Function
Properties:
Handler: com.amazonaws.serverless.proxy.spring.SpringDelegatingLambdaContainerHandler
CodeUri: target/***.jar
Runtime: java21
MemorySize: 1024
Environment:
Variables:
MAIN_CLASS: com.amazonaws.serverless.sample.springboot3.Application
22

Self-written Lambda function
Properties:
Handler: software.amazonaws.example.product.handler.StreamLambdaHandler::handleRequest
Runtime: java21
MemorySize: 1024
23

public class StreamLambdaHandler implements RequestStreamHandler {
SpringBootLambdaContainerHandler<AwsProxyRequest, AwsProxyResponse> handler =
SpringBootLambdaContainerHandler.getAwsProxyHandler(Application.class);
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context
context) throws IOException {
handler.proxyStream(inputStream, outputStream, context);
}
}
24

AWS Lambda Web Adapter
25
https://github.com/awslabs/aws-lambda-web-adapter

▪ AWS Lambda Web Adapter is a tool written in Rust programming language
to run web applications on AWS Lambda.
▪ It allows developers to build web apps (HTTP API) with familiar frameworks
(e.g. Express.js, Next.js, Flask, Spring Boot, ASP.NET and Laravel, anything
that speaks HTTP 1.1/1.0) and run it on AWS Lambda.
▪ The same Docker image can run also on Amazon EC2, AWS Fargate, and
local computers
26

▪ Run web applications on AWS Lambda
▪ Supports Amazon API Gateway Rest API and HTTP
API endpoints, Lambda Function URLs, and
Application Load Balancer
▪ Supports all non-HTTP event triggers, such as SQS,
SNS, S3, DynamoDB, Kinesis, Kafka, EventBridge,
and Bedrock Agents
27

Can be deployed in several ways:
▪ Lambda functions packaged as Docker Images
▪ Lambda functions packaged as OCI Images
▪ Lambda functions packaged as Zip package for
AWS managed runtimes and attached as Lambda
layer to your Lambda function
28

@RestController @EnableWebMvc
public class ProductController {
@Autowired
@RequestMapping(path = “/products/{id}”, method = RequestMethod.GET, produces =
public Optional<Product> getProductById(@PathVariable(“id”) String id) {
}
@RequestMapping(path = “/products/{id}”, method = RequestMethod.PUT, consumes =
public void createProduct(@PathVariable(“id”) String id, @RequestBody Product product) {
product.setId(id);
productDao.putProduct(product);
}
Spring Boot 3 Product (Rest)Controller class
29

Properties:
Handler: run.sh
Runtime: java21
MemorySize: 1024
Layers:
- !Sub arn:aws:lambda:${AWS::Region}:753240598075:layer:LambdaAdapterLayerX86:20
Environment:
Variables:
AWS_LAMBDA_EXEC_WRAPPER: /opt/bootstrap
30
https://github.com/Vadym79/AWSLambdaJavaWithSpringBoot/tree/master/spring-boot-3.2-with-lambda-web-adapter

run.sh
#!/bin/sh
exec java -cp "./:lib/*" "software.amazonaws.Application"
31

Properties:
Handler: run.sh
Runtime: java21
MemorySize: 1024
Layers:
- !Sub arn:aws:lambda:${AWS::Region}:753240598075:layer:LambdaAdapterLayerX86:20
Environment:
Variables:
AWS_LAMBDA_EXEC_WRAPPER: /opt/bootstrap
32

Spring Cloud Function for AWS Lambda
34
https://spring.io/projects/spring-cloud-function https://spring.io/projects/spring-cloud-aws

▪ Promote the implementation of business logic via functions.
▪ A simple function application (in context or Spring) is an application that
contains beans of type Supplier, Java 8 Function interface or Consumer.
35

▪ With Spring Cloud Function on AWS Lambda, AWS adapter takes a Spring
Cloud Function app and converts it to a form that can run in AWS Lambda
▪ With AWS it means that a simple function bean should be recognized and
executed in AWS Lambda environment
▪ Fits well into the AWS Lambda model with Amazon API Gateway in front
which similar to the Java 8 function receives the (HTTP) request, executes
some business logic and then sends the (HTTP) response to the caller
37

▪ AWS Request Adapter converts the JSON coming
from Lambda function to the HttpServletRequest
which then invokes the Spring Dispatcher Servlet
which then interacts with our Spring Boot
application on API level without starting web server
▪ Then response flows back and AWS Response
Adapter converts HttpServletResponse to JSON
which Lambda function sends back to API Gateway.
38

pom.xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-function-adapter-aws</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-function-web</artifactId>
</dependency>
40
https://github.com/Vadym79/AWSLambdaJavaWithSpringBoot/tree/master/spring-boot-3.2-with-spring-cloud-function

Properties:
Handler: org.springframework.cloud.function.adapter.aws.FunctionInvoker::handleRequest
Runtime: java21
MemorySize: 1024
Environment:
Variables:
MAIN_CLASS: software.amazonaws.Application
SPRING_CLOUD_FUNCTION_DEFINITION: getProductByIdHandler
41

@Component
public class GetProductByIdHandler implements
Function<APIGatewayProxyRequestEvent, Product> {
@Autowired
...
public APIGatewayProxyResponseEvent apply(APIGatewayProxyRequestEvent requestEvent) {
String id = requestEvent.getPathParameters().get("id");
}
42
SPRING_CLOUD_FUNCTION_DEFINITION:
getProductByIdHandler

Docker Image with Spring Cloud Function
for AWS Lambda
43

▪ Re-use Spring Cloud Function
▪ Use Base Java 21 Docker Image from Amazon ECR
public.ecr.aws/lambda/java:21
▪ Docker build image
▪ Docker tag image
▪ Create Amazon ECR repository (if not exists)
▪ Docker push image to Amazon ECR repository
Docker Container Image with Spring Cloud Function
44
https://github.com/Vadym79/AWSLambdaJavaDockerImage/

Dockerfile
FROM public.ecr.aws/lambda/java:21
# Copy function code and runtime dependencies from Maven layout
COPY target/classes ${LAMBDA_TASK_ROOT}
COPY target/dependency/* ${LAMBDA_TASK_ROOT}/lib/
45

Properties:
PackageType: Image
ImageUri: !Sub ${AWS::AccountId}.dkr.ecr.eu-central-1.amazonaws.com/aws-spring-boot-
3.2-java21-custom-docker-image:v1
ImageConfig:
Command:
["org.springframework.cloud.function.adapter.aws.FunctionInvoker::handleRequest"]
MemorySize: 1024
Environment:
Variables:
MAIN_CLASS: software.amazonaws.Application
SPRING_CLOUD_FUNCTION_DEFINITION: getProductByIdHandler
46

Demo Application
47
▪ Used Spring 3.2 with Amazon Corretto
Java 21
▪ Lambda has 1024 MB memory setting
▪ Lambda uses x86 architecture
▪ Info about the experiments:
▪ Approx. 1 hour duration
▪ Approx. first* 100 cold starts
▪ Approx. first 100.000 warm starts
*after Lambda function being re-deployed

Lambda function lifecycle – a full cold start
48
Sources: Ajay Nair „Become a Serverless Black Belt” https://www.youtube.com/watch?v=oQFORsso2go
Tomasz Łakomy "Notes from Optimizing Lambda Performance for Your Serverless Applications“ https://tlakomy.com/optimizing-lambda-performance-for-serverless-applications

▪ Start Firecracker VM (execution environment)
▪ AWS Lambda starts the Java runtime
▪ Java runtime loads and initializes Lambda function code
(Lambda handler Java class)
▪ Class loading
▪ Static initializer block of the handler class is executed (i.e. AWS service client
creation)
▪ Runtime dependency injection
▪ Just-in-Time (JIT) compilation kicks in
▪ Init-phase has full CPU access up to 10 seconds for free for the managed execution
environments)
▪ Lambda invokes the handler method
49
Sources: Ajay Nair „Become a Serverless Black Belt” https://www.youtube.com/watch?v=oQFORsso2go
Tomasz Łakomy "Notes from Optimizing Lambda Performance for Your Serverless Applications“ https://tlakomy.com/optimizing-lambda-performance-for-serverless-applications
Michael Hart: „Shave 99.93% off your Lambda bill with this one weird trick“ https://hichaelmart.medium.com/shave-99-93-off-your-lambda-bill-with-this-one-weird-trick-33c0acebb2ea
Lambda function lifecycle

0
1000
2000
3000
4000
5000
6000
7000
8000
AWS Serverless Java
Container
AWS Lambda Web Adapter Spring Cloud Function for
AWS
Docker Image based on
Spring Cloud Function for
AWS
p50 p75 p90 p99 p99.9 max
https://dev.to/aws-builders/aws-snapstart-part-13-measuring-warm-starts-with-java-21-using-different-lambda-memory-settings-160k
ms

0
1000
2000
3000
4000
5000
6000
7000
8000
AWS Serverless Java
Container
AWS Lambda Web
Adapter
Spring Cloud
Function for AWS
Docker Image based
on Spring Cloud
Function for AWS
Pure Java w/o
framework usage
p50 p75 p90 p99 p99.9 max
https://dev.to/aws-builders/aws-snapstart-part-13-measuring-warm-starts-with-java-21-using-different-lambda-memory-settings-160k
ms

0,00
5,00
10,00
15,00
20,00
25,00
30,00
AWS Serverless Java
Container
AWS
AWS
p50 p75 p90 p99
ms

0,00
5,00
10,00
15,00
20,00
25,00
30,00
AWS Serverless Java
Container
AWS Lambda Web
Adapter
Spring Cloud
Function for AWS
Docker Image based
on Spring Cloud
Function for AWS
Pure Java w/o
framework usage
p50 p75 p90 p99
ms

0
500
1000
1500
2000
2500
AWS Serverless Java
Container
AWS
AWS
p99.9 max
ms

0
500
1000
1500
2000
2500
AWS Serverless Java
Container
AWS Lambda Web
Adapter
Spring Cloud
Function for AWS
Docker Image based
on Spring Cloud
Function for AWS
Pure Java w/o
framework usage
p99.9 max
ms

Latency is the amount of time it takes from when a request
is made by the user to the time it takes for the response to
get back to that user
Latency
59

For our application:
Overall latency =
t(client to create and send request to the API Gateway endpoint) +
t(API Gateway to process request and invoke Lambda function) +
t(Lambda cold start time) +
t(Lambda warm start time) +
t(API Gateway to processes Lambda response and sends it back to the client) +
t(client to receive and process response from the API Gateway endpoint)
Latency
60

AWS Lambda
SnapStart
61 How to develop, run and optimize Spring Boot 3 application on AWS Lambda

AWS Lambda SnapStart != SnapChat
AWS Lambda SnapStart
62
https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html

AWS People behind Amazon Corretto
High performance Serverless Java on AWS
63

„AWS Lambda SnapStart „ series
64
https://dev.to/vkazulkin/measuring-java-11-lambda-cold-starts-with-snapstart-part-1-first-impressions-30a4
Article series covers they why and what
behind Lambda SnapStart and priming
techniques including measurements for cold
and warm starts with different settings for
▪ Java 11
▪ Java 17
▪ Java 21
▪ Micronaut
▪ Quarkus
▪ Spring Boot 2.7

▪ Lambda SnapStart for Java can improve startup performance for latency-
sensitive applications
▪ SnapStart is fully managed
65

AWS SnapStart Deployment & Invocation
66

▪ Currently available for Lambda managed Java Runtimes (Java 11, 17 and 21)
▪ Not available for all other Lambda runtimes:
▪ Docker Container Image
▪ Custom (Lambda) Runtime (a way to ship GraalVM Native Image)
67

available for:
▪ Spring Cloud Function (on AWS Lambda)
▪ Custom (Docker) Container Image
68

70
https://aws.amazon.com/de/blogs/compute/reducing-java-cold-starts-on-aws-lambda-functions-with-snapstart/
Vadym Kazulkin @VKazulkin , ip.labs GmbH
C
Create
Snapshot
Firecracker microVM
create & restore
snapshot

71
Firecracker microVM
create & restore
snapshot

▪ Linux CRIU available since 2012 allows a running application to be paused and restarted at some
point later in time, potentially on a different machine.
▪ The overall goal of the project is to support the migration of containers.
▪ When performing a checkpoint, essentially, the full context of the process is saved: program
counter, registers, stacks, memory-mapped and shared memory
▪ To restore the application, all this data can be reloaded and (theoretically) it continues from the
same point.
▪ Challenges
▪ open files
▪ network connections
▪ sudden change in the value of the system clock
▪ time-based caches
CRIU (Checkpoint/Restore in Userspace)
72
https://criu.org/Main_Page

▪ Compared to CRIU and Docker checkpoint and restore, Firecracker
snapshotting is different in the sense that it does not only saves a single
process or container but a whole running OS.
▪ Advantages of the Firecracker snapshot : we don't have to care about
file handles because they will be still valid after resume.
▪ Drawbacks the Firecracker snapshot : the need to reseed /dev/random
and to sync the system clock.
Snapshot /checkpointing and restore
Firecracker microVM vs CRIU
73
https://mail.openjdk.org/pipermail/discuss/2021-July/005864.html

76
Vadym Kazulkin @VKazulkin , ip.labs GmbH
Lambda uses the
CRaC APIs for
runtime hooks
for Priming
C
Create
Snapshot
Firecracker microVM
create & restore snapshot

▪ CRaC is a JDK project that allows you to start Java programs with a
shorter time to first transaction, combined with less time and resources
to achieve full code speed.
▪ CRaC effectively takes a snapshot of the Java process (checkpoint) when
it is fully warmed up, then uses that snapshot to launch any number of
JVMs from this captured state.
▪ CRaC is based on CRIU
Ideas behind CRaC (Coordinated Restore at
Checkpoint)
78
https://www.azul.com/blog/superfast-application-startup-java-on-crac/ https://github.com/CRaC/docs

AWS Lambda SnapStart with Priming
79

Approach 1 Priming of DynamoDB request
81

▪ Prime dependencies during initialization phase (when it worth doing)
▪ „Fake“ the calls to pre-initialize „some other expensive stuff“ (this technique is called
Priming)
▪ In case of DynamoDB client put the following code outside of the handler method to
pre-initialize the HTTP Client and Jackson Marshaller:
DynamoDbClient client = DynamoDbClientBuilder.builder().region(Regions.US_WEST_2).build();
GetItemResponse getItemResponse = client.getItem(GetItemRequest.builder()
.key(Map.of("PK", AttributeValue.builder().s(id).build()))
.tableName(PRODUCT_TABLE_NAME).build());
……
Priming
82
invocation forces HTTP Client and Jackson
Marshallers to pre-initialize
getProductById (int id)
method

@Configuration
public class Priming implements Resource {
@Autowired
public Priming() {
Core.getGlobalContext().register(this);
}
@Override
public void beforeCheckpoint(Context<? extends Resource> context) throws Exception {
productDao.getProduct("0");
}
@Override
public void afterRestore(Context<? extends Resource> context) throws Exception { }
}
AWS Serverless Java Container (Priming of DynamoDB request)
83

public class StreamLambdaHandler implements RequestStreamHandler, Resource {
@Autowired
public StreamLambdaHandler() {
}
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) {
}
84
Another alternative to
perform priming (within
custom Lambda function)

@Override
}
@Override
}
85

@Configuration
public class Priming implements Resource {
@Autowired
public Priming() {
}
@Override
}
@Override
}
AWS Lambda Web Adapter (Priming of DynamoDB request)
86
Looks the same as with AWS
Serverless Java Container

@Component
Function<APIGatewayProxyRequestEvent, Product>, Resource {
@Autowired
public GetProductByIdWithDynamoDBRequestPrimingHandler () {
}
...
public Product apply(APIGatewayProxyRequestEvent requestEvent) {
}
87
Spring Cloud Function for AWS (Priming of DynamoDB request)

@Override
}
@Override
}
88
Spring Cloud Function for AWS (Priming of DynamoDB request)

Approach 2 Priming/Proxying the whole web
(API Gateway) request without going via
network
89

public class StreamLambdaHandler implements RequestStreamHandler, Resource {
@Autowired
public StreamLambdaHandler() {
}
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) {
}
90
AWS Serverless Java Container (Priming of API Gateway request)

@Override
handler.proxy(getAwsProxyRequest(), new MockLambdaContext());
}
@Override
91

private static AwsProxyRequest getAwsProxyRequest () {
final AwsProxyRequest awsProxyRequest = new AwsProxyRequest ();
awsProxyRequest.setHttpMethod("GET");
awsProxyRequest.setPath("/products/0");
awsProxyRequest.setResource("/products/{id}");
awsProxyRequest.setPathParameters(Map.of("id","0"));
final AwsProxyRequestContext awsProxyRequestContext = new AwsProxyRequestContext();
final ApiGatewayRequestIdentity apiGatewayRequestIdentity= new ApiGatewayRequestIdentity();
apiGatewayRequestIdentity.setApiKey("blabla");
awsProxyRequestContext.setIdentity(apiGatewayRequestIdentity);
awsProxyRequest.setRequestContext(awsProxyRequestContext);
return awsProxyRequest;
}
}
92
Simulate
ApiGatewayProxyRequest

This type of priming doesn’t work for AWS Web Adapter
as doesn’t offer low-level API to stream/proxy the API
Gateway web request
93

@Component
Function<APIGatewayProxyRequestEvent, Product>, Resource {
@Autowired
public GetProductByIdWithDynamoDBRequestPrimingHandler () {
}
...
public Product apply(APIGatewayProxyRequestEvent requestEvent) {
}
94
Spring Cloud Function for AWS (Priming of API Gateway request)

@Override
new FunctionInvoker().handleRequest(new
ByteArrayInputStream(getAPIGatewayRequestMultiLine().getBytes(StandardCharsets.UTF_8)),
new ByteArrayOutputStream(), new MockLambdaContext()); }
@Override
}
95

private static String getAPIGatewayRequestMultiLine () {
return “”” {
"resource": "/products/{id}",
"path": "/products/0",
"httpMethod": "GET",
"pathParameters": {
"id": "0"
},
"requestContext": {
"identity": {
"apiKey": "blabla"
} } }
“””;
} }
96
Simulate
ApiGatewayProxyRequest

Lambda SnapStart Priming Guide
97
guide aims to explain techniques
for priming Java applications.
It assumes a base understanding
of AWS Lambda, Lambda
SnapStart, and CRaC.
https://github.com/marksailes/snapstart-priming-guide

0
1000
2000
3000
4000
5000
6000
7000
AWS Serverless Java Container AWS Lambda Web Adapter Spring Cloud Function for AWS
w/o SnapStart w SnapStart no Priming
w SnapStart & DynamoDB request priming w SnapStart and API Gateway request priming
p90
ms

0
1000
2000
3000
4000
5000
6000
7000
AWS Serverless Java
Container
AWS
Pure Java w/o framework
usage
p90
ms

0
500
1000
1500
2000
2500
AWS Serverless Java Container AWS Lambda Web Adapter Spring Cloud Function for AWS
max value
ms

0
500
1000
1500
2000
2500
AWS Serverless Java
Container
AWS
Pure Java w/o framework
usage
max value
ms

Other optimizations
104
• Measure the cold and warm start of Lambda
with SnapStart enabled (and with priming) for
arm64 architecture and compare it to x86
• Measure the impact of the different Java
compilation options and memory settings
• Measure the impact of setting the different
synchronous HTTP clients
DynamoDbClient client = DynamoDbClient.builder().region(Region.EU_CENTRAL_1)
. httpClient(ApacheHttpClient.create())
//.httpClient(UrlConnectionHttpClient.create())
//.httpClient(AwsCrtHttpClient.create())
.build();

„AWS Lambda SnapStart „ series
105
Article series covers they why and what
behind Lambda SnapStart and priming
techniques including measurements for cold
and warm starts with different settings for
▪ Java 11
▪ Java 17
▪ Java 21
▪ Micronaut
▪ Quarkus
▪ Spring Boot 2.7

Lambda x86_64 vs arm64 architecture
106
https://aws.amazon.com/lambda/pricing/?nc1=h_ls
For the same memory setting Lambda and
Lambda function execution duration the choice of
arm64 over x86_64 architecture is approx. 25%
cheaper

Lambda x86_64 vs arm64 architecture
107
https://aws.amazon.com/de/about-aws/whats-new/2024/07/aws-lambda-snapstart-java-functions-arm64-architecture/

0
500
1000
1500
2000
2500
3000
3500
4000
4500
w/o AWS SnapStart with AWS SnapStart w/o priming with AWS SnapStart with priming
Cold starts of the pure Lambda function (no framework in use)
with Java 21runtime with
1024 MB memory setting, Apache Http Client, compilation
-XX:+TieredCompilation -XX:TieredStopAtLevel=1 for p90
x86_64 arm64
ms
https://dev.to/aws-builders/aws-snapstart-part-16-measuring-cold-and-warm-starts-with-java-21-using-different-asynchronous-http-clients-4n2
+8,6%
+23,9%
+24,8%

6,40
6,60
6,80
7,00
7,20
7,40
7,60
7,80
8,00
w/o AWS SnapStart with AWS SnapStart w/o priming with AWS SnapStart with priming
Warm starts of pure Lambda function (no framework in use)
with Java 21runtime with
1024 MB memory setting, Apache Http Client, compilation
-XX:+TieredCompilation -XX:TieredStopAtLevel=1 for p90
x86_64 arm64
ms
https://dev.to/aws-builders/aws-snapstart-part-16-measuring-cold-and-warm-starts-with-java-21-using-different-asynchronous-http-clients-4n2
+9,1%
+10,1%
+4,8%

110
Firecracker microVM
create & restore
snapshot

Demo Application
111
▪ Used Spring 3.2 with Amazon Corretto
Java 21
▪ Lambda has 1024 MB memory setting
▪ Lambda uses x86 architecture
▪ Info about the experiments:
▪ Approx. 1 hour duration
▪ Approx. first* 100 cold starts
▪ Approx. first 100.000 warm starts
*after Lambda function being re-deployed

AWS SnapStart tiered cache
112
https://dev.to/aws-builders/aws-snapstart-part-17-impact-of-the-snapshot-tiered-cache-on-the-cold-starts-with-java-21-52ef
• Due to the effect of
snapshot tiered cache, cold
start times reduces with the
number of invocations
• after certain number of
invocations reached the
cold start times becomes
stable

AWS Lambda under the Hood
113
https://www.infoq.com/articles/aws-lambda-under-the-hood/
https://www.infoq.com/presentations/aws-lambda-arch/

▪ SnapStart supports the Java 11, 17 and 21 (Corretto) managed runtime
only
▪ Deployment with SnapStart enabled takes more than 2-2,5 minutes
additionally
▪ Snapshot is deleted from cache if Lambda function is not invoked for 14
days
▪ SnapStart currently does not support :
▪ Provisioned concurrency
▪ arm64 architecture (supports only x86). Supports arm64 architecture since
18 July 2024
▪ Amazon Elastic File System (Amazon EFS)
▪ Ephemeral storage greater than 512 MB
AWS SnapStart Challenges & Limitations
114

▪ AWS Serverless Java Container and AWS Lambda Web Adapter offer similar
functionality
▪ AWS Serverless Java Container a bit lower warm start times
▪ AWS Serverless Java Container offers more flexibility to apply priming techniques to the
individual Lambda functions in the deployment artifact through its API
▪ AWS Lambda Web Adapter offers lower cold start times (with SnapStart and priming)
▪ AWS Lambda Web Adapter offers more event triggers (non HTTP events)
▪ Spring Cloud Function makes sense if already in use
▪ AWS Serverless Java Container (since 2.0.2) and Spring Cloud Function both
support GraalVM Native Image
▪ Using Docker Image leads to the highest cold start. You can use the recent Java
version though and use jlink to reduce the size of the JDK
Framework Comparison
116
https://www.azul.com/blog/superfast-application-startup-java-on-crac/ https://github.com/CRaC/docs

▪ Low footprint ahead-of-time mode for JVM-based languages
▪ High performance for all languages
▪ Convenient language interoperability and polyglot tooling
GraalVM Goals
118
Source: „Everything you need to know about GraalVM by Oleg Šelajev & Thomas Wuerthinger” https://www.youtube.com/watch?v=ANN9rxYo5Hg

GraalVM Architecture
119

GraalVM Ahead-of-Time Compilation
120
Source: Oleg Šelajev, Thomas Wuerthinger, Oracle: “Deep dive into using GraalVM for Java and JavaScript”
https://www.youtube.com/watch?v=a-XEZobXspo

AOT vs JIT
121
Source: „Everything you need to know about GraalVM by Oleg Šelajev & Thomas Wuerthinger” https://www.youtube.com/watch?v=ANN9rxYo5Hg

Promise: Java Function compiled into a native executable using GraalVM Native
Image significantly reduces
▪ “cold start” times
▪ memory footprint
GraalVM Native Image
122

▪ AWS doesn’t provide GraalVM (Native Image) as Java Runtime out of the box
▪ AWS provides Custom Runtime Option
Current Challenges with Native Executable using
GraalVM
123

Custom Lambda Runtimes
124
https://github.com/Vadym79/AWSLambdaGraalVMNativeImage

GraalVM Release Calendar
125
https://www.graalvm.org/release-calendar/

GraalVM CE is based on OpenJDK
126
https://www.graalvm.org/2022/openjdk-announcement/
https://blogs.oracle.com/java/post/graalvm-free-license

▪Spring Boot 3+ provides official support for
compiling Spring Boot applications into the GraalVM
Native Image
▪Spring AOT (Ahead-of-Time Processing) is a process
that analyzes your application at build-time and
generate an optimized version of it. It is a mandatory
step to run a Spring ApplicationContext in a native
image
Spring Supprt for GraalVM Native Image
127
https://docs.spring.io/spring-boot/maven-plugin/aot.html

pom.xml
<profiles>
<profile>
<id>native</id>
<activation>
<property>
<name>native</name>
</property>
</activation>
....
</profile>
</profiles>
GraalVM Native Image with Spring Cloud Function
128
mvn clean package -Pnative
https://github.com/Vadym79/AWSLambdaJavaWithSpringBoot/tree/master/spring-boot-3.2-with-graalvm-native-image

pom.xml
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<id>process-aot</id>
<goals>
<goal>process-aot</goal>
</goals>
</execution>
</executions>
</plugin>
129

pom.xml
<plugin>
<groupId>org.graalvm.buildtools</groupId>
<artifactId>native-maven-plugin</artifactId>
<configuration>
<mainClass>software.amazonaws.Application</mainClass>
</configuration>
<executions>
<execution>
<id>build-native</id>
<goals>
<goal>compile-no-fork</goal>
</goals>
130
<phase>package</phase>
</execution>
</executions>
</plugin>

▪ You can run into errors when
application is running
GraalVM Native Image
131
https://github.com/Vadym79/AWSLambdaGraalVMNativeImage/blob/master/pure-lambda-graalvm-jdk-21-native-image/src/main/reflect.json

import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.RuntimeHintsRegistrar;
import
org.springframework.aot.hint.annotation.RegisterReflection
ForBinding;
@Configuration
@RegisterReflectionForBinding({DateTime.class,
APIGatewayProxyRequestEvent.class, HashSet.class,
APIGatewayProxyRequestEvent.ProxyRequestContext.class,
APIGatewayProxyRequestEvent.RequestIdentity.class,
Product.class, Products.class})
@ImportRuntimeHints(ApplicationConfiguration.Application
RuntimeHintsRegistrar.class)
132
public class ApplicationConfiguration {
public static class ApplicationRuntimeHintsRegistrar
implements RuntimeHintsRegistrar {
@Override
public void registerHints(RuntimeHints hints,
ClassLoader classLoader) {
hints.reflection() .registerType(Product.class,
PUBLIC_FIELDS, INVOKE_PUBLIC_METHODS,
INVOKE_PUBLIC_CONSTRUCTORS
;
}
}
}

950
1000
1050
1100
1150
1200
1250
GraalVM 21 Native Image with Spring Cloud Function for AWS
p50 p75 p90 p99 p99.9 max
1024 MB
memory
ms

0
50
100
150
200
250
GraalVM 21 Native Image with Spring Cloud Function for AWS
p50 p75 p90 p99 p99.9 max
1024 MB
memory
ms

0
1000
2000
3000
4000
5000
6000
7000
AWS Serverless Java
Container
AWS
Graal VM 21 Native Image
with Spring Cloud Function
for AWS
w SnapStart & DynamoDB priming w SnapStart and Web priming
p90

0
500
1000
1500
2000
2500
AWS Serverless Java
Container
AWS
Graal VM 21 Native Image
with Spring Cloud Function
for AWS
w SnapStart & DynamoDB priming w SnapStart and Web priming
max value
ms

0
200
400
600
800
1000
1200
1400
GraalVM 21 Native Image with Spring Cloud Function
for AWS
GraalVM 21 Native Image with Pure Java w/o
framework usage
p50 p75 p90 p99 p99.9 max
1024 MB
memory
https://github.com/Vadym79/AWSLambdaGraalVMNativeImage/tree/master/pure-lambda-graalvm-jdk-21-native-image
ms

GraalVM 21 Native Image for Spring Cloud Function for
AWS
138
ONE SECOND ONE GB

0
200
400
600
800
1000
1200
1400
1600
1800
2000
256 MB 512 MB 768 MB 1024 MB 1280 MB 1536 MB
p50 p75 p90 p99 p99.9 max
GraalVM 21
Native Image
with Spring
Cloud
Function for
AWS
ms

0
100
200
300
400
500
600
700
800
900
1000
256 MB 512 MB 768 MB 1024 MB 1280 MB 1536 MB
p50 p75 p90 p99 p99.9 max
GraalVM 21
Native Image
with Spring
Cloud
Function for
AWS
ms

▪ GraalVM is really powerful and has a lot of potential
▪ GraalVM Native Image improves cold starts and memory footprint significantly
▪ GraalVM Native Image is currently not without challenges
▪ AWS Lambda Custom Runtime requires Linux executable only
▪ Building Custom Runtime requires some additional effort
▪ e.g. you need a scalable CI/CD pipeline to build memory-intensive native image
▪ Build time is a factor
▪ You need to carefully test to avoid runtime errors
▪ You pay for the init-phase of the function packaged as AWS Lambda Custom
and Docker Runtime
▪ Init-phase is free for the managed runtimes like Java 11, Java17 and Java 21
GraalVM Conclusion
141

Frameworks and libraries Ready for GraalVM Native Image
142
https://www.graalvm.org/native-image/libraries-and-frameworks/

“Spring Boot 3 application on AWS Lambda” series
143
Article series covers different
ways to write Spring Boot 3
application on AWS Lambda
▪ Spring Cloud Functions
▪ Custom Docker Image
▪ GraalVM Native Image
Cold and warm start time
measurements are also provided
https://dev.to/aws-builders/spring-boot-3-application-on-aws-lambda-part-1-introduction-to-the-series-2m5g

“Data API for Amazon Aurora Serverless v2
with AWS SDK for Java” series
144
Article series also covers
cold and warm start time
measurements and
optimization techniques
https://dev.to/aws-builders/data-api-for-amazon-aurora-serverless-v2-with-aws-sdk-for-java-part-1-introduction-and-set-up-of-the-sample-application-3g71

Word of caution
145
Re-measure for your use case!
Even with my examples measurements might
already produce different results due to:
▪ Lambda Amazon Corretto Java 21 managed
runtime minor version changes
▪ Spring Boot 3 version updates (already 3.3.
released, tested with 3.2.)
▪ Lambda SnapStart snapshot create and
restore improvements
▪ Firecracker VM improvements
▪ GraalVM and Native Image improvements
(already version 22 released, tested with 21)
▪ There are still servers behind Lambda
▪ Java Memory Model impact (L or RAM
caches hits and misses)

▪ Spring Boot natively supports CRaC
▪ For Checkpoint: -Dspring.context.checkpoint=onRefresh -XX:CRaCCheckpointTo={path}
▪ For Restore: -XX:CRaCRestoreFrom={path}
▪ Amazon Corretto doesn’t support CRaC
▪ Azul Zulu OpenJDK supports CRaC
▪ Can be deployed on Lambda with Docker Container Image
▪ Currently very complicated and partially possible with hacks and many trade-offs
▪ Mounting EFS for CRaC snapshot. Requires Lambda being in VPC and managing EFS
throughput
Spring Boot Native CRaC Support
146
https://github.com/CRaC/example-lambda/issues/7

▪ With AWS SnapStart and GraalVM Native Image you can reduce cold
start times of the Spring Boot 3 application on AWS Lambda to the
acceptable values
▪ If you’re willing to accept slightly higher cold and warm start times for
certain the Lambda function(s) and solid priming is applicable -> use fully
managed AWS SnapStart with priming
▪ If a very high performance for certain the Lambda function(s) is really
crucial for your business -> go for GraalVM Native Image
Wrap up and personal suggestions
147

Project Leyden
148
The primary goal of
this Project is to
improve the startup
time, time to peak
performance, and
footprint of Java
programs.
https://www.youtube.com/watch?v=teXijm79vno
https://openjdk.org/projects/leyden/

FAQ Ask me Anything
149

Thank you

How to develop, run and optimize Spring Boot 3 application on AWS Lambda at AWS User Group New York 2024

More Related Content

Similar to How to develop, run and optimize Spring Boot 3 application on AWS Lambda at AWS User Group New York 2024

More from Vadym Kazulkin

Recently uploaded

How to develop, run and optimize Spring Boot 3 application on AWS Lambda at AWS User Group New York 2024