►
Description
Speaker: Reza Rahman
This slide free session will show you the many ways of deploying a Jakarta EE application to Azure. This includes IaaS, PaaS, Docker and Kubernetes. We will discuss the trade-offs of each approach on the way, offering guidelines for which approach might be best for your application on the cloud.
///GET SOCIAL!
Subscribe: https://www.youtube.com/user/EclipseFdn
Follow us on Twitter: https://twitter.com/JakartaEE
Follow the conference: https://twitter.com/JakartaOneConf
Like us on Facebook: https://www.facebook.com/JakartaEE/
Become a member of our Jakarta Tech Talks Meetup: https://www.meetup.com/jakartatechtal...
Join us on LinkedIn: https://www.linkedin.com/groups/13597...
Tag us: #JakartaEE #JakartaOneLivestream
A
Hello
in
this
session,
what
we
will
do
is
take
a
look
at
the
many
different
ways:
Java
EE
or
Jakarta.
Ee
applications
can
run
on
the
cloud
in
this
particular
case,
we'll
be
using
Azure
ever
obviously,
I
believe
is
particularly
well-suited
for
running
this
type
of
applications.
But,
quite
honestly,
you
could
use
any
major
cloud
to
do
similar
things
more
or
less,
but
obviously,
in
this
case,
we'll
be
focusing
on
Azure
feel
free
to
obviously
take
this
stock
and
adapt
it
adapted
it
in
a
different
way.
So
octave
is
not
to
do
a
lecture.
A
My
objective
is
to
actually
show
you
how
to
do
all
of
these
things
and,
in
fact,
instead
of
a
slide,
what
I
will
have
is
a
github
repository.
So
this
is
the
URL
of
the
github
repository.
It's
essentially
one
of
the
most
popular
repositories
on
my
own
personal
github.
Account
should
be
relatively
easy
to
find.
So
what
I
will
do
is
essentially
run.
Demos
end
to
end
slide
lists
for
the
entire
session.
There's
no
slides,
but
what
you
do
have
is
step
by
step.
A
Instructions
on
doing
everything
that
I
will
be
doing
today
in
the
next
hour
or
so
so
you
should
absolutely
feel
free
to
run
this
talk
by
yourself
or
and
explore
this
codebase
through
the
github
instructions
by
yourself.
In
fact,
these
instructions
are
actually
geared
towards
a
one-day
lab,
hands-on
lab,
so
we
won't
be
covering
all
of
the
material
here.
A
That's
not
really
possible,
then
in
our
timeframe,
but
what
I
definitely
will
do
is
show
you
just
enough
so
that
you
definitely
get
a
feel
for
what
is
going
on
with
Java
EE
on
the
cloud
in
Java
EE
on
Azure
in
particular,
and
give
you
enough
material
so
that
you
can
take
a
look
at
the
github
account
and
get
going
by
yourself.
So
the
first
place
we
should
start
is
on-premise
essentially
on
your
own
own
physical
machine
and
show
how
all
of
this
stuff
runs
on
on-premise
locally
on
your
left
off.
A
First
before
we
do
anything
on
the
cloud.
So
this
is
what
we'll
do.
Throwout
is
basically
use
a
simple
Java,
EE
cloud
application,
not
very
fancy,
but
it
does
use
quite
a
bit
of
Java
EE
slide
Shikata
e.
So
we
were
using
jax-rs,
cgb,
CDI,
JPA
Joseph
and
been
publishing.
Full
suite
of
things
should
be
definitely
enough
to
give
you
a
flavor
of
how
this
type
of
application
would
look
like
on
the
cloud.
A
What
we
will
do
here
is
spin
out
this
application
locally,
using
our
IDE
clips
in
this
case,
but
you
could
use
any
maven
capable
ID.
The
application
isn't
IDE
specific.
It's
just
a
maven
application.
In
fact,
you
could
probably
run
it
purely
on
the
command
line,
if
you
so
wish.
We
happen
to
be
using
WebSphere
Liberty
in
this
case,
or
rather
sorry
wildfly
in
this
case,
but
you
could
use
Webster,
Liberty,
payara
or
any
other
Java
EE
8,
slash,
Jakarta,
yet
compatible
runtime
will
be
using
Postgres.
But
again
you
can
use
any
basically
database.
A
That
would
work
with
JPI.
Alright,
so
I
do
have
all
my
setup
done
here.
I
will
cheat
a
little
bit
here
and
there
for
this
drug
just
to
save
a
bit
of
time.
So
I
do
have
JDK
installed
on
this
machine.
I
have
Eclipse
IDE
installed,
I've
installed.
Docker
will
be
using
docker
a
bit
more
extensively
a
bit
later,
but
it's
also
convenient
to
use
docker.
Even
for
this
on
premise,
sort
of
on
my
laptop
demonstration,
I'll
explain
why,
in
a
second
as
we
as
we
go
along,
I
do
have
this
code
installed
locally
on.
A
My
machine
I
will
need
that
to
move
forward.
So
this
is
basically
a
database
driven
application.
You
do
need
a
database.
You
I
could
have
instead
of
the
database,
in
this
case
Postgres
locally
on
my
own
machine,
but
in
fact
there's
no
real
reason
to
do
that.
I'll
be
using
docker
and
for
the
kubernetes
portion
of
this
of
this
demo
anyway.
So
I
just
want
to
use
docker
for
running
the
database.
That
way,
I
don't
really
have
to
install
anything
specific
on
my
machine.
A
It's
very
ephemeral,
I
just
started
in
it
we'll
go
and
download
Postgres
from
docker
hub,
run
it
and
as
soon
as
I
shut
down
the
docker
container.
I
don't
have
anything
else
installed
on
my
machine
other
than
docker
and
the
Postgres
instance
just
sort
of
goes
away.
So
let's
go
ahead
and
start
the
database
instance
via
docker.
Ok,
if
you
haven't
seen
dr.
before
I'll
talk
you
through
it
just
really
quickly.
So
here
we
go
I'm
copying
and
pasting
the
the
instructions.
A
You
know
that
I
have
from
my
gaiter
fact
account
again,
so
you
should
again
be
able
to
do
this
and
replicate
this
yourself,
so
basically
I'm
doing
a
docker
run
of
the
Postgres
image
that
exists
in
docker
hub
I'm,
giving
it
a
this
image,
a
name
and
I'm
also
doing
a
little
bit
of
file
system.
Mapping.
Don't
need
to
know
about
a
great
detail
of
that.
Quite
yet.
I
do
need
to
expose
the
board,
so
the
port
I'm,
exposing
the
other
B
parameter,
as
you
can
see
here,
is
a
5432.
A
This
is
because
essentially
every
single
docker
instance
is
sort
of
you
can
think
of
it
as
behind
its
own
firewall.
So
you
can't
really,
except
so
in
order
to
be
able
to
access
it
from
localhost,
meaning
my
own
machine
from
an
IDE
I
need
to
expose
that
board.
So
that's
what
I'm
doing
am
exposing
port
54
32.
So
let's
spin
this
up
and
see
what
happens
unable
to
find
the
image
locally.
I
am
on
a
relatively
fast
network.
So
what
is
going
to
happen
here
is
the
docker
will
determine
that
I!
A
Don't
have
this
I,
don't
have
Postgres
copy
locally,
so
I
need
to
go
and
download
Posterous,
which
is
it's
going
to
go
ahead
and
and
do
and
then
it's
going
to
just
start
up
post
crest
right
on
the
fly.
As
you
can
see,
this
is
started
right
up.
The
rate
equation
is
now
up
and
running
and
ready
to
accept
connections.
Okay,
so
now,
let's
go
over
to
the
IDE
in
the
IDE
here,
I
already
have
the
application
set
up.
It's
a
Java,
EE
Cafe
you'll
see
a
moment.
A
Why
that
is
there
a
lock-on
of
the
pom.xml?
It's
a
super
simple
application.
Really
it's
the
way
most
canonical,
Java
EE
are
victims
or
Jakarta.
Applications
should
look
like
really
just
one
dependency
on
the
Java
EE
api's
in
this
case
version
8,
which
I've
specified
up
here
and
that's
it
and
there's
really
nothing.
Much
more
to
this
application.
I
do
have
a
bit
of
setup
that
I've
done
I'll
go
over
that
in
a
second
after
I
run,
run
the
simple
demo
I'll.
A
Also
show
you
the
code
a
little
bit
as
well,
so
I
do
have
wildfly
17
up
and
running
I
do
have
it
registered
on
with
my
IDE
here
so
I'm
gonna
just
run
this
application
I've
done
a
little
bit
of
setup
beforehand,
namely
I've
set
up
the
data
source
for
this
application
to
connect
up
to
their
running
post
test
instance
that
I
have
alright.
So
let's
go
ahead
and
give
this
a
spin
I'm
going
to
right
click.
A
A
A
Okay,
so
there's
my
application,
it's
running
on
localhost
port
8080,
which
is
a
default
port
for
Wirefly,
as
you
can
see,
I
pre-populated
the
database
with
a
bit
of
data,
so
I
have
two
instances
of
coffees
here:
I
have
Reza
one
and
Reza.
I
won't
bore
you
by
showing
you
the
entire
data,
but
basically
what
you
can
do
here
is
create
a
new
coffee
instance
as
well
as
delete
the
coffee
instances.
So
there's
your
basic
crud
functionality
here
I'll
show
you
a
little
bit
about
the
application
itself,
not
too
much
just
so.
A
A
It's
a
jax-rs
based
rest
interface,
as
you
see,
published
under
path,
coffees
and
then
I'm,
injecting
any
repository
instance
in
here,
and
basically
it's
a
crowd
interface,
so
I
have
get
for
all
of
the
instances
of
coffee.
I
have
post
to
create
a
new
instance
of
the
coffee.
I
have
get
a
particular
instance
of
of
a
coffee
I
need
that
to
show
some
of
the
details
of
a
particular
coffee
and
then
I
have
a
functionality
to
delete
a
coffee
instance
behind
here
is
a
entity
object
that
I'm
referencing,
pretty
simple
entity
is
the
coffee
entity.
A
And
it
looks
like
things
are
just
a
bit
sluggish
at
the
moment.
What
we'll
do
here
is
simply
open
this
up
through
their
resource.
It's
a
bit
faster,
okay,
so
here's
the
coffee
entity,
it's
a
JPI
entity
and
we
have
a
generated
ID
and
really
just
two
data
points,
the
name
and
the
price,
and
that's
really
it,
as
you
saw
from
the
from
the
screen.
It's
off
there's
also
a
repository
behind
this.
A
Okay,
it's
a
simple
crowd:
crowd
repository
just
in
injecting
your
persistence
manager.
You
could
even
use
Delta
spike
data
to
do
further
abstract
this
repository.
If
you
wanted
to
I
didn't
bother,
this
is
just
a
stateless
session
bean
for
me
and
I'm,
injecting
an
entity
manager
and
doing
some
simple
operations
to
do
essentially
add
remove
of
entities
on
finding
the
Earth's
finding
the
coffee
beans
themselves.
There
is
a
gesture
back
into
this.
A
I
won't
bother
showing
you
that
the
GSR
back
in
what
it
is
doing
is
that
it
is
invoking
the
restaurant
interfaces
behind
the
scenes,
similar
to
what
you
would
perhaps
do
using
angular
or
view.
So
that
is
it
in
terms
of
what
I
want
to
show
you
of
the
application
itself.
So
let's
minimize
the
ID
but
I
do
want
to
show
you
a
little
bit
of
the
setup
that
I
have
done
behind
the
scenes.
So
this
was
the
application.
It's
a
maven
application,
nothing
special
about
that
under
the
server
directory.
A
Here
there
are
a
few
steps
that
I
have
taken
and
all
of
the
steps
are
actually
outlined
here,
so
you
can
replicate
them
yourself
in
your
local
environment.
But
basically
this
is
what
I've
done.
I
need
a
post
class,
your
father,
I've,
downloaded
and
installed
that
and
put
that
in
the
library
directory
for
Wirefly
locally
here
on
my
machine
on
the
post-crisis
jar
file
must
be
accompanied
by
a
module
dot
XML.
This
should
register
it
with
wildfly.
So
this
is
what
what
it
is.
A
It's
a
relatively
boilerplate,
nothing
much
more
going
on
really
here
and
I
do
have
a
custom,
standalone,
dot,
XML
file
and
really
the
only
big
change
that
I
have
done
here.
Is
that
I've
specified
the
database,
which
is
right
here,
as
you
can
see?
Okay,
so
you
have
given
under
jndi
name
and
give
it
a
given
it
of
name
or
the
pool
and
basically
I'm
connecting
up
to
localhost
for
5432,
and
that
is
working
because
I've
exposed
that
port
under
docker,
and
that's
really
yet
there's
nothing
much
else
going
on
here.
A
Alright,
so
that
is
it
in
terms
of
my
local
installation
of
this
application
and
running
you
and
showing
you
how
this
works
in
the
old-fashioned
way.
Now,
let's
go
and
take
all
of
the
stuff
and
run
it
on
the
clock.
So
the
first
there's
a
couple
of
many
different
ways
that
we
could
do
this
so
really
on
Azure
I'll
give
you
a
description
of
what
they
are
and
sort
of
what
I
will
cover
next,
so
the
the
simplest
way
to
do
this
is
just
use
virtual
machines.
A
So
this
is
very
similar
to
what
you
would
do,
perhaps
in
your
own
data
center,
except
that
you're
doing
it
on
a
jar
instead
you're
literally
creating
an
instance
of
an
operating
system
and
doing
whatever
you
need
to
do
in
order
to
get
the
environment
ready
for
this
application
and
then
deploy
the
application
and
run
it.
So
that
would
be
is
on
the
opposite.
Level
of
abstraction
is
pass
or
platform-as-a-service.
A
So
in
this
option,
what
would
happen
is
you
would
do
very
little
in
terms
of
environment
setup,
you
really
don't
care
about
things
like
operating
systems
and
so
on.
You
just
want
to
want
an
instance
of
wildfly
is
going
to
be
managed
for
you
by
the
environment,
and
we
do
have
such
a
often
available
on
Azure.
It's
a
essentially
app
service
learning,
Linux
wildfly.
A
It's
a
fully
managed
instance
of
wall
flight
that
you
don't
need
to
worry
about
the
kind
of
things
you
would
worry
about
for
docker
and
kubernetes,
or
is
everything
is
relatively
abstracted
for
you?
We
can
also
run
this
application
purely
using
docker,
so
I'll
show
you
in
a
moment
how
you
can
take
this
application
and
docker
eyes
it,
and
you
can
run
that
docker
image
using
Azure
or
container
instances
right.
So
this
is
something
a
lightweight
usage
of
docker
Ikey.
A
Well
on
the
cloud
and
of
course,
above
and
beyond
that,
you
can
go
a
whole
scale
with
containerization
and
use
kubernetes,
as
it
has
a
very
good
kubernetes
implementation
as
your
kubernetes
service.
So
you
can
take
full
advantage
of
everything.
Every
single
thing
in
the
container
ecosystem
and
deploy
this
application
using
docker
and
kubernetes
as
well,
so
I
won't
be
sure,
be
able
to
show
you
all
of
this
in
an
hour
time
span
what
I'm
going
to
aim
to
show.
A
You
is
perhaps
the
simplest
option,
which
is
containers
and
and
I
as
if
you're
new
to
the
cloud.
This
is
how
you
would
typically
probably
start
with
to
get
yourself
comfortable
close
to
how
things
would
be.
If
you
were
running
on
premise
and
I'll,
show
you
the
most
popular
option
and
the
most
popular
option.
These
days
really
is
kubernetes.
So
I'll
show
you
the
kubernetes
way
of
deploying
this
application
to
to
the
to
the
cloud
to
a
short
as
well
and
then
I'll.
A
Let
you
explore
the
other
two
options,
namely
the
azure
container
instances
or
just
plain
docker,
or
the
fully
abstracted,
fully
managed
manageable
fly
by
yourself
as
well.
The
idea
here
is
is
very,
very
similar,
so
once
you
especially
take
a
look
at
the
kubernetes
way
of
running
things,
those
two
ways
will
seem
more
or
less
pretty
natural,
and
not
really
all
that
all
that
mystifying.
So
let's
go
ahead
and
start
with
as
your
Linux
containers.
A
So
this
is
again
very
similar
to
what
you
would
be
doing
if
you
were
doing
this
sort
of
by
you
know
by
yourself
in
your
own
data
center
expert
in
the
data
center
in
this
case,
obviously
is
after
so
similar
to
how
we
started
that
database,
which
actually
we
don't
need
anymore,
so
I'm
going
to
just
shut
down
this
video
base.
I
just
hit
control
C.
Now
the
database
is
shut
down.
I,
don't
need
the
instances
of
a
database
anymore
and,
in
fact,
I'm
going
to
shut
down
wildfly
as
well.
A
Just
to
be
just
for
good
measure,
so
wildfly
is
also
now
shut
down.
So
just
like
I
had
a
database
instance
running
running
locally
I
need
a
database
instance
running
on
the
cloud
and
there's
many
different
ways.
You
could
do
that,
but
the
easiest
way
is
just
to
use
a
pass.
So
we
do
have
a
post
class
pass
option
on
a
sure
and
in
fact,
I
have
the
steps
outlined
here
on
how
you
would
go
over
creating
that
through
the
azure
portal.
A
This
is
not
really
that
fundamental
to
our
the
Java
EE
side
of
the
story,
so
I'm
gonna
skip
this
over
cheat
a
little
bit
just
for
the
sake
of
time.
So
I've
already
created
a
DBS
has
managed
version
of
of
post
curse
here,
so
it's
called
Java
EE,
cavity,
B,
slash,
Reza
I
go
in
here,
you'll,
see
that
it
is
deployed
on
to
Azure
already.
This
is
the
other
portal,
if
you
haven't
seen
it
before
is
deployed
in
the
central
us.
A
First
thing
we
need
to
do
in
order
to
get
this
running
on
the
cloud
using
virtual
machines
is
create
the
virtual
machine.
How
do
we
do
that?
Well,
that's
what
I'm
going
to
show
you
now
so
first
thing
is
to
go
into
the
azure
portal
and
create
a
virtual
machine
in
this
case
we're
going
to
be
using
Ubuntu,
it's
a
popular
Linux
distribution.
So
let's
go
ahead
and
and
go
ahead
and
create
that
and
I'll
be
flipping
back
and
forth
between
these
instructions
and
the
azure
portal.
A
You
can
do
all
of
this
by
the
way,
using
something
called
the
azure
CLI
or
other
mechanisms
as
well,
but
the
actual
portal
is
sort
of
a
beginner
friendly
way
of
doing
a
lot
of
these
things.
So
we're
going
to
go
to
the
azure
portal
and
we're
going
to
try
to
create
a
resource
and
what
we
are
going
to
do
is
you'll
see
several
categories
here.
A
The
category
that
we're
interested
in
in
this
case
is
compute
and
that's
more
or
less
a
Sunnah
name
for
is
or
infrastructure
as
a
service
and
there's
various
VMs
that
I
could
be
mm
ages.
That
I
could
use
here
that
I
could
start
with,
but
the
one
I'm
going
to
start
with
this
one
too.
Okay,
so
I'll
go
ahead,
and
here
one
here
on
the
portal
I'm
presented
with
several
options.
First
thing
you'll
need
to
do
is
choose
a
resource
group.
This
is
more
or
less.
A
You
can
think
this
is
a
logical
data
center
grouping,
so
I'm
going
to
I've
created
one
already.
It's
called
Java
EE
cafe
group
Reza
I'm
just
going
to
reuse
that
one.
So
that's
where,
for
example,
my
database
also
resides
this
is
just
a
way
of
thinking
about
this
entire
deployment.
A
bit
easier.
I
do
need
to
get
the
virtual
machine
a
name,
so
the
name
I'm
going
to
choose
here
is
going
to
be
Java.
A
Ee
cafe
server
Reza
I'll
choose
my
own
suffix
for
that
so
I'm
going
to
just
go
ahead
and
copy
and
paste
this
from
my
instruction
set.
I
need
to
give
a
name
here
on
Reza,
okay.
So
this
is
this
virtual
machine
is
called
Java
EE,
Cafe
Reza.
It
happens
to
be
running
Ubuntu
as
a
region
I'm
going
to
choose
central
us
so
the
same
one
as
where
I
have
my
my
post,
consent
and
instance
running
just
reduce
the
latency
a
little
bit.
A
I,
don't
think
I
need
to
change
so
I
do
need
to
specify
a
username
and
password.
You
can
use
SSH
to
access
this
machine
and
we
will
be
accessing
this
machine
in
just
a
moment
using
SSH
but
orbiting
it
a
little
bit
easier
ally
of
the
using
passwords
instead,
so
a
little
bit
old-fashioned,
but
still
works
just
fine,
so
I'm
going
to
specify
wildfly
as
the
username
to
access
this
virtual
machine
remotely.
A
So
here
we
go
I,
don't
give
it
a
suitable
password,
nothing
to
complicate
it,
just
something
to
get
by
just
for
the
demo,
so
I'm
going
to
just
enter
the
password
here
and
confirm
the
password
here
and
I
believe
that
is
really
all
I
need
to
do
it.
Out
of
you
know,
there's
a
few
other
steps
we
need
to.
We
need
to
do
as
well,
so
by
default
again,
this
virtual
machine
won't
be
accessible
to
the
outside
world,
but
we
do
want
this
to
be
accessible
from
the
outside
world.
A
One
is
we
need
to
go
ahead
and
do
some
setup
steps
on
to
this
machine,
and
we
also
want
this
applicant
to
be
available
on
the
internet,
so
I
actually
need
to
allow
this
virtual
machine
to
be
able
to
be
accessible
from
the
web.
So
I
need
to
open
up
a
certain
select
number
of
ports,
so
the
ports
that
are
going
to
open
up
our
HTTP
8,
a
port
80.
Ok,
this
is
where
we'll
be
accessing
like
web
application.
I
do
want
HTTP
access
and
I
do
want
SSH
access
as
well.
A
In
fact,
it's
SH
is
what
I'll
be
doing.
I'll
be
using
in
order
to
set
up
the
rest
of
my
application,
so
I'll
choose
SSH,
so
those
are
the
ports
that
I
need
open.
I,
don't
need
RDP,
just
because
I
won't
be
using
RTP
in
this
case,
I'll
simply
be
using
SSH
instead,
so
I
do
I
need
to
do
anything
else
here.
No
I,
don't
so
we're
basically
ready
to
go
and
we're
going
to
get
go
ahead
and
do
a
review
and
I
create
and
get
our
virtual
machine.
A
So
it's
running
the
evaluation.
It
says
a
validation
passed,
there's
no
issues
with
the
settings.
The
default
settings
that
I've
created
so
far,
so
I'm
going
to
go
ahead
and
create
this
image.
Now
this
was
pretty
remarkable.
This
is
this
never
ceases
to
amaze
me.
You
know
back
in
the
day
when
you
needed
to
do
this
on
your
own
machine.
You
need
to
rack
and
stack
a
machine
or
create
do
a
whole
bunch
of
probably
days
worth
of
work
before
you
can
get
a
machine
up
and
running.
A
This
will
just
happen
in
just
a
few
minutes
right.
It's
pretty
remarkable
what
is
going
on
here,
but
as
this
is
going
on,
it's
going
to
take
a
few
minutes
for
this
to
deploy,
as
this
is
going
on,
let's
take
a
look
at
a
little
bit
more
greater
detail
into
our
application
and
what
we
will
be
doing
next.
Okay.
So
this
is
what
we'll
be
doing
NASP.
A
So,
as
you
can
see,
there's
not
a
lot
going
on
that
is
different
will
be
more
or
less
taking
the
Java
EE
application
that
we
had
deployed
on-premise,
but
we
do
need
to
make
a
small
change,
and
that
is
that
our
standalone
dot
XML
will
be
a
little
bit
different
right.
Then
what
it
would
have
been
on-premise,
obviously,
because
localhost
doesn't
make
any
sense
here.
So
we
need
to
specify
where
our
a,
where
our
application,
where
our
database
is
actually
running,
and
so
that
is
the
difference
here
right.
A
So,
as
you
can
see,
I've
specified
that
that
the
postman
instance
in
this
case
is
running
on
Azure.
So
this
is
the
azure
URL,
where
I
have
my
manager,
instance
of
Postgres,
running
and
I
have
to
specify
a
particular
username
and
a
particular
password
right,
actually
you'll
be
able
to
find
all
of
this
information.
If
you
looked
in
my
resources
tab
and
looked
into
the
manage
database
instance,
it
will
tell
you
what
this
URL
should
look
like.
A
There's
a
specific
section
that
says
that
has
this
information
for
you
and
it
will
also
tell
you
what
your
username
and
password
should
be
in
order
to
be
able
to
connect
to
this
virtual
machine.
Ok,
so
next
we'll
be
going
through
several
steps
beyond
this,
so
we
will
be
basically
doing
the
installation
that
we
would
have
done
on-premise
if
you
are
starting
from
the
operating
system
layer
up
on
this
virtual
machine
once
this
virtual
machine
is
actually
allocated.
A
So
the
first
thing
I'm
going
to
do
is
I'm
going
to
SSH
into
this
box
using
an
SSH
client,
and
this
is
how
we'll
get
the
public
IP
address
in
a
second
we'll,
actually
be
able
to
cut
and
paste
that
so
our
dip,
my
deployment
is
complete,
so
let's
go
ahead
and
actually
do
the
steps
as
well
right,
so
we'll
go
ahead
and
connect
up
to
SSH.
So,
as
you
can
see,
it'll
tell
you.
Your
deployment
has
succeeded
so
now.
I
have
a
running
instance
of
a
virtual
machine
that
is
publicly
accessible
on
Asscher.
A
It
took
just
a
few
minutes
to
do
that.
The
next
thing
I'm
going
to
do
is
go
ahead
and
connect
up
to
this
to
this
instance,
so
you'll
notice
a
little
bit
of
a
there's,
a
prominently,
visible,
connect,
tab
here,
so
well
click
on
the
connect
tab
and
it
will
tell
me
how
I
can
access
it
via
association
right,
so
I'm
simply
going
to
copy
this
information
from
here.
A
A
Okay,
so
now
I'm,
actually
in
on
that
physical
machine
on
running
on
Azure
and
now
I
can
set
up
my
application.
I
can
get
everything
that
I
need
to
do
done
in
order
to
get
the
application
up
and
running.
So
the
first
thing
I
need
to
do
is:
do
a
sudo
apt
update,
because
I
want
to
install
JDK
8
and
by
default
the
window
image.
That
is,
there
will
not
have
that
definition.
Yet
so
I
simply
briefly
need
to
do
a
apt
update.
A
A
A
A
Okay,
so
now
I
have
Java
mr.
verify,
I
will
say
Java
version
and
there's
a
my
open,
JDK
version
running
I
happen
to
be
running.
Jdk
twitch
is
more
than
sufficient
for
this
application.
Next
thing,
I
need
to
do
is
install
maven.
Normally.
What
you
would
do
here
is
this
step
wouldn't
been
really
been
necessary
because
you
will
be
deploying
through
a
CI
CD
pipeline,
but
in
this
case
I
want
to
keep
it
pretty
simple,
stupid,
so
I'm
going
to
actually
build
the
application
locally
on
this
box.
A
A
A
All
right
and
wildfly
is
ready
to
go
so
now
we
need
to
do
a
bit
of
setup,
so
the
first
thing
we
need
to
do
now
is
actually
download
the
application
itself.
So
in
this
case,
I'll
be
downloading
the
source
code
onto
this
machine
and
building
it
there.
So
I'm
going
to
do
an
under
W
get
in
this
case,
I'm,
going
to
actually
download
this
source
code
repository.
A
A
A
Okay
and
there's
my
war
file,
it's
under
target
I
think
there's
no
need
to
really
show
show
you
that
I'm
going
to
go
back
to
the
home
directory
and
finish
the
rest
of
our
installation.
So
now
I'm
going
to
do
whatever
is
necessary
to
get
wildfly
ready
to
run
this
application.
The
first
thing
I
need
to
do
is
install
the
the
post
class
drivers
in
order
to
do
that.
A
I
need
to
create
a
directory
under
wildfly
to
install
the
module
so
I'm
going
to
do
that
next,
its
m'kay
dear,
and
under
what
line
modules
I
need
to
create
a
Postgres
subdirectory
so
creating
that
now,
alright,
that
is
done
next
I
need
to
copy
over
the
the
Postgres
drivers.
The
driver
jar
file
onto
that
directory
that
I
just
created
so
going
going
to
do
that
next
as
well.
A
A
A
And
what
is
going
to
happen
here
is
that
we
are
going
to
open
up
port
80,
so
that
is
the
other
bit
of
configuration
that
is
in
the
standalone
dot
XML
file.
You
know
instead
of
running
on
port
8080,
we're
running
on
port
80,
so
I
will
need
to
run
a
superuser
before
I
can
unable
to
do
that
so
I'm
going
to
go
ahead
and
quickly
su
as
in
to
the
super
user.
A
A
Excellent
so
now
my
application
is
running,
so
it
is
now
deployed
to
get
to
the
cloud
and,
as
you
can
see,
it's
not
terribly
different
from
what
you
would
normally
do
in
perhaps
your
own
pro
on-premise
installation.
It's
super
simple
to
do,
but
it
is
running
on
the
cloud,
the
application
that
is
now
my
java
application
is
running
on
Azure.
So
how
do
I
verify
that?
Well,
first
thing
I
need
to
do
is
find
out
the
public
IP
address,
of
where
this
virtual
machine
is
running
and
then
simply
access
my
application.
A
So
that's
what
I'm
going
to
do
and
how
do
I
do
that.
Well,
in
the
same
overview,
tab
you'll
see
a
public
IP
address.
This
is
the
public
public
IP
address
where
this
virtual
machine
is
available.
If
you
wanted
to,
you
could
front
end
this
with
a
load
balancer
or
even
specify
your
own,
your
own
public
IP,
your
own
public
dns
to
this
as
well,
but
regardless,
let's
copy
this
over
and
then
open
up
a
browser
and
hit
enter
here.
So
here
I
have
wildfly
running.
A
A
A
Let's
skip
this
over
and
now
move
into
the
kubernetes
portion
and
show
you
what
the
different
shield
is
between
running
it
in
the
is
way
which
is
sort
of
again
the
the
bargain-basement
easy
way
to
get
into
the
cloud
versus
some
more
most
popular,
probably
perhaps
the
most
popular
way
that
we
know
of
these
days,
which
is
using
container
and
kubernetes
and
show
you
how
that
really
looks
like
in
terms
of
the
difference.
Okay,
very
good,
so
I'm,
going
to
now
exit
out
of
this
machine,
I
don't
need
it
anymore.
A
Some
walked
out
of
the
virtual
machine
back
into
my
back
into
my
regular
environment
here:
okay
and
then
we'll
sort
of
effectively
starting
from
scratch
and
doing
the
same
things
over.
But
this
time
using
using
kubernetes
so
again,
I'm
skipping
over
the
pair's
option
definitely
feel
free
to
take
a
look
at
that.
A
Sorry,
as
your
container
instances
feel
free
to
take
a
look
at
that,
I
have
instructions
for
that
as
well,
but
right
now
we're
going
to
move
over
our
tour
on
to
kubernetes
and
showing
you
how
all
of
the
stuff
works
relatively
well
with
aks
and
kubernetes.
So
you
do
need
a
little
bit
of
setup
to
go
here
as
well.
Ling
and
I've
set
up
I've
specified
everything
step
by
step
here.
So
you
can
replicate
these
steps
yourself.
If
you
so
wish.
A
Yeah
again,
you'll
need
a
managed
for
stressed
instance,
again,
I've
already
done
this,
it's
already
there.
So
if
you
look
into
my
resource
groups
and
jump
into
the
resource
group
that
I
have
set
up
here,
there
is
effectively
my
my
database
instance
sitting
sitting
right
there
by
the
way.
If
you
scroll
a
bit
down
now,
you'll
be
able
to
see
our
our
virtual
machine
that
we
have
created
earlier.
So
there
is
my
virtual
machine,
Java
EE,
Cafe
server,
either
way
the
database
is
up
and
running
for
us.
A
Here's
the
fancy
instructions
to
do
that
and
in
fact
it's
just
one
line.
If
you
were
using
the
the
edge
or
CLI
it's
one
line
to
create
a
kubernetes
cluster,
it
does
take
a
little
bit
of
time,
though
it
should
take
about
between
five
and
ten
minutes,
which
we
can
I
think
better
utilize,
showing
you
something
else
or
explaining
something
else
to
you.
So
here's
my
kubernetes
cluster,
as
you
can
see,
there's
a
kubernetes
version.
It's
running
them
in
central
us.
It
does
have
an
API
server
address.
A
It
is
publicly
essentially
publicly
accessible
I
I
do
have
a
couple
of
note
pools
right,
so
I
have
three
instance:
three
nodes
running
here
whereby
I
can
create
pods
and
there's
some
other
interesting
information
here
as
we'll
see
in
a
second.
In
fact,
I'll
show
you
right
now.
If
you
click
on
the
insights,
tab
you'll
see
a
little
bit
more
information
about
what
is
going
on
with
this
kubernetes
cluster.
We'll
revisit
this
in
a
second.
A
A
Okay,
so
if
you
haven't
seen
this
before
cube
control,
you
can
think
of
it
as
basically
the
command
line
for
kubernetes,
so
all
of
the
interactions
with
kubernetes
will
take
place
using
this
command
line
tool.
It's
almost
as
though
you're
running
kubernetes
locally,
but
what
is
really
happening
is
that
all
of
the
issues
all
of
the
commands
that
you're
issuing
like
the
kubernetes
get
nodes
command
that
I
just
issued.
A
This
is
running
against
the
azure
kubernetes
instance
running
on
the
cloud
and
it's
getting
the
information
from
there
and
will
be
interacting
through
cube
control
there
as
well.
So
there's
a
little
bit
of
a
steps
here
to
get
you
keep
control
connected
up
to
your
cloud.
I've
outlined
what
these
steps
are:
they're,
really
not
that
difficult.
So
you
just
need
to
control
install
you
need
the
azure
CLI
installed
and
you
need
a
single
single
command
that
says:
hey!
A
Please,
go
and
connect
my
my
azure
kubernetes
instance
with
cube
control
using
this
one,
IKS
get
credentials
command.
If
you
haven't
seen
this
before
the
AZ
stands
for
basically
the
azure
ad
hoc
command
line
interface.
Okay,
the
other
thing
I
will
need,
is
docker
a
docker
hub
account.
So
in
order
for
this
application
to
land
on
kubernetes,
it
first
needs
to
be
in
a
repository
somewhere.
So
in
you
could
use
the
azure
container
registry
and
the
big
benefit
of
using,
that
is
that
it
is
private.
A
Nobody
else's
taken
is
able
to
see
what
images
that
you're,
using
with
docker
and
kubernetes,
but
in
this
case
I,
don't
really
need
that
per
se,
so
I'm,
just
using
docker
hub
so
I'll
be
publishing
my
my
docker
image
onto
docker
hub
and
you'll
be
able
to
see
it
there.
So
at
the
moment,
as
you
can
see,
this
is
my
daughter
hub
account.
There's
really
nothing
there,
no
repositories
whatsoever,
but
there
will
be
something
there
in
a
moment
as
we
as
we
go,
but
bottom
line
is
I'm
using
a
docker
hub
instance.
A
If
you
wanted
to,
you
could
use
the
Azure
container
registry
as
well.
So
the
first
step
for
me
here
is
to
build
the
application,
and
there
are
some
subtle
differences
between
this
application,
the
one
that
I
was
using
before,
but
I
don't
need
to
go
through.
All
of
this
I've
basically
cheated
here
and
I've,
created
a
war
version,
a
war
file
already
and
copied
it
over
and
I'll
show
you
where
that
is
so.
This
is
under
github.
A
This
is
my
local
machine
and
if
you
go
into
the
kubernetes
directory,
I
already
have
a
war
file
sitting
there.
Just
just
waiting
for
me.
I've
just
P
build
this
war
file
to
save
time-
and
this
is
the
war
file
I'll,
be
packaging
up
and
packaging
up
using
docker
and
then
deploying
onto
kubernetes
and
applying
onto
ash
or
using
communities.
As
you
can
see,
it's
tiny,
it's
a
14,
kilobyte
thin
war
file,
very,
very,
very,
very
typical
of
how
it
would
look
like
using
a
Java,
EE
or
Jakarta
EE
application.
A
So
all
of
that
stuff
is
essentially
done.
So
I've
set
up
the
standalone
dot
XML
file
here
as
well.
We
will
need
a
specific
one.
A
specific
standalone
dot.
Xml
file.
Well,
show
you
all
of
those
steps
in
a
second,
but
this
there's
some
artifacts
that
you
will
need
in
order
to
be
able
to
create
your
docker
image
now.
So
basically,
everything
that
you
need
to
run
the
application
needs
to
effectively
be
in
the
in
the
docker
image
in
one
way
or
the
other.
So
bottom
line
is
I.
A
A
A
And
yes,
I've
logged
in
now,
so
I
can
now
begin
uploading,
my
building
my
docker
image
and
then
uploading
it
up
to
docker
hub.
So
that's
what
we're
going
to
do
next.
So
the
next
step
is
to
build
the
docker
image
and
I'll.
Show
you
what
what's
going
on
in
in
a
second
when,
after
we
do
this
so
I'm
going
to
copy
and
paste
this
command
and
I'll
describe
to
you
what
this
command
is.
A
If
you
haven't
seen
so
docker
before
so
I'm
doing
I'm
building
my
docker
image,
I'm,
going
to
give
it
a
name,
Java
EE
Cafe
and
give
it
a
version
which
is
version
one,
and
essentially
what
I'm
saying
here.
The
dot
stands
for.
Look
in
the
correct
directory,
the
in
the
current
directory.
There
will
be
a
file
called
docker
file.
The
docker
file
that
describes
how
this
docker
image
should
look
like,
but
I'm
also
going
to
give
it
a
name
here,
because,
ultimately,
my
goal
is
to
publish
this
image
out
onto
my
docker
hub.
A
So
my
doctor
image
is
now
built
as
as
you'll
see
when
I
want
to
show
you
the
dockerfile
in
a
second.
Basically,
what
is
happening
here
is
very
similar
to
what
what
would
happen
if
I
were
to
doing
this
in
the
in
the
VM
style,
except
that
it's
it's
a
lot
shorter
and
much
more
repeatable
and
you
need
to
do
much
less
striping
because
effectively
and
everything
is
set
up
in
docker
and
communities
for
you,
so
I'm
going
down
loading
wildfly
at
the
moment,
but
it's
not
just
wild
fly.
A
A
A
Then
I
am
basically
going
through
the
same
steps
that
I
would
I
basically
did
when
I
was
doing
the
VM
instances
so
I'm
creating
a
directory
for
to
install
the
to
install
the
the
post
press
jar
file
I'm
installing
the
hostess
jar
file
copying
would
in
the
module
file
copying
over
the
standalone,
dot,
XML
file
and
then
finally
copying
over
the
war
file.
So
this
is
effectively
describing
how
my
docker
image
should
look
like.
A
A
So
the
next
step
for
me
is
to
actually
publish
so
there's
a
few
more
artifacts
is
a
docker
file,
as
you
saw
there
is
a
Java
EE
cafe,
dot
e
mo
file
that
I'll
describe
in
a
second.
This
has
to
do
with
kubernetes
and
the
module
dot
XML
file
you
already
familiar
with
this-
is
your
file,
and
this
is
the
standalone
dot
XML
file
that
is
describing
the
wildfly
configuration.
So
next
I'm
going
to
push
the
stalker
image
on
to
docker
hub.
A
All
right,
so
it
is
in
a
moment
here.
You
will
see
that
this
image
will
show
up
and
my
doctor
have
a
comp.
So
let
the
Porsche
finish
and
the
Porsche
is
finished
in
fact.
So
let
me
refresh
my
refresh
my
upholstery
now
and,
as
you
can
see,
this
docker
image
is
now
published
on
on
to
my
docker
hub
account,
and
it
is
ready
to
go
ready
to
be
used
by
any
cooper-
instance.
A
Let
me
go
ahead
and
issue
this
cube
control
command
and
what
we
are
doing
is
creating
the
actual
actual
docker
image
instances
on
all
kubernetes.
So
let's
do
that
and
now
it
has
actually
created
next
thing.
I
need
to
do
is
monitor
so
I'll
show
you
the
contents
of
the
Java
EE
cafe
Katayama
file
in
a
second,
but
in
the
meanwhile.
What
I
need
to
do
is
see
if,
when
the
service,
in
particular
the
load
balancer
that
is
serving
that
this
application
is
going
to
be
ready.
So
it's
not
going
to
be
ready
instantaneously.
A
It
is
going
to
take
a
little
bit
of
time
as
you'll
see
in
a
second
so
I'm
going
to
just
copy
this
paste
command
and
I'll,
explain
to
you
what
this
command
is
doing
and
then
we
will
go
back
and
actually
take
a
look
at
the
kubernetes
llamó
file
and
see
what
exactly
went
on
there.
So
what
I'm
doing
here
is
doing
getting
a
service
by
a
name
and
you'll,
see
where
this
Java
EE
cafe
service
is
defined
in
a
moment
and
I'm
watching
for
when
this
comes
on
line.
A
Okay,
so,
as
you
can
see
on
this
line
of
home
values,
there
is
an
X
external
IP
column.
There
is
not
quite
populated,
yet
it
just
say
it
says
it
is
spending.
So
that
is
what
we
need
to
wait
for
for
a
few
moments.
It's
just
going
to
take
a
few
minutes
for
this
external
IP
to
get
propagated,
and
while
this
is
happening,
let
me
show
you
the
kubernetes
portion
of
this
application
and
what
the
what
the
settings
for
that
really
looks
like.
A
So
this
is
a
kubernetes
llamó
file
and
you
can
obviously
take
a
look
at
that
yourself
later
on
after
the
stock
is
over,
and
basically
this
is
describing
how
your
data
center
should
effectively
look
like
on
the
cloud.
How
does
your
co-parent
is?
Cluster?
Look
like
in
so
the
gist
of
this
is
that
we
are
taking
a
container
image
that
happens
to
be
running
my
container
image
here
and
creating
two
copies
of
it,
two
replicas
of
it.
A
So
there
will
be
two
instances
of
machines
running
that
docker
image
with
websphere
liberty,
with
a
wild
fly
and
all
of
my
wall
flight
configuration
as
well
as
my
war
file
running
there,
and
there
will
be
two
V
ends
that
are
spun
up
by
my
kubernetes.
So
how
do
you
actually
load
balance
between
those
two?
Well,
that
is
also
a
kubernetes
service,
and
that
is
the
service.
In
fact,
we
are
waiting
for
so
the
name
of
the
service
is
Java
EE
cafe,
as
you
can
see,
and
it
is
a
type
of
load
balancer.
A
So
it
is
actually
going
to
load
balance
across
these
two
instance,
instances
of
wildfly
that
that
kubernetes
is
going
to
create
for
us
and
what
we
are
also
doing
is
doing
a
bit
of
port
mapping,
so
we're
porting
we're
mapping
port
82
port
8080.
So
these
two
instances
of
well
fly
I
haven't
changed
their
setting
on
it.
A
If
you
look
at
the
standalone
door,
XML
file
they're
running
on
port
8080,
so
in
order
to
be
able
to
access
it
from
the
web,
I
need
to
specify
that
I
want
to
map
it
from
port
80
to
port
8080.
So
that
is
the
word
that
the
load
balancer
is
going
to
do
for
us
in
a
moment,
and
you
will
see
that
in
action,
so
we
do
have
an
external
IP
now
so
I'm
going
to
ctrl
C
after
this,
so
I'm
going
to
just
copy
over
this.
This
public
IP
address.
A
A
A
Okay,
so
we
have
two
instances
of
the
coffees
running
here:
I'm
going
to
just
show
you
how
it
looks
like
in
the
rest,
interface,
okay,
so
there
we
have
it.
That
is
the
restaurant
face
behind
the
scenes.
That
is,
that
is
running
this,
so
to
go
back
to
the
instructions.
This
is
basically
the
end
of
the
instructions
for
kubernetes.
We
basically
have
your
application
up
and
running
now.
What
you
can
experiment
with
is
communities
can
also
auto
scale
these
instances
for
you.
A
So
let's
say
you
wanted
three
copies
of
one
fly
running
instead
of
two,
so
you
can
easily
do
that
by
simply
using
the
scale
command
in
incorporate
is
to
do
that
now.
Some
of
the
other
nice
things
about
kubernetes
is
a
lot
of
in
in
many
of
these
cases.
So
first
thing
you
should
note-
is
that
how
simple
this
was
right.
A
A
The
deployment
rolling
deployments
can
are
also
handled
by
kubernetes,
as
opposed
to
handled
by
the
application.
Server
and
basic
monitoring
is
also
handled
by
kubernetes.
So
if
you
won't
go
into
the
azure
monitor
in
this
case
after
insights
monitor,
you
will
see
that,
as
your
insights
monitor,
will
actually
show
you
information
about
CP
utilization
for
each
node
memory,
utilization
for
each
node
access,
some
access,
active
activity,
counts
and
so
on
and
so
forth.
So
a
lot
of
the
information
that
you
would
have
seen
from
your
application.
A
Server
console
is
now
available
inside
of
the
kubernetes
environment
instead,
and
you
can
take
a
look
at
a
very
in-depth
information
about
about
all
kinds
of
things
that
are
that
are
going
on
in
the
container
and
kubernetes
environment.
So,
basically,
what
happens
here
is
that
a
lot
of
the
your
your
information
that
you
would
have
done
into
in
I,
as
is
all
automated?
It's
basically
all
repeatable.
You
can
run
the
same
docker
file
locally
if
you
saw,
if
you
so
wanted,
and
you
can
take
the
same
docker
file
and
run
it
on
kubernetes.
A
All
of
those
would
be
when
we
managed
for
you,
and
a
lot
of
the
things
that
you
would
have
done
manually
is
basically
handled
by
the
kubernetes
environment
itself,
so
that
is
the
big
differential
between
kubernetes
and
why
it's
somewhat
justifiably,
pretty
popular
so
I
hope
you
got
a
flavor
for
how
easy
it
is
to
run
a
Java,
EE
or
Jakarta
ii
application
on
the
cloud.
There's
many
different
ways
of
doing
this.
There's
really
nothing
holding
you
back
whatsoever.
A
I
just
showed
you
two
different
options
of
just
on
Azure
and
there's
many
other
options
on
Azure
as
well,
and
all
of
these
are
mostly
covalent
right.
If
you
look
at
other
clauses,
they
will
also
have
similar
features
more
or
less
so,
really
all
the
power
to
you
if
you're
a
Java,
EE
and
Jakarta
EE
user.
The
cloud
is:
is
your
domain?
You
should
be
perfectly
comfortable
and
have
many
different,
powerful
choices
on
the
cloud
here.