Hands-on Cloud-native Java with MicroProfile, Kubernetes and OpenShift

Hands-on Cloud-native
Java with
MicroProfile,
Kubernetes and
OpenShift
Jamie L Coleman
Software Engineer/Developer Advocate
Twitter: @Jamie_Lee_C
Email: JLColeman@uk.ibm.com

Contents
GIDS Java / Sept 9th, 2020 / © 2020 IBM Corporation 2
Workshop 03
The modules 04
The Environment 06
Why move to the Cloud? 08
What the Cloud offers 12
Microservices 13
Eclipse MicroProfile 14
Contributors 16
Community 17
Vendors/Implementations 20
MicroProfile Technologies 21
MicroProfile Stack 22
MicroProfile Core Technologies 34
A Full Open Stack 35
Open Liberty Overview 37
Open J9 Overview 41
Containers & Testing 43
Docker 47
Testing with Containers 49
Kubernetes & OpenShift
Kubernetes 53
MicroProfile and Kubernetes 59
OpenShift Overview

Workshop Modules
8 Modules each between 15 – 25 mins
long.
1. Creating RESTful Web Services
2. Injecting dependencies into a Java
microservices
3. Configuring Java microservices
4. Building fault-tolerant
microservices with the @fallback
annotation
5. Containerizing Microservices
6. Introduction to MicroShed Testing
7. Deploying MicroServices to
Kubernetes
8. Building and deploying a RESTful
web service on OpenShift 4.x

Additional Workshop Modules
3 Modules each between 15 – 25 mins
long on reactive Java Programming.
1. Creating reactive microservices
using MicroProfile Reactive
Messaging
2. Testing reactive Java microservices
3. Building and deploying Reactive
Java microservices on OpenShift 4.x

Skills Network Labs

Why move to the
Cloud and what is
Cloud-Native?
8

What the Cloud offers
Demand
time
One big server running all the time?

Demand
time

Agile, Microservices,
DevOps & Cloud
+ +C
B
A
+

Microservices
A microservice is an architectural style that
structures an application as a collection of
loosely coupled services
The benefit of having an application made
up of microservices is that it improves
modularity and make it easier to develop,
test and more resilient to changes
Allows teams to work on individual
services
Enables continuous delivery and
deployment per microservice

What is MicroProfile?
● Eclipse MicroProfile is an open-source
community specification for Enterprise Java
microservices
● A community of individuals, organizations, and
vendors collaborating within an open source
(Eclipse) project to bring microservices to the
Enterprise Java community
microprofile.io

MicroProfile
Contributors

MicroProfile Community
● Over a dozen vendors and Java user groups
● 140 individual contributors
● Over half a dozen independent
implementations

Locations of some
MicroProfile
Contributors
18
GIDS Java / Sept 9th, 2020 / © 2020 IBM Corporation
Seattle – USA
Ontario – Canada
Canberra – Australia
Stuttgart – Germany
Rochester – USA
Prague – Czech Rep
Newcastle – UK
Munich – Germany
Paris – France
Hursley – UK
Centurion – South Africa
Boston – USA
Sao Paulo – Brazil
Rio de Janeiro – Brazil
Coimbra – Portugal
Amsterdam – Netherlands
Source: MicroProfile.io

MicroProfile Community
Video HangoutsBi-Weekly & Quarterly
General community
Meetings
MicroProfile ProjectsGoogle Groups
YouTube Channel

MicroProfile
Vendors/Implementations

MicroProfile 3.3 Stack
JSON-B 1.0JSON-P 1.1CDI 2.0
Config 1.4
Fault
Tolerance 2.1
JWT
Propagation
1.1
Health
Check 2.2
Metrics 2.3
Open Tracing
1.3
Open API 1.1
JAX-RS 2.1
Rest Client
1.4

MicroProfile Core
Technologies
23 GIDS Java / Sept 9th, 2020 / © 2020 IBM Corporation
B
@Path("/brews")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class BrewsResource {
@POST
public Response startCoffeeBrew(CoffeeBrew brew) {...)
}
JAX-RS

MicroProfile Core
Technologies
REST Client
BA
@RegisterRestClient
@Path("/resources/brews")
@Produces(MediaType.APPLICATION_JSON)
public interface BaristaClient {
@POST
public Response startCoffeeBrew(CoffeeBrew brew);
}

MicroProfile Core
Technologies
CDI
BA
@Path("/orders")
public class OrdersResource {
@Inject
CoffeeShop coffeeShop;
...
}

MicroProfile Core
Technologies
JSON-B & JSON-P
A B
...
@POST
public Response startCoffeeBrew(CoffeeBrew brew) {
CoffeeType coffeeType = brew.getType();
...
}
public class CoffeeBrew {
private CoffeeType type;
public CoffeeType getType() {
return type;
}
public void setType(CoffeeType type) {
this.type = type;
}
}

MicroProfile Core
Technologies
Open API
A B
openapi: 3.0.0
info:
title: Deployed APIs
version: 1.0.0
servers:
- url: http://grahams-mbp-2.lan:9081/barista
paths:
/resources/brews:
post:
operationId: startCoffeeBrew
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/CoffeeBrew'
responses:
default:
description: default response
components:
schemas:
CoffeeBrew:
type: object
properties:
type:
type: string
enum:
- ESPRESSO
- LATTE
- POUR_OVER

MicroProfile Core
Technologies
JWT
@POST
@RolesAllowed({ "admin", "coffee-shop" })
public Response startCoffeeBrew(CoffeeBrew brew) {...}
BA

MicroProfile Core
Technologies
Fault
Tolerance
A B
@Retry(retryOn = TimeoutException.class,
maxRetries = 4,
maxDuration = 10,
durationUnit = ChronoUnit.SECONDS)
public void startCoffeeBrew(CoffeeBrew brew) {
Response response = baristaClient.startCoffeeBrew(brew);
...
}

MicroProfile Core
Technologies
Config
A B
@ApplicationScoped
public class Barista {
@Inject
@ConfigProperty(name="default_barista_base_url")
String baristaBaseURL;
...
}

MicroProfile Core
Technologies
Health
A B
{
"checks": [
{
"data": {
"barista service": "available"
},
"name": "CoffeeShopHealth",
"state": "UP"
}
],
"outcome": "UP"
}
@Health
@ApplicationScoped
public class HealthResource implements HealthCheck {
...
public boolean isHealthy() {...}
@Override
public HealthCheckResponse call() {
if (!isHealthy()) {
return HealthCheckResponse.named(...).down().build();
}
return HealthCheckResponse.named(...).up().build();
}
}

MicroProfile Core
Technologies
Metrics
A B
@POST
@Counted(name="order", displayName="Order count",
description="Number of times orders requested.", monotonic=true)
public Response orderCoffee(@Valid @NotNull CoffeeOrder order) {
...
}

MicroProfile Core
Technologies
Open Tracing
A B
@Traced
public void startBrew(CoffeeType coffeeType) {
...
}
JAX-RS methods
are automatically
traced by default

MicroProfile 3.3 Stack
Reactive
Streams
Operators 1.1
Reactive
Messaging
1.0
GraphQL 1.0
Context
Propagation
1.0
Standalone Projects
Config 1.4
Fault
Tolerance 2.1
JWT
Propagation
1.1
Health
Check 2.2
Metrics 2.3
Open Tracing
1.3
Open API 1.1
JAX-RS 2.1
Rest Client
1.4

A Full Open Stack
MicroProfile
Open Liberty
OpenJ9
OpenShift

Open Liberty Overview

Focus on code
Easy to make fast and iterative changes
Easy to write tests
True-to-production testing (as much as possible)
Ready for containers
Not-in-your-way tools and flexibility
Open Liberty Overview

Developer
Experience: dev
mode
Boosts developer productivity
Immediate feedback for code and config changes
No re-build necessary
mvn liberty:dev

Developer-oriented Docs

0
0.5
1
1.5
2
2.5
December '18 March '19 April '19 July '19 August '19 September '19 April '20
2018-2020 Progression of OpenLiberty+OpenJ9 startup time (seconds)
42
Open Liberty with OpenJ9: the road to one second startup time
OpenJ9 : Improved Cached feature metadata when no change to server.xml Changed bundle activation to start in parallel
Better AOT code RAS processing Optimized loading of CXF JSON/JSONB provider RAS annotation processing at build time
JMX MBeanServer init Cached annotation information for built-in JAX-RS Providers Cached plugin xml and OSGi metadata
OpenJ9 : GC hints in shared classes cache Reduced class loading during startup
Reduced logging overhead
OpenJ9 : More AOT code in shared classes cache
OpenJ9 : Optimize class verification overhead

Open Liberty startup time comparison (using OpenJ9 JVM)
43
0
1
2
3
4
5
6
7
8
Open Liberty 20.0.0.4 TomEE 8.0.0-M3-
microprofile
Tomcat 9.0.22 +
OpenWebBeans
2.0.11(CDI) + CXF
3.3.2 (jaxrs)
Wildfly 17.0.1 javaee JBoss 7.2 Glassfish web 5 Payara web 5.192
PingPerf application startup time with OpenJ9 Shared Classes Cache (in seconds)

Open J9 Overview
Designed from the start to span all the
operating systems needed by IBM products
This JVM can go from small to large
Can handle constrained environments or
memory rich ones
Is used by the largest enterprises on the
planet
If any JVM can be said to be at the heart of
the enterprise – its this one.

45
Time To Code
To get started visit the following URL in your browser:
ibm.biz/cloud-native-java
Or
https://ide.skillsnetwork.site/cloud-native-java-with-microprofile-kubernetes-and-openshift
Please run the cleanup.sh script from the terminal at the end of each
lab to clean up your environment.

Workshop Part 1:
Fast Iterative
Development
46

Containers &
Testing with Containers
47

MicroProfile &
Containers
Containers Kubernetes OpenShift
Config 1.4
Fault
Tolerance 2.1
JWT
Propagation
1.1
Health
Check 2.2
Metrics 2.3
Open Tracing
1.3
Open API 1.1
JAX-RS 2.1
Rest Client
1.4

Containers
build, ship and run any app,
anywhere
docker build -t ol-runtime --no-cache=true .
docker run -d --name rest-app -p 9080:9080 -p
9443:9443 -v <absolute path to
guide>/start/target/liberty/wlp/usr/servers:/servers
ol-runtime

my-app:latest
(app container)
mongo:4.0
(DB container)
Dev/Test env
Production env
integration
tests
end users
my-app:latest
(app container)
mongo:4.0
(DB container)
Testcontainers
• Integration tests that are
easy to setup, write, and run
• Test your apps the same
way they run in production
• Tests are portable to any
compatible implementation:
• Liberty
• Wildfly
• Payara
• TomEE
• etc…

MicroShed Testing
• Integration tests that are easy to setup, write,
and run
• Test your apps the same way they run in
production...in Containers
• Can run multiple containers on same network
(e.g. test DB integration)
• http://microshed.org/microshed-testing/
@MicroShedTest
public class MyTest {
// Search for Dockerfile.
// Start app in Container.
// Wait for Container before running tests.
@Container
public static MicroProfileApplication app
= new MicroProfileApplication()
.withAppContextRoot("/myservice")
;
// Inject JAX-RS REST Client
@Inject
public static MyService mySvc;
// A test method like any other
@Test
public void testMyService() {
...
}
}

Workshop Part 2:
Containers &
Testing with Containers
52

Deploying to the Cloud
with Kubernetes &
OpenShift
53

Regain control with Kubernetes
Organize and govern the container chaos
Kubernetes
Intelligent
Scheduling
Self-HealingHorizontal
Scaling
Automated
Rollouts &
Rollbacks
Secret &
Configuration
Management
Service Discovery &
Load Balancing

Kubernetes

MicroProfile with Kubernetes
Config
A B
env:
- name: GREETING
valueFrom:
configMapKeyRef:
name: greeting-
config
key: message
kubectl create configmap greeting-config --from-literal
message=Greetings...
@Inject
@ConfigProperty(name =
"GREETING")
private String greeting;

MicroProfile with Kubernetes
Health
A B
readinessProbe:
httpGet:
path: /health
port: 9080
initialDelaySeconds:
15
periodSeconds: 5
failureThreshold: 1

Why should developers care about
DevOps?
• Enables the delivery of innovation more often
• Improves quality
• Reduces toil to allow developers to focus on code
• Improves confidence
• Improves time to production
• Improves communication and collaboration

OpenShift is a Kubernetes-based platform
with added functions. It streamlines the
DevOps process by providing an intuitive
development pipeline. It also provides
integration with multiple tools to make the
deployment and management of cloud
applications easier.

IDE integration - With OpenShift's
integration with Eclipse, JBoss
Developer Studio, and Visual
Studio developers can stay entirely
within the IDE that they prefer when
working with OpenShift.

63
OpenShift and the
Hybrid Model

Workshop Part 3:
Deploying To The Cloud
With Kubernetes &
OpenShift
64

65
Recap
MicroProfile
• No vendor lock in
• Full set of cloud ready APIs
• Config
• Health
• Metrics
• Fault Tolerance
• …
• Big community
Open Liberty
• Modular Application server
• Light weight
• Easy to configure
• Jakarta EE 8 certified
• Production ready
• Official Docker images available
• Optimized for development
All Open Source!
Open J9
• Low memory footprint
• Fast startup time
• High application throughput
• Smoother ramp-up in the cloud
• Easy to use Docker images
OpenShift
• Works on all clouds
• Uses Containers for easy portability
• Can run on Private and Public
Clouds
• Integration with IDE’s to make
developers lives easier.

Thank you
66
Jamie Lee Coleman
Software Engineer/Advocate Team Lead
Email: jlcoleman@uk.ibm.com
Twitter: @Jamie_Lee_C

Hands-on Cloud-native Java with MicroProfile, Kubernetes and OpenShift

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Hands-on Cloud-native Java with MicroProfile, Kubernetes and OpenShift

Similar to Hands-on Cloud-native Java with MicroProfile, Kubernetes and OpenShift (20)

More from Jamie Coleman

More from Jamie Coleman (18)

Recently uploaded

Recently uploaded (20)

Hands-on Cloud-native Java with MicroProfile, Kubernetes and OpenShift

Editor's Notes