►
Description
In this presentation you'll learn how to quickly and easily build and deploy your Java application on the cloud using Eclipse JKube.
The presentation will show how standard Java applications using a variety of Frameworks can be easily deployed into Kubernetes and OpenShift clusters with very little configuration and a very smooth and seamless user experience.
We will also show how to make a plain old webapp ready to be deployed in the cloud and how can the development process and experience be greatly improved by using Eclipse JKube's developer features.
A beginner level of Java and Maven is recommended.
Speaker(s):
Marc Nuri (Red Hat, Inc.)
A
A
A
So,
let's
start
talking
about
cloud
native.
If
we
check
the
cloud
native
computing
foundation
definition,
we
see
that
cloud
native
technologies
empower
organizations
to
build
and
run
scalable
applications
in
modern
dynamic
environments
such
as
public,
private
and
hybrid
clouds,
containers
service
measures,
microservices
immutable
infrastructure
and
declarative
apis
exemplify
this
approach.
A
So
this
really
is
a
very
broad
definition
and
probably
for
us
java
developers.
What
makes
more
sense
is
that
the
cloud
native
brings
it's
basically
a
change
of
the
paradigm,
so
we
were
used
to
a
different
architecture.
Our
applications
were
based
on
a
monolithic
architecture
and
now
that
everything
is
cloud
native,
we
have
switched
into
a
micro
service
architecture,
a
distributed
computer
architecture
which
brings
a
set
of
new
challenges.
A
But
it's
not
only
that
it's
we've
changed
the
the
workflow
for
for
our
development
process.
So
right
now,
our
applications
are
probably
intended
to
be
run
in
a
cluster
which
can
be
kubernetes,
openshift
or
maybe
another
flavor
of
kubernetes,
which
means
that
our
applications
need
to
be
shipped
in
a
in
a
different
way.
A
So
now
we
need
to
ship
the
applications
as
containers
as
docker
images
or
container
images,
and
this
means
that
we
need
to
create
docker
files
and
create
these
docker
images,
but
not
only
this
so
now
in
order
to
be
able
to
deploy
the
application
we
create.
We
need
to
create
these
cluster
configuration
files
and
manifest,
so
we
need
to
actually
master
what
kind
of
resources
the
cluster
is
offering
us.
So
we
need
to
know
about
deployments,
replica
sets
spots,
services,
ingresses
configuration
maps,
etc.
A
So
it's
a
huge
set
of
new
concepts
that
we
not
now
need
to
know,
understand
and
master,
and
this
was
probably
something
that
we
didn't
have
to
do
before.
So
here
is
where,
where
j
cube
comes
in
handy
because
it
actually
tries
to
abstract
and
abstract
away
and
the
implement
the
implications
and
the
implementation
details
of
all
of
these
kind
of
configurations
and
all
of
these
additional
tasks
that
we
are
needing
to
deal
with.
A
So
what's
eclipse
youtube
eclipse
youtube
is
a
set
of
tools
and
plugins
that
will
actually
help
you
generate
these
container
images
and
then
generate
these
configuration
manifest
and
actually
apply
them
into
into
the
cluster.
So
jcube
comes
in
in
as
of
now
in
three
flavors,
let's
say
so.
We
have
this
standalone
java
api.
A
So,
regarding
build
strategies,
as
of
now,
we
support
the
docker
build
strategy,
so
in
the
case
of
the
kubernetes
maven
plugin,
this
will
require
to
have
a
local
demon,
a
local
docker
demon
running
in
your
system
or
in
case
of
openshift.
This
will
perform
a
docker
build,
but
in
your
cluster
also
for
openshift,
we
are
offering
a
source
to
image
binary,
build
strategy.
In
this
case
the
build
will
be
running
on
your
cluster
and
finally,
we
offer
a
build
strategy.
In
this
case,
the
build
is
delegated
to
jeep.
A
So
you
actually
don't
need
to
have
a
docker
demo
running
in
your
in
your
computer
and
then
youtube
is
based
on
a
set
of
very
strong
opinionated
defaults.
So
we
are
actually
offering
configuration
defaults
for
many
different
frameworks
and
technologies,
but
this
should
be.
This
really
should
be
enough
for
many
of
your
application,
but
probably
it's
not
for
some.
A
So
then
we
have
this
xml
plugin
configuration,
so
we
you
can
actually
override
these
defaults
in
your
maven
plugin
configuration
or
then
we
also
offer
this
resource
fragments
fragments,
which
is
all
also
a
very,
very
easy
way
in
order
to
improve
the
the
cluster
configuration
manifest
that
we
provide.
So
you
can
provide
parts
of
this
configuration
some
small
fragments
that
then
will
be
merged
into
the
actual
fragments
that
were
generated
by
by
gay
cube
with
its
open,
united
defaults.
A
But
coming
back
to
that
initial
slide,
where
we're
talking
about
the
the
new
difficulties
that
come
with
this
new
developer
workflow,
what
j-cube
also
tries
to
aim
is
to
simplify
this
this
workload
for
workflow
for
you.
So
if
in
case
of
you
are
using
a
maven
plug
and
even
project,
you
basically
usually
had
to
package
your
application,
and
you
were
left
with
this
jar
or
wire
package,
but
then
you
are
faced
with
the
challenge
of
actually
putting
this
wire
or
this
application
in
in
your
cloud
and-
and
here
is
when
jq
comes
really
handy.
A
So
the
first
goal
that
we
provide
is
the
build
goal.
This
build
goal
is
in
charge
of
generating
your
probably
your
docker
file
and
then
building
your
container
image.
This
container
image
can
then
be
pushed
into
a
public
or
private
registry.
In
order
for
your
cluster
to
be
able
to
to
pull
your
image,
and
then
we
offer
this
resource
goal,
the
resource
goal
is
actually
in
charge
of
generating.
A
This
configuration
manifests
once
we
have
these
jumble
files,
it's
as
simple
as
invoking
the
maven
khs
apply
goal,
and
this
manifest
will
be
applied
into
your
cluster
again
without
any
kind
of
specific
configuration
from
your
site,
so
everything
should
be
actually
infer,
the
cluster
configuration
the
etc,
and
then
we
offer
a
set
of
specific
goals
for
for
developers.
So
the
first
goal
is
the
khs
log.
A
This
will
actually
connect
to
your
cluster
and
tell
the
logs
for
your
application
or
your
container
running
in
the
in
the
cloud,
the
debug
goal,
which
will
actually
open
a
remote
debug
session
with
your
application
running
in
the
cluster
and
finally,
the
watch
goal,
which
is
in
charge
of
how
to
loading
your
application.
So
it
will
detect
changes
on
your
application
and
will
actually
how
to
load
your
application
in
the
cluster.
A
So
in
this
first
demo,
what
I'm
going
to
do
is
I'm
going
to
showcase
how
you
can
actually
deploy
the
springboot
petclinic
example
application
into
an
openshift
cluster
by
using
eclipse
jacob,
but
with
actually
not
even
configuring,
the
plugin
in
your
maven
project,
so
just
by
using
the
the
maven
goals
with
any
kind
of
configuration.
So
I
chose
the
springboot
cleanly
because
it's
a
pretty
well
known
project,
and
so
the
first
step
is
we
need
to
clone
the.
A
Okay,
application
was
built,
so
I'm
let
me
check
change
to
the
my
local
openshift
cluster
and
now
that
application
is
packaged.
The
first
thing
that
we
want
is
to
actually
build
the
application.
So
in
this
case
we
are
going
to
use
the
the
build
goal,
since
we
are
targeting
an
openshift
movement,
plugin
eclipse,
j-cube,
actually
infers
this
cluster
configuration
and
will
perform
an
s2i
build,
so
this
build
is
going
to
be
performed
in
the
cluster.
A
A
This
will
actually
analyze
our
project
and
check
which
kind
of
project
it
is
with
a
springboard
project
or
whatever
and
we'll
infer
most
of
the
configurations
for
us.
So
in
this
case,
if
we
check
the
general
configurations
that
jacob
generated
for
us,
we
can
actually
see
that
it
generated
a
service.
It
inferred
the
port
where
the
application
is
running.
A
It
generated
that
deployment
config
again,
since
we
are
targeting
an
openshift
cluster,
it
will
generate
the
openshift
specific
resources
and
it's
going
to
even
add
a
liveness
probe
and
the
readiness
probe
for
us.
So
this
is
all
as
you
as
you
saw.
We
didn't
that
any
kind
of
configuration
we
just
flown
the
project
and
it's
everything
in
the
row.
A
So
it's
it's
detecting
everything
so
now
that
we
have
the
the
resources
built
for
us,
it's
a
time
for
us
to
apply
the
resources
and
if
we
go
and
check
the
bot,
this
is
the
pot
that
was
used
to
perform
our
build,
and
now
we
should
see
that
the
deployment
is
coming
up
and
that
the
the
pod
has
been
deployed
again,
since
we
added
this
liveness
and
readiness
probe,
we
can
actually
check
when
the
the
container
is
comes
ready
or
not.
So
let's
wait
a
second.
A
Okay,
so
now
the
pod
is
ready,
and
since
we
were
using
the
openshift
maven
plugin,
we
could
the
route
was
generated
for
us,
so
we
can
check
the
route
and
if
everything
was
okay,
we
can
see
that
the
application
is
actually
running.
We
can
check
everything.
We
see
that
the
database
is
working
well
and
we
could
even
add
a
new
entry.
So.
A
Again,
everything
is
is
working
as
expected,
so
yeah,
so
we
just
saw
how
we
actually
could
deploy
the
springboot
tech
clinic
with
not
a
single
configuration
just
by
invoking
three
maven
commands,
but
it's
not
only
this.
We
could
actually
actually
debug
the
application.
So
in
this
case
we
are
going
to
use
the
debug
goal.
A
And
this
will
actually
redeploy
the
the
application,
but
with
an
environment,
an
environment
variable
that
will
load
the
application
in
in
the
bulk
mode.
In
the
background,
so
our
pods
should
be
restarting
okay.
So
when
the
pod,
the
new
pod,
becomes
ready,
we
should
be
able
to
to
the
block
debug
the
application
in
order
to
debug.
We
simply
need
to
create
a
standard,
remote,
debug
application.
A
The
port
is
the
5005,
which
is
the
standard
so
again
when
this,
but
it's
ready,
we
should
be
able
to
connect
okay
great,
so
we
were
able
to
connect
to
the
dagger,
and
now
we
can
actually,
we
can
actually
check
one
of
the
one
of
the
controllers,
so
we
are
going
to
add
a
breakpoint
into
this
veterinarian
controller.
So
whenever,
whenever
we
visit
the
veterinary
divider
in
the
aryans
list,
we
will
our
application
to
stop.
Okay,
we
see
that
it
stopped.
We
could
now
modify
one
of
the
values.
So
let's
try
this.
A
A
So
one
of
the
other
one
of
the
other
goals
intended
for
developers
is
the
log,
so
this
will
actually
connect
to
the
application
container
and
forward
the
logs
and
print
them
in
our
screen.
So,
as
you
can
see,
we
can
see
the
standard
lock
and
if
you
know
a
little
bit,
the
springboot
clinic,
one
of
the
links
here
is
actually
intended
to
perform
like
a
fake
exception.
So
if
I
press
this
link,
something
should
be
printed
in
the
lock.
Let's
check
it
yeah.
A
So
just
to
complete
the
demo,
we
can
actually
see
the
undeployed
goal,
which
will
actually
clean
up
all
of
the
resources
that
we
generated
in
the
cluster.
So
if
I
run
this
all
of
these
resources
that
were
generated
the
the
pods,
the
build
route
you
can
see,
everything
has
been
cleaned
up,
but
is
terminating,
but
as
soon
as
it
terminates,
it
should
be
going
away
same
for
the
builds
so
yeah,
okay.
A
A
Okay,
so
let
me
show
you
the
application.
This
is
just
a
an
old
web
application.
It
has
some
dependencies
because
well,
this
is
an
application
that
we
run
in
a
wildfly
web
application
container,
so
it
provides
some
of
the
jboss
dependencies
that
are
provided,
so
this
will
be
provided
by
the
web
application
container.
These
are
all
the
dependencies
the
project
has,
and
then
we
added
our
plugin
in
the
plugin
section
and
we
configured
the
plugin
in
the
properties.
A
So
we
only
provided
two
configurations
in
this
case
the
docker
image
name,
so
we
are
going
to
name
our
image
like
this.
This
is
necessary
for
me
to
be
able
to
push
this
into
my
docker,
I
o
registry.
So
since
my
user
name
is
mark
nuri,
I
need
to
change
the
image
name
and
I'm
also
providing
this
configuration
for
the
service.
So
the
generated
service
manifest
will
be
of
type
notepad.
This
will.
A
A
Basically,
it
has
this
bins
configuration
that
is
used
for
dependency
injection
and
some
jboss
specific
configuration.
This
is
actually
the
file
that
will
that
youtube
will
detect
and
will
be
used
to
infer
that
the
it
needs
to
be
run.
The
application
needs
to
be
running
in
a
wildfire
container.
So
then
we
have
this
index
that
basically
will
redirect
the
user
to
a
servlet
that
I
will
describe
now
so
first
place.
We
have
this
hello
service.
A
The
application
is
filled
and
now
we
can
use
since
we
are
using
the
openshift
maven
plugin.
We
use
the
khs
prefix
and
we
can
build
the
application
right,
just
as
we
did
in
the
other
example.
But
now
since
we
are
using
the
kubernetes
cluster
and
we
are
not
using
openshift,
it
will
perform
a
docker
build.
So
it's
going
to
use
my
local
docker
demon.
So
if
I
check
my
images
here,
I
can
see
that
the
image
has
just
been
generated.
A
A
Okay,
the
application
has
been
pushed
if
I
check
my
register
here.
Okay,
one
second
yeah-
it
was
just
pushed
a
few
seconds
ago.
So
now
is
the
time
to
actually
deploy
this
into
my
kubernetes
local
quantities,
minicube
cluster.
So
I'm
going
to
generate
the
resources
just
as
we
did
before,
and
I'm
going
to
also
apply
these
resources
in
just
the
same
run.
So
basically.
A
A
A
A
Yeah,
so
the
logs
were
are
tailing
now
and
we
can
see
that
the
application
is
running
inside
a
wide
fly
application
container,
instead
of
just
a
java
runtime.
In
the
previous
example,
the
application
was
running
on
the
standalone,
springboot
generated
jar,
and
now
it's
actually
a
word
deployed
in
the
in
the
wildfly
web
application
container.
A
This
concludes
the
second
demo,
so,
let's
move
on
future
plans
for
eclipse
youtube.
So,
let's
see
what's
coming
in
the
next
in
the
next
days
or
in
the
next
months.
What
we
actually
want
to
do
is
include
more
build
strategies,
namely
kaneko,
but
any
other
thing.
It's
that
suggests
that
it's
good
and
we
also
want
to
create
greater
plugins
on
top
of
this
mega
plugin.
A
So
right
now
we're
only
supporting
maven
projects,
but
our
intention
is
to
support
greater
projects
too,
create
their
projects
too,
and
finally
provide
support
for
more
frameworks
and
more
opinionated,
defaults
and
so
on.
So
the
most
important
thing
is
that
what
we
want
is
that
the
community
to
get
involved,
so
it
would
be
nice
if
you
actually
got
in
touch
with
us
and
and
provided
feedback
and
said
hey.
I
would
like
to
see
this
new
feature
in
the
project
or
whatever.
So
that's
what
we're
really
striving
for
in
the
next
few
months.
A
So
thank
you
very
much
again
for
joining
the
session.
I
hope
that
you
enjoyed
it
and
you
can
find
us
on
twitter
or
you
can
visit
the
repo
or
you
can
even
visit
our
website
where
you
have
more
information
on
about
how
to
get
involved,
how
to
contribute
to
the
project.
So
again,
thank
you
very
much
and
let's
see,
if
you
have
any
questions
in
the
next
q
a
session.
Thank
you
bye.
Okay,
so,
let's
see,
if
you
have
any
questions
first,
one
will
the
flow
be
the
same
for
openshift4.
A
A
will
j
cube,
be
integrated
to
carcos,
so
quarkus
offers
its
own
extensions
to
do
more
or
less
what
you
saw.
It
has
a
docker
extension,
a
jeep
extension
and
a
kubernetes
extension,
so
there
are
already
certain
alternatives
that
you
can
use
using
the
quarkus
way,
but
obviously
jq
provides
a
more
integrated
and
I
don't
know
configurable
way
to
do
the
same.
A
You
can
actually
use
our
our
plugin
with
quarkus
and
with
any
carcass
project,
and
it
will
work
exactly
as
we
did
with
the
spring
project
and
with
the
wildfly
project.
So
you
can
try
also
the
quarkus
way
and
and
see
if
which
way
you
prefer
also
is
gradle
support
plant.
Well.
This
was
already
in
one
of
the
in
one
of
the
roadmap
slides.
A
Yes,
we
actually
plan
this
for
the
1.1
milestone
and
we'll
try
to
to
implement
this
as
soon
as
possible,
since
there
is
lots
of
people
interested
okay.
What
are
the
required
dependencies?
Oc
cube,
control,
et
cetera,
so
we
don't
rely
on
oc
or
cube
ctl
internally
j-cube
uses
the
fabricated
kubernetes
client,
which
our
team
also
maintains.
A
So
there's
actually
no
dependencies,
two
binaries,
except
maybe
for
docker
in
case
you're
using
docker
builds,
but
even
this
can
be
substituted
with
chip.
So
you
really
don't
need
any
specific
binaries
or
dependencies
in
your
environment
to
run
j-cube,
plugins
and
finally,
will
fabricate
when
x-client
be
moved
to
jq,
not
that
I
know
of
so
it's
an
independent
project
that
it
has
its
own
community.