►
Description
// ABSTRACT
Eclipse MicroProfile is a feature-rich collection of specifications for developing microservices. Quarkus is a MicroProfile implementation that gives developers an incredibly productive development experience (“Developer Joy”) and delivers superb runtime efficiency. When combined, developers quickly can deliver feature-rich container-based MicroProfile applications that start in under 10's of milliseconds and utilize only 10’s of megabytes of total memory. This Tech Talk will include a few slides to set the context and then live-code a container-based MicroProfile application that is deployed to Kubernetes.
///GET SOCIAL!
Subscribe: https://www.youtube.com/user/EclipseFdn
Follow us on Twitter: https://twitter.com/JakartaEE
Like us on Facebook: https://www.facebook.com/JakartaEE/
Join us on LinkedIn: https://www.linkedin.com/groups/13597...
Tag us: #JakartaEE
Want more great Eclipse Community webinars?
Become a member of our Jakarta Tech Talks Meetup: https://www.meetup.com/jakartatechtal...
A
Okay,
hi
everyone
we're
just
about
to
start
another
exciting,
Tech,
Talk
and
Quercus
is
the
team
of
the
month
for
sure
everyone
is
buzzing
about
it,
and
we
have
this
great
opportunity
to
have
John
clinger
here
with
us,
and
he
will
be
talking
about
how
to
build
eclipse
micro
profile
applications
with
carcass,
so
without
really
wasting
too
much
time.
I'll
just
hand
it
over
to
John
and
John.
If
you
want
to
take
it
over
and
go
ahead
sure
so
I
am
going
to
share
my
screen.
A
Yes,
your
screen,
awesome,
okay,
so
welcome
everyone,
thanks
for
taking
your
valuable
time
out
to
hear
about
how
to
build
micro
profile
apps
with
Quartus,
and
my
name
is
John
Klingon
I'm,
a
product
manager
at
Red,
Hat
and
also
a
micro
profile
committer.
One
of
the
co-founders
kind
of
helped
set
up
my
profile
and
my
twitter
handle
is
at
Jai
Klingon,
so
you'll
you'll
see
me
chat
a
lot
about
about.
Quark
is,
and
it's
a
micro
profile
and
stuff
like
that
too
so
I
got
a
few
slides
and
then
an
awful
lot
of
live
coding.
A
A
This
Java
stack,
that's
been
optimized
for
most
of
the
last
20
years
for
basically
running
Java
applications
and
servers
right.
So
the
expectation
is
that
you're
running
on
either
directly
on
hardware
or
in
a
virtual
machine,
you're
running
a
heavy,
an
application
server
running.
On
top
of
that
running.
On
top
of
the
JDK,
the
JDK
has
been
optimized
for,
to
a
large
degree
for
running
application,
servers
right,
running
lots
of
tons
of
threads,
a
lot
of
dynamic
activity
as
you
deploy.
A
None
deploy,
applications
and
you've
got
frameworks
that
have
increasingly
over
time,
become
more
and
more
dynamic,
and
that
means
using
a
lot
of
reflection,
making
a
lot
of
decisions
at
runtime,
so
we're
where
we've
kind
of
been
moving
over
the
last
three
or
four
years
has
been
more
and
more
towards
micro
services
and,
as
you
know,
Java
EE
slowed
down
for
a
while.
Now
it's
moving
to
the
Eclipse
Foundation
as
Jakarta
EE,
but
why
would
it
had
slowed
down
for
a
while?
A
We
basically
as
a
community,
as
you
know
whether
it's
vendors
or
individuals,
Java
user
groups,
created
the
Eclipse
micro
profile
right.
The
idea
was
to
continue
the
idea
of
creating
specifications
that
foster.
You
know
multiple
implementations,
but
we
do
it
in
a
different
way
than
was
done
with
Java
EE
and
even
different
from
I
think
how
Jakarta
EE
will
evolve
and
that
basically
means
we
treat
micro
profile
a
lot
like
it's
an
open
source
community
right.
So
it's
an
open
source
project
I
mean
so
we
we
have
multiple
releases
per
year.
A
We
don't
necessarily
guarantee
backwards,
compatibility
quite
like
Java,
EE
or
even
Jakarta
EE,
probably
plans
to
write,
so
we
consider
ourselves
a
faster-moving
community
to
address
the
needs
of
micro
services.
Devel,
there's
still
a
lot
of
movement
in
this
area.
So
if
you
look
to
the
right
hand,
side
of
this
diagram
you'll
see
that
there's
a
healthy
set
of
specifications
there's
a
base
programming
model
based
on
Java
EE,
with
CDI
Jason,
processing
and
Jason
binding,
and
then
jax-rs.
A
That
kind
of
defines
the
base
programming
model,
and
on
top
of
that,
we've
got
specifications
that
define
how
to
utilize
microservices
patterns,
with
its
specific
set
of
api's
and
in
the
market.
There's
multiple
implementations
of
these
api's.
So
in
the
lower
left-hand
side,
what
you
can
see
is
it's
a
rather
large
community.
Both
vendors
organizations
and
individuals,
a
very
active
community
micro,
profiled
IO
and
in
the
lower
right
hand
side.
You
see
a
bunch
of
implementations
and
Korkis
which
I'll
be
talking
about.
It
is
also
an
implementation.
A
We
just
haven't
fully
run
the
micro
profile
tcks
yet,
but
there's
also
multiple
specifications
in
the
pipeline,
meaning
in
fact
one
of
them
is
done.
We
have
micro
profile,
reactive
streams,
operators
and
there's
a
reactive
messaging,
spec
context,
propagation
graph,
QL
long-running
actions.
So
there's
lots
of
specifications
that
are
kind
of
being
baked
that
should
come
out.
Probably
within
you
know
the
next
six
months
or
so
so
we
continue
to
evolve
pretty
quickly
but
again,
we're
evolving
in
the
context
of
micro
services.
A
Development
right
now,
what's
interesting
is
if
we
think
about
the
modern
enterprise,
Java
micro
services
stack
really
what
we
do
is
we
take
the
same
philosophy
that
we've
had
in
many
cases
the
same
frameworks
that
we've
had
you
know
over
the
last
you
know
15
years
or
so,
and
we
just
applied
them
towards
micro
services.
So,
instead
of
deploying
multiple
apps
on
top
of
a
JVM,
what
we,
what
we
do,
is
we
just
deploy
single
app
leveraging
again
many
of
the
same
frameworks.
There
are
new
frameworks
right,
so
micro
profile
is
a
good
example
right.
A
We've
got
so
far,
eight
or
nine
homegrown
specs
with
a
bunch
more
in
the
pipeline
like
I
mentioned.
So
there
are
some
new
frameworks,
but
the
way
that
these
frameworks
have
been
evolving
is,
if
they're,
still
fairly
dynamic
right.
They
make
a
lot
of
runtime
decisions,
and
even
the
runtimes
underneath,
like
an
application,
server,
still
do
a
lot
of
optimizations
and
decision-making
at
runtime
right.
A
So
that's
what
we're
course
comes
in
right.
Quark
is
basically
rethinks
this
and
it
says
well,
let's,
let's
optimize
this
stack
so
that
we
we
understand
that
our
target
environment
isn't
necessarily
running
multiple
applications
on
an
app
server
right.
That
is
by
the
way,
monoliths
the
java
ee
model.
That's
still
available
right.
So
what
we're
talking
about
here
is
if
I'm,
specifically
targeting
micro
services
and
a
single
app
stack.
A
That's
where
we're
looking
at
something
like
like
Korkis
right,
where
I
can
take
these
applications
and
these
these
frameworks
and
build
them
with
the
understanding
that
it's
going
to
be
deployed
to
a
kubernetes,
Linux,
container,
based
environment
and
that's
kind
of
those
two
icons
that
you
see
under
the
stack
right.
That's
that's
kind
of
the
new
target
environment
that
organizations
are
deploying
to,
and
so
cork
is
specifically
targets,
kubernetes
and
containers.
So
what
that
means
is
well
in
a
kubernetes
environment.
A
It's
it's
a
very
it's
an
immutable
environment
right,
meaning
that
when
I
develop
a
container
I
tend
not
to
log
into
the
container
and
make
changes
right.
What
I
do
is
I
make
my
changes
in
code
and
then
I
run
that
code
through
pipeline
and
it
redeploys
a
new
container
right.
So
this
is
the
idea
of
immutable
infrastructure.
A
So
if
you
think
about
those
dynamic
frameworks
that
I've
kind
of
been
talking
about,
where
we
do
lots
of
reflection,
we're
making
a
lot
of
runtime
decisions
and
deploying
to
it
what's
really
an
immutable
infrastructure,
so
Korkis
tree
thinks
that
it
says
well,
let's
not
target
or
let's
not
make
a
lot
of
these
decisions
at
at
runtime.
Let's
optimize
the
frameworks
with
the
understanding
that
I'm
targeting
immutable
infrastructure.
A
So
what
we
do
is
we
do
the
optimizations
things
like
scanning,
the
classpath
or
annotations
pre,
compiling
the
results
of
that
into
the
the
jar
file,
if
you're
going
to
run
on
top
of
Java
or
into
the
native
binary.
If
you're
going
to
be
running,
you
know
directly
on
on
the
operating
system
with
it
without
by
JDK.
So
we
do
a
lot
of
this
work
now
at
Build
time,
with
the
understanding
that
we're
going
to
be
deploying
two
immutable
infrastructure.
So
we're
basically
optimizing
that
entire
stack
right
so
you'll
see
some
examples
of
this.
A
No
no
quark
is
can
run
on
the
JDK.
You
can
put
it
in
production
on
the
JDK
if
you
want
to
right,
but
you
can
also
compile
it
down
to
native
binary,
an
in
fact
in
development
mode
will
run
strictly
and
on
top
of
the
JDK
all
right,
I'm
gonna
do
a
quick
time
check
all
right
now,
if
I
do
want
to
compile
down
to
a
binary.
A
A
So
what
Korkis,
utilizes
growl
vm
for
is
both
native
compilation
and
dead
code
elimination.
So
one
of
the
things
that
we've
done
with
Korkis
is
we've
optimized
a
lot
of
the
libraries
so
that
we
reduce
dependencies
both
within
the
library
and
even
across
libraries,
and
what
this
means
that,
if
your
application
doesn't
use,
some
of
the
code
it'll
be
eliminated
during
the
compilation
phase,
and
that
means
you
get
a
relatively
small
executable
binary
all
right.
Okay,
so
let's
do
a
little
bit
of
live
coding.
A
Okay,
so
can
everyone
see,
let's
see
here,
I'm
gonna,
make
this
bigger
I
do
have
the
chat
open
in
another
monitor.
So
if
folks
want
to
ask
questions
or
make
comments
about,
but
you
know
being
able
to
see
the
code
I,
write
and
stuff
just
just,
let
me
know
all
right
so
to
create
a
project
with
Korkis.
What
we're
going
to
do
is
we're
going
to
use
the
Quercus
maven
plugin,
so
this
will
actually
generate
the
outline
of
us
a
very
simple
restful
endpoint.
A
We
are
working
on
kind
of
a
web-based
starter
as
well,
but
for
now,
what
we're
going
to
be
using
is
the
maven
plugin
to
generate
the
source
code.
So
what
you
can
see
here
is
I'm
just
providing
the
maven
artifact
information
that
I
want
to
be
generated
for
this
write
for
this
project
write.
What
the
group
ID
is
the
artifact
idea
here,
I'm
going
to
call
it
person
we're
gonna,
create
a
restful
resource
called
person,
resource
and
it'll,
be
listening
at
a
person.
Endpoint,
hey
I'm
gonna
go
ahead
and
create
this
alright.
A
So
if
I
want
to
take
a
look
at
the
source
code
real
quickly,
what
you
see
is
it
is,
you
know,
kind
of
like
what
I
said.
It's
a
very
simple
restful.
Endpoint
now,
let's
add
some
additional
maven
dependencies
so
that
we
can
build
out
an
actual
micro
profile
application.
So
Korkis
again
with
the
maven
plug-in,
has
something
has
a
goal
called
list
extensions.
An
extension
in
Korkis
is
basically
what
I
mentioned.
A
It's
a
pre
optimized
framework
that
well
it's
optimized
for
efficiency
like
I
mentioned
before,
but
it's
also
you
can
assume
that
if
it's
in
a
chorus
extension,
it
could
also
be
compiled
down
to
a
native
binary.
Not
all
the
frameworks
out
in
the
Java
ecosystem
could
be
compiled
down
to
a
native
binary
without
some
extra
work
and
we've
kind
of
done
that
extra
work
on
behalf
of
the
developer
for
these
frameworks.
So
if
we
take
a
look
at
the
extensions
we've
got,
our
keys
are
CDI
implementation
for
Quercus.
A
Let's
see
what
else
we
have
in
Finnish
band
support
as
a
client,
Jason
consuming
and
producing
Jason
via
Jason,
binding
and
processing
key
cloak
for
security,
kubernetes
I
hope
to
have
time
to
show
that
one
it
generates
the
amyl
that
enables
you
to
take
your
application
and
deploy
it
into
a
kubernetes
environment.
Catelyn
I
mentioned
so
you
got
transactions.
A
All
these
small
right
ones
are
basically
micro
profile,
spec
implementations
right,
so
you
can
see
context
propagation
fault,
tolerance,
Health,
metrics,
a
lot
of
those
are
implemented
in
the
small
right
project
and
kafka
support,
and
all
that
alright.
So
that's
quite
a
big
list.
So
what
I'm
going
to
do
now
is-
and
here
is,
show
you
a
how
to
add
some
extensions
to
our
project.
So
what
we're
going
to
do
is
use
the
add,
a
extension
goal
and
we're
going
to
specify
the
extensions
oops
if
I
could
spell
properly.
A
All
right,
so
one
of
the
nice
things
about
this
extension
is
you
don't
have
to
necessarily
type
in
the
entire
strings
that
you
see
here.
You
can
just
type
in
a
subset
and
if
it
can
find
without
any
kind
of
name
it
without
any
kind
of
name
collision.
It'll.
Add
it
alright.
So
let's
do
a
Kubb
I
mentioned
that
for
doing
kubernetes,
yeah
mol
generation
fault
tolerance.
A
Let's
use
the
micro
profile
restclient
we're
going
to
show
that
I'm
going
to
show
some
metrics
I'm
going
to
show
open,
API
and
swagger
this
one
I'm
not
about
because
we
will
have
a
namespace
collision.
Korkis
rest,
easy,
jason,
binding.
Let's
see,
I'm
gonna
do
panache.
Panache
is
a
layer
and
ease
of
use
layer
on
top
of
GPA
and
hibernate,
so
that'll
be
interesting.
Show
I'm,
gonna,
show
weird
see
when
you
use
the
h2
database
while
we're
developing
locally
so
that
we
use
in
memory
database.
A
But
when
we
go
into
production
on
our
kubernetes
cluster,
which
I
have
running
on
my
laptop,
please
post,
Chris
and
we'll
use
micro
profile
health
check,
we'll
see
how
much
of
this
we
can
actually
get
to
during
this
hour.
So
now
this
is
going
to
fail
because
we
actually
ran
into
a
namespace
collision.
I
mentioned
post
Chris,
but
there's
actually
two
different
post
CRA's
database
drivers,
one
for
you
for
using
the
async
reactive
driver,
the
other
one
for
using
a
standard
JDBC
driver.
A
Okay,
so
that
was
added
now
I'm
gonna
do
one
other
kind
of
little
bit
of
pre
optimization
here
in
this.
For
this
project
and
I'm
gonna
set
an
environmental
variable,
so
I'm
gonna
set
Quercus
underscore
profile
equals
dev.
So
this
is
going
to
come
in
hand
when
we
start
using
micro
profile
config,
where
we
can
have
different
configuration
profiles,
one
for
development
and
one
for
production,
all
right
now,
I'm
going
to
open
this
all
up
into
Visual
Studio
code.
Of
course
you
can
use
your
favorite
IDE
again.
A
Well,
let's
take
a
look
at
the
palm
file
and
you'll
see
we're
using
version
17
of
quark
is.
This
is
the
most
recent
version
and
you
could
see
all
these
maven
dependencies
that
we
just
added
with
an
extension,
okay
and
there's
also
if
we
want
to
compile
down
to
native
code,
one
of
the
things
you'll
see
is
a
pro
maven
profile
called
native
and
that
let
us
generate
a
native
binary.
A
I'm
gonna
try
to
minimize
that
because
it
takes
a
while-
and
we
don't
have
a
lot
of
time
to
show
an
awful
lot
of
functionality,
so
I'm
going
to
create
a
terminal.
Now
what
I'm
going
to
do
is
put
Quercus
in
development
mode?
Actually,
I
should
have
set
the
profile
here.
So
in
fact-
and
we
do
that
in
this
terminal
window
now
we're
going
to
run
Quercus
in
developer
mode,
so
I
can
develop
this
project.
Maven
quirk
is
:
dev.
A
So
let's
actually
try
out
the
the
restful
endpoints
I
may
have
to
make
this
bigger,
okay
and
we're
going
to
execute
the
endpoint
and
you'll
see
that
responds
with
hello.
Now,
I'm
not
going
to
be
using
the
browser
to
interact
with
the
application,
because
I
want
to
have
to
constantly
switch
back
and
forth
between
the
browser
and
and
the
application,
so
I'm
going
to
do
most
of
the
work
directly
in
in
the
IDE
and
a
terminal
okay.
A
So
so
you
can
kind
of
check,
check
box
off
the
fact
that
mica
profile
supports
open
API
out
of
the
box,
so
I'm
gonna
go
back
to
actually
the
presentation
here
go
fullscreen
and
talk
a
little
bit
about
micro
profile,
config,
good
micro
profile,
sorry,
good
micro
services,
development
style.
You
know
kind
of
a
twelve
factor
app.
If
you
want
to
externalize
your
application
configuration-
and
you
could
do
that
with
micro
profile
config,
where
you
can
inject
the
value
of
a
property
into
your
application
and
behind
the
scenes.
A
A
Alright,
so
let's
go
back
and
do
a
little
bit
of
coding,
so
I
am
going
to
bring
up
oops,
not
test
mein
Java
person
resource.
Here
we
go
so
this
is.
This
is
the
code
that
was
generated
now.
What
we're
going
to
do
is
add
in
the
ability
to
inject
resources
from
an
external
location
all
right.
So
let's
do
at
inject
config
property.
This
is
a
micro
profile.
Api,
let's
make
sure
we
choose
the
right
one.
A
Let's
see,
what
is
it
here
we
want
to
do.
Name
is
going
to
be
greeting
and
we're
also
going
to
give
it
a
default
value.
Just
so
we
can
test
it
out
right
now
and
the
default
value
is
going
to
be
hello,
okay
and
we're
going
to
inject
this
into
a
string
variable
reading,
but
down
here
we're
just
going
to
return
greeting
all
right.
A
A
What
you
may
not
have
noticed
is
that
I
didn't
have
to
compile
anything.
I
didn't
have
to
hit
control-c
recompile
and
then
restart
the
app
right.
So
Korkis
is
actually
live
loading
all
the
changes
that
I'm
making
as
they
make
them
right
and
it
doesn't
not
just
for
code
but
also
for
properties
in
the
property
file.
So
let's
go
ahead
and
do
that
oops
here
we
go
application.
Dep
properties,
so
we're
gonna
do
here
is
we're
gonna,
add
a
greeting,
and
here
let's
see
we
want
to
call
it.
Oh
okay,
okay,
yeah
I'll!
A
What
we'll
see
is
that
picked
it
up
out
of
the
property
file,
so
there's
an
order
of
precedence
with
Mecca
profile
right,
where
the
look
at
the
config
file
first
and
pull
it
out
of
there.
You
can
override
that
by
using
an
environmental
variable
and
you
can
eat
over
at
both
of
those
if
you
use
a
Java
system
property
right
by
de
greeting
okay.
So
that's
pretty
cool!
Now,
let's
take
a
look
at
another
API,
the
micro
profile,
rest
client.
A
So
with
jax-rs
the
red
building
out
a
a
REST
API
takes
a
little
bit
of
work.
It
uses
a
builder
pattern
to
interact
with
a
restful
service
with
a
micro
profile.
Rest
client.
What
it
does
is.
It
takes
a
very
type,
safe
approach
to
doing
development
of
a
restful
client
so
for
interacting
with
a
restful
service.
Really
you're,
just
manipulating
a
Java
object
right.
So
let's
go
ahead
and
build
out
a
restful
client.
A
A
I
moved
too
far
on
accident.
I'm
gonna
just
delete
that
earlier
when
I
was
scrolling
up,
I
accidentally
copied
a
file
all
right.
Here
we
go.
Let's
go
back
here
and
now
we're
gonna
create
a
new
file.
We're
gonna
call
this
the
hello
rest,
client,
dot,
Java,
all
right
and
we're
gonna
have
a
package
and
what
we're
to
do
is
create
a
an
interface
interface,
hello,
rest,
client.
A
Now
we
have
to
annotate
this
interface
with
a
couple
of
things.
The
first
is
register
rest
client,
okay,
and
we
that's
going
to
register
this
this
restful
client,
so
that
we
can
actually
inject
it
in
our
actual
application
code.
So
next
I'm
going
to
do
is
at
path
so,
which
end
point.
Is
this
going
to
access
slash
and
what
is
the
the
remote
service?
A
A
So
what
this
is
whenever
I
invoke
this
this
end
point
or
sorry
invoke
this
method.
It's
going
to
call
the
restful
endpoint,
but
one
of
the
things
we
need
to
do
is
point
to
the
URL,
where
the
actual
end
point
is
so
I
can
either
specify
that
I
think
here
or
I
can
specify
it
in
the
property
file,
and
so
what
I'm
going
to
do
is
specify
this
in
the
property
file,
all
right,
so
I'm
gonna
go
back
to.
A
A
It's
just
a
response,
hello
or
was
some
other
message,
so
what
I
did
is
I
took
that
and
I
actually
compiled
it
down
to
a
native
binary
and
deployed
it
to
kubernetes,
and
if
you
take
a
look
here,
real
quick,
what
you'll
see
if
I
look
at
the
actual
log
you'll
see
that
this
actually
started
in
39
milliseconds
right,
which
is
actually
kind
of
slow?
Normally,
this
starts
in
like
10
milliseconds,
but
I
have
lots
of
things
going
on
right
now
on
a
machine,
so
that's
pretty
impressive
for
a
java
application
right.
Alright.
A
And
I'm
going
to
paste
this
in
while
I
can
now
what
I
have
to
do
is
provide
the
property
that
the
micro
profile
rest
client
will
read
and
there's
a
specific
pattern
for
that.
The
pattern
basically
starts
with
the
name
of
the
package,
so
I'm
gonna
copy
that
because
it's
convenient
dot
the
name
of
the
the
class
hello
rest
client,
followed
by
MP
rest,
followed
by
the
URL
okay.
A
So
this
is
going
to
be
the
endpoint
and
I
think
in
each
also
have
to
add
hello,
so
micro
profile,
rest
client
will
read
this
property
and
figure
out.
This
is
the
endpoint
I
need
to
access
and
do
the
Java
binding
Java
object
binding
if
I
need
to
okay
so
see
that
let's
go
back
to
our
client
now
here
we
have
to
inject
the
restful
client
right.
A
Okay,
now
this
should
actually
inject
our
hello
client
proxy
directly
into
the
hello
client
variable
and
then
invoke
what,
when
I,
actually
invoke
the
hello
method,
it'll
actually
make
the
remote
call.
So
what
I'm
going
to
do
here
is:
do
hello,
client,
dot,
hello
right,
so,
let's
cross
our
fingers
and
make
sure
this
actually
works.
A
And
it
did
so
it's
it's
calling
howdy,
which
is
the
message.
That's
actually
predefined
in
the
hello
service
running
in
the
CUDA
at
ease,
runtime
right,
which
is
OpenShift
okay.
So,
let's
head
over
back
to
our
slides.
If
we
can
now
what's
nice
is
again,
you
didn't
see
me
recompile,
you
know,
all
I
had
to
do
is
say:
didn't
have
to
rebuild
recompile
restart
a
very
nice
natural
flow
towards
doing
development.
Now,
since
we're
making
a
remote
call,
we're
gonna
add
some
fault
tolerance
support
into
our
application.
A
So
how
do
we
deal
with
failure
if
the
low
service
happens
to
be
down?
So,
in
fact,
let's
even
let's
even
do
that.
Let's
actually
no
I'll
do
that
in
a
second.
So
what
strategies
do
we
have
to
deal
with
fault
tolerance?
Well,
I
can
use
the
asynchronous
annotation
and
run
a
method
call
in
in
a
different
thread.
A
So
if
you're,
making
a
method
call
and
that
method
happens
to
fail,
you
can
provide
alternative
logic
with
the
fallback
annotation
I'll
be
showing
that
one.
If
you
happen
to
have
a
failure,
you
can
also
use
retry
logic
with
the
retry
annotation.
Some
might
think
that's
an
anti-pattern,
but
if
you
have
an
unstable
network
it
could
actually
come
in
kind
of
handy
and
then
the
last
one
is
a
timeout.
A
If
you
want
to
make
sure
that
you
provide
a
responsive,
well
response
back
to
your
to
your
client,
you
can
limit
the
amount
of
time
your
remote
call
might
make
so
you
can
set
it
though
it'll
throw
a
timeout
exception
if
it
exceeds
some
threshold.
So
what
I'm
going
to
do
here
is
we're
going
to
take
this
call,
in
fact,
I
think
at
this
point.
A
I
can
just
get
rid
of
the
the
endpoint
that
you
with
a
big
Jax,
Russ
endpoint
and
just
simply
make
it
a
method
call,
and
what
we're
going
to
do
is
we're
going
to
basically
make
this
a
timeout
and
after
a
certain
period
of
time,
if
we
don't
get
a
response,
then
it's
going
to
return
with
a
timeout
exception.
Okay-
and
let's
see
here,
I
think
I
need
to
import
that
and
now
there's
two
parameters
I
can
provide.
One
is
the
unit
so
unit
of
time.
A
I'll
just
leave
it
at
the
default,
which
is
milliseconds,
and
it's
also
going
to
by
default.
Take
one
second
2,000
milliseconds,
but
we'll
just
make
this
shorter,
we'll
say
what
was
it?
Value
equals
a
half
a
millisecond
right,
so
it's
going
to
timeout
after
a
half
a
millisecond,
we're
also
going
to
provide
a
fallback
method.
So
if
this
method
fails
through
because
of
some
exception,
then
what
we're
going
to
do
is
provide
some
fallback
logic.
So
what
we're
going
to
do
is
specify
a
fallback
method.
We're
gonna
call
it
hello.
All
back.
A
Okay
nowaday
to
do
is
provide
the
fallback
method.
Oops,
sorry
about
that,
go
down
here
and
say
public
and
the
fallback
method
just
has
to
have
the
same
method.
Signature
as
the
method
that
the
fallback
annotation
is
on.
So
public
stringing,
we're
gonna,
call
it
hello
fallback
and
it
has
to
return
a
string
all
right.
So
I'm
gonna
return,
mrs.
Doubtfire
there
we
go
so
I
am
now
going
to
rerun
this
application.
A
A
A
A
We're
gonna
call
this
person
Java,
alright,
so
with
with
person,
we're
gonna,
make
it
a
GPA
entity
and
with
a
GPA
entity,
it's
basically
an
annotated,
Java
Bean
right
in
a
lot
of
ways.
But
what
we're
going
to
do
is
we're
going
to
use
something
called
panache
and
to
use
panache
we're
going
to
extend.
A
A
That
would
be
nice,
that
was
the
problem
and
we
are
going
to
import
the
JPA
entity.
Alright,
now
I
get
some
really
nice
things
with
panache.
Typically,
you
would
have
to
create
private
fields
with
getters
and
setters,
but
with
panache
you
can
just
make
them
public
fields,
so
we're
gonna
miss
a
public
string,
name
and
public
int
age
right
and
I
could
annotate
these
with
JP
annotations,
like
you
know,
at
column,
I
can
put
in
hibernate
validator
constraints
and
so
on.
In
the
interest
of
time,
I
am
NOT
going
to
do
that.
A
A
A
A
A
Yeah
public
list
must
return.
Oh
I
haven't
returned
it.
That
would
be
nice
now.
Let's
try
and
actually
hit
the
endpoint
list.
All
and
it's
gonna
fail,
because
we
haven't
defined
our
application
properties
for
the
JPA
datasource.
So
what
I'm
going
to
do
this
is
where
I'm
gonna
do
a
little
bit
of
cheating,
I'm
gonna
copy
and
paste
alright.
A
So
what
I've
got
now
is
a
development
in
development
mode
I'm
going
to
talk
to
the
h2
in
memory
database
and
in
production
we're
going
to
talk
to
Postgres
now
this
is
where
that
profile
comes
in
so
with
cork
is,
if
you
have
an
environmental
variable
or
a
property
set
called
Korkis
and
the
score
profile.
It'll.
Actually,
then
utilize
that
profile
name
here
and
select
the
properties
with
that
profile.
Name
right,
so
I
specified
dev
is
the
profile
alright.
So
I
prefix
this
these
with
the
dev
profile.
A
A
Still
having
problems
because
I
wonder
if
I
have
the
h2
database
driver
in
my
palm,
this
is
the
live
coding.
The
problem
with
live
coding,
h2.
Is
there
right
here
now,
you're
all
probably
screaming
at
me
right
now
saying
you
forgot
something:
no
dialogue
driver
specified
by
Quercus
database
that
data
source
not
driver.
Okay,
go
back,
oh
I,
didn't
save
the
file.
I,
think
that
was
it
actually.
A
Person
table
the
table,
person
is
not
found,
so
that
means
I
forgot
to
do
something
here.
I
forgot
to
basically
set
drop
and
create
so
there
was
no
database
table,
so
we
have
to
drop
and
create
the
database
table.
That's
what
the
problem
is
alright,
so
there
we
go
now.
It
worked
sorry
about
that.
But
the
nice
thing
is
I'm
running
into
all
these
problems
because
of
my
poor
coding
style,
but
I'm
never
having
to
restart
right.
So
I
guess
you
might
say
that
I'm
actually
failing
fast,
so
so
now
we're
talking
to
a
database.
A
Let's
make
sure
that
we
can
add
a
person
right
so
now
we're
going
to
use
at
post
we're
going
to
do
a
produces
and
consumes
of
a
JSON
data
type
and
we're
going
to
public
person,
so
we're
gonna
return.
The
person
that
we're
adding
add
person
gonna
be
adding
a
person
person
now
the
way
that
you
add,
with
panache
again,
there's
no
named
query:
there's
no
entity
manager
involved
directly
in
the
code
that
you
write.
What
we're
just
going
to
do
is
we're
just
going
to
call
a
person.
A
Dot
persist,
method,
we're
inheriting
that
from
the
parent
class
all
right
and
then
we're
going
to
return
that
same
person.
So
that's
pretty
cool
okay,
I'm
gonna,
see
code,
and
now
what
I'm
going
to
try
and
do
is
actually
add
a
person
method
post
does
not
provide
okay
running
into
another
error.
Get
oh
I
forgot
to
add
something
at
transactional.
This
has
to
be
done
in
the
context
of
a
transaction
because
we're
updating
the
database
and
I
think
that
might
be
my
problem.
There.
A
A
A
To
do
a
lookup
by
ID,
it's
actually
really
easy,
with
panache,
we
just
say
person
dot,
find
by
ID
and
we're
gonna
pass
in
the
ID
and
we're
gonna
return
something
here.
So
what
we're
going
to
return
is
a
string
but
we're
going
to
kind
of
build
this
string
from
scratch,
so
we're
gonna
call
the
hello
method.
So
when
I
greet
this
person
plus
and
it's
person's
name
person,
dot,
name
plus,
remember
it's
a
public
property,
but
if
they
were
a
getter
it
would
call
the
getter.
So
that's
some
really
nice
feature:
okay,
oops!
A
A
Person
dot
age
plus
years
old,
okay,
so
that
works
now
what
you're
gonna
find
is
if
we
actually
try
to
list
all
the
people
they're
going
to
be
gone,
that's
because
what
panache
is
really
doing
under
the
scenes
as
its
dropping
the
class
loader
and
basically
reloading
the
entire
application
from
scratch.
So
anything
that's
in
memory
is
lost
unless
you
persist
it
somewhere,
like
a
database
right.
A
So
what
I'm
going
to
do
is
I'm
going
to
actually
post
these
people
back,
create
these
people
again
now,
if
I
actually
want
to
go
and
just
list
that
one
person
what
you'll
see
is
it
saying
howdy
Duke,
you
are
twenty
five
years
old
right
so
now,
if
we
go
back
to
our
fallback
logic
right,
what
we
want
to
do
then,
is
basically
do
a
fallback
if
there's
a
problem
with
making
this
remote
call
to
person.
So
what's
I'm
looking
for
our
here,
we
go
for
our
hello
call
right.
So
what
happens
if
this
fails?
A
Well,
let's
find
out
so
I
am
going
to
go
back
to
open
shift,
kill
all
copies
all
instances
of
this
application.
So
now
we
have
nothing
and
running
so
hopefully
this
time
it
will
actually
call
the
fallback
logic
which
it
does.
So
that's
pretty
cool
all
right.
So
what
if
we
want
to
do
some
additional
logic
around
counting
how
many
times
this
method
fails
and
then
being
able
to
view
that
and
go
find
a
dashboard,
for
instance
right.
A
What
I'm
going
to
use
is
that
counter.
Some
of
this
is
changed
with
micro
profile,
metrics
2.0,
but
right
now
we're
using
my
profile,
metrics
1.1
right,
but
what
you
get
out
of
the
box
with
metrics
is
an
endpoint,
slash,
metrics
that
can
be
pulled
by
for
exist,
for
example,
Prometheus
right
and
with
with
that,
you
get
some
base
metrics
that
are
required
by
Mikah
profile.
Things
like
you
know,
CPUs
and
memory
available,
some
vendor
specific
metrics.
A
If
a
vendor
wants
to
provide
that
and
then
of
course
your
application
metrics
right,
so
let's
actually
try
and
add
a
metric
in
here.
So
what
I'm
going
to
do
is
see
you
here
come
back
back
here.
We're
gonna
track
a
metric,
I'm
going
to
say
at
inject
a
metric
and
we're
going
to
give
this
metric
and
name
of
hello
fail
the
number
of
times
the
hello
method
fails
and
we're
gonna
make
this
a
counter.
A
A
A
So
this
is
in
prometheus
format
by
default,
but
you
can
see
there's
some
vendor
specific
metrics
there's
some
base
metrics
that
are
required
by
micro
profile
and
now
what
I'm
going
to
do
is
see.
If
I
can
do
a
grep,
I'm
gonna
look
for
our
application
metric
and
then
you
can
see.
Let's
see
so
far,
it
says
it's
failed
zero
times.
So
let's
try
this
again.
A
It
should
fall
back
whenever
we
get
this
person.
Let's
see
hello
now,
let's
go
back
and
count
it
again
and
you'll
see
that
it's
failed
three
times
right
so
now,
I
can
keep
track
of
application,
metrics
and
created
for
fauna,
dashboard
running
inside
of
communities
and
everything
so
I
think.
Maybe
at
this
point
we
got
a
few
minutes
left
I,
don't
know
if
I'm
gonna
have
time
to
compile
this
down
to
a
native
binary.
Well,
maybe
I'll
try
but
I
have
to
do
one
thing.
First,.
A
I'm
gonna
change
the
end
point
here
because,
when
we're
running
in
forgot
to
make
this
as
a
part
of
the
profiles,
so
we
are
going
to
do
colon
8080,
slash
hello
when
we're
running
in
inside
of
kubernetes,
the
URL
for
the
service
is
going
to
be
different
because
we're
not
going
through
an
external
gateway,
an
external
proxy.
So
there
we
go
so
I'm
gonna,
try
and
compile
this
down
to
a
binary,
and
we
should
be
utilizing
these.
A
Database
properties,
when
we
do
that
so
first
I'm
going
to
do
maybe
I'll,
do
it
right
now
before
I
forget
is
I,
am
going
to
modify
my
docker
file
to
make
sure
that
I'm
specifying
and
the
right
profile
equals
prod
there
we
go
and
we're
gonna,
compile
it
down
to
a
native
binary
by
by
specifying
native,
but
we
want
it
to
be
in
a
Linux
container,
so
we
got
to
compile
it
into
a
Linux
binary
right.
So
that's
what
this
line
right
here
is.
A
A
A
Maybe
what
I'll
do
is
show
you
a
little
bit
about
getting
started
with
Korkis
if
you
want
to
get
started
with
Korkis,
go
to
quark
estádio,
there's
literally
a
get
started
page
where
it
will
take
you
through
some
of
the
steps
that
I've
showed
you
here
about
creating
your
first
application
that
you
know,
use
the
maven
plug-in
to
create
a
project
kind
of
like
you
saw,
and
we
do
here
how
to
build
a
native
image.
How
to
use
maven
and
Gradle
Gradle
is
also
supported
with
Korkis.
A
There's.
Actually
I'll
go
to
extensions
first.
There
are
many
many
extensions
like
I
mentioned,
that
cover
all
sorts
of
functionality
that
you
can
use
with
Korkis.
If
you're
running
in
JVM
mode,
you
could
pretty
much
use
any
Java
library
that
you
want.
The
issue
is
when,
if
you
want
to
compile
down
to
a
native
binary,
then
you
might
run
into
some
issues
right
where
you'll
have
to
use
Quercus
extensions
or
do
a
little
bit
of
extra
work
or
work
with
the
framework
provider
to
kind
of
support
native
native
development.
A
There's
guides
for
all
of
this
functionality
with
quark
is
there's
a
guide
on
that's
effect
functionality.
If
you
have
code
within
your
organization
and
your
own
custom
frameworks,
we
have
a
guy
that
kind
of
explains
to
you.
Well,
if
it
doesn't
compile
down
to
native
binary
out
of
the
box,
and
you
can
create
your
own
extension
so
that
your
framework
providers
within
your
organization
can
make
them
an
extension
that
other
folks
can
use
right.
So
we've
got
guides
on
doing
you
know,
database
manipulation,
there's
a
extension
being
worked
on
right
now.
A
All
sorts
of
web
style
extensions,
some
of
them
I,
showed
you
messaging
with
Kafka
and
reactive
messaging,
with
micro
profile,
reactive
messaging,
some
security
extensions,
so
there's
actually
quite
a
bit.
There
I
think
there's
something
we
had
some
camel
guides
here
too.
Let's
see
how
our
compilation
is
doing.
Oops
word.
This
way.
A
And
it's
still
building
yeah
I,
don't
think
it's
gonna
build
in
time,
so
it
takes
about
five
minutes,
but
one
thing
I
did
do
and
you
might
find
this
kind
of
interesting
is
I
kind
of
pre
ran
this
in
another
OpenShift
project
right.
So,
if
we
go
to
kind
of
my
backup
project,
you'll
see
that
I
have
this
running.
I
have
the
person
project
running
and
what's
really
cool
is
because
Korkis
is
so
efficient.
I
can
just
run
just
a
ton
of
copies
of
this
I'll.
A
Guess
with
that
we're
at
the
top
of
the
hour
I
apologize
for
some
of
the
technical
difficulties,
I
ran
into
I,
didn't
get
to
show
you
mica
profile,
whole
health
checks
and
so
with
micro
profile,
health
checks,
there's
the
ability
to
kind
of
expose
the
health,
the
lightness
and
readiness
of
your
application
to
your
to
the
environment
in
this
case
kubernetes,
so
that
if
it
sees
that
it's
it's
it's
not
live.
If
it'll
kill
the
potter,
you
start
it
right
or
if
the
pot
isn't
ready,
it
won't
direct
traffic
to
it.
A
A
All
right,
well,
I,
think
we
are
actually
done
here.
I
think
we
seem
to
have
lost
Tanya
and
I
think
we're
still
recording
all
right
Oh
anyway,
thanks
everyone
for
joining
I
apologize.
You
can
find
me
on
at
edge
a
Klingon
on
Twitter
and,
although
I'm
kind
of
embarrassed
with
some
of
the
problems
I
ran
into
so
just
be
nice
all
right.
Thanks,
bye,.