2018 10-19-jc conf-embrace-legacy-java-ee-by-aws-serverless

© 2018, Amazon Web Services, Inc. or its Affiliates. All rights reserved.
19 Oct, 2018
Kim Kao( ), Solutions Architect
Embrace Legacy Java EE
By AWS Serverless

Classic Java EE Core Pattern
ü Tiering Paradigm
ü Distributed System Design
ü Spring framework Birth
ü Beautiful methodologies age
http://www.corej2eepatterns.com/

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)
Ecosystem is changing …

Old Soldiers never die

“The cloud is the new normal”

“All Things Distributed”
“Design to Fail”
“Redundant is hard”
“No servers is easier to manage than No server”

AWS customers modernize applications one at a
time
Assess and
prioritize, one
app at a time
Re-host (lift-and-shift)
data center à EC2
Re-platform (lift-tinker-shift)
VMs à containers
Re-factor
monolith à microservices
Re-invent (cloud-native)
new serverless microservices
Determine
modernization
path

Why AWS for modern applications?
Experience
Partners
Portfolio
Customers
Developer
Community
AWS frees
innovators to innovate
and fail without fear
Any starting point
Any application
Anything is possible

Why migrate to Serverless?

Computing evolution – A paradigm shift
FOCUS ON BUSINESS LOGIC
LEVELOFABSTRACTION
Virtual Servers
in Datacenters
Virtual Servers
in Datacenters
Physical Machines
Virtual Machines
Containerization
Serverless
• Continuous scaling
• Fault tolerance built-in
• Event-driven
• Pay per usage
• Zero maintenanceAWS Fargate
Amazon
API Gateway
AWS
Lambda
AWS Step
Function

No servers to provision
or manage
Scales with usage
Never pay for idle Availability and fault
tolerance built in
Serverless means…

What does Fargate mean?
Serverless Container Management.
No worrying about scaling, service mesh, underlying infrastructure,
cluster resources, capacity, setup.
Just give it a task definition or pod (in 2018), set some resource
limits, and away you go.

SERVICES (ANYTHING)
Changes in
data state
Requests to
endpoints
Changes in
resource state
EVENT SOURCE FUNCTION
Node.js
Python
Java
C#
Go
Serverless applications

Cost-effective and
efficient
No Infrastructure
to manage
Pay only for what you use
Bring Your
Own Code
Productivity focused compute platform to build powerful, dynamic, modular
applications in the cloud
Run code in standard
languages
Focus on business logic
Benefits of AWS Lambda
1 2 3

How it works

Using AWS Lambda
Bring your own code
• Node.js, Java, Python, C#
• Bring your own libraries
(even native ones)
Simple resource model
• Select power rating from
128 MB to 1.5 GB
• CPU and network
allocated proportionately
Flexible use
• Synchronous or
asynchronous
• Integrated with other
AWS services
Flexible authorization
• Securely grant access to
resources and VPCs
• Fine-grained control for
invoking your functions

Using AWS Lambda
Authoring functions
• WYSIWYG editor or
upload packaged .zip
• Third-party plugins
(Eclipse, Visual Studio,
SAM)
Monitoring and logging
• Metrics for requests,
errors, and throttles
• Built-in logs to Amazon
CloudWatch Logs
Programming model
• Use processes, threads,
/tmp, sockets normally
• AWS SDK built in
(Python and Node.js)
Stateless
• Persist data using
external storage
• No affinity or access to
underlying infrastructure

AWS Lambda Pricing
• Buy compute time in
100 ms increments
• Low request charge
• No hourly, daily, or
monthly minimums
• No per-device fees
Never pay for idle!
Free Tier
1 million requests and 400,000 GB-secs of
compute every month, every customer

What can make migrating to / adopting AWS
Serverless easier?
ü Cost effective
ü Secure
ü Low maintenance
q Reuse existing code and frameworks
q Leverage existing developer skills

Serverless adopt decision
Lambda Function Serverless Container
Too complexity ecosystems
Frequent API call
Huge ISV Solutions
Newly creation services
Dividable Applications
Acceptable Method invoke times
Legacy Java EE

Comparison between Lambda & Container App
Runs on Lambda Function Runs on Container
Pay by Memory size * Execution time Stable pricing model
DDoS make you pay
Computing cost
DDoS make you pay
Infra cost
Scaling with limitation(soft & hard) Scaling by metrics/self
Consider more Cloud Native Nature fit-in Legacy
Request/method throttling control Self control

Lambda Function Lifecycle

AWS X-Ray Integration with Serverless
• Lambda instruments
incoming requests for all
supported languages
• Lambda runs the X-Ray
daemon on all languages
with an SDK
var AWSXRay = require(‘aws-xray-sdk-core‘);
AWSXRay.middleware.setSamplingRules(‘sampling-rules.json’);
var AWS = AWSXRay.captureAWS(require(‘aws-sdk’));
S3Client = AWS.S3();

Most Concern - Summary
“Pay as you go”
“Execution Time – Cold Start time”

“How to get good Cold Start time ”
Re the Legacy Spring App

Serverless Java Container
• A Java wrapper to run Spring, Jersey and Spark* Java Apps
inside AWS Lambda, without a Servlet Engine (such as
Tomcat)
• Open source via awslabs, Apache 2.0 license
• https://github.com/awslabs/aws-serverless-java-container

Serverless Java Container – How does it work?
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)

Java Container for Spring-boot

Java Container for SparkJava + Guice

Number matters …

Run time binding vs Compile time binding
Spring Boot
SparkJava Guice

How much effort?
• Just make sure your code is AWS Lambda
friendly
• Create the infrastructure (e.g. using AWS
SAM)

SparkJava Lambda Handler
public class SparkStreamLambdaHandler implements RequestStreamHandler {
private static SparkLambdaContainerHandler<AwsProxyRequest, AwsProxyResponse> handler;
static {
try {
handler = SparkLambdaContainerHandler.getAwsProxyHandler();
SparkResourceRoute.defineResources();
Spark.awaitInitialization();
} catch (ContainerInitializationException e) {
// if we fail here. We re-throw the exception to force another cold start
e.printStackTrace();
throw new RuntimeException("Could not initialize Spark container", e);
}
}
public SparkStreamLambdaHandler() {
// we enable the timer for debugging. This SHOULD NOT be enabled in production.
Timer.enable();
}
@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();
}
}

Guice DI configuration
public class ClinicModule extends AbstractModule {
@Override
protected void configure(){
/**
*
private PetRepository petRepository;
private VetRepository vetRepository;
private OwnerRepository ownerRepository;
private VisitRepository visitRepository;
private SpecialtyRepository specialtyRepository;
private PetTypeRepository petTypeRepository;
*/
bind(OwnerRepository.class).to(JpaOwnerRepositoryImpl.class);
bind(PetRepository.class).to(JpaPetRepositoryImpl.class);
bind(VetRepository.class).to(JpaVetRepositoryImpl.class);
bind(VisitRepository.class).to(JpaVisitRepositoryImpl.class);
bind(SpecialtyRepository.class).to(JpaSpecialtyRepositoryImpl.class);
bind(PetTypeRepository.class).to(JpaPetTypeRepositoryImpl.class);
bind(ClinicService.class).to(ClinicServiceImpl.class);
}

Replace Spring Data JPA by Guice Module
public class DatabaseModule extends AbstractModule {
@Override
protected void configure() {
install(new JpaPersistModule("demo"));
bind(JPAInitializer.class).asEagerSingleton();
}
@Singleton
public static class JPAInitializer {
@Inject
public JPAInitializer(final PersistService service) {
service.start();
}
}
}

Define Route entry point
public class SparkResourceRoute {
private static final Logger logger = LoggerFactory.getLogger(SparkResourceRoute.class);
public static void defineResources() {
Injector injector = Guice.createInjector(new JpaPersistModule("demo"),new
ClinicModule());
injector.getInstance(DatabaseModule.JPAInitializer.class);
// rest controller routing
OwnerRestController ownerRestController =
injector.getInstance(OwnerRestController.class);
//@RequestMapping(value = "", method = RequestMethod.GET, produces =
MediaType.APPLICATION_JSON_UTF8_VALUE)
get("/owners", (req, res) -> {
Collection<Owner> owners = ownerRestController.getOwners(() -> res.status(404));
res.status(200);
return owners;
}, new JsonTransformer());
}
}

Could be more better
• Load/Include less libs/classes
• Check by Java Agent
• Using Dagger2 not Guice
• Lighter, faster
• Using AWS SDK for Java v2
• Excluded unnecessary Deps
• Fixed on the URLConnection client

Making your existing Java code AWS Lambda Friendly
Difference What to avoid Possible Solution
No sticky sessions /
session replication
Avoid HttpSession variables Store state in (DynamoDB / RDS)
15 minute timeout Avoid long blocking requests
Call another Lambda asynchronously.
Use an appropriate service for long running tasks
Container freezes on
handler return
Avoid background task
execution and scheduling
Same as above +
CloudWatch Events Scheduled Rules for
scheduling
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
NEW

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)

Testing
ü Pure Unit tests – no significant change
ü MockMvc – no significant change
ü Selenium / UI tests – no significant change
• Full integration tests without deploying to Lambda:
• AWS SAM CLI when possible
• Build as a regular jar file (requires some setup effort)

Deployment
AWS Serverless Application Model (SAM)
CloudFormation extension optimized for serverless
(Infrastructure as Code)
Resource types: functions, APIs, and tables
Supports anything CloudFormation supports
Open specification (Apache 2.0)
https://github.com/awslabs/serverless-application-model

SAM template
AWSTemplateFormatVersion: '2010-09-09’
Transform: AWS::Serverless-2016-10-31
Resources:
GetHtmlFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: s3://sam-demo-bucket/todo_list.zip
Handler: index.gethtml
Runtime: nodejs4.3
Policies: AmazonDynamoDBReadOnlyAccess
Events:
GetHtml:
Type: Api
Properties:
Path: /{proxy+}
Method: ANY
ListTable:
Type: AWS::Serverless::SimpleTable
Tells CloudFormation this is a SAM
template it needs to “transform”
Creates a Lambda function with the
referenced managed IAM policy,
runtime, code at the referenced zip
location, and handler as defined.
Also creates an API Gateway and
takes care of all
mapping/permissions necessary
Creates a DynamoDB table with 5
Read & Write units

“Lambda goes well, how about container”

AWS Container related offering
Amazon ECS
(available now)
Amazon EKS
(preview)
Fargate mode for
ECS
(available now)
Fargate mode
for EKS
(available
2018)

ECS
Easiest way to deploy and
manage containers
Integration with entire AWS platform
ALB, Auto Scaling, Batch, Elastic Beanstalk,
CloudFormation, CloudTrail, CloudWatch Events,
CloudWatch Logs, CloudWatch Metrics, ECR, EC2 Spot,
IAM, NLB, Parameter Store, and VPC
Scales to support clusters of any size
Service integrations (like ALB and NLB) are at
container level
1
2
3

EKS
Managed Kubernetes on AWS
Highly available Automated
version upgrades
Integration with
other AWS
services
Etcd
Master
Managed
Kubernetes
control plane
CloudTrail, CloudWatch,
ELB, IAM, VPC,
PrivateLink

AMAZON CONTAINER SERVICES
So you want to run a (managed) container on AWS
Choose your orchestration tool1
Choose your launch type2
ECS EKS
EC2 Fargate EC2 Fargate

FIN, ACK
It’s never been easier to build and launch APIs!
Serverless APIs:
• No management of servers
• Pay for what you use and not for idle resources!
• Instantly scale up without turning any knobs or provisioning any resources
• Tooling to get started in minutes with incredibly minimal code needed
• Built in high availability built into multiple places in the application stack
• Authentication and Authorization built into multiple places in the application stack
InternetMobile/Web
apps
AWS
Databases/
Data stores
API Gateway AWS Lambda
functions

All in Serverless
AWS : YikaiKao@amazon.com
Telegram : YikaiKao
WeChat : YikaiKao
Twitter : @YikaiKao
GitHub Repos

Thank you!

2018 10-19-jc conf-embrace-legacy-java-ee-by-aws-serverless

More Related Content

Similar to 2018 10-19-jc conf-embrace-legacy-java-ee-by-aws-serverless (7)

More from Kim Kao (12)

Recently uploaded (20)

2018 10-19-jc conf-embrace-legacy-java-ee-by-aws-serverless