►
From YouTube: Java Application Deployment Options in OpenShift - Nigel Brown (IBM) | OpenShift Commons Briefing
Description
Java Application Deployment Options in OpenShift
Nigel Brown (IBM)
OpenShift Commons Briefing
2020-04-23
A
Well,
hello
and
welcome
everybody
to
this
OpenShift
Commons
briefing
today
we're
going
to
hear
from
Nigel
Brown
who's,
a
developer
advocate
at
IBM
about
java
application
deployment
options
or
open
shipped
on
the
IBM
cloud.
We're
really
excited
to
have
Nigel
here
today
and
today
is
also
our
first
experiment
in
live
streaming
to
twitch.
So
if
you
see
me
twitch
a
few
times
today,
it's
just
because
this
is
a
new
experiment
and
as
well
Nigel
will
be
available
for
some
Q&A
at
the
very
end
of
this.
A
So
if
you're
joining
through
bluejeans,
ask
the
questions
in
the
blue
jeans
chat
if
you're
joining
through
twitch
actually
ask
the
questions
on
Twitch
and
our
other
moderator
over
there
will
forward
the
questions
into
this
session
so
without
any
further
ado
Nigel.
Thank
you
very
much
for
coming
and
we're
thrilled
to
have
you
so
take
it
away
and
let's
see
what
live
demoing
does
on
Twitch.
At
the
same
time.
Oh
this.
B
Is
gonna
be
great?
Thank
you
all
for
having
me
so
much.
My
name
is
Nigel.
As
has
already
been
said,
I'm
a
developer
advocate
at
IBM
I,
do
advocacy
around
IBM
cloud
working
a
lot
on
cloud
native
deployments,
working
on
containers
and
kubernetes
and
open
ships.
So
one
of
the
things
that
we
noticed
when
we
were
starting
to
do
a
lot
of
these
workshops
is
that
people
were
happy
with
the
demos
that
we
were
giving
in
nodejs.
B
B
B
I
will
try
not
to
pull
any
weird
faces
while
we're
no
promises
myself,
okay
and
then
I
will
share
this
chat.
So
this
is
a
workshop
that
I
gave
last
week
on
the
13th
and
I
set
up
a
gist
that
we
had
going
at
the
time
with
a
lot
of
helpful
links
in
it.
So
I'm
gonna
drop
the
gist
there,
so
you
all
can
follow
along
with
everything
that's
going
on
here.
B
What
I
want
to
show
is
this
link
here.
So
it's
an
open
shift
on
IBM
cloud
workshop
that
was
written
to
show
Java
and
open
shift
for
the
application
that
we're
showing
today
shows
us
a
web
app.
That
would
be
a
sort
of
like
author
return
system,
so
you'd
send
a
get
request
to
figure
out
who
and
author
is
and
get
information
back
on
that
person.
B
So
we've
got
the
web
application
front-end
that
request
data
from
the
web
api,
the
web
api
retrieves,
a
list
of
articles
title
and
author's
name
from
the
article
service
and
for
every
author
it
retrieves
the
details,
the
blog
URL
and
the
twitter
handle
from
the
authors
service.
In
this
lab,
we
only
use
the
author
service,
but
again
this
is
built
as
a
very
bare
bones.
B
Skeleton
thing
that
you
can
build
on
top
of
for
your
own
application,
so
I
want
to
give
a
huge
shout
out
to
Nicholas
and
Hyde
Nicholas
I
love
and
our
old,
whose
names
you'll
see
a
lot
through
this
workshop,
because
they're
the
ones
that
wrote
this
content.
So
we
have
in
this
workshop.
They
have
like
the
three
optional
parts,
will
the
prereqs
and
then
the
two
optional
parts,
and
then
the
rest
of
it
is
for
the
4
through
8.
B
The
4th,
through
the
8th
exercises,
are
more
dealing
with
getting
the
IBM
cloud
appointment,
working
and
hooking
it
in
with
other
services
and
things
of
that
nature.
But
I
think
that
it's
important
that
we
do
spend
a
little
bit
of
time
in
the
optional
parts,
because
that's
where
all
of
the
content
about
Java
is-
and
this
lab
is
beautifully
documented.
B
Okay,
where
are
we
here,
so
we're
gonna
start
off
with
the
prerequisites?
Of
course,
one
of
the
beautiful
things
about
working
in
IBM
cloud
is
that
we
have
an
IBM
cloud
shell
now
so,
if
I
go
inside,
VM
cloud
and
I
hit
this
little
button
here.
That
looks
like
a
show,
we'll
get
a
shell
that
loads
up
and
if
you
don't
want
to
install
packages
locally,
it's
you
know,
especially
with
keeping
track
of
versioning
and
everything
else.
B
You
can
definitely
work
in
the
IBM
cloud
show
you
can
do
most
things
that
you
need
to
do
there.
Anything
that's
doctor
related
you'll
have
to
have
a
local
doctor
and
get
installation,
but
for
everything
else
dealing
with
OSI
the
open
ship
CLI
dealing
with
cube
control,
cube,
CTL,
cube
huddle.
However,
you
pronounce
it
I'm,
not
gonna
die
on
that
hill.
Today,
you
can
use
all
of
that
inside
of
IBM's
cloud
show
the
rest
of
the
prereqs.
Oh
I
should
probably
put
the
link
in
for
creating
an
IBM
cloud
account.
I
did
not
do
that.
B
B
Then
we're
gonna
move
the
order
of
these
this
inning
and
then
yeah.
If
there
any
questions
that
anyone
has
especially
Diane.
If
you
want
to
ask
you
anything
or
say
anything
while
we're
going
through
and
the
more
mundane
parts
of
me
copying
and
pasting
things
I'm
happy
to
do
that,
okay
and
then
we're
gonna
change
into
that,
and
then
the
last
step
there
on
the
prereqs
is
to
create
an
environment
variable
called
root.
Folder
we're
gonna
be
passing
that
in
as
an
argument
to
some
commands
later.
B
So
yes,
if
you're
not
familiar
with
bash,
this,
just
essentially
sets
of
I'm
a
variable
called
root
folder
and
runs
the
command
print
working
directory.
So
it
says
this
folder
is
the
output
of
that
root
folder.
We
can
make
sure
that
it
went
through
by
sending
an
echo
out
for
that
root.
Folder
cool
we're
in
the
right
place,
great
and
then
I
already
have
a
cluster
provisioned
in
IBM
cloud.
This
is
me
PNB
dev,
but
if
you
were
creating
an
open
shift
cluster,
it
would
you'd
go
through
the
catalog.
B
B
It
this
Red
Hat
open
shift
on
IBM
cloud,
and
then
you
have
a
choice
between
3.11
or
4.3
and
yeah.
Go
through
set
up
your
cluster
hobby
like
pick
out
your
infrastructure
and
how
many
worker
nodes
you
need,
and
then
yeah
you'll
it'll
take
about
a
half
an
hour
ish
to
get
the
cluster
up
and
running,
and
when
you
do
you
get
to
a
page
like
this.
That
tells
me
I
have
a
cluster
set
up
with
two
worker
nodes
that
are
working
normally.
B
Let
me
close
my
slack
so
that
we
don't
get
interrupted
and
if
I
go
to
the
open
shift
web
console,
which
I've
done
here
this
page,
where
the
topology
shows
up.
This
is
what
we
get
I'm
gonna
developer
persona.
We're
gonna
talk
a
little
bit
about
that
in
a
minute
but
yeah.
This
is
how
my
cluster
is
doing
right
now,
all
right
and
that
gets
us
through
the
prereqs.
One
of
the
things
that's
cool
to
see
is
that
when
you're
inside
of
the
open
ships
the
web
console,
you
can
grab
this
command
here.
B
B
Great
and
then,
if
I
open
up
my
cloud,
shell
and
then
just
paste
that
command
in
it
logs
me
in
yeah,
now
I
can
look
in
OSI
version
just
to
see
that
I'm
logged
in
to
my
cluster-
and
it
tells
me
all
about
my
ownership
cluster-
that's
running
okay
and
I-
think
the
phat
brings
us
to
the
end
of
the
prerequisites,
nothing
in
the
comments.
Yet,
hopefully,
people
are
still
okay
still
hanging
out
with
us,
and
so
this
part
would
skip
ahead
to
lab
4.
B
We
don't
want
to
do
that,
so
we
want
to
look
at
the
perks.
We
want
to
talk
about
what's
going
on
with
Java,
so
the
lab
the
first
part
and
there's
helpful
videos
to
get
you
through
all
of
the
content.
That's
here
of
Nicolas
R&R
Harold
working
through
all
of
these
different
examples,
but
it's
important
to
kind
of
bring
up
the
infrastructure
of
our
Java
code.
So
we
created
microservices
implemented
with
Java,
EE
and
Eclipse
micro
profile.
B
The
micro
service
has
been
kept
as
simple
as
possible,
so
they
can
be
used
as
a
starting
point
for
other
micro
services.
It
contains
the
following
functionality.
You
got
an
image
with
open,
Jana
and
open
JDK,
open,
Liberty
and
micro
profile.
We've
got
a
maven
project
for
all
of
our
project.
Management
needs.
We've
got
an
open,
Liberty
server,
that's
how
our
web
server
is
working.
We've
got
a
health
endpoint
which
is
going
to
be
later
when
we
start
talking
about
how
OpenShift
works,
how
kubernetes
works
to
make
sure
that
our
applications
are
running
healthily.
B
We've
got
yellow
files
for
folks
who
may
have
be
used
to
already
deploying
to
kubernetes
and
want
to
do
a
similar
style
of
deployment
to
open
ship,
and
then
we
have
our
sample
rest
get
endpoints
for
the
author's
application
for
the
get
author
and
for
the
author
and
then
again,
the
service
provides
the
REST
API
get
author.
Normally
we
use
a
database
but
we're
storing
the
data
locally,
just
so
that
we
can
show
how
all
of
these
things
fit
together
and
I
would
encourage
you.
B
Definitely
if
you're
working
through
this
on
your
own
time
take
a
take
a
minute
read
through
this.
This
is
really
good.
It
again
links
out
to
a
blog
that
Nicholas
has
written
about
how
to
run
the
hello
world
Java
micro
service,
and
then
we've
got
inside
of
our
repo
as
well,
because
we're
going
to
talk
about
different
methods
of
deploying
to
OpenShift
one
method.
We're
going
to
talk
about
is
deploying
with
the
docker
file.
B
B
We
build
an
environment
container
from
from
all
of
the
requirements
for
Java,
and
that
sets
up
all
of
everything
that
we
need
to
build
the
application
and
make
sure
that
the
container
that
we're
deploying
doesn't
have
anything
in
it
that
it
doesn't
need,
because
if
you
set
up
one
container
for
example,
that
has
all
of
the
build
tools
in
it,
then
that's
just
a
bigger
container.
Then
it
needs
to
be.
B
But
if
we
set
one
up
first
to
handle
all
of
the
build
to
hit
all
of
the
environment
variables
to
handle
all
of
the
environment,
set
up
getting
maven
installed
everything
like
that,
and
then
we
start
another
container
that
actually
runs
our
application.
The
container
that
gets
announced
to
production
is
a
lot
lightweight,
a
more
lightweight
and
easy
to
deploy,
especially
and
that's
something
that
will
become
a
concern
as
we're
deploying
more
and
more
micro
services
and
looking
at
the
resource
requirements
of
what
we're
building.
B
So
this
the
exam
we'll
take
it
line
by
line
to
say:
okay,
here's
what's
going
on
in
each
line
of
micro
profile
and
then
there's
an
option
to
excuse
me
in
each
line
of
the
dockerfile,
not
micro
profile,
but
there's
an
option
here
so
to
run
the
The
Container
locally,
to
see.
What's
going
on
here,
I'm
going
to
check
how
we're
doing
on
time
to
see
this.
B
B
B
B
Why
not
use
s2
I?
Thank
you,
I'm,
so
glad
you
brought
SII
up.
We
are
gonna
be
going
in
it's
honestly.
Sii
is
one
of
my
favorite
features
of
open
shift,
so
for
those
who
are
unfamiliar
yes,
I
stands
for
source
to
image.
It's
an
open
source
project,
that's
worked
on
by
Red
Hat
and
what
it
allows
is
for
us
to
create
these
custom
builder
images
that
will
take
our
code.
That's
already
been
deployed
our
code.
B
That's
already
been
written
package
that
into
a
container
for
us
and
run
that,
because
essentially,
a
container
is
just
a
process
that
has
all
the
isolation
around
it.
So
if
we
create
these
this
automated
way
of
outputting
a
process
that
can
access
all
of
the
libraries
and
features
that
it
needs,
then
it's
a
lot
easier
to
get
people
who
have
never
used
containers
before
to
be
able
to
use
it
and
one
of
the
really
cool
things.
Actually,
let's
take
a
bus.
That
is
something
that
we
do
look
at
and
this
works.
B
We
will
absolutely
do
that,
but
the
reason
I
don't
bringing
it
up
early
is
because
I
think
that
read
the
people
who
were
doing
a
lot
of
Java
deployments
they're
often
what
I
found
is
they
want
to
get
a
sense
of
what's
happening
with
the
Java
first
before
we
show
them.
Okay,
hey!
Actually,
there's
this
really
cool
thing
that
you
can
do
all
sorts
the
image
where
you
don't
have
to
deal
with
these
build
containers
and
everything
we
have
the
containers
already
built
ahead
of
time
for
you
but
yeah.
Let's
look
at
so.
B
If
I
go
to
my,
if
I
go
to
my
develop
review
and
open
shift
and
I
look
at
the
topology,
because
there's
no
work
load
running
in
this
default
project,
we're
gonna
create
a
project
later
for
what
we're
gonna
do.
If
you
go
to
the
from
catalog
here
you
have,
a
heel
is
of
ready
built
builder
ammo
is
two
setups
builds
inside
of
openshift.
B
We
use
a
lot,
the
the
nodejs
one,
but
if
you
wanted
to
do
an
engine,
X
server
or
Perl,
or
anything
like
that,
you
have
a
ton
of
builder
images
here
and
if
you
don't
see
what
you
need,
there's
really
good
documentation
for
setting
up
your
own
builder
images
and
even
having
to
be
able
to
show
up
in
the
catalog
as
well.
But
yeah.
B
B
B
B
B
B
We're
gonna
give
that
a
second
to
get
up
and
running,
so
the
the
thing
about
this
container
that
I've
noticed
as
opposed
to
other
ones,
is
that
it
does
take
a
little
bit
longer
to
get
going,
but
that
was
a
little
bit
more
heavyweight
there's
a
lot
of
things
that
are
happening
in
the
background
to
be
able
to
get
well
we're
about
to
see
happening,
so
we're
gonna.
Look
at
all
these.
B
All
this
logging
is
normal
and
as
soon
as
it
tells
us
ready,
then
we're
gonna
go
look
at
the
host
3000
and
look
at
the
application
that
we're
building.
Are
there
any
other
questions
while
we're
while
we're
getting
this
set
up
and
yeah
Dan
I,
don't
know
if
there's
anything
else,
you
want
to
say
about
source
to
image.
I
see
that
you
dropped
the
link
there
to
the
docs
or
I
ya.
A
Know
the
SGI
stuffs
been
around
for
a
long
time.
It's
really
really
useful.
I'll
share
the
links
at
the
end
of
this
session
and
people
can
do
it.
You
can
go
to
doc,
stop
a
ship,
calm
and
just
search
on
Sui
and
you'll
find
it
if
you're
listening
in.
But
it's
it's
it's
a
really
handy
tool
to
have.
It
is
always
all
open
source
too.
So
it's
pretty
great
yeah.
B
A
And
everything
we
do
all
of
OpenShift
itself
is
open
source
as
well,
and
all
of
the
operators
and
anything
else
that
we
use,
and
these
apps
are.
You
can
find.
Okay,
Dee
is
the
name
you
could.
Ok
do
find
OpenShift
itself
and
all
of
its
glory
and
operator
hub
do
for
any
of
the
operators
that
we
use
as
well.
So
it
is
Red
Hat.
We
do
everything
in
the
open.
B
B
First
path
that
we
need
is
open,
API,
flash
UI
and
we
get
a
graphical
view
of
the
API
working,
so
it
makes
it
a
lot
easier
to
debug
on
what's
going
on
with
our
calls
but
yeah.
If
we
run
this
get
author
call,
we
the
model
is
that
it
returns
a
name,
let's
Witter
handle
on
a
blog
address,
and
so,
if
we
yeah
I
could,
if
we
curled
begin,
we
could
curl
this
endpoint
and
get
the
same
information
out.
B
But
what's
important
to
see
is
that
if
this
is
what
we
would
expect
to
see,
once
we
have
the
deployment
up
on
OpenShift,
if
it's
not
working,
then
we
know
something
is
gone
wrong.
So
I'm
gonna
jump
back
over
to
yeah.
We
just
wanted
to
see
it
running
locally
and
we
looked
at
the
UI
and
yeah.
If
you
can't
open
a
browser,
you
can
hit
a
curl
and
then
we're
gonna
go
over
to
lab
3
I.
Think
I'm
finished
with
running
it
locally,
so
I'm
just
gonna
shut
that
container
down.
B
Let
it
do
its
thing
and
then
we'll
hop
back
over
here,
all
right,
great,
so
understanding
the
Java
implementation,
so
yeah
using
maven
maven
is
a
software
project,
management
and
comprehension,
tool
concept
of
a
project
object
model
maven
can
manage
your
project
projects,
build
reporting
and
documentation
from
a
central
piece
of
information.
This
is
the
pom
file
that
we
have
set
up
to
explain
our
may
be
and
implementation
there.
B
All
of
this
is
really
really
well
documented
and
I
would
encourage
you
if
you
wanted
to
have
a
look
at
it.
Please
take
the
time
to
do
so,
but
the
important
part
that
we're
looking
at
here
is
what
we
saw
that
each
author
has
the
attributes
named
Twitter
and
blog
and
when
you're
implementing
this
yourself,
of
course,
do
whatever
you
need
and
then
for
getting
the
author.
We
want
to
figure
out.
B
B
So,
let's
go
yeah
and
how
we're
gonna
support
the
live
and
readiness
probes
and
kubernetes
with
health
checks.
So
one
of
the
things
to
understand
if
you're
not
familiar
with
kubernetes
and
OpenShift,
is
this
this
way
of
dealing
with
applications
being
built
in
they
are
being
described
in
this
imperative
versus
declarative
way.
When
we're
working
like
with
declarative,
we,
when
we
work
with
imperative
systems,
what
we
do
often
is.
B
We
have
a
clearly
defined
like
algorithm,
for
how
our
application
should
work
and
that's
what
we
as
programmers,
often
write
and
then
with
imperative
program
or
with
declarative
programming
which
are
declarative
like
operation,
which
is
how
kubernetes
and
OpenShift
work.
You
say
when
my
application
is
healthy.
This
is
these
are
the
attributes
that
it
has
and
then
with
the
use
of
the
control
plane
in
kubernetes
with
it,
the
control
loops
are
similar
to
how
a
thermostat
might
work.
We
have
like
a
thermometer.
That's
telling
us
what
the
temperature
in
the
room
is.
B
Excuse
me
with
how
Micro
profile
the
the
kubernetes
micro
profile
health
documentation
on
github,
so
definitely
check
that
out.
So
I've
already
changed
the
data
and
run
the
container
locally
and
we're
gonna
move
on
to
yet
to
see
it
update.
But
now,
let's,
let's
get
into
the
deploying
the
OpenShift
part,
I,
see
a
comment
here.
B
I
understand
this
is
an
introduction,
but
since
the
doors
open
by
Nigel
I
hope
it
covers
on
binary,
builds
versus
just
from
source
and
Delta
builds
starting
from
a
docker
bill
is
probably
the
Slauson
or
sashan
available
with
openshift
container
platform.
Yes-
and
one
thing
also
to
know
with
openshift-
is
that
the
docker
bills
aren't
going
to
be
available
in
every
cluster,
because
running
docker
builder
requires
root,
and
one
of
the
things
about
managing
security
is
not
giving
everyone
root
access.
B
So
it
may
be
the
case
that,
especially
with
clusters
that
have
been
set
up
and
access
given
by
some
other
sysadmin
to
developers,
you
may
not
even
be
able
to
run
docker
builds
in
your
open
ship.
Cluster
I
want
to
make
a
plug
for
folks.
If
you're,
if
you
have
a
chance,
Red
Hat
has
a
great
book
about
that
covers
everything
that
is
mentioned
in
the
comment
by
Peter.
All
that
we
don't
have
time
to
do
everything
go
build.
Yeah
build,
is
great,
but
check
out
this
book
deploying
the
open
ship.
B
It's
free
online
I
think
that
I
put
the
link
in
the
gist
to
it,
but
it
covers
all
the
different
ways
to
build
open
ship
applications
and
deploy
all
the
information
is
for
over
2/3.
There
hasn't
been
one
that
came
out
for
4
yet,
but
the
information
is
still
great
and
yeah
if
there,
if
you
have
specific
like
it,
gets
into
a
lot
of
specifics
about
how
you
might
be
able
to
of
more
specific
bills
and
the
differences
between
a
lot
of
the
build
strategies
on
which
we
won't
have
time
to
go
into
today.
B
B
Well,
if
there's
anything
specific
in
the
end,
we'll
maybe
try
to
cover
that
but
yeah.
This
I'm
gonna
plug
along
with
this,
because
watching
the
time
in
this
lab
will
work
with
the
open
shoes
web
console
and
with
openshift
OC
CLI
on
IBM
cloud.
Shell,
the
following
image
is
a
simplified
overview.
The
topics
in
the
lab
and
keep
in
mind
the
open
ship
is
kubernetes
platform
yeah,
so
kubernetes
is
the
engine
that
makes
the
OpenShift
car
run.
B
It's
it's
every
a
lot
of
the
commands
that
are
I
mean
every
command
that
and
cube
controllers
of
a
little
C
command.
So
if
you're
familiar
with
kubernetes,
then
there's
not
a
lot
that
changes.
I.
Think
that
a
lot
of
times
when
we
give
this
workshop-
and
it
probably
won't
be
the
case
here-
because
this
is
to
like
folks
and
the
Red
Hat
OpenShift
ecosystem,
making
the
differentiations
between
kubernetes
and
open
shift
and
people
understanding
that
they're
like
they're
different,
but
it's
still
it's
kubernetes
underneath
and
yeah.
B
Sometimes
we
talk
about
how
open
shift
was
like
a
rails
thing
initially,
and
then
it
was
rebuilt
with
kubernetes
underneath,
but
yeah
I'm
sure
you
all
already
know
all
of
that
stuff.
So
I
won't
labor
at
that
point.
So
the
lab
has
two
parts
we
build
and
save
the
container
image.
We
create
an
open
ship
project.
B
We
define
a
build
config
which,
like
we,
build
the
pod
inside
of
openshift
and
save
the
container
image
to
the
internal
open
ships
container
registry
and
then
we'll
deploy
the
application
and
explosive
service
and
yeah
there's
a
lovely
gift
here
that
you
can
check
out
when
we,
when
you
have
time
to
to
view
this
on
your
own.
So
the
first
thing
we
want
to
do
is
create
an
open,
shipped
project.
B
So
I'm
gonna
make
a
different
project,
but
I'll
have
to
wash
I
have
to
be
careful
about
any
sort
of
project
names
that
are
in
any
of
the
commands,
because
yeah
I'm
gonna
pretend
my
first
name.
Last
name
is
something
else
today,
all
right.
Let's
open
up
our
cloud
show
and
I'm
gonna
pull
up
the
instructions
over
in
a
different
window.
Yeah
I
know
how
this
works.
I
know
how
to
do
it,
but
it's
always.
B
Whenever
I'm
doing
it
live
working
a
little
bit
too
fast
that
I
get
lost
and
something
breaks
and
I'm
gonna
do
my
absolute
best
to
not
do
that
so
I'm
working
a
little
slow.
That's
why?
So?
We
want
to
make
sure
that
we're
in
that
root,
folder
and
we're
also
gonna
go
to
deploying
to
open
shift
perfect.
B
Your
first
name,
your
last
name,
I
say
my
first
name
is
Nigel
and
my
last
name
just
OSI
project,
Nigel
Nigel
and
that's
going
to
create
the
new
project.
Great,
you
can
add
applications
of
this
project
with
the
new
app
command.
For
example.
Try
a
new
app
sent
us
I'm,
not
gonna!
Do
that
because
we
have
steps
here.
So
what
we're
gonna
do
is
we're
gonna.
Do
a
binary
build
here
with
the
docker
build
strategy,
so
there
was
some
mention
of
binary
bills
before
yeah.
B
B
B
B
B
Yeah
one
of
the
things
that
we're
gonna
have
a
look
at
is
like
with
doing
logs
on
IBM
cloud.
But
what
we're
waiting
to
see
here
is
that
there's
a
there's,
a
part
that
says
that
our
image
was
successfully
pushed
to
our
internal
registry,
so
people
may
be
familiar
with
container
registries
dealing
with
doctor
hub,
or
maybe
you
have
a
private
registry
somewhere
and
I.
Think
well.
I
know
that
we
have
a
service
on
IBM
cloud
as
well.
B
B
Great
awesome:
well
maybe
you
like
push
ahead
a
little
bit.
I,
don't
want
to
sit
and
wait
for
this
thing
to
build,
because
we
have
so
much
to
cover
it
with
so
much
to
talk
about.
The
next
thing
that
we
want
to
do
is
to
verify
the
container
image
inside
of
open
ships.
So
if
we
looked
at
the
image
streams
inside
a
builds
instead
of
where
we
were
looking
at
looking
at
the
builds
themselves,
we
see
that
this
image
stream
was
created
three
minutes
ago.
There's
one
image
in
it
and
yeah
it's.
B
Oh,
it
has
from
a
pushed
image
and
we
want
to
look
at
the
information
under
under
the
oh
yeah,
the
image
repository.
So
that's
the
that's
the
repo
internally
to
open
ship
that
our
container
lives
and
then
we're
gonna
need
this
in
a
minute
because
we're
gonna
look
at
the
first
thing
we're
gonna
look
at
is:
if
you're
used
to
kubernetes
already
how
you
might
mimic
the
same
things
in
openshift
and
we're
gonna
need
this
thing.
B
B
Poblet
pods
are
just
a
group
of
one
or
more
containers
and
it
represents
the
processes
running
in
your
cluster.
So,
let's
start
with
the
deployment
IMO.
So
again
we
have
inside
of
our
inside
of
our
repository.
We
already
have
the
mo
already
there
for
you
for
the
deployment
and
yeah.
So
if
you're
unfamiliar
with
how
the
mo
works
I'd
encourage
you
to
check
this
out,
we
could
spend
workshops
talking
about
yeah
mo,
but
the
important
things
that
we
want
you
to
see
here
are
just
that.
B
We've
got
the
name
of
our
container
or
the
name
of
yes,
the
name
of
our
container,
the
image
which
ports
are
running
and
the
live
witness
probes.
So
in
the
full
deployment
I
am
we're
going
to
have
to
change.
Excuse
me
we're
gonna
have
to
change
this.
This
line
to
be
able
to
put
the
right
one
for
our
deployment
there,
so
we're
gonna
first
edit,
the
mo.
B
Let
me
get
back
over
to
our
cloud.
Shell,
perfect
and
yeah.
We're
gonna,
look
in
our
deployment
folder
and
we're
gonna
copy
the
templates
deployment.
Oh
that's
already,
there
we're
gonna,
call
it
deployment
gamal
and
then
we're
gonna
edit
that
deployment
and
Paul
we're
gonna
wanted
to
has
change
this
line.
Here,
though,.
B
B
Our
deployment
was
created,
so
let's
go
look
in
our
topology
and
an
open
ship
to
make
sure
that
that
is
showing
up
the
way
we
expected
to
so
we're
going
to
jump
over
to
our
develop
review
and
look
at
our
deposit
look
at
their
a
brand-new
shiny
deployment
of
our
authors.
Dot
then
the
container
is
creating
we're
done.
B
Yeah
we're
gonna,
look
at
how
to
do
this
from
the
console,
but
for
those
folks
that
a
lot
of
times
we're
dealing
with
like
shelling
and
the
resources
don't
have
the
luxury
of
looking
at
this
beautiful
interface
that
we
have
here
in
OpenShift,
all
the
stuff
is
available
from
the
command
line
and
we're
showing
it
with
the
cloud
shell,
but
yeah
works
as
easily
when
you
Sheldon
we're
gonna.
Give
that
a
second
to
go.
Let
me
look
at
what
comes
after
this
part.
B
Yeah,
we're
gonna
also
apply
a
service,
and
this
is
another
thing
that,
if
you
used
to
dealing
with
kubernetes
like
you'll,
be
familiar
with,
if
you're,
if
you
haven't
and
you're
just
dealing
with
openshift
count
yourself
lucky
because
we're
gonna
show
how
to
do
that
and
a
much
unclear
waste
by
checking
some
boxes
when
we're
deploying
an
open
ship.
So
wanna
at
least
draw
your
attention
here
to
the
the
yam
will
here.
So
in
the
service
we
see
a
selector
of
the
pod
using
the
label,
app
authors
and
yeah.
B
This
is
again
already
been
created
for
you,
but
you
can
update
it
as
you
wish,
and
we're
just
gonna
apply
that
service.
It
doesn't
have
to
be
changed
because
the
port's
the
same,
regardless
of
which,
which
registry
it's
deployed
to
which
registry
your
container
stored
in
so
we're
gonna,
go
ahead
and
apply
that
service
right
now,
so
OC
oops
apply
we're
gonna
pass
in
as
an
argument
that
file.
That's
in
this
folder
service
that
amo.
B
Qu
and
that
service
was
created
and
so
we're
gonna
check
in
the
web
console
again
and
that's
apology
view
before
there
wasn't
there
wasn't
a
service
in
routes,
but
there
will
be
now
when
we
go
look
so
and
that's
apology:
now
we
have
a
service
and
well
the
routes
aren't
up
yet
we'll
figure
out.
What's
going
on
why
it's
most
behaving
but
oh
I
didn't
expose
it.
That's
my
fault.
So
after
you
apply
the
service,
then
you
have
to
expose
the
route.
Let
me
do
that
right
now,
I
will
see
exposed.
B
B
B
This
is
what
we
saw
in
our
browser
before
and
if
we
then
go
to
that
same
UI,
which
was
at
flash
open,
API,
slash,
UI,
perfect,
we
see
what
we
saw
locally,
which
means
that,
where
it's
working
so
that
at
least
gives
us
some
idea
of
how
it
might
be
to
the
develop
locally
with
docker
using
containers,
everything
like
that
and
then
deploying
it.
You
open
shift
and
making
sure
that
our
environments
kind
of
match
the
only
difference
being
this
long
string
of
text
at
the
beginning
here,
for
where
our
application
actually
is
check.
B
B
B
Okay,
we're
gonna
go
to
create
we're
gonna,
deploy
a
new
container
image,
so
in
our
ads
use
the
container
image
we're
gonna
do
an
hi
love,
there's
v1,
which
is
the
same
container
that
we
had
the
same
container
that
we
emit
the
same
image
that
we
had
before.
But
this
time
we're
gonna
get
it
from
docker
hub,
as
opposed
to
providing
the
docker
file
for
our
binary,
build
we're
gonna
change
the
name
to
be
authors,
image
because
we're
deploying
it
as
an
image.
This
time
we're
gonna,
create
it.
B
B
Come
on
buddy
should
be
ready
soon,
but
yet
there
was
a.
There
was
a
fair
amount
to
get
the
the
job
application
up
and
running.
It
wasn't
immediately
accessible
before
I
there.
It
is
it's
up
and
running
now,
then
we're
gonna
go
ahead
to
that
same
open,
API,
UI
and
see
exactly
what
we
expect
to
see
so
that
deployment
took
us
a
lot
shorter
time
than
it
did
before
to
build.
It
then
apply
the
MMO
files
and
everything
else
you
can.
B
Just
if
you
have
an
image,
that's
pre-made
as
long
as
this
OCI
compliant,
you
can
run
it
in
openshift,
with
the
exception
of
your
containers,
can't
be
running
his
route,
there's
a
flag
that
you
can
change
an
open
ship
that
don't
recommend
it
but
yeah
by
default,
your
container
or
stone.
You
can't
run
his
route
because
yeah.
If
your
process
escapes
its
container,
then
it
can
execute
commands
in
your
cluster
as
route
and
generally
not
a
good
thing.
So
yeah
you.
B
If
you
have
your
own
image
that
you
like
to
deploy
to
OpenShift
yeah,
all
you
have
to
do
right
there,
and
then
this
is
the
same
java
application
that
we
had
before
that's
been
containerized
and
deployed
to
openshift.
Now
we
have
to
deployment
strategies,
we
did
a
build
with
the
binary
and
then
we
have
an
image
now
and.
B
B
Next,
we
want
to
look
at
first
image:
build
excuse
me,
so
I'm
gonna
go
ahead
and
well
the
first,
the
first
we're
gonna,
do
it
from
from
a
git
repository
and
I'm
gonna
do
that
from
the
the
HSS
as
it's
doing
that
from
the
command
line.
So
let's
do
that.
That
way,
because,
like
oh
I,
can
just
do
this
instead
and
then
break
something
and
then
spend
you
know
all
of
our
time
troubleshooting.
So
we're
gonna
make
sure
that
we're
in
the
right
project,
oops
Oh
see
not
PC.
This
is
a
Mac
project.
B
Yep
and
I'm
gonna
copy
and
paste
in
this
long
thing
here
and
we'll
talk
about
it
in
a
second,
so
yeah.
So
we've
got
a
string
for
the
repository
this
open
ship
and
IBM
cloud.
The
context
directory
so
we're
an
actual
application
is,
is
in
that
deploying
to
open
shift
directory
and
we're
gonna
name
it.
Authors
get
because
this
is
our
git
deployment.
B
B
It
just
takes
that
docker
file,
that's
in
our
in
our
git
repository
and
uses
that
to
build
and
expose
our
application,
and
so
if
we
we
didn't
have
to
create
any
Emma
files
or
anything
like
that,
we
just
pointed
it
to
a
repository
that
had
a
docker
file
in
it
and
if
our
repository
didn't
have
a
docker
file
in
it,
that's
what
we
get
to
source
the
image.
So
I
got
a
little
bit
ahead
of
myself.
There
we're
still
using
a
docker
build
strategy
because
we
have
the
docker
file
in
our
repository.
B
Excuse
me:
let's
go,
have
a
look
at
that
oops
dumped
over
to
builds,
and
we
see
that
our
authors
get
build
is
here
and
the
git
repository.
Is
there
the
IBM,
open
ship
and
I've
been
cloud
workshops,
and
if
we
look
at
like
all
of
the
ammo
is
already
generated
for
us
there
or
the
buildconfig,
we
don't
have
to
deal
with
any
of
the
mo
stuff
which
can
be
vessel
if
you're
not
used
to
dealing.
B
B
Authors,
kids
build
one,
it's
still
running,
so
it's
gonna
take
a
minute
as
it
did
before,
and
then
we'll
have
to
create
the
routes.
Again.
Oh
wait:
we've
got
the
service
there,
so
we'll
have
to
expose
that
service
and
then
we'll
have
to
get
the
routes.
Alright.
So
we'll
jump
back
over
to
our
cloud.
Shell
OC
expose.
B
B
B
Name
is
what
we
had
locally
alright.
So
so
far
we
have
done
three
different
build
strategies,
not
counting
the
one
locally.
We've
got
a
build
that
we
did
from
an
image
and
that
was
existing
in
a
public
docker
hub
docker
registry
we've
got
this,
get
build
that
we
just
did,
and
then
we
did
our
binary
build
as
well
see
if
we
can
fit
another
one
in
here.
So
yeah
we've
got
that
built.
I.
Think
I
did
all
the
things
here.
B
Yeah.
If
you
had
your
own
image,
that's
back
before
we're
past
that
now
we
did
all
yeah
we've
had
three
different
deployments
there,
amazing,
and
now
we
get
to
the
source
to
image
builds
which
was
mentioned
at
the
beginning.
So
we
have
a
custom
builder
image
set
up
that
same
image
that
we
were
talking
about
before.
So
there's
not
in
the
catalogue
already
the
open,
Liberty
builder
image
and
so
we're
gonna
pull
in
the
one
that
that
we
had
before
and
we're
gonna
use
open
shift
to
make
it
available
to
us.
B
We're
gonna
use
the
CLI
to
make
it
available.
So
I'm
gonna
hop
over
to
our
CLI,
we're
gonna
start
we're
already
in
the
right
project.
That's
the
first
step
here
so
we're
the
the
image,
the
builder
image
that
Nicholas
made
as
well
as
available
in
a
public
repository,
so
I'm
just
gonna
copy
in
that
command.
So
we
want
to
import
an
image:
the
docker,
dot,
IO
and
I'd
love.
Then
the
source
image
open.
The
liberty
latest
gonna
confirm
that.
Yes,
we
want
to
pull
this
image
and
add
it
to
our
internal
registry,
great-great
great-great-great-great-.
B
B
So
we're
gonna
go
check
out
in
our
admin
view.
We're
gonna
have
a
look
at
the
image
streams
and
we
can
see
that
our
STI
open
liberty
builds
or
our
open,
Liberty
image
stream
is
here
and
the
cool
thing
about
these
image
streams
is
like:
if
the
if
the
image
gets
updated,
then
it
it
triggers
the
update
here,
an
open
shift
and
then
all
of
our
images
that
were
built
with
those
images
are
updated
again.
So
with
dealing
with
security
vulnerabilities.
Anything
like
that,
you
don't
have
to
go
through
and
rebuild
every
single
container.
B
That
has
the
flaw
in
it.
You
just
look
at
your
builder
image
patch,
whatever
needs
to
happen,
and
then
your
builds
automatically
will
roll
out
from
there
and
you
can
keep
everything
up
to
date
and
secure
so
we're
gonna
move
ahead.
What
comes
next,
deploying
the
micro
service
so
yeah,
the
previous
step,
installs,
the
open,
Liberty
Builder
image
only
to
have
to
be
executed
once
after
this
multiple
openly
be
applications
can
be
deployed
without
docker
files
in
the
ammo
files.
B
The
image
builder
expects
certain
directory
structure
of
open
Liberty
projects
with
two
files.
The
server
and
the
war
so
before
the
code
can
be
pushed
open
shift.
The
war
file
needs
to
be
built
with
maven
and
maven
is
in
the
IBM
cloud.
Shell,
if
you're
in
a
different
Sheldon
you'll,
have
to
build
it
differently,
but
these
are
all
the
things
that
are.
This
is
how
the
Builder
image
is
set
up.
B
B
Let
that
run
so
after
those
commands
the
file
authors,
that
war
will
exist
in
the
target
directory
and
you
can
check
by
doing
a
listing
of
that
that
target
directory.
So
when
this
builds
we'll
see
what
we
expect
to
see,
and
then
we
can
set
up
a
new
build
with
that
custom
builder
image
that
we
just
imported
in
OpenShift
to
be
able
to
support
this
Java
Open
Liberty
application.
A
B
B
B
B
Alright,
this
STI,
here's,
the
one
that
we
just
did
build.
One
is
running
so
there's
a
few
more
details
in
the
and
the
documentation
here,
so
we
got
that
output
that
we
expected
will
see
that
the
bill
failed,
which
is
to
be
expected.
The
first
build
before
the
microservice
can
be
deployed
with
the
image
builder.
The
code
needs
to
be
uploaded
OpenShift.
This
is
done
via
the
OC
start,
build
the
end.
The
OC
start
build
command.
B
B
B
B
B
So
we
have
used
four
different,
different
ways
of
building
and
deploying
our
java
applications
to
openshift.
We
started
with
doing
our
binary
build.
Then
we
grabbed
from
an
existing
docker
hub
image.
Then
we
went
over
and
did
it
from
a
git
repository
that
has
a
docker
file
in
it,
and
then
we
did
our
source
to
image,
build
using
our
custom
job
a
builder
image.
But
if
we're
doing
a
different
language
to
switch
the
image
build,
if
we
did
something
that
was
in
the
catalog,
for
example,
it
would
have
been
a
lot
more
straightforward.
B
Let's
say
that
we
were
doing
like
the
nodejs
one
and
we
create
an
application.
We
would
just
have
to
point
to
a
git
repo
there
that
had
a
node.js
app
in
it
and
it
would
run
through
everything
and
we
wouldn't
have
to
do
all
of
the
work
of
it,
their
ass
and
everything
else.
But
because
we
set
out
this
custom
builder
image,
we
had
to
do
a
little
bit
more
configuration
than
than
we
would.
You
know
normally,
but
yeah
that's
Java
for
you,
you
need
extra
configuration.
B
A
B
A
It's
perfectly
fine,
I
just
need
to
make
a
bigger
screen
and
I'm
doing
good
here.
So
this
is.
This
has
been
really
wonderful
and
and
if
you
people
want
to
get
a
hold
of
Nigel,
we'll
put
all
of
this
up
on
YouTube
on
the
rh
OpenShift
youtube
channel
shortly
and
we're
we're
really
thrilled
to
have
you
here
we'll
make
you
do
this
again
on
other
flavors
with
new
features
and
functions
come
out
and
I.
You
know,
I
am
very
impressed.
A
I
do
see
like
when
your
screen
gets
a
little
bit
smaller,
there's
a
little
strange,
green
bar
on
the
side,
but
I
think
this
actually
Street
nicely
on
Twitch
and
bluejeans
simultaneously.
So
next
time
we're
gonna,
do
you
twitch
bluejeans,
YouTube
and
Facebook?
Oh
man,
thank
you
for
being
game
and
trying
this
all
out
with
us,
and
we
really
look
for
you
back
again
soon.
Yeah.
B
Thanks
so
much
for
having
me,
thank
you
all
I
hope
you
all
are
taking
care
of
yourselves
out
there
being
safe.
You
know
it's
troubling
times
and
I'm
glad
that
we're
finding
ways
to
be
connected
to
still
be
able
to
deliver
content
to
help
you
deploy
your
applications
learn
something
new.
So
thanks
so
much
I'm
glad
you
all
spent
spent
your
time
with
me
and
hopefully
we'll
see
you
soon.
All.