►
Description
Join OpenShift's Developer Experience experts for our regularly scheduled program filled with cloud native, Kubernetes, and OpenShift tips and tricks for developers.
A
B
B
A
B
We
have
a
scenario
on
learn.openshift.com
where
you
can
follow
along
and
try
out
all
of
these
scenarios
and
try
out
all
the
learning
examples.
I
will
post
that
into
chat
in
a
minute,
and
I
also
have
a
couple
other
urls
for
folks.
If
you
are
interested,
let
me
paste
one:
let's
see
figure
out
where
my
mouse
is.
B
B
B
B
B
And
this
desktop
okay,
this
is
odo.dev,
so
there's
some
notes
on
this
site
here
for
installing
odo
you
can
go
to
the
github
repo
and
check
out
issues,
file,
pull
requests
and
and
whatnot
watch
some
of
the
activity
there.
If
you're
interested
we've
got
a
short
video
here
that
you
can
watch
but
I'll
be
doing
a
demo
on
learn.openshift,
and
these
are
probably
more
more
documentation
on
a
couple
of
these
subtopics
how
to
install
what's
the
basic
concepts
and
we'll
cover
most
of
that
today.
B
In
this
this
stream,
you
can
also
there's
more
information.
This
is
about
deploying
a
dev
file.
If
you're
interested
in
a
lot
of
details
around
the
dev
file,
2.0
format,
I
know
there's
a
whole
kind
of
index
of
all
the
attributes
you
can
set
what
the
what
they're
for
what
the
purpose
is
and
how
to
configure
them
on
that
site.
B
I'm
going
to
be
going
to
this
developing
with
odo
on
openshift
learn.openshift.com,
so
you
can
find
it
by
going
to
develop
learn.openshift.com
and
then
clicking
on
this
developing
on
open
shift
shift
and
then
that'll
click
you
into
a
kind
of
subset
of
topics.
There's
one.
That's
underneath
called
developing
with
odo.
That's
the
scenario
we're
gonna
run
today,
and
this
will
give
you
a
should
boot
up
a
vm
that'll.
B
Give
you
one
hour
of
free
access
to
openshift,
so
you
can
awesome,
try
it
out
figure
out
how
it
works
with
your
particular
tool
chain.
So
I'm
going
to
be
using
the
embedded
console,
that's
provided
there,
but
there
are.
You
could
run
the
exact
same
commands
from
your
local
laptop
if
you
had
an
ide
or
some
other
set
of
tooling
that
you
wanted
to
link
into
a
remote
kubernetes
cluster.
B
B
B
Before
I
do
my
big
roll
out,
that's
usually
kind
of
the
end
of
the
line
for
me.
So
this
we're
going
to
try
to
show
you
how
to
do
that.
Whole
inner
loop:
how
to
make
changes
test
them
quickly,
but
test
them
against
a
very
production-like
environment,
so
we'll
be
using
openshift
cluster
to
host
our
microservices
and
we'll
be
dealing
with
multiple
microservice
components.
B
B
We
could
have
a
db
behind
that
as
well,
but
this
is
actually
going
to
connect
to
the
kubernetes
api
and
read
events
from
the
kubernetes
api
as
our
database
or
our
final
data
store
behind
the
web
service
layer,
nice
cool
and
there's
some
nice
kind
of
separation.
The
front
end
app
doesn't
have
direct
access
to
the
you
know
the
api
credentials
that
well,
I
guess
it
can
access
the
same
service
account
token,
so
it
could
potentially
perform
similar
operations.
B
B
Okay,
next
step
here
is
actually
kind
of
like
a
our
back
type
of
use
case.
We
I
set
our
back
end.
Environment
was
designed
to
connect
to
the
kubernetes
api
and
read
events.
So
one
way
of
doing
that,
every
container
in
a
kubernetes
system
is
usually
given
a
some
kind
of
service.
Account
token
that's
mounted
into
their
container.
B
It's
called
the
default
service
account.
So
most
containers
have
this.
You
know
pretty
much.
All
of
them
have
this
default
service
account.
The
default
service
account
might
not
actually
have
any
permissions
granted
to
it
or
it
may
have
root
permissions
cluster
admin
pro.
I'm
not
sure
how
how
locked
down
your
particular
environment
is.
But
openshift
clusters
are
usually
pretty
restrictive
on
an
individual
container
basis.
Unless
it
needs
elevated
privileges,
it
doesn't
have
them
by
default.
B
In
fact,
you
don't
even
have
view
access
on
the
kubernetes
api,
so
this
first
step
is
setting
up
view
access,
there's
a
graphic
on
how
to
do
it
via
the
web
ui,
and
I
also
have
an
example
command.
You
could
run
the
same
thing
from
the
command
line
by
running
this
oc.
Adm
policy
add
role
to
user
and
then
the
role
we
want
to
add
is
view
permission.
B
A
B
That
should
give
our
back
end
access
to
view.
Events
from
the
api
cool
feel
free
to
follow
along
if
you're
interested.
You
can
join
me
at
learn.openshift.com
and
go
through
these
same
steps
on
your
own
and
either
use
the
command
line
like
like
I'm,
using
I'm
going
to
planning
on
adding
some
notes
to
the
content
later
today
to
kind
of
make
that
command
line,
option
explicitly
noted
in
the
in
the
content
here.
B
So
if
you
come
through
later
you'll
you'll
see
that
alternative
option,
so
next
step
is
actually
setting
up
our
back
end
service.
The
assumption
with
this
odo
setup
is
that
you
possibly
already
have
a
tool
chain
that
you
have
found
a
lot
of
value
in
in
the
past.
Maybe
you
have
an
ide
that
has
a
particular
set
of
plugins
or
other
features
that
allow
you
to
really
quickly
iterate,
on
whatever
source
code.
You're
working
with
we'll
take
a
look
at
the
odo
catalog,
and
this
should
pull
information
from
openshift
to
see.
B
B
This
wildfly
bootable
jar
might
be
one
that
that
I
swapped
to
or
let's
see,
there's
a
spring
boot
option
in
here.
So
I
should
try
one
of
those
for
the
back
end
component,
but
today
I'm
going
to
use
the
supported
java
s2i
image
and
I
think
I
had
selected
open
jdk
11
on
ubi
8.,
we'll
take
a
look
see
what
the
what
the
text
says
here,
there's
also
a
node.js
source
to
image,
build
that
you
can
use
in
today's
demo.
B
B
B
I
did
a
couple
dry
runs
last
night,
a
couple
of
them
broke.
A
couple
of
them
succeeded.
Well,
actually
it
was
me
just
experimenting
with
different
command
line,
syntax
and
finding
out
what
are
the
edge
cases.
So
this
may
be
my
if
it
works
flawlessly
with
no
errors.
This
will
be
my
first
flawless
pass
through
so
which
means.
A
B
B
B
B
B
B
B
While
this
was
being
created,
I
guess
there's
some
status
coming
back
here,
but
you
can
also
run
odo
log
dash
f
in
order
to
follow
the
logs
from
your
command
line.
So
if
you
wanted
to
get
access
to
your
logs
to
your
server
output,
you're,
not
running
it
locally
anymore,
you're
running
it
in
a
hosted
environment
which
should
give
you
more
production-like
feedback.
B
B
A
B
A
A
A
B
A
B
B
The
config.yaml
is
still
in
our
backend
folder,
so
it's
in
a
different
directory
and
whenever
we
change
directories
using
odo,
it's
going
to
try
to
help
switch
context
for
us
and
make
sure
that
next
time
we
run
odo
push
I'm
pushing
my
node.js
source
code
instead
of
my
jar
file.
So
just
changing
directory
should
be
all
I
need
in
order
to
to
do
that,
step.
I'll
list,
the
files
here
and
we
can
see-
we've
got
a
package.json.
B
I
can
run
this
oto
create
node.js
frontend,
and
this
is
using
the
s2i
flag.
This
would
use
the
this
will
totally
work
using
our
source
to
image
solution,
but
I
have
also
recently
added
a
devfile.yaml
to
the
repo.
If
you
don't
have
a
devfile.yaml
in
your
repo.
Currently,
you
can
generate
one
by
running
odo,
create
nodejs
frontend
without
the
s2i
flag
and
that'll
print
a
new
dev
file
for
you,
I'm
not
going
to
run
that
here,
because
it'll
stomp
on
my
existing
dev
file
that
I've
added
to
the
repo
and
I
made
one
small
modification.
B
B
So,
there's
a
bunch
of
basically
commands
that
this
dev
file
has
staged
up
that
you
could
run
this
first.
One
is
doing
the
install
and
kind
of
building
the
base
of
the
application.
This
next
one
is
going
to
boot
the
application
and
run
it
there's
a
couple
other
options
in
here
and
currently
we
do
not
have
anything
in
the
here's,
the
components.
This
is
the
front-end
component
and
there's
a
single
container
in
this
front-end
component.
B
B
B
B
B
Okay,
so
this
is
going
to
this-
should
be
a
little
bit
different
than
the
output.
We're
expecting
with
the
source
to
image
style,
build
source
to
image
is
going
to
do
a
slightly
different
line
of
work
here.
This
is
going
to
start
with
validating
the
dev
file
that
we've
added
on
our
own,
making
sure
that
it's
compatible,
that
it's
a
version
2.0
or
if,
if
it's
a
version,
1.0
dev
file,
then
it
can
maybe
make
some
accommodations
for
the
older
older
file
format
as
well.
That
should
start
up
our
node.js
process.
B
So
here
we
go
the
node.js
containers
already
up
and
running
one
thing
we
can
note
in
the
let's
jump
in
and
take
a
look
at
the
logs.
We
showed
how
to
view
logs
from
the
command
line
before,
but
you
can
also
access
the
logs
via
the
web
terminal,
and
you
could
see
there's
an
error
printed
in
here.
This
one
is
actually
kind
of
intended.
This
app
is
expected
to
have
some
amount
of
environment
variables
to
let
it
know
how
to
contact
the
backend
service.
B
We
could
potentially
have
it
read
this
information
about
what
other
services
are
available.
They
could
maybe
ask
the
kubernetes
api
what
other
services
are
available,
but
then
you
have
an
application.
That's
more
kind
of
tightly
bound
to
only
running
on
kubernetes
clusters,
which
is
probably
a
safe
assumption,
but
you
know
why
tie
it
to
really
any
platform
if
you
can
avoid
it
environment
variables
are
a
clean
and
easy
way
to
configure
how
you're
going
to
connect
to
another
service.
B
Awesome
you
can
also
well
while
I'm
on
and
pop
over
okay.
While
I'm
on
this,
you
can
also
access
the
live
terminal.
So
this
is
kind
of
nice.
I
could
ask,
who
am
I?
I've
got
a
really
high
random
user
id
and
I
can
see
process.
One
is
looks
like
we've
got
supervisor
d
as
our
primary
process,
so
I
think
that
should
automatically
restart
our
app
on
change
or
or
if
it
crashes,
okay,
so
next
step,
we
have
our
front
end
app.
B
We
found
our
config
error
in
the
logs,
so
next
step
is
setting
the
config.
We
can
do
that
via
odo.
We
can
also
manipulate
the
dev
file
or
another
there's
a
env
file.
So
let
me
do
cat,
let's
see
if
the
changes
are
in
the
dev
file,
yet
yeah
it
looks
like
already.
We
have
these
environment
keys
that
were
added
to
the
dev
file
and
then
we
can
push
those
keys
on
up
by
running
odo
push
and
I'm
gonna.
Add
one
extra
flag
here.
Auto
push.
B
You
can
add,
odo
push
dash
dash
config.
This
will
do
a
slightly
faster
push.
So
if
you're,
really
in
a
in
a
hurry
to
get
your
work
done
and
you're
only
pushing
configuration
changes
photo
push
dash
dash
config
might
work
a
little
bit
quicker
for
you
still
taking
a
little
bit
of
time
here,
but
anyway,
that
should
fix
our
issue
with
the
back-end
service.
Since
we're
publishing
new
environment
keys
into
the
environment,
the
container
will
need
to
be
restarted
in
order
to
read
those
new
environment
keys.
B
So
that's
probably
what
our
additional
kind
of
pause
there
is.
Maybe
waiting
for
that
container
to
run
its
reboot
cycle
last
step
is
going
to
be.
Let's
see,
let's
go
back
to
the
topology
view
and
see
where
we're
at
so
we
have
our
two
component
services,
they're
shown
as
grouped
together
in
this
application
grouping
to
kind
of
indicate
they're
a
single
app.
B
We
have
a
nice
kind
of
delete
to
application
or
add
to
application
grouping
control
from
the
ui
to
mirror
a
little
bit
of
what
you
can
do
with
odo
on
the
command
line,
and
this
container
right
now,
where
I
think
we're
ready
to
connect
to
it
and
run
our
tests.
So,
let's
go
back
to
the
command
line.
The
command
for
this
is
going
to
be
odo.
Url
create
front
end,
since
we
want
to
add
to
our
front
end
component
and
then
we're
going
to
publish
port
8080
externally.
B
I
only
had
view
access
if
we
were
to
give
it
edit
access.
Instead,
then,
when
we
click
on
these
resources,
it'll
actually
do
a
delete,
and
since
these
resources
are
used
to
host
the
game,
the
game
might
break.
So
you
you
typically
don't
want
to
give
it
edit
access.
Unless
you
had
assets
in
the
game
that
you
were
prepared
to,
you
know
were
replicated
like
a
pod.
You
know
you
could
set
the
replication
to
five
and
then
blast
as
many
pods
as
you
like.
B
B
A
very,
very
loud
feedback
from
the
app
nice
yeah
ooh
I
need
to.
I
need
to
change
that
demo,
but
anyway,
that's
our
that's
our
setup
with
a
back-end
component
that
can
read
from
the
api
potentially
modify
content
on
the
api
as
well,
and
let's
see
now
that
we
have
the
whole
front
end
back
end
data
store
all
set
up
and
implemented
in
our
production
context.
B
Now
I
want
to
flip
back
to
my
development
tool
chain
right.
I
want
to
see
what
changes
can
I
make
without
having
to
stop
and
make
commits
or
stop
all
my
work
and
do
a
deployment
and
and
or
wait
for
a
ci
build
or
you
know
if
I
want
really
quick
iterative
feedback
on
how
changes
to
either
the
front
end
or
back
end
are
going
to
impact
a
system
after
I
make
my
commits
this
gives
me
a
workflow
where
those
commits
are
now
decoupled.
B
B
We
were
using
supervisor
to
host
this
process,
but
if
you
were
coding
with
a
react
or
some
more
responsive
development
kit,
it
might
automatically
promote
the
changes
right
to
your
browser
using
a
websocket.
So
you
don't
even
need
to
hit
the
reload
button
potentially
right,
but
that
kind
of
depends
on
your
development
stack
and
how
close
to
a
production
environment.
Are
you
expecting
in
your
in
your
hosted
environment,
right
nice,
but
depending
on
how
how
you
have
things
set
up?
B
A
B
But
more
neutral,
also
kind
of
well,
I
think
part
of
the
nice
feature
of
the
the
positive
spin
I
can
put
on
odo.
I
think
it
you
should
be
able
to
use
it
in
fully
neutral
environments,
any
kubernetes
or
open
shift,
so
it
should
work
as
a
as
a
somewhat
of
a
feature
should
be
very
feature
complete
in
terms
of
what
scaffold
offers.
B
B
B
So
I
think
that
is
just
about
it
for
the
demo
portion
I
have.
Hopefully
that
shows
how
you
can
make
rapid
changes.
I
could
also
you
know,
potentially
pop
into
a
terminal,
make
changes
directly.
That's
not
the
best
way
to
do
it.
Another
kind
of
decorator
you
can
have
on
here.
We
have
this
link
to
open
the
url.
B
B
Let
me
unselect
operator
backed
so
here's
a
list
of
language
support.
A
portion
of
this
is
going
to
be
using
source
to
image.
So
I
showed
you
how
the
odo
dash
dash
s2i
flag
can
set
up
source
to
image.
You
can
also
use
code
ready
workspaces
with
source
to
image
builds
as
well,
so
most
of
these
they're
marked
template
or
are
going
to
be
using
probably
a
template.
That's
wrapping
a
source
to
image
builder
image
yeah.
B
This
template
is
going
to
combine
node.js
and
postgres
together
and
there's
a
couple
different
configurations
of
that
with
a
ephemeral
data
store
or
a
actual
persistent
disk
right
so
and
these
ones
are
not
operator
backed.
So
these
are
our
kind
of
older
postgres
installs,
but
just
shows
how
to
quickly
template
out.
B
B
B
Yeah
yeah,
so
this
list,
ruby,
python,
php,
perl
node.js.
You
have
the
language
and
then
also
which
image
tag,
and
usually
we
put
the
different
kind
of
releases
or
runtime
versions
for
that
language
as
tags
on
one
image
until
things
get
too
complicated,
and
then
we
switch
to
a
different
image
name,
you
know,
but
there's
also
these
options
up
here:
python
django
this
node.js
option.
These
are
using
the
new
dev
files
instead
of
sourced
or
older
sourced
image
style.
B
B
B
B
I
know
there's
somewhere
right
here.
We
go
deploying
your
first
dev
file
and
ingress
setup
is
part
of
the
recipe
here.
This
setup
is
like,
like
we
said
this,
should
support
openshift
and
just
vanilla
kubernetes,
so
you
could
see
in
the
ingress
examples
we're
actually
using
minikube
instead
of
an
open
shift
environment.
B
B
B
B
B
So
when
we're
running
a
build
here,
we're
really
basically
just
doing
like
a
like
a
docker
copy,
or
you
know
copying
in
a
new
layer
on
top
of
a
pre-existing
node.js
container
that
node.js
container,
that
openshift
provides
has
already
been
adapted
to
work
really
really
well
with
se,
linux
we've
taken
additional
precautions
to
make
sure
like
when
I
ran.
Who
am
I
and
it
returned
a
high
number.
B
B
B
B
B
A
A
B
A
B
B
B
A
A
B
A
B
B
B
B
B
B
Got
the
the
new
edit
source
link
from
git,
but
it
looks
like
it's
pretty
easy
to
add
annotations
in
order
to
mark
up
some
of
these
features.
I
know
we
have
passed
some
office
hours
sessions
that
focus
a
little
bit
more
closely
on
code
ready
workspaces.
Those
will
tell
you
exactly
how
to
set
up
the
linkage
for
our
purposes.
B
Today
we
were
expecting
the
back
end
to
be
producing
jar
files,
somehow
maybe
via
a
thick
ide
that
I
have
running
on
my
laptop
and
the
front
end
was
going
to
be
a
light
command
line,
edited
node.js
application.
I
usually
do
those
with
vi,
but
you
know
theoretically
either
one
of
these
environments
could
also
be
accessed
via
a
hosted
ide,
and
then
I
can
have
all
of
my
tool
chain
available
on
demand
hosted
in
the
cloud.