Cloud Native Development With Quarkus (GOTO masterclass)

May 25, 2023

Cloud Native Development
with Quarkus

Holly Cummins

Red Hat

@holly_cummins

View Slide

hi!

View Slide

@holly_cummins #RedHat
how today works:
08:00: Registration and breakfast
 
09:00: Masterclass starts
 
10:30-10:45: Coffee break
 
12:00-13:00: Lunch
 
14:30-14:45: Coffee break
 
16:00: Masterclass ends

View Slide

how today works:
• Quark-what?

• How to be cloud native

• The test pyramid and beyond

• TDD with Quarkus

• Writing a Quarkus REST application

• Persistence with Hibernate and Panache

• Microservices with Quarkus

• Contract testing

• JWT and Keycloak

• Deciding between native and Java compilation

• Deploying Quarkus apps to Kubernetes

• Troubleshooting + observability

• Q&A + wrap up + retrospective

View Slide

how today works:
• I do

• We do

• You do

View Slide

how today works:
• I do

• We do

• You do
• I talk

View Slide

who are you?
• what’s your name?

• who do you work for?

• what’s your role?

• what’s in your tech stack?

View Slide

background check!
spring boot?

View Slide

https://developers.redhat.com/e-books/quarkus-spring-developers

View Slide

background check!
cdi?

View Slide

background check!

View Slide

background check!
cloud?

View Slide

background check!
cloud?
kubernetes?

View Slide

interest check!
test-driven-development?

View Slide

background check!
quarkus?

View Slide

interest check!
test-driven-development?

View Slide

background check!
reactive?

View Slide

interest check!
reactive?

View Slide

background check!
native?

View Slide

interest check!
native?

View Slide

background check!
quarkus?

View Slide

quark-what?

View Slide

advantages of quarkus?

View Slide

disadvantages of quarkus?

View Slide

$18,000 Sun Sparc App Server Box (4 CPUs, 2GB of RAM)

+ $60,000 BEA Weblogic

+ $92,000 Sun Sparc DB Server Box (8 CPUs)

+ $243,000 Oracle RDBMS

+ $50,000 Symantec Visual Café for 10 developers

--------------------------------------------------

$463,000 (capex) + ~$80,000 annual maint (opex)

Cost of a Java-based Web App circa 1999

View Slide

Historical Enterprise Java Stack
Operating System + Hardware/VM
Java Virtual Machine (Hotspot)
Application Server
App App App App App
Dynamic Application Frameworks
Architecture: Monoliths
 
 
Deployment: multi-app,
 
appserver

App Lifecycle: Months

Memory: 1GB+ RAM

Startup Time: 10s of sec

View Slide

2000
RED HAT
LINUX
2007
KVM
2009
DEVOPS

View Slide

View Slide

Modern Enterprise Java Stack
Application Server
App
Dynamic Application Frameworks
Architecture: Microservices
 
 
Deployment: Single App
 
 
App Lifecycle: Days

Memory: 100 MB + RAM

Startup Time: Seconds
No Change
QUARKUS WORKSHOP

View Slide

Quarkus - Optimizing the Stack
App (Imperative / Reactive)
Optimized Application Frameworks
Architecture: Microservices,
 
Serverless
 
 
Deployment: Single App
 
 
App Lifecycle: Minutes/Days

Memory: 10 MBs + RAM

Startup Time: Milliseconds
Optional
QUARKUS WORKSHOP

View Slide

Source: https://newrelic.com/resources/ebooks/serverless-benchmark-report-aws-lambda-2020
Languages used on AWS Lambda
38%
6%
Node.js
51%
Python
Java

View Slide

View Slide

Designed for
Throughput

View Slide

Designed for
Throughput
At the expense
of footprint

View Slide

View Slide

Designed
to
be
long-running

View Slide

Designed
to
be
long-running At the
expense
of startup
speed

View Slide

View Slide

Rich dynamic behavior
built for mutable
systems

View Slide

Rich dynamic behavior
built for mutable
systems
Yet containers
are primarily
immutable

View Slide

An Open Source

stack to write Java apps
Cloud Native Microservices Serverless

View Slide

Kubernetes-Native Development with Quarkus
Solid Foundation
Java consistently ranks in the Top 3
of programming languages in use
today with a community of 7-10
million developers.
Stunning Performance
Optimized to provide native-level
memory footprint and startup time,
allowing for increased density,
performance and elasticity at lower
cost.
Toolchain
End-to-end toolchain including
OpenShift Developer Console,
Code Ready Workspaces, project
generators in IDE and web, live-
reload for lightning fast inner loop
workflow, and CI/CD integration.
Community
Massive catalog of extensions
connects your applications with best
of breed-technologies including
Camel, Jaeger, Prometheus, Istio,
Kafka and more.

TIOBE : #1

IEEE : #1

SlashData : #2

RedMonk : #2

View Slide

Quarkus Brings Real Developer Joy
A cohesive platform for optimized developer joy:

● Based on standards, but not limited

● Unified configuration

● Reactive & Imperative, all in one

● Zero config, live reload in the blink of an eye

● Streamlined code for the 80% common usages,
flexible for the 20%

● No hassle native executable generation

View Slide

Quarkus + GraalVM

13 MB
Quarkus + OpenJDK

74 MB
Traditional Cloud-Native Stack

140 MB
REST
https://quarkus.io/blog/runtime-performance/
Quarkus Improves Memory Utilization

View Slide

Quarkus Improves Startup Time
Quarkus + GraalVM 0.014 Seconds
REST
REST + CRUD
Quarkus + OpenJDK 0.75 Seconds
Quarkus + GraalVM 0.055 Seconds
Quarkus + OpenJDK 2.5 Seconds
Traditional Cloud-Native Stack 9.5 Seconds
Traditional Cloud-Native Stack 4.3 Seconds
https://quarkus.io/blog/runtime-performance/

View Slide

Quarkus Unifies Imperative and Reactive
● Combines both Reactive and imperative development in the same application

● Reactive Messaging - Apache Kafka, MQTT, AMQP…

● Reactive Services
@Inject
SayService say;
@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return say.hello();
}
@Inject @Stream(”kafka”)
Publisher reactiveSay;
@GET
@Produces(MediaType.SERVER_SENT_EVENTS)
public Publisher stream() {
return reactiveSay;
}

View Slide

Quarkus uses Best of Breed Frameworks & Standards
Eclipse Vert.x Hibernate RESTEasy Apache Camel Eclipse MicroProfile Netty
Kubernetes OpenShift Jaeger Prometheus Apache Kafka Infinispan
Flyway Neo4j MongoDB MQTT KeyCloak Apache Tika

View Slide

40
They load way too many classes
They are way too dynamic / reflective
They perform a lot of initialization at Runtime
What is Wrong with Java Frameworks

View Slide

@ 
@
>
Packaging 
(maven,
gradle…)
Build Time
Runtime
How does a framework start?

View Slide

@ 
@
>
Load and parse config files,
properties, yaml, xml, etc.
Build Time
Runtime

View Slide

@ 
@
>
Classpath scanning and
annotation discovery
Attempt to load class to
enable/disable features
Build Time
Runtime

View Slide

@ 
@
>
Build its metamodel
of the world.
Build Time
Runtime

View Slide

@ 
@
>
Start thread pools,
IO, etc.
Build Time
Runtime

View Slide

Do the work once, not at each start
Get rid of all bootstrap classes
Less time to start, less memory needed
Less or no reflection nor dynamic proxies
What if we Initialize at Build time?

View Slide

@ 
@
>
Build Time

View Slide

@ 
@
>
Runtime
Build Time

View Slide

The Quarkus Way enables Native compilation
Native
@ 
@
>
JV
M
Build Time

View Slide

The Traditional vs. Quarkus Ways
@ 
@
>
Build Time
Runtime

View Slide

@ 
@
>
@ 
@
>
Build Time
Runtime
Build Time

View Slide

@ 
@
>
@ 
@
>
Build Time
Runtime
Runtime
Build Time

View Slide

demo

View Slide

View Slide

a note on the localization

View Slide

https://hollycummins.com/quarkus-workshops/
to the code!

View Slide

how to be cloud native

View Slide

what is cloud native?

View Slide

containers?

View Slide

microservices?

View Slide

Capabilities of a Cloud Native Application Architectures?

The benefits of cloud native application architectures enable speed of development and deployment, flexibility,
quality, and reliability. More importantly, it allows developers to integrate the applications with the latest open source
technologies without a steep learning curve. While there are many ways to build and architect cloud native
applications following are some great ingredients for consideration:

• Runtimes - More likely to be written in the container first or/and Kubernetes native language, which means
runtimes such as Java, Node.js, Go, Python, and Ruby, etc.

• Security - Deploying and maintaining applications in a multi cloud, hybrid cloud application environment, security
becomes of utmost importance and should be part of the environment.

• Observability - The ability to observer applications and their behavior in the cloud. Tools that can give realtime
metrics, and more information about the use e.g., Prometheus, Grafana, Kiali, etc.

• Efficiency - Focused on tiny memory footprint, small artifact size, and fast booting time to make portable
applications across hybrid/multi-cloud platforms. Primarily, it will leverage an expected spice in production via
rapid scaling with consuming minimal computing resources.

• Interoperability - Easy to integrate cloud native apps with the latest open source technologies such as
Infinispan, MicroProfile, Hibernate, Apache Kafka, Jaeger, Prometheus, and more for building standard runtimes
architecture.

• DevOps/DevSecOps - Designed for continuous deployment to production in line with the minimum viable
product (MVP), with security as part of the tooling together with development, automating testing, and
collaboration.

View Slide

Capabilities of a Cloud Native Application Architectures?

The benefits of cloud native application architectures enable speed of development and deployment, flexibility,
quality, and reliability. More importantly, it allows developers to integrate the applications with the latest open source
technologies without a steep learning curve. While there are many ways to build and architect cloud native
applications following are some great ingredients for consideration:

• Runtimes - More likely to be written in the container first or/and Kubernetes native language, which means
runtimes such as Java, Node.js, Go, Python, and Ruby, etc.

• Security - Deploying and maintaining applications in a multi cloud, hybrid cloud application environment, security
becomes of utmost importance and should be part of the environment.

• Observability - The ability to observer applications and their behavior in the cloud. Tools that can give realtime
metrics, and more information about the use e.g., Prometheus, Grafana, Kiali, etc.

• Efficiency - Focused on tiny memory footprint, small artifact size, and fast booting time to make portable
applications across hybrid/multi-cloud platforms. Primarily, it will leverage an expected spice in production via
rapid scaling with consuming minimal computing resources.

• Interoperability - Easy to integrate cloud native apps with the latest open source technologies such as
Infinispan, MicroProfile, Hibernate, Apache Kafka, Jaeger, Prometheus, and more for building standard runtimes
architecture.

• DevOps/DevSecOps - Designed for continuous deployment to production in line with the minimum viable
product (MVP), with security as part of the tooling together with development, automating testing, and
collaboration.
lots of words

View Slide

rapid release cadence

View Slide

independently deployable microservices

View Slide

how do you know if
you’re decoupled?

View Slide

can you deploy
independently? v5.1.4
v5.1.4
v5.1.4
v5.1.4

View Slide

can you deploy
independently? v6.2.8
v65.7
v5.1.4
v1.0.5

View Slide

can you deploy at all?

View Slide

confidence allows releasing

automation allows confidence

View Slide

cloud native is culture, not containers - or runtimes

View Slide

TDD with Quarkus

View Slide

TDD

View Slide

TDD: improves quality

View Slide

TDD: an excellent design tool

View Slide


View Slide

the real reason to do TDD:

View Slide

the real reason to do TDD:
gamified testing

View Slide

the first module has TDD instructions

the rest do not

challenge

in each module, scroll forward, find the tests, and
work backwards.!

View Slide

the test pyramid and beyond

View Slide

the test
pyramid

View Slide

the test
pyramid
(you can TDD
at every level)

View Slide

the test
pyramid

View Slide

the test
pyramid end-to-end tests

View Slide

the test
integration tests

View Slide

the test
unit tests
integration tests

View Slide

the test
unit tests
integration tests
low effort

View Slide

the test
unit tests
integration tests
low effort
high realism

View Slide

the test
unit tests
integration tests
low effort
high realism
high value

View Slide

all models are wrong

some are useful

View Slide

tools
evolve end-to-end tests
unit tests
integration tests
low effort
high realism

View Slide

tools
unit tests
integration tests
low effort
high realism
tests with
application
server

View Slide

tools
unit tests
integration tests
low effort
high realism
tests with
application
server
test REST
endpoints

View Slide

writing a Quarkus REST application

View Slide

https:/
/hollycummins.com/quarkus-workshops/#rest

View Slide

persistence with hibernate and panache

View Slide

79
@Entity
public class Todo extends PanacheEntity {
// id is inherited
public String title;
public boolean completed;
public String url;
@Column(name = "ordering")
public int order;
public static List search(String query) {
return list("completed = ?1 and title like ?2", false, query);
}
public static List findNotCompleted() {
return list("completed", false);
}
public static long deleteCompleted() {
return delete("completed", true);
}
}
Define entity with Panache

View Slide

80
@GET
public List getAll() {
return Todo.listAll(Sort.by("order"));
}
@POST @Transactional
public void addTodo(@Valid Todo todo) {
return todo.persist();
}
@GET @Path("/search/{query}")
public List search(@PathParam("query") @NotBlank String query) {
return Todo.search(query);
}
Accessing entities with Panache
Convenient methods for lazy people
(aka good devs)

View Slide

https:/
/hollycummins.com/quarkus-workshops/#rest-transaction-orm

View Slide

reactive programming

View Slide

quarkus supports both blocking and reactive
• it easier to become blocking on a
reactive core than to become non-
blocking on a blocking core

View Slide

background check!
node.js?

View Slide

Uni
• returning a Uni makes a method non-
blocking*

• a Uni is like a node.js promise

• Unis mix nicely with lamdas for chaining

• you can mix blocking and non-blocking in
an application, but be careful how finely
you mix
* there are limitations - you can get some subtle bugs!

View Slide

https:/
/hollycummins.com/quarkus-workshops/#reactive

View Slide

microservices with Quarkus

View Slide

https:/
/hollycummins.com/quarkus-workshops/#microservices

View Slide

contract testing

View Slide

the limitations of unit tests
“why do my colleagues
tell me my code is
broken, even though my
unit tests all pass?”

View Slide

their code
our code
why unit tests
aren’t enough

View Slide

their code
our code
why mocks
aren’t enough

View Slide

their code
our code
why stubs
aren’t enough

View Slide

our code our mock
why mocks
aren’t enough

View Slide

our code our mock
tests ✔

why mocks
aren’t enough

View Slide

our code our mock
our code their actual code
tests ✔

why mocks
aren’t enough

View Slide

our code our mock
our code their actual code
tests ✔

reality ✘
why mocks
aren’t enough

View Slide

our code their code
why mocks aren’t
enough

View Slide

our code their code
contract test
why mocks aren’t
enough

View Slide

our code their code
contract test
mock
why mocks aren’t
enough

View Slide

our code their code
contract test
mock functional test
why mocks aren’t
enough

View Slide

our code their code
contract test
our tests ✔

their tests ✔

reality ✔

why mocks aren’t
enough

View Slide

our code their code
contract test
why mocks aren’t
enough

View Slide

our code their code
contract test
our tests ✔

their tests ✘

reality ✘

why mocks aren’t
enough

View Slide

our code their code
contract test
why mocks aren’t
enough

View Slide

our code their code
contract test
our tests ✘

their tests ✔

reality ✘

why mocks aren’t
enough

View Slide


View Slide

contract-first is a great way to TDD

View Slide

contract-first is a great way to TDD
(and a great design tool)

View Slide

#RedHat
@holly_cummins
• consumer-driven contract testing can save your bacon

• pact is a mock for the consumer

• pact is a functional test for the producer

• shared json contracts aligns expectations across
services

View Slide

pitfalls of contract testing:

• we have to talk to the other team

• our consumers can break our CI?!

• versions

• pact is hard to grok

• testing the mock

• but I’ve invested in wiremock

• duplicated tests is overhead

View Slide

contract testing options:

• pact.io

• spring contract

• OpenAPI schema validation + mock generation

• prism

• schemathesis

View Slide

pact can exercise

• input parameters

• state

View Slide

the story of the 204

View Slide

https:/
/hollycummins.com/quarkus-workshops/#contract-testing

View Slide

deciding between native and java compilation

View Slide

use case for native

• low workload (so throughput isn’t the
bottleneck)

• resource-constrained or old hardware
(especially memory)

• high re-deploy rate (applications never
get warmed up before being spun down)

• serverless (of course)
 
use case for JVM

• high workload (you need lots of
throughput)

• long-lived processes (the rapid start of
native doesn’t save you much over the
lifetime)

• stable workload or very little elasticity in
underlying orchestration
is native better?

View Slide

is there a sustainability aspect?
yes … and it’s just as depend-y!

optimising

• cost

• application performance

will also be optimising carbon

View Slide

native vs JVM is not an either-or
• consider hybrid
deployment models

• a strength of Quarkus is
application code is the
same for native and JVM

View Slide

deploying Quarkus apps to Kubernetes

View Slide

• Kubernetes extension

• uses dekorate under the covers

• OpenShiftExtension

• s2i

View Slide

… so in conclusion

View Slide

what did we all think?

View Slide

Customers using Quarkus Today
“We could run 3 times
denser deployments
without sacrificing
availability and
response times of
service”
“When you adopt
Quarkus, you will be
productive from day
one since you don’t
really need to learn
new technologies.”
“Quarkus seemed to
provide the performance
boost we needed while
at the same time having
a good backer (Red Hat)
and relying on battle-
tested technologies”
Thorsten Pohl

Lufthansa Technik AVIATAR
Product Owner Automation &
Platform Architect
Roberto Cortez

Talkdesk Principal Architect
Christos Sotiriou

DXL technical lead at Vodafone Greece

View Slide

https:/
/delawen.com/2022/07/bungee-jumping-into-quarkus/
the gotchas

View Slide


View Slide

Continue your Journey
code.quarkus.io
red.ht/try-quarkus
red.ht/idc-quarkus-study

View Slide

thank you

@holly_cummins
https://hollycummins.com/cloud-native-quarkus-workshop-goto-aarhus/

View Slide

Cloud Native Development With Quarkus (GOTO masterclass)

Cloud Native Development With Quarkus (GOTO masterclass)

Holly Cummins

More Decks by Holly Cummins

Other Decks in Programming

Featured

Transcript