►
From YouTube: 10 Strategies For Developing Reliable Jakarta EE & Microprofile Applications For The Cloud
Description
Ever thought of implementing a modern cloud architecture with Jakarta EE and MicroProfile applications but don’t know which practices to follow? This talk will highlight 10 strategies that will help you implement robust scalable cloud-ready applications!
///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
I
sharing
the
okay
you're,
sharing
the
presentation,
hi
everyone
and
welcome
to
this
week's
Jakarta
Tech
Talk.
Today
we
have
Fabio
Theresa
who's,
going
to
be
sharing
his
presentation,
so
family
I'm
gonna,
let
you
go
ahead
and
jump
into
it.
Okay,
just
give
me
a
second
because
I
think
that
I'm
sure
in
the
manager,
but
not
the
presentation
yourself.
Okay,
what
do
I
change
that?
Okay,
so
I
have
to
stop
it.
A
A
A
Yes,
apologies
for
the
technical
issues,
okay,
so
many
thanks
for
having
me
by
it
is
a
pleasure
to
talk
in
this
your
car,
the
Tech
Talk.
So
this
is
10
strategies
for
developing
reliable
Jakarta
in
your
micro
profile
applications
for
the
cloud
application
development
for
more
than
times
before
we
begin
it
would
be
good
if
everyone
that
it's
seeing
the
stock
recall
their
own
life
to
having
immediate
knowledge
of
what
your
car
Java
EE
is
in
a
sense
what
the
eclipse,
a
micro
profile,
project
works
and
some
notions
on
distributed,
concert
some
clustering.
A
So
if
that's
the
problem,
don't
worry
if
you
have
any
questions
and
any
time
let
Vanessa
know,
and
she
and
I
will
find
the
time
reply
to
them.
So
speaking,
today,
it's
father
Teresa
pleasure
to
meet
all
of
you.
I
am
service
team
leader
Pereira
Services
Limited,
which
is
a
company
that
works
for
in
that
is
based
on
the
UK,
and
we
are
the
main
maintenance
of
the
parrot
platform,
which
is
an
innocence.
A
replacement
or
evolution
of
the
original
class
trees
open
source
edition
server.
A
We
also
have
a
commercial
sport
and
open
yet
eco,
suburbia
partnership
that
we
have
or
a
school
systems
the
Azul
systems.
We
are
founding
members
of
the
Eclipse,
a
micro
profile
project.
We
are
both
members
of
the
Enterprise
Edition
for
Java
project
as
well,
and
we
are
major
contributors
to
the
Jakarta
specifications.
So
we
very
well
involved
in
all
of
this
process.
A
So
at
the
moment
there
are
no
reference
implementations,
but
the
korean
edition
of
the
eclipse
class,
whose
project
which
was
released
a
few
weeks
ago,
which
is
class
v6,
which
at
the
moment
I
think
it's
in
Nakhla
build
mode.
It's
the
correct,
that's
a
standard
of
how
Jakarta
e9,
which
is
an
explosion
of
the
D
technology,
should
behave
so
Eclipse
micro
profile,
on
the
other
hand,
was
initially
conceived
as
a
technology
to
develop
clouded
rented
microservice
applications
duty
holla,
slow
Java.
A
He
was
at
the
moment
in
innovating
the
platform
for
the
title,
this
type
of
architectures,
so
it
was
similar
to
Java
EE,
but
with
less
restrictions.
The
idea
is
that
anyone
could
put
the
code
ahead
of
the
specification,
see
that
there
was
an
issue
and
useful
death
technology
right,
a
few
set
of
tests
as
part
of
the
disk,
a
and
publish
it,
and
that
would
be
an
API
and
that
could
be
designed
a
part
of
this
of
this
technology.
A
So
at
some
point
the
idea
was
that
my
profile
was
going
to
be
like
the
standard
of
innovation
in
the
enterprise
Java
environment,
but
they've
come
jump.
It
Jakarta
a
comma
hop
decade
at
a
full
suit
price,
so
there
was
some
kind
of
overlap
on
thinking.
Okay,
what
of
the?
What
about
of
these
API
so
Michael
profit
that
can
be
used
in
your
cart
and
visa
versa.
So
at
the
moment
let's
say,
let's
say
we
ran
a
roadblock,
we're
trying
to
figure
out
if
a
full
technology
of
Micra
profile
can
be
broke
over
to
jakarta.
A
Maybe
it
should
be
remaining
as
its
own
framework,
apart
with
clear
goals
and
mindset,
so
be
using
this
technology
to
illustrate
some
strategies,
but
they
may
change
in
the
future
if
they
become
officially
part
of
Jakarta
he
or
they
stay
at
the
own
technology
in
a
sense.
So
let's
talk
about
the
main
challenges
that
we
have
for
java
application
development.
Nowadays,
one
of
the
problems
that
we
mostly
have-
or
at
least
most
of
the
users
I
have
interacted
with
house-
is
proper
distribution
application
development.
That
means
an
application
that
lives
in
a
distributed
arrangement.
A
That
is
either
a
recent
early
or
particularly
scale
up,
and
it
should
handle
some
degree
of
quality
attributes.
That
means
only
needs
to
respond
to
an
appropriate
number
of
current
user
requests
per
second
and
to
allow
these
users
to
feel
that
there
is
reliable
and
it's
performing
well
so
one
of
the
main
mechanisms
through
history
that
has
allowed
us
to
do
this.
A
It's
clusters,
which,
if
some
of
you
are
aware
of
how
clusters
work
or
if
you
were
aware
of
how
clusters
work
on
applications
habits
in
law
ye
we're
course
that
was
this
is,
let's
say,
a
static
method
of
defining
a
set
of
multiple
server
instances
that
live
on
a
network.
And
then
you
will
have
to
manually
configure
the
mechanisms
on
which
these
clusters
star
and
hand
the
load
balancing,
handle
the
request
for
all
these
users
and
the
security
aspects
of
it.
A
The
an
optimization
of
decals
used
to
maintain
this
cluster
high
availability
and
reliability
as
I
said,
because
the
idea
is
to
allow
users
to
feel
like
the
application
is
performing
well
without
any
impact
on
the
that's
a
tell
usage
and
to
also
deep
light
in
water
logs
and
simplify
:,
because
if
at
the
end
developers
were
developing
complex
applications
with
too
much
boilerplate,
then
it
would
in
long
term
become
a
nightmare
to
maintain.
So
the
question
is:
can
Jakarta
a
Michael
profile
or
Michael
profile
here
with
reliable
clustering?
A
And
the
answer
is
yes,
of
course
it
can,
but
there
are
some
set
of
strategies
that
you
need,
because
from
the
get-go
this
is
not
clear.
There
is.
The
main
challenge
is
that
there
are
no
standard.
Api
is
in
Jakarta
at
the
moment
that
define
how
a
bender
then
implements
these
specifications
define
how
clustering
should
walk
in
many
aspects.
So,
and
it's
only
not.
This
is
not
the
only
problem,
because
microservice
architectures
have
their
own
specific
demands
and
requirements
on
how
you
should
implement
these
distribution
arrangements.
So,
unfortunately,
even
there
is
no
standard
mechanism.
A
No,
it's
not
Ana
starting
point
that
you
can
use.
There
are
some
strategies
that
has
been
proved
through
the
let's
say
through
the
last
latest
years
of
the
technology's,
come
and
go
and
we
have
their
web
applications
for
them
that
you
can
use.
The
future
is
looking
bright,
because
the
idea
is
that
after
Jakarta
a10
comes
out
of
the
gate,
future
versions
of
they're
really
of
these
specifications
will
bring
changes,
and
hopefully
there
will
be
an
under
specification
that
allows
you
to
be
fine.
How
distributed
arrangement
should
work.
A
So
at
the
moment,
the
only
thing
that
we
have,
that
is
innocence,
standard
in
Jakarta
II
for
distribution.
Is
this
distributable
element
in
that
you
can
be
fine
in
the
web.xml
deployment?
The
scripture?
Those
of
you
who
are
familiar
with
the
servlet
specification
are
aware
that
you
can
define
these
as
a
way
to
tell
the
tablet
container
that
web
sessions
that
live
in
that
container
should
wrap
be
replicated
to
other
members
in
a
cluster
arrangement.
A
However,
all
of
that
definition
is
in
a
sense,
is
just
a
mildly
stipulated
contract
at
the
bend
of
scans
follow-up
to
some
point,
but,
for
example,
while
flag
does
it
differently
to
what
we
our
server
does
or
to
what
open
Liberty
does
or
to
what?
What
logic
does
so
each
vendor
can
do
it
differently,
and
this
is
actually
just
only
limited
to
web
sessions.
What
about
data
that
is
positioned
on
a
database
or
data
that
is
managed
as
part
of
the
HIV
container?
All
of
that
is
not
correctly
standardized,
so
it
is
a
bit
limiting.
A
What
happens
when,
for
example,
an
application
that
is
developed
for
a
small
user
base
needs
to
scale
up
and
announced
to
be
moved
to
the
cloud
and
as
a
developer,
you
think
to
know
okay,
my
application
was
handling
10
users
per
second,
which
was
absolutely
an
small
number,
and
now
it
needs
to
handle
hundreds
or
even
thousands,
of
users
per
second.
How
can
I
add
up
by
application
to
do
that
with
minimal
code
changes,
so
it
falls
on
us
benders
to
fill
the
gaps
in
that
yokatta.
A
A
specification
doesn't
give
us
the
strategy
to
do
that
in
order
to
promote
them
to
allow
that,
however,
there
are
no
silver
bullets,
even
if
we
have
no
standards.
This
is
try
to
sell
these
strategies
are
not
silver
bullets
that
should
be
applied
in
all
cases,
because
there
are,
of
course,
some
mild
considerations
when
you
are
developing
a
new
application,
and
you
should
be
aware
that
if
you're
doing
that,
then
you
could
fall
in
some
problems.
A
If
you
are
not
considering
some,
let's
say
specific
problems
that
you
might
awright,
then
you
might
encounter
while
developing
these
applications.
So,
let's
start
with
strategy
number
one
which
is
statelessness,
so
one
question
that
I
get
asked
about
when
a
new
development
new
developers
is
starting,
a
new
project
is,
should
I
handle
State
on
my
application
in
memory
and
the
come
on
answer
that
I
give
Deniz,
don't
bother
doing
that
because
it's
a
complicated
to
maintain
in
the
long
term.
It
is
better
if
you
just
focus
on
States
as
components.
A
The
idea
is
that
you
should
use
less
memory
in
the
middleware.
Hence
you
optimize
resources.
You
have.
Your
application
is
easy
to
coordinate,
because
you
don't
need
to
worry
about
migrating
or
maintaining
data
in
memory,
and
you
use
less
code
to
also
do
that.
So
you
also
have
that
as
a
bonus
and
how
to
do
this,
if
you're
using
the
CDI
specification,
you
should
focus
on
using
the
request,
scope,
annotation
or
if
you
use
in
the
common
ground,
a
gba
specification,
you
should
be
using
the
stateless
annotation,
which
is
plenty
plenty
stack
forward.
A
A
That
means
that
when
I'm
using
calculator
service
yet
every
time
that
I
execute
this
measure
not
getting
an
instance
that
it's
dynamically
resolved
by
the
CDI
container
when
I
execute
the
method,
I'm
also
retrieving
the
name
of
the
current
principal,
which
in
northern
terms,
is
the
user
requesting
to
do
this
operation
so
I'm
forcing
authentication
and
I'm
forcing
authorization
of
this
user.
Every
request
that
is
been
executed
by
this
service
so
a
stateless,
and
this
is
that
that
you
need
pair
every
request
that
you
are
getting
for
each
user.
A
You
are
assembling
all
the
components
that
you
need
in
order
to
execute
the
operation.
When
all
this,
then
the
operation
is
done.
All
these
components
that
are
needed
are
garbage
collector
by
the
ABN
or
return
to
a
pool
or
the
state
is
discarded.
So
how
about
Singleton's
so
strategy?
Number
two
is
that
you
should
consider
the
user
Singleton's,
because
even
if
single
turns
are
just
simply
the
management
of
just
one
instance
per
JVM
of
this
specific
class
or
component
that
you're
handling,
they
can
be
useful
to,
let's
say,
handle
the
coordination
of
set
and
resources.
A
But
you
mean
you
must
be
aware
not
to
do
over
coordination,
because,
if
you're
writing
resources
to
but
you're
writing
code
to
prevent
resources
from
being
lockout
or
from
being
access
and
concurrently
by
add
millions
of
users
at
a
time,
then
you
are
getting
yourself
into
trouble.
So
my
recommendation
is
make
a
single
turn
only
when
a
user
need
to
do
or
worry
about
concurrent
modifications.
That
means
is,
for
example,
you
have
a
single
turn
that
is
controlling
a
key
that
needs
to
be
accessed
by
the
only
one
user.
A
At
a
time,
then
that
is
not
a
good
idea,
because
then
you
need
to
walk
about
coordinating
Duncan
Karina's
x-axis,
so
that
is
really
just
a
havoc
in
playing
place.
So
don't
worry
about
that.
All
the
single,
a
single
aspect
of
an
application
requires
coordination.
So
if,
for
example,
you
need
to
access
a
cache
and
this
cache
has
sensitive
information
that
is
stored
for
each
user,
then
just
forget
about
writing
your
own
cache.
A
You
can
just
simply
write
a
single
turn
that
works
and
half
a
state
or
just
a
wrapper
for
this
cache
and
allows
you
accessing
when
the
time
is
right
for
this
specific
users.
So,
like
the
first
strategy
you
can
use
on
DCP
I
expect
the
application
scope
annotation,
which
will
allow
you
to
mark
a
component
as
a
single
tone
or
for
the
h-e-bs
specification
you
can
use
the
add
singleton
annotation.
A
So
here
is
an
example
of
code.
I
have
a
component
here
called
token
generator,
which
is
a
class
that
I
can
be
used
for
an
application
that
needs
generate
JSON
web
tokens
more
on
that
later,
that
you
can
use
in
order
to
allow
users
to
authenticate
against
your
application.
So
the
tokens
need
to
read
a
specific
data
which
they
tend
to
read.
They
need
to
read
the
specific
data
about
the
issue
or
the
entity
that
is
issuing
the
tokens.
So
you
don't
want
this
specific
entity,
it's
read-only.
A
It
doesn't
change,
padding
and
lifecycle
of
an
application,
so
you
might
want
to
read
it
once
and
once
you
have
that
you
just
can
simply
allow
the
component
to
generate
a
token.
Every
time
you
receive
the
request.
So
the
reason
why
I'm
turning
this
into
a
singleton
is
because
of
that
it
needs
to
read
this
data
once
and
once
it
has
it,
it
just
only
needs
to
concern
itself
on
executing
the
operations.
So
it
is
a
perfect
example
for
a
for
a
singleton
component.
A
However-
and
this
is
strategy
number
three-
what
about
through
Singleton's?
The
problem
with
singleton
is
that
the
patent
allows
you
to
define
an
instance
of
a
class
per
JVM.
That
means
that,
if
on
a
distributed
arrangement,
you
will
have
multiple
j
beings
as
many
notes
as
you
have,
you
have
a
cluster
with
five
notes.
A
Then
you
have
five
separate
GB
ends,
and
if
you
define
a
component
as
a
singleton,
then
you
will
have
single
turning
one
of
each
of
these
JVMs,
and
that
is
usually
not
a
problem,
however,
remembered
what
we
talked
about
on
previous
slides.
We'll
talk
about
coordination
and
the
issue
with
coordination
is
what
happens
if
you
need
to
read
data
that
it's
constantly
updated,
for
example,
in
a
previous
example
that
we
have
this
issue
object
or
property,
which
is
read
from
configuration
property.
It
is
only
if
this
one
debris
at
the
beginning.
A
Now
you
don't
need
to
concern
yourself
about
it.
But
what
happens
when
you
update
this
value
in
real
time,
and
you
need
to
refresh
all
of
your
properties,
then
you
can
just
simply
do
that
refresh
the
single
term,
but
if
the
single
turn
is
story
mode
across
multiple
cherien's,
you
could
have
an
inconsistency
issue.
So,
sadly,
at
the
moment
there
is
no
Jakarta
standard
for
a
two
single
turn.
Yet
this
is
something
that
we
might
improve
in
the
future
by
enhancing
the
CDI
specification.
A
However,
this
is
what
benders
come
to
the
rescue
and
pay
up,
which
is
quite
the
pure
platform
which
is
productive.
We
maintain
has
a
annotation
name
at
cluster
that
allows
instances
of
a
singleton
class
to
be
defined
and
coordinated
cluster
white,
so
this
is
transparent
to
the
developer.
The
idea
is
that
you
only
define
this
at
cluster
8
annotation
on
a
singleton
component
and
the
container
does
the
rest.
A
This
is
how
to
magically
just
coordinated
across
the
cluster
Andy,
for
example
an
oath
that
processes
or
handles
that
current
instance
of
the
IBM
is
lost
or,
if
it's
all
of
it
crashes
or
it
needs
to
be
regenerated,
then
that
that
data
is
migrated
to
another
life
node
in
the
cluster.
So
all
the
vendors
have
similar
solutions,
and
even
if
that
is
not
an
issue
out,
for
example,
you
don't
want
to
rely
on
those
solutions.
You
can
implement
a
caching
solution
that
can
also
help.
A
However,
this
might
be
a
bad
idea
if
you
are
not
fully
aware
of
how
caching
can
also
have
his
own
challenges,
so
I
just
say
to
use
whatever
depend
or
is
giving
you
so
here
is
an
example
of
how
can
I
define
true
single
turn?
I
have
a
component
service
name
station
rating
service
and
the
idea
is
that
I
am
without
cluster
and
defining
it.
With
these
configuration
setting
the
called
post
construct
an
attached
property
to
Falls.
A
That
say
it's
only
called
the
post
construct
method
when
these
instances
created
when
the
instance
is
migrated
from
one
component
from
one
node
to
the
other
cluster
to
another
node,
then
you
don't
need
to
call
it
again.
Hence
this
is
preventing
reinitialize
ation
of
the
component,
and
if
there
is
a
long
operation
here
in
the
initialization
process
in
this
method,
then
you
are
preventing
that
execution
when
the
instance
needs
to
be
regenerated
in
a
sense
means
migrated
across
nodes.
A
So
we
were
talking
about
caching
right,
so
strategy.
Number
four
relates
to
that.
We
told
a
statelessness
it's
good,
but
even
if
we
say
that
there
is
always
a
need
to
handle
state
in
memory
at
some
point,
for
example,
you
might
want
to
prevent
that
array.
Processing.
For
example,
let's
say
that
you
execute
your
application
is
connect
to
our
relational
database
and
you
execute
a
make,
a
sequel
query
that
takes
10
minutes,
for
example,
constructor.
A
Let's
say
report
of
that:
our
user
data
that
requires
just
one
parameter,
for
example
the
user
login
or
the
email
address,
or
some
identifier.
What
happens
if
the
user
runs
that
exact
same
query
again,
so
you
might
want
to
prevent
the
user
from
waiting
10
minutes
again
and
in
order
to
do
that,
you
can
provide
you
can
provide
a
cache
so
that
your
application
stores
that
data
in
memory
for
that
specific
users-
and
you
can
just
presented
it
again,
preventing
you
to
reprocess
all
that
data
again.
A
You
can
also
optimize
resource
man,
the
resource
management
of
this
information,
because
if,
for
example,
you
now
have
this
data
in
memory
and
let's
say,
for
example,
you
have
this
information
that
can
be
reused
for
another
user,
then
you
don't
need
to
maintain
this
structure
for
these
two
separate
users,
or
even
if
this
not
only
to
users
but
millions
of
users
that
can
reuse
that
same
information,
you
can
maintain
a
mnemonic
one
place
and
allowing
these
users
to
access
it
at
some
point.
So
for
Jakarta
exactly
there
is
no
standard.
A
Jakarta
api's,
however
they're
an
excellent
third-party
solutions
like
a
cache
or
spring
cash.
However,
at
some
point
there
was
a
an
API
named
J
cache,
which
sadly
was
proposed
to
the
JCB.
It
wasn't
a
specific
specification
since
the
relevancy
that
was
to
be
considered
to
be
included
in
Jeong
India
by
e8.
Unfortunately,
he
didn't
make
the
cut.
It
was
fully
defined
and,
for
example,
we
are.
The
PR
platform
has
implemented
our
own.
We
have
used
our
own
implementation
of
of
the
a
cache
API,
but
it
hasn't
been
made
part
of
it.
A
Hopefully,
now
that
Jakarta
is
all
of
the
open.
We
have
a
chance
of
fully
submitting
a
new
specification
of
J
cache
as
part
of
Jakarta
API.
So
there
is
a
one
of
the
solutions
that
I
can
recommend
you
use
if
you're
not
happy
with
the
solutions,
you
could
develop
your
own
cache
using
map
based
solutions.
I
have
seen
this
happening,
some
companies
and
some
users
thinking
that
they
might
not
need
to
always
think
a
map
based
solution
for
a
simple
cache.
A
So
here
is
an
example
of
what
I
was
talking
about
you
talking
about
the
same
session
rating
service,
let's
say,
for
example,
that
a
user
wants
to
compute
the
writing
for
in
a
specific
session,
and
the
only
thing
that
it
needs
to
provide
the
API
is
the
ID
of
that
session.
So
you
could
compute
the
writing
since
the
session.
It's
just
read-only
data,
because
the
session
happened
only
once
that
you
can
retrieve
the
information
from
the
database,
put
it
on
a
cache
and
then
return
it.
A
This
is
an
in-house
solution,
because
I'm
using
a
simple
map
and
the
method,
pivot
accent
will
just
simply
call
this
a
specific
method
if
the
value
is
absent
from
the
database
in
particular.
Well,
this
is
actually
not
performant,
because
the
to
the
backs
match
we'll
always
executed
retreat
session
from
database.
A
There
are
no
note,
or
do
you
migrate
it
in
some
capacity,
or
do
you
distribute
all
of
that
data
equally
to
all
the
other
nodes,
so
these
challenges
that
I'm
talking
about
should
be
considered
when
developing
these
solutions.
You
also
need
to
think
about
in
validating
data
on
them
and
what
happens
when
the
data
on
this
on
on
a
specific
cache
is
deemed
stale,
and
you
need
to
recalculate
it
because
it
was
updated
in
the
data
store
or
database
or
whatever.
A
So
this
is
important
as
well
and
lastly,
as
I
was
talking
about,
you
need
to
think
about
failover
and
data
migration.
So
for
the
pure
platform
you
use
J
cache
support,
which
is
the
API
mention,
and
the
kodan
is
a
DJ
box.
Cache
cache
API.
As
you
can
see,
it
still
uses
the
old
G
of
X
prefix
package
name,
which
is
unfortunately
saying
that
it
is
and
all
the
API
that's
still
part,
or
it
was
going
to
be
part
of
Java
EE.
So
hopefully,
in
the
future,
we
can
replace
these
Javitz
with
Jakarta.
A
There
are
also
proprietary
api's
as
well
that
we
using
depor
a
platform
that
internally
and
the
caching
engine
that
this
implementation
of
this
api
eats
product
that
we
use
internally
called
hazel
Cass
Community
Edition,
which
is
a
powerful
distributed
in
memory
data
grid,
which
is
similar
to
other
products
for
another
bundles,
like
in
paint
and
finish
span
from
Red
Hat
or
coherence
for
an
Oracle
which
was
recently
open
source
as
well.
So
here
is
the
same
code,
but
now
we
are
used
in
the
cache
annotation.
A
Sorry,
the
cache
interface,
which
again
it's
as
this
is
a
resource
man
maintained
by
the
container.
We
need
to
inject
it.
We
get
a
catch
and
tape.
J
cache
cache
works,
live
maps
in
a
sense
they
are
not
technically
Maps,
but
the
structure
and
methods
that
I
offer
and
follow
as
part
of
their
public
api's
work
in
a
similar
manner.
So
here
I
would
just
call
the
same
method
could
be
accent,
retrieve
the
information
from
the
database
and
just
simply
put
it
on
the
map.
It
means
not
absent
and
there
is
no
problem.
A
A
A
better
solution
is
to
use
annotations,
in
this
case
I'm,
using
the
same
method
that
I
am
giving
to
you,
which
is
retrieve
session
from
DB
well,
in
this
case
I'm
using
the
cache
resort
annotation,
which
instructs
the
container
to
catch
the
result
of
this
exit
of
the
execution
of
this
method,
the
first
time
that
it's
called
and
then
every
time
that
you
call
get
rating
sorry,
you
would
prevent
the
execution
of
this
method
internally.
How
do
you
annotate,
or
how
do
you
link
the
references
of
the
resource
for
the
specific
key
on
the
cache?
A
So
we
use
the
cache
key
annotation
to
mark
the
ID
of
the
session
that
we
are
trying
to
calculate
it's
right
in
front
on
the
database.
I
think,
as
I
said
earlier,
they
can
the
key
in
the
corresponding
cache.
And
additionally,
we
want
to
keep
this
cache
name.
So
we
are
used
to
cache
the
false
annotation,
which
fits
the
cache
managed
by
all
of
these
methods
in
the
session
rating
service
component
with
the
writings
name.
A
Next
strategy
would
be
a
CPI
of
HIV,
so
this
is
something
that
I
always
like
to
tell
application
developers
which
are
starting
with
Jakarta.
The
usual
question
is
what
component
model
should
I
consider.
So
at
the
moment
we
have
the
old
older
component
model
with
each,
which
is
a
TB
enterprise
javabeans,
which
is
a
technically
not
really
that
old,
but
it
started,
let's
say
on
and
really
has
a
really
rough
project
that
it
wasn't
intuitive
to
use.
It
was
a
bit
of
design.
A
You
have
a
lot
of
complications,
because
the
developer
had
to
write
a
lot
of
interfaces
and
buying
those
interfaces
to
internal
components
that,
at
the
end,
was
too
unproductive,
but
at
some
point
the
specification
modernize
itself,
and
now
it
has
a
reaches
stage
which
you
can
use
it.
Without
that
much
let's
say:
boilerplate
code,
a
GB
has
been
a
resilient,
reduce,
but
at
the
end
of
the
day,
obsolete
a
specification
because
it
hasn't
been
updated
that
much
in
there's
less
in
this
latest
years.
A
A
You
can
write
CDI
extensions
that
allow
you
to
do
things
that
you
couldn't
do
with
the
banila
framework,
which
is
something
that
a
GB
doesn't
allow
you
to,
and
this
is
the
main
reason
why
I
choose
to
use
CDI
because
CDI,
it's
more
lean,
it's
more
powerful
and
it
gives
you
the
capabilities
to
write
your
own
stanchions
and
to
feel
G
on
needs
of
your
product
or
your
applications.
If
those
aren't
provided
by
T
by
the
framework,
not
only
that
but
Jakarta,
a
micro
profile,
podrĂa
rely
on
CDI.
A
The
CDI
specification
is
the
corner
store
micro
profile.
So,
if
you're
thinking
about
developing
applications
that
use
both
frameworks,
a
GB
won't
help
you,
because
a
GP
is
not
part
of
microphone.
So
if
you
write
an
adv
component,
it
won't
be
able
to
interact
with
micro
profile
api's.
So
here
is
a
quick
comparison.
You
can
see
that
the
components
are
exactly
the
same
decision
service.
It's
just
and
in
this
case
it's
a
single
turn
on
a
GB
or
is
an
application
scope
on
CDI.
A
The
annotations
are
just
simply
replaced,
and
you
know
that
you
access
all
the
components
on
the
same
spectrum.
The
heb
specification
relies
on
the
AGV
annotation,
which
allows
you
to
look
up
dynamically
or
at
let's
say
at
creation
time
all
the
components
which
match
the
exact
interfere
or
class
name.
That
is
here
and
inject
them,
and
with
the
CBI
specification
we
have
the
atom
jet,
which
does
the
same.
A
The
thing
is
that
Syria
is
more
powerful
because
you
can
inject
resources
and
all
the
components
that
are
part
of
the
CDI
specification
and
all
the
components
like
even
a
TV
beings
or
other
resources
provided
by
the
container,
whereas
a
GB
is
not
as
powerful
as
that.
There
are
some
caveats.
For
example,
if
you
are
familiar
with
the
NDB,
there
is
a
feature
of
the
or
the
framework,
sorry
of
the
API
called
timers
which
allow
you
to
define
reusable
scale
unit
tasks
that
you
can
define.
A
A
Managers
managers
kelly
the
executor,
which
is
a
service
that
allows
you
to
execute
tasks
in
the
future.
Another
caveat
is
that
there
are
no
cooling
mechanisms
present
since
EDI
AGV
allows
you
to
put
beans
in
a
way,
optimizing
resources,
but
again,
that's
actually
a
byproduct
of
the
time
where
AGV,
what
the
AGV
specification
was
designed.
So
it
wasn't,
it
isn't
something
that
is,
let's
say
that
more
relevant
for
more
than
applications,
and
now
and
additionally,
there
is
no
standard-
a
signal,
a
synchronous
execution
in
CDI.
A
However,
there
is
a
feature
of
micro
profile
that
can
help
you
with
this.
So
if
you
are
using
any
of
these
features
in
this
case,
you
might
want
to
stay
on
a
TV.
However
I
in
let's
say
well
not
that,
but
I
want
you
to
consider
when
you
are
developing
new
products.
Well,
no,
you
really
need
these
features
and
if
you
don't
need
them,
then
you
can
just
include
closed
over
a
TV
and
use
CDI
instead,
so
yeah,
it's
not
at
this
one.
A
The
next
strategy
be
j,
pn
cashing.
So
we
were
talking
about
data
that
it's
storing
at
relational
database,
so
that
data
needs
to
be
cash
as
well,
because,
as
we
talked
about
they
issue,
eight
caching
data
is
that
you
want
to
prevent
re
execution
to
the
database
when
in
some
instances
can
be
an
expensive
process,
not
only
for
the
user,
but
for
you,
because
you
are
executing
these
processes
in
the
database,
then
that
might
cost
you
some
money
if
that
is
repetitively
done
every
day.
A
So
within
the
Jakarta
your
specification,
there
is
a
sub
special
medication,
called
in
Java
persistence,
API,
which
is
key
to
this,
and
this
API
has
defined,
let's
say
under
standard
caching
mechanisms
that
implementers
can
use.
However,
there
are
two
levels
of
cache
that
you
can
use
in
API
level,
one
and
level
two
level
one
is
standardized
between
the
API
and
every
vendor
must
implement
it.
A
I
must
provide
this
and
mechanisms,
so
you
don't
need
to
worry
about
that,
but
there
are
no
standard
mechanisms
for
the
second
level,
two
cache
so
level
two
cache
over
fast
at
and
retrieve
all
level.
One
is
not
that
as
fast
level
two
is
and
each
vendor
does
it
differently
and
all
all
Bender's
are
Monday
mandated
to
implement
it.
A
So
the
peer
platform
relies
on
eclipse
link,
which
is
an
open
source
project,
also
maintained
by
the
Eclipse
Foundation,
which
is
the
default
implementation
of
JPA,
or
was
because
at
the
moment
Jakarta
doesn't
have
default
implementations
or
reference
implementations
and
true
these
feature
called
the
hast
cast
cache
coordination.
We
internally
impaired
on
the
PR
platform,
a
low
cash
on
level
level,
two
cache
to
be
coordinated
across
notes.
How
to
do
this
simple?
There
is
this
file
called
the
persistent
XML
deployment
scripture
on
the
API
specification
that
allows
you
to
define.
A
How
do
you
connect
to
your
database?
What
you
do
is
to
configure
a
persistence
unit,
give
it
a
name,
define
the
transaction
type
that
is
used
for
this
persistence
unit
and
tied
that
persistence.
You
need
to
understand
J
datasource.
This
is
vanilla
APA,
and
this
is
how
it's
always
been
done
on
the
Jakarta
award,
so
to
define
a
caching,
you
have
to
use
the
shell
cache
mode
property.
There
are
multiple
modes
that
you
can
configure
and
the
first
one.
A
It's
enable
selective
that
allows
to
tell
you
that
some
entities
that
you
manage
in
your
application
will
be
cache,
but
not
all
of
them.
How
do
you
define
which
entities
are
cache?
You
use
the
cashable
annotation,
which
is
unstaple
of
the
api
specification
by
telling
ana
an
entity
that
is
cache
evenly
use,
whichever
attributes
are
mark
as
IDs
of
the
entity
as
part
of
the
keys
that
would
be
used
automatically
to
cache
the
results.
A
However,
there
is
the
problem,
because
the
API
cache
is
managing,
but
note
you
need
to
consider
what
happens
if
you
are
living
in
a
cluster.
So
to
do
this-
and
this
is
the
proprietary
mechanism.
I
was
talking
about
for
pre
era.
You
have
to
configure
the
eclipse
cache
coordination
protocol
value
which
allows
you
to
define
and
a
specific
implementation
on
our
coordination
protocol
class,
which,
in
the
case
of
PRI,
is
fish
that
we
are
persisting
and
klippstein
cache
coordination,
a
silk
as
publishing
transportation
manager,
which
is
a
long
name
actually.
A
This
tells
the
container
the,
for
example,
I
have
retrieved
decision
writing
entities
from
the
data
racing,
one
note
and
then
note
crashes,
and
there
needs
to
be
failover
in
some
capacity
to
another
knows,
then
it
will
use
this
class
internally
to
communicate
under
the
covers
and
translate
the
data
to
the
separate
note,
hence
preventing
you
from
losing
that
data,
maintaining
the
cache
in
a
distributed
manner.
Okay,
so
I
pause
for
drinking
water.
A
Okay
strategy,
number
seven
is
configuration,
and
this
one
is.
This
is
one
of
the
preferred
strategies
that
I
would
like
to
talk
about,
because
one
of
the
common
questions
that
you
will
ask
yourself
when
starting
a
new
project
is
where
is
my
application
configuration
located?
You
need
to
restore
that
in
an
intuitive
manner
and
retrieve
it
in
very
easily
everything
that
you
need
to
access
those
values.
A
So,
sadly,
there
was
going
to
be
a
doubt:
Java
EE
specification
for
Java
8,
which
was
going
to
be
a
java
configuration
which
was
going
to
be
a
standard
and
knowledgeable.
Unfortunately,
it
was
scrapped
and
it
wasn't
my
part
of
the
API
around
that
time.
I
could
profile
was
starting
and
one
of
the
first
API
side
was
born
in
the
project
was
micro
profile
configuration
which
sat,
which
hopefully
gave
us
a
starting
point
to
allow
standardized
configuration
mechanisms.
It's
a
highly
extensible
with
sensible
defaults.
A
You
should
work
in
most
environments,
especially
cloud
environments,
so
the
micro
proper
configuration
allows
you
to
configure
your
application,
which
relies
on
centralized
data
sources.
That
means,
if
you
deploy
an
application
that
lives
in
ten
nodes.
All
ten
nodes
should
be
able
to
access
these
data
sources.
No
matter
were.
There
are
also
sense
of
what,
if
also,
for
example,
if
you
want
to
deploy
your
application
on
a
station
environment,
what
the
configuration
is
not
ready,
but
you
might
want
to
prevent
your
application
from
breaking
down
because
it
doesn't
have
access
to
these
values.
A
You
can
prevent
some
sensible
defaults,
so
the
application
can
work
in
some
capacity
and
you
also
have
some
integration
with
CDI.
So
you
can
inject
these
values
when
you
need
them
or
if
you
do
not
prefer
to
do
manually
action,
or
you
simply
would
like
to
dynamically
look
for
them
at
runtime.
You
can
set
a
parametric
manner
as
well.
So
here's
a
comparison
about
sterling.
If
you
want
to
inject
these
values
in
a
static
manage,
you
can
just
use
the
conflict.
A
Property
annotation,
which
is
part
of
the
API,
look
for
the
value
of
the
property
demo.
Dot
conference
that
speaker
the
opinions
injected
in
this
link
of
strings.
So,
as
you
can
see
what
it
will
take,
the
configuration
API
will
look
for
this
property.
It
will
attain
this
property
as
a
string
value,
and
it
will
split
it
as
the
specification
states.
The
value
should
be
a
comma
separated
list
of
values.
A
You
should
split
it
and
put
into
this
list
of
strings,
and
if
you
can
find
it,
they
can
just
simply
set
the
value
to
ocarina,
which
you
will
be
only
one
value
in
this
list.
You
can
also
do
the
same
with
pramatta
click
up.
To
do
that,
you
can
all
use
the
conflict
provider
that
get
conflict
started
method
which
will
give
you
access
on
your
container
to
the
configuration
object,
and
you
can
just
simply
run
that
get
value
and
just
look
for
the
property
again
and
set
it
as
set.
A
What
is
the
value
that
would
be
the
result
of
this
conversion,
so
in
this
case
I'm
not
splitting
the
values
as
a
list
of
strings
of
just
simply
setting
it
as
a
single
body
string,
it
is
actually
helpful
because
they
micro
profit
configuration
allows
you
to
define
some
sensitive
data
sources.
So,
for
example,
if
you
are
running
your
application
on
a
docker
command,
you
can
run.
You
can
configure
a
micro
profile
configuration
property
as
an
environment.
A
So
strategy,
number
eight,
is
these
fault
tolerance,
and
this
is
important,
because
this
is
some
specific
challenge
that
many
people
don't
think
about.
Why
should
you
do
when,
in
your
distributed
arrangement
across
turn,
no
trails?
What
happens
is
specifically
in
your
application
code
when
the
database
is
not
reachable
because
it
crash
or
because
there
is
some
communication
issue
or
if,
for
example,
you
are
using
a
third-party
service,
either
legacy
swap
service
or
and
more
than
Jack's
a
rest
service
that
you
can
access
you.
What
happens
when
your
own
system
is
at
a
critical
state?
A
So
your
answer
can
be
that
you
reply
to
the
customer
on
a
webpage
or
on
a
miracle
that
the
service
is
not
available.
Please
try
again
in
five
minutes,
because
that
is
not
acceptable
in
2020.
You
need
to
adapt
your
application
code
to
these
fails
and
you
need
to
use
it.
You
need
to
do
some
tolerance
of
these
rails
enhance
fault
tolerance,
so
the
micro
profile
for
tolerance
API
allows
you
to
do
this
and
how?
How
do
you
do
it?
A
Well,
the
micro
profile
fault,
tolerance,
API,
is
a
set
of
a
standard
patterns
that
guide
business
logic
flow.
That
means
that
you
have
to
specify
what
happens
in
the
event
of
a
failure
and
how
the
application
should
behave
from
developer.
This
is
by
separating
the
execution
logic
from
the
execution
itself.
So
you
have
logic
that
specifies
the
code
or
what
do
you
when
everything
is
correct,
but
you
have
also
execution
logic
that
specifies
what
happened
with
something's
from
the
advantage
of
this
API.
It
has
been
designed
on
top
of
CDI
the
CDI.
A
A
spec
has
a
feature
called
interceptors,
which
are
annotations
that
allow
you
to
define
aspects
like
aspect
based
programming
would
allow
you
to
do,
and
these
aspects
allow
you
to
intercept
the
execution
of
a
method.
So
all
of
these
are
just
simple
acoustic,
interceptor
annotations
that
you
can
use
in
Europe
and
your
application
code,
so
fault,
tolerance.
Suppose
the
following
tolerance
pattern,
retry
hold
back,
which
I
will
show,
in
example,
in
the
following
slide:
Paul
heads:
it
could
be
record
timeout
and
a
synchronous.
A
So
I
previously
mentioned
that
if
you
were
preparing
to
use
CDI
over
a
GB
and
on
the
edge
EBS
specification,
that
is
an
a
synchronous
annotation
that
allows
you
to
define
a
synchronous
code
execution.
So
in
CDI
that
is
not
a
feature
button
for
tolerances
and
standard
tolerance
patterns,
so
you
can
use
it
here.
A
Here
is
an
example.
So,
for
example,
I
have
these
register
matter
that
will
receive
an
attendee
and
register
it
to
a
session,
so,
for
example,
I
want
to
because
this
method
relies
on,
let's
say
on
stable
service
that
might
fail,
because
the
service
is
not
available.
I'm
not
might
want
to
retry
that
so
I
can
configure
the
register
matter
to
be
automatically
retried
up
to
five
times
each
time,
separated
by
a
delay
of
thirty
seconds.
A
So
I
can
give
some
leeway
to
the
substrate
to
recover
itself
of
off
to
or
to
allow
me
or
any
system
administrator
to
find
out
what
is
happening
with
that
service
by
one
in
it
that
it's
happening
something
all
these
I
mean
problems.
However,
this
is
not
an
ideal
solution,
because
if,
at
the
end
of
these
five
three
tries
the
service
is
still
down,
you
will
get
an
error
and
then
you
will
have
to
tell
stone
something
to
users.
So
a
better
strategy
is
to
use
a
fallback
method.
A
So
a
fallback
method
is
just
a
backup
strategy
for
you
met
on
in
case
you
that
it
fails
and
you
can
execute
it
successfully.
So
the
configuration
in
this
case
is
that
I'm
also
having
our
retry
policy
for
my
method
or
grid
try
three
times
each
execution
separated
but
one
minute
and
if,
in
the
case,
all
three
retries
fail
then
fall
back
to
this
cache
writing
method.
So
what
the
ad
frightened
matron
is
doing,
it's
trying
to
add
an
attendee.
Oh,
it
gets
an
attendee.
A
It
gets
a
rating
that
this
attendee
wants
to
give
to
a
session
and
just
put
it
on
the
database,
as
you
can
see,
I'm
using
the
JPI
especific
JPII
methods,
process
and
thrush
here,
and
this
should
go
to
the
database.
But
if
the
database
is
not
available
and
this
method
fails
three
times-
I
fall
back
to
the
cash
rate
method.
So
a
casual
try
to
method
is
simple:
it
uses
a
cache
to
get
that
rating
and
put
it
temporarily
in
memory.
A
So,
as
you
see,
the
cache
rating
method
is
not
actually
going
again
to
the
database,
but
it's
just
simply
storing
the
value
in
memory,
but
it's
giving
something
to
the
user.
It's
telling
them.
Okay,
you
session
was
rate,
even
if
it's
not
technically
on
the
database.
At
this
moment
it
will
fall
on
you
now,
since
you
have
multiple
data
source,
you
have
a
cache
with
temporary
values
that
needs
to
be
synchronized
to
the
database,
but
you
have
prevented
your
user
from
being
inconvenienced
by
this
failures.
So
that
is
how
you
tolerate
them.
A
Stratton
on
the
dime.
It's
still
the
security
and
it
allows
you
as
I
as
I
said
at
first.
My
first
strategy
is
something
stateless
component.
You
need
to
concern
yourself
with
securing
them,
because
at
the
end,
if
you
are
not
securing
your
components
in
the
right
way,
you
are
putting
your
business
and
your
applications
at
risk.
A
So
when
using
stateless
services,
you
should
concern
yourself,
with
appropriately
securing
access
to
all
resources,
making
sure
that
those
endpoints
are
available
only
to
the
right
people,
which
is
authorization
and
propagate
secure
information
to
other
services,
because
more
than
applications
are
micro.
Services
are
using
multiple
data
stores
and
data
sources.
You
need
to
concern
yourself
what
happens
when
a
service
that
is
have
been
authenticated
and
secured
for
one
specific
user
needs
to
call
another
service?
A
Do
I
need
to
reallocate
the
user
or
can
I
use
a
secure
information
that
I
already
verify
for
the
user
for
the
calling
of
this
separate
service.
So
these
questions
are
important.
So
a
good
solution
that
you
implement
is
to
make
sure
that
each
request
that
it's
validated
or
that
is
executed
as
part
of
this
Estela
components
is
validated
separately
in
insulation.
That
means
everything
that
you
sent
a
request
to
these
services.
A
They
have
to
validate
the
information
every
single
time
that
when
it
comes
from
a
client
directly
or
an
or
an
end
user,
that
means
that
user
data
should
be
a
template.
Then
that
means
that
everything
that
you
do
execute
in
the
same
operation,
you
should
get
the
same
result
without
any
alterations
to
the
user
identity
and
be
portable.
A
That
means
that
if
you
move
that
data
to
a
separate
service
and
needs
to
be
real,
10
takeda,
it
should
yield
the
same
result
and
each
node
in
a
cluster
needs
to
have
all
the
right
tools
to
validate
this
information.
So
there
are
multiple
mechanisms
and
standards,
but
I
think
that
the
best
solution
is
to
use
the
JSON
web
tokens
a
JSON
web
token.
It's
token-based,
authentication
or
authorization
solution
is
based
on
a
standard
called
Open,
ID
Connect
and
it's
compatible
with
the
standard.
A
So
on
the
micro
profile
side
we
have
the
JWT
or
JSON
web
tokens
propagation
API,
which
allows
you
to
define
how
applications
validate
these
tokens.
So
here
is
an
example
of
a
JSON
web
token,
a
JSON
web
token,
as
I
said,
is
a
compute.
Well,
it's
a
set
of
payloads,
a
header,
a
proper
payload
which
has
all
the
attributes
or
standard
attributes
and
I
mentioned,
and
a
signature
which
is
encoded
and
is
separated
into
three
parts
by
a
dot.
So
how
do
you
do
this?
A
So
everything
that
you
execute
an
HTTP
request
to
an
endpoint
of
your
application?
You
need
to
send
this
soakin
and
the
token
needs
to
be
sent
as
part
of
the
authorization
bearer
token
Heather
use
on
the
HTTP
request,
and
then
you
should
receive
this
method
on
your
server,
validate
the
talking
to
make
sure
that
whoever
is
sending
this
information
is
who
says
that
it
is
and
verifying
that
the
user
has
access
to
the
methods
that
he
is
trying
to
execute.
So
how
do
you
do
this
on
the
on
the
codebase
or
on
the
server-side?
A
First,
you
need
to
define
that
your
application
is
to
be
authenticated
by
micro
profile
JSON
web
token,
and
for
that
you
use
the
login
config
the
annotation,
and
you
can
also
optionally
declare
what
roles
can
be
used
to
authenticated
users
on
your
application.
So
this
is
our
10th
occasion,
and
this
is
authorization
next,
you
need
to
define
how
these
users
or
how
these
tokens
will
be
authenticated.
So
the
a
specification
forces
you
to
use
these
two
properties.
A
This
is
like
a
profile
configuration
as
well
and
look
allocation
for
a
public
key,
which
is
the
key
that
was
used
to
segment
this
token.
That
I
was
showing
you
and
an
issuer
or
an
entity
that
has
generated
this
token.
So
if
the
token
is
has
been
used
by
this
specific
entity,
then
there
is
no
problem.
It
is
validated
and
if
the
signature
of
that
token
validates
against
this
public
key,
then
the
token
is
completely
padded
and
you
can
allow
the
user
to
be
authenticated
and
how
do
I
configure
authorization
by
using
the
rosula
annotation.
A
This
is
a
nostalgic,
kata
annotation.
So
in
this
case
the
JWT
specification
it's
integrated
fully
with
Jakarta,
and
it
tells
the
container
to
allow
users
who
had
this
role
can
vote
to
execute
all
of
the
methods
in
here.
So
the
user
is
authenticated
by
validating
the
token
and
in
this
out,
your
eyes,
verify
and
matching
the
roles
that
he
has
configure.
So
in
the
case
of
this
method,
which
is
right,
how
do
I
know
which
user
is
executing
them?
A
So
simply
I
just
inject
the
principle
and
again
this
is
a
Jakarta
standard
mechanism
and
the
principle
is
automatically
obtained
by
using
the
sub
or
the
UPN
fields.
In
the
token,
so
the
UPN
and
the
sub
still
give
me
an
identity
for
the
user,
which
in
this
case
it's
configured
by
using
the
email
addresses
of
the
corresponding
user.
That
is
executing
the
method.
A
So
here
we
have
another
example
again,
but
instead
of
using
the
principle,
let's
say
that
I
want
to
access
more
information
about
the
token
itself.
So
I
can
inject
the
token
by
using
the
JSON
web
token
class,
which
is
part
of
the
MIT
profile.
Jwt
specification
and
I
can
use
this
method
get
groups
to
see
what
are
the
groups
or
roles
configuring.
A
Lastly,
my
final
strategy:
for
you,
it's
metrics-
and
this
is
a
question
that
many
users
think
about,
but
they
do
not
try
to
optimize
so
daily.
You
need
to
be
thinking
if
you
are
an
application
maintainer,
how
good
or
bad
is
said
of
your
system.
How
can
you
optimize
your
environment
and
based
on
real
time?
Data
is
environment,
handling
the
load
perfectly
or
is
dragging
or
it's
lacking
resources,
and
all
that
you
give
users
good
response
time.
You
also
you
need
to
D
analyze
the
data
generated
by
application.
A
So
if,
for
example,
do
you
develop
an
application
that
manages
users
and
you
need
to
know
how
many
user
accounts
are
created
per
day
in
order
to
give
those
stats
to
upper
management
in
your
company,
or
something
like
that,
you
might
want
to
also
try
to
see
that
so
Micro
profile
metrics
allows
you
to
do
this
and
micro
profile.
Matrix
is
just
a
cloud
pretty
standard,
matrix
format,
which
is
based
on
the
primitives
format,
which
is
an
standard
of
the
cloud
native
software
foundation,
and
it's
just
a
primitives
in
seosan
applicate.
A
Well,
it's
a
metric
server
that
allows
you
to
aggregated
metrics
from
multiple
sources.
The
only
thing
that
you
need
to
do
on
your
applications,
it's
to
simply
nothing
because
it
is
automatically
integrated
with
the
within
the
container.
There
is
no
bootstrapping
code
that
it's
needed.
There
are
three
base.
Sorry,
there
are
three
scores
for
the
metrics
that
you
can
use
pace
which
is
matrix
from
the
JVM
and
from
the
application
server
a
container
like
the
amount
of
memory
being
used
at
the
moment.
A
For
example,
each
metric
has
is
my
own
set
of
metadata
or
tags
that
you
can
use
in
order
for
your
primitive
server
configuration
to
graph
those
metrics
in
a
specific
manner
like
this
one.
So
here
is
a
screenshot
of
the
media
server,
which
is
actually
being
used
by
a
separate
tool
called
graph
Anna,
which
is
a
graphic
tool
that
can
be
that
can
be
bound
or
linked
to
an
existing,
primitive
server
configuration
and
show
these
data
in
real
time.
So
there
are
current.
A
There
are
currently
five
type
of
metrics
I
think
I'm
missing
a
six
one
gauge
counters
majors
histogram,
some
timers,
and
all
of
these
metrics
follow
and
a
specific
reason.
Specific
goal
counters,
for
example,
counter
incrementally,
while
the
current
value
of
a
metric
histograms
map
the
current
history
of
fluctuations
of
any
specific
numeric
metric
and
so
on.
So
here's
an
example.
However,
I
can
configure
application
metrics.
A
So,
for
example,
that
say
that
I
want
to
see
on
my
application
that
handles
sessions,
how
many
sessions
were
created
since
the
application
was
deployed,
so
I
can
use
the
meter,
add
annotation,
which
will
define
a
meter
type
metric
named
session,
that
creation
dot
tries,
and
this
absolute
allows
me
to
specify
the
container
that
this
is
the
absolute
name
of
the
metric
and
every
time
this
metric
is
called.
This
method
is
called
the
method.
A
Will
be
recalculated
in
real
time,
so
you
will
get
these
value
automatically,
and
the
only
thing
that
I
have
to
do
is
just
to
use
an
annotation.
However,
you
want
to
have
more
control
on
your
matrix.
You
can
use
specific
programmatic
mechanisms
with
the
classes
themselves,
so
here
is
symmetric
name
session
spaces,
which
is
a
counter,
and
this
metric
is,
is
being
defined
with
the
name
session
spaces
and
I'm.
Defining
here
that
the
name
is
not
absolute,
so
the
container
will
add
a
prefix
to
this
metric
as
well,
and
how
is
this
metric
computed?
A
A
When
the
when
the
class
is
follower
is
called
successfully
later
and,
for
example,
the
parrot
platform
API
allows
you
to
define
metrics
by
using
an
S
Pacific
XML
configuration
file
named
custom,
metrics
and
Here
I
am
computer
on
a
metric
called
system,
CPU
load,
which
allows
me
to
define,
which
is
the
current
CPU,
Bali
or
load
for
the
system.
That
is
something
the
sorry
that
is
has
been
executed
on
the
JVM
or
the
host
machine
and
how
I'm
doing
that
simple
I
intend
this
value
to
Anam
beam.
A
This
is
standard
jmx
configuration
for
all
those
who
you
are
aware
of
complete
the
game
exit
system
and
I'm
timed
their
value
of
that
metric
dynamically
to
to
that
value,
so
I
can
reuse
all
the
metric
components
or
metric
servers
inside
the
JVM
to
fill
in
this
value.
Sidereal
time
and
I.
Think
that's
it.
So
if
there
is
any
questions
feel
free
to.
Let
me
know.
A
Doesn't
look
like
there's
any
questions
right
now,
but
thank
you
so
much
for
your
presentation.
Okay.
So
just
to
finish
up,
we
up
your
services
limit
that
half
our
new
protocol.
Well
any
program
called
PRF,
which
is
a
community
group
program.
The
idea
is
that
we
want
to
reach
communities
which
are
hosting
their
own
events
locally,
or
you
know,
let's
say
in
bigger
environments,
however,
due
to
the
current
situation
overall,
I'm
afraid
that
it
would
be
on
the
limited
to
online
events.
A
So
if
you
are
hosting
an
event
in
your
local
community-
and
you
would
like
to
be
sponsored
by
us-
let
us
know
just
contact
us
prior.
Are
that
fish,
/
riff
and
we'll
gladly
support
you
in
anything
that
you
want
to
do
regarding
e,
if
you're,
using
in
the
apparel
platform
or
if
you
are
using
Jakarta
in
some
capacity.
So
thank
you
so
much
for
your
time.