►
From YouTube: OpenShift App Development with Red Hat Dev Suite: Part 5, Creating Containers with JBDS
Description
In part 5 of the OpenShift Application Development with Red Hat Development Suite series, Veer Muchandi shows how to build and test container images on your local OpenShift cluster using JBoss Developer Studio.
Check out also:
*Part 1: https://youtu.be/zVXveqFcjzs
*Part 2: https://youtu.be/UxwBB0_-9VM
*Part 3: https://youtu.be/AoWtqyOifdo
*Part 4: https://youtu.be/DX4pSCwxyjs
A
Welcome
back
in
this
video,
we'll
learn
to
build
and
test
containers
on
your
local
OpenShift
cluster.
For
that
we
will
use
a
docker
file.
I
have
a
docker
file
in
my
git
repository
and
it
uses
a
real
base
image
and
there
is
a
script
this
docker
file
refers
to
which
displays
the
time
so
we'll
use
this
example,
build
a
container
and
apply
that
container
onto
the
local
OpenShift
cluster
test.
It
make
changes
and
test
it
again.
There's
that's
our
exercise.
A
First
I
will
import
this
project
from
the
git
repository
will
select
this
projects
from
it
with
smart
import.
We
will
flown
it
using
a
URI,
provide
the
URI
here
and
any
authentication
that
is
needed
to
connect
to
the
git
repository
just
leave
it
as
defaults
and
I
will
finish
so
now
we
have
the
git
repository
cloned
locally.
Now
I
am
selecting
the
rel
based
image
that
I
just
showed
you.
This
is
docker
file.
Now,
let's
switch
the
perspective
quickly.
A
You
are
seeing
the
JBoss
perspective
right
now
and
then
we'll
switch
to
darker
tooling
perspective
that
you
will
see
as
an
icon
here.
Let's
click
on
that
now
the
perspective
switches
to
docker
a
tooling
perspective,
it's
by
default,
pointing
to
your
local
docker
environment.
We
would
want
to
build
this
container
as
part
of
this
container
development
environment.
If
you
remember,
when
you
install
cdk,
we
first
start
a
VM
and
mini
shift
gets
installed
on
that
VM.
A
This
container
development
environment
is
inside
that
VM,
so
we
want
to
connect
to
the
darker
daemon
that
is
running
inside
the
container
development
environment.
So
if
you
look
at
the
list
of
containers,
these
are
the
existing
parts
that
are
running
on
my
own
on
the
overshift
cluster,
which
is
running
inside
that
VM,
and
these
are
the
images
that
are
available
in
the
docker
daemon
that
is
running
inside
the
V.
A
All
the
steps
are
not
complete
and
the
image
is
successfully
built,
and
you
can
also
see
that
under
images
here
it
has
real
time
and
with
the
latest
AG.
Now
let
us
deploy
this
continual
image
that
we
just
created
as
an
application
on
open
shipped,
so
we'll
switch
to
the
open,
shipped
Explorer.
We
see
that
there
is
a
my
project
here.
Right
click
on
that
select
this
option
deploy
docker
image.
It
shows
up
a
menu
that
allows
you
to
select
a
continuous
image
to
apply
so
we'll
browse
for
that
image.
A
Now
this
shows
us
the
list
of
images
available
in
the
container
development
environment.
So
here
is
the
image
that
we
just
created
will
select
the
dreaded
time
image,
say:
ok
and
when
the
application
gets
created
it'll
you
would
want
this
image
to
be
created
and
pushed
as
an
image
stream
in
this
registry.
So
this
is
our
registry
running
on
OpenShift.
It
shows
you
by
default.
We
want
this
image
to
be
pushed
into
this
registry
as
an
image
stream
and
then
deploy
it.
A
So
just
select
this
option
push
push
image
to
registry
and
say
next:
we
want
to
run
one
instance
of
this
app.
There
is
nothing
to
build
here.
It
will
create
a
route
as
well
no
levels
select
all
three
Falls
and
finish.
You
can
see
that
it
is
pushing
the
darker
image
into
the
registry
right
now.
The
image
is
now
pushed.
You
can
see
that
there
is
a
deployment
configuration
and
there
is
a
service
for
that
new
application.
A
Now,
if
I
run
this
application
show
in
web
browser,
it
shows
the
time
the
part
name
is
also
displayed
here
now.
Let's
change
this
image.
A
little
bit
just
just
show
the
entire
cycle,
or
how
do
we
change
the
docker
file
and
test
it
again
now
switch
back
to
this
JBoss
perspective.
This
docker
file
refers
this
unit,
dot
sh
less.
So,
let's
open
that
make
a
small
change
in
this
file
in
this
file.
I'll
make
a
small
change.
I,
just
added
the
text,
the
current
date
and
time
ease
will
save
these
changes.
A
Select
the
darker
file
and
run
docker
image
build
again,
so
it
is
running
the
build
again.
The
build
is
now
complete.
Now,
let's
see
how
we
can
connect
to
the
internal
registry,
so
I
switched
back
to
the
docker
tooling
you,
the
registry
is
running
as
a
part
on
the
open
shift
environment
here,
so
we'll
cut
to
that
registry.
Let's
first
open
the
terminal,
openshift
client
is
available
at
user
local
bin.
A
Tu
will
give
me
a
token
with
which
this
user
ID
is
logged
in
s.
So
this
is
the
client
token
that
is
generated
by
openshift
and
exchanged
with
my
client
I'll
copy.
This
client
token.
We
will
use
this
to
connect
to
the
registry.
Now
we
will
find
the
container
image
that
we
just
updated
and
we'll
try
to
push
this
container
image
into
the
registry.
So
I'll
say
right.
A
Click
on
this
real-time
image
that
we
just
created
and
I
will
set
the
option,
push
now
it's
trying
to
connect
to
the
registry
and
it
is
trying
to
push
the
debase,
but
this
image
should
be
pushed
into
the
image
stream
in
the
my
project.
You
know
if
I
try
to
push
it
now,
it
will
fail
because
I
didn't
configure
the
registry.
So,
let's
configure
access
to
registry.
A
The
history
IP
address
is
170
2.30,
dot,
1.1,
colon
5,000
username
to
log
in
as
is
developer,
and
the
password
is
the
token
that
we
just
copied
now
that
we
provided
the
credentials.
I
click
on
finish.
This
will
push
the
image
into
registry.
It
just
pushed
it
if
you
notice,
there's
a
quick
push
that
happened
there.
Now
that
the
image
is
pushed,
it
should
be
automatically
updated
because
the
deployment
configuration
would
say
that
hey
they
made
changes
in
the
main
stream
automatically
update
the
application,
so
a
new
part
should
be
now
running.
A
So,
let's
check
the
running
app
show
in
web
browser.
Now
you
can
see
the
change.
It
says
current
date
and
time
is
so-and-so
right.
So
in
this
video
we
have
learned
how
to
create
a
container
image
locally
and
test
it
on
the
local
open
chef
cluster
also
make
changes
to
it
and
redeploy
it
on
the
local,
open
chef
cluster
I
hope
you
enjoyed
this
video
thanks
a
lot
for
watching.