►
Description
Get your espresso ready for the EMEA OpenShift Coffee Break to follow along with Alex Groom, Carlos Vicens Alonso (@_cvicens), and Madou Coulibaly (@madou_coulibaly) talking about how Java Developers can improve their developer experience with the Inner Loop and Outer Loop on top of OpenShift.
A
All
right
welcome
to
this
other
episode
of
the
open
shift
coffee
break
good
morning,
everyone.
I
hope
you
have
your
good
shot
of
coffee
together
with
you,
and
today
we
will
do
another
episode
of
the
openshift
coffee
break.
We
may
have
the
wrong
title
on
twitch
and
youtube,
but
it's
fine
today,
we're
gonna
fix
it
today.
We're
gonna
talk
about
the
cloud
native
inner
and
outer
loop
together
with
all
our
guests,
so
I
leave
the
word
to
jafar
to
present
everyone.
B
B
C
D
E
B
B
C
Okay,
I
guess
I
can
start
with
this.
I
mean
we
talk
about
loops
here,
really
is
developers
strangely
enough,
spend
a
lot
of
their
time
doing
the
same
thing
over
and
over
again
as
they
slowly
build
out
an
application
they'll.
You
know,
for
example,
the
inner
loop
they'll
write
a
bit
of
code
they'll
test
that
bit
of
code
locally,
when
they're
happy
with
it
and
they're
satisfied
that
it's
working
functionally,
they
will,
maybe
you
know,
add
a
bit
more
and
then
go
around
that
loop
again
building
stuff
debugging.
C
It
writing
a
bit
more
code,
so
they
are
continually
working
in
a
loop.
Okay.
The
thing
they're
building
is
changing
each
time,
but
they're
doing
much
much
the
same
task
and
as
they
get
to
the
end
of
that
loop,
they
will
actually
then
commit
those
changes,
the
stuff
that
they've
done
into
source
control
and
that's
typically,
how
we
think
of
the
inner
loop.
C
It's
that
really
tight
circle
of
work,
the
developer
is
doing,
and
if
that
loop
isn't
very
tight
and
efficient,
then
the
developer
can
spend
an
awful
lot
of
time
waiting
around
for
their
systems
to
compile
build,
set
up.
Install
whatever
it
happens
to
be
when
it's
actually
more
productive,
if
they're,
actually
thinking
about
problems
writing
code,
whatever
it
happens
to
be
so,
the
longer
a
developer
has
to
wait
to
test
the
thing
that
they've
just
thought
of
the
code.
They've
just
written
I'll,
give
you
the
less
efficient
they
get.
C
E
E
So
after
that,
so
we
enter
into
the
outer
loop
and
the
uterus
is
mainly
defined
by
all
the
automation
and
all
the
process,
so
everything
that
you
have
around
the
cicd
pipeline,
so
a
continuous
integration,
continuous
delivery.
In
order
to
be
able
to
build
your
final
artifact,
your
final
binary
that
you
are
going
to
promote
from
a
different
environment,
so
development,
the
test
environment,
your
qa,
the
staging
environment
until
the
production
environment,
basically
so
the
main
difference
between
outdoor
loop
and
inner
loop.
B
D
Exactly
I
think,
alex
introduced
this
this
situation.
So
what
you
want
us
as
a
developer
is
change.
The
code
see
results,
change
the
currency
results,
and
when
you
try
to
do
this
with
kubernetes,
then
you
have
a
problem,
because
you
need
to
wait
until
everything
is
deployed
right
also.
I
think
the
idea
is
just
to
find
how
to
reduce
the
amount
of
time
you
need
to
see
results
so,
and
there
are
several
ways
to
do
this.
D
B
D
Perfect.
Okay,
so
this
is
a
spoonboot
application.
I
have
deployed
this
application
before
we
started
the
session.
It's
a
very
simple
application,
where
you
can
just
basically
see
rows
coming
from
a
non-local
database.
So
database
is
a
database
that
I'm
I'm
sharing
across
the
cluster.
You
need
to
think
about
this
as
an
external
oracle
database
that
you
want.
Okay,
then
what
I'm
going
to
do
is
using
telepresence
that
a
person
says
well.
I
think
I'm
going
to
explain
that
later
the
magic.
I
want
to
see
the
magic
and.
F
D
Just
want
to
see
the
magic
exactly
just
the
magic
for
now.
So
let
me
do
this.
So
what
if
I
do
something
such
as
creating
a
vpn,
something
like
a
vpn
from
my
laptop
and
I
deploy
the
code
in
my
laptop,
I
use
my
laptop
to
run
the
java
code
and
swap
this
deployment
with
a
proxy.
Basically,
that's
what
I'm
gonna
do
when
you
do
this.
You
need
some
some
requirements
in
in
the
in
the
back
end,
because
you
need
some
permissions
so
that
you
can
deploy
a
specific
proxy.
C
Yeah,
it's
it's
worth
reminding
people
at
this
time.
Our
definition
between
inner
and
outer
loop
is
that
code
commit
and,
as
applications
have
gotten
more
complicated,
we're
discovering
that
actually
openshift
is
actually
becoming
part
of
the
inner
loop.
I
mean
the
original
assumption
might
have
been.
C
Half
of
the
microservices
already
exists
in
openshift,
and
the
piece
you're
working
in
is
actually
on
your
code
bench
and
we
end
up
having
to
integrate
or
spend
our
time
integrating
with
the
code
with
writing
and
openshift
itself
and
then
later
on.
We
will
then
actually
commit
the
code
and
that
will
close
the
inner
loop,
but
we
still
need
to
be
as
efficient
as
possible
exactly.
D
No,
no,
I
was
just
about
to
say
that
it's
true,
so
if,
for
instance,
you
want
to
to
create
just
this
very
simple
microservice,
it's
not
connected
to
nothing.
You
don't
need
this,
so
as
alex
was
suggested.
Maybe
there
are
external
services
where
things
that
you
cannot
reach
from
your
laptop,
but
those
things
are
reachable
from
the
cluster.
So
this
is
basically
the
situation
when
maybe
telepresence
is
something
that
could
help
you
with
the
inner
loop.
Okay.
D
D
All
old-fashioned
application,
but
it's
very
useful
when
you
try
to
do
these
things
so
now
I
test,
and
you
see
that
I
can
reach
the
data,
so
I
can.
I
can
start
talking
to
the
database
directly
and
that's
something
that
is
not
really
deployed
in
in
kubernetes
and
then
it's
an
external
database,
I'm
using
this
external
database
with
a
service
of
type
external
name.
D
F
D
You
need
to
pay
attention
is
that
I'm
providing
some
environment
variables
because
I'm
running
the
application
directly
in
my
laptop.
So
it's
not
a
kubernetes
deployment.
So
there
are
no
environment
variables
injected
by
default,
so
I'm
putting
all
those
environment
variables
before
I
run
the
the
java
code
in
my
machine
and
hopefully
it
will
start
up
and
we
can
run
the
the
applications
locally
by
talking
to
the
database,
which
is
deployed
in
kubernetes
or
through
current,
so
just
people.
This
kind
of
lazy
now.
D
It's
about
okay.
There
we
go
so
now
this
springboard
run
is
connected
to
the
database.
Hopefully,
so
before
I
try
to
do
anything,
I
should
check
that
localhost
is
working,
it's
working
and
it's
talking
to
exactly
the
same
database,
and
I
know
this
because
if
I
run
this
url
this
is
an
external
url.
This
is
the
same
external
journal,
and
this
is
very,
very,
very
handy
because
I
mean
localhost
is
very,
very
fun.
It's
normal,
it's
the
normal
stuff.
We
do
so.
If
I
change
something
here,
let's
go
to
the
index.
D
C
D
I,
if
I
do
exactly
the
same,
you
see
from
twitch,
but
the
services
I'm
talking
to
from
my
java
code
are
in
kubernetes,
okay,
okay,
so
if
I
go
here-
and
I
use
this
url-
should
it
work
because
you
see
the
deployment
has
been
swapped,
so
this
deployment
has
been
has
been
scaled
down
to
zero,
I'm
using
the
proxy.
So
the
java
code
is
in
my
machine,
but
this
url
is
is
a
it's
an
ingress,
it's
a
route
to
openshift
right.
Should
it
work?
D
C
C
To
get
services
that
are
too
big
to
run
locally.
Imagine
that
database
you've
got
about
three
entries
in
that
database.
Imagine
you
had
30
000
entries
or
maybe
3
million
entries.
Then
it's
not
something
you
would
want
to
bring
down
to
your
laptop
and
run.
You
absolutely
want
to
remote
it
and
connect
to
it
in
a
in
a
in
an
easy
way.
So
yeah.
B
And
so
also
guys,
what
you
are
saying
is
that,
with
with
this
type
of
setup,
we
are
able
to
share
environments,
so
we
don't
have
to
duplicate
them
for
every
new
developer
or
every
every
new
project.
So
we
have
remote
shared
environment
that
benefit
from
all
the
power
and
the
resources
of
the
cluster,
which
is
basically
sort
of
unlimited
compared
to
what
you
can
have
on
your
laptop,
and
you
are
also
compliant
to
all
the
security
constraints.
B
C
Right
and
that's
pretty
important
because
the
complexity
of
deployment,
we
can
now
actually
practice
deployment
while
we're
developing
and
that's
actually
very
important
because
it
means
the
developer
is
much
more
aware
of
what
the
final
state
is
going
to
look
like,
and
the
sooner
you
expose
the
developer
to
the
constraints
or
the
the
benefits.
Perhaps
of
that
final
deployment,
the
better.
It
is
because
their
code
will
inevitably
be
tested
and
will
work
better
in
that
final
scenario,
because
it's
what
they've
been
using
up
until
that
point.
C
But
the
key
thing
here
is
is
if
you're
going
to
get
developers
to
use
a
deployment
system.
It
has
to
be
easy
to
use
and
fast
to
use
if
it
starts
delaying
them
or
slowing
them
down
significantly
in
that
in
a
loop
that
we
want
to
be
as
efficient
as
possible.
Then
they're
going
to
reject
it
and
they're
just
going
to
move
back,
doing
everything
locally
on
their
own
workbench,
because
it's
the
fastest
way
to
write
code.
C
So
it's
always
a
balance
with
developers,
whether
they
do
stuff
locally
or
whether
they
do
stuff
remotely
and
openshift
brings
a
number
of
decisions
to
be
made.
Actually
because,
as
I
said,
as
your
application
gets
more
and
more
complicated,
more
and
more
micro
services
involved,
it
actually
becomes
harder
and
harder
to
run
this
thing
locally
reliably
when
actually
the
reliable
way
to
run.
It
is
in
an
openshift
cluster,
because
that's
someone's
already
done
the
work
to
define
how
to
deploy
it
and
the
relationship
between
those
services,
and
you
have
to
end
up
duplicating
that.
C
B
Okay,
thank
you
very
much,
carlos
and
everyone,
the
very
interesting
ways
of
improving
the
the
developer
experience
and
inner
loop,
while
still
leveraging
all
the
the
power
of
the
openshift
remote
platform
in
in
in
in
your
situation.
Okay,
thanks!
So
anything
anything
else
you
wanted
to
show
us
guys.
So
is
this
the
only
way
to
do
inner
loop
did
you
have
other
treats
for
us
regarding
this
topic,
because
I've
heard
about
several
other
ways
we
can.
A
C
C
Hopefully,
what
you
can
see
now
is
it's
basically
an
ide.
This
happens
to
be
code
ready
workspaces.
I've
just
happened
to
use
that
because
it
was
easy.
I
can
put
everything
in
a
browser
for
this
particular
demo
today,
but
what
I'm
trying
to
demonstrate
here
is
developer
busy
in
their
inner
loop,
they're
writing
code,
they're
testing
code,
they're
building
a
very
simple
rest.
B
C
What
this
environment
is,
which,
if
you
imagine
it
below
this,
this
chrome
tab,
is
our
code
ready
workspaces,
development,
environment.
This
is
something
that's
actually
running
in
openshift.
We
use
it
a
lot
for
demos.
It
is
essentially
like
a
vs
code
environment,
not
just
very
similar
to
what
carlos
was
showing
us
shortly
written
recently,
except
it
runs
in
the
browser.
C
Your
actual
workspace
is
actually
running
in
open
shift,
so
your
code
and
all
your
builds
and
all
your
storage
is
running
in
the
openshift
cluster
and
all
the
browser
is
doing
is
projecting
the
front
end.
It's
just
showing
you
the
you
know
the
graphics
and
the
code.
That's
going
on
what
this
means
is
that
all
the
code
is
stored,
remotely
there's
nothing
local
on
my
laptop,
so
it's
actually
a
very
secure
way
of
writing
code.
But
that's
not
really
the
issue
we're
trying
to
talk
about
today.
C
F
C
B
C
Video
previews
is
that
over
there
just
put
it
yeah
okay.
So
what
I've
got
here
is
to
test
the
microservice.
It's
got
a
very
simple
front
end,
so
I
can
go
in
here
and
test,
and
this
makes
one
api
call.
It's
looking
up
this
item
returning
this
value
35.
So
that's
all
very
simple.
If
I
want
to
make
a
code
change,
I
can
show
you
how
to
do
that
quite
easily.
So
if
I
go
in
and
tweak
the
quantity
class,
so
it
returns
maybe
100
times
the
same
values.
I
make
the
code
change.
C
I
can
refresh
the
tester
and
what
it's
doing
in
the
background
is
reloading
that
code
recompiling.
It
rebuilding
it
in
a
very
small
number
of
seconds,
and
I
can
immediately
test
it
and
strangely
enough,
I've
hit
the
wrong
one,
which
is
set
quantity.
I
need
to
do
the
get
quantity,
one
that's
what
has
maybe
changed.
Let's
try
that
again
do
the
same
thing.
B
C
Literally
seconds
you
can
imagine
if
it
takes
five
minutes
to
go
off
and
do
that
maven
build
again.
I
would
be
you
know
either
drinking
a
lot
of
coffee
or
tearing
out
what
little
hair
I've
got
left,
but
I
can
make
a
co
changing
within
two
or
three
seconds.
I
get
the
response
back
so
by
changing
the
quantity
to
times
100,
I'm
now
getting
3
500
back
as
a
result.
What.
C
B
C
C
It
actually
sits
within
a
group
of
other
microservices
and
what
I've
done
earlier,
because
it
takes
a
moment
or
two
is
I've
gone
over
to
openshift
and
I've
actually
deployed
this
complex
series
of
microservices
where
I've
got
a
front
end
some
orchestration
another
springboot
app,
and
this
is
my
application-
that
I've
been
working
on
this
one
here
and
it's
using
a
database
in
my
openshift
environment.
Now.
What
I
want
to
do
is
test
it
and
develop
my
code.
While
it's
live
in
my
openshift
cluster,
so
that's,
I
think,
that's
the
next
thing.
C
It's
a
dev
environment,
yes,
but
I
want
to
make
changes
to
the
version
that's
running
in
the
openshift
cluster,
because
I
want
to
test
it
in
its
real
environment
in
situ.
It's
using
a
database,
it's
working
alongside
other
microservices,
so
I'd
like
to
test
it
and
make
code
changes
while
it's
in
its
proper
place,
not
just
running
on
my
workbench,
which
is
what
I
was
doing
previously,
which
is
a
perhaps
a
bit
artificial.
C
So
I
want
to
try
and
do
this
for
real.
So
what
I
have
to
do
is
you've
seen
the
dynamic
aspect
that
caucus
has
when
it's
running
in
the
ide,
but
we
can
split
those
two
things
apart
and
actually
run
a
piece
in
openshift
that
will
listen
to
changes
and
detect
those
changes
in
the
ide,
and
we
will
send
those
changes
across
to
the
openshift
cluster
and
update
the
running
version
in
openshift,
and
to
do
that,
I
need
to
run
a
slightly
different
build
locally.
C
So
if
you
just,
let
me
find
that
and
let
this
start
up,
but
we
should
be
able
to
do
the
same
thing.
What
my
ide
is
now
going
to
do
once
it's
done
this
build,
it
will
be
connecting
up
to
the
openshift
cluster
and,
as
I
make
code
changes
they'll
get
sent
across
a
http
link
into
that
running
application
and
update
it
exactly
as
we're
doing
locally,
except
we're
now
doing
it
across
a
network
link
now
clearly.
C
This
is
what
my
app
looks
like
in
fact,
let's
just
in
case
there's
any
doubt.
So,
let's
start
from
the
beginning
here
and
start
from
my
openshift
cluster
and
bring
up
my
my
app
have
you
noticed
that
all
these
quantities
are
now
that
35
or
3500
is
now
actually
being
displayed
in
the
web
ui
as
a
stock
quantity
as
part
of
this
web
interface,
so
these
3500s
1200s?
These
are
all
because
of
that
100
multiplier,
I've
added,
which
is
clearly
wrong.
I
don't
want
that
anymore.
C
So,
if
I
go
back
to
my
code,
I
can
take
that
out
now
go
back
to
my
open
shift
application.
That's
running
there
refresh
that
this
takes
a
little
bit
longer,
maybe
five
or
six
seconds
to
actually
refresh,
because
it
has
a
little
bit
more
work
to
do,
and
here
we
see,
let
me
make
this
a
little
bit
bigger
for
you.
These
numbers
are
now
35
12,
45
etcetera,
which
is
the
correct
number.
So.
C
B
C
It
detects
that
code
change
repackages,
that
code
change,
sends
it
across
to
openshift
and
puts
it
into
that
container
where
it's
running
and
it
doesn't
need
to
build
a
container
or
restart
the
container.
So
here
we
are
350.,
so
you
can.
This
is
this
is
like
a
absolutely
blurring
the
lines
we
don't
want
to
say
in
a
loop
means:
don't
use
open
shift.
We.
C
Is
everything
you
do
before
you
commit
your
code
to
source
control
git,
probably,
and
what
we're
talking
about
here
is
making
openshift
part
of
that
development
environment,
because
it
has
an
awful
lot
of
benefits
for
doing
so.
This
is
a
a
very
interesting
example
of
where
the
fear
of
oh
having
to
containerize
up
and
and
put
my
application
in
openshift
is
going
to
slow
my
development
down.
C
Absolutely
not
you
can
carry
on
making
code
changes,
updating
your
code
almost
as
quickly
as
you
would,
if
you're
doing
it
locally
with
caucus
and
to
get
an
update
within
four
or
five
seconds.
That's
like
no
js!
That's
like
javascript
speed
and
it's
something
almost
unheard
of
in
the
java
environment,
which
would
normally
be
two
or
three
minutes
to
build
your
jar
file
and
then
another
couple
of
minutes
to
turn
that
into
a
container
and
deploy
it.
So
maybe
five
minutes
between
each
code
change
we're
talking
here
about
five
seconds
between
each
code
change.
E
B
A
But
following
if
you
have
any
any
question,
please
send
it
in
the
chat,
so
we
will
try
to
answer
your
question
from
the
chat
here
in
twitch
and
youtube
or
facebook
or
everyone
who
is
listening
and
in
the
while
we
will
go
to
the
other
demo
right
wow
such
a
warning.
I
haven't
seen
three
live
demos
at
10
a.m.
Faults.
I
need
another
coffee
well,.
B
All
right
so
so
who's
next
for
our,
are
we
still
in
the
inner
loop
or
are
we
transitioning
to
the
outer
loop?
So
maybe
before
we
transition
to
the
outer
loop,
can
you
tell
us
a
bit
more
about
those
underlying
technologies
or
tools
that
you
have
been
using
alex?
I
saw
that
you've
been
doing
a
maven
compiled
with
remote
browser.
C
C
Now,
once
you
get
on
to
openshift,
we'll
see
using
things
like
databases
and
various
different
frameworks,
each
each
microservice
actually
uses
a
different
framework,
but
the
one
that
I
was
doing
the
live
debugging
on
the
live
coding
with
is
caucus.
On
the
other
hand,
there's
no
there's
no
limit
with
openshift.
I've
got
one
of
my
components:
was.net
another
was
spring
boot.
The
web
ui
is
node.js,
so
it
just
indicates
that
there
are
there's
kind
of
no
limitations
here.
What
you
can
do
with
openshift,
but
the
actual
live
live
coding
is
a
caucus
feature.
C
So
that's
a
kind
of
special
speciality,
but
that's
that's
really.
All
I've
been
using
today,
as
part
of
my
my
demo,
carlos,
I
think
actually
is
using
some
additional
features,
he's
using
something
called
telepresence,
and
maybe
he
can
just
talk
you
through
that
and
what
he
actually
needs
to
to
get
that
running,
because
I
think
you
need
to
install
that
is
that
true
cars.
E
E
Basically,
there
is
one
question
and
one
main
question
that
we
need
to
ask
is
why
you
will
have
why
it
will
be
good
for
you
as
a
developer,
to
be
able
to
use,
let's
say,
openshift
or
kubernetes
when
you're
developing
your
application,
so
the
main
aspect
around
that
and
why
we
would
like
to
do.
That
is
really
to
be
able
for
you
to
develop
a
better
application.
So
say:
yes,
better
application!
Why?
That's?
Because,
as
a
developer,
there
is
always
things
that
I
was
fighting
but
say
in
my
past
career.
E
It's
really
the
fact
that
some
time
when
I
push
a
code
into
a
git
repository,
I
created
and
generated
some
bugs
so
linked
to
not
the
code,
not
the
business
logic
that
I
implement,
but
because
there
is
some
infrastructure,
a
problem,
because
my
application
didn't
get,
for
example,
a
specific
dependency,
because
I
just
left
one
bad
parameters
inside
the
application
and
so
on,
and
that
it's
really
really.
It's
really
really
frustrated
as
a
developer.
E
It's
really
that
the
fact
that
I
don't
have
the
right
environment
to
be
sure
that
in
my
inner
loop,
when
I
have
let's
say
all
this
flexibility
way,
the
code
is
mine.
I
haven't
published
the
code,
so
I
didn't
have
let's
say
all
the
resources
that
I
have
to
be
able
to
be
sure
that
the
application
that
I
have,
I
will
be
able
to
test
it
into
the
same
environment.
E
Then
the
application
will
be
used
into
production.
So
that's.
Why
that
we
do
a
lot
of
work
here
in
order
to
be
able
to
add
to
add
these
openshifts
as
a
developer
inside
the
developer
phase,
because
I
think
it's
not
only
for
the
developer,
but
also
for
later
your
project
manager,
because
I
don't
know
if
you
are
familiar
with
the
concept
about
the
cost
of
a
software
bug.
So
there
is
a
concept
with
the
fact
that
if
you
are,
let's
say
that
you
have
a
bug
into
your
your
application.
E
If
you
find
the
bug,
let's
say
during
the
development
phase,
so
this
blog,
this
bug
is
going
to
cost,
let's
say
yeah,
so
100
euro
right,
you
find
the
bug,
so
you
find
it
into
your
development,
so
it
costs
about
100
euro.
After
you
push
your
codes
into
a
git
repository,
and
you
find
this
this
bug
into
your
qa,
for
example,
this
bug
is
going
to
cost
you
one
for
1
000
euro,
so.
E
You
can
exactly,
and
you
continue
to
that
until
the
production,
because,
of
course,
if
you
have
a
bug
into
your
production,
so
I
mean
the
impact
will
be
much
more
much
more
bigger
because
it's
in
production.
So
your
customers
see
the
bug.
So
you
are
going
to
have
a
bad,
so
a
very
bad
feedback.
They
are
going
to
stop
using
the
application.
They
are
going
to
post
everything
into
the
social
network
and
so
on.
E
E
I
think
it's
not
an
important
market,
something
that
you
can,
that
you
can
avoid,
but
really
be
able
and
give
the
ability
for
your
developer
to
to
to
use
the
production
environment
or,
like
so
the
same
production
environment,
to
be
able
so
to
be
comfortable
and
to
be
sure
that
when
they
are
going
to
push
a
code
into
a
git
repository,
everything
would
be.
Everything
will
be
perfect
and
and
clear.
B
E
Yeah
yeah-
it's
really
too
yes
to
to
enable
this.
Yes,
the
capability,
really
to
to
say
that
it's
not
that
I'm
going
like,
for
example,
to
test
my
code
when
I'm
going
to
production,
or
I'm
just
only
to
test
the
code
when
it's
going
to
go
through
my
ci
cd
pipeline,
but
I'm
going
to
really
test
the
code
so
from
the
first
prompt.
So
when
I
starting
to
to
enter
and
to
implement
my
business
logic,
I
will
have
all
the
resources
to
be
able
to
be
sure
that
my
code
is
working.
E
So
technically
it's
working
well
on
the
environment
and
after
that,
what
you
want
to
have.
Basically,
when
you
have
a
code,
so
it's
better,
but
it's
better.
It's
let's
say
more
relevant
to
be
able
to
have
a
code
around
your
business
logic,
because
it's
what
you're
trying
to
implement
instead
of
having
your
code,
because
I
don't
know,
you
forget
to
add
any
specific,
for
example,
cloud
libraries
that
you
need
to
to
to
run
your
your
application.
B
A
E
A
B
E
E
Yeah:
okay,
yes,
perfect!
So
as
we
mentioned,
so
everything
that
we
have
seen
today
with
all
the
technology
is
around
the
inner
loop.
So
in
our
loops
of
code,
when
you
code,
you
run
your
deploy
or
you
build
your
application
that
you
test,
that
your
application
has
the
expected
behavior
and
are
you
doing
this
loop
in
order
to
at
the
end,
create
your
application
after
you
create
your
application?
So
what's
happening
it's
especially
when
we
talk
about
the
container.
E
Let's,
let's
put
this
into
a
container
context,
so
you
are
going
to
build
your
container
of
your
application
once
it's
really
important
and
then
you
are
going
to
deploy
this
exact
same
artifact
into
the
different
environment
until
the
production
one.
So
you
build
your
container
after
that.
You
deploy
your
container
into,
for
example,
the
qa.
E
So
everything
here
and
I
think
when
we
talk
about
outdoor
open
inner
loop,
I'm
quite
sure
that
within
the
cloud
context
or
without
outside
the
cloud
context,
it's
exactly
what
you're
doing
in
your
day-to-day
life.
It's
what
is
defined
as
your
application
life
cycle
right
and
what
is
going
to
change
is
the
fact
that
you
are
going
to
have
much
more
container.
You
are
going
to
to
to
to
move
from
so
smaller
services
and
more
services
is
going
to
compose
your
application.
E
So
that's
why
that,
in
order
to
be
sure
and
to
let's
increase
the
quality
of
everything
that
you
would
like
to
deploy
into
production
and
to
go
through
this
this
journey,
so
you
need
to
have
a
consistent
way
right
to
be
able
to
push
and
to
do
all
these
all
these
steps,
and
this
consistent
way
it's
rich
and
it's
something
that
you
will
be
able
to
to
to
achieve
by
automation.
So
many
automation
and
that's
why
we
have
the
continuous
integration
and
continuous
daily
pipeline.
E
When
I
talk
about
continuous
integration
for
people
who
are
not
familiar
with
that,
so
the
continuous
integration
is
basically
the
process
for
you.
In
order
to
build
and
create
your
release
and
to
create
so
at
the
end
here,
a
container
and
the
continuous
delivery
or
the
continuous
deployment,
so
there
is
a
different
terminology
for,
for
that
is
to
be
able
to
take
this
release
and
to
deploy
it
into
the
different
different
environments,
same
thing
so
automatically.
E
What
I'm
going
to
to
have
here
it's
my
cn
project,
so
one
project
in
which
that
I'm
going
to
take
to
simulate
a
specific
environment,
not
my
dev
environment,
it's
what
carlos
and
alex
used.
But
it
will
be
my
let's
say
my
next
environment,
let's
say
the
staging
environment,
one
way
to
be
able
to
implement
the
cicd
pipelines.
It's
so.
E
E
That
means
that
it
will
be
a
team,
would
be
responsible
from
the
creation
of
the
application
to
the
operation,
to
the
same
application
into
production
and
to
be
able
to
enable
that
and
to
give
all
this
capability
what
we
could
use
and
what
we
are
going
to
use
so
right
now
what
I'm
going
to
demo.
It's
openshift
pipelines,
openg
pipeline.
It's
a
technology
based
on
the
upstream
project,
so
tecton,
which
is
going
to
help
you
to
define
some
kubernetes
native
pipelines.
E
E
E
I
would
like
to
take
my
code,
let
me
put
and
take
my
code
there,
so
we
will
be
this
one
so
also
available.
If
you
would
like
to
use
it,
I'm
going
to
specify
my
code,
it's
software
git
here
I
would
like
to
deploy
which
application
I'm
just
thinking
about
one
application
spring.
I
will
take
the
exact
same
application
that
alex
used.
A
I
shared
in
the
chat,
the
workshop
link
and
if
anyone
want
to
try
it,
it
can
do
just
follow
the
workshop
and
also
to
create
an
account
on
developer
sandbox.
I
put
in
the
chat
also
the
link
to
the
developer
sandbox.
So
it's
a
free
account.
You
have
to
add
a
cloud
access
to
openshift,
so
that's
kubernetes
and
you
can
follow
the
same
workshop.
Madhu
is
doing
if
you
like
to.
E
Yes,
let
me
change.
Let
me
change
like
this,
because
that's
it's
a
live
demo
and
I
would
like
just
to
change
a
bit
about
which
application
I'm
going
to
use
I'm
going
to
use
this
application,
so
it
will
be
a
back-end
application
that
with
you,
especially
in
natalie,
that
we
work
with
to
be
able
to
it's.
You
will.
E
Application,
but
we
see
so
it's
just
one
preview-
that
what
we
are
going
to
to
use
so
the
end
application
from
the
application.
It
will
be
a
java
application.
So
once
again,
I'm
not
going
to
everything
even
to
be
able
to
build.
My
container
will
be
automated.
I
will
let
the
platform
running
that
and.
E
App
and
it
will
be
at
the
back
end
and
here
what
I'm
going
to
use
here
is
I'm
going
to
enable,
for
example,
pipelines
who
is
going
to
create
a
for
me
automatically
a
pipeline
so
based
on
tecton,
so
kubernetes
native
pipelines
here.
So
I
would
like
to
expose
and
to
to
get
access
to
my
application,
and
I
push
on
the
button
correct
when
I'm
doing
that.
So
this
is
familiar,
it's
something
that
we
push
into
into
into
openshift.
Then
you
have
seen
into
the
outer
loop.
E
But
what
is
going
to
change
here
is
the
fact
that
now
I'm
going
to
to
to
build
and
to
have
this
build
based
on
my
pipelines.
If
I
have
a
look
on
the
pipelines
that
I
have
so
it
will
be
different
step
here
so
without
a
different
task
here.
So
without
going
too
much
in
detail,
so
I'm
going
to
have
so
one
task
with
going
to
a
query
and
to
get
to
clone
my
my
code
from
my
git
repository.
E
It's
something
that
I
have
here.
Then
the
other
task
is
going
for
me
to
take
that
source
code
in
order
to
create
my
container
image
that
it
will
push
that
container
image
into
a
image
registry
and
at
the
end,
if
I
go
back
to
the
detail,
he's
going
to
deploy
my
container
image
into
my
git
repository
the
cool
thing
with
this
way
to
run
the
container.
It's
really
that
we're
going
to
enable
to
run
this
pipeline.
It's
that
we
are
going
to
enable
and
to
leverage
all
the
benefit
that
we
are
with
containers.
E
That
means
that
each
let's
say,
steps
that
you
can
see
here
running.
It
will
be
a
specific
container,
so
I
could
have
so.
Let's
say
one
container
focus
with
with
maven,
for
example,
in
which
I'm
going
to
increase
the
resources,
because
it's
maven
and
I
will
need
to
take
a
lot
of
different,
a
lot
of
different
libraries
and
it's.
E
I
need
to
have
a
lot
of
resources
when
it's
maven
and
after
that,
I
will
be
able
to
have
smaller
container
with
smaller
resources,
in
order
to
do
just
to
push
into
my
image
registry
or
to
deploy
an
openshift
or
just
to
run.
Some
script
and
whatever
so
I'm
going
to
have
this
a
really
good
flexibility
around
dealing
with
my
my
pipelines.
E
So
it's
in
progress
so
after
that,
so
my
pipeline
is,
is
now
finished,
so
my
pipeline
is
not
going
to
consume
any
services,
so
it's
really
enabled
the
serverless
capability
just
consume
resources
when
it's
needed.
So
here
my
pipeline
is
run
automatically
completely
and
now,
if
I
access
to
my
services,
so
I
can
go
to
the
url.
E
E
E
F
D
E
A
B
E
Yeah,
basically
so
it's
the
pipeline
so
generating
by
default,
and
if
I
would
like
to
add,
let's
say
more
more
more
tasks
my
pipeline,
so
I
will
be
able
to
to
to
edit
it
and
a
pipeline.
So
what
is
a
pipeline
is
just
different.
Let's
say
task
of
action
that
we
would
like
to
to
to
schedule
and
to
order
and
on
that,
for
example,
let's
say
that
I
build
and
before
let's
say
before,
building
I
would
like
to
to
to
run
a
specific
task.
E
E
So
to
another,
so
I
will
have
some
specific
tasks,
for
example
scorpio
in
which
I
will
be
able
to
define
so
the
source
url
of
my
my
image
and
where
I
would
like
to
push
my
image
and
so
on.
I
will
be
able
to
ask
more
tasks,
of
course.
So,
before
building
and
let's
say
in
parallel,
I
would
like
to
run
some
specific
commands
here.
I
have
some
tasks
here,
so
not
a
cluster
task.
That
could
be
interesting
there
for
me,
but
I
would
like
to
use,
for
example,.
E
C
E
E
E
So
it's
something
that
we
are
going
also
to
integrate
as
a
catalog
inside
openshift
in
order
to
give
you
to
have
a
spot
where
people
is
going
to
share
tasks
and
that
you
will
be
able
to
reuse
so
like
you
are
with
the
docker
app,
for
example,
or
other
other
container
public
registry,
and
let's
say
that
I
would
like
from
this.
I
use
a
sonar
cube,
so
I
would
like
to
use
my
sonia
scanner,
so
here
it's
explaining
what
is
that
task?
E
So
now
my
task
is
creating
and
if
I
go
back
to
my
pipeline,
so
I
go
here
from
the
pipeline
and
from
the
pipeline
I'm
going
to
edit
and
just
before,
let's
say
building
my
application,
so
I'm
going
to
here
I'm
going
to
just
run
my
cube,
cube
scanner
tasks.
So
I
select
my
cube
scanner
task
and,
of
course
there
are
some
parameters.
B
B
A
No
problem
right,
cool
super
cool.
We
have
seen
today,
three
live
demos
on
cloud
native,
inner
loops
and
outer
loops.
I
would
like
to
thanks
a
lot
alex
carlos
madhu
for
this
three
live.
Demos
is
just
one
our
fault,
you
know
it's
not
that
easy.
We
have
seen
all
live
demos
we
shared
in
the
chat,
all
the
links.
If
you
want
to
try
out
those
demos,
and
also
there
is
the
links
for
to
developer
sandbox.
A
If
you
like
to
try
it
out
on
openshift
online
cloud
access
30
days
renewable
for
free,
you
can
use
developer
sandbox,
so
we
also
use
developer
sandbox.
Today
I
would
like
to
go
to
the
end
and
remind
the
what
we
have
in
the
shadow
today,
so
the
next
one
would
be
the
level
up
hour,
docker
compose
with
podman
version,
3
and
9am
et
time.
This
is
interesting,
dogger
composed
with
podman,
and
we
come
back
again
the
openshift
coffee
hour.
A
We
will
come
back
again
on
wednesday
april
14
with
another
disconnected
series.
We
will
talk
about
the
vmware
disconnected
with
ipe
with
robert
vonne.
Thank
you,
everyone
for
attending.
Thank
you
to
our
guest.
Thank
you.
Jafar,
do
you
have
any
final
words
to
this
awesome
live
demo?
We
said
we
saw
today.