How to develop, run and optimize Spring Boot 3 application on AWS Lambda at Java Forum Stuttgart 2024

Vadym Kazulkin | @VKazulkin |ip.labs GmbH
How to develop, run and optimize Spring Boot 3
(web) application on AWS Lambda
Vadym Kazulkin, ip.labs, Java Forum Stuttgart, 31 July 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
Challenge
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
▪ Requires securing the application only
▪ With less possible engineering effort in the business logic
Challenge
8

▪ It’s a bad idea
▪ Performance is bad
▪ Too much runtime annotation processing, reflection, dynamic class loading used
▪ 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

▪ 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

▪ 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
https://github.com/awslabs/aws-lambda-web-adapter

▪ 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

AWS_LAMBDA_EXEC_WRAPPER : /opt/bootstrap
▪ When we add a layer to a Lambda function, Lambda extracts the layer contents
into the /opt directory in our function’s execution environment
▪ All natively supported Lambda runtimes include paths to specific directories
within the /opt directory
▪ This gives our Lambda function access to our layer content
33

Spring Cloud Function for AWS Lambda
34

▪ 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
https://spring.io/projects/spring-cloud-function https://spring.io/projects/spring-cloud-aws

▪ 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
▪ 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

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

„AWS Lambda SnapStart „ series
60
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
AWS Lambda SnapStart
61
https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html

AWS SnapStart Deployment & Invocation
62
https://dev.to/vkazulkin/measuring-java-11-lambda-cold-starts-with-snapstart-part-1-first-impressions-30a4

▪ 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)
AWS Lambda SnapStart
63

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

66
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

67
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)
68
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
69
https://mail.openjdk.org/pipermail/discuss/2021-July/005864.html

72
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)
74
https://www.azul.com/blog/superfast-application-startup-java-on-crac/ https://github.com/CRaC/docs

AWS Lambda SnapStart with Priming
75

Approach 1 Priming of DynamoDB request
77

▪ 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
78
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)
79

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

@Override
}
@Override
}
81

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

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

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

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

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

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

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;
}
}
88
Simulate
ApiGatewayProxyRequest

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

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

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

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

Lambda SnapStart Priming Guide
93
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 Web 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
High performance Serverless Java on AWS
100
• 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
• 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();

101
Firecracker microVM
create & restore
snapshot

Demo Application
102
▪ 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
103
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
104
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
105

▪ 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
Framework Comparison
107
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
109
Source: „Everything you need to know about GraalVM by Oleg Šelajev & Thomas Wuerthinger” https://www.youtube.com/watch?v=ANN9rxYo5Hg

GraalVM Architecture
110

GraalVM Ahead-of-Time Compilation
111
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
112
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
113

▪ 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
114

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

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

GraalVM CE is based on OpenJDK
117
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
Spring Supprt for GraalVM Native Image
118

pom.xml
<profiles>
<profile>
<id>native</id>
<activation>
<property>
<name>native</name>
</property>
</activation>
....
</profile>
</profiles>
GraalVM Native Image with Spring Cloud Function
119
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>
120

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>
121
<phase>package</phase>
</execution>
</executions>
</plugin>

▪ You can run into errors when
application is running
High performance Serverless Java on AWS
122
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)
123
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
129
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 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
132

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

“Spring Boot 3 application on AWS Lambda” series
134
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
135
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
136
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
▪ -Dspring.context.checkpoint=onRefresh -XX:CRaCCheckpointTo={path}
▪ Amazon Corretto doesn’t support CRaC
▪ Azul Zulu OpenJDK supports CRaC
▪ Can be deployed on Lambda with Docker Container Image
▪ Firecracker microVM throws error when performing CRaC snapshot/checkpoint and
it seems that kernel not to support CRIU/CRaC
Spring Boot Native CRaC Support
137
https://github.com/CRaC/example-lambda/issues/7

FAQ Ask me Anything
138

Thank you

How to develop, run and optimize Spring Boot 3 application on AWS Lambda at Java Forum Stuttgart 2024

More Related Content

Similar to How to develop, run and optimize Spring Boot 3 application on AWS Lambda at Java Forum Stuttgart 2024 (20)

More from Vadym Kazulkin (16)

Recently uploaded (20)

How to develop, run and optimize Spring Boot 3 application on AWS Lambda at Java Forum Stuttgart 2024