►
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
All
right,
hi
everyone
today
we're
gonna,
go
ahead
and
get
started,
and
thank
you
for
joining
us.
Welcome
to
today's
cncf
live
webinar
how
to
manage
kubernetes
application
life
cycle
using
carpal,
I'm
libby
schultz
I'll
be
moderating
today's
webinar,
and
I
want
to
welcome
our
presenters,
helen
george
product
manager
for
carville,
vmware
and
joel
pereira.
A
Where-
and
I
know
I
didn't
say
it
right,
so
I'm
gonna,
let
you
tell
everyone
to
correct
me,
a
few
housekeeping
items
before
we
get
started
during
the
webinar.
You
are
not
able
to
talk
as
an
attendee
inside
the
chat
icon
at
the
top
is
a
q,
a
specific
box
for
q,
a
please
feel
free
to
drop
your
questions
there
and
then
we'll
get
to
as
many
as
we
can.
At
the
end.
This
is
an
official
webinar
of
the
and,
as
such,
is
subject
to
the
cncf
code
of
conduct.
A
Please
do
not
add
anything
to
the
chat
or
questions
that
would
be
in
violation
of
that
code
of
conduct
and
please
be
respectful
of
all
of
your
fellow
participants
and
presenters.
Please
also
note
that
the
recording
and
slides
will
be
posted
later
today
to
the
cncf
online
programs
page
at
community.cncf.io,
under
online
online
programs.
B
B
So
today's
agenda,
if
we
go
to
the
next
slide,
is
it's
simple,
as
you
can
see,
first
we'll
talk
about
what
carbo
is
what
problem
carbo
is
solving.
After
that
we
will
spend
a
majority
of
our
time
demonstrating
how
you
can
use
carvo
and
talk
about
its
benefits.
Then
we
will
wrap
up
our
time
with
some
q
a.
B
So
my
name
is
helen
george,
I'm
a
product
manager
from
vmware
working
on
project;
carvel.
I've
been
with
vmware
for
about
a
year
before
that
I
worked
at
various
consulting
firms,
helping
customers
build
products
in
various
industries
ranging
from
healthcare
travel
and
finance,
and
here's
my
co-speaker
for
the
day.
C
Hello,
I
am
joao,
I'm
also
in
vmware,
I'm
a
software
engineer
that
works
on
the
karmal
tools
and
I've
been
with
vmware
for
roughly
a
year
now.
Prior
to
that,
I
worked
in
pivotal
and
I
worked
in
projects
for
from
cncf
like
build
packs.
I
worked
also
as
part
of
the
team
that
worked
in
kpac
and
yeah.
That's
it.
B
Cool
so
yeah,
let's
get
started.
What
is
carval
so
carvo
is
a
set
of
kubernetes
tools.
Note
deploy
there,
so
it's
not
a
single
tool,
but
rather
a
tool
suite
that
help
application
developers
and
platform
operators
to
build
kubernetes
applications,
distribute
them
and
install
them.
It
consists
of
single
purpose,
composable
tools
based
on
unix
philosophy,
so
each
tool
does
one
thing
very
well,
and
yet
they
work
well
together
to
go
further
to
name.
B
A
few
carbo
consists
of
ytt
k,
build
image,
package,
cap
and
vendor,
and
there
are
other
tools,
such
as
cap
controller,
which
is
used
for
package
management
and
also
we
have
other
experimental
tools
which
you
can
learn
more
about
from
our
website
carvalho.dev,
but
in
today's
webinar
we
will
only
cover
the
tools
shown
on
the
slide
here.
B
So
what
are
these
tools,
and
what
are
they
for
before
we
jump
into
what
these
tools
are,
we
would
like
to
take
a
step
back
and
show
the
problem
space
we
are
playing
in
since
kubernetes
ecosystem
is
big
and
vast.
This
will
help
us
understand
where,
in
the
kubernetes
landscape,
carbo-tool
suite
fits
in.
B
So
what
you're
looking
at
here
right
now
is
a
simple
workflow
from
application
definition
to
management
of
its
lifecycle
on
kubernetes.
You
might
have
heard
of
this
referred
to
as
day
one
and
day
two
operations
day.
One
operations
involve
developing
and
deploying
software
that
was
designed
on
day,
one
which
is
not
represented
here.
B
We're
gonna
start
from
day
one
today
and,
and
then
this
workflow
we're,
starting
with
the
building
the
app
into
container
image
and
as
part
of
the
process,
the
application
developer
will
describe
the
details
for
deployment
with
manifest
and
then
parameterize
configurations,
and
those
configurations
will
make
it
easy
for
the
platform
operator
to
make
changes
to
deployment
details
if
needed
and
later
in
the
workflow.
B
So
platform
operators
will
manage
the
application
and
storage
life
cycle
and
date
to
operations
doing
such
as
backup
and
failure.
Recovery
they'll
be
also
scaling.
The
platform
as
the
demand
grows,
perform
upgrades
whenever
a
new
version
of
the
application
and
its
dependencies
are
made
available
and
also
install
security
patches.
If
any
vulnerabilities
are
found,
so
where
does
carbo
fit
in
what
problems
carbo
is
solving
here
then?
B
So,
if
we
go
to
the
next
slide
now
that
we've
gone
through
the
whole
development
deployment
life
cycle,
we'll
show
you
where
carboxy
fits
into
to
this
workflow.
So
as
mentioned
earlier,
we
had
the
units
philosophy
in
mind
when
we
first
created
karvo,
because
we
wanted
to
prevent
it
from
be
becoming
a
monolithic
tool
which
is
hard
to
use
it
with
other
tools,
and
we
don't
want
that.
B
So
now,
looking
at
the
day,
one
operations
you
see
ytt,
which
stands
for
yaml
templating
tool
and,
as
you
can
guess
from
the
name,
it
is
a
yamo
templating
tool.
So
it's
structural
aware,
which
is
really
convenient
and
it
is
used
for
authoring
and
customizing
configuration
next.
Cable
is
used
for
building
container
images
and
image
package
is
used
for
packaging
and
relocating
those
package.
Configurations
and
images
cap
is
used
to
deploy,
applications
to
clusters
and
cap
is
really
good
at
ordering
kubernetes
resources
during
deployment.
So
it
prevents
you
from
getting
into
this
weird
race
conditions.
B
We'll
show
you
more
of
cap
in
action
during
the
demo
later
so
carbo
12c
tool
suite
can
also
be
used
for
day
two
operations,
as
the
diagram
shows
just
like
how
you
use
them
to
customize,
build
move
and
install
applications
for
day
one
operations.
You
can
do
the
same
for
upgrading,
patching
and
scaling
this
way
you
can
operate
applications
in
the
production
environment
in
the
repeatable
and
the
reliable
fashion,
in
the
same
way
that
you
have
done
in
the
past
so
and
yeah.
B
Another
advantage
of
carvel
is
that
it
meets
users
where
they
are.
What
I
mean
by
that
is
that
you
can
decide
to
mix
and
match
different
tools
in
your
workflow.
So,
for
example,
here
you
can
easily
swap
a
cap
here
and
you
can
use
cucudo
instead
to
do
deployments
or
you
can
swap
out
ytt
with
either
helm
or
customize
for
templating.
It's
really
up
to
the
user
to
choose
the
right
tools
that
work
best
for
them.
C
Cool,
thank
you
ellen,
so
we're
going
to
we're
going
to
look
at
an
application,
I'm
just
going
to
roll
back
a
little
bit
just
we're
going
to
step
through
all
these
steps
during
this
process
and
we're
gonna
use
the
the
carvel
tool
suite
in
order
to
to
move
us
forward.
So
what
what
we
have?
What
we
have
to
show
y'all
today
here
is:
we
do
have
a
small
application
that
we
built.
C
That
is
an
application
that
basically
stores
projects
that
are
a
name
in
the
description
into
acrd,
and
it's
able
to
read
it
so
like
this
is
the
the
application
that
we
are
going
to
show
here
today
and
to
start
us
off
we're
going
to
use
a
tool
that
we
didn't
specify.
We
didn't
show
in
the
in
the
flow
that's
when
there
and
we
are
going
to
use
vendor
because,
like
vendors,
an
application
also
part
of
the
carnval
tool
suite
that
allows
us
to
synchronize
directories
in
in
your
operating
system,
for
example.
C
So
what
we're
going
to
use
vendor
for
is
we
standardize
that
we
need
some
versions
of
the
carvel
tooling
to
develop
our
software
and
we
are
going
to
use
vendor
to
retrieve
them
and,
as
you'll
see
in
the
configuration
we
are
setting
up?
Where
do
we
want
to
retrieve
those
those
binaries
and
vendor
is
going
to
do
everything
for
us,
so
vendor
has
is
able
to
download
github
releases
files
from
github
releases.
So,
for
example,
in
here
we
see
that
on
this.
C
C
You
can
retrieve
github,
github
or
git
repositories
and
as
we'll
see
in
a
step
in
in
in
a
little
bit
in
the
next
step,
but
you
can
also
get
some
blobs
some
files,
some
directories
that
are
present
in
in
other
places,
so
we're
going
to
just
start
off
by
initializing
our
environment.
By
just
doing
a,
I
created
a
make
file
to
get
us
everything,
because
we
need
also
to
move
the
files
into
the
binaries
and
shmot
them
as
well.
C
So
this
is
while
this
is
running,
let's
go
and
talk
a
little
bit
about
our
application,
so
this
is
done
and
now
you'll
be
able
to
see
that
in
our
bin
folder
we
do
have
all
the
applications
that
we
are
going
to
use
for
this
part
of
the
demo.
C
So
this
is
let's,
let's
start
from
the
beginning,
he
was
a
software
developer
created
this
application,
but
now
you
need
to
install
it
somewhere
and
for
that
we're
going
to
install
it
in
kubernetes,
so
we'll
have
all
our
crds,
not
crds,
but
all
our
manifest
and
our
deployment
configuration
that
we
need
to
store
right.
C
So
we
created
a
deployment
folder.
These
are
not
like
mandatory.
We
just
decided
to
put
them
here
and
we
have
our
configuration
and
each
of
these
files.
It
is
so
these
are
template
files
for
ytt
and,
as
you
can
see,
this
is
using
annotation
for
ytt,
but
it
is
a
plain
yaml
configuration
file.
So
ytt
will,
when
invoked,
will
replace
all
these
values
as
a
template,
a
templating
engine
that
will
replace,
like
all
of
these
files,
with
the
values
that
we
provide
to
ytt.
So
we
do
have
applications.
C
We
do
have
a
definition
of
crds
right
here
and,
as
you
can
see,
there
are
replacements
there
and
because
to
for
ytt
we
we
use
starlark
as
a
the
language
that
is
going
to
do
the
processing
so
you're
able
to
create
starlark
files
that,
in
the
end,
they
pretty
much
look
like
python,
because
starlark
is
somewhat
a
subset
of
of
python.
C
So
you
can
create
functions
in
a
star
file
and
then
you
can
just
load
the
star
file
and
load
the
function,
project,
crd
and
call
it
project
crd,
and
you
can
then
just
invoke
it
and
we'll
be
able
to
see
that
it
is
going
to
replace
the
the
values.
So
in
this
case
it's
going
to
replace
by
projects
and
then
whatever
comes
from
the
data
values
file.
Crd.Group,
so
this
these
are
like
the
configuration
files
more
or
less
one
new
feature
that
we
are
rolling
out.
It's
still
experimental
our
schemas.
C
What
what
are
schema
schemas
are
from
the
developer
side
is
to
tell
whoever
is
deploying
what
are
the
values
that
you
can
change?
What
are
the
values
that
you
can
parameterize
on
your
on
the
deployment
side?
That
will
be
that
will
be
used
then
later
so
another
thing
that
this
schema
will
allow.
It
will
allow
you
to
sh
tell
what
is
the
shape
of
the
these
data
files.
C
These
are
the
values
so,
for
example,
you'll
have
a
crd
that
is
going
to
be
an
entry
to
a
map
that
will
contain
a
map
that
will
have
a
group
and
a
version
keys,
and
these
both
are
strings
right.
So
this
is
telling
the
the
deployer
that,
if
they
want
to
change
this,
the
group
of
this
crd-
which
in
this
case
we
do
not
advise,
but
if
you
want
to
change
it,
you'd
have
to
put
a
string
there.
C
So
this
is
very
experimental.
We're
starting
playing
developing
this,
so
the
the
major
annotation
that
it
has
at
this
point
is
schema
nullable,
where
you
can
say
that
the
description
for
the
projects
can
be
no,
so
it's
it
doesn't
need
to
to
be
present
when
you
are
defining
the
projects.
C
So
another
thing
that
I'd
like
to
call
out-
and
this
is
kind
of
specific,
but
if
you
define
an
array
so,
for
example,
projects
is
an
array,
the
default
value
that
you'll
have
when
you
generate
the
schemas
is
going
to
be
an
empty
array.
C
Something
that
I
forgot
to
say
is
that
this
works
as
also
the
default
values.
So
you
don't
need
to
set
up
example,
karl
dev.
It
will
come
by
default,
so
just
to
give
you
a
little
test
out
just
to
look
at
how
this
would
work,
I'm
just
going
to
create
a
file
called
data.yaml,
and
what
I'm
going
to
do
is
this
is
going
to
be
a
datavalus
file,
and
what
I
want
to
do
is
I
want
to
add
to
our
projects.
C
I
want
to
add
three
projects,
one
two
and
three
and
as
you
can
see,
the
description
is
only
present
on
the
last
one,
as
we
said
on
our
schema
that
can
be
nullable
and
and
yeah.
So
let's
take
a
look
and
let's
try
to
run
this
and
see
what
happens
when
we
run
ytt
with
our
with
our
information
with
our
files.
So
let's
first
take
a
look
at
the.
What
how
we
call
ytt.
C
So
we
are
providing
all
the
configuration
files
that
we
have
in
this
folder
plus
our
data
values
file
and
we
do
have
to
enable
the
experimental
schema
flag
because
we're
not
yet
it's
not
yet
like
live.
So
you
need
to
enable
it
there.
But,
as
you
can
see
like
previously,
our
namespace
didn't
had
anything
here.
It
had
like
the
ytt
templating
information,
but
now
it
got
replaced
by
project
app
and
a
more
interesting
part
is
in
here.
If
you
go
to
the
bottom,
where
we
see
the
projects
where
we
previously.
C
So
let's
take
a
look
at
what
the
projects
look
like.
It
is
a
for
loop
that
we
literate
over
the
project's
value
and
then
it
will
create
a
custom
resource
for
each
one
of
them.
So
if
we
look
at
it,
it
is
creating
a
custom
resource
for
each
one
of
them
and
on
the
only
one
that
has
a
description
is
the
last
one.
Okay,
so
it
looks
like
everything
is
working,
so
the
next
step
in
our
process
would
be
okay,
so
we
do
have
configuration.
C
We
saw
that
our
configuration
is
working
by
creating
like
this
ytt
that
values
file.
So
what?
Next
now
we
need
to
build
our
application
and
create
a
create
a
an
oci
image
with
it.
So
we
do
have
a
tool
that
does
that
it
is
called
k
build.
So
I'm
just
going
to
run
it
right
away
because
it's
going
to
take
a
little
bit
to
compile.
C
While
I
talk
about
what
what
cable
does
cable
is,
is
an
orchestrator
that
uses
applications
that
you
have
installed
in
your
machine
or
in
a
kubernetes
cluster
to
build
your
application.
So
in
this
case,
what
what
is
doing,
what
cable
is
doing,
is
it's
looking
at
our
configuration
file
that
we'll
see
in
a
bit?
C
It
provides
also
the
deployment
and
I'll
explain
why
in
a
little
bit,
and
then
we
provide
this
other
flag
that
we'll
discuss
in
a
little
bit
as
well.
So,
let's
start
from
looking
at
our
configuration
file,
so
our
configuration
file
was
this,
the
one
that
I
used.
No,
I
use
the
hub
one.
So
it's
interesting
that
if
you
see
I
do
have
two
different
configuration
files
that
differ
only
on
the
destination.
C
C
This
is
the
place
where
it's
going
to
read
the
information
from
so
because
we
didn't
just
specify
anything
it's
going
to
use
docker,
so
it's
going
to
search
for
a
docker
file
in
the
in
this
path.
In
this,
in
our
case,
we
do
have
a
docker
file
he's
here,
so
it
works
and
we're
going
to
you
tell
it
tell
that
we
want
to
say
we're
going
to
push
this
image
into
gcr
in
this
case
or
into
docker
hub,
we'll
see
how
that
went
in
a
little
bit.
C
Another
thing
that
that
you
can
do
is
I
have
another
example
here
where
we're
using
pac
the
build
packs
from
the
wheel,
packs
project
and
it
uses
the
pack
builder
in
order
to
build
the
image
so
cable
supports,
building
images
for
using
docker,
build
using
build
kit
using
pack
and
recently
in
the
newer
version.
It
also
allows
co
to
build
images
using
co,
so
it
is
an
orchestrator.
C
So
the
second
thing
that
that
we
talked
about
was
that
you
need
to
provide
a
configuration
file,
a
deployment
so
that
k
build
knows
what
are
the
images
that
need
to
be
built.
So
if
we
go
back
into
our
application,
that's
the
file
you'll,
see
that
in
our
deployment
we
did
set
up
our
image
as
project
app
image.
C
So
cabled
will
search
for
this
name
here
to
see
if
it
is
used
in
the
in
the
configuration
files
that
we
have
and
if
it
is
used,
then
it
will
build
it
and
you'll
see
that
the
output
from
from
k
build.
So
the
output
from
cable
tool
will
replace
where
you
had
previously
the
image
projects
app
image.
It
will
replace
it
with
a
full
image
name.
B
C
C
So
you
can
use
ytt
to
generate
the
templates
cable
to
replace
the
images
and
afterwards
you
can
use
cap
as
we'll
see
in
a
little
bit,
but
basically
it's
just
a
docker
build
and
then
it
pushes
the
image
to
the
place
where
we
asked
it
to
push
the
image
to
and
that's
it
so
looks
like
that.
Cable
was
able
to
create
the
image
that
we
want.
So
the
next
thing
we
want
to
do
is
we
need
to
package
our
application
and
so
that
our
deployer
can
deploy
it
in
in
their
cluster.
C
C
This
configuration
files
here
and
you
will
need
the
oci
image.
So
let's
take
a
look,
and
how
might
we
do
this?
I'm
gonna
do
first,
I'm
gonna
copy
a
file
that
do
you
remember.
I
say
I
said
that
we
would
look
at
this
image
log
output
afterwards,
now
it's
the
afterwards,
so
I'm
just
gonna
copy.
It
sorry
didn't
copy
what
I
asked
it
to
copy,
which
is
good.
C
So
let
me
paste
that
so
I'm
just
going
to
make
a
new
folder
called
bundle,
I'm
going
to
give
it
another
folder
underneath
it
that
is
dot
image
package.
This
is
a
structure
that
is
fixed
and
you
need
to
follow
it
in
order
for
image
package
to
know
that
this
is
a
bundle
and
we're
going
to
copy
the
the
file
that
we
just
created
from
from
k,
build
and
we're
going
to
put
it
inside
of
it.
C
So
this
is
called
the
image
log
file
and
if
we
look
at
it,
what
it
contains
is
a
list
of
all
the
images
that
will
be
contained
in
our
bundle.
So
you'll
see
here
the
image
and
it
contains
the
full
image
with
the
shadow
27c.
C
So
we
are
saying
to
image
package
that
this
image
is
part
of
our
bundle
is
part
of
our
bundle,
so
let's
call
image
package
and
create
our
bundle.
Okay.
So
there,
let's
paste
that
and
as
you
can
see,
I
am
what
image
package
is
doing,
we're
asking
it
we're,
pushing
a
bundle.
That
is
a
group
of
images
plus
configuration
into
this
particular
place.
C
That
is
docker
hub
and
we
want
to
include
in
this
bundle
our
bundle
folder
that
contained
only
the
structure
to
create
an
image,
an
image
package
bundle
plus
all
our
configuration
folder.
So
you
don't
need
to
specify
these
separately.
I
just
did
it
so
you
know
that
you
don't
need
to
select
a
single,
a
single
folder
and
you
can
see
how
this
all
works.
So
the
in
you
can
you
can
see
all
the
information,
all
the
things
that
were
attached
to
the
bundle.
C
This
is
also
an
oci
image
and
is
saved
into
the
registry,
and
there
you
go.
This
is
where
our
this
is,
where
our
image
is
right
now,
so
the
as
you
can
see
this
sha
here,
this
is
going
to
be
important.
We're
going
to
use
it
because
now
that
we
have
this
in
a
public
place,
we
want
to
provide
to
our
deployer
to
the
person
that
is
going
to
deploy
this
application.
C
We
want
to
provide
it
this
shot
so
that
okay,
sorry
about
that
we're
going
to
provide
to
our
deployer
this
shot,
because
this
is
what
the
deployer
is
going
to
use
in
order
to
be
able
to
deploy
the
application.
So
if
we,
if
we
look
at
here,
if
we
look
at
our
next
step
here,.
C
At
the
deployer
side,
what
we'll
have
only
is
going
to
be
our
sha,
so
the
first
thing
that
we
are
that
we
want
to
do
as
a
deployer,
because
we
are
concerned
that
we
want
to
have
the
images
saved
in
our
private
registry,
because
we
want
to
make
sure
that
if
something
happens
to
docker
hub,
we
still
have
an
image
that
can
be
pulled
from
our
local
registry.
Oh,
what
is
wrong
with
this.
C
We
want
to
be
able
to
pull
it
from
a
local
registry
and
we
want
to
make
sure
that
it
doesn't
take
a
lot
of
time.
So
what
we're
going
to
do?
The
first
step
that
we're
going
to
do
is
we're
going
to
move
all
the
images
that
exist
in
this
bundle
that
we
just
created
to
our
local
to
our
local
registry.
So
in
in
this
case,
I
did
stand
up
a
registry
v2
in
my
local
machine,
and
I
want
to
copy
this
image
that
we
have
here.
C
That's
the
one
that
there's
it's
right
there,
sorry
about
that,
and
I
want
to
copy
it
to
a
new
repo
locally
called
bundle
to
deploy.
So
what
this
is
going
to
do
is
it's
going
to
find
all
the
images
associated
with
this
bundle,
plus
the
bundle
itself
and
is
going
to
copy
them
to
our
new
registry
and
repository.
C
This
would
allow
you
to
afterwards
to
just
delete
the
all
the
images
on
this
repo
and
when
you
don't
need
it
anymore,
so
now
that
we
copied
everything
to
our
registry,
our
local
registry,
what
we
want
to
do
the
next
step
as
a
deployer,
we
want
to
get
the
configuration
that
the
application
developer
created
and
we
want
to
do
some
tweaks
to
it,
because
you
know
in
our
in
our
company.
We
need
to
do
some
little
tweaks.
C
C
They
did
have
the
exactly
the
same
sha,
because
I
didn't
change
the
configuration,
so
you
have
like
a
repeatability
of
of
your
builds
as
well
so,
and
we
want
to
output
our
bundle
that
we're
going
to
pull
from
this
place,
we're
going
to
output
into
the
stem
project
bundle.
So
let's
do
that
and
it
was
able
to
pull
everything,
and
it
also
says
here
that
it
found
all
the
images
in
that
were
in
our
images
locked.
C
They
were
found
inside
the
repo
for
the
bundle,
so
they
were
found
in
here,
so
we
were
able
to
relocate.
What
happens
was
that
this
image
package
images
is
now
updated.
So
let's
take
a
look
and
see
what
does
that
mean?
So
I
saved
everything
into
our
image
package
here.
So
if
we
look
here
now,
the
image
that
we
have
is
pointing
to
our
local
image.
C
This
is
the
previous
one
that
was
pointing
to
the
initial
one
that
was
pointing
to
docker
hub,
but
it's
no
longer
in
docker
hub,
the
one
that
we
care
now,
the
one
that
we
carry
is
in
our
local
registry
all
right.
So
let's
take
a
look
at
this
configuration.
What
is
this
configuration?
So
it's?
C
Basically,
this
folder
and
one
interesting
thing
is
that
the
developer
said:
okay
in
order
for
you
to
install
everything,
you'll
need
these
applications,
you'll
need
ytt,
you'll
need
cap
and
you
need
k
build,
but
because
we
want
to
we
want
to
do.
We
want
to,
we
save,
we
use
some
sort
of
like
a
bit
ops.
C
Model
in
our
company
here
as
a
deployer,
I
want
to
also
download
to
my
configuration
folder
and
put
it
into
a
local
folder,
some
configuration
that
we
currently
have
for
this
particular
application.
So
this
is
good
if
you,
for
example,
like
if
the
app
on
the
day
two
example
where
the
developer
creates
a
new
version
of
the
application.
For
some
reason,
there's
a
bug
fix
or
something.
There
are
things
that
me
as
a
deployer
care
for
my
company
that
I
want
to.
When
I'm
deploying
I
want
to
make
sure
that
they
are.
C
They
are
the
same
throughout
making
my
life
easier.
So
I'm
I
saved
in
this
repository
more
configuration.
That's
going
to
be
used
to
generate
a
new,
generate
our
deployment
and,
as
you
can
see,
we're
going
to
use
vendor
again
now
to
download
all
the
binaries
that
we
care
about
and
also
to
download
the
download
our
configuration
set.
C
So
I
do
have
a
script
that
basically
just
does
that
and
I'm
gonna
just
do
bash
prepare
and,
as
you
can
see,
it
is
using
vendor
to
fetch
the
releases
that
we
care
about
into
our
bin
director
inside
though
this
folder
and
as
you
can
see
here,
it
was
able
to
download
from
using
git
to
download
our
configuration.
So
if
we
do
an
ls
now
or
if
you
do
a
tree,
you'll
see
that
we
have
a
local
configuration.
C
So
one
thing
that
that
the
deployer
decided
to
do
was
to
every
time
that
you
install
this
application.
C
So
what
this
is
doing
is
it
tries
to
find
this
role
binding
that
we
have
in
our
configuration-
and
it
will
add-
as
you
can
see
here,
you
can
see
here
it
will
append
a
service
account
to
our
role
binding.
So
this
way
you
can
have
your
own
overlay,
your
your
local
update
of
configuration
in
your
separate
repo
that
will
just
change
the
default
behavior
or
just
change
something
in
the
configuration
that
comes
from
the
developer.
C
C
Okay.
So
now
that
we
saw
this,
I
do
have
like
a
big
line
that
does
everything
that
just
generates
uses
ytt
to
generate
all
this
configuration
k.
Build
will
do
something
to
it,
and
then
it
calls
cap
to
the
installation.
But
I'm
going
to
do
this
step
by
step
and
we'll
see
the
output
and
we'll
see
what
the
differences
are.
So
the
first
thing
that
we're
going
to
do
again
is
call
ytt.
C
C
We
also
are
going
to
provide
to
itt
our
values,
plus
our
overlays,
that
we
for
our
configuration
that
we
just
got
from
git,
and
we
also
want
to
enable
the
experimental
schemas,
because
if
you
don't
it,
just
it
will
fail
and
as
you'll
see
here,
a
new
thing
was
dependent.
That
was
not
there.
When
the
developer
created
this
configuration
so
one
thing
and
then
in
the
end
you'll
see
the
projects
that
we
just
asked
for.
C
An
interesting,
interesting
thing
here
is:
let's:
let's
imagine
that
we
have
these
values
files
right
and
for
some
reason
I
I
want.
I
said
that
the
description
is
going
to
be
a
number
one.
C
When
we
run
ytt
again,
it
is
going
to
complain
to
us
that
the
description
field
that
we
have
in
our
values
file
line
11
right
there
very
specific,
which
is
good,
is
of
the
type
integer
when
it
should
be
a
string.
So,
as
you
can
see,
the
schema
allow
the
developer
to
make
sure
that
when
you
are
deploying
something
you
don't
accidentally
change
or
did
do
something
that
is
not
expected.
So
let
me
roll
this
back
and
if
we
go
and
do
this
you'll
see
that
everything
is
here,
is
it
in
a
good
order?
C
We
can
say
that
maybe
it
is,
but
this
is
somewhat
it
is
not
randomly
generated.
This
is
not
random
like
printed,
but
it
might
not
have
a
good
order
right
now
for
ytt
after
ytt
comes
out,
but
we'll
see
what
happens
when
cap
is
invoked.
C
So
the
next
thing
that
we
want
to
do
is
so
we
do
have
our
we
do
have
our
our
output.
But
if
you
see
our
image
here,
it
is
still
not
resolved.
It
is
still
project
app
image
right.
So
what
we're
going
to
do
is
we're
going
to
pipe
this.
This
yaml
that
we
have
here
into
cable
and
we're
going
to
say
this
is
where,
where
the
information,
your
image
lock
file,
is
the
translation
layer
for
our
images,
use
it
and
translate
the
image
into
some
into
our
new
image.
C
C
C
Let's
see
so
we
do
have
this
command
again,
where
we
pipe
ytt
into
k,
build
here
and
then
k
build
into
cap
and
what
cap
is
going
to
do
is
going
to
deploy
our
application
and
it's
going
to
read
what
comes
from
the
the
input.
So
this
is
going
to
fail.
It
was
kind
of
on
purpose.
You
need
to
pass
a
minus
y
so
that
you
say
like
that.
You
accept
that
this
change
is
what
you
want.
Why
stop
this?
So
you
can
see
something
interesting
here.
C
Do
you
do
you
see
the
the
last
thing
that
we
have
as
an
output
for
our
k,
build
it
is
it
is
the
the
custom
resource
and
there's
also
like
this.
The
custom
resource
definition
but
k
build
is
smart
enough
to
know
that.
Maybe
you
want
these
to
come
first,
so
it
reorders
your
custom
resources.
It
reorders
your
resources
that
you
have
here
in
order
to
for
them
to
make
sense
when
they
are
being
applied
to
the
to
our
to
our
cluster.
C
So
if
I
do
a
minus
y
here,
as
I
said,
it
is
going
to
deploy
everything
and
it
just
finished,
which
means
that
we
should
have
our
application
running.
So
if
we
run
cap
inspect
inspect
and
we
provide
the
deployment
name
that
we
have
here
into
it,
you'll
see
that
the
cluster
does
have
custom
resources
it.
C
C
Logs
minus
n
and
the
name
space
is
going
to
be
team
one,
and
we
want
to
see
the
logs
for
our
application
that
our
application
is
here,
you'll
see
that
it
contains
some
logs
and
if
we
we
could
expose
the
port
and
we
could
see
the
output
of
this
application.
So
summing
it
up
all
up.
You
can
see
that
we
do
the
application
that
we
just
built
was
move
through
the
beginning
of
our
creating
configuration
into
our
deployment
and,
for
example,
and
and
all
the
tools
that
we
are
using
throughout
this
this
time.
C
Okay,
so
this
was
a
very
big
demo.
As
you
can
see,
there
are
a
lot
of
steps
on
the
creation
of
an
application,
and
we
in
all
these
carbon
tools
are
here
to
try
to
help
you
to
move
this
process
along
and
try
to
meet
you
where
you
are
as
a
developer
as
a
deployer.
If
you
have
tools
that
you,
like
you,
can
intertwine
carvel
tools
in
some
of
these
steps
to
ease
your
work
and
to
make
it
easier.
So
this
being
said,
if
this,
let's
see,
if
this
moves
on
there,
we
go.
A
C
The
short
answer
is
yes:
if
you,
you
need
to
add
a
label
to
it,
though,
but
it
would
it
so
like
it's
asking
if,
if
you
can
reconcile
the
existing
resources
in
kubernetes
cluster
into
the
deployment
and
you
need
to
add
the
labels
to
it,
so
basically
cap
controls,
everything
knows
about
the
resources
using
the
labels.
C
All
right,
so
we
do
have
another
question:
what
are
the
benefits
that
of
dwight
over
the
hall?
I'm
gonna
be
very
straightforward
with
you.
I
just
had
to
google
to
see
what
the
hall
was,
but
the
benefits
that
we
see
from
ytt
is
that,
first
of
all,
you
can
do
you
can
just
pipe
everything
through
all
the
cargo
tools
if
you
want
to
and.
C
C
B
Like
dimitri
added
some
content
there
for
us,
oh
cool,
recording.
B
C
C
You'll
be
able
to
see
that
there's
a
couple
of
information
that
you
can
provide,
but
you
always
because
of
the
nature
of
the
configuration
itself.
It
would
be
a
little
bit
hard
for
you
to
try
to
provide
all
the
information
that
you
care
that
that
you
need
for
it
to
build,
because
you
can
provide
destinations
to
it
where
you
want.
To
put
it,
you
need
to
provide
also
a
name.
You
can
provide
multiple.
C
You
can
create
multiple
images
from
the
same
configuration.
So
if
we
look
at
our
example
of
sorry,
our
build
file
you'll
see
that
you
can
provide
multiple
sources
and
create
multiple
images
from
it.
So
it
would
be
a
little
bit
hard
to
have
like
all
those
things
in
in
in
the
command
line.
B
And
in
terms
of
where
you
can
learn
more
about
carnival
earlier
in
the
thank
you
slide,
we
had
our
website
carl.dev,
so
we
have
all
of
our
docs
there
as
well.
So
you
can
check
out
various
documentations
and
then
other
vmware
projects
open
source
projects.
You
can
go
to
there's
a
github
called
vmware
tanzu
you'll,
see
various
other
open
source
projects
like
valero
and
other
penny
pad,
so
you'll
be
able
to
learn
some
more
resource
get
some
resource
there.
C
Cool,
maybe
we
can
provide
them
in
the
chat
in
the
chat.
The
links
dmitry
provided
a
link
to
to
the
website
too
as
well,
so
there
we
go
so.
The
next
question
is:
are
all
these
tools
do
they
work
on
the
client
only
or,
if
there's
any
kind
of
configuration
that
needs
to
happen
in
the
cluster?
C
So
these
tools
are
all
client-side,
there's
nothing
that
you
need
to
install
in
in
your
cluster.
In
order
to
make
this
work,
we
are
developing
right
now,
another
tool
that
is
the
cap
controller
that
is
going
to
do
to
manage
all
these
tabs,
so
you'll
be
able
to.
It
will
run
ytt
for
you,
k,
build
and
cap,
and
it
will
install
applications
for
you,
but
this
is.
That
would
be
like
some
sort
of
like
an
orchestrator
of
all
this
that
I
showed
manually.
It
will
be
done
in
the
cluster,
so
we
are
still
developing
it.
C
We
we
still
are
not
in
an
mvp
situation,
so
we
didn't
showed
it
here
today,
but
we
hope
that
in
the
next
couple
of
months
we'll
have
a
version
that
does
more
or
less
that
does
like
this.
A
Okay,
y'all
did
a
great
job.
Thank
you
so
so
much
and
thank
you
for
your
q
and
a
one
else
has
any
questions
we'll
go
ahead
and
wrap
it
up
today.
Thank
you
for
joining
us
and
remember
that
the
recording
will
be
online
later
today
and
we
will
see
you
all
at
a
future.
Cncf
webinar
have
a
great
day.