►
Description
Get your espresso ready for the OpenShift Coffee Break as together with Dev Advocates and Engineers Alex Soto and Andy Damevin we walk you through on a live demo on how to code, deploy and update a game using the approach GitOps. During the demo we will play with this nice interactive game made with Quarkus and Quinoa framework where you should move an EV car with your phone, join to discover how!
A
Hello,
everyone
and
welcome
back
to
openshift
coffee
break
part
of
the
operation
TV
series,
and
today
we
have
quite
a
crowd
we
have
obviously,
who
is
on
the
other
side
this
time
it's
going
to
be
part
of
the
presenters,
of
course,
in
our
Fabio,
and
then
welcome.
Alex
welcome,
Andy
Welcome
to
our
show
and
I
just
wanted
to
ask
you
guys
I.
Think
I
think
you
guys
are
presenting
today
telling
us
about
githubs
and
we're
gonna
see
a
really
nice
demo.
A
A
B
B
Okay,
we
know
you
very
well
about
this,
for
us,
okay
sure
sounds
good,
so
I'm
developer
for
the
caucus
team
and
I
prepared
this
demo
a
y
logo.
It
was
really
like
nothing
when
I
started.
It
was
just
like
a
a
few
car
moving
with
Kafka
and
kwakis
I
I
wanted
to
present
quinoa
an
extension
I
I
made
for
caucus.
We
may
talk
about
that
a
bit
later
and
then
it
go
to
something
really
nice
that
you
will
see
later,
and
this
is
what
we
will
present.
E
B
B
Those
two
cars
will
need
green
energy
to
work,
and
the
idea
is
that
the
the
energy
is
generated
from
your
phones.
So
you
you
just
open
some
URL
on
your
phone.
You
will
have
the
screen
that
you
see
on
the
left
part
of
the
screen
with
a
wind
turbine
and
by
tapping
really
really
fast.
It
will
generate
energy,
and
this
energy
will
be
sent
to
the
car
which
will
move
on
the
track.
There
are
two
teams,
and
people
will
be
balanced
in
one
team
or
the
other
automatically.
We
don't
let
the
user
choose
their
name.
B
B
B
Let's
just
imagine
this:
in
the
real
world
we
will
have
a
farm
of
wind
turbines
and
on
all
those
winter
bands
you
will
have
a
sensor
to
to
hit
how
much
energy
is
generated
and
from
the
sensor
we
will
then
create
events
that
might
be
thousands
and
thousands
of
even
per
second,
and
with
those
event
we
would
just
send
them
to
Kafka,
because
Kafka
is
really
made
for
this
kind
of
job
I.
Think
Alex.
Do
you
want
to
to.
E
E
So
this
is
basically
the
the
architecture
of
the
application
or
how
it's
the
application
deployed.
You
will
see,
like
you,
know
your
mobile
phone
with
this
wind
turbine
there,
where
you
will
need
to
push
really
hard
to
generate
some
power,
then
basically,
the
the
flow
is
that
when
you
open
the
the
game
you
will
assign
it
as
Andy
said,
a
new
random
name
and
also
you
will
send
it
to
team
one
or
team
two
now.
E
What
is
this
is
just
you
know,
a
synchronous
call
nothing
really
complicated,
but
then
it
comes
the
complicated
part,
and
it's
like
when
what's
happened
when
you
start
generating
power,
so
what's
happened
when
you
start,
you
know
pushing
just
your
your
white
meal
super
hard
right
there
to
generate
energy.
Every
time
that
you
pull
is
a
well-mill,
we're
generating
breast
call
to
or
gain
back
end
okay.
So,
every
time
that
you
push,
we
send
a
request
to
our
backend
and
then
asynchronously
Urban
just
sends
this
power
to
the
topic.
E
Okay,
we've
got
a
Kafka
cluster
there
up
and
running
all
running
in
in
an
open
chip
which
is
yeah.
You
know
it's
a
kubernetes
implementation,
then
this
event,
just
you
know,
goes
from
the
back
end
to
the
Kafka
topic
and
we've
got
the
dashboard,
which
is
a
another
part
of
the
backend
which
is
listening
all
these
events
as
simple
Nursery.
Okay,
so
every
time
that
we
generate
power,
it
goes
to
the
Kafka
topic.
The
Kafka
topic
just
sells
at
this
event
to
the
dashboard.
Well,
actually,
the
dashboard
consumes
this
event
and
updates
the
dashboard.
E
Okay,
so
update
the
position
of
the
car.
So,
as
you
can
see,
we
are
generating
thousands
of
thousands
of
events
per
minute
because
as
much
player,
there
are
more
more
faster.
You
click
the
windmill.
More
events
are
sent
to
that
topic,
they're
processed
a
real
time
and
send
it
back
to
the
dashboard.
So
this
is
how
all
the
application
works.
C
E
We
are
using
the
you
know,
the
project
which
is
at
the
end,
it's
just
some
API
or
some
reactive
API,
for
communicating
with
that's
one
thing
and
the
other
one
is
that
let's
say
like
cuercus
per
se,
although
you
think
that
it's
using
a
synchronous
communication,
the
reality
is
that
it's
using
an
asynchronous
communication.
It's
something.
E
B
B
So
it's
using
her
teaser
active
and
then,
as
a
lecturer
said,
it's
using
the
the
Kafka
smart
messaging,
which
is
sending
to
Tucson
and
receives
And
subscribe
to
the
event
and
then
for
for
the
connection
to
the
UE
UI.
You
can
just
set
a
flag
to
say
you
want
server
Sunday
event
which
lets
you
make
sure
that
the
events
are
coming
from
the
server
to
the
client,
which
is
what
we
want
to
update
the
the
car
on
the
screen.
D
B
Yeah
quinoa,
it's
pretty
cool
It's
Made
to
to
let
you
so.
Anyone
who
made
a
front-end
modern
front
end
will
use
node.js
to
build
it.
It
will
be
using
as
a
react
or
angular
or
View
and
with
quinoa.
You
just
add
your
your
your
front-end
project
in
your
Quakers
app
and
then
the
extension
deal
with
the
rest.
So
you
can
have
Dev
mode.
Then
you
can
build
and
have
your
backend
and
front
end
together.
You
can
develop
on
on
front
end
and
back-end
on
live
coding
both
at
the
same
time.
B
A
B
D
Idea
was
that
we
have
a
live
demo
of
everything
from
the
developer
workstation
to
production
and
we
all
play
all
together
this
game,
so
the
people
now
attending.
Please
send
your
question
in
the
chat,
but
also
make
sure
to
play
the
game.
Please
have
your
phone
next
to
you,
because
this
is
a
the
front.
End
is
basically
for
mobile
phone
phone
or
tablet,
whatever
you
want
to
use
and
then
there's
the
backend
that
we
will
show
in
the
dashboard.
But
yes,
this
is
definitely
a
mobile
game.
D
Exactly
Fabio
so
now
Andy
will
start
as
a
developer,
right,
start
coding
and
the
testing
locally
and
then
we'll
show
his
inner
loop
in
an
environment
called
developer
sandbox
for
openshift,
where
it
can
test
his
stuff
as
a
developer
in
the
in
this
free
kubernetes,
Cloud
environment.
And
then
we
move
to
the
let's
say:
prod
using
githubs
and
I
will
show
how
it
works
with
Alex
as
well.
B
So
here
I'm
is
a
developer
and
I
created
this.
This
project
with
Quark
quiz
and
I,
want
to
put
it
on
on
openshift.
So
the
first
thing
I
do
as
a
developer
is
look
under
that
website
and
see.
Oh,
there
is
a
Sandbox
that
I
can
use
and
it's
free,
which
is
great
and
why
not
deploy
it
on
it.
But
first,
let's
have
a
look:
a
quick
look
at
the
project
itself,
so
it's
generated
with
quercus,
so
I
just
came
to
code.forequest.io
from
crowd.com
added
a
few
extensions
or
quinoa.
B
Then
you,
you
can
choose
a
QP
quinoa.
Then
you
pick
Kafka
here
you
have
the
connector,
so
you
and
then
you
have
rest
easy
reactive.
You
pick
those
bunch
of
extension
which
will
help
you
create
your
app
and
it
will
give
you
all
the
the
tool
that
you
need
to
make
sure
that
your
app
is
ready
to
go
in
the
cloud,
which
is
the
awesome
thing
about
quarkus.
But
let's
we
can
go
deeper
into
that.
If
you
have
questions
on
this
part,
but
the
topic
is
more
about
about
the
apprenticeship
part.
B
I
have
this
project
generated
here,
and
this
is
quite
small
but
I,
don't
know
how
I
can
make
this
part
bigger.
When
I
will
open
the
card,
it
will
be
a
bit
bigger.
But
let
me
talk
you
through
it,
so
you
have
Source
main
Java,
which
is
a
normal
Java
project
and
then
here
something
special.
You
have
a
web
UI
directory,
which
is
what
quinoa
is
actually
doing
so
here,
yeah.
B
It
no.
This
is
way
too
big.
Okay,
let's
not
do
that
so
yeah
I
have
directly
in
a
web
UI
and
just
to
to
explain
in
there.
You
have
a
package.json,
and
this
is
a
standard
UI
project.
It
uses
react.
This
one
use
react,
but
you
could
it
could
be
angular
or
whatever.
The
most
important
is
that
it
contains
the
package.json
and
then
you
can
by
putting
it
here
and
adding
the
extension.
B
B
B
What's
your
infinite
span,
it
need
Kafka
and
infinite.
So
without
jafkin
infinix
band,
it
won't
start,
but
something
great
with
quircus
is
that
for
developers
you
can
have
your
Dev
Services
started
for
you,
which
means
that
when
I
start
devmod
without
having
any
Kafka
and
without
infinite
span
on
my
local
machine,
it
will
just
spin
them
up
using
Docker
and
everything
will
be
plugged.
So
I
can
develop
easily
on
my
machine
so
see
everything
is
already
started
really
fast
and
I
have
my
game
running
on
my
local
machine.
B
B
Internet
power
and
the
car
is
moving
great.
Everything
is
fine,
and
the
cool
part
is
that
I
can
actually
live
code
on
this,
meaning
that
if
I
go
here
and
I
just
change,
something
I
didn't
really
prepare
that.
But
this
may
be
another
item
to
change
something,
but
it
will
just
update
on
the
UI.
Oh
so,
in
the
back
end
I
mean
I
know
where
to
change
in
the
front
end,
so
I
will
not
change
anything
in
the
back
end.
B
B
B
C
B
Yeah
I
know
right:
okay,
that
worked
so
I
didn't
restart
the
server
right
and
then
I
will
go
in
the
UI
and,
as
you
saw,
it
was
a
V1
that
we
had.
Let's
switch
to
V2,
so
here
I
will
enable
a
new
feature,
and
if
we
go
back
here,
oh
without
doing
anything,
it
was
already
there.
So
this
is
what
we
will
have
in
V2.
Instead
of
tapping,
it
will
be
checking
you
can
check
your
phone,
so
I
can
develop
front-end
and
backend
together,
and
this
is
all
really
quick.
B
Let's
close,
this
everything
is,
is
closed
and
now,
let's
deploy
it
to
openshift,
which
is
also
great,
because
now
that
I've
been
developing
I
want
to
go
to
openshift,
which
is
like
the
normal
flow.
You
would
have
trust
on
your
machine.
Then
you
push
it
on
the
on
the
cluster
I
prepared
here
on
the
sandbox
I
prepared
a
few
things
before
the
demo,
so
that
we
don't
do
the
boring
stuff
I'm,
creating
a
Kafka
instance
which
is
free
just
for
for
learning
and
everything.
B
Okay,
so
let's
go
back
to
so
as
I
said,
game
events,
power
event,
user
action
and
then
I'm
I've
been
adding
a
few
settings
to
to
make
sure
that
I
can
access
it
from
the
open.
The
open
chips
console
from
the
openshift
cluster.
Sorry
I've
added
really
open
security,
which
means
that
it's
it.
What
not
what
you
will
do
on
production,
but
for
that
demo,
that
will
be
all
right.
B
C
B
D
So
and
you
you
have
two
dependencies
right
that
you
have
to
put
on
this
kubernetes
cluster,
an
open
shift
cluster
in
this
case,
but
in
general
in
any
kubernetes
you
need
a
Kafka
cluster
and
a
infinite
span
cache
cache.
Now
you
show
us
that
you
can
create
a
Kafka
cluster
in
the
cloud
and
then
you
can
connect
this
Cloud
Kafka
cluster
over
here
right.
B
B
B
Good,
so
here
I'm
using
a
m
chart,
you
also
have
an
operator
for
infinite
span,
but
the
red
shirt
was
already
installed
here.
So
on
the
developer.
Sandbox,
you
don't
have
the
infinite
pen
operator
installed,
but
if
it
was
your
own
cluster,
you
would
be
able
to
use
it,
but
here
so
I'm
just
keeping
the
default
and
it
will
install
infinite
span.
For
me,
let's
wait
a
few
seconds.
B
B
I
created
this
instance
win
turbine,
and
it's
here
so
I'm
just
connecting
it
and
what's
great,
is
that
just
after
doing
that
see,
I
have
my
two
services
on
openshift,
so
I
have
infinite
and
Kafka,
which
is
like
kind
of
awesome
like
in,
like
a
few
seconds.
I
have
everything
ready
for
my
service
to
work
now
with
caucus,
you
have
an
open
shift
extension
which
allows
you
to
generate
the
openshift
resources
needed
to
to
deploy
on
on
openshift,
which
is
what
I
prepared.
B
B
So
it's
pretty
like
simple
stuff,
but
then
what's
great
is
with
just
those
few
things
when
I
will
build,
it
will
generate
all
the
resources
that
I
need
for
openshift
or
kubernetes,
like
all
these
complex
stuff
is
done
for
me
and
if
you
already
used
organifer
everything
you,
you
know
that
those
files
are
the
art
path
to
to
generate.
Once
you
understand
how
it
works,
then
it
gets
easy,
but
at
first
this
is
what
sometimes
gets
a
bit
tricky.
C
B
E
E
B
E
B
Cool,
so
here
you
can
see
that
I
added
a
few
parameters,
so
I'm
telling
my
grid
that
I
want
to
deploy
to
kubernetes,
so
it
it
opens
it
behind
the
scene,
but
it's
using
the
kubernetes
API
client.
So
it's
the
same,
even
if
it's
opencbi
what
I
did
before
tipping
this
command
is
that
I
logged
into
my
cluster
with
the
OC,
the
openshift
client,
which
was
a
normal
command.
B
So
I
didn't
do
anything
special,
but
I
will
not
do
it
live
so
that
you
don't
see
my
credon
first
and
then
I'm
telling
that
I
want
to
use
the
Quaker's
profile,
which
is
openshift
sandbox,
because
I
can
deploy
this
app
on
the
openshift
sandbox
or
a
real
openshift
cluster
and
some
some
stuff
changed
slightly.
This
is
why
I
have
different
profile
and
I'm,
telling
that
the
container
group
is
my
name,
because
this
is
a
project
name
on
openshift.
D
B
B
So
this
is
something
we
can
do
with
with
work
with
some
kind
of
hybrid
approach
between
native
and
non-native,
and
here
I
just
decided
to
go
for
jvm
for
now
for
this
demo,
so
it's
building
everything
then
it's
creating
all
the
resources
that
we
saw
before
for
openshift
and
it's
making
sure
everything
is
deployed
on
openshift
and
we
are
done.
If
we
go
to
open
shift
see
now
we
have
our
our
deployment.
That
is
here
so
our
app
quercus
applications
have
been
generated.
Let's
connect
it
to
infinite
spam.
B
C
A
C
So
you
can
see
the
topology
something
that
you
mainly
when
you
start
to
develop
microservices
with
a
lot
of
component
being
Kafka
and
stuff
like
that,
you
lose
the
the
the
the
map
where
I
am
who
is
connected
to
world
and
then
from
deployment
perspective
also
developers.
Now
their
life
is
easier
because
quarkus
provides
all
the
tools
that
allows
to
skip
the
let's
say,
the
building
complexities
to
work
overshift.
So,
yes,
that's,
become
really
really
developer
friendly
yeah.
D
C
C
B
B
B
D
Inner
loop
Andy,
so
we
demonstrated
that
you
from
your
workstation.
You
used
your
developer
workflow.
Then
you
deployed
on
kubernetes.
Now,
let's
imagine
this
is
fine.
You
know
this
is
good.
Now
we
want
to
move
this
to
prod
I.
Think
and
the
the
next
step
is
that
you
as
a
developer
or
anyone
can
should
give
us
the
those
yeah
all
those
yaml
files.
So
we
can
use
their.
B
Food
ID
to
so,
if,
if
we
want
to
do
that
so
that
that
will
make
it
real,
like
I've,
been
developing
and
now
let's
send
that
to
the
Ops
right,
so
I
will
go
here.
So
can
you
still
see
my
screen?
Yes,
so
I
have
my
beautiful
app
here
and
I
want
to
export
it.
So
I
just
click
here
which
is
using
github's
primary
right,
then
I
click
export
application
and
it
will
start
and
it
will
export
everything
from
this
quiz.
B
D
Exactly
and
now
we
want
to
move
to
the
let's
say
prod
cluster,
so
all
your
tests
are
great
and
if
you
can
provide
the
yaml
file
of
you,
then
we
can
then
create
our
key
tops
repo
Alex,
because
now
what
we
want
to
do
is,
as
we
said,
we
said,
begin
topsify.
This
app.
We
want
to
make
it
the
RCI
Parts
cd
part
and
using
the
guitars
approach
is
a
continuous
deployment,
continuous
delivery.
D
D
Okay,
okay,
let
me
start
sharing
the
screen,
so
first
thanks
Andy.
For
this
part,
it's
great
and
thanks
for
providing
us
all
the
yaml
file.
I
just
wanted
to
say
that
what
Andy
did
is
you
know
develop
on
this
part,
but
then
thanks
to
is
Manifest
we
can.
We
could
create
the
the
guitars
repository
In,
the
Heat
of
repository
we
can
share.
Also
in
the
chat.
Let
me
let
me
quickly
share
with
you
in
the
private
chat.
So
then
you
can
see,
and
in
in
the
Manifest
repository
there
are.
D
We
are
using,
in
this
case,
Argo
CD.
So
this
is
our
Argo
app
pointing
to
this
manifest
and
those
manifests
are
basically,
you
know,
have
the
deployment
and
the
created
and
exported
with
that
function,
which
is
a
an
operator
called
the
gitops
primer,
an
operator
that
collects
all
the
manifests
and
and
then
extract
them
to
be
ready
for
githubs,
there's
a
route
there's
a
service
and
the
customization
file
we're
using
customize
here
to
update
the
version
of
of
this
app.
D
So
this
is
the
the
let's
say,
prod
cluster
in
in
this
product
cluster
we're
using
a
Kafka
cluster
locally
to
the
cluster.
So
we
just
deployed
the
Kafka
using
streamzy,
which
is
a
you
know,
a
Kafka
operator
to
deploy
Kafka
in
this
cluster.
We're
using
Infinity
span
the
same
thing
and
we
have
our
application
here
up
and
running.
So
let's
play
this
game
and
Alex.
Let's
play
the
game,
but
before
doing
that,
do
we
do
we
have
to
show
anything
else
like?
Oh,
yes,.
D
Just
wanted
to
show
that
now
that
we
are
improved,
this
is
an
egg
available
app
right.
We,
we
have
five
replica,
but
this
is
also
kit
Ops
driven.
So
we
have
our
Ergo
City,
which
is
controlling
the
github's
Manifest
and,
as
you
can
see
this,
there
is
in
the
integration
with
this
cluster
with
openshift
authentication.
So
when
you
log
in
then
you
are
in
the
the
Argo
City
console.
This
is
our
application.
You
can
see
this
application
in
this
version
is
up
and
running.
C
D
In
deployment
it's
in
the
same
cluster,
it's
index
same
cluster,
so
we
have
an
argosity
in
this
cluster.
We
have
also
another
component,
which
is
a
advanced
cluster
security,
so
formally
stack
rocks
to
scan
the
container
image
representing
this
game
we
will
show
after
but
Alex
should
we
start
with
playing
this
game.
Yeah.
E
D
D
D
B
D
D
Somebody
somebody
else
that
can
join
the
race
come
on
people
in
the
chat,
don't
be
shy
just
again
just
go
to
the
QR
code
and
or
the
URL
here,
and
we
start
playing
the
game
and
the
game,
and
maybe
for
the
second
version.
We
have
more
people,
you
know
joining
it,
but
let's,
let's
show
okay,
I,
think
we're
fine
with
four
and
three
people
more
people
are
coming
so
Alex.
Are
we
ready
to
go.
D
Yeah
so
five,
four
three
people,
the
people
that
want
to
to
join
just
you
know
just
just
go
to
the
the
URL
and
and
click
on
the
on
the
windmill,
and
we
can.
We
can
start
this
game
when
we
start
the
game
when
I
click.
Here,
you
should
see
on
your
phone,
a
windmill
appearing
when
that
me
windmill
appears,
you
just
have
to
tap
in
the
windmill
in
order
to
move
this
electrical
car.
This
is
a
a
green
game
right,
so,
let's,
let's
try
it
out.
D
A
D
D
E
Because,
at
the
end
we
are
developers,
and
sometimes
we
want
to
innovate
and
we
say:
hey
I
would
like
to
just
try
a
new
way
of
generating
green
energy.
So
instead
of
you
know,
pushing
a
windmill.
I
could,
for
example,
shake
my
phone,
so
the
password
I
check
my
phone,
the
more
energy
I
generate
so
I'm.
The
developer
I
just
developed
all
these
new,
this
new
computer
and
then
on
Friday
evening
I
just
pushed
the
code
and
I
just
send
an
email
to
The,
Operators
and
say:
hey
the
feature.
Is
there?
E
It's
tested
just
deployed
to
production
right
and
well.
You
know
this
could
be
a
problem
because
maybe
I
miss
any
parameter
in
the
mail
or
maybe
I.
Just
don't
put
the
clear
instructions
on
how
to
deploy
this
new
version,
and
the
operator
will
spend
all
his
weekend
just
trying
to
deploy
my
application
to
production
right,
and
this
is
what
is
known
as
a
wall
of
confusion.
So
what
we
need
to
adapt
is
devops
and
developed
is
not
only
about
that
and
apps.
It's
not
just
a
Dev
and
absolutely
needs
to
work
together.
E
Is
that
the
whole
organization
needs
to
work
together,
Hand
by
hand
when
I
said
all
the
organizations
I'm
in
the
Ops,
the
SEC,
the
Beast,
the
PO,
the
debt,
the
QA
and
also
the
dbas
right
and
I'm,
not
saying
that
the
dbas
are
zombies,
I'm,
saying
that
the
in
the
age
loves
Walking,
Dead,
okay,
so
all
needs
to
be
in
the
devops.
But
what's
happened
then,
obviously,
is
just
a
methodology.
We
need
to
find
a
way
to
implement
it
and
I
think
that
one
great
way
to
implement
the
maps
is
using
githubs.
D
Right,
thank
you.
Alex
I.
Think
gitops
is
the
right
approach
now
to
simulate
this
use
case,
where
we
have
to
add
a
new
feature.
Just
a
quick
reminder:
what
is
github's
the
three
main
pillar,
get
it
a
single
source
of
fruit.
Everything
is
treated
as
a
code
and
every
operation
is
through
git
workflow.
In
fact,
also
this
game
is
made
in
this
way.
We
have
a
the
first
part
where
there's
a
pipeline.
D
This
is
the
repositor
of
the
app
that
where
Andy
was
working
from
the
beginning
right
and
then
this
generate
the
container
image,
some
pipeline
generate
the
container
image
and
store
this
container
image
into
a
registry
when
there
is
a
git
workflow,
a
git
action
like
a
pull
request.
There's
also
will
consider
the
the
Manifest
describing
this
app.
So
there's
the
Manifest
repository
and
there's
a
gitops
controller
that
will
monitor
detecting
any
drift,
taking
action,
syncing
any
change
to
pushing
any
change
to
kubernetes.
So
now
Alex,
it's
time
to
see
more
like
this.
D
What
maybe
what
we
can
do
is
that
I,
you
send
me
the
pull
request
to
this
change.
Do
you
want
to
enable
the
checking
right?
You
want
to
enable
the
checking
so
again
enable
the
checking
is
going
into
as
an
end
is
shown
in
the
in
the
local
development
going
here
in
the
web.
Ui
changing
this
parameter
so
Alex,
if
you
do
this
live
I,
can
approve
your
pull
request
and
we
can
start
this.
Okay,
okay,.
D
Exactly
exactly
from
your
because
you
already
cloned
the
repository
right,
you
Fork
the
repository,
so
you
you
test
it
and
then
now
you
wanna,
you
wanna
add
this
feature.
Well,
the
best
practice
is
Fork
the
repo.
Do
your
change?
Send
the
pull
request
then
restart
the
GitHub
action.
So
now
we
want
to
enable
the
checking
feature,
which
means.
D
Thank
you,
Alex.
That
means
you
can
move
your
the
windmill
move,
the
car
with
your
phone.
Let
me
review
your
particular
Alex.
That
looks
good
to
me.
So
let
me
give
your
well-deserved,
plus
one
and
now
that
we
merge
this
for
requests.
What
happens
under
the
hood?
Well,
we
have
the
we
have
to
kick
off
the
CI
parts
right
and
the
CI
part
is
automatically
kicked
off
through
a
Web
book
that
we
configure
oh,
and
we
have
a
Live
error
permission.
E
E
E
D
D
So
I
wanted
to
show
that
what
we
did
is
configure
a
Web
book.
Of
course,
here
we
went
into
the
repository
in
the
app
repository
and
we
added
this
Web
book
of
there's
a
authentication.
We
added
this
webbook
where
this
web
group
started
well.
This
webbook
started
from
the
pipeline
definition
in
tecton.
You,
you
have
a
component
called
tecton
triggers
trick
that
give
you
the
capability
to
add
web
books.
When
you
use
openshift
in
this
broad
cluster,
you
can
even
build
this
pipeline
from
the
pipeline
UI.
D
So
what
we
really
did,
it's,
you
know
creating
a
new
Pipeline
and
then
we
added
the
task
like
okay,
I
need
the
git,
clone
and
I
need
to
add.
Then
a
Marvin
task.
So
we
really
did
this
right,
so
Jeep,
Marvin
or
Community,
my
whatever
and
and
we
built
our
Pipeline
and
and
then
we
add
our
triggers
and
the
triggers
will
give
us
that
URL
that
will
provide
us,
the
the
automation,
but,
as
you
can
see
the
map
and
build
start
and
now
we're
building
the
container
image.
D
This
container
image
will
be
stored,
not
in
the
cluster,
but
in
a
external
registry.
In
this
case
is
square
yo,
so
we
also
added
some
credential
here
and
the
the
last
part
is
the
the
Manifest,
the
the
git
manifest
update.
We're
gonna
update
the
the
the
git
manifest
again.
Those
manifests
are
in
the
Manifest
repository
that
you
can
see
here
so.
D
Exactly
it's
really
close
for
what
you
did
on
your
machine,
but
we
it's
all
automated
and,
as
you
can
see,
this
already
started
so
this
updated
the
Manifest.
Let's
see
what
is
happening
here
in
Argo
City,
so
Argo
CD
is
retriving
the
change.
Now
everything
is
out
of
sync,
but
it
will
redeploy
the
app
and
we
can
see
this
also
on
openshift,
because
openshift
is
doing
a
and
kubernetes
now
is
doing
a
rolling
update
of
the
app.
D
B
This
is
also
something
pretty
good
with
workers.
Is
that
all
the
Readiness
and
liveness
are
like
out
of
the
box
so
that
you
just
make
your
crack
quiz
app
and
you
have
you
install
that
extension
for,
for
else
check
and
everything
will
work
in
in
openshift,
and
you
can
also
like,
if
you
add
Kafka,
it
will
make
sure
that
Kafka
is
started
and
everything
so
that
you,
you
are
sure
your
crackers
app,
is
ready
to
receive
requests.
D
Exactly
and
and
yeah
I
also
want
to
show
that
what
what
we
did,
it's,
it's
real
so
one
minutes
ago
we
did
this
comment.
Actually
we
didn't
do
the
pipeline.
Did
this
comment
using
customized
took
the
hash
of
the
container
image
we
pushed
on
this
registry
and
substituted
in
the
in
the
Manifest.
So
now
our
app
should
be
in
version
two
and
since
it's
all
live
demo,
let's
verify
this.
Please
go
back.
Take
your
phone
again
and
point
your
phone
to
this
core
code
or
just
go
to
the
URL
that
you
find
I.
D
Good
point
that
Andy,
so
if
you
are
using
iPhone
it's
gonna
is
that
it
will
ask
you
to
have
the
permission
to
access
the
sensor,
because
this
is
gonna
use
the
sensor
for
for
enabled
shaking.
So,
if
you're
using
iPhone,
please
allow
it
with
its
open
source.
You
can
see,
we
are
not
doing
anything
weird,
so
just
click
enable
shaking,
and
now
we
are
ready
to
go
with
version.
Two
December
should
do
the
entity
locally.
Now
we
did
it
using.
D
You
know
the
gitops
approach,
it's
all
automatic
right,
Argo
City,
retire
with
the
change
redeployed,
everything
and
Alex.
We
are
ready
to
go
for
the
second
round.
Yes,
so
let
me
go
back
here
to
our
Let
me
refresh
it.
Of
course,
this
dashboard
you
find
in
the
game.
It
has
some
credential,
so
the
people
restarting
joining.
Let
me
check
in
which
team
I
am
this
time.
Fred,
oh
still,
team
one!
D
D
C
D
B
D
Oh,
that
that's
great
and
the
people
in
the
chat
please
share
in
the
chat
who
were
you
it's
nice
to
see
if
you
enjoyed
and
play
this
game,
but
what
we
wanted
to
show
you
is
this:
we
did
this
change
Friday
afternoon,
just
accountable
request.
Everything
is
automated
and
we
have
version
two.
The
good
thing
of
article
CD
and
open
shift
key
tops.
You
can
roll
back
to
the
previous
version.
If
everything
is
wrong,
it's
just
a
one
kilometer
way
right
and
we're
not
finished.
D
Yet
we
wanted
to
show
that
in
this
demo
app
we
also
insert
the
this
advanced
classes.
Security
for
kubernetes,
the
Upstream
name-
is
stack
rocks.
We
wanted
to
show
that
we
had
also
a
scan
of
our
container
image.
We
have
some
scoring
of
the
scan.
There's
some
cve
in
this
image.
Talking
about
production
right,
we
can
decide
if
not
to
let
this
go
through
prod,
so
the
pipeline
can
really
stop
if
we
say
that
our
risk
priority
is
too
high
or
we
have
too
many
important
severity
CBE.
D
We
can
decide
to
block
this,
but
for
the
sake
of
this
demo,
we
decided
it
was
good
to
go.
But
this
is
also
interesting
to
understand.
Maybe
we
we
can
control
the
docker
file.
Maybe
we
can
control
how
we
build
the
the
container
image
yeah,
just
to
mention
it
and
Alex.
Just
to
finish,
I
think
we
we
can
show
some
of
the
messages
in
Kafka
right.
Yeah
can.
E
E
E
B
D
B
This
case
so
infinite
spam.
So,
as
we
said,
we
have
multiple
pods
and
we
need
to
make
sure
that
everything
is
consistent
for
the
user.
So
when
we
assign
user
and
team,
we
need
to
make
sure
that
the
number
of
people
in
team
one
and
team
two
are
balanced.
And
for
this
we
need
a
shared
Contour
or
cluster
Hunter,
and
also
we
need
to
make
sure
that
the
user
is
are
unique
to
usernames,
and
this
is
why
we
use
that.
D
Fantastic,
so
just
wanted
to
show
that
we
were
able
to
do
a
nice.
You
know
mobile
game
in
architecture,
front
and
back-end,
using
the
streaming
data
streaming,
events,
caching
or
or
a
session,
and
keeping
and
then
Kafka
messages
you
know
distributed
streaming.
Then
we
were
able
to
use
a
pipeline
using
tecton.
We
were
able
to
use
key
tops
using
Argo
CD.
D
C
Yeah
as
I
told
before,
definitely
yes,
so
the
show
this
demo
sure
clearly
how
concrete
development
workflow
could
be
implemented
and
on
office
shift
using
tool
that
are
very
easy
to
manage,
and
and
actually
you
could
really
implement
it
through
githubs
and
best
practices
leveraging
all
these
all
these
stuffs,
and
that's
great,
is
you
just
not
Theory?
You
can
really
do
it
now
avoiding
to
manage,
as
you
talk
before
a
lot
of
yaml
which
are
yeah.
B
Like
something,
I
really
noticed,
I
I'm
more
developer
than
an
Ops
I'm
developing,
so
openshift
I'll
just
use
it
to
to
try
my
stuff
and
I
went
to
open
shift
a
few
years
ago
and
I
was
like
wow
that,
like
that's
way
too
hard
and
now
see
like,
without
touching
anything
like
complex
from
openshift
I
managed
to
do
everything,
I
needed
and
and
like
I'm,
not
an
Ops.
But
I
did
some
up
stuff
as
a
developer,
which
is
kind
of
great.
A
A
D
I
think
it's
a
collaboration
on
there,
but
also,
moreover,
an
opportunity.
It's
self-serve,
because
from
the
pipeline
UI
Builder,
you
can
build
a
pipeline
on
your
own
from
Argo
CD.
You
can
create
an
Argo
app
from
the
UI,
so
you
know
you
you
can
do
the
complete
Loop
alone
as
a
developer,
but
I'm.
This
is
sure
a
collaboration
between
the
developers
and
the
devops
are
now
platform.
Engineers
that
need
to
you
know,
prepare
the
production
with
everything
set
like
we.
We
shown
Advanced
cluster
security
for
kubernetes.