►
From YouTube: Effective Docker and Kubernetes for Java EE / Jakarta EE Developers | Jakarta TechTalks - May 2019
Description
There are several key trade-offs to consider while using Docker and Kubernetes with Java EE applications. Examples include:
- Whether to use thin WARs, fat JARs, or hollow uber-JARs to effectively work with Docker repositories, layering, and caching.
- Whether to deploy applications within images, through exposed admin ports or as autodeployed mounted external volumes.
- How Docker clusters, networking, and Kubernetes deployments align with application server administration, clustering, auto-discovery, and load-balancing.
- How the CI/CD pipeline of your application can be adapted to Docker and Kubernetes.
This entirely slide-less, fast-paced, demo-driven session walks through each of these considerations in detail.
///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
Okay,
everyone
can
everyone,
the
up
great
present,
so
I
can
hear.
I
can
see
if
people
are
already
waiting
for
for
the
session.
I'm
super
excited
today
to
have
reservoir
man,
with
his
presentation
on
effective
docker
and
kubernetes
for
Java,
EE
and,
of
course,
Jakarta
II.
Now
developers
we
have
people
from
around
the
globe
which
is
super
exciting
and
interesting,
and
I
will
immediately
hand
it
over
to
Reza.
So
we
can
start
the
session.
A
B
Perfect
so
the
first
thing
I'd
like
to
do
is
talk
a
little
bit
about
this.
What
this
talk
is
about
and
what
the
motivations
are
and
what
we
hope
can
accomplish
to
accomplish
together
in
the
next
hour
or
so
so,
I
think
the
if
you
haven't
read
the
abstract,
I'll,
explain
it
a
little
bit
more.
So
basically,
this
talk
is
about
how
to
be
effective
as
a
Java
EE
developer,
using
docker
and
kubernetes
there's
a
lot
of
fat
around
there.
The
Java
EE
is
not
a
good
fit
for
these
technologies
and
so
on.
B
The
reality
is
very
different.
Not
only
is
it
a
very
good
fit
for
these
technologies
and
I'll
explain
the
reasons
why
that
is
it
there's
also
many
different
trade-offs.
There's
many
different
things
that
you
can
do.
That
is
right
for
your
particular
individual
situation.
So
that's
some
of
those
factors
is
what
we're
going
to
talk
about.
I'll,
give
you
a
run
through
what
those
are
the
other
thing.
I
am
few
other
things.
I'll
tell
you
is
that
I?
If
I
actually
went
through
the
entire
material
of
this
talk,
it
would
probably
take
about
2.
B
So
there's
definitely
enough
work
here
for
a
workshop,
so
I
won't
be
covering
obviously
all
of
the
materials
today,
I
almost
never
do
what
I'm
going
to
do
is
I'm
gonna
skip
over
certain
parts
and
I'll.
Tell
you
why
that's
not
a
big
deal.
The
reason-
that's
not
a
big
deal
is
this
is
the
talk
as
you
can
see,
you
can
hopefully
see
my
screen.
The
talk
is
essentially
on
github
and
believe
it
or
not
in
this
talk,
I
won't
be
using
a
slides
whatsoever.
B
Literally,
what
I'll
be
doing
is
I'll
be
live
coding
for
the
next
hour
or
so,
but
it's
not
the
entirely
live
coding.
I'll
basically
be
using
the
instruction
set.
That's
here
to
do
the
live
coding.
So
what
this
means
is,
after
the
fact
you
can
just
log
take
a
look
at
this.
This
github
URL
and
you'll
be
able
to
replicate
all
of
the
demos
by
yourself.
So
that
is
one
of
the
objectives
of
this
talk.
I,
do
consider
it
and
sort
of
an
open-source
talk,
so
you
can
self
guide
yourself.
Take
all
the
materials.
B
Do
it
yourself
and
in
fact,
I
always
encourage
you
to
maybe
consider
delivering
this
talk
yourself?
Certainly
all
of
the
material
is
out
there
for
you
in
order
to
do
that,
and
of
course
you
can
always
reach
back
to
me
if
you
need
anything
at
all
and
need
any
guidance
on
how
you
could
possibly
deliver
this
talk
yourself,
perhaps
internally,
perhaps
on
a
jug,
perhaps
at
a
conference.
What
have
you
even
as
a
workshop,
if
you
so
wish?
B
So
without
further
ado,
let
me
explain
the
outline
of
the
talk,
so
first
of
all,
we'll
be
just
going
over
a
basic
Java,
EE
application,
then
I'll
be
using
throughout
this
talk
here.
So
that's
under
the
Java
EE
folder,
so
there's
some
very
simple
instructions
on
how
to
get
this
application
up
and
running
it's
a
basic
crud
application.
B
So
it's
got
all
of
the
basic
moving
pieces
that
you
would
expect
it's
using
Java,
EE
8
at
the
moment,
obviously
as
soon
as
Djakarta
EE
8
is
available,
I'll
be
switching
over
to
that
can
do
that
quite
yet
for
obvious
reasons,
but
definitely
on
the
roadmap.
For
this
talk,
and
hopefully
one
of
the
first
talks-
I'll
be
delivering
under
the
Djakarta
EE
Briella
sooner
rather
than
later.
Okay,
so
some
basic
instructions
on
how
to
do
it.
I
won't
go
over
this.
This
is
for
most
of
us.
There
are
Java
developers.
B
This
is
probably
pretty
simple
stuff
and
I'll
just
run
the
application
to
show
you
how
the
application
looks
like
after
that,
we
will
be
talking
about,
for
the
most
part
docker
for
about
half
to
three-quarters
of
the
of
the
presentation,
we'll
be
talking
about
different
ways
that
you
can
package
and
deploy
java
ee
applications
using
docker,
so
we'll
be
using
the
thin
water
approach,
that's
sort
of
a
favorite
of
Adams
and
certainly
honestly,
a
favorite
of
mine
as
well.
You
believe
it
or
not.
B
That's
not
the
only
option
that
you
have
in
in
using
docker
and
Java
EE
applications.
You
can
use
uber
jars,
so
called
Cooper
jars
or
fetch
ours
as
well
I'll
be
showing
you
how
to
do
that
in
using
Java
EE
and
what
the
trade-off
some
of
the
trade-offs
there
is
and
there's
also
another
very
interesting
approach
called
hollow
goober
jars
and
some
Java,
EE
and
micro
profile.
Runtimes
will
allow
you
this
hablo
over
char
option
as
well.
So
those
are
the
three
options
that
I'll
actually
be
talking
about.
B
Those
are
the
sort
of
the
mainstream
options
that
I've
seen
in
use
for
deploying
and
packaging
java
applications
using
docker
the
part.
The
other
parts
that
are
sort
of
bonus
that
I
would
I
would
encourage
you
to
take
a
look
at
yourself.
Is
the
expert
expose
port
and
external
volume
techniques?
I'll,
just
briefly
explain
it
here,
and
that's
all
I'm
going
to
cover
for
those
two
techniques
and
of
course
again,
you
can
take
a
look
at
this
yourself
later
on.
B
B
So
that's
one
of
the
techniques
that
you
can
consider
and
it's
documented
on
how
to
do
that
using
docker.
It's
a
fairly
straightforward
technique
there
and
the
other
interesting
technique
that
I
also
have
seen
in
use
in
the
wild
is
using
docker
external
volumes.
So
most
of
the
java
application
servers,
modern
ones
provide
an
option
for
drop-in
deployment,
so
you
have
a
specific
designated
directory
India
in
your
file
path
that
you
can
simply
deploy
your
war
file
or
ear
file
and
the
application
server
will
simply
pick
that
up.
B
There
are
advantages
to
this
approach
and
believe
it
or
not.
You
can
use
this
approach
with
docker
and
kubernetes
as
well.
It's
a
fairly
straightforward,
again
way
of
doing
things,
there's
a
specific
mechanism
in
docker
that
will
allow
you
to
do
that.
It's
called
external
volumes
and
in
the
external
volume
section
you
will
see
how
to
do
that
and
again.
I
won't
cover
it
here
beyond,
certainly
describing
what
it
is.
Finally,
in
the
last
quarter
of
the
presentation
we'll
be
talking
a
bit
about
kubernetes
in
the
nexus
wall.
B
So
how
does
the
entire
Java
EE
deployment
scenario
looked
like
with
cool
with
kubernetes
in
the
next?
There
are
some
similarities
and
differences
on
how
you
do
this
there's
a
V
sort
of
a
traditional
on-premise
deployment,
but
I
think
for
the
most
part,
it's
actually
an
improvement.
I'll,
explain
to
you
why
there
is
effectively
what
happens
with
kubernetes
is
some
of
the
things
that
traditionally
app
servers.
B
Control
are
then,
at
this
point,
controlled
by
kubernetes,
and
actually
that
makes,
in
general
things
easier
to
deal
with
and
more
scalable
and
repeatable
and
all
of
the
good
stuff
that
kubernetes
comes
with
now
on
the
one.
A
part
of
this
talk
that
still
work-in-progress
and
I
haven't
quite
finished
yet
is
the
is
how
to
show
all
of
this
with
CI
CD
enabled,
specifically
with
Jenkins
on
evil.
I.
Just
haven't
gotten
a
chance
to
get
to
doing
that.
Yet.
B
Certainly
I
would
welcome
a
pull
request
to
do
that
work
so,
as
I
mentioned
I'm
using
Java
EE
8.
At
this
moment,
I
chose
WebSphere
Liberty
4
for
this
demo
faithfully,
because
it
lends
itself
very
well
to
all
of
the
different
techniques,
but
you
don't
necessarily
have
to
use
WebSphere
Liberty.
You
can
use
for
the
most
part
any
Java,
EE,
runtime
and
they'll
are
by
and
large
it's
that
you
will
see
the
same
sort
of
available
techniques
and
trade-offs
available
to
you
for
the
demo.
B
Today,
I
will
be
using
Azure
I'll,
be
using
the
azure
kubernetes
service,
which
is
a
kubernetes
implement
of
the
leading
kubernetes
implementations
out
there.
You
don't
have
to
use
either.
If
you
don't
want
to
it's
everything
that
I'm
gonna
be
showing
in
this
demo,
you
could
easily
apply
to
some
other
kubernetes
implementations,
whether
that's
googles
or
Amazons,
or
what
have
you
and
obviously
Jenkins,
as
I
mentioned-
haven't
quite
gotten
around
to
doing
that
as
of
yet
so
let
start
with
demoing
the
application.
B
So
the
first
thing
I
need
to
do
in
order
to
demo
the
application
is
get
the
database
up
and
running.
This
is
a
database
driven
trata
application.
Actually,
the
simplest
way
to
do
that,
since
we're
going
to
be
using
docker
anyway,
is
just
start
the
database
using
docker.
So
that's
what
I'm
going
to
be
doing
I'm
going
to
starting
a
post-race
instance,
essentially
using
docker.
B
B
What
we
are
doing
is
we
are
taking
the
Postgres
image
that
is
available
on
docker
hub
and
essentially
running
it
and
we're
just
giving
the
image
a
name
name
parameter,
and
the
slash
V
is
actually
what
I
mentioned
as
the
exposed,
or
rather
external
volume
technique,
in
this
case
I'm,
using
an
external
volume
on
my
local
machine
that
I
need
to
store
the
the
data
in
the
actual
physical
data
that
needs
to
reside
outside
of
the
our
side
of
the
docker
image.
So,
okay
go
ahead
and
get
the
day
started
here.
B
Okay,
so
what's
happening
here
is
we
are
downloading
the
database
from
docker
hub
it's
getting
downloaded
locally,
it's
gonna
take
just
a
moment
and
once
the
download
completes
it's
going
to
actually
start
the
database,
hopefully
without
incident.
So
one
thing
I
forgot
to
mention
is
that
I
don't
tend
to
do
separate,
Q&A
a
time
so
I'd
much
rather
go
for
death
rather
than
breath.
So
if
we
have
questions
just
ask
the
questions,
you
know
I
guess
using
the
chat
mechanism
in
this
case
and
thani
is
gonna.
B
Ask
me
the
question
swap
me
and
hopefully
ask
your
question
to
me
and
we
can
just
do
Q&A
throught,
there's
no
reason
to
wait
around
if
I
don't
cover
ground
that
I
wanted.
It's
not
a
big
deal
like
in
all
of
the
material
is
available
to
you.
So
if
you
have
questions,
don't
don't
hold
back
just
just
toss
them
right
away,
so
the
database
is
now
up
and
running
it's
running
locally.
It
is
running
on
a
designated
port,
as
you
can
see.
B
So
if
you
look
it
up
into
my
docker
command,
I
have
a
P
parameter,
and
this
is
actually
what's
exposing
the
port.
So
when
you
are
running
a
docker
image
by
default,
the
image
actually
will
not
expose
any
of
the
ports
so
think
of
this
as
a
built-in
firewall
around
the
MRAP
the
running
image.
In
order
to
actually
expose
a
port
out
of
the
image,
you
need
to
be
very
explicit
about
it.
So
in
this
case,
we're
explicitly
saying
please
expose
port
54
32
so
that
this
port
can
be
accessible
outside
of
the
running
image.
B
So
there's
the
database
up
and
running
now
and
we're
gonna
go
ahead
and
access
this
database
and
actually
virgins
can
keep
the
database
up
and
running
for
a
while.
This
is
my
application.
It's
set
up
using
in
Eclipse
I'll
just
do
a
walk-through
of
the
brief
walk
throughout
the
application
and
the
best
way
to
do
that
is
actually
in
the
github
itself.
So
if
you
bump
back
up
this
is
the
my
java
ee
tea
tree.
This
is
what
the
java
application
resides.
B
This
is
where
the
java
application
actually
is
on
the
under
the
Java
EE
Cafe
directory.
This
is
really
nothing
much
more
than
just
a
vanilla,
maven
Java
EE.
Eight
application
won't
go
through
their
code
too
much.
You
can
do
that
by
yourselves.
I'll
just
show
you
the
palm
file,
because
I
think
that's
relevant,
so
I'm
gonna
increase
the
font
here
a
bit,
so
we
can
all
see
it
so,
a
typical
Java
application
very,
very
simple,
set
of
dependencies.
B
In
this
case
we
just
have
a
dependency
actually
just
on
Java
I
ate
the
Java
API
version
is
declared
up
here,
as
you
can,
as
you
can
imagine
so
other
than
that,
there's
no,
no
other
dependencies.
The
build
is
super
simple
beyond
that,
so
I
mean
really.
You
can
get
much
simpler
in
terms
of
a
into
the
pom
file,
so
very
sort
of
java
ee
situation.
Here
you
do
need
a
little
bit
of
server
configuration
and
the
server
configuration
is
on
under
the
server
directory.
B
So
all
you
really
need
in
this
case
is
a
is
a
database
driver
and
there's
the
post
question
base
driver
it's
actually
included
in
the
github.
For
your
convenience-
and
you
need
some
very
small
configurations
for
the
application
server
itself
not
much.
This
is
for
the
most
part,
but
what
you
can
see
to
expect
in
Liberty,
or
rather
worse
here,
Liberty
as
a
normal
deployment,
so
in
this
case
I'm
using
so
West
Liberty
comes
with
profiles
or
features
in
this
case
I'm
using
the
Java
EE
8
feature
set.
B
This
is
giving
me
all
of
the
API
Satar
in
Java,
yet
other
than
that.
I
have
some
very
simple
configuration
just
for
set
up
some
security.
Some
poor
sex
pose,
but
the
most
important
bit
of
configuration
is
here:
I
have
a
database
have
a
datasource
configured
and
the
datasource
notice
is
talking
to
local
host
and
port
54
32,
which
is
the
port
that
we
exposed
in
our
docker
image
other
than
that.
It's
just
a
little
bit
of
configuration
just
to
register
the
database
driver
okay.
So
let's
run
the
application.
B
B
Okay,
go
there,
we
go
it
started
in
3.17
two
seconds:
I
think
is
pretty
impressive.
So
now
we
have
the
application
up
and
running,
let's
play
around
with
the
applications
just
a
little
bit
so
I'm
gonna
go
ahead
and
paste
it
on
through
my
browser,
I'm
gonna
add
a
few.
It's
just
a
crud
application.
Silly
is
basically
a
crud
application,
managing
coffee,
a
coffee
and
entry.
So
we'll
just
add
a
few
things
here,
we'll
add
Reza
one,
oh,
my
goodness.
B
B
Let
me
do
this,
let
me
just
do
sometimes.
This
is
just
a
caching
issue
that
can
happen
I'm
just
going
to
make
sure
that
my
code
is
is
fresh.
So
let
me
just
take
a
look
at
to
see
if
there's
anything
I've
inadvertently
change.
So
this
is
Java
EE
docker.
Let
me
just
do
a
commit
real,
quick
and
see
if
there
is
any
differences.
No
there's,
no
significant
differences,
that's
a
that's!
What
I
would
have
expected
to
happen.
So
let
me
just
do
a
cleanup
in
Delft,
so
let
me
make
sure
Liberty
shut
down.
B
B
B
Okay,
there
we
go
sometimes,
as
I
said,
there's
this
sometimes
I've
noticed
in
gloss
efficient,
open,
Liberty
application
servers
that
are
using
things
like
OSGi,
sometimes
just
things
get
cached
and
not
flushed
for
some
reason.
So
let
me
just
show
you
so
this
is
the
there's,
a
crud
application
I'm
going
to
hit
delete
here
fully
that
works.
It
died.
Okay,
so
let
me
say,
let
me
add
an
entry
just
to
show
you
that
I
don't
have
anything
hidden
off
my
sleeves.
B
B
Okay,
so
what
we
have
here,
let
me
shut
this
down
just
so
it
doesn't
interfere
with
anything
else
and
I.
Don't
forget,
there's
already
a
running
instance
of
Liberty,
so
that's
all
shut
down.
So
if
you
look
at
the
source
code,
it's
relatively
simple,
so
you
have
essentially
your
Java
sources,
so
source
main
Java
technical
maven
structure
here
so
under
web
app.
There's
really
not
a
whole
lot
going
on
as
a
resource
is
a
single
JSF
facelet
component
for
input
price,
there's
not
a
lot
in
the
web
and
there's
a
very
simple
web.
B
Xml
file,
not
a
whole
lot
going
on
here
again,
just
specifically
specifying
the
welcome
file
for
the
most
part.
It's
a
very
simple
index:
dot
HTML
file,
the
the
page
that
you
saw
there
the
basically
this
is
a
spa,
a
JSF
spa
as
a
sort
of
weird,
as
that
may
seem
it's
just
a
single
page
application
that
allows
you
to
do
crud
and
then
there's
some
resources,
again:
persistence
or
XML
fairly
straightforward,
not
a
lot
going
on
here
either.
B
Just
a
definition
of
the
data
source
for
the
most
part
is
the
only
interesting
thing
here
and
under
the
cafe
web.
You
have
some
messages,
properties
that
I'm
loading
other
than
that
it's
just
the
Java
code
and
hopefully,
there's
a
better
way
of
showing
the
Java
code.
Let
me
see
if
I
can
do
that,
shouldn't
have
to
there.
We
go
okay,
so
under
source
main
Java
there's
a
several
packages.
There's
a
model
and
under
the
model
is
just
really
just
a
repository
the
repository
code.
B
It's
just
proud
applications
that
allows
you
to
essentially
get
read,
update,
delete
coffees
using
JPA,
it's
injecting
the
JTA
entity
manager.
You
have
the
actual
entity
very,
very
simple,
this
of
coffee
entity.
It's
just
got
a
three
fields
to
it:
ID
name
and
price,
and
then
we
have
a
simple
best
interface
for
it,
there's
a
there's,
a
path
for
it,
and
then
we
have
a
get
post
and
two
gets.
One
is
forget
all
in
one
get
by
ID
and
then
delete.
B
So
those
are
cruddy
interfaces
for
the
rest
and
there's
also
a
JSF
blind,
as
you
saw
so,
the
gesture
pliant
is
backed
by
a
an
named
beam.
So
there's
a
named
annotation
emits
happens
to
be
session.
Scoped
and
again,
it
just
reflects
for
the
most
part,
just
just
crowd
operations
get
all
coffees
at
a
coffee
and
remove
the
coffee.
Okay.
So
that's
what
it
in
terms
of
all
I
didn't
really
wanted
to
show
you
of
the
application.
In
fact,
we
can
shut
down
eclipse
altogether.
B
Now
we
don't
actually
be
in
Eclipse
to
do
any
of
the
rest
of
it.
We
can
just
get
away
with
the
command
line
for
the
most
part
for
the
rest
of
it,
not
okay.
So
now,
let's
talk
about
well,
that's
all
good
and
fine,
and
you
know
stuff:
we've
done
for
probably
a
good
20
years.
15
20
years
now,
I'm
just
building
a
war
file
and
deploying
it
with
an
application
server
using
an
IDE
in
this
case.
So
let's
take
a
little
beginner.
B
Take
a
look
at
how
do
things
look
like
when'd,
you
begin
to
introduce
in
docket,
so
the
first
thing
we're
gonna
do
is:
show
the
thin
war
approach
to
using
docker
in
Java,
EE
and
I'll.
Explain
in
a
second
what
what
I
mean
by
the
thin
war
approach
as
well.
But
first
let
me
show
you
how
the
thing
looks
like
in
action
and
then,
while
that
is
going
on,
I'll
show
you
some
other
mechanics
under
the
hood
and
how
all
of
this
is
taking
place.
B
So
again,
we're
just
going
to
use
the
running
database
that
we
have
here.
We
don't
kind
of
bother
starting
up
another
database
instance
there's
no
need
for
it.
What
we
are
going
to
do
is
essentially
actually
package
of
the
application.
So
if
you
noticed
basically,
the
application
consists
of
your
war
file,
the
Postgres
jar
file
that
we
talked
about
the
database
driver
and
the
server
built
our
excel
okay.
B
So
that's
really
all
you
need
in
order
to
pack
all
you
need
to
package
up
in
one
shape
or
form
or
the
other,
so
we're
going
to
just
go
ahead
and
package
that
up
in
docker.
Let
me
I
can
show
you
how
looks
like
in
action
and
then
after
that,
I'll
show
you.
What
is
how
the
codec
actually
looks
like
to
do
that
work
so
right
now,
I
meant
that
I
have
all
of
the
code
downloaded
onto
my
local
machine
I'm,
going
to
just
CD
into
the
thin
wall
directory.
So
let
me
do
that.
B
So
here
we
are,
and
first
thing,
I'm
going
to
do
is
actually
so
called
build
the
docker
image
right.
So
this
is
how
that
looks
like
and
again
I
need
to
type
in
a
pseudo
in
front,
so
docker
build
and
then
I'm
giving
it.
The
T
denotes
a
name
for
this
image
and
all
I'm
saying
is
that
whatever
is
in
the
current
directory,
go
ahead
and
build
a
docker
image
in
my
current
directory.
So
let's,
let's
give
this
a
shot
and
see
what
happens.
B
Okay,
so
you'll
notice,
first
thing
has
happened.
That's
happening
is
that
we
are
downloading
open
Liberty,
as
you
can
see
from
my
command
line.
So
that's
going
to
take
just
a
moment,
so
that
actually
constitutes
the
what's
called
the
first
layer
of
my
daughter
image.
So
we'll
give
it
just
a
second
here.
I
really
won't
take
that
long
to
happen,
and
then,
subsequent
to
that
there
will
be
the
other
steps
that
we
need
in
order
to
package
up
this
application
using
the
thin
water
pouch.
B
Step
what
we
did
was
we
got
the
Western
Liberty
base
image
from
docker
hub
now.
What
we
can
do,
just
with
what
we
just
did,
is
copy
over
three
files,
as
you
can
see,
so
here's
the
copy
of
the
Postgres
jar
and
that's
going
into
a
specific
directory
in
my
docker
image,
the
resources
directory,
I'm
copying
over
the
server
dot
XML
and
that's
going
into
the
config
directory
and
finally
I'm
adding
the
war
file
and
that's
going
into
the
drop-ins
directory
and
lo
and
behold,
essentially,
my
docker
image
is
now
built
right.
B
So
everything
that
I
would
need
in
order
to
get
this
application
up
and
running
is
packaged
up
into
a
docker
image.
Now
I
can
actually
run
the
doctor
animation.
Let
me
go
ahead
and
do
that
so
they're
gonna
go
in
here
and
simply
say:
docker
run
it.
So
this
is
again
the
command
that
you
would
use
to
actually
run
this
image.
So
let's
go
ahead
and
do
that
and
then
we'll
analyze
what
went
on
here
so
again,
it's
a
docker
run.
B
B
Alright
and
as
you
can
see,
basically
exactly
what
happened,
what
would
happen
if
we
an
ID
or,
if
you're,
doing
an
on-premise
deployment
without
docker
and
that's
exactly
what's
happening
so
websphere
liberty
is
starting
up.
It's
reading
the
the
servitor
XML
that
I
gave
it
it's
and
it
just
deployed
the
the
Java
EE
Cafe
application.
So
if
I
went
into
my
browser
now
and
try
to
access
it
again,
rather
this
is
9018
apologies.
B
So
let's
take
a
look
at
the
code
a
little
bit
and
try
to
figure
out
okay.
What
exactly
happened
here?
So
the
java
application
is
actually
the
java
application
is
actually
just
as
this.
So
all
I
really
did
here
is
behind
this
a
little
bit
before
my
talk.
What
I
did
was
I
built,
and
this
is
all
covered
in
the
instructions.
Basically,
what
I
did
was
I
built.
My
war
file
and
the
war
file
is
in
the
target
directory.
B
Here
it
is
Java,
cafe,
dot
war
and,
while
and
while
I'm
doing
this,
let's
do
this
I'll
tell
you
in
a
second.
Why
I'm
doing
this
so
I'm
copying
over
the
war
file?
This
is
the
thin-wall
directory
and
what
I
did
was
I
just
copied
over
the
pasted
over
the
the
war
file
here
and
I'm
gonna.
Do
it
again
and
I'll
show
you
in
a
moment
why
I
did
that
so
other
than
that
you
have
a
few
artifacts
that
you
need
in
order
for
to
build
the
docker
image.
B
One
is
the
server
dot
XML,
and
this
is
basically
identical
to
the
server
dot
XML
that
you
saw
before
the
only
difference
here
is
that
we
are
not
referencing
a
localhost
we're
referencing.
This
funky
little
IP
address
1
7,
2,
dot,
17
dot,
0
dot
2.
What
is
that
so?
Basically,
what
happens
is
docker
runs
its
own
runs
inside
its
own
network
and
all
of
the
docker
images
are
given.
B
Essentially,
a
DNS
assigned
IP,
so
the
very
first
image
that
starts
is
actually
1:
7,
2,
dot,
17
dot,
0
dot
2,
so
that
refers
to
this
running
instance
of
the
database.
So
that's
how
I'm
able
to
resolve
to
that
database-
and
this
is
a
bit
of
a
hack
you,
you
don't
need
to
do
this
for
simply
when
you're
doing
kubernetes
and
I'll
show
you
why
that
is
in
kubernetes.
You
can
actually
get
this
dynamically
assigned,
IP
referenced
for
you
or
you
can
simply
reference
in
DNS
name
as
opposed
to
referencing
it
by
IP.
B
So
that's
really
the
only
big
difference
here
in
terms
of
servitor
XML,
the
processed
jar
you
need
in
order
because
you
need
it
packaged
up
in
the
docker
file
and
the
the
big
piece
of
magic
really
is
the
docker
file.
So
this
is
the
guide
that
actually
says
what
is
what
is
in
the
docker
image,
so
this
corresponds
to
the
server
the
steps
that
we
saw
before
so
we're
taking
from
the
WebSphere
Liberty
base
image.
B
B
Image
and
I'll
show
you
that
in
a
second,
when
we
talk
about
the
other
techniques
of
how
you
package
up
with
docker,
but
in
this
case
we're
just
picking
the
job
ie8
image
the
default
image
for
for
West
Liberty,
as
you
can
see,
we're
copying
over
the
post
code,
jar
file
and
copying
with
server
dot,
XML
and
then
adding
the
Java,
EE,
Cafe
and
then
by
default.
That
is
all
that
you
need
to
do
when
they,
when
the
base
image
starts.
B
Each
of
these
lines
actually
consists
of
a
layer,
and
that
comes
in
extremely
handy
for
Java
EE
applications
because
essentially
Java
EE
application
server
is
the
way
they
are
intended
is
that
they
separate
they
separate
infrastructure
concerns
and
runtime
concerns
from
the
application
itself,
and
hence
you
have
the
application
server
itself
separated
from
things
like
the
configuration
separated
from
things
like
the
the
actual
war
file
deployment,
and
in
this
case
we
are
simply
deploying
a
very
thin
war
file
and
that
actually
works
in
our
favor.
I'll.
B
Show
you
why
right
now,
so
you
notice
what
happened
when
I
built
the
war
file
the
first
time
right
so
youyou
saw
that
we
went
through
all
of
the
steps
in
order
to
build
the
image.
Let's
try
to
rerun
the
rebuild
the
image
so
remember,
while
I'm
doing
this
I
did
do
something.
I
did
change
something,
namely
I
copied
over
the
war
file
one
more
time.
So
that's
the
same
for
a
second,
the
reason
I
did.
B
B
The
reason
is
read
what's
happening
here
in
each
of
the
in
each
of
the
steps
in
each
of
the
layers
so
step
104,
which
is
a
Western
Liberty
based
image,
it's
from
its
it's
already
cached
locally,
because
I
did
it
once
same
thing
for
the
copy
operation
for
the
Postgres
jar
file,
same
thing
for
the
server
dot,
XML
file
and
same
thing
for
for
everything
else,
except
for
my
last
change,
which
is
the
actual
deployment
of
the
war
file
so
well.
This
is
impressive!
Now,
it's
even
more
impressive!
B
When
you
have
kubernetes
in
the
picture,
because
what
happens?
Is
these
cat
and
the
the
way
this
caching,
your
learning
works,
is
actually
throughout
the
doctor
and
kubernetes
based
system.
So
what
this
means
is,
if
you
are
using
thin,
Wars
you're
able
to
do
everything
much
faster
you're
able
to
build
your
new
image
must
faster
you're
able
to
propagate
this
change
to
your
application,
much
faster.
You
don't
have
to
actually
upload
the
entire
docker
image.
All
that
actually
happens
is
only
the
change.
B
Change
part
is,
is
updated
all
the
way
up
to
your
docker
repository
and
all
the
way
down
to
your
kubernetes
deployment.
So
this
is
why
thin
water
approach
is
actually
very,
very
good
and
it
works
very
very
nicely
with
with
docker
and
kubernetes
based
departments,
because
of
the
way
that
it
works
very
naturally
with
the
docker,
layering
and
caching,
so
I
think.
That's
all
I
really
wanted
to
show
you
in
terms
of
the
thin
wire
approach.
B
The
value
of
this
approach
actually
becomes
more
obvious
when
you
take
a
look
at
some
of
the
alternatives.
So
let's
now
take
a
look
at
the
uber
jar
approach.
So
what
is
this
uber
jar
approach?
I?
Think
it's
best
to
show
you,
rather
than
rather
than
talk
too
much
I,
think
that's
a
much
easier
way
of
showing
you
exactly
what
is
going
on.
So
in
this
case,
what
I
have
is
there's
actually
a
copied
over
to
Java
EE
Cafe
application.
B
The
reason
is:
there's
several
changes
in
the
pom.xml,
the
way
that
the
pom.xml
was
built
and
I'll
show
you.
Why
that
why?
That
is
in
a
second,
the
other
thing
you'll
notice
is
in
this
case
the
dockerfile
is
actually
within
the
Maven
application.
This
is
actually
the
normal
way
he
would
do
docker,
usually
in
in
the
other
cases
I'm
just
trying
to
make
it
a
little
bit
more
simpler,
but
this
is
a
normal
way
of
how
you
would
have
your
project
structure.
B
Actually,
so
the
docker
file
is,
within
your
the
say
at
the
same
level
as
your
pom
dot
XML.
So,
let's
see
what
this
guy
does
right
and
what
is
different
about
it
from
a
docker
standpoint,
not
much
it
looks
virtually
identical,
but
what
happens
behaviorally
is
very
different,
so
we
will
see
why
that
is.
B
Alright,
so
that's
done
now:
I'm
gonna
do
an
install
now
notice
very
carefully.
What
happens
here?
There's
some
interesting
stuff
that
will
happen
when
I
when
I
do
the
maven
install
here.
So
what
I'm
actually
doing
is
I'm
building,
not
a
war
file
but
actually
a
fat
jar,
and
this
was
the
typical
way
you
do.
You
do
a
fetch
our
approach,
the
Fed
chair
approach
is
done
generally
through
maven.
B
So
that's
exactly
what's
happening
here,
so
it's
going
to
be
a
little
bit
different
and
then
what
would
happen
in
the
thin
water
brochure
or
pretty
much
any
other
approach
of
building
your
war
file
of
the
a
maven
so
fateful
plague,
Lake
was
a
close
efficient
I
will
give
you
a
running
commentary
of
what
happens
when
I
hit
install.
Hopefully
things
don't
blow
up.
B
So
first
thing
is
very
normal:
we're
just
building
the
war
file,
so
the
war
file
is
now
built
now,
what's
actually
happening
is
we're
installing
the
server,
so
what
is
actually
happening
is
we
are
going
out
and
pulling
with
certain
Liberty
from
a
public
repository
and
actually
expanding
it.
As
part
of
my
build
next
thing
is,
we
are
actually
copying
our
files
in
as
part
of
the
build,
so
this,
where
that's
that
went
a
little
bit
faster
than
I
was
expecting.
So
let
me
talk
through
what
happened
here,
so
here's.
B
What
happened
up
to
this
part
here
is
the
build
of
the
of
the
war
file
over
here.
What's
happening,
is
we're
actually
downloading
Liberty
itself?
Okay,
so
we're
getting
that
from
a
location.
I'll
show
you
that
in
the
comics
and
how
that
happens,
we're
copying
over
the
server
dot
XML
file
that
we
need
as
part
of
the
install
apps
command
or
phase.
Then
we
are
copying
over
the
Postgres
jar
file
show
you
were
downloading
it
from
maven
central,
in
this
case
the
pasta
jar
file
and
then
copying
it
over
into
a
into
a
certain
directory.
B
And
finally,
we
are
packaging
all
of
this
up.
Okay.
So
after
we
package
all
of
this
up
in
this,
this
actually
all
happens.
Let
me
show
you
what
the
final
output
is.
So,
let's
do
an
LS
and
you
notice
this
funny.
Little
Java
EE
cafe
dot
jar.
Okay,
this
job
ie,
cafe
door.
Jar
is
actually
a
self-contained
self-contained
jar
file.
That
includes
everything
that
you
need
in
order
to
run
this
application.
B
So
it
includes
all
of
the
all
of
our
configuration
files
it
in
this
is
a
war
file
and
it
includes
the
actual
runtime
in
this
case.
Websphere
liberty,
so
I'll
show
you
how
that
all
works
via
docker
actually,
but
before
I.
Do
that,
let
me
show
you
the.
Let
me
show
you
the
actual
palm
file
to
show
you
how
that
looks
like
and
how
we
actually
created
the
fat
jar.
It's
a
bit
involved.
B
So,
as
you
can
see
normal
Java
EE
jar
file
all
the
way
up
to
here.
Okay,
then,
the
interesting
stuff
begins
to
happen.
So
in
this
case
we
are
using
the
Liberty
maven
plug-in
to
do
all
of
our
work.
We
actually
create
our
our
fat
jar.
So
in
the
configuration
section
we
are
saying,
please
install
the
website,
Liberty
Java,
EE
8
version
and
download
it
as
a
zip
file.
We're
gonna
find
finally
package.
All
of
this
up
as
a
as
an
uber
jar
called
Rebecca,
feed
or
char.
It
happens
to
be
Honorable
in
the
executions.
B
You
say:
I
want
to
install
the
server,
and
the
most
interesting
thing
you
will
say
here
is:
where
is
my
circuit
XML
file?
Okay,
that
I'm
going
to
package
up
in
my
uber
char,
and
then
we
are
also,
as
I
mentioned,
using
the
maven
copy
target
to
actually
get
a
copy
of
the
Postgres
jar
file
and
put
it
in
a
directory
where
we're
going
to
package
it
up
in
in
the
fat
jar
itself?
Okay,
so
that
is
all
the
subsystem
that's
necessary
in
in
maven
to
actually
build
this.
B
So
one
thing
you
should
have
noticed
is
that
this
is
a
lot
slower
in
building
then
just
building
a
thin
bar
file,
obviously
because
there's
a
lot
more
going
on.
But
let's
see
how
this
looks
like
in
in
in
docker
roll.
So
let's
go
up
to
and
actually
do
the
same
thing
we're
going
to
build
a
docker
image
and
we'll
actually
run
the
application
as
well.
So
let's
do
that
alright!
So
here's
my
docker
image
build.
B
All
right
so
notice
what
is
happening
in
this
case
in
this
case
we're
actually
getting
from
open
JDK,
so
we're
not
installing
West
Liberty
at
all.
Our
base
image
in
this
case
is
open,
JDK,
and
then
we
are
next
time
next
step.
We're
doing
is
actually
copying
over
the
fat
jar
you'll
see
that
happening
in
a
second
yep
there.
It
is
there's
the
there's,
the
add
command
for
the
actual
fat
jar
and
then
we're
going
to
actually
run
the
fat.
B
B
B
All
right-
and
it
is
back
up
and
running-
let
me
just
prove
it
by
reloading
this
URL
and
there's
there's
a
there's,
my
application
up
and
running
once
again.
So
now,
let's
see
how
different
or
similar
the
docker
configuration
file
is,
and
what
precisely
are
the
trade-offs
for
for
this
approach.
So
here's
the
rocker
file,
so
you
saw
the
palm
file
already
and
you
saw
what
was
necessary
to
build
the
fat
jar
and
you
saw
that
the
maven
build
is
a
bit
slower
then
otherwise
it
didn't
it
would
otherwise.
B
So
this
is
the
docker
file,
so
in
this
case
again
we're
copying
over
not
from
Wizard
liberty
but
from
the
JDK.
This
would
be
typical
for
a
fare
jar
based
approach.
This
is
the
first
thing
you
would
do.
You
would
add
the
fat
jar.
In
this
case
we
are
adding
the
Java
EE
Cafe
tour
jar
that
we've
built
from
maven.
You
have
to
explicitly
expose
for
90-80
in
this
case,
because
that's
all
the
support
that
the
third
jar
will
be
talking
on
and
then
finally,
you
do
your
Java
dash
our
command.
B
B
Layers
here
are
relatively
flat
right,
so
all
I
can
cache
here.
Is
this
portion
so
each
time
I
need
to
make
a
change?
This
is
the
portion
that
will
get
executed
over
and
over
again,
so
we're
and
in
the
end
you're
you're
transferring
so
let
me
show
you
tell
us,
and
you
can
see
the
size
of
this
file,
it's
quite
a
sizable
file.
So
each
time
you
do
a
docker,
build
you're,
manipulating
this
much
larger
jar
file
and
to
make
matters
worse.
This
is
not
just
for
the
build.
B
You
know
when
you
go
to
do
a
deployment
when
you
go
to
upload
your
your
docker
file
into
your
into
your
docker
repost
docker
registry,
when
you
go
to
download
and
kubernetes
each
time,
you'll
be
transferring
a
much
larger
file
than
you
normally
would
for
a
thin
wire
based
approach.
In
my
opinion,
this
is
basically
an
anti-pattern.
This
is
what
you
you
should
not
be
doing
using
Java
EE.
B
This
is
probably
you're
working
against
the
facilities
that
you
have
in
Java
EE
in
terms
of
being
able
to
use
a
thin
wire
right,
so
you're,
basically
transferring
over
a
lot
of
us.
In
fact,
my
opinion
is,
this
approach
is
actually
more
useful
if
you
do
are
not
using
docker,
but
you
want
to
have
a
docker
like
experience,
because
everything
is
essentially
self-contained
and
all
you're
relying
on
is
the
fact
that
you
have
a
you,
have
a
JVM
and
that's
all
with
docker
I
think
this
entire
approach
is
less
compelling,
in
my
opinion.
B
So
finally,
let's
talk
about
the
holo
Boober
jar
approach
and
see
what
that
is
all
about.
Okay.
So
let's
let's
go
ahead
and
do
that
and
again,
the
easiest
thing
to
do
is
actually
to
show
you
yes
we're
just
talking
about
it.
So
can
I
go
and
take
a
look
at
the
holo.
Guitar
sorry
see
the
over
one
more.
B
B
So
basically,
you
need
less
setup
in
the
deployment
if
you're
not
using
docker,
it
takes
less
setup
steps
because
you
can
just
deploy
the
the
jar
file
and
not
worry
about
any
of
the
additional
setup
steps.
But
this
is
a
with
docker
you,
don't
you
don't
really
care,
because
at
the
end
of
the
day,
with
Walker,
you
are
deploying
a
docker
image
so
that
by
its
office
of
contained,
it
contains
all
of
the
steps
that
you
would
need
in
order
to
run
your
application.
B
So
it
basically
is
uber
jar
plus
plus
it's
a
it
does
what
the
birds
are
approach
dozen
more
so,
in
my
opinion,
there's
not
many
advantages
to
using
the
uber
jar
approach.
You
know
if
you're,
using
Java,
EE,
you're
kind
of
working
against
what
is
available
you're
working
against
what
docker
on
kubernetes
gives
you
in
terms
of
the
benefits
of
of
layering
and
caching.
B
However,
there's
something
to
be
said
about
the
center
uber
jar
stuff
and
that's
what
I'll
show
you
in
the
hollow
where
jar
and
that's
where
you
get
some
of
the
benefits
of
sort
of
this
approach
it
hired
for.
So
let's
take
a
look
at
the
palooka
jar
approach,
ins
and
maybe
that
will
help
answer
answer
the
question.
You
bet
that
so
here's
the
hollow
birch
our
approach,
I'm
going
to
again
I
pre
copied
over
the
war
file.
I,
don't
need
to
do
that
I'm
just
going
to
build
the
dog,
my
docker
image
now.
B
So,
let's
see
what
happens
here
in
victory.
Plecos
attention
and
I
will
also
obviously
give
you
some
running
commentary:
okay,
I'm,
sorry,
sudo,
Thank,
You,
forgeting
I'm
on
a
little
pardon
me
alright.
So
in
this
case,
what
is
happening
is
we
are
downloading
from
a
separate
Liberty
image
is
called
the
Liberty
kernel,
so
just
what
you
need
in
order
to
run
Liberty
and
beyond,
above
and
beyond.
A
B
2.3
as
being
installed-
and
that's
that's
the
installation
step
for
that-
that
is
going
on
right
now
and
then
jax-rs,
2.1
and
so
on.
So
this
will
take
a
little
bit
of
time.
So,
let's
see
utilize
this
time
and
show
you
how
the
code
looks
like
and
maybe
I'll
explain,
update
what
is
going
on
here
and
why
on
earth?
Would
you
want
to
do
this?
So,
first
of
all,
let's
take
a
look
at
this
River
dot
XML
file.
B
So
one
thing
that
should
strike
you
is
that
in
this
case
we
are
calling
out
explicitly
the
features
that
we
need.
So
we're
not
just
importing
Java
EE,
eight
anymore,
we're
explicitly
importing
the
specific
bits
and
pieces
that
we
need
for
this
application
and
then
the
the
thing
you'll
notice
is
that
this
is
pretty
small.
There's
not
a
whole
lot
of
other
configuration
going
on,
because
there's
nothing
to
configure
right
so
we're
starting
from
very,
very
simple
we're
starting
from
the
Liberty
kernel
and
then
we're
referencing.
B
Only
the
parts
then
that
we
need
of
out
of
open
Liberty.
So
there's
nothing,
there's
nothing
to
do
other
than
just
configure
your
data
source.
That's
it
if
you
look
at
the
docker
file,
you'll
see
how
there
is
that
this
was
enabled
right.
So
the
reason
this
is
enabled
is
that
again
we're
taking
from
the
Liberty
Liberty
kernel
and
then
each
of
those
features
that
I
referenced
I
actually
have
to
explicitly
install
to
say:
hey,
please,
you
know
install
that
particular
component.
B
Only
okay
and
then
the
rest
of
the
steps
are
very
similar
to
what
you
would
have
in
a
thin
wire.
So
we're
copying
over
the
database
driver
we're
copying
the
server
dot
XML
and
whenever
we're
copying
over
the
bar.
So
basically
this
is
sort
of
the
best
of
both
worlds.
So
one
of
the
arguments
for
uber
jars
is
that
hey?
Why
would
you
want
to
package
up
your
entire
application
server?
You
know
why
not
have
a
docker
image
that
is
much
smaller
and
only
contains
what
you
need.
B
How
much
smaller
is
frankly,
arguably
whether
it's
really
worth
the
few
megabytes
that
you
get
you
gain
by
doing
this,
but
in
the
in
the
end
you
get
a
smaller
dropper
image
by
just
installing
exactly
what
you
need.
So,
let's
see,
if
that
is,
this
is
actually
done.
Yeah,
it
happens
to
be
done.
Okay,
so
just
to
not
scare
you
too
much.
So
let
me
copy
over
the
war
file,
one
more
time
so
I'm
going
to
just
over
here
and.
B
Go
to
the
target
directory
and
copy
over
the
war
file
and
go
over
to
the
uber
char
and
sorry
know.
The
butcher
part
me,
the
Haulover
jar
and
copy
over
my
war
file,
one
more
time
so
I'm
pretending
that
I
made
a
change
to
the
application.
Let's
rerun
this
guy,
okay
notice,
what
happened
again,
docker,
layering
and
caching-
is
helping
us
out
in
this
case,
so
in
all
of
those
steps
that
you
need
to
create
a
a
custom,
Haulover
jar.
Well,
that's
all
cached
right!
B
The
trade-off,
of
course,
is
it's
a
bit
more
complex
all
right,
so
you
need
you
need
to
know
about.
All
of
these
components
that
you
need
explicitly
call
them
out
and
so
on,
even
if
you're
not
using
open,
Liberty
and
you're
using
some
other
similar
mechanism
for
doing
hollow
Bashar's.
The
trades
are
trade-offs.
Here
are
basically
the
same,
so
I
do
I'm
running
short,
a
bit
shorter
time,
so
I
had
just
about
ten
minutes.
I
won't
have
a
lot
of
time
to
show
you.
The
kubernetes
and
I
really
wanted
to
do
that.
B
So
I'm
gonna,
just
actually
just
breeze
through
the
demo.
The
equipment
is
demo.
Real,
quick
and
I
won't
have
a
lot
of
time
to
explain
what
I'm
doing.
Hopefully,
you
you
get
to
read
the
instructions
and
be
able
to
do
this
yourself
so
over
here.
What
I
have
a
short,
so
everything
that
I'm
I
have
everything
set
up
already
so
I
have
an
azure
kubernetes
cluster
set
up
blow
this
up
a
little
bit
more,
so
you
can
see
it.
There
is
my
little
kubernetes
cluster
Community
Service
and
I'm
just
deploy
via
kubernetes.
B
Just
so
you
see
you
can
see
how
all
of
this
stuff
works
when
it's
all
put
together,
so
I'm
gonna
go
ahead
and
create
the
database
in
kubernetes.
You
do
all
of
this
stuff
by
basically
a
set
of
llamó
files,
a
sort
of
kubernetes
scripts.
If
you
well
first
thing
I'm
gonna
do
is
I'm
going
to
create
my
database.
B
Okay,
so
my
database
is
created,
there's
several
steps
in
there
in
the
post
castrati
mo
file
that
it'll.
Allow
me
to
do
that
now.
What
I'm
gonna
do
is
I'm
gonna,
be
a
little
bit
clever
and
I'm
gonna
get
the
physical
IP
address
of
the
database.
That
is
running
on
the
cloud
and
I'm
gonna
say
that
into
a
configuration
what's
called
a
configuration
map
in
in
in
kubernetes
and
you'll,
see
again
all
of
these
steps
outlined
in
the
instructions
you
can
use
just
DNS
names
as
well.
B
In
fact,
I'm
going
to
probably
change
this
truck
to
use
DNS
names
as
opposed
to
doing
this
technique.
So
I'm
going
to
do
that
so
now,
I
have
a
config
map
created
with
my
IP
address
for
my
database
I've
already
built
my
daugher
war
files
in
there,
so
it's
already
sitting
in
there
somewhere
I'm
going
to
now,
okay
to
a
docker
bill.
B
Using
youth
in
water
approach
in
this
case,
so
that's
what's
going
on
I
just
built
that
and
I'm
gonna
push
this.
This
is
the
step
I
haven't
done
before
I'm,
going
to
force
this
docker
image
on
to
docker
hub,
because
that's
the
only
way
I'm
going
to
be
able
to
deploy
it
onto
a
sure
it
needs
to
be
somewhere
public.
It
can't
be
on
my
local
machine
so
I'm
going
to
publish
my
in
docker
image
that
I
just
built.
B
Because
what
happens
when
you
hurry
off
to
lunch
all
right
and
my
daugher
image
is
getting
pushed
as
you
can
see,
it's
using
docker
layering
here
as
well,
the
first
time
it's
it
can't
really
catch
anything.
So
it's
gonna
basically
do
all
of
the
upload
all
of
the
stuff.
If
you
look
at
my
docker
hub
account,
I
now
have.
B
My
Walker
hub
account,
okay,
so
in
my
docker
hub
account,
I
now
have
an
image
and
kochava
a
cafe.
Next
thing:
I'm
gonna
do
is
I'm
gonna
actually
deploy
this
to
kubernetes
cluster
to
my
to
my
cluster,
so
this
literally
creating
my
data
center
there's
two
instances
of
West
Liberty.
The
law
of
they're
running
you'll
have
to
take
my
word
for
it
for
just
for
now,
but
you'll
be
able
to
see
it.
B
If
you
look
at
the
actual
me
llamo
file,
so
I'm
creating
in
two
instances
the
West
Liberty
both
running
this
image
that
has
my
war
file
in
World
War,
five
built
into
it.
So
here
we
go
alright.
My
cluster
is
created
now
I'm
going
to
need
to
wait
just
a
little
bit.
So
while
the
cluster
creation
is
extremely
fast,
creating
a
load
balancer
in
front
of
it
is
slow
right
and
it's
not
just
low
inertia.
It's
it's
low
end
I've
tried
it
in
Google
and
Amazon.
B
It's
for
some
reason
doing
wiring
on
the
strap
in
the
wiring.
All
this
stuff
up
in
in
to
a
load.
Balancer
is
a
little
bit
time-consuming
for
some
reason.
So
we're
going
to
just
watch
and
wait
for
the
load
balancer,
what's
called
a
service
in
kubernetes
terms
to
come
up.
So
let's
do
that.
So
what
we're
watching
for
is
the
external
IP
fuels
it's
going
to
take
just
a
moment
for
the
external
IP
to
pop
up,
while
that
is
going
on.
B
Let
me
show
you
a
little
bit
of
the
code
if
I
can
so
in
this
case
the
doctor
file
is
going
to
be
very
similar
to
the
thin
water
approach.
Okay,
nothing
very
exciting
there.
The
Postgres
and
these
artifacts
are
basically
going
to
be
largely
basically
the
same,
except
for
one
difference
which
is
in
this
case.
We
are
using
environment
properties,
okay,
so,
for
example,
the
host
is
in
an
environment
variable,
so
we
populate
the
environment
variable
abilities
actually,
so
this
is
a
post
Crestor.
The
mo
file
is
very,
very
simple.
B
All
that
it
really
does
is
that
it
assigns
a
volume
which
is
some
space
in
the
file
system
on
the
cloud,
and
then
then
it
just
takes
the
Postgres
image
and
deploys
it,
and
that's
really
all
there
is
to
this,
and
then
we
attach
a
service
in
front
of
it
to
make
it
available
to
the
rest
of
the
cluster
and
in
this
case
we're
using
cluster
IP,
which
means
we're
just
literally
exposing
an
IP
in
internal
IP
address.
This
is
how
the
ml
file
for
the
actual
Western
Liberty
looks
like
it's
in
this
case.
B
What
we
are
actually
doing
is
that
we're
pulling
from
my
docker
hub
account.
Okay,
this
is
now
I
need
to
change
that
while
running
it
and
but
it's
falling
from
my
docker,
her
account
and
actually
creating
two
instances-
replicas
two
in
this
two
instances
over
so
everybody
running
on
my
cluster,
and
it
is
front,
ended
by
a
load,
balancer,
okay
and
the
load
balancer.
It
translates
from
port
80
to
port
90
80s.
B
Upon
behold,
in
this
case,
obviously
there
is
no
data
because
we're
running
on
the
cloud:
it's
not
the
same
instance
that
I
had
running
locally
and
just
to
show
you
I
took
this
out,
there's
virtually
no
darling
right,
there's
two
instances:
action
of
West
Liberty
actually
and
it's
a
round-robin
being
load
balanced
and,
in
fact,
in
this
case,
I'm
actually
using
a
shared
cluster,
so
that
that's
all
configured
in
here
as
well
I'll
show
you
real
real,
quick
in
the
server
dot
XML.
If
you
look
here.
B
Yeah,
you
see
I'm
using
something
called
HTTP
session
database,
which
means
the
session
cache
is
actually
in
the
database
itself.
So
you
can
use
clustering
unbalancing
if
I
had
a
bit
more
time,
I'll
show
you
I
would
have
show
you
the
how
to
upscale
and
downscale
these
images
and
in
increase
the
number
of
replicas
decrease
the
number
of
replicas
and
how
you
would
actually
monitor
and
manage
this
cluster
I'll
just
show
you
again
really
really
quickly.
So,
if
I
go
into
insights,.
B
B
I'm
running
out
of
time
so
need
to
move
on
so
yeah,
basically
take
a
look
at
this
you'll
be
able
to
see
how
this
differs
from
your
traditional
app
server
deployment.
It's
functionally
equivalent.
There's
just
that
kubernetes
takes
over
certain
elements.
The
observer
would
normally
would
so
things
like,
for
example,
management
of
nodes
removed,
distributed
deployment.
So
if
I
was
to
really
apply
this
application,
you
know
all
of
that
would
be
handled
through
kubernetes,
as
opposed
to
applications
from
a
native
facilities.
B
There's
some
management
and
monitoring
capabilities
that
are
built
into
the
kubernetes
ecosystem
and
console
and
so
on.
So
that's
a
bit
of
a
replacement,
so
some
bits
and
pieces
are
taken
over
by
kubernetes
and
some
bits
and
pieces
remain
with
the
app
server.
But
most
certainly
you
can
do
all
of
this,
and
do
it
relatively
elegantly
using
Java,
EE
and
docker.
So
that
is
all
the
time
that
I
have
for
today
and
I
do
under
try
to
my
time
slot
so
again
feel
free
to
take
a
look
at
my
money.
B
Docker
hub
image
feel
free
to
give
all
of
this
a
try
by
yourself
and
just
to
see
what
what
do
you
see
and
obviously
you're
more
than
welcome
to
help
me
finish,
the
Jenkins
and
Jenkins
CI
section
as
well
love
to
get
that
going
at
some
point.
Obviously,
that
is
going
to
be
make
us
way
above
the
timeline
and
really
make
this
a
workshop
as
opposed
to
just
a
talk.
Okay,
so
thank
you
very
much.
I
appreciate
it.
A
So
I've
been
monitoring
the
the
chat.
There
were
a
lot
of
conversations,
but
I
don't
think
there
are
any
specific
questions.
I
think
we
will
all
need
a
little
bit
of
time
to
absorb
everything
you
shared
with
us
and
try
it
ourselves
and
then
looking
forward
to
another
opportunity
to
have
your
rows
own.
The
jacquard
attack
talks
absolutely.