►
From YouTube: Exploring Stateful Microservices in the Cloud Native World | JakartaOne Livestream 2021
Description
Jakarta EE gives developers a comprehensive set of vendor-neutral, open specifications that are used for developing modern, cloud native Java applications from the ground up. With Jakarta EE, technology developers and consumers can be confident they have the best technologies for developing cloud native, mission-critical applications. And they can build on decades of Java developer expertise to move existing workloads to the cloud.
Learn more: https://jakarta.ee/
Follow us on Twitter: https://twitter.com/home
Follow us on LinkedIn: https://www.linkedin.com/showcase/jakartaee/
Like us on Facebook: https://www.facebook.com/JakartaEE/
A
Hi,
mary,
hello,
shannon:
how
are
you
doing
you're
actually
live
now,
so
you
can
start.
I'm
live.
Oh
wow,
okay,
great
to
have
you
here,
oh
wow!
Thank
you.
Thank
you
because
I'm
also
looking
at
the
other
screen
and
then
I
don't,
I
think,
there's
a
delay,
but
anyway
it
is
yes
there.
It
is
okay,
all
right,
cool
cool,
yeah.
All
right
now
I
see
myself.
Okay,
very
good.
Let
me
also
make
sure
I
mute
that
side
so
that
it
doesn't
interfere
myself
here.
So
yeah.
A
Wonderful,
thanks,
really
good
to
see
all
of
you
here,
even
though
I
can't
really
see
you,
but
I
know
you
are
there
so
yeah
and
also
the
last.
You
know
session
of
the
day,
so
I
have
the
responsibility
of
keeping
everybody
awake,
so
so
very
nice
yeah,
so
yeah
should
I
should
I
be
starting
right
now
or
I
think
I
can
right.
Yes,
please
do!
Thank
you.
Okay,
all
right,
then
yeah
and
I
am
going
to
now.
Instead
of
sharing
screen,
I'm
just
gonna.
Do
the
picture-in-picture
thing.
So
let
me
kind
of
do
this.
A
I
think
I
was
told
that
I
you
can
essentially
put
me
in
there
can
folks
see
me:
okay,
yeah,
okay,
yes,
okay!
Thank
you
all
right,
then
yeah,
okay,
cool!
I
just
want
to
make
sure
that
I
I
look
okay
right
in
this
screen
here,
all
right,
so
I'm
just
gonna
start
now,
then.
Okay,
so
welcome
everybody.
To
my
talk,
it's
about
stateful
microservices
in
the
cloud
native
world
and
as
such
do
well.
This
is
jakarta.
One
live
stream,
so
I
want
to
kind
of
highlight
you
know
the
jakarta.
A
How
can
jakarta
help
us
right
in
this
particular
aspect,
but
first
of
all
too,
let's
try
to
understand
what
is
stateful
microservices.
I
just
have
to
assume
that.
Maybe
not
everybody
has
the
background.
So
please,
you
know
pardon
me
if
I'm
kind
of
repeating
something
that
you
already
know
so
here
here.
A
I
am
so
and
also,
let
me
know
too,
if
you
can't
see,
but
first
of
all,
if
you
are
interested
in
having
the
slide
act
with
you,
this
is
how
you
can
get
it
right
now
and
that's
the
tiny
url,
the
short
one,
and
also
the
qr
code.
So
I'll
leave
it
here
for
like
20
seconds.
A
If
you
want
to
take
a
quick
picture
and
then
you
should
be
able
to
access,
this
is
a
share,
slide
deck
so
and
then
in
the
meantime,
let
me
also
kind
of
get
myself
move
over
a
little
bit.
It's
always
this
kind
of
tricky
thing
right
so
oops.
Sorry,
let
me
kind
of
move
myself
over.
A
A
So
I'm
a
senior
developer
advocate
at
ibm,
my
area,
I
met
with
the
websphere
and
liberty
team,
so
my
areas
with
java,
open
source
cloud,
devops
and
enterprise
distributed
systems
and
those
are
kind
of
actually
distributed
systems
messaging
have
always
been
my
area
of
kind
of
I'm
passionate
about
that
yeah.
Somehow
I
just
like
kind
of
messaging
that
type
of
system.
So
so
that's
my
area
and
then
I'm
responsible
to
right
now
advocacy
for
open
liberty.
A
Microprofile
and
jakarta,
ee
and
I've
been
with
this
team
since
february,
so
just
about
a
year
now
and
I've
over
25
years
of
experience
as
a
software
engineer
becoming
before
becoming
an
advocate
so
yeah,
so
I
actually
have
been
so
to
speak
by
in
the
in
the
trenches
like
with
it
shops
right
doing
things,
so
I
kind
of
can
understand
very
well
too.
I'm
also
the
president
of
the
chicago
java
uses
group.
A
So
if
you're
in
chicago,
let
me
know
and
come
and
join
us
or
even
now,
you
know
you
don't
need
to
be
in
chicago.
Everything
is
digital
now
and
I'm
just
an
active
technical
community
organizer
for
several
ibm
sponsor
meetup
groups
too
in
chicago.
A
So
let
me
kind
of
first
by
saying
just
some
basic
thing
right
about
stateful
and
stateless.
So
what
is
stateful
and
stateless
right?
And
these
days
we're
always
hearing
about
stateless
in
the
cloud-native
time
period
that
we're
in
so
exciting
everything's
stateless.
So
I
thought,
let
me
use
kind
of
an
example
that
probably
is
like
not
dealing
with
computers,
let's
kind
of
explain
it.
So
if
somebody
comes
to
you
without
the
background
they
want
to
understand
so
I'm
using
this
example,
as
you
can
see,
is
using
finding
nemo.
A
So
if
you
know
the
story
right,
then
you
know
that
marlin,
the
big
fish,
the
daddy
fish,
is
out
into
the
ocean.
Looking
for
his
son,
who
is
lost
in
the
ocean,
the
little
fish
nemo
and
in
the
meantime
he's
swimming,
then
he
ran
into
the
blue
fish.
Dory,
so
dory
is
this
forgetful
fish
right
and
she
doesn't
remember
anything
if
she
wants
something
to
be
done.
She
just
jumps
right
at
it
and
that's
just
her.
A
Whereas
marlin
is
this
fish
that
can
make
connection
to
things
you
know
it's
like,
for
example,
you
know
dory
saw
like
a
bunch
of
jellyfish
that
kind
of
swam
by
and
she
was
all
excited.
She
wanted
to
swim
with
them
and
jump
on
them
and
then
marlin
said:
wait,
wait,
wait,
don't
do
it
because
then
these
jellyfish
can
sting
you.
So
don't
do
that.
A
So
I
think
you
can
probably
guess
as
to
why
I'm
using
this
analogy,
because
it's
stateful
right
it
is
sort
of
like
when
we're
dealing
in
the
computing
sense
is
that
we
will
remember
the
context
right.
We
will
have
the
memory
of
where
we
are
and
what
we're
supposed
to
be
doing
and
everything,
and
then
stateless
is
basically
just
the
opposite.
Is
it's
essentially
a
happy-go-lucky
fish?
You
know
in
dory's
case
she
doesn't
remember
anything
she
just
she
goes
and
do
whatever
she
wants
at
any
time
kind
of
thing.
A
So
I'm
just
using
this
example.
It's
pretty
kind
of
like
a
very
you
know.
Kind
of
crude
kind
of
example
doesn't
explain
everything,
but
I
think
you
know
initially,
if
you
want
to.
If
I
try
to
like
explain
the
concept,
I
feel
that
that
would
be
kind
of
an
appropriate
one
to
use
so,
okay.
So
now,
then,
let's
get
a
bit
into
the
discussion
part.
So
you
know
I'd
like
to
first
talk
about
how
computing
life
right
used
to
be
simpler,
we're
doing
used
to
be
dealing
more
with
stateless
computing.
So
what
is
stateless?
A
So
stateless
really
is
a
communication
protocol
that
does
not
retain
any
session
information,
so
the
state
of
data
does
not
get
recorded
between
transactions.
When
your
data
travels,
you
know,
through
the
wire,
through
different
network
boundaries,
you
know
different,
you
know
physical
devices
and
all
these
things
you
don't
care,
it
just
travels
through
it.
You
need
something
you
know
be
done.
It
will
be
done
so
as
a
result
to
your
architecture
of
your
system,
the
design,
the
implementation.
A
Everything
is
simpler.
You
want
to
scale
the
system,
no
problem,
just
kind
of
you
know,
spin
up,
another
node
get
another
part
up
and
you
know
fill
your
cluster.
Everything
is
just
more
like
spin,
it
up,
don't
worry
about
it,
it
just
starts
and
if
you
need
to
recover
from
the
system
to
any
kind
of
system
failure
your
components,
no
big
deal,
let's
spin
up
another
one.
So
a
lot
of
you
know
when
you
do
things
in
a
stateless
fashion.
A
It's
really
a
lot
cleaner,
a
lot
faster
and
also
kind
of
it's
very
often
to
kind
of
compare
with
when
you're
doing
like
functional
style.
Programming
right,
when
you
do
something
stateless,
it's
it's
when
you
don't
need
to
remember
the
state.
You
know
it's
functional,
it's
more
like
you
know.
I
need
something
done
pass.
A
It
pass
the
data
through
the
formula
you
get
your
result,
you're
done
you,
you
don't
need
to
worry
about
saving
anything
recording
anything,
but
realistically
too,
is
that
we
live
in
a
you
know,
a
stateful
world,
which
means
you
know
we
can't
just
kind
of
like
go.
Do
whatever
we
want,
and
you
know
kind
of
you
know
how
can
it
be
right
if
you
think
about
the
fact
that
you
cannot
remember
your
spouse's
birthday?
That
would
be
a
big
major
issue
right
I'd
say
so,
among
other
things
right
just
then
that's
just
an
example.
A
So
stateful
computing
really
is
the
opposite.
It's
a
communication
protocol
that
would
retain
all
session
information.
So
when
data
travels
through
space
and
time
to
through
different
different
physical,
we
you
know
kind
of
a
devices
resources,
network,
boundary.
Everything
gets
recorded
at
every
step
of
the
way
because
there's
traceability
involved,
you
know
so
as
a
result
to
it's
more
difficult
right
when
you
do
systems
like
that,
you
you
do
need
to
like
keep
track
of
all
the
state
changes
in
any
given
point
in
time.
A
So
if
you
have
any
issue
with
your
system,
components
going
down,
a
pod
is
down.
You
need
to
spin
it
up.
Everything
will
take
longer
to
kind
of
restart
it,
because
then
you
need
to
re
like
initialize.
The
state
of
that
particular
component
to
be
like
the
rest
of
you
know
your
part
in
in
that
particular
say
in
that
particular
node.
So
just
the
opposite.
Now,
let's
kind
of
take
a
look,
then
how
about?
Let's
talk
about
statefulness
in
the
cloudless
days
you
know
cloudless
is
before
the
clouds.
A
So
a
bit
of
history
is
always
good
right.
How
do
we
kind
of
get
here
so
in
the
client's
server
systems?
Time
right,
it's
kind
of
in
the
more
like
the
90s.
At
that
time
there
was
no
cloud
right.
Internet
was
just
born.
We
need
to
do
all
the
things
and,
as
we
kind
of
like,
came
to
find
out
right
computing.
Isn't
that
simple?
Not
as
simple
as
just
you
know,
you
have
you
run
through
some
functional
formula,
not
like
that.
A
You
need
to
actually
keep
track
of
the
state
of
your
data
along
the
way
now,
in
the
cases
too,
in
which
it
may
not
be
that
common
everywhere.
However,
it
is
not
uncommon
either
is
that
you
can
have
a
situation
in
which
you
need
to
deal
with
data,
that's
kind
of
resides
on
different
database
and
basically
to
let's
take
an
example.
If
you're
you
know
doing
an
order,
entry
kind
of
system,
you
could
have
data
actually
store.
You
know
the
order
system.
As
you
know,
right
e-commerce
order,
entry
is
is
fairly
complicated
system.
A
You
can
have
an
order,
entry,
the
you
know
the
managing
all
the
orders.
The
resources
are
in
one
database,
you
know,
let's
say
it's
a
db2
database
and
then
you
actually
have
you
know
your
customer
data
may
be
stored
in
another
erp
system.
It
could
be,
you
know,
kind
of
a
sy-based
database
or
something
older.
Let's
talk
about
that,
I
used
to
work
for
sybase,
so,
okay,
so
now
just
example
of
using
two
right,
but
but
in
reality
you
can
actually
have
even
like
the
same
vendor.
A
You
can
have
have
multiple
copies
of
databases
that
are
keeping
track
of
different
things
and
different
point
in
time.
So
how
do
you
kind
of
keep
track
and
coordinate
all
of
the
data
to
be
all
kind
of
in
you
know,
in
in
kind
of
coherence,
fashion,
right
that
that
your
order
doesn't
kind
of
you
know,
kind
of
all.
The
data
doesn't
travel
through
all
of
your
database
and
kind
of
get
corrupted
and
everything.
A
So
what
it
used
to
be
done
is
we're
using
a
two-phase
commit
type
of
protocol
and
in
that
protocol
is
that
you,
it
will
require
a
coordinator
to
be
dealing
with
with
this
kind
of
scenario
so
take,
for
example,
right
this
two-phase
commit
protocol
is
actually
still
in
use
today
doing
some
of
the
sharding,
for
example,
in
some
of
the
cloud
infrastructure
so
two-phase
commit.
So
what
what
it
does
is
that
you
know
instead
of
well.
Okay,
let's
put
that
away,
I
have
like
I.
A
I
need
to
have
data
that
I
need
to
coordinate
on
using
example,
db2
and
a
side-based
database.
Let's
say
an
oracle,
so
the
coordinator
will
kind
of
do
a
two
pass.
So
first
phase
is
that
you'll
come
through
each
one
of
them
in
a
very
synchronous
blocking
fashion.
It
will
kind
of
go
to
your
db2
and
ask
db2.
Are
you
all
done
you
know
and
and
then
so
db2
comes
back
and
says:
yes,
I'm
all
good
whatever
I
needs
to
do
can
be
committed.
So
we
pass
back
this
vote.
A
You
know
back
to
the
coordinator,
then
the
coordinator
will
go
to
the
next
one:
go
to
the
side
base
and
ask
the
same
question
and
the
side
base
will
say:
okay,
I'm
all
good
too.
So
then
it
collects
all
these
vote
and
then
go
to
oracle.
Oracle
says
the
same
thing.
So
after
essentially,
this
coordinator
has
gone
through
every
single.
You
know
database
instances.
Then
it
will
come
back
and
collect
and
look
at
it
and
say:
okay,
everybody
is
good.
A
So
now
let's
tell
everybody
to
commit,
so
it
would
go
to
db2
and
say
commit
commit
commit
like
that.
But
of
course
you
know
during
the
commit
something
can
go
wrong
and
then
you
have
to
like
immediately
roll
back
and
that's
another
issue,
but
you
get
the
idea
right.
That's
how
like
two-phase
commit
was
done,
as
you
can
tell
too.
This
particular
protocol
is
also
like
not
very
efficient
and
in
fact
that's
the
one
big
issue
with
it
is
that
it
is
very
slow
because
everything
is
blocking.
A
Let's
say
if
I'm
dealing
with
the
db2
database,
the
rest
of
the
databases
are
waiting.
You
know
they
can't
do
anything
and
they
have
to
wait
for
this
coordinator
to
be
ready
and
kind
of,
tell
you
be
told
what
they
can
do
or
what
they
need
to
be
doing.
A
So,
in
that
case
too,
it
becomes
kind
of
a
bottleneck
right
and
so
that's
kind
of
a
big
kind
of
a
drawback
in
this
kind
of
approach,
and
not
only
that
too,
you
know
using
that
kind
of
approach,
we're
assuming
the
network
is
reliable,
which
in
reality
network
is
totally
unreliable,
as
we
all
know.
So
it's
it's.
It's
not
like
a
really
good
solution
to
this.
A
So,
but
that's
how
you
know
kind
of
like
how
we
deal
with
like
statefulness
to
in
like
multiple
copies
of
database
kind
of
more
like
a
bit
more
of
a
traditional
way
of
dealing
with
the
the
old-fashioned
oltp
transaction
kind
of
processing.
Okay,
so
that's
that
now,
then,
let's
move
on
to
java
right
before
the
cloud
actually
with
java
right
enterprise
java
before
like
jakarta
ee,
there
is
a
java
ee.
A
Then,
before
java
ee
actually
was
j2
ee,
so
java
two
enterprise
edition,
so
which
is
something
I
also
worked
on
in
the
very
beginning
of
my
java
career
in,
like
I
think,
year,
2000
or
1999,
something
like
that.
So
so
in
java,
as
we
all
know,
then
we
have
enterprise,
java
beans,
ejb
right,
there's
also
there's
a
session
ejb,
which
can
be
stateless
session
which
actually
completely
doesn't
keep
track
of
the
state
right
and
and
then
there's
also
stateful
ejb.
A
So
stateful
will
keep
track
of
things
as
long
as
your
request,
this
session
is
in
effect,
so
once
the
session
goes
away,
then
your
data
doesn't
get
persist
to
database
and
how
do
we
deal
with
it?
So
in
that
case,
then,
you
have
to
handle
it
using
entity
beans.
So
once
you
kind
of
have
entity
beans,
then
it
kind
of
gets
mapped
to
your
database
or
whatever
back-end
storage,
persistent
storage.
You
have
and
that's
how
we
do
it
using
ejb
and
then
there's
also
http
session,
so
http
session.
A
As
we
know,
http
is
stateless
and
then
we're
kind
of
talking
about
servlet.
But
the
thing
is
that
which
this
session
to
is
that
we
can
actually
leverage
on
the
session
and
keep
track
of
data
to
be
like.
You
know,
consistent
within
a
particular
http
session,
so
that's
kind
of
the
java
on
the
application
side
and
then
now
let's
then
take
a
look
into
client-side
like
caching
of
server
responses.
A
So
I'm
sure
too,
if
you're
familiar
with
like
web-based
programming,
then
you're
familiar
with
cookie,
based,
authentication
or
like
right
now
too,
in
the
newer
way
of
doing
things
is
dealing
with
json
web
token.
So
the
differences
are
that
cookie
base
is
essentially
a
bit
slower,
because
then
your
cookie
will
carry
the
session
id
and
present
the
id
to
your
server
side,
and
so
when
it
is
well
when
it
gets
kind
of
approved,
then
the
server
says.
Okay,
you
are
good.
You
know,
then,
basically
to
the
request.
A
You
know
the
client
will
have
to
go
back
to
the
the
the
client
side,
essentially
and
kind
of
take
the
payload
and
basically
travel
across
the
wire
again
and
present
it
to
the
server.
So
it's
a
bit
kind
of
slower,
whereas
like
with
jwt,
is
a
little
bit
faster
because
jwt
will
carry
both
the
session
id
as
well
as
the
payload.
At
the
same
time,
when
once
he
gets
authenticated,
then
the
payload
is
there
and
you
can
present
it
to
the
server.
A
So
that's
how
kind
of
like
the
client
server
systems
are
used
to
handle
all
of
these
things.
Now
now,
then,
let's
kind
of
move
on
to
the
cloud
native
environment
that
we're
all
kind
of
in
you
know
this
new
kind
of
way
of
doing
things
now.
Well,
isn't
really
that
new
right,
but
it's
since
like
2010..
A
So
how
do
we
then
deal
with
like
stateful
microservices,
because
when
we
talk
about
cloud
native
we're
all
talking
about
stateless
everything
is
stateless,
they're,
lambdas
right
in
aws,
for
example,
and
and
different-
you
know
kind
of
like
in
you
know
open
with
two
is
the
form
of
like
serverless
kind
of
like
computing
all
these
things.
So
how
do
we
deal
with
it?
So
here
it
is
a
picture
too
it's
about
stateless
containers.
So
how
do
we
maintain
state
right?
A
So,
let's
kind
of
take
a
look,
but
let's
also
first
kind
of
understand
a
bit
too
about
cloud-native
computing.
It
really
is
an
overarching
approach,
so
essentially,
cloud
native
is
an
extension
to
cloud
computing
by
addressing
the
true
needs
of
the
enterprise
level
distributed
business
application
systems.
So
what
are
these
true
needs
right?
So
netflix
coined
this
term
cloud
native
in
the
early
2010s
and
essentially
they
wanted
to
leverage
on
the
cloud
to
meet
their
goals
for
the
systems
to
be
highly
available,
scalable
and
performant.
A
Now
those
are
kind
of
lofty
kind
of
goals
you
know,
but
how
do
we
achieve
it?
Right
is
the
question
in
it.
So
so
everybody
wants
it
too.
We
want
highly
available
systems
scalable
and
performant,
so
in
cloud
native
too,
and
and
also
just
a
bit
of
a
background,
is
that
there
are
also
12-factor
application.
This
principle,
which
I
think
earlier
I
saw,
I
think,
was
adam-
that
adam
ben
that
also
talk
about
12
factor,
but
I
like
to
just
bring
up
quickly.
A
Then
I
won't
dwell
on
it
as
much
assuming
that
you
have
already
seen
that
and
also
maybe
some
of
you
are
already
very
familiar,
but
just
for
the
sake
of
those
who
are
maybe
new
to
this.
So
let
me
kind
of
go
through
it
again,
a
little
bit
so
the
12
factor
application
is
essentially
a
methodology
that
was
drafted
by
developers
at
heroku.
A
It's
a
set
of
guidelines
or
best
practices
for
portable
and
resilient
applications
that
are
well
suited
to
be
in
the
cloud
environments,
and
one
of
the
factors
indicates
the
need
for
self-contained
services,
which
are
to
be
deployed
as
stateless
containers
and
essentially
too
that's
what
is
referring
to
now.
We're
understanding
is
that
we're
all
using
microservices
architecture
to
achieve
that,
because
it
can
satisfy
that
type
of
requirement.
A
The
nice
thing
about
microservices
architecture
is
really
a
set
of
principles
and
it
doesn't
like
enforce
how
you
do
it.
It's
basically
saying
that
it
you
know
it.
Those
are
the
concepts.
Those
are
like
solid
concepts
that
you
must.
Any
applications
must
follow
in
order
to
achieve.
You
know
portability
of
your
system,
you
know,
and
and
and
also
very
efficient
and
everything
so,
okay.
A
So
now,
then,
let's
kind
of
take
a
really
quick
look
then
into
this
12
factor
again
and
as
such,
I
won't
kind
of
step
through
all
of
it,
but
I
wanted
to
point
out
too,
of
all
the
aspects
of
12
factor
right.
If
you
look
through
then
essentially
number
six,
the
processes
is,
you
want
to
execute
the
app
as
one
or
more
stateless
processes
and
then
also
number
nine.
I
want
to
point
out
disposability
oops.
A
I
guess
I
kind
of
accidentally
switch
it
so
disposability
right
number,
nine
is
basically
we
want
to
maximize
the
robustness
with
fast
startup
and
graceful
shutdown,
so
everything
has
to
be
very
clean,
very
fast
and
everything
so
that
kind
of
suits
it
right.
It's
really
a
stateless
type
of
systems
that
we're
environment
that
we're
aiming
at.
So
how
do
we
then
deal
with
maintaining
the
state
right
in
in
this
type
of
environment?
How
do
we
preserve
this
state
right
across
session
right?
One
session
you
do
need
to
keep
track
of.
A
You
know
what
client
it
is.
You
don't
want
to
every
time
a
client
comes
in,
you
know.
Let's
say
I
already
have
this
component
servicing
this
request.
Why
do
I
need
to
restart
every
time?
If
you
know
I
go
back
every
time
and
fetch
new
things
you
know
from
the
client.
I
need
to
restart
this,
so
no
sense
of
doing
it.
So,
there's
a
certain
amount
of
stateless,
stateful
kind
of
data
that
needs
to
be
preserved.
A
You
know
during
a
session,
for
example,
or
even
like,
sometimes
between
sessions
too,
and
then
there
are
also
transactions
too
same
thing.
I
talked
about
earlier
with
transactions.
We
want
to
kind
of
maintain
the
context
too,
and
also
across
different
network
boundaries.
So,
okay,
so
let's
kind
of
review
quickly
right
so
for
techniques
and
mechanisms
they're
like
cash,
you
know,
which
I
kind
of
talked
a
bit
about
earlier,
or
did
I
okay
but
anyway,
but
they
are
like
caches
to
cache
too.
So
cache
is
essentially
that's
what
you
you
can
have
right.
A
You,
you
kind
of
keep
it
sort
of
like
in
temporary
memory.
These
data
that
you
can
I
kind
of
reuse
during
your
session
right.
So,
for
example,
too,
like
in
like
a
cloud
native
environment
too,
you
can
be
making
use
of
redis,
for
example,
that
you
know
a
mongodb
couchdb.
All
these
are
kind
of
good
mechanism
for
you
to
use
and
then
actually
in
the
systems,
I'm
working
with
to
open
liberty
that
we're
actually
leveraging
on
j
cash
right.
A
This
is
like
the
java
spec
for
caching
mechanism,
and
then
you
can
use
the
service
provider
such
as
like
hazelcast
or
any
kind
of
caching
kind
of
provider.
It
can
be
like
redis
again
something
like
that
right.
You
can
use
caching
to
help
you
and
then
also
the
database
style
transactions
that
I
talked
about
kind
of
earlier
too.
Oh,
that's
right!
I
didn't
actually
talk
about
that
was
actually.
A
You
can
also
like
leverage
on
database
to
kind
of
do
the
maintaining
of
your
state
right,
so
you
can
have
essentially
have
like
a
traditional
relational
database
that
it
actually
has.
You
know
that
that
you
can
leverage
on
the
database
controlled
control,
transaction
or
you
can
actually
do
user
level
kind
of
control
transaction
as
well
too,
but
of
course,
if
you
do
user
level
transaction,
then
it's
definitely
more
work.
You
know
on
your
application
code
side,
but
normally
two.
A
We
rely
on
the
database
engine
to
manage
transactions
for
you,
and
so
so
so
that
you
know.
If
let's
say
you
know,
a
transaction
is
good
you're,
inserting
a
bunch
of
data
updating
you
group
them
into
transaction.
If
it's
all
good,
you
commit
them,
if
not
you
roll
back
kind
of
like
that,
so
and
then
of
course,
dude
there
also
the
use
of
cookies
right
cookies.
As
I
talked
about
earlier,
you
can
be
like
cookies
that
deals
with
like
in
a
web
application
side
of
things.
A
You
have
cookies,
that
that
kind
of
carries
with
it
like
session
for
session
id
kind
of
authentication,
type
of
kind
of
usages
right
and
then
they're
also
over.
Here
too,
I
already
talked
about
like
sessions
right
and
and
sessions,
and
also
like
tokens,
for
example
like
jwt
the
json
web
token
that
I
talked
about
earlier.
So
these
are
kind
of
more
like
the
techniques,
the
mechanisms
that
you
can
leverage
on
and
let's
then
take
a
look,
then
a
little
bit
step
up
into
like
cloud
native
infrastructure.
A
So
when
we
talk
about
cloud
cloud
native
these
days,
we
cannot
get
our
you
know
kind
of
our
talks
away
from
kubernetes
because
it
is
just
everywhere.
It
is
the
defective
standard
for
orchestrating
containers
like
a
world
of
you
know
many
containers,
so
containers
we
know
are
everywhere:
they're
they're,
managing
you
know
kind
of
application.
For
us,
you
know
from
many
levels
in
a
cloud-native
environment,
so
let's
kind
of
step
into
kubernetes
and
take
a
look
and
how
kubernetes
kind
of
handle
the
statefulness
of
data.
A
So
first
of
all
too,
as
we
all
know
too,
if
we're
kind
of
doing
like
complicated
scenario
when
you
need
to
duplicate
or
replicate
your
data
or
your
state
of
your
data
in
in
your
system,
right
there
are
kubernetes,
there
are
clusters
or
having
like
worker
nodes,
all
these
components
get
replicated
the
parts
and
everything.
So
one
thing
too,
is
I
want
to
point
out
is
that
it's
also
very
important
is
having
a
good
algorithms
for
doing
like
leader
is
election.
Why?
A
Because,
for
example,
right
in
a
real
life
scenario
you
can
be
doing
like
you
can
have
components
that
actually,
let's
say
doing
payment
right,
so
you
can
be.
Let's
say
simplest
case
is,
let's
not
make
it
way
too
complicated.
Let's
say
it's
just
two
components:
they
are
doing
payment.
They
get
rep,
they
both
get
replicated.
You
know
each
doing
the
same
thing,
but
when
it
comes
time
to
actually
authorizing
a
payment
or
submitting
a
payment,
you
only
want
one
to
do
it,
so
who
is
going
to
do
it
right?
A
So
that
is
very
important
and
that's
why
I
wanted
to
point
out
too.
We
need
to
have
also
good
understanding
of
the
leader
election
algorithms.
Now
the
good
news
about
it
is
that
in
kubernetes
there's
also
by
default,
there's
the
fcd
there
that
already
has
its
own,
like
kubernetes,
like
leader,
election
algorithms,
that
takes
care
of
things
for
you.
Now,
if
you
don't
like
that,
you
can
actually
have
external
components.
A
Let's
say
like
something
like
zookeeper
also
has
the
the
leader
election
algorithms
in
there
too,
and
then,
of
course,
there
are
also
other
software
that
you
can
actually
purchase
instead
of
using
the
default
kubernetes
one,
but
just
wanted
to
point
out.
It
is
absolutely
important,
especially
in
this
kind
of
transaction
scenario.
You
don't
want
the
same
thing
be
executed
twice.
You
know
that
type
of
stuff.
So,
okay,
so
that's
that
and
then
there's
also
in
kubernetes.
A
There
are
also
concepts
of
stateful
sets,
so
stateful
sets,
as
the
name
implies
it
kind
of
takes
care
of
sets
of.
You
know
all
of
your
worker
notes
and
and
your
parts
and
everything
within
your
your
ecosystem
right,
so
the
stateful
sets
will
manage.
You
know
any
time
too,
because
okay,
because
at
any
given
time
right,
you
can,
you
can
often
have
some
parts
that
are
not
healthy
and
needs
those
down,
and
then
you
need
to
spin
up
another
one.
A
All
of
these
things
are,
you
are
updating
things
you
know
up
and
down
all
the
time.
So
essentially
too,
you
can
implement
this
feature
right
in
kubernetes
that
are
stateful
sets.
That
will
actually
manage
all
of
these
changes.
A
So
then
there's
this
layer
of
or
functionality
that
you
can
work
with.
It's
called
persistent
volume.
So
the
persistent
volume
is
how
you
actually
arrange
all
of
your
storage
kind
of
with
your
how
you
manage
it
with
kubernetes.
So
so,
basically
you
can
leverage
on
this
persistent
volume
feature
too
and
then
there's
also
on
the
user
level.
A
Let's
say
right:
I'm
managing
I'm
working
with
this
volume
in
my
cluster
everything
you
can
actually
use
a
persistent
volume
request
in
order
to
request
a
different
volume
and
delete,
and
all
of
these
things
too,
so
that's
kubernetes
and
then
also
one
more
feature
of
kubernetes
is
the
cookies
and
session
affinity,
type
of
features,
and
that's
important
too.
Imagine
too
right-
and
I
used
this
example
earlier-
is
that
if
I
request
coming
in
right,
you
have
like
tons
of
replicated,
you
know
kind
of
kind
of
pots
or
components.
A
Microservices
are
taking
care
of
the
same
thing,
but
let's
say
one
kind
of
actually
will
be
the
actual
one
handling
some
you
know
kind
of,
let's
say
the
request
that
comes
in
by
the
client
that
comes
in.
So
in
that
case
I
want
to
have
this
stickiness
maintained,
because
then
this
session
may
still
you
know
it
basically
to
this
request
can
often
go
away,
but
then
the
next
time
it
comes
into
you
want
to
have
this.
A
The
mechanism
there
in
which
it
comes
back
in
and
you
know
who
was
handling
it
before
so
then
you
don't
need
to
pick
another
microservice
to
actually
do
the
job,
because
this
will
save
time
because
there's
no
need
to
kind
of
reinitialize
yourself
again
to
service
the
same
client
things
like
that
so
kind
of
kind
of
you
know.
This
is
just
a
way
of
explaining
the
concept
behind
this
session
affinity,
kind
of
sticky
session
kind
of
features
in
kubernetes
so
and
again,
because
this
session
isn't
about
about
that.
A
So
I'm
kind
of
explaining
things
more
like
just
talking
about
it.
You
know
the
concept
of
such
so.
Okay,
all
right
then,
as
such,
I
only
have
10
minutes.
So
let
me
kind
of
get
into
a
bit
of
the
programming
design
pattern
aspect
now
so
on
the
application
level
too.
We're
leveraging
on
like
programming
pattern
to
help
us
too,
with
doing
you
know,
handling
like
design
or
handling
statefulness.
A
You
know
in
your
system
in
a
microservices
type
of
system,
so
that
the
first
and
foremost
actually
this
would
be
something
that
everybody
would
be
picking
to
use.
Is
the
saga
pattern
so
psychopattern
as
it
implies
right?
It
helps
with
spanning
you
know,
you're
trying
managing
your
transactions
that
are
span
across
multiple
services,
right
and
so
saga.
A
As
such,
it
offers
you
a
concept,
a
role
forward
or
kind
of
it's
called
forward
strategy
kind
of
concept.
You
know,
there's
no
such
thing
as
rollback,
so
essentially
too,
when
you
write
your
microservice
to
handle
things
right,
then
you
also
need
to
have
like
a
counterpart
of
a
compensation
kind
of
service
that
goes
with
it.
A
So
then
you
know
that
if
something
goes
wrong
rather
than
rolling
back,
you
will
actually
have
steps
in
your
code
in
which
you
actually
compensate
for
what
has
been
done
and
you
want
to
sort
of
like
undone
it.
But
you
don't
call
it
rollback,
it's
more
like
roll
forward,
basically
kind
of
fixing
it.
So
then
you
can
kind
of
insist
in
a
sense.
It's
like
restoring
where
it
was
before,
but
that's
the
the
concept
of
a
soccer
pattern
and
then
there
are
also
two
ways
of
dealing
or
actually
two
ways
of
coordination.
Sagas
too.
A
So
there
are
choreography,
which
is
an
event-driven
type
of
approach
of
kind
of
doing
sagas,
and
I
have
a
quick
example
to
show
you
shortly
and
then
otherwise,
too,
there's
also
an
orchestration
kind
of
way
of
doing
things,
and
so
choreography
is
more
like
a
self-directed
kind
of
ways.
It's
all
event
driven
right.
You
listen
to
events
that
interest
you
that
particular
microservices.
A
So
if
the
event
comes,
then
I
will
react
accordingly
and
do
its
thing
and
then
maybe
when
it's
done
it
will
generate
some
other
event
for
some
other
components:
microservices
that
are
listening
on
it.
So
that's
how
you
kind
of
like
trigger
the
actions
to
kind
of
flow
through
your
whole
system,
it's
very
event-driven
in
nature
and
there's
no
like
single,
so
to
speak,
like
a
component.
That
kind
of
tells
you
what
to
do
unlike
orchestration.
So
orchestration
is
like
just
sort
of
like
just
the
opposite.
You
actually
do
need
an
orchestrator.
A
It's
like
an
orchestra,
you're
playing
you
know,
music.
Then
you
need
somebody
to
be
there
sort
of
like
coordinate
and
make
sure
everybody
is
in
existence
existing
in
harmony,
so
to
speak,
and
as
such,
do
I
wanted
to
point
out
too
in
micro
profile,
there's
a
new
feature
that
a
relatively
new
feature
that
came
out
in
may
of
this
year
and
it's
actually
a
running
action.
It's
called
lra
and
it's
makes
use
of
the
soccer
interaction
pattern
and
it
makes
just
also
has
the
compensator
model
and
there's
also
an
example
library.
A
Well
actually,
but
this
is
the
example
library,
implementation
is
the
micro
profile
and
it
as
such,
too.
It
makes
use
of
the
orchestration
way
of
doing
things
now.
The
thing
is
too:
I
don't
currently
have
an
example,
the
demo
and
that's
something
I'm
still
have
to
kind
of
do,
but
I
wanted
to
quickly
show
you
a
design
too
as
to
how
we
can
maybe
leverage
right
to
kind
of
show
some
concept
of
this
choreography
event-driven
saga
pattern.
A
So,
let's
take
a
look
at
you
know
an
example
to
kind
of
illustrate
this
concept,
so
I
have
actually
a
shopping.
Cart
example.
Very
simple:
all
it's
doing
is
that
it
takes
an
order.
You
know
when
an
order
comes
in.
Let's
say
you
know,
I'm
using
kafka.
Some
order
happens
in
here.
Then
it
produces
an
event.
So
that's
where,
when
my
order
microservice
will
listen
to
this
event
in
something
called
order
generated,
then
the
order
will
then
be
put
to
work
right.
A
My
microservices
will
kind
of
do
all
these
things
and
you
know
set
up
the
order
and
set
up
all
the
proper
statuses
and
all
these
things
and
then
kind
of
like
you
know,
find
you
know
the
the
item
number
you
know
is
it
in
the
catalog
and
then
essentially
two
once
it
all
these
things
gets
kind
of
put
in
place,
then
you
have
a
an
order
created
event
that
gets
generated
now
this
this
event
is
being
listed
on
by
two
micro
services.
One
is
an
inventory
check
and
the
other
is
the
credit
check
now
again.
A
This
is
a
simplified
kind
of
kind
of
a
real
life
scenario,
but
simplify,
but
in
reality
you
can
have
more
than
one
micro
services.
Listening
on
this
particular
order
generated
event,
because
you
are
doing
many
things
at
the
same
time,
but
for
this
you
know
simplicity,
we
say
we
need
to
go
and
check
the
inventory
and
inventory
and
making
sure
that
the
items
that
you
know
the
request
is
requesting
for
you
know
is
in
place.
So
that's
when
you
have
your
inventory
check.
A
Microservice
will
go
off
and
does
its
own
thing
and
then
the
credit
check
at
the
same
time
would
say:
okay,
cool!
You
know
we
get
the
credit
card
number,
let's
kind
of
make
sure
that
this
is
a
valid
credit
card.
All
these
things,
it
hasn't
expired
blah
blah
blah
all
these
things.
So
so
these
two
microservices
will
be
busy
doing
its
own
job.
A
You
know
accordingly,
now,
in
the
meantime,
while
they're
doing
everything,
we
also
want
to
update
to
maybe
sending
back
update
to
the
order
microservices,
because
two
we
also
keep
track
of
a
list
of
status
of
this
order.
So
let's
say,
as
you
can
see
too,
I
kind
of
put
it
over
here.
This
order
created
all
the
inventory
validated
all
of
these
status.
That
indicates
the
state
of
the
order
too.
So,
as
you
can
see,
this,
this
kind
of
usage
is
can
be
very
complicated
in
the
sense
that
you
can
have
multiple
things
happening.
A
The
status
of
everything
can
be
changing
at
any
time,
so
you
need
to
kind
of
have
a
way
of
keeping
track
of
it.
Now.
One
way
to
to
kind
of
keeping
track
of
it
is
using
event
sourcing,
for
example.
Now
I
won't
have
time
to
talk
about
event
sourcing,
but
essentially
to
event
sourcing
is
you're
keeping
track
of
the
state
changes
of
this
order.
At
the
same
time,
so
we
can
be
using
a
kind
of
event
sourcing
to
keep
track
of
the
state
changes
too.
Okay.
A
So
now,
let's
kind
of
how
about,
if
we
kind
of
go
back
right,
these
two
microservices,
let's
say
inventory
check,
does
its
job,
it's
all
good.
Now,
then
it
generates
an
order.
Inventory
checked
kind
of
indicating
it's
successful
checking.
I
have
the
10
bottles
of
wine
that
this
request
is
asking
for,
so
then
it
will
generate
the
order.
Inventory
checked
event
which
is
listed
on
by
the
payment
processor.
A
Likewise,
the
payment
processor
cannot
do
anything
because
it's
waiting
for
credit
check
to
come
back
now.
Let's
say
my
credit
check
goes
to
the
payment
authorization
provider
check
and
make
sure
the
credit
card
is
good.
All
these
things
are
good
running
through
all
the
checks
is
all
good.
Then
it
generates
an
order.
Credit
check.
So
in
that
case
both
events
gets
generated.
Then
my
payment
processes
said:
okay,
all
good.
I
am
expecting
these
two
events
they
come.
Then
I
can
do
my
work
in
the
meantime,
too.
A
A
Then
I'm
going
to
go
through
and
send
my
payment
to
the
payment
authorizing
provider
right
and
all
of
these
things,
which
is
quite
complicated,
which
something
I've
done
before
so
it
kind
of
goes
through
different
steps
and
external
services
to
to
do
all
these
things,
and
so,
while
this
is
waiting,
everything
is
kind
of
waiting.
Let's
say
it's
all
good,
then
in
that
case
you
know
the
order
is
paid.
A
It
will
receive
a
payment,
a
proper
kind
of
status
that
comes
back
from
my
payment
provider
and
says:
okay
order
is
paid,
I'm
all
good.
So
in
that
case
then,
I
know
with
this
event.
Then
payment
processor
will
then
notify
the
shipping
processor,
so
the
shipping
processor
can
now
get
busy
go
and
fetch.
You
know
things
from
the
warehouse
and
then
ship
to
the
the
receiver.
In
the
meantime,
too,
I'm
doing
a
lot
of
things
to
update
my
order,
making
sure
my
order
payments
process
is
paid
and
shipped
all
these
things.
A
Now,
in
this
particular
case,
let's
say
everything
is
good,
then
there's
no
need
to
invoke
the
compensator
microservices
for
doing
any
kind
of
compensation.
But
if
there's
something
goes
wrong
then
you
have
to
actually
execute
this
compensator
so
that
everything
wouldn't
happen.
This
whole
thing
wouldn't
happen
at
the
end,
so
okay,
so
I
think
I
might
be
talking
a
little
bit
too
long
and
I
think
I
should
kind
of
move
back
onto
my
slide,
which
is
also
like
towards
the
end
now
too.
A
So
that's
kind
of
like
a
quick
kind
of
example
illustrating
the
concept
of
this
so
and
I
also
wanted
to
bring
up
quickly
what
about
reactive
right?
Maybe
I
won't
talk
about
as
much
because
that's
an
area,
I've
kind
of
worked
with
before,
but
I
just
wanted
to
point
out
doing.
Microservices
too,
you
can
also
kind
of
use
a
reactive
type
of
approach.
The
one
big
difference
with
it
is
that
then
you'll
be
making
use
of
streams.
A
A
Examples
that
you,
if
you
like
to
try
out-
and
I
think
I
don't
think
I
have
enough
time
or
do
I
to
kind
of
show
things,
but
I
can
quickly
show
too
there's
also
like
I
wanted
to
point
out.
Is
the
open
liberty
session
persistence
that
this
one
isn't
using
the
soccer
pattern,
but,
like
I
said,
soccer
pattern
has
yet
to
be
built
and
that
something
is
in
my
plan.
A
But
in
the
meantime
I
wanted
to
show
you
open
liberty,
session
persistence
using
j
cash
and
hazelcast
too,
so
you
can
actually
go
to
our
open
liberty.
I
o
guides
and
then
session
too.
So
let
me
kind
of
quickly
show
you,
even
if
we
don't
have
time
to
kind
of
try
them
out.
Okay,
so
go
back
to
my
actually.
A
I
should
have
open
it
here:
open
liberty,
right
and
basically
go
into
guides
and,
as
you
can
see
too,
they
are
not
just
soccer
pattern,
not
just
everything
we
have
like
about
58
guys
in
total
they're.
Also
the
red
ones
are
run
in
cloud
right,
so
you
can
actually
try
them
out
without
worrying
about
installing
all
of
the
requirements
too.
So
that's
a
nice
thing
if
you
want
to
try
the
cloud
interactive
ones
so
so
now,
in
this
case,
you
can
kind
of
go
through
different
categories.
A
If
you
go
to
persistence,
this
is
the
one
that
I
was
gonna
show
you,
but
the
thing
is
too:
we
may
not
have
enough
time
to
do
them
today,
but
I
at
least
wanted
to
point
out
to
you.
Is
that
if
you
want
to
kind
of
get,
you
know
put
your
hands
into
something
to
just
try
it
out.
This
is
actually
very
self-explanatory
and
it
shows
you
how
how
you
can
kind
of
leverage,
caching,
http
session
data
using
j
cash
and
hazelcast
so
and
as
such,
too
wanted
to
also
highlight
right.
A
That's
the
beauty
too,
of
using
jakarta
ee
using
micro
profile.
All
of
these
kind
of
play
so
well,
and
the
nice
thing
also
is
that
you
launch
it
into
open
liberty
which,
actually,
by
default,
it
uses
the
open,
j9
jvm,
which
is
like
built
perfectly
right,
very
efficient
for
like
a
clown
native
type
of
environment,
so
yeah
everything
kind
of
comes
together.
I
wanted
to
encourage
all
of
you
to
try
if
you
haven't
already
done
so
so
okay,
so
I
want
to
kind
of
like
do
a
quick
thing
in
here.
A
You
know
before
I
kind
of
I
think,
I'm
almost
running
out
of
time,
essentially
too,
this
set
of
exercise
will
involve
like
two
microservices
a
system
and
also
a
an
inventory
one.
So
if
you
kind
of
read
through
it,
it
will
explain
to
you,
but
essentially
two
we
are
trying
to
show.
You
is
a
very
simple
kind
of
shopping,
cart
scenario
and
it's
leveraging
on
j
cash
and
and
basically
have
hazelcast
as
our
provider
to
do
it.
A
So
you
can
kind
of
work
through
all
of
these
guides
and
then
there
are
also
two
directories
too
for
all
of
our
guides.
Here,
there's
a
start
and
the
finish
you
always
want
to
go
to
the
start
directory.
If
you
want
to
work
through
all
of
the
examples
and
we'll
provide
you
guidelines
on
what
you
need
to
do
when
you
create
your
class
files,
set
up
your
configurations
and
everything-
and
it's
like
nice
thing
about
this-
is
leveraging
on
micro
profile
on
jakarta,
ee
of
doing
like
restful,
jax
rs,
for
example.
A
These
are
all
like
standardized
type
of
features
that
we
can
leverage
on
in
the
jakarta
ee,
in
the
micro
profile,
implementation
and
also
then,
as
we
all
know
too
micro
profile
is
so
flexible
right.
It's
it's
kind
of
micro
profile,
5.0
just
got
released
today
I
saw
emily
kind
of
advertise
for
that.
So
and,
of
course,
I'm
aware
of
that,
so
that's
wonderful
too.
So
five
fifo
is
there,
and
so
it's
really
nice-
I
mean
the
more
I'm
using
it.
A
I
I
really
feel
is
it's
really
like
very
flexible
and
it
supports,
like
nine
different
implementations
of
the
runtime,
of
which
you
know
open
liberty
is
one
of
them,
so,
okay,
and
over
here
too,
you
can
just
follow
all
of
these.
Like
I
said
you
know
all
these.
You
know,
example
here
the
the
cart.
You
know,
application
as
you
can
see,
and
the
card
resource
is
basically
making
use
of
the
jsonp
json
b
and
all
these
things
that
some
other
speakers
already
talk
about.
A
But
the
thing
is,
I
just
want
to
quickly
kind
of
show
it
to
you.
So
if
you
want
to
give
it
a
try,
please
do
so
so,
okay,
so
instead
of
me
kind
of
stepping
through
all
of
it,
since
I'm
kind
of
running
out
of
time
I'll
go
back
to
my
slides
and
kind
of
wrap
up
quickly.
Now
so,
okay,
here
we
go.
Oh,
I
guess
the
wrong
side.
A
Let
me
go
back
okay
here
we
go
so
that's
our
sessions
and
as
such
you
can
reference
my
slides
and
you'll
be
able
to
get
to
all
of
these
and
another
example
is
a
stateful
open
liberty,
application
in
kubernetes,
which
graham
charters
actually
put
together
this
and
I
kind
of
looked
into
it.
I
think
it's
a
good
way
for
you
if
you
want
to
take
a
look
at
stateful,
the
stateful
sets
in
kubernetes
and
we're
using
the
nginx
as
the
ingress
controller
to
do
that
too.
A
So,
if
you
want
to
take
a
look
at
that
one
and
then
some
more
resources
and
links
in
here
too
and
such
all
of
these
right,
these
are
all
the
code.
Examples,
design
patterns
open
source,
libraries
that
I've
talked
about
in
open
liberty
and
and
all
these
two
examples,
I've
tried
out
saga,
design,
pattern,
microprofile,
lra
and
the
lra
block
too,
and
I'm
hoping
to
to
actually
work
on
an
actual
example
of
the
saga.
A
So
then
we
I
can
share
it
with
you
later
too,
and
these
are
links
to
all
of
the
open
liberty,
micro
profile
in
jakarta,
ee
and
okay
and
the
next
one
wait
here
we
go
and
then
there
are
also
other
resources
from
ibm
too.
If
you
want
to,
you
know,
read
them
on
cloud
cloud,
devops
cloud
native.
All
of
these
please
kind
of
reference,
this
page
and
then
I'm
also
on
the
ibm
developer.
Twitch
live
stream
every
wednesday.
A
If
you
want
to
join
me,
this
is
the
link
to
our
twitch
ibm
developer
channel,
and
then
we
also
have
our
expert
tv
and
meetups
too.
There
are
all
kinds
of
shows
on
there
all
free,
so
please
consider
joining
and
also
my
chicago
java
users
group.
We
do
have
at
least
once
a
month.
We
have
meetups
and
sometimes
two
times
two.
So
please
consider
joining
and
there's
also
the
public.
A
Well,
actually
free
tier,
ibm
cloud,
you
if
you
sign
up
you
get
a
200
credit
if
you
want
to
try
it
out
too
and
with
that
comes
to
a
close,
and
I
think
I'm
kind
of
right
on
time.
So
thank
you.
Thank
you
so
much
for
giving
me
this
opportunity.
I
want
to
invite
you
to
connect
with
me
on
my
discord.
Server
too.
I'm
on
there
almost
all
the
time,
and
if
you
have
any
questions
you
want
to
continue
discussing
about
any
things.