►
From YouTube: A Comparative Review of Microservice Frameworks
Description
In this session we will compare some of the most popular Microservice frameworks in the Java ecosystem like SpringBoot, Quarkus, Eclipse MicroProfile, and more. We will give an overview and jumpstart for each framework. Next to this we will answer questions like:
Which features do provide all of them, what are their unique selling points?
How do I start writing microservices with the different frameworks?
Which technology stack do the different frameworks use?
How do they perform in regards to startup time, and responding with different response sizes?
How large are the resulting application containers in Docker?
Slides (External URL):
https://speakerdeck.com/hendrikebbers/a-comparative-review-of-microservice-frameworks
Speaker(s):
Karsten Thoms (Karakun AG)
Hendrik Ebbers (Karakun AG)
A
Hello
and
welcome
to
our
framework,
a
tech
talk,
a
comparison
of
microservice
frameworks
in
java,
yeah,
I'm
hendrik
abbas.
I
work
at
a
company
that
is
called
carracoon,
I'm
the
co-founder
of
that
company
and
I
do
a
lot
of
java
related
things
so
I've
the
founder
of
the
java
user
group
here
in
in
dortmund
in
germany,
which
is
my
hometown.
A
B
Hi,
I'm
carsten,
I'm
a
colleague
of
henrik
working
also
for
caracoon.
I
live
also
in
dortmund
and
yeah,
I'm
quite
involved
in
eclipse
projects.
I'm
part
of
the
eclipse
platform
team
and
I
work
also
for
eclipse
x,
text
and
yeah
contribute
to
a
couple
of
other
frameworks
and
yeah,
and
today
we
want
to
talk
with
you
a
little
bit
about
microservice
frameworks
in
java.
B
B
B
A
Yeah
so,
let's
start
with
the
first
topic
and
let's
have
a
general
look
at
micro
services
and
what
micro
microservices
are
so
in
general,
a
microservice
can
be
more
or
less
everything
right.
It
can
can
do
several
things.
It
can
be
event-based,
it
does
event
streams
and
so
on
what
we
did
for
our
talk.
We
had
a
look
at:
let's
call
it
classical
microservice,
which
is
a
microservice
that,
on
the
one
hand,
has
some
some
input
channels.
A
Normally
they
they
are
west-based
where,
for
example,
the
client
or
another
service
can
communicate
within
the
microservice
and
on
the
other
hand
the
microservice
provides
some
some
data
that
are
coming,
for
example,
from
from
a
sql
database.
So
this
is
how
the
microservice
might
hook
like.
So
it's
a
small
service
that
has
one
xpc
feature
that
is
implemented
by
this
service
in
this
case,
providing
data
that
is
coming
from
a
database
to
a
west
end
point.
A
There
can
be
other
things
other
functionalities,
but
this
is
a
general
one
and
when
having
a
look
at
such
services,
they
are
not
really
depend
on
java,
so
in
general
you
can.
Since
we
concentrate
on
java
today,
you
can
create
microservices
with
more
or
less
any
programming
language
that
that
you
want
to
use
okay.
Maybe
there
are
some
old
ones
like,
for
example,
cobol
that
you
yeah,
you
know
you
cannot
really
use
to
create
micro
services.
A
That
is
what
I
thought
before
I
started
to
to
work
on
this
session.
So
this
is
the
first
lesson
of
this
session.
Never
underestimate
the
power
of
the
internet.
You
will
find
everything
in
the
internet,
even
people
that
use
cobalt
to
write
microservices
okay
anyway,
but
let's
have
a
look.
What
a
microservice
should
do
and
I
hand
over
to
carsten
for
that
one.
B
B
We
expect
that
we
have
typically
the
possibility
to
call
rest
services
that
that's
the
use
case
that
we
that
we
focused
on,
but
this
doesn't
mean
that
everything
there's
a
couple
of
other
kind
of
microservices
that
use
event-based
systems
like
on
kafka
or
mqtt,
or
even
serverless,
so
just
functions.
Typically,
you
want
to
access
some
kind
of
data
storage,
be
it
relational
or
non-relational.
B
B
So
now,
let's
look
at
our
competitors
and
first
competitors
on
the
caucus
framework.
Quackers
is
on
the
newest
candy
date
on
our
list.
It's
actually
just
two
years
old,
yeah,
crafted
by
red
hat
and
makes
corkers
quite
special
is
that
it
comes
with
a
grav
vm
support
out
of
the
box,
and
it
is
based
on
a
couple
of
standard
ike.
Some
are
from
microprofile,
which
is
our
next
competitor
and
a
little
bit
special.
So
we
have.
B
We
have
some
numbers
here
to
our
candidates
and
microprofile
is
always
very
low,
but
that's
because
the
micro
profile
is
just
for
itself.
It's
more
specification,
and,
and
this
specification
is
quite
some-
vendors,
like
jara,
tommy
and
so
on,
and
those
provide
the
implementations
for
the
frameworks
that
are
actually
compiled
to
the
mic.
B
A
Yeah,
so
oh
where's,
my
focus
here
so
the
next
one
is
the
one
that
maybe
all
of
you
know,
which
is
spring
boot.
It's
quite
the
oldest
of
the
frameworks
that
we
will
have
a
look
at.
It
was
first
released
in
2030
and
the
owner
of
spring
spring
boot
is
pivotal
and
yeah,
as
you
can
see
in
the
elevator
pitch.
A
So
it's
quite
new
and
here's.
The
special
things
about
a
micro
node
are
that
it's
provide
a
non-blocking
and
reactive
framework
that
is
perfectly
to
create
micro
services
and
even
server
guest
functions,
and
next
to
this
micro
node
already
provides
a
quite
good
cribrium
support,
as
we
will
see
later.
Okay.
A
You
can
choose
if
you
want
to
use
maven
or
if
you
want
to
use
gravel
to
build
your
application-
and
you
can
already
add
extensions
like
when
talking
about
spring,
for
example,
spring
data
jpa
to
directly
access
a
jpa
by
using
jpa
a
database
and
a
lot
of
other
extensions.
So
this
can
be
done
by
the
initializers
and
by
using
those
you
will
can
or
you
can
download
your
project
or
a
template
for
your
project
that
you
can
easily
import
in
any
ide
and
directly
start
with
your
micro
service
project
or
application.
B
That's
not
a
timeline.
We
looked
three
years
back
how
the
projects
evolved,
henrik
and
here
from
springboot.
We
can
see
that
it
has
already
long
live
and
releases
that
are
maintained.
So
here
we
have
support
for
the
framework,
as
said
actually,
because
we
don't
have
the
framework
itself
specs
handmake.
B
Can
you
advance,
so
we
have
at
certain
point
of
times
that
the
my
project
compiles
a
set
of
specs
to
those
frameworks
and
that
were
version
three
and
so
on.
Let's
have
a
look
at
quakers
on
the
quarker
side,
a
micronut,
sorry
micronut
is
a
typical
yeah
framework,
which
just
maintains
the
current
version
and
advances
and
releases
water
and
and
for
quakers.
B
B
Source
code
not
much
and
not,
basically,
we
have
some
rest
resource
which
provides
yeah,
which
is
our
endpoint,
and
we
expect,
for
example,
that
objects
are
automatically
converted
to
json
thanks
to
jsonp
or
whatever
is
behind
that.
Let's
have
a
look:
quarkx
solves
this
quarkx
and
microprofile.
You
use
the
jux
rs
standard
to
annotate
our
resources
and
methods
and
parameters,
and
if
we
look
at
boot,
this
looks
slightly
different.
B
B
This
is
specific
to
spring,
which
are
to
also
understand
spring
annotations,
and,
let's
have
a
final
look
at
micronode,
surprise
looks
only
the
names
are
different,
but
yeah
we
are
here
in
this
example.
We
also
see
how
we,
how
micro
node
supports
reactive
programming
with
rx
java
so
analytic,
and
do
you
take
over
to
data.
A
Access
yeah,
the
next
example
we
will
have
a
look
at
is
how
to
to
work
with
a
database.
So
in
general
we
could
have
a
look
at
much
more
functionalities
that
can
be
in
microservice,
but
as
said,
we
only
have
half
an
hour,
so
we
we
only
have
a
look
at
those
two
functionalities
and
how
they
are
can
be
implemented
by
the
framework.
So
the
second
one
is
database
access
and
here
all
four
frameworks
that
we
want
to
have
a
look
at
use
more
or
less
the
same
pattern,
which
is
the
repository
pattern.
A
A
Same
for
micro
node
here
we
see
it's
more
or
less
the
same
as
we've
seen
in
spring
boot.
It's
another
api.
So
this
is
the
data
api
firm
from
micro
node,
but
they
use
the
repository
pattern
2,
and
here
you
only
need
to
provide
an
interface
too
a
little
bit
different.
Is
it
when,
when
you
have
a
look
at
micro
profile,
because
micro
profile
is
based
on
basic
jpa
or
brain
jpa,
so
here
you
only
have
the
jpa
api,
which
allows
you
easily
to
create
repositories
by
using
the
repository
pattern.
A
A
B
B
Vertex
actually
is
under
the
hood
of
quarkx
again
and
helidone
from
oracle
is
even
provided
in
two
versions.
One
of
them
is
a
micro
profile
implementation.
I
read
today
on
that.
They
now
support
the
latest
micro
profile
version
3.3
and
actually
it's
not
really
even
defined.
What
makes
a
microservice
framework.
Even
when
you
look
at
lists
of
microservices
frameworks
in
java,
then
you
will
see
also
things
like
jersey
or
rest
easy,
which
are
not
really
microservices,
but
a
part
of
microservice
frameworks.
B
A
I
don't
know
six
years
something
like
that
and
that
really
helps
you
to
provide
such
functionality,
and
this
is
the
container
functionality
in
this
case,
especially
docker
as
a
tool
that
helps
you
to
create
containers
out
of
your
application
and
what
we
did
for
the
different
microservices
frameworks.
We
had
a
look
at
how
you
can
use
docker
to
create
containers
out
of
those
microphones
or
how
you
can
put
your
application.
That
is
based
on
those
frameworks
into
a
container
for
some
of
the
frameworks.
This
is
quite
easy
here.
A
A
First
of
all
we
have
linux,
then
we
have
the
jvm,
and
then
we
have
an
application
once
we
did
that
we
can
build
the
container
and
then
easily
start
it,
and
when
you
do
this,
you
will
see
something
like
this.
So
these
are
all
the
commands
that
are
executed
when
building
the
the
image
on
the
right
size,
you
can
see
the
size
how
the
commands
affect
the
size
of
the
image
and
why
there
are
some
that
don't
affect
it
at
all.
A
There
are
some
that
affected
in
a
quite
high
amount
and
we
can
move
them
back
to
where
they
are
coming
from,
especially
to
the
linux
layer,
to
the
jdk
and
to
our
application.
That
is
based
on
the
microservice
framework
for
spring
boot,
for
example.
This
works
like
this,
so
we
decided
for
all
to
have
ubuntu
as
a
base.
Then
we
have
adopt
open,
jdk
11
as
the
jvm,
and
then
we
have
the
microservice
framework
with
the
application
on
top,
so
our
application
was
really
small.
It
was
just
one
endpoint
with
one
database
access.
A
So
mostly
everything
we
see
here
is
coming
from
the
framework
when
having
a
look
at
the
different
frameworks-
and
here
we
only
look
at
micro,
node
crackus
in
spring
boot,
because
eclipse
micro
profile
is
some
somehow
special
carson
will
show
this.
We
can
see
that
crackers
provide
the
smallest
yeah
or
needs
the
smallest
image
because
qrakos
as
a
framework,
as
that
is
a
kind
of
smaller
than
micro,
node
or
spring
boot.
A
B
Yeah,
the
memory
consumption
is
quite
lower
and
especially
start-up
time
is
way
faster
on
the
other
side
for
quite
a
while
to
build
such
a
binary.
So
it's
not
for
for
daily
use.
You
would
with
this
if
you
are
finally
deploy
your
application
to
production
and
also
you
this.
So
no
one
wants
wants
to
debug
your
native
binaries,
but
you
can
have
both
of
that
when
yeah,
can
you
advance
please?
B
In
microprofile
you
can
we
rely
and
rely
on
application,
servers
or
containers
like
wildfly
or
liberty.
Of
course,
they
have
some
kind
of
size.
They
are
not
not
small,
but
action
that
you
are
finally
deployed
is
really
really
what
what
comes
out
of
your
typical
development
process,
the
their
developing,
multiple
versions
of
your
applications
just
adds
a
layer
on
top
of
your
basic
infrastructure.
B
Okay,
now,
let's
have
a
look
at
startup
times.
We
measured
the
time
until
the
the
different
implementations
rest
end
point,
and
especially
surprising.
Now,
on
the
both
ends.
We
were
surprised
that
pajara
took
16
seconds
until
the
first
rest
call
came
through
and
on
the
other
side,
we
have
yeah
the
gravy
implementation
which
answered
after
300
milliseconds
and
in
between
you
see
that
yeah.
That
spring
is
somehow
in
the
middle
and
the
others
are
a
little
bit
faster
in
starting
okay.
B
Can
you
advance
for
the
build
times,
as
said
before,
when
you
build
the
binary
for
gravim?
This
takes
quite
a
long
time
and
on
the
other
side,
spring
moves
here
fastest
and
yeah
liberty
also
takes
quite
a
while,
and
they
do
quite
some
instrumentation
and
analysis
during
the
build
and
also
testing
and
yeah.
So
that's
what
you
have
as
a
typically
work
around
other
turnaround
during
your
development
process.
B
A
Yeah,
that's
about
the
z1
and
bit
time,
let's
go
back
to
the
size
of
the
images,
so
we've
seen
before
that
we
have
this
linox,
jvm
and
application
layer
to
be
true.
Here
we
can
work
on
it
too,
to
get
it
a
little
bit
smaller.
So,
first
of
all,
we
used
ubuntu
as
a
linux
layer.
Here
we
can
use
much
smaller
linux
layers.
One
example
is
alpine
linux,
for
example.
A
When
you
do
this,
for
example,
for
a
small
spring
boot
application,
you
can
create
a
you
can
run
it
on
an
alpine
linux,
that
is
about
10
megabytes
and
the
jegging
based
jv.
I
mean
that
is
about
55
megabytes
and
then
on
top
you,
for
example,
have
your
application,
and
now
you
can
see
that
now
it's
maybe
already
a
difference
if
you
use
crackers
or
spring
or
something
else,
even
with
the
difference,
there's
only
10
or
20
megabytes.
A
A
A
So
let's
have
a
look
at
the
advanced
features
of
microservices
and
we
will
do
this
quite
fast
because
I
said
we're
running
out
of
time.
So
there
are
a
lot
of
more
features
that
normally
you
should
ever
look
at
when
deciding
what
framework
you
want
to
use
like
the
tracing
or
monitoring
support
configuration
cloud
configuration
if
it
has
a
service
discovery
if
serverless
functions
are
already
supported,
like
micronaut,
for
example,
does
how
the
reactive
apis
look
and,
for
example,
how
authentication
strategies
the
framework
supports
by
default
yeah.
So
two
minutes
left.
B
Before
before
we
do
this,
we
have
one
question
on
henrikh:
what
tools
do
we
prefer
for
testing
of
microservice
frameworks?
So
actually
I
I
would
first
say
I
use
as
much
as
possible.
I'm
testing
with
unit
tests
inside
and
not
from
the
outside,
but
when,
when
we
have
when
we
want
to
test
the
services
themselves
on,
each
of
the
frameworks
are
provide
different
support
for
testing
frameworks
like
rest
assured
and
so,
and
they
are
quite
easy
to
use.
A
So
that's
it's
the
same.
For
me,
junit
is
perfect.
If
you
want
to
test
your
client
endpoint,
then
you
can
easily
set
up
with
spark
another
server.
If
you
want
to
test
complex
things,
you
can,
for
example,
use
test
container,
which
is
a
perfect
framework
for
testing
okay
yeah.
At
the
end,
when
having
a
look
at
the
firmware,
I
mean
here,
we
can
see
that
in
general,
they're
all
fine
they're
always
the
same
license
they're
all
since
at
least
two
or
three
years
on
the
market.
They
have
quite
good
release
cadence.
A
B
Yeah
and
all
them
of
course,
are
perfectly
supporting
containers
for
growl
vm.
Only
micro,
node
and
quakers
bring
out
of
the
box
support
it.
Actually,
it's
quite
a
little
bit
harder
to
to
support
that
for
spring.
Boot
are
not
allowed
to
use
reflection
and
spring
or
heavily
relies
on
that.
So
it's
quite
some
work
that
you
have
to
do
to
enable
spring
applications
for
graph
vm.
Now
image
sizes
and
startup
times.
We.