Characteristics and considerations for developing and deploying cloud-native Java microservices. Presented at Devnexus 2019

1. 1
Are you ready for Cloud-Native Java?
Graham Charters - @gcharters
Steve Poole - @spoole167
1

2. 2
Who we are
Steve Poole
@spoole167

3. 3
Quiz
You’ve been deploying Java applications for years and want to move to
a cloud-native approach. Do you?
a. Decide cloud-native is so different you should throw out everything you
know and have done and start over again.
b. Decide cloud-native is just a “storm-in-a-teacup” and hunker down till the
clouds have passed.
c. Understand how modern Java runtimes let you re-use and extend what
you have in order to create new cloud-native applications.

4. 4
What’s special about Cloud?
4

5. What ‘Cloud’
promises
a virtual, dynamic environment
which maximizes use, is infinitely
scalable, always available and
needs minimal upfront
investment or commitment
Take your code – host it on someone else's
machine and pay only for the resource you
use for the time you use it
AND be able to do that very quickly and
repeatedly in parallel

6. https://www.flickr.com/photos/vuhung/
“Compute on demand” – it’s what we’ve always wanted

7. Cloud computing:
compute == money
Money changes everything
With a measurable and direct relationship
between $£€¥ and CPU/RAM, disk etc the
financial success or failure of a project is
even easier to see
And that means…
Even more focus on value for money.

8. compute == money
$ == GB/hr
-Xmx: $100

9. Demand
time

10. Demand
time
How does your application respond to demand?

11. Demand
time
One big server running all the time?

12. Demand
time
One big server running all the time?Look at all that wasted money!

13. Demand
Smaller compute units are better

14. Demand
time
Smaller compute units are better

15. Time
Memory
Traditional profile
Throughput

16. Time
Lag Over-Peek usage
Doesn’t fit new model
Costs $ Costs
more $
Memory
Throughput

17. Time
More like this please
Memory
Throughput

18. Cloud demands:
• Small runtime memory footprint
• Small deployment sizes
• Fast starting applications
• No resource usage when idle

19. Can we do this all with a JVM?

20. 20
Quiz
Is Cloud so different that the JVM is no longer relevant?
a. Yes - lets move everything to Node.js.
b. Maybe – even re-tuning the JVM isn’t going to cut it.
c. No – Not all JVMs are the same…

21. http://www.eclipse.org/openj9
https://github.com/eclipse/openj9
Dual License:
Eclipse Public License v2.0
Apache 2.0
Users and contributors very welcome
https://github.com/eclipse/openj9/blob/master/CONTRIBUTING.md
Eclipse OpenJ9
Created Sept 2017

22. 22 https://adoptopenjdk.net/?variant=openjdk8-openj9

23. 23 https://hub.docker.com/r/adoptopenjdk/

24. 24
Java ME Inside!

25. 25
Java ME requirements
 Small footprint
–On disk and runtime.
–Very limited RAM, usually more ROM
 Fast startup
–Everybody wants their games to start quickly
 Quick / immediate rampup
–Your game should not play better the longer you play

26. 26
Java in the Cloud requirements
 Small footprint
–Improves density for providers
–Improves cost for applications
 Fast startup
–Faster scaling for increased demand
 Quick / immediate rampup
–GB/hr is key, if you run for less time you pay less money

27. 27
Results
Hotspot OpenJ9 OpenJ9 -Xshareclasses -
Xquickstart
Hotspot OpenJ9 OpenJ9 -Xshareclasses -Xquickstart
Startup time is 30% faster with OpenJ9 –Xshareclasses -Xquickstart

28. 28
Results
Footprint is 60% smaller with OpenJ9
Hotspot OpenJ9 OpenJ9 -Xshareclasses -
Xquickstart
Hotspot OpenJ9 OpenJ9 -Xshareclasses -Xquickstart

29. Time
Remember this?
Memory

30. Time
Real data
OpenJDK 9
with Hotspot

31. Time
Real data
OpenJDK 9
with Hotspot
OpenJDK 9
with OpenJ9

32. Time
Real data
OpenJDK 9
with Hotspot
OpenJDK 9
with OpenJ9
OpenJDK 9
with OpenJ9
+ AOT

33. Eclipse
Open J9
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.
@spoole167

34. http://www.eclipse.org/openj9
https://github.com/eclipse/openj9
Dual License:
Eclipse Public License v2.0
Apache 2.0
Users and contributors very welcome
https://github.com/eclipse/openj9/blob/master/CONTRIBUTING.md
Eclipse OpenJ9
Created Sept 2017

35. Don’t just
take my word
for it
@spoole167
adoptopenjdk.net

36. 36
Quiz
Cloud-Native Java. Are we done then?
a. Yes - nothing to see. Move along.
b. Not really – still need to re-architect my application
c. No – actually Cloud-Native introduces some new challenges

37. 3737
What you run can outweigh
the JVM benefits

38. 38
Agile & DevOps & Cloud & Microservices
+ + + service C
service B
service A

39. 39
Middle-aged spread
https://www.slideshare.net/delabassee/java-ee-8-february-2017-update
https://medium.com/@alextheedom/java-ee-past-present-future-8bf25df7b6a3

40. 40
Liberty Features
<dependency>
<groupId>io.openliberty.features</groupId>
<artifactId>jaxrs-2.1</artifactId>
<type>esa</type>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>io.openliberty.features</groupId>
<artifactId>jsonb-1.0</artifactId>
<type>esa</type>
<scope>provided</scope>
</dependency>

41. 41
Thorntail Fractions
<dependency>
<groupId>io.thorntail</groupId>
<artifactId>thorntail-jaxrs</artifactId>
</dependency>
<dependency>
<groupId>io.thorntail</groupId>
<artifactId>thorntail-jsonp</artifactId>
</dependency>

42. 4242
Not all cloud-native challenges can be
solved by the runtime

43. 4343

44. 44
There’s a good chance you’ll use REST APIs.

45. 45
JAX-RS
B
@Path("/brews")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class BrewsResource {
@POST
public Response startCoffeeBrew(CoffeeBrew brew) {...)
}

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

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

48. 48
JSON-B & JSON-P
A B
...
@POST
@Consumes(MediaType.APPLICATION_JSON)
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;
}
}

49. 49
Handling 100s of collaborating and frequently
evolving services requires new APIs

50. 50
Where were we...?
A B

51. 51
MicroProfile
OpenAPI
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

52. 52
MicroProfile JWT
A B
@POST
@RolesAllowed({ "admin", "coffee-shop" })
public Response startCoffeeBrew(CoffeeBrew brew) {...}

53. 53
MicroProfile 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);
...
}

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

55. 55
Handling 100s of collaborating services
requires a strong operations focus

56. 56
Where were we...?
A B

57. 57
MicroProfile Health
A B
@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();
}
}
{
"checks": [
{
"data": {
"barista service": "available"
},
"name": "CoffeeShopHealth",
"state": "UP"
}
],
"outcome": "UP"
}

58. 58
MicroProfile 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) {
...
}

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

60. 60
Eclipse MicroProfile
Open specifications
Wide vendor support
REST services
OpenAPI support
Security
Fault Tolerance
Configuration
Metrics
Health
Open Tracing

61. 61
Quiz
A team wants to use your service and has asked you to document it.
Do you?
a. See it as an opportunity to try out that Asciidoc thing you heard about at a
conference.
b. Suggest they fire a few REST requests at it. With an infinite number of
monkeys, they’ll get there eventually.
c. Use the OpenAPI Java support because it documents your API with little to
no effort.

62. 62
Quiz
You’re deploying microservices that depend on other teams’ services
and have noticed occasional errors from them which cause your
service to fail. Do you?
a. Blame the other team every time your service fails. They need to sort their
act out!
b. Hold firm, you trust that they’ll fix all the problems eventually then
everything will be fine.
c. Take responsibility for gracefully coping with instabilities in the services
you depend on.
d. a & c

63. 63
Quiz
You’re about to be the proud owner of a live production microservice.
You like your weekends and want to minimize the time spent resolving
issues. Do you?
a. Decide it’s a no-op due to encapsulation. The great thing about
microservices is you never need to know what’s going on inside.
b. Write everything to stdout. Factor XI of 12factor.net tells you that’s all you
need to do.
c. Instrument your service for health and metrics and use open tracing to
track request flows.

64. 64
Can’t I do all this with a service mesh?

65. 65
Istio Fault Tolerance
A B
Fallback
Retry
Timeout
Circuit Breaker
Bulkhead

66. 6666
Packaging for deployment

67. 67
You’d be hard-pushed to find a cloud that
doesn’t support Docker

68. 68
Making the most of Docker
O/S
JVM
Libs/Server
Application
O/S
JVM
Application
thin war/jar fat jar
Libs/Server

69. 69
Being ready for cloud-native Java
• Open standards-based with wide
open source vendor support?
• JVM Optimized for the cloud
• Application framework designed
for cloud-native Microservices

70. 70
Final Quiz – Are you ready for cloud-native Java?
You’re boss asks you to recommend an open technology stack for
developing and deploying cloud-native microservice applications. Do
you?
a. Recommend Eclipse OpenJ9 to optimise your runtime characteristics and
costs for the cloud
b. Recommend Eclipse MicroProfile to add resilience, monitorability, security,
and more, in a vendor neutral way
c. Recommend a right-sizable runtime with broad open spec support (e.g.
Open Liberty :D ) to optimize your deployments for the cloud
d. All of the above.

71. 71
Calculating...

72. 72
Congratulations, you are now ready for cloud-native Java
Passed

73. 73
Useful Links
• https://www.eclipse.org/openj9/
• https://adoptopenjdk.net/
• https://adoptopenjdk.net/?variant=openjdk8&jvmVariant=openj9
• https://microprofile.io/
• https://github.com/gcharters/workshop-cloud-native-java
• https://openliberty.io/guides/
73

74. 74
Thank You

75. 75
Useful Links
• OpenJ9 - http://www.eclipse.org/openj9/
• AdoptOpenJDK OpenJ9 Builds: https://adoptopenjdk.net/?variant=openjdk8&jvmVariant=openj9
• MicroProfile: http://microprofile.io/
• Eclipse MicroProfile Site: https://projects.eclipse.org/projects/technology.microprofile
• MicroProfile Guides: https://openliberty.io/guides/?search=MicroProfile
• Open Liberty: https://openliberty.io/
75

76. 76
The End
76