Legacy java ee meet lambda

© 2018, Amazon Web Services, Inc. or its Affiliates. All rights reserved.
21.Jul.2018
Legacy JavaEE Lambda
Kim Kao
Solution Architect @ AWS

Legacy
Legacy!

Java EE
• Oracle Java EE
• Apache / Eclipse
• Java EE 9
•
• MicroProfile by Eclipse
Jakarta EE is coming

Jarkata EE
• Specification JCP
• Version Java EE 8
•
• Eclipse GlassFish
• Apache TomEE
• Wildfly
• Oracle Weblogic
• Jboss
• IBM Websphere
• Eclipse Foundation
Old Name New Name
Java EE Jakarta EE
Glassfish Eclipse Glassfish
Java Community
Process (JCP) ¹
Eclipse EE.next
Working
Group (EE.next)
Oracle
development
management
Eclipse Enterprise
for Java (EE4J)
Project
Management
Committee (PMC)

Java EE

Why Migrate to Serverless

Serverless compute manifesto
• Functions are the unit of deployment and scaling.
• No machines, VMs, or containers visible in the programming
model.
• Permanent storage lives elsewhere.
• Scales per request. Users cannot over- or under-provision capacity.
• Never pay for idle (no cold servers/containers or their costs).
• Implicitly fault-tolerant because functions can run anywhere.
• BYOC – Bring your own code.
• Metrics and logging are a universal right.

AWS Lambda ?
• Linux
• Process/Networking
•
•
•
•

AWS Lambda

*
API
API
?

• API
• API Key
• SigV4 API
• API
• Lambda
Amazon API Gateway

API Gateway
• Managed cache to store API responses
• Reduced latency and distributed denial of service (DDoS)
protection through Amazon CloudFront
• SDK generation for iOS, Android, and JavaScript
• Swagger support
• Request/response data transformation

Microservices and AWS Lambda
AWS Lambda + Amazon API Gateway is the
easiest way to create microservices
• Event handlers one function per event type
• Serverless backends one function per API / path
• Data processing one function per data type

Amazon API Gateway: Serverless APIs
Internet
Mobile apps
Websites
Services
AWS Lambda
functions
AWS
API Gateway
cache
Endpoints on
Amazon EC2
Any other publicly
accessible endpointAmazon
CloudWatch
Amazon
CloudFront
Amazon
API Gateway

Serverless Java Container
• A Java wrapper to run Spring, Jersey and Spark Java
Apps inside AWS Lambda, without a Servlet engine
• Open source via awslabs, Apache 2.0 license, written by
Stefano Biliani
• https://github.com/awslabs/aws-serverless-java-
container

Client Sends Request API Gateway
Lambda Proxy
Request
Serverless Java
Container
Spring
(HttpServletRequest)
Client Receives
Response API Gateway Lambda Proxy Response
Serverless Java
Container
Spring
(HttpServletResponse)

Legacy

• AWS Lambda
• ServeletRequest handler lambda handler
• ! !
• AWS SAM
•
• Serverless Friendly

Difference What to avoid Possible Solution
No sticky sessions /
session replication
Avoid HttpSession variables Store state in (DynamoDB / RDS)
5 minute timeout Avoid long blocking requests
Call another Lambda asynchronously.
Use an appropriate service for long running tasks
Memory Limit Avoid large dependencies
Break monolithic apps into separate “microservice”
Spring projects, you can use the same Cognito user
pool with multiple API Gateway APIs

Containers may be reused
for subsequent requests
Avoid relying too much on
container reuse
You can still use in-memory caching to save
costly initializations if the container is reused
Containers are never
reused for concurrent
requests.
Avoid returning DeferredResult /
CompletableFuture, @Async,
servlet 3.0 asyncSupport, relying
on large DB connection pools
Use regular @RequestMapping,
Avoid unneeded thread safety synchronization
Use per-lambda throttling to for maxconn in DBs
No streaming HTTP
response or WebSockets
support
Avoid old school “comet” (long
polling / streaming)
WebSockets
Use a service that supports WebSockets
(AWS Iot MessageBroker, AppSync) or launch
on EC2

Serving static assets /
near-static content
Avoid serving static resources
from /resources or WEB-
INF/views, or using JSPs or
other serverside rendering
Serve static assets from s3 / CloudFront.
Use a client side “SPA” framework (Angular,
React, Vue etc).
Can’t use legacy
distributed cache methods
(e.g. jGroups, multicast or
unicast)
Avoid jGroups or similar solution
for distributed Hibernate 2nd level
cache etc.
Use a managed cache service. E.g. Hibernate
2nd level cache memcached support (e.g. on
AWS ElastiCache)
Stateless
Avoid cookie based
authentication
Use JWT for authentication (Cognito)

• - S3 + Cloudfront
• DI – Spark Framework Spring
• lambda Cold start time
•
• Shade
aws-java-sdk-bom
aws-xray-recorder-sdk-bom
• X-ray

– Legacy SpringWebMVC
@RequestMapping(path = "/pets", method = RequestMethod.POST)
public Pet createPet(@RequestBody Pet newPet) {
if (newPet.getName() == null || newPet.getBreed() == null) {
return null;
}
Pet dbPet = newPet;
dbPet.setId(UUID.randomUUID().toString());
return dbPet;
}

– Wrapper
private static SpringLambdaContainerHandler<AwsProxyRequest, AwsProxyResponse> handler;
handler = SpringLambdaContainerHandler.getAwsProxyHandler(PetStoreSpringAppConfig.class);
handler.onStartup(servletContext -> {
FilterRegistration.Dynamic registration =
servletContext.addFilter("CognitoIdentityFilter", CognitoIdentityFilter.class);
registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, "/*");
});
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context)
throws IOException {
handler.proxyStream(inputStream, outputStream, context);
// just in case it wasn't closed by the mapper
outputStream.close();

•
•
• Junit
• Mockito
• MvcMock
• Spring related Mock/Test framework
• Selenium

Wrapper
@Test
public void handleRequest() throws Exception {
// create a Proxy Request
AwsProxyRequest proxyRequest = new AwsProxyRequestBuilder().path("/").build();
// convert the request to JSON, then to a byte array
ByteArrayInputStream in = new
ByteArrayInputStream(objectMapper.writeValueAsString(proxyRequest).getBytes("UTF-8"));
ByteArrayOutputStream out = new ByteArrayOutputStream();
// call the Lambda handler
underTest.handleRequest(in, out, new MockLambdaContext());
// convert the response to a Proxy Response
AwsProxyResponse awsProxyResponse = objectMapper.readValue(out.toByteArray(),
AwsProxyResponse.class);
//test something with the response body
Assert.assertEquals(awsProxyResponse.getBody(), "expected");
}

Serverless
Author Package Test Deploy
• AWS
• ?
• AWS SAM( CloudFormation )

AWS CloudFormation
•
• CloudFormation Stack
• YAML or JSON
https://github.com/humank-awshandson/20171116-cfn-lab

AWS Serverless Application Model (SAM)
• Serverless App
• : Function, API, Tables
• CloudFormation SAM
• Open specification (Apache 2.0)
NEW!

SAM
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Example Pet Store API written with spark/guice with the aws-serverless-java-container library
Resources:
PetStoreFunction:
Type: AWS::Serverless::Function
Properties:
Handler: solid.humank.serverlesslabs.SparkStreamLambdaHandler::handleRequest
Runtime: java8
CodeUri: target/sparkjava-petclinic-1.0.0.jar
MemorySize: 512
Policies: AWSLambdaFullAccess
Timeout: 60
Events:
GetResource:
Type: Api
Properties:
Path: /{proxy+}
Method: any
Outputs:
SpringBootPetStoreApi:
Description: URL for application
Value: !Sub 'https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/owners'
Export:
Name: SparkPetClinicApi

lambda
• Package
• (.zip)
• S3 Bucket
• S3 code URI
• Deploy
• CloudFormation ‘CreateChangeSet’ API
• CloudFormation ‘ExecuteChangeSet’ API
NEW!

Lambda
AWS Lambda
Amazon DynamoDB
Amazon SNS
Amazon API Gateway
Amazon SQS
Amazon Kinesis
THE COMPLETE PLATFORM
Amazon S3
AWS Step Functions

JavaEE Serverless
•
• Wrapper APIG Servelet
Handler
•
•
•
•

Legacy java ee meet lambda

More Related Content

Similar to Legacy java ee meet lambda (7)

More from Kim Kao (12)

Recently uploaded (20)

Legacy java ee meet lambda