►
From YouTube: Cohort Day 2 - Ortelius with Jenkins
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
So
there's
two
ways:
we
can
do
this
for
the
getting
started
one.
We
can
go
over
how
to
configure
ortelius
in
like
a
kubernetes
cluster,
or
we
can
get
into
the
jenkins
side
of
things
how
we
hook
into
jenkins
so
either
way
we
could
either
way
we
could
go.
It
doesn't
matter
to
me
it's
your
your
choice,
guys
and
we'll
do
that.
A
C
A
A
A
B
B
A
So
we
have
the
hipster
store
demo
application
out
there,
and
what
we're
going
to
do
is
we're
going
to
focus
on
just
this
pipeline
for
this
service,
so
typically
we're
going
to
have
a
pipeline
for
every
service
or
workflow
for
every
single
service
out
there.
So
the
one
we're
going
to
be
working
with
is
is
the
the
email
service
as
part
of
that
process.
A
We're
going
to
actually
have
the
jenkins
job
is
going
to
be
part,
is
going
to
be
what's
actually
going
to
do
the
docker
build
we're
going
to
grab
some
of
the
container
information
about
where
it
has
pushed
the
digest.
The
the
information
about
the
repo
itself,
the
helm,
chart,
that's
actually
used
to
install
the
service
into
the
cluster,
so
that's
kind
of
information
that
we're
gonna
gather
from
the
jenkins
pipeline.
A
A
So
this
is
the
actual
the
actual
service,
the
the
service
itself.
Isn't
that
important
for
what
we're
doing,
but
basically
it
looks
like
it's
a
python
application
that
is
going
to
provide
the
actual
service.
So
from
our
point
of
view
this
what
the
service
does-
and
you
know
how
it's
put
together-
we
don't
care
about
that
as
much.
A
A
A
B
A
A
You
can
configure
like
the
user
id
the
password
at
the
jenkins
system
level.
So
when
we're
looking
at
the
definition
in
here,
it's
just
going
to
be
environment
variables
that
you're
going
to
reference,
but
for
just
simplification
for
people
to
follow.
I
just
hard
code
them
here
so
this
this
is
not
a
requirement
to
expose
the
user
id
password
that
can
be
done
at
the
jenkins
level.
Some
of
the
next
stuff
that
we
have
is
what
is
our
application
in
our
application
version
that
we're
going
to
package
this
microservice
in?
A
A
A
For
my
from
what
I
remember
is
this
one
is
going
to
build
and
I
don't
think
we're
going
to
do
the
deploy.
Oh,
we
do.
We
record
the
deployment,
so
in
this
case
we're
going
to
record
that
the
deployment
went
out
to
this
environment,
so
an
environment
in
the
arturous
world
is
just
going
to
be
a
set
of
of
endpoints.
A
It's
just
a
way
to
gather
together,
so
you
could
have
a
an
endpoint
that
could
be
your
database
server.
You
could
have
your
kubernetes
cluster
as
an
endpoint,
and
then
you
may
have
like
a
on
on-prem
vm.
That's
running
the
monolith,
for
example,
so
the
environment
can
be
comprised
of
any
any
number
or
any
types
of
endpoints.
A
Basically,
the
environment
is
representing
a
place
that
we
deployed
to
the
next
part
that
we
have
is
going
to
be
the
component
name,
so
in
this
case
we're
going
to
be
working
with
our
email
service,
our
base
component
version.
So
this
is
the
schematic
version
that
we're
going
to
be
utilizing.
Let
me
see
if
I
got
logged
in
here
change
up
our
filter.
A
A
A
A
So
we
have
our
our
service
name,
our
component
name.
The
base
schematic
version
in
this
case
we're
adding
a
custom
action
to
it,
which
is
going
to
be
the
helm.
Chart
action
which
allows
us
to
deploy
from
ortelius
using
a
helm,
chart
the
chart
name,
the
chart
version.
Sometimes
the
chart
version
may
be
derived.
A
The
image
registry.
This
is
where
we
push
our
images
over
to
I
like
way
over
docker
hub,
it
doesn't
have
the
restrictions
like
docker
hub
has,
and
it's
much
more
stable,
we're
just
gonna
tag
it
as
latest,
and
then
this
is
some
of
the
new
service
owner
service,
catalog
data
that
we're
pulling
in
service
owner
email
phone
number
as
part
of
that.
So
this
is
kind
of
like
your
your
base,
information
that
we
need
to
set
up
now.
A
Some
of
some
of
this
information,
I'm
looking
at
putting
into
a
tamil
file
and
being
able
to
read
that
in
and
expose
it
as
environment
variables,
instead
of
having
it
as
part
of
the
jenkins
file
and
the
reason
being
is
what
we've
run
into
is
not
every
developer
has
access
to
update
the
jenkins
files.
Those
are
controlled
by
another
group.
A
A
It's
just
gonna
save
any
hiccups
down
the
road
where,
like
you,
can't
get
logged
into
a
repo
or
something
like
that,
because
somebody
forgot
to
give
you
access
so,
whenever
possible,
use
the
ssh
version
of
it.
So
that's
going
to
be
our
full
url,
some
of
the
things
that
we
want.
It's
just
going
to
be
like
the
get
repo
name.
A
A
A
So
you
have
your
base
version
in
our
cases,
email
service,
the
variant
is
gonna,
be
the
branch
that
you're
on
now.
This
could
be
like
the
pr
that
is
being
used.
It
could
be
a
branch
like
maybe
like
maintenance.
It
could
be
a
branch
like
for
feature
requests
say
you
know.
New
ui
would
be
that
branch,
but
what
we've
recognized
is
within
a
brand
or
a
variant.
You
can
have
additional
schemas
within
that.
A
So
let's
say
we're
on
the
the
maintenance
branch
and
we're
gonna
iterate
through
multiple
builds
on
the
maintenance
branch
that
we're
going
to
push
out
to
our
cluster.
We
kind
of
want
to
keep
track
that
the
variant
is
the
maintenance
branch
and
that
we're
going
to
go
ahead
and
iterate
from
one
point
1.2.0.
A
You
know
build
number
to
the
next
one,
so
we're
going
to
keep
on
doing
multiple
builds
for
that
variant.
As
part
of
that,
so
I
would
recommend
using
a
variant
in
the
artillious
world.
That's
where
we'll
see
that
we
have
our
service
name
and
then
our
variant,
which
in
this
case
we're
on
master
and
then
within
master,
we're
going
in
iterating
through
the
builds-
and
you
can
see
here-
we
didn't
do
a
check
in
so
we
didn't
get
a
new
commit,
but
we
are
doing
new
builds.
A
You
can,
whatever
one
that
you
already
have
in
place,
you
can
use.
You
know
just
take
this
off
and
or
supply
your
format
for
your
image
tag
that
you
have,
whether
it's
gonna
be
like
latest
but
same
concept.
We
tag
everything
with
the
the
branch,
those
can
be
master,
our
component
version
number
and
the
commit
it
just
makes
it
handy-
have
a
unique
tag
out
there.
Now
we're
actually
gonna
get
into
this
place
this
step.
So
all
of
this.
A
A
A
So
any
image
that's
been
built
locally,
doesn't
have
a
digest
associated
with
it.
You
don't
get
the
digest
until
you
actually
do
the
push
and
then
from
there
you
can
inspect
the
registry
that
that
actual
tag
to
get
the
image
digest
it's
a
weird
quirk,
but
that
step
has
to
be
done
after
you
know,
post
push
at
that
level.
A
So
you
know
you
put
your
build.
You
know
kind
of
put
your
build
stuff
in
here,
however,
you're
doing
it,
we've
had
people
use
canaco,
build
docker
builds,
you
know,
there's
a
bunch
of
different
build
tools,
but
in
in
general,
that's
going
to
happen
and
then
once
post
post
push
we're
going
to
grab
our
digest
and
then
we're
going
to
record
all
of
this
with
ortillius.
A
So,
basically
we're
going
to
go
ahead
and
start
pushing
all
this
information
up
to
artelius
for
this
component
version.
Now,
one
of
the
things
that
we're
doing
here
is
we're
actually
going
to
save
this.
This
information
that
we're
gathering
and
we're
going
to
persist
it
to
a
file
and
the
reason
being
is
if
we
have
to
do.
A
Let's
say
we
have
multiple
services
that
are
building
in
a
single
workflow
instead
of
having
one
workflow
per
service.
So
let's
say
we're
going
to
build
four
services
and
one
right
after
another,
we'll
actually
go
ahead
and
run
this
step
for
each
service,
that's
getting
created,
but
we'll
keep
on
persisting
it
to
the
same
file
and
what
ends
up
happening
is
we'll
use
that
file
later
on,
when
we
record
that
a
deployment
happens.
A
Now,
in
this
case,
we
are
going
to
basically
update
our
component.
Tell
ortelius
that
there's
a
new
version
out
there.
Ortillius
comes
back
and
says:
okay,
I
just
created
a
new
version
for
you:
here's
the
information
we're
going
to
put
that
into
that
json
file
and
then
eventually
we're
going
to
record
the
deployment
here
where
we're
going
to
utilize
that
information
and
that
application
version
information
later
on
now,
you'll
see
here
at
the
component
level.
We
don't
have
any
thing
to
do
with
the
application.
A
So
if
you
have
the
service,
that's
going
to
be
created,
you
don't
know
what
the
application
is.
Yet
you
know
that
type
of
scenario.
You
know
who
the
consumers
is
we'll
deal
with
that
at
the
deployment
time.
So
here
we're
actually
going
to
record
the
deployment
being
done
and
the
reason
why
we're
recording
it
is
we're
giving
it
a
deployment,
data
and
deployment
environment.
A
Now
we
could
actually
do
the
deployment
from
or
to
this,
and
we
just
leave
off
a
couple
parameters
at
that
level.
So
if
we
do
the
deployment
through
ortelius
we're
actually
going
to
execute
this
custom
action
to
do
the
deployment,
so
it
just
depends
on
how
you
have
things
plumbed
together,
whether
you're
going
to
have
the
jenkins
pipeline
continue
doing
the
deployment
or,
if
you're,
going
to
switch
over
towards
this
doing
the
deployment
either
way.
A
It
doesn't
matter
to
us
we're
going
to
gather
the
information
one
of
the
advantages
of
utilizing
ortillius
to
do
the
deployment
is
when
we
deploy
this
application
version
to
the
environment,
we'll
incrementally
figure
out
what's
changed
and
only
deploy
the
change
pieces
for
that
application
version.
So
we're
not
going
to
redeploy
everything
all
the
time
and
typically
the
deployment
step
will
be
somewhere
else
in
your
pipeline.
You
may
do
a
bunch
of
like
security
scans,
some
test
cases
and
then
eventually
you
go
and
do
the
deployment.
A
A
A
A
A
A
B
A
Basically,
you
can
cut
and
paste
this
in
change
your
domain
names.
You
know
what
you're
gonna
call
things
your
login,
yeah
yeah
and
that's
gonna,
be
you
know
like
basically
the
what
I
would
call
the
hard-coded
piece.
You
know
just
giving
us
some
names,
because
if
some
of
this
could
be
theoretically
derived
so
like
you
may
have
a
domain
out
there,
that's
everybody's
gonna
be
using
so
you
haven't,
got
gotten
to
a
domain
driven
design
level.
Yet
so
you're
just
going
to
throw
everything.
B
B
A
B
So
at
the
moment
everything's
done,
you
know,
like
you
just
mentioned,
that
with
groovy,
I
don't
have
control
over
that
stuff.
It's
done
by
a
run
team,
so
I've
got
the
pipe.
I
can
use
the
pipelines
whenever
I
want
to
even
create
my
own.
That's
why
I
asked
the
question
of
how
to
integrate
jenkins
yeah.
I
could
integrate
this
into
jenkins.
B
A
A
A
Okay,
so
so
pre-build,
you
can
even
actually
do
this
a
lot
of
this
post
build
as
well,
but
basically
you
want
to
log
this
derived
information,
the
derived
image
digest.
So
you
could
actually
do
this
as
well,
but
we're
if
you're
not
using
like
here
we're
using
the
derived
values,
but
if
you're,
if
you,
if
you
ignore
that
and
you're
just
using
like
pre-defined
values,
we
can
move
a
lot
of
this
to
post,
build
and
you'll
just
need
to
add
in
this
the
dh.
A
B
B
A
A
A
A
A
A
But
you
will
have
some
so
sasha.
You
will
have
some
stuff
that
you
could
put
into
your
config.json,
but
you
still
will
need
a
couple,
little
updates
to
your
pipeline
file,
your
jenkins
file
and
then
down
the
road.
You
could
probably
wrap-
or
you
know,
move
those
into
the
jenkins
libraries
that
there
you
they
they
have
like.
A
C
C
So
it
means
every
microservice
if
I
have
let's
say
10
micro
services,
so
I
have
10
components
listed
in
ordinance
dashboard
exactly
yes,
that's
right
and
another
another,
because
we're
talking
about
the
building
the
pipelines.
What
I
feel
from
the
last
day
I
attending
the
city
on
the
people
are
questioning
about
that.
Let's
say
you
have
a
micro
services,
then
you
trigger
out
the
bill,
but
there
are
some
few
tools
that
are
really
feasible.
C
C
A
A
One
of
ours
I
feel
like
I
get
the
web
or
we'll
get
docs,
so
this
is
actually
being
done
through
google
cloud
build.
This
is
our
our
documentation
website
and
you'll
see
here
we're
doing
something
very
similar,
so
we're
setting
up
those
environment
variables.
You
know
the
name
of
the
application,
the
repo
those
type
of
things
so
you
can
see
here
is
we're
deriving
that
the
version
number
again
as
part
of
that.
So
slightly
it's
the
same
data.
It's
just
the
way
google
cloud
build.
A
A
You
know,
containers
and
stuff
like
that
at
that
point,
so
this
is
actually
running
a
a
docker
image,
so
we
actually
take
our
dh
program
and
wrapper
it
up
into
a
container.
That's
all
ready
to
go
as
well,
and
you
can
run
the
container
instead
of
installing
the
python
library.
So
our
our
deploy
hub
comp
update
image
has
everything
installed
on
it
already
ready
to
go
so
it
we
can.
We
can
and
the
short
answer
is
we
can
fit
into
any
of
those
tools.
C
A
A
A
A
A
A
Let's
say
we
want
the
payment
service
and
the
shipping
service
these
two
here
we
want
to
tightly
couple
so
they're
always
deployed
these
two
version.
16
of
the
payment
service
in
version
17
of
the
shipping
service,
are
always
deployed
together.
That's
going
to
be
what
we're
calling
a
component
set
and
we'll
tightly
couple
those
services,
those
versions
of
the
services
together
in
the
component
set,
and
then
the
application
will
consume
a
component
set
up
at
that
level.
A
B
B
A
B
A
C
Was
he
what
I
like
to
do
is
in
the
dashboard?
Is
that
when
you
have
a
visualizer,
I
see
we
discussed
that
before
this
service
smash
and
githubs,
and
this
kind
of
thing
is
on
the
roadmap.
I
want
to
see
in
the
dashboard
that
I
click
on
the
service,
and
I
I
by
clicking
the
service
I
can
adding
the
side
guard
into
it
and
then
automatically
behind
the
curtain.
Service
mesh
is
integrated
into
it
and
when
I
click
in
there,
I
go
back
to
the
linkedin
or
skew
dashboard
and
visualize
all
the
metrics.
A
C
That's
my
dream
of
the
because
clicking
on
the
services
you
can
integrate
the
site
card
and
service
mesh.
You
don't
have
to
write
so
many
ml
files.
I
think
that's
everyone
is
looking
forward
to
it.
If,
if
that
is
going
to
be
happen
there,
I
I'll
love
that
this
is
absolutely
what
people
like
about
it.
A
Yeah,
so
some
of
the
things
I
can't
find
the
the
the
application
version
I
was
playing
with,
but
some
of
the
things
like
we're,
adding
in
like
the
pager
dirty
pagerduty
service,
url,
so
that'll
be
a
clickable
link
to
take
you
to
the
the
data
on
the
the
the
service.
You
know
what
what
is
the
escalation
policy
that
type
of
thing
who's
the
contact?
So
things
like
you
know,
I'm
at
a
a
component
level.
A
So
one
of
the
things
that's
tricky
that
you're
talking
about
is
visualizing
that
information
across
the
pipeline
there's
tools
out
there.
That
will
just
look
at
like
the
production
cluster
and
we
can
look
at
the
service
mesh
for
production
and
give
you
a
view
of
that.
But
if
this
that
this
service
has
been
deployed
to
not
only
to
it's
made
it
through
the
pipeline,
it's
gone
from
dev
to
qa
to
production.
I
want
to
be
able
to
see
how
the
service
meshes
is
acting
and
configured
in
qa
versus,
what's
how
it's
configured
in
production.
A
So
that's
one
of
the
challenges
because
we
sit
so
high
up
in
the
the
view
of
the
world
that
we're
looking
across
all
the
clusters,
all
the
environments
and
what
we'll
probably
end
up
doing
is
adding
on
additional
boxes
here
that
will
list
the
environment
that
this
been
that
this
service
has
been
deployed
to
and
do
a
link
that
says
view
service
mesh.
You
know
view
the
container
logs.
A
So
they're,
you
know.
The
number
of
clusters
that
like
airbnb
is
running
is
in
the
thousands
just
to
support
a
a
single
service.
So
we
have
this
this,
this
additional
layer
that
we
have
to
kind
of
navigate
through
that
we
have
to
work
on
the
visualization
side.
But
I
hear
what
you're
saying
I
I
want
to
get
there
too.
We
just
got
to
figure
out
the
right
road
map
to
do
the
navigation
to
get
that
all
pulled
together.
C
A
Oh
so
for
serverless
serverless
like
lambda
function
is
just
another,
a
another
component
version,
so
it
doesn't
for
us.
We
track
it
because
we
don't
store
anything.
We
just
do
pointers.
We
can
point
to
the
get
repo
that
is
being
used
to
store
the
lambda
code
in,
for
example,
there's
there's
where
it
is
when
it
when
we
deploy
to
lambda,
we
record
that
we've
run
basically
aws
command
to
deploy
the
land
the
function
into
the
serverless
environment.
We
record
all
that
information.
A
So
from
there
we
still
could
have
a
like
a
swagger
endpoint
file
so
how
to
interact
with
that
lambda
function.
We
can
have
that
that
details
license
consumption
and
cves
probably
aren't
going
to
be
as
critical.
I
haven't
figured
out
how
to
scan
a
lambda.
You
can
actually
scan
the
like
the
python
code
for
the
cves
before
it's
placed
up
in
the
into
aws,
but
that's
the
type
of
thing
that
we're
working
on
gathering,
so
the
swagger
will
be
just
for
this
service.
What
what
is
this?
C
A
A
A
A
So
in
this
case,
like
an
application,
server
would
be
like
a
tomcat
server
or
a
jetty,
or
something
like
that.
You
know
more
traditional
server
and
the
kubernetes
definition.
It
says
this.
This
server
knows
how
to
talk
to
kubernetes
what
we
do
with
the
component
types
and
the
endpoint
types
is
we'll
automatically
route
at
the
deployment
time
using
the
artillious
deployment
engine
route,
components
to
the
right's
endpoints
as
part
of
the
deployment
process.
A
So
let's
say
we
have
we'll
just
take
a
traditional
application,
we're
going
to
deploy
an
ear
file,
and
so
we
have
an
ear
component
and
we
have
a
database
component,
for
we
have
two
endpoints
in
our
environment,
one
for
the
database
server
one
for
the
tomcat
server.
When
we
go
through
and
do
our
deployment
the
deployment
engine
will
go.
Oh
I
have
this
component,
it's
an
it's
going.
It
needs
to
go
to
the
application
server.
That's
going
to
be
the
ear
file
I'll
route
that
over
to
the
tomcat
server
now.
A
My
second
component
I
have
is
the
mongodb
server-
is
a
mongodb
type.
I
know
automatically
to
route
that
over
to
the
database
server
as
part
of
that
process.
So
that's
where
the
the
custom
types
and
kind
of
come
into
play,
if
you're
not
using
the
artilleries
deployment
engine
they're
more
for
just
like
tagging
and
references.
B
B
A
And
then
it's
it
will
then
associate
over
to
the
components
so
and
that's
one
of
the
things,
because
we
have
a
component
really
isn't
a
thing.
You
know
it's
not
like
a
it's
just
a
pointer
to
a
thing.
You
can
use
a
component
for
your
terraform.
You
can
use
a
component
for
your
test
cases.
You
could
use
a
component
for
your
database.
Your
containers,
your
serverless,
even
config
maps
can
be
a
component
and
what
that
allows
us
to
do
is
when
we
look
at
an
application.
A
I
picked
a
bad
one.
Oh
there,
it
is
at
the
bottom.
We
can
associate
different
versions
of
those
components
to
that
version
of
the
application,
so
you
can
think
of
application
versions
as
the
packaging
step,
and
we
want
to
pull
in
different
versions
of
the
components
into
that
version
of
you
know
that
packaged
version
of
the
application.
A
So
if
you
need
a
specific
version
of
your
terraform,
then
you
need
a
specific
version
of
your
config
map
or
you
need
a
specific
version
of
your
istio
of
your
of
your
service
mesh
to
be
defined.
All
those
can
be
component
versions
that
we're
going
to
pull
together
and
have
it
all
in
one
place.
So
we
understand
what
is
our
runtime
environment
for
that
application
to
you
know
to
be.
B
A
You
know
you
can
have
actions
at
the
pre-post
custom
actions
at
the
application
level,
the
component
level.
So
after
something's
deployed
post
deployment,
you
could
say
go
run
all
the
test
cases
I
just
deployed
and
you
can
make
sure
that
those
are
being
executed
and
recorded
as
part
of
that
process.
A
A
We
can
actually
query
from
the
jenkins
pipeline
the
list
of
components
and
the
test
cases,
and
we
can
say:
oh
this
application
has
these
test
cases
associated
with
it,
I'm
going
to
get
that
list
and
pass
it
off
to
jenkins
now
to
go
off
and
do
all
the
the
actual,
heavy
lifting
and
running
the
test
cases
for
me
wow.
That's
amazing,.
B
A
B
Yeah,
so
so,
for
example,
if
I
go
make
a
pr,
I
have
to
take
my
branch
first
and
make
a
pr
and
I
commit
it,
it
create
it
as
a
plan,
but
it
doesn't
apply.
There's
a
the
last
gate
is
for
someone
from
from
the
cloud
platform
team
to
approve
that
for
that
advantage
and
then
atlanta's
all
around
their
plan.
Yeah.
A
B
B
Yeah,
because
what
I'm
finding
is
that
atlantis
will
show
you
your
output
of
the
plan
in
the
pr
right,
so
you
can
drop
down
like
a
little
drop
down
and
it
shows
you
what
it
ran
right,
but
once
your
pr
has
been
approved
and
gone,
it's
almost.
It
almost
feels
like
it's
really
pretty.
It's
like
a
bit
of
a
mission.
You've
got
to
go
and
find
your
pr
again.
B
B
A
Like
that,
oh
and
you
just
want
to
go,
look
at
the
log
to
see
how
it
it
defined
your
your
your
node,
your
node
pools
that
information
that
link
we
can
associate
back
to
the
either
at
the
component
level
or
at
the
application
level,
or
even
at
the
environment
level.
We
can
do
it
at
three
pla
at
the
any
of
the
three
places.
A
A
B
I
think
I
might
be
getting
the
wrong
terminology,
so
just
correct
me
guys
they
changed
this,
I'm
trying
to
remember
what
they
did.
If
somebody
changed
the
service
mesh
they
took,
they
it
was.
There
was
public
and
private.
I
think,
and
someone
took
the
private
off
so
and
I
had
a
big
presentation
to
do
on
the
monday
and
I
couldn't
fall
for
it
anymore.
B
A
A
What
jenkins
has
done
for
creating
that
that
new
component
version
and
then
the
second
step
is
the
deploy
piece
so
we'll
either
deploy
using
the
deploy
of
ortiz's
deployment
engine
or
we'll
record
that
jenkins
did
the
deployment
either
way.
We
have
that
second
step
in
our
our
pipeline
to
record
what
happened
as
as
part
of
the
action
and,
like
you
said,
sasha
is
we're.
A
Ortelius
is
logging
what's
happening
in
your
pipeline
process,
and
so
we
provide
visibility
into
what's
happening.
You
know,
because
we
know
that
a
component
was
created
now.
Some
of
the
things
we
didn't
get
into
that
are
available
is,
if
you
create
a
new
component
and
you
don't
know
who,
which
applications
are
consuming
it.
As
long
as
we
have
a
base
definition,
or
at
least
one
association,
we
can
turn
on
a
flag.
A
B
A
B
A
You
know,
if
you
look
at
I'm
just
going
to
monitor,
prod
and
always
look
at
what
prada
is
doing.
That's
the
easy
purple.
If
we
from
the
artelia
side,
we
want
to
look
at
it
from
the
highest
point
of
view
across
every
single
cluster,
every
single
environment,
because
you
want
to
be
able
to
compare
what
you
know
production's
running
great.
Do
we
have
a
mirror
in
qa?
A
Are
we
in
sync
between
qa
and
production,
so
the
developer
needs
to
test
something
or
we're
getting
a
wobble
in
production?
Are
we
seeing
the
same
wobble
in
qa
or
if
we're
going
to
hit
qa
with
a
load
test,
how
that's
going
to
run
and
if
we
need
to
make
it,
you
know
we
need
to
have
those
comparisons
in
place
to
have
that
real
world
view
of
an
application
not
only
from
the
production
view,
but
from
what
the
developers
are
are
making
on
their
side.
You
know
their
little
little
changes.
C
Last
few
one
of
the
recommendations,
suggestions
from
my
side
is,
I
see
in
the
class
native
landscape.
That's
really
a
very
valid
case.
We
talked
about
this
before
the
discord
as
one
of
the
project
that
I
really
have
an
eye
on,
for
whenever
this
launch
is
name
is
cubella.
So
what
you
try
to
solve.
The
problem
is
that
you
have
don't
write
a
yaml
file.
You
just
write
a
configuration
file.
It's
build
out
the
yaml
file
for
you
and
deploy
to
the
kubernetes.
C
That's
called
open
obligation
model,
so
they
do
it
tremendously,
but
later
down
the
road
they
do
stuff
that
they
don't
expect
to
do
like
progressive
delivery.
It's
not
a
job
for
gilbert,
so
they're
putting
stuff
so
much
into
it.
So
they
lost
focus.
What
is
trying
to
solve
the
problem,
so
I
think
right
now,
ortillius
and
deploy
hub.
There
are
so
many.
I
think
we
are
living
in
a
micro
services
world
and
we
have
floods
of
information.
A
C
C
I
think
we
have
a
build
job
for
building
the
images
talker
is
doing
so
docker
is
actually
an
entire
stack
that
doing
so
many
things
now,
people
like
to
run
their
tools
like
container
d,
cryo,
building
tools
like
new
job
and
eco,
and
there
is
so
much.
I
think
the
ship
ride,
I
think,
is
a
union
of
builder
and
I
think,
an
eco.
They
have
built-ins
the
union
of
both
of
those.
So
I
think
that's
a
great
tool
I
have
tested
out.
A
B
B
Yeah,
so
this
is
so.
This
was
one
of
the
most
amazing
sessions
here,
because
I'm
dead
I
want
to
run.
My
goal,
is
to
run
autelius
and
show
them
a
real
live
demo
of
it
actually,
with
the
one
of
the
applications
for
the
business
that
it's
being
mapped
yeah,
because
I
did
a
demo
for
people
and
cool
sure
there
was.
There
was
test
data.
You
know,
you've
got
this.
B
A
A
A
B
C
I
think
sasha,
where
you
have
this
kind
of
thing.
I
think
it's
the
perfect
time
to
do
some
blog
post,
writing
for
that
or
might
be
putting
on
some
youtube
video
for
that
and
for
the
kubernetes
content
and
service
match.
I
am
absolutely
up
to
it.
I
think
we
are
doing
this
kind
of
stuff
regularly,
because
I
think
we
are
doing
a
r
d
work
on
a
lottery,
because
we
need
to
search
and
search
on
the
internet.
C
What
are
the
tools
we
need
to
integrate
with
hoteliers
yeah
before
we
reinventing
the
wheel,
because
there
is
so
many
tools
out
there
that
I
think
is
help
our
job
really
easy.
So
I
think
we
have
to
do
this
kind
of
session,
and
tonight
steve
you
put
down
of
so
many
great
information
to
us
and
hopefully.