►
From YouTube: How to Develop Your First Cloud Native Applications with Java | Jakarta Tech Talks - July 2019
Description
// ABSTRACT
In this session, we will demonstrate how to build microservices with Java EE and Eclipse MicroProfile and how to run and operate them on Kubernetes and Istio. MicroProfile also comes with convenience functionality that you typically need when developing microservices, for example invocations and implementations of REST APIs including their documentation. Attend this session to see how we walk you through a scalable and resilient sample application that can be run in your local Kubernetes environment or on any other Kubernetes cluster.
Sample application: https://github.com/nheidloff/cloud-native-starter
///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/jakartatechtalks_/
A
Hi
everyone,
okay,
I,
think
we
are
aligned
now
hi.
Everyone
welcome
to
another
tech.
Talk
we're
thrilled
today
to
have
presentation
on
how
to
develop
your
first
called
native
application
with
with
Nick
was
here
I'll.
Let
him
introduce
himself
a
little
bit
more
and
a
little
bit
better,
but
because
we're
already
a
couple
minutes
late,
we
had
the
few
technical
glitches
on
our
end.
B
Okay,
so
I'm
gonna
describe
what
these
different
technologies
do
and,
more
importantly,
how
you
can
use
them
together,
because
sometimes
that's
a
little
bit
confusing,
especially
when
it
comes
to
the
positioning
from
SEO
versus
eclipse
micro
profile.
Now
earlier
this
year,
I
was
looking
for
an
application
for
sample.
That
would
show
you
to
do
how
to
do
all
of
these
things
together.
Unfortunately,
I
couldn't
really
find
the
one
application
the
one
sample.
There
are
lots
of
samples
for
coup
Benitez.
There
are
really
good
guides
for
Open
Liberty,
including
micro
profile.
B
I,
just
couldn't
find
the
one
application
that
would
show
me
how
to
implement
a
full
end-to-end
application
or
an
enterprise
application,
including
authentication
in
front
and
persistence,
and
all
of
this.
So
what
I
did
was
to
basically
develop
such
an
application
myself,
together
with
a
colleague
of
mine
who
cannot
make
it
today,
and
you
can
find
the
link
here
on
most
of
the
slides
in
the
lower
right
corner.
B
It's
a
link
to
a
repo
on
github
in
our
IBM
organization,
and
that
repo
is
what
I'm
gonna
use
here
throughout
this
session
for
all
of
my
demos.
So
after
this
every
one
of
you
should
be
able
to
run
all
the
demos
yourselves
on
your
local
machines,
so
I
assume
that
most
actually
all
of
you
have
heard
about
micro
services
and
cloud
native,
so
I
don't
really
want
to
do
here
along
introduction
just
very
quickly.
This
is
the
definition
of
micro
services
from
Wikipedia
and
I.
Think
it's
pretty
good.
It
says.
B
For
example,
there's
this
benefit
of
being
able
to
implement
applications
that
stay
responsive
even
when
single
micro
services
are
not
available,
and
similarly,
you
can
continuously
deliver
new
functionality,
because
the
nice
thing
about
micro
services
is
that
you
can
update
them
independently
from
each
other.
So
for
us
as
developers,
there
are
new
options,
new
possibilities,
and
that
means
we
need
to
understand
them.
We
need
to
understand
the
advantages
and
disadvantages
so
that
we
can
decide
which
option
we
want
to
choose,
or,
as
illustrated
here
on
the
slide,
when
there
are
multiple
doors.
B
You
need
to
decide
which
one
you
want
to
open
and
also
new
options
often
lead
to
new
challenges
and
here's
an
example.
When
you
break
down
an
application
in
multiple
micro-services.
What
do
you
do
if
a
service
a
wants
to
invoke
a
service
B
in
a
distributed
environment,
but
the
network
is
not
available,
so
you
need
to
think
about
these
new
challenges
so
real
quickly.
Let
me
introduce
the
key
technologies
here.
Kubernetes
is
do
and
micro
profile.
B
First
of
all,
kubernetes
kubernetes
is
an
orchestration
framework,
not
only
one
of
many,
it's
the
de
facto
orchestration
frameworks
to
run
container
workloads,
it's
open
source
project
and
it's
well
established.
Basically,
every
cloud
provider
supports
coup
Benitez,
so
the
nice
thing
is,
you
can
implement
applications
once
and
deploy
them
basically
everywhere,
whether
that's
a
private
cloud,
a
public
cloud
or
different
cloud
providers-
and
that's
a
really
nice
thing.
In
other
words,
there
is
no
vendor
login.
Ok,
the
next
technology
here
that
we're
going
to
use
in
the
demo
is
this.
Do
this
deal?
B
Is
a
service
mesh
and
it's
essentially
an
extension
to
kubernetes
that
helps
you
to
really
manage
micro
services.
The
best
example
that
always
mentioned
that
I
always
mention
is
traffic
management,
so
obviously
with
kubernetes,
you
can
do
things
like
rolling
updates,
but
this
do
goes
far
beyond
bed.
For
example,
if
you
want
to
do
things
like
dark
launches
of
new
features,
a
be
testing
canary
rollouts.
All
of
this
is
well
supported
by
its
doom
and
I'm.
B
Gonna
demonstrate
that
a
little
later
and
by
the
way,
what
you
can
see
here
in
this
little
diagram
is
that
the
trick
that
is
used
here
is
to
use
these
proxies.
So
the
proxies
are
containers
that
run
in
the
same
pots,
together
with
the
containers
with
your
micro
services
code.
Ok
and
all
the
communication
goes
through
the
proxies
and
that's
why
SEO
can
manage
the
traffic
that
well
by
using
policies,
then
obviously
micro,
profile
micro
profile
is
an
open
source
project.
B
It's
a
set
of
libraries
and
api's
that
you
as
a
Java
developer,
can
use
to
build
micro
services.
Again,
it's
an
open-source
project.
The
companies
that
are
behind
it
are
pretty
much
the
same
ones
that
are
behind
Java,
EE
or
now
Jakarta
EE,
and
the
reason
why
micro
profile
is
a
separate
project
from
Jakarta
at
this
point
is
because
the
goal
is
to
innovate
really
fast
and
at
least
in
the
past,
with
Java
EE.
That
hasn't
always
been
possible.
Okay,
and
so
far
this
really
works.
B
Well,
there
are
many
new
releases
so
back
to
my
diagram
here.
There's
this
little
puzzle
when
to
use
what
again
the
question
is:
when
would
you
should
you
use
kubernetes
and
sto,
which
are
what
I
call
generic
platforms
and
when
should
you
use
frameworks
like
Eclipse
micro
profile
for
certain
languages,
in
this
case
Java?
Okay-
and
here
is
what
I
think
should
be
done,
or
this
is
my
suggestion.
B
Right,
I
say
leverage
the
platform's
crew
Benitez
in
is
do
as
much
as
possible,
so
whenever
you
can
do
something
with
kubernetes
and
is
due
to
implement
and
deploy
micro
services
use
that
functionality.
Why?
Because
it's
generic,
it
works
for
all
types
of
micro
services,
no
matter
how
they
have
been
implemented
for
certain
micro
services
functionality.
However,
that
doesn't
work,
because
at
some
point
you
need
to
write
business
logic.
You
need
to
write
some
code
to
do
certain
things
and
I
will
give
you
several
examples.
B
Just
as
a
heads-up
authorization
exists,
like
you
know,
think
about
project
management,
application
which
has
a
task
and
an
owner
of
the
task,
and
really
only
the
application
knows
in
that
context,
who
the
role
or
who
has
this
role
owner
of
that
particular
task?
Ok,
so
it's
an
example
for
something
a
platform
like
coup.
Benitez
cannot
deliver
and
again
that's
exactly
where
you
would
use
frameworks
like
micro
profile.
B
Okay
and
again,
that's
nice
thing
about
kubernetes
the
ability
to
be
able
to
run
everywhere.
So
here's
the
architecture
and
don't
worry,
I
won't
go
through
all
of
this
now
I
just
wanted
to
show
you
the
full
picture.
What
I
will
do
in
the
next
minutes
here
is
to
really
walk
you
through
the
single
services
but,
as
I
said,
I
really
want
to
or
wanted
to
provide
here.
A
complete
end-to-end
example,
which
means
I
wanted
to
have
a
modern
front-end.
B
So
again
more
about
that
example.
Later
now,
let's
get
a
little
bit
more
concrete
here.
The
first
thing
you
need
in
order
to
develop
microservices
our
container
images
and
containers.
Again,
here's
the
definition
of
an
image
from
dhaka.
Comm
an
image
is
a
package
of
package
of
software
that
includes
everything
needed
to
run
an
application
and
at
run
time
you
execute
containers
that
work
in
their
isolated
environments
so
that
they
don't
interfere
with
each
other.
B
The
key
benefit
of
containers
is
that
there
are
portable
everything
you
need
to
run
an
application
or
in
this
context,
actually
a
micro
service
you
put
together
in
one
box:
ok,
the
application
server,
the
operating
system,
your
actual
application
and
all
of
the
dependencies
and
I
think
it's
a
brilliant
concept,
because
again
it
allows
you
to
run
this
code
in
different
environments
and
here's.
How
easy
it
is
to
get
started?
This
is
all
you
need
to
define
your
first
docker
image.
This
is
the
docker
file
here
in
the
right
column.
B
All
you
need
are
three
lines
of
code,
but
before
I
talk
about
that,
let
me
describe
what's
in
that.
Stick
is
I,
said
I'm
a
big
fan
of
open
source
and
I
chose
here,
an
open,
ass
deck
that
is
fully
based
on
open
source
components.
Ok,
so,
starting
with
the
open
j9
open
j9
is
IBM's
JVM,
which
we
open
source
I
think
two
years
ago,
and
it's
used
in
many
many
of
our
offerings.
In
other
words,
it's
enterprise
proven
the
nice
thing
about
open
j9
is
that
it's
really
great
to
run
container
workloads.
B
The
memory
usage
is
less
than
60%
compared
to
hotspot,
and
the
startup
time
is
40
percent
faster
than
hotspot,
and
the
reason
for
that
is
that
it
was
originally
designed
to
run
on
really
small
devices.
So
that's
component
number
one
in
the
stick
component
number
two
is
open,
JDK
and
I'm,
using
here
a
JDK
release
from
adopt
open,
JDK.
The
nice
thing
about
it
is
that,
first
of
all,
you
get
it
for
free,
but
you
even
get
sick.
B
The
updates
for
a
particular
JDK
after
six
months
of
the
initial
release,
and
then
the
next
component
here
is
open.
Liberty,
open
Liberty
is
basically
the
open
source
version
of
WebSphere
Liberty
and
the
nice
thing
about
it
is
that
it
comes
with
micro
profile
which
I'm
going
to
use
here
for
for
several
features.
So
here
again
in
the
docker
file,
that's
all
you
need
to
do
three
lines
of
code.
This
first
image
that
I
extend
here
open,
Liberty,
that's
the
one
that
contains
the
complete
stack
that
I
just
described.
B
So
that's
step
number
one,
and
this
is
by
the
way,
the
the
front
end
of
the
sample
application.
It's
very
easy.
Okay,
it's
just
the
website
that
lists
five
or
ten
different
links
to
articles
together
with
information
about
the
author's,
the
links
to
the
Twitter
profiles
and
the
blocks.
It's
very
simple
and
to
be
honest
for
such
a
simple
application,
you
most,
you
probably
don't
need
a
cloud
native
approach
here
and
in
all
this
complexity,
okay,
but
we
wanted
to
keep
the
example
really
simple
so
that
you
could
easier
understand
the
different
ya
features.
B
Ok,
so
again,
the
UI
is
not
really
that
impressive,
but
what's
going
on
I
think
is
pretty
interesting
and
that's
what
I'm
going
to
describe
now
so
after
you
have
to
find
the
image.
The
next
thing
you
need
to
think
about
is:
how
do
you
communicate
between
the
different
microservices?
Okay,
because,
as
I
said,
microservices
means
or
a
cloud
native
means
you
break
down
complex
applications
and
multiple
micro
services,
and
then
you
need
to
think
about
how
do
they
communicate?
And
there
are
many
different
alternatives
here.
Many
different
protocols,
you
can
do
it
synchronously
asynchronously.
B
B
This
is
the
browser
running
a
web
application
implemented
with
Roo
us,
but
it
doesn't
really
matter
in
this
context
and
that
one
invokes
api's
from
the
web
api
service,
the
blue
one
here
now
this
one
implements
the
backend
forefront
and
pattern,
which
means
the
web
front-end
only
invokes
API
or
API
of
that
single
service,
but
the
Web
API
internally
invokes
then
two
other
micro
services,
articles
and
authors.
Okay.
B
So
what
that
means
is
you
need
to
expose
REST
API
to
the
outside,
for
example,
the
web
api
service
needs
to
expose
the
api's
to
the
web
app
and
vice
versa.
The
web
api
also
needs
to
be
able
to
invoke
rest
api
from
articles
and
authors
and
here's
how
it's
done.
So.
This
is
the
example.
This
is
the
implementation
of
the
method
to
get
articles.
The
api
that
returns
the
list
of
articles.
Okay,
the
the
endpoint
get
multiple,
and
in
order
to
do
that,
you
can
use
standard
jax-rs.
So
this
is
nothing
new
right.
B
B
Additionally,
you
can
use
here
open,
API
or
swagger
to
do
you
know
further
annotations
so
that
you
can
document
the
interface
of
your
endpoint
directly
in
the
code
to
make
sure
the
documentation
doesn't
get
out
of
sync,
with
the
actual
implementation
of
your
API
and
again,
very
simple
and
straightforward.
You
have
these
annotations,
like
API
responses
and
operation
and
so
forth.
B
Once
you
have
done
that,
you
get
a
nice
UI,
a
nice
web
front-end
that
is
delivered
with
open,
API
and
integrated
in
open
Liberty,
and
this
is
basically
the
documentation
of
the
API,
but
not
only
that.
It's
also
the
it's
also
an
API
Explorer.
So
what
you
can
see
here
is
that
you
can
actually
execute
these
api's
directly
from
this
web
UI.
So
it's
basically
a
test
UI
if
you
want
so
nothing
really
fancy
but
I.
B
Think
very
nice
and
very
easy
to
use
when
you
use
three
Java
EE
and
micro
profile,
and
then
the
next
thing
is
you
want
to
be
able
to
invoke
other
services
again.
The
Web
API
service
in
this
case
wants
to
invoke
the
office
service
so,
and
this
is
now
the
first
time
where
micro
profile
comes
in,
because
micro
profile
provides
this
really
nice
rest
api
and
it
allows
you
to
invoke
other
services
very
easily.
B
Okay-
and
this
is
what
you
see
here-
this
highlight
it's
lipid
shows
that
you
can
define
an
interface
to
the
office
service
and
that's
really
all
you
need
to
do
just
an
interface
here,
the
public
method
to
get
author,
and
you
don't
have
to
worry
about
the
implementation,
because
the
implementation
is
provided
for
you
more
or
less
magically
by
micro
profile
by
the
restaurant.
Ok,
all
you
need
to
do
here
is
to
define
the
DNS
name
and
in
the
path
of
your
endpoint
right.
B
This
is
the
first
highlighted
snippet
and
by
the
way,
kubernetes
takes
care
about
the
service
discovery
right.
All
you
need
to
know
is
the
dns
name,
the
name
of
your
service
and
all
the
routing
and
magic
that
goes
on
there.
That
is
something
that
is
handled
by
kubernetes,
for
you
ok,
very
easy
to
use
from
a
developer
point
of
view,
and
then
the
second
snippet
here
shows
how
you
can
now
invoke
the
service
and
the
nice
thing
here
is
again:
you
don't
have
to
implement
this
interface
right.
B
You
get
the
implementation
magically
and
you
even
get
a
typed
interface.
Ok,
so
very
easy
to
use,
and
you
don't
have
to
worry
about
all
the
marshalling
and
marshalling
of
data,
so
that
was
scenario
number
one.
If
you
want
now.
The
next
scenario
is
traffic
management
and
that's
where
it
still
comes
into
play
now.
I
have
another
little
demo
here
and
in
order
to
show
how
to
route
traffic
I
created
a
second
version
of
the
Web
API
service.
Ok
and
the
second
one
is
very
different,
very
similar
to
the
first
one.
B
This
is
the
first
one
which
returns
five
different
articles:
okay,
the
second
one
returns
10,
so
in
other
words,
when
you
deploy
both
version,
1
and
2
at
the
same
time,
you
know-
and
you
hit
refresh
in
your
browser-
you
will
see
sometimes
five,
sometimes
ten
being
returned.
Okay,
now
ECU
allows
you
to
control
this
traffic
and
to
define
what
exactly
or
how
exactly
you
want
to
post
expose
these
different
versions
and
here's
how
it's
done
as
always.
Typically,
you
use
Yama
fires,
okay
and
then
it
still
has
some
additional
resources
in
this
case
here.
B
It's
this
resource
called
virtual
service
that
you
put
on
top
of
the
service
that
is
provided
by
ku
Benitez,
and
once
you
do
that
you
can
then
go
ahead
and
define
these
routes.
Here
you
can
say:
okay,
virtual
one
I
want
80%
of
my
traffic
to
be
routed
to
and
version
to,
20%
it's
a
very
simple
sample.
But
again
you
can
do
much
more.
You
can
route,
for
example,
based
on
the
headers.
In
the
request
you
can
say:
okay,
all
the
users
who
come
in
from
a
mobile
device
should
get.
B
B
Once
you
have
deployed
or
applied
this
this
policy,
you
can
actually
see
that
the
routing
works,
and
this
is
a
tool
called
key
ally,
again,
obviously
also
aku
sauce,
which
is
now
part
of
it
still
so
once
you
install
is
do
in
your
kubernetes
cluster,
you
get
this
tool
for
free
and
I.
Think
it's
really
an
awesome
tool
here,
because
it
shows
you
automatically
all
the
you
know
how
the
traffic
flows
and
what
you
see
here
again
is
the
Web
API
service
with
version
one
and
two,
and
also
the
articles
and
authors
service.
B
B
Okay,
so
resiliency
means
that
your
app
remains
responsive,
even
when
single
micro
services
are
not
available
and
in
this
case,
I
want
to
demonstrate
it
by
shutting
down
the
articles
and
the
author's
service
and
I
want
the
web
application
still
to
be
able
to
display
the
articles
and
I
want
the
web
api
service
to
still
be
responsible.
Okay,
so
that's
a
little
demo
scenario
here
and
this
can
be
done
rather
easily,
and
this
is
a
case
now
where,
as
I
said
at
the
beginning,
you
cannot
rely
on
the
platform's.
B
You
cannot
rely
on
kubernetes
and
SEO.
Why?
Because
this
functionality
is
application
specific.
This
is
something
that
you
need
to
implement
in
your
code
and
here's
how
it's
done
very
easy.
This
is
case
number
one,
which
is
how
what
can
you
do
when
the
author's
service
is
not
available?
So
what
you
see
here
is
the
implementation
of
the
endpoint
get
articles
of
the
Web
API
service
and
the
highlighted
snippet
shows
what
happens
when
the
author's
service
is
not
available.
The
solution
here
is
very
easy.
B
Instead
of
not
returning
any
articles,
you
simply
return
the
articles,
but
without
the
author
information.
So
this
is
plain
old
Java,
nothing,
fancy,
okay,
but
then
to
go
one
step
further
and
again.
This
is
where
micro
profile
comes
into
play,
and
this
is
what
you
need
to
do
or
can
do
when
the
article
service
is
not
available,
because
when
the
article
service
is
not
available,
an
exception
is
thrown,
and
that
triggers
another
method,
a
fallback
method,
and
you
can
define
that
by
using
this
micro
profile
annotation
at
fallback.
B
So,
in
this
current
case,
we
invoke
the
fallback
method
and
that
one
simply
returns
the
articles
that
were
read
the
last
time
the
article
service
was
available.
So
in
other
words,
all
we
do
here
is
to
use
a
simple
caching,
okay,
nothing,
fancy
and
really
easy
to
do,
and
here's
how
it
looks
in
the
UI.
This
is
the
UI
at
the
simplification
fully
functional
when
all
services
are
available.
B
Okay,
next
scenario,
authentication,
authorization
and,
to
be
honest,
this
one
was
for
me
anyway,
the
hardest
part
to
get
it
to
work,
because
I
really
assume
that
that
is
do
or
end
or
coup
Benitez
would
would
provide
more
support
in
order
to
build
these
things.
But
let
me
give
you
some
big
background
first
now,
in
order
to
do
authentication,
authorization
I
really
want
to
go
with
standards.
Here
and
I
think
the
standard
way
to
do
that
these
days
is
to
use
Open
ID
Connect,
which
is
an
extension
of
auth.
B
In
other
words,
it
gives
you
and
a
nexus
token,
but
also
an
identity
token,
which
means
you
can
use
it
for
both
authentication
and
authorization.
Okay
and,
for
example,
when
you
use
it
together
with
JWT
tokens,
the
JSON
web
tokens
there
is
nice
documentation
is.
Do
that?
Tells
you
how
you
can
how
you
can
make
sure
that
the
user
is
authenticated
when
invoking
certain
endpoints?
And
that's
exactly
what
you
see
here.
So
this
is
the
the
simplest
sample
if
you
want.
B
Okay
and
all
you
need
to
do
here
is
to
say,
okay,
the
in
book
on
the
user
that
invokes
this
method
needs
to
have
a
valid
JWT
token
from
the
open
ID
provider,
in
this
case,
IBM
app,
ID,
okay,
very
easy
and
straightforward.
Now,
as
I
said,
it
wasn't
really,
at
least
for
me
not
really
as
easy
as
I
wanted
and
I
had
expect
to
get
some
some
functionality
from
kubernetes.
B
That
would
help
me
to
get
the
JWT
tokens
because
there's
documentation
that
helps
you
how
to
use
JWT
token
view
and
micro
profile
I
couldn't
really
find
good
documentation.
That
tells
you
how
to
get
it
in
the
first
place,
at
least
not
from
my
specific
open
ID
connect
provider
using
open
source,
only
okay,
so
what
I
ended
up
doing
was
I
implemented
this
authentication
service,
and
that
does
nothing
else
then
connecting
to
an
open,
ID,
Connect
provider
to
get
the
JWT
token
and
that
open
ID
connect
provider
can
be.
You
know,
Twitter
Facebook.
B
What
have
you
or
I
chose
here?
An
IBM
service
called
IBM
app
ID
now
the
reason
why
I
chose
it
here
is
because
when
you
want
to
build
enterprise
applications,
you
don't
want
to
recreate
your
users
in
some
cloud
directory
or
whatever,
but
you
want
to
be
able
to
access
and
integrate
your
existing
organization
directories
and
that's
one
of
the
nice
things
that
IBM
app
ID
allows
you
to
do,
because
you
can,
you
know,
connect
to
your
Active
Directory
using
sam'l.
You
can.
You
know,
leverage
your
existing
login
dialogs
and
all
of
this
right.
B
So
that's
why
I
chose
it,
but
it's
only
an
optional
component,
so
I'm
just
quickly
here
everything
that
you
see
in
the
two
left
columns.
This
is
all
open
source.
Everything
in
the
right
column
is
not
open
source,
but
it's
optional
only
and
it's
relatively
easy
to
replace
with
other
implementations.
Okay,
so
yeah,
that's
essentially
what
I
did
well
I
added
this
authentication
service
so
that
I
can
get
the
JWT
token
and
once
I
have
the
JWT
token
I
can
pass
it
into
the
the
the
Web
API
invocations
and
here's
an
example.
B
So,
first
of
all,
I
want
to
be
able
to
log
in
this
is
the
login
page
that
app
ID
provides
for
you.
It
looks
pretty
blank
and
easy
and
straightforward,
and
that's
the
intention
here.
Obviously
you
can
customize
it
to
your
needs
right
for
your
own
branding
company
branding
and
as
soon
as
you
use
them,
or
you
would
use
your
own
login
page
anyway,
and
you
wouldn't
have
to
create
this
one,
but
for
testing
purposes.
I,
just
you
know,
use
this
one
here,
it's
just
to
test
users,
user
and
admin.
B
Okay,
now
to
go
one
step
further,
once
you
have
the
JWT
token,
you
can,
you
know,
define
these
policies
in
sto
in
sto,
Yama
files,
or
you
can
even
use
it
in
your
Java
code
again
using
micro
profile
functionality
and
just
quickly,
here's
how
it's
done
so
in
the
server.xml
file.
This
is
the
configuration
file
of
open
Liberty.
You
define
a
couple
of
things
about
the
JWT
token.
First
of
all,
again,
what
is
your
provider
in
this
case
here?
B
You
can
finally
use
the
JW
to
JWT
token
very
easily
here
just
by
using
this
dynamic
injection,
and
this
is
the
easiest
possible
way
to
use
it.
So
all
I
do
here
is
to
check
the
email
address.
So
when
you
get
the
JWT
token,
you
can
get
all
the
claims.
The
different
roles
and
everything
right
in
this
case
I
make
it
really
simple.
I,
say:
okay:
if
the
email
is
the
email
of
the
admin,
the
admin
is
allowed
to
invoke.
This
endpoint
called
managed,
which
doesn't
do
anything
with.
B
It
doesn't
really
make
sense,
but
just
for
illustration,
illustration
purposes
right
and,
and
if
you
are
an
admin,
you
can
do
it
if
you
are
not
an
admin,
if
you're
just
a
normal
user,
you,
you
know
this.
This
method
would
return
an
arrow
okay,
next
topic
observability.
So
this
is
something
that
developers
now
need
to
understand
at
least
more
than
previously
right.
B
So
in
a
couple
of
years
ago,
I
remember,
you
know,
developers
typically
would
just
want
to
implement
code
and
then
throw
it
over
the
fence
and
someone
from
UPS
would
pick
it
up
and
operate
and
deploy
and
everything
right.
This
is
not
how
it
works
anymore,
with
cloud
native
and
in
microservices.
This
is
not
how
the
whole
DevOps
culture
really
works
or
should
work
right.
B
You
really
want
to
bring
together
all
the
different
people
you
build
and
deploy
and
operate
a
full
micro
service
of
full
application
end-to-end,
and
that
means
that
developers
at
a
minimum
need
to
understand
these
different
observability
topics,
for
example,
tracing
logging,
monitoring,
matrix
health
checks
and
so
forth.
So,
to
give
you
some
examples,
let's
make
it
more
concrete
again
and
let's
start
with
logging.
Ok,
because
that's
that's
what
every
developer
understands
you
know
you
implement
something
something
doesn't
work.
B
You
want
to
know
where's
my
log
fire
now
in
this
case
there
is
not
the
one
locked
file
anymore
right.
So
the
question
is:
where
can
you
fire
find
all
the
logs
in
one
central
place?
Unfortunately,
there
are
weights
Intuit's
that
allow
you
to
do
that,
so
again,
here's
a
little
sample.
You
know
this
now
already
the
web
application
invoking
web
api
and
web
api,
invoking
articles
and
authors
and
if
everything
works
you
can
see
now
all
the
locks
here
nicely
in
one
place.
B
B
How
can
you
see
which
service
invokes
which
other
service?
How
long
does
it
take
other
bottlenecks
and
so
forth
and
so
forth?
And
the
way
you
do
that
is
by
using
some
oak
tracing,
which
is
a
vendor-neutral
API,
and
then
there
are
different
tracing
systems
like
Yaga
and
Zipkin,
and
you
can
very
easily
just
use
that
in
micro
profile,
all
you
need
to
do
here
is
to
include
a
separate
open,
tracing
Zipkin
file,
and
you
don't
have
to
do
anything
else.
B
In
other
words,
you
don't
have
to
to
you
know
forward
any
HTTP,
headers
or
anything.
All
of
that
is
done
for
you
by
micro
profile,
so
you
just
write
the
Java
code
as
always,
but
then
you
get
additional
tracing
information
that
tracing
information
is
stored
and
then
you
can
use,
for
example,
here
the
Yaga
UI
to
see
what
exactly
is
going
on
in
this
case.
What
we
see
here
is
that
the
web
api
was
invoked
and
the
web
api
service
then
invoked
the
article
service.
B
Okay,
next
topic
matrix-
and
here
is
another
example
where
micro
pathi
comes
in
right,
because
certainly
the
platform's
crew
Benitez
in
is
to
you.
They
can
do
a
whole
bunch
of
monitoring.
For
you
already
like,
for
example,
how
many
times
was
an
anvil
at
endpoint
invoked
right,
but
for
other
scenarios,
that's
not
possible,
because
sometimes
you
want
to
track
certain
information
that
happens
somewhere
down
in
your
you
know,
Java
code,
which
is
not
exposed
to
the
endpoint
directly,
and
that
again
is
where
microfolk
comes
into
play,
because
micro
profile
provides
these
additional
annotations.
B
If
there
are
too
many
instances,
then
they're
shut
down
and
so
forth
and
ku
Benitez
needs
to
be
able
when
and
if
an
application
or
a
micro
service
is
actually
running
and
the
way
this
is
done
is
by
using
here
these
two
probes
called
lifeless
probe
and
readiness
probe
in
the
Yama
file
of
the
deployment
of
your
micro
service.
Okay,
now
it's
important
to
understand
that
there
are
actually
two
different
probes.
Lifeless
means:
when
is
the
application
server
available?
When
has
it
started?
But
that's
not
obvious.
B
That's
not
always
the
same
time
when
the
full
application
is
available,
especially
when
you
you
know
need
to
do
a
lot
of
initially
initialization
first,
for
example,
if
you
want
to
create
a
database
connection,
it
takes
some
time
right.
So
there's
a
delay
between
the
life
is
probe
in
the
readiness
probe
and
that's
why
you
have
these
two
different
ones
here
now
in
order
to
define
when
an
application
is
actually
ready,
you
can
use
another
Micro
profile
function
or
functionality.
B
It's
here,
this
health,
endpoint
and
the
health
check
interface,
and
in
this
call
method
here
in
the
first
limit,
you
can
simply
define
when
the
application
is
ready.
Okay,
so
in
this
case
it's
all,
it
always
returns
ready,
which
doesn't
really
makes
much
sense,
because
in
this
case
the
life
is
probe
would
be
the
same
as
readiness
probe
more
or
less.
But
but
you
get
the
point
and
in
here
you
could
then
add
checks
for
you
know
it's
the
database
connection
there
next
topic
and
that's
the
last
bigger
topic
here.
B
It's
persistence
because
that's
another
thing
you
typically
need
to
build.
You
know
complete
end-to-end
enterprise
applications
and
what
I've
done
here
is
to
use
JPA
for
the
persistence
of
the
article
service
and
again,
as
you
know,
everything
in
the
right
column
here
is
not
an
open
source
component
and
I'm
using
here
another
service
from
the
IBM
cloud
called
db2,
but
since
this
is
just
an
SQL
service
or
database
and
since
we're
using
JPA,
obviously,
as
you
know,
this
can
be
changed
very
easily.
B
So
it's
really
just
an
example
and
here's
how
you
do
it.
This
is
again
some
configuration
that
you
need
to
do
in
the
server.xml,
the
the
configuration
file
of
Liberty
and
just
on
a
high
level.
You
need
to
do
at
least
two
things
here.
One
is
you
need
to
define
the
database
driver,
the
JDBC,
a
JDBC
driver,
and
the
second
thing
is
you
need
to
define
your
credentials
to
access
that
data
source?
Okay,
once
you
have
done
that
you
can
use
standard,
JPA
functionality
and
in
this
case
the
article
service
stores
articles.
B
So
there's
one
table
called
article
which
stores
entities
called
article
and
every
column
here
is
one
property
in
the
class
and
the
property
ID.
Here
is
this
special
column
with
the
UN
ID
and
here's
how
it's
done.
We
have
easy
and
straightforward
and
I
think
there
were
some
other
webinars
about
it
previously.
So
if
you
want
to
find
out
more
check
out
those
so
I
said
I
use
here
SQL
as
the
database
for
articles.
B
My
are
variables,
for
example,
here
the
variable
whether
or
not
I
want
to
use
an
SQL
in
the
SQL
database
or
in
in
memory
data
store.
Okay,
then,
in
the
java
code,
it's
very
easy
to
use,
use
you
simply
use
again
here,
the
ED
inject
and
then
at
config
property
and
dynamic
property
injection
and
give
it
a
name
and
the
default
value.
And
that's
really
all
you
need
to
do
very
easy
and
straightforward.
B
B
We
wrote
many
many
scripts
and
documentation
and
I
saw
the
other
day
that
we
actually
wrote
more
lines
of
code
for
scripts,
the
nature
Java
code
and
again
it
should
be
a
matter
of
30
minutes,
maybe
an
hour
to
set
up
everything
locally,
and
if
you
have
already
cluster
it's
even
much
faster
than
that
so
I,
you
know
just
recommend
check
out
the
sample.
If
you
want
to
know
more
about
it
and
I
would
love
to
get
feedback
by
the
way.
If
you
like
the
sample,
let
me
know
if
you
don't
like
it.
B
B
So
this
is
the
it's
just
a
screenshot
of
the
repo
called
cloud
native
starter
and
in
there
there's
also
many
many
dot
links
to
blocks
I
think
we
wrote
a
series
of
25
block
entries
about
it.
So
if
you
want
to
find
out
more
about
the
topics
that
I
just
talked
about,
go
to
the
repo
and
check
out
those
links
and
obviously
also
want
to
call
out
here
that
iBM
has
a
company
to
service
which
I
think
is
pretty
good.
Why?
B
Because,
first
of
all
it's
the
managed
service,
it's
very
easy
to
get
your
own
cluster
just
by
clicking
one
button
and
basically
choosing
what
server
configuration
you
want
to
have.
We
support
there's
many
data
centers
worldwide.
We
have
multi
availability
zones.
You
can
choose
from
many
many
different
hardware
configurations
down
to
bare
metal
and
I
think
we
are
the
only
ones
supporting
bare
metal
for
managed
crew
Benitez
and
the
other
nice
thing
is.
There
is
a
managed
it
steel
in
a
managed
care
native
plugin.
B
So
if
you
want
to
play
with
these
technologies,
just
go
to
our
cloud,
get
a
free
light
account.
You
know
and
then
play
around
with
these
things
and
in
try
out
this
example,
which
is,
you
know,
requires
kubernetes
as
well
as
this
deal,
and
that
brings
me
to
the
end.
Here's
a
quick
summary.
This
QR
code
is
a
link
to
the
repo.
If
you
want
to
take
a
picture
and
go
there
and
just
quickly
as
I
said,
sometimes
it
can
be
a
little
bit
confusing
when
to
use.
B
What,
when
you
Scooby
need,
is
an
sto
on
the
one
inside
when
to
use
micro
profile
or
other
frameworks
on
the
other
inside
again,
I
think
you
should
use
as
much
Coogan
meters
and
is
to
function
T
as
possible,
because
it's
generic,
but
sometimes
that's
not
sufficient.
Sometimes
you
need
to
implement
microservices
functionality
in
your
code
and
that
that
that's
exactly
where
micro
profit
comes
into
play.
Second
point:
IBM:
laughs,
open-source,
I
love
open
source.
B
All
the
core
components
of
this
example
are
available
as
open
source
and
I
also
told
you
that
iBM
has
done
a
lot
of
good
things
for
open
source.
Recently,
a
lot
of
great
contributions
like
open,
g9,
adopt
open
JDK.
We
were
part
of
open
Liberty
and
we
are
part
of
the
cloud
native
computing
foundation.
Eastview
is
basically
the
original
idea
of
SEO
came
from
IBM
research,
so
there's
many
things
that
we
are
doing
around
open
source.
B
Ibm
developer
is
our
portal,
our
entry
page
essentially
for
developers,
there's
lots
of
other
good
samples,
tutorials
videos
in
the
course,
and
if
you
want
to
get
started,
there's
a
free
light
account
which
basically
gives
you
access
to
many
of
our
services.
It's
free!
You
don't
have
to
give
us
a
credit
card,
there's
no
time
restriction
and
you
can
just
go
ahead
and
play
around
with
all
of
these
nice
things.
B
A
B
A
B
Yeah
yeah
open
liberties,
our
version
of
WebSphere
Liberty,
it's
a
lightweight
Java,
EE
application,
server
very
flexible
and
it
comes
with
an
implementation
or
micro
profile
right.
So
it's
it's
it's.
You
know
updated
regularly
with
the
latest
and
greatest
micro
profile
releases
and
as
I
showed,
there's
also
all
these
daca
images.
So
it's
really
easy
to
get
started
without
really
having
to
install
you
know
a
big
standalone
or
local
installation.
You
just
can
use
in
the
docker
container
and
then
go
ahead
and
build
services.
A
B
A
So
it
seems
that
this
is
everything
we
have
for
today.
Well,
thank
you.
So
much
do
keep
in
mind
that
the
recording
will
be
available
and
you
can
always
get
in
touch
with
Lucas
or
me
over
the
web.
So
if,
if
you
come
up
with
a
follow
up,
questions
we'll
make
sure
those
get
answered
and
thank
you
so
much
for
attending
live
and
we'll
be
Dutch.