►
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
When
we
are
recording
thanks
for
joining
us,
everyone
continue
to
sign
in
and
get
settled,
but
we're
going
to
go
ahead
and
get
started
with
today's
cncf
live
webinar.
Tackling
the
kubernetes
software
packaging
puzzle
with
cncf
sandbox
project
Carvel
I
am
Libby.
Schultz
and
I
will
be
moderating.
Today's
webinar
I'm
going
to
read
our
code
of
conduct
and
then
hand
over
to
Cora
iberklein,
developer,
Advocate
and
gabri
Brody
Solutions
engineer,
both
with
VMware
a
few
housekeeping
items
before
we
get
started
during
the
webinar.
A
You
are
not
able
to
speak
as
an
attendee,
but
you
are
able
to
add
questions
to
the
chat
box.
Please
do
so
and
get
send
your
questions
there
we'll
get
to
as
many
as
we
can.
At
the
end.
This
is
an
official
webinar
of
the
cncf
and,
as
such
is
subject
to
the
cncf
code
of
conduct.
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.
A
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
programs
they're
also
available
via
your
registration
link.
You
used
to
sign
in
today,
and
the
recording
will
also
stay
on
our
online
programs.
Youtube
playlist
with
that
I
will
hand
things
over
to
Cora
and
gabri.
Take
it
away.
Okay,.
C
B
So
today
we
want
to
cover
project
carvo
we
want
to
set
us,
give
you
an
idea
of
what
each
individual
tool
is
for,
but
then
give
you
a
larger,
broader
story
for
software
producers
and
software
consumers
for
multi-component
applications.
So
we'll
talk
about
the
challenges
and
requirements
that
you
need,
if
you're
in
one
of
these
two
task
groups,
producers
and
consumers
of
software
and
then
we'll
go
through
the
project
and
give
you
an
a
demonstration
of
how
you
can
put
it
all
together.
C
B
And
then,
from
a
producer
from
a
consumer
perspective,
as
we
know,
the
many
systems
are
not
only
systems
of
microservices,
but
actually
you
know
you
might
have
an
application
at
the
database
or
it's
just
a
more
complex
application
together
as
a
consumer.
If
I
want
to
take
advantage
of
of
such
a
system,
I
want
the
I
want
it
to
be
easy
right.
B
I
need
to
deploy
it
to
many
different
Target
locations
and
those
Target
locations
might
have
different
configuration
requirements
either
it's
multi-cluster
or
every
Target
location
actually
satisfies
a
different
use
case,
so
I
I.
My
concern
is:
how
do
I
get
this
complex
system
out
to
many
different
kinds
of
targets?.
C
The
first
challenge
is,
if
my
said,
like
I
I'm,
the
the
one-
that's
developing
the
system,
if
I
am
not
able
to
do
an
easy
installation
of
this
system,
I
cannot
test
it
in
a
a
pretty
fast
fashion,
like
I
cannot
be
up
to
speed
with
all
of
the
things
that
need
to
be
happening
in
order
to
go
properly
to
the
life
cycle
of
my
system,
then,
even
how
can
I
think
about
my
users
being
able
to
do
that?
C
So,
first
of
all,
I
need
to
solve
also
the
same
challenge
for
myself
and
see
how
I
can
be
really
I
can
be
able
to
do
this
to
do
install
different
components
to
do
upgrades
of
this
component.
So
everything
that's
about
the
life
cycle,
management
software
in
my
own
environment
and
then
from
there
improved
to,
of
course,
also
provide
the
experience
to
my
customers.
C
Now
this
system
that
I'm
looking
at
can
be
something
where
I
need
to
configure
different
I
need
to
configure
for
different
type
of
use
of
Microsoft.
For
example,
I
can
have
a
system
that
is
installed
in
a
location
where
there
are
a
lot
of
resources.
I
can
rely
on
higher
viability
like
I
can
run
multiple
replicas
of
the
same
workload,
and
let's
say
that
I'm
also
using
an
external
system.
C
I
want
also
to
be
able
to
deploy
all
of
the
dependencies
that
I
have
that
are
needed
for
this
software
to
to
run
because
eventually
I'm
having
some
third-party
components
that
I
need
to
also
add
and
the
the
other.
The
other
thing
is
that
I
would
like
for
this
complex
system
to
be
really
installed
in.
Like
are
we
used
to
install
software
in
I?
Don't
know
with
an
image
for
our
Mac
or
an
executable
in
our
windows.
So
in
one
step
is
that
really
possible.
B
We're
looking
at
different
screens
but
I
Advanced
the
slide
one
but
I
think
it
might
be
it
might
be.
You
might
be
moving
the
slides
on
your
own
screen
differently.
So
just
so,
you
know
I
we're
on
the
producer
requirements.
I'm
just
going
to
go
back
a
slide
to
build
the
second
half
of
this
slide,
which
is
the
consumer
side.
B
So
from
the
consumer
side,
the
same
story
right
like
if
the
producer
delivers
a
software.
Even
if
the
producer
delivers
software
in
a
cohesive
package
in
a
single
package
from
a
consumer
perspective,
because
my
targets
are
very
in
the
type
but
the
capacity
that
they
can
sustain-
or
maybe
the
type
of
Hardware
I
might
have
Edge
locations.
I
might
have
a
data
center.
B
Data
center
I
might
have
something
in
the
cloud.
That's
more
elastic,
I
can't
simply
take
the
same
yaml,
for
example,
the
same
configuration
that
describes
a
multi-component
system
and
apply
that
same
yaml
to
different
locations
or,
as
a
gabri
mentioned
right.
There's
things
like
databases,
things
like
that
require
secrets,
so
every
Target
location
has
to
have
some
kind
of
configurability.
So
so
we
have
both
of
those
challenges
right.
B
A
complex
multi-component
system
as
well
as
the
need
to
vary
the
configuration
of
it
depending
on
the
Target
location
right,
so
different,
apps,
different
targets,
different
configuration
and
so
so
I'll
go
past.
This
next
slide,
which
we
covered
so
from
a
consumer
perspective.
My
requirements
are
that
if
I
have
different
Target
locations
and.
A
B
All
require
the
same
system
to
be
installed,
but
that
system
has
to
be
installed
in
different
ways
like
maybe
in
at
the
edge
I
need
three
apps
and
in
the
cloud
I
can
install
10
apps
right,
a
sort
of
a
different
kind
of
setup
for
the
same
system,
then
I
still
as
as
a
consumer,
System
Manager
I
still
want
the
whole
system
to
be
centrally
managed,
especially
if
you
think
about
Edge
locations
that
are
maybe
a
point
of
sale
somewhere
or
somewhere.
You
know
in
a
remote
area.
B
We
can't
necessarily
assume
that
you
even
have
the
same
sort
of
operational
Personnel
to
be
able
to
manage
an
education
right
so
I.
So
it's
very
important
to
have
this
sort
of
central
management
and
not
assume
that
you
can
have
high
touch
deployments,
so
everything
should
be
low,
no
touch
deployments
and
automated
as
much
as
possible
and
allow
for
different
kinds
of
configurations
and
combinations.
B
And
of
course,
it's
super
important,
of
course,
that
this
be
reliable,
repeatable
every
time,
because
you
might
have
thousands
and
thousands
of
of
Target
locations
and
you
and
you
have
to
manage
the
system
with
confidence
and
repeatability.
And
finally,
there
are
going
to
be
some
Target
environments
that
have
access
to
the
internet
and
some
Target
environments
that
are
air
gapped.
So
again,
we
need.
We
need
to
be
able
to
consume
software
in
a
way
that
allows
for
both
of
these
setups.
B
So
functional
get
this
out,
Gabby
cover
it.
C
Of
course,
githubs
it's
going
to
be
a
an
important
requirement,
so
we
need
to
have
the
possibility
to
approach
the
tops
model
and
for
all
of
this
reason
we
need
something
that
is
really
going
to
enable
us
to
manipulate
Yaman
configuration,
because
there
are
going
to
be
a
lot
that
we
need
to
to
work
with,
but
we
also
want
to
have
a
clear
building
of
materials
like
we
need
to
know
what
is
deployed
at
any
time
for
a
specific
environment.
So
we
are
not
going
to
use
simply
tax
label
for
our
images.
C
We
need
to
be
able
to
lock
down
the
exact
shell
that
was
used
for
for
a
specific
deployment.
This
is
also
another
important
components
of
our
solution,
and
the
last
one
is
that
we
need
to
automate
as
much
as
possible
all
of
the
operations
and,
let's
see
how
we
can
do
this,
which
are
the
tools
that
are
really
giving
us
this
Edge.
B
Exactly
so,
we
propose
that
Carvel
gives
us
all
of
these
function,
provides
all
of
these
functional
requirements
for
us
and
gives
us
the
tool
set
to
be
able
to
solve
these
two
challenges
for
producers
and
for
consumers,
and
so
we
want
to
spend
the
rest
of
the
time
now
introducing
you
to
this
project
and
showing
you
how
it
can
particularly
solve
these
two
problems.
B
So
from
a
high
level,
you
can
see
this
on
carville.dev
the
Carville
home
site.
It's
a
set
of
reliable
single
purpose,
composable
tools,
so
you
can
see
that
there
are
4567
tools
listed
on
the
website
and
each
one
has
a
very
specific
purpose
and
it
specializes
in
and
you
can
use
each
tool
separately
from
the
others,
but
you
can
also
string
them
together
in
a
way
that
gives
you
a
complete
workflow
to
solve
the
broader
challenges
that
we're
talking
about.
So,
let's
dive
in
a
little
bit
more.
B
So
what
does
it
mean
again,
single
purpose
and
composable?
So,
for
example,
these
are
three
of
the
tools
that
were
shown
in
the
last
slide.
So
ytt,
for
example,
is
a
tool
that
focuses
on
processing
yaml
a
contemplating
and
it
can
overlay
so
some
overlap
with
a
tool
with
customized,
for
example,
some
overlap
with
Helm,
but
it
has
it's
a
very
effective
tool
for
sort
of
wrangling,
your
yaml,
and
so
it
expects
the
amylase
input
it
modifies
the
yaml
and
then
it
emits
yamla's
output.
B
B
It
goes
to
the
registry
and
it
looks
at
which,
which
sha
represents
that
tag,
and
then
it
emits
the
same
yaml
that
you
that
it
read,
but
now
it
has,
it
produces
information
about
what
the
actual
Shaw
is,
and
then
we
have
cap,
which
is
a
sort
of
an
improvement
on
Cube
cuddle,
CLI
Cube,
cuddle
CLI
one.
One
of
the
challenges,
for
example,
is,
is,
if
you
do
a
cube,
cuddle
apply
on
a
file
that
has
20
different
resources
in
it.
B
Then
you
can't
simply
use
Cube,
cuddle,
delete
and
the
same
file
and
delete
all
20
resources
right.
You
have
to
have
that
file,
so
you
can
see
which
resources
they
were
and
delete
them,
one
by
one
or
there's,
no
way
that
you
can
manage.
If
you,
if
you
change
one
field
in
that
file
of
20
resources,
and
you
apply
that
file
again,
Cube
cuddle
can't
tell
you
what's
changing
and
get
you
to
confirm
that
you
want
to
do
that
change
right.
Are
you
creating
something
new?
Are
you
updating
something
you
really
don't
know?
B
Cube
cuddle
is
is
more
basic
than
that.
So
cap
is
sort
of
a
step
up
from
that,
and
it's
also
one
of
the
tools
in
the
tool
set
and
because
all
of
these
tools
expect
to
get
yaml,
then
they
can
simply
be
chained
together
in
this
way,
to
give
you
a
workflow
in
this
case,
starting
with
some
yaml
updating
some
Fields,
resolving
the
Shaws
and
then
applying
it
directly
to
your
kubernetes
cluster.
B
Now,
because
they're
yaml
in
yaml
out
they're
also
interchangeable
with
tools
that
you
might
be
more
familiar
with.
So
if
you
want
to
continue
using
Helm
customer
or
any
other
tool
that
reads
and
emits
yaml,
then
those
can
play
very
well
together.
So
again,
because
they're
single
purpose,
you
can
choose
what
you
want.
Vendor
is
another
tool
in
the
in
the
set
of
Carvel
tools
that
was
shown
on
on
the
screen
with
the
screenshot
from
the
web.
Page
vendor
is
the
tool
that
enables
you
to
synchronize
dependencies.
B
B
That
is
included
that
that
forms
part
of
your
system,
and
you
don't
own
that
code
and
you
don't
own
that
yaml
so
vendor
can
help
you
reference
which,
where
the
source
of
those
dependencies
are
in
this
example,
we're
showing
on
the
screen,
The
Source
happens
to
come
from
a
GitHub
repo,
but
it
doesn't
have
to
be
Git.
It
could
be
other
kinds
of
sources,
images
and
such,
and
it
gives
you
the
ability
to
through
a
simple
command
synchronize
on
your
local
machine,
the
files
that
you
need
from
that
third-party
product.
B
So
you
can
see
here
on
the
right
after
a
vendor.
Sync
we've
actually
downloaded,
in
this
case
the
yaml
configuration
for
redis,
because
we
are
right
as
a
dependency
in
our
system
and
we
don't
want
to
tell
our
consumers
to
go
get
their
own
redis.
We
actually
want
to
vendor
in
redis
into
our
application,
so
vendor
can
help
us
manage
that
and
again
track
versions
and
track
Shaws
and
things
like
that.
So
vendor's
another
one
in
there.
B
So
if
we
put
it
all
together,
if
we're
building
a
multi-component
system,
we
would
first
bring
in
our
third-party
dependencies
and
then
we
take
that
plus
the
rest
of
our
yaml
configuration
for
the
rest
of
our
system,
and
then
we
can
get
to
a
place
where
we
can
apply
that
to
a
kubernetes
cluster.
But
of
course,
this
flow.
You
know
you
don't
usually,
if
you're
in
the
business
of
producing
software,
you
don't
want
to
necessarily
just
have
a
yaml
file
with
a
whole
bunch
of
stuff
in
it.
B
You
might
want
to
be
a
little
bit
more
organized
or
provide
different
ways
for
consumers
to
retrieve
your
software,
and
so,
in
this
case,
there's
another
tool
called
image
package
which
we
show
it
we're
showing
here,
as
instead
of
using
cap
to
directly
apply
the
yaml
to
a
kubernetes
cluster.
Instead,
you
can
take
all
of
that
configuration
and
place
that
into
a
bundle
and
have
the
consumers
download
that
bundle
instead
in
the
same
way
that
you
would
send
them
an
installer
executable,
for
example,
but
in
the
case
of
Carvel,
what
it
does
is
it.
B
It
leverages
oci
image
Registries
as
a
way
to
transport
files
to
Consumers.
So
it's
kind
of
like
a
in
the
same
way
that
you
might
use
an
FTP
server.
You
can
you
can
you
can
put
any
arbitrary
content
inside
of
an
oci
image
and
then
use
a
registry
to
enable
people
to
download
that
content.
So
you
can
see
here,
for
example,
what's
going
into
this
oci
image
is
just
a
set
of
files.
B
It's
not
actually
necessarily
yaml
that
you
would
directly
apply
to
a
kubernetes
cluster,
we're
not
using
or
it's
not
it's,
not
a
we're,
not
using
the
oci
image
as
the
executable
image
that
would
go
inside
of
a
pod,
we're
using
an
oci
image
as
a
method
to
transfer
and
distribute
an
arbitrary
of
files.
So
this
is
we're
going
to
use
this
as
a
way
of
getting
software
to
Consumers,
which
is
also
great,
because
consumers
can
now
every
image
has
a
shot
right.
B
Then
I
can
tell
my
consumers
to
Simply
reference
that
bundle
and
once
they
download
they
put
that
into
a
kubernetes
cluster
and
that
kubernetes
cluster
using
yet
another
one
of
the
tools
that
we
saw
on
the
on
the
first
image
that
showed
all
of
the
tools
of
Carvel
in
this
case
we're
talking
about
cap
controller,
because
this
process
is
now
happening
inside
of
the
kubernetes
cluster
right.
We
apply
this.
B
This
package
yaml
shown
here
on
the
right
into
the
cluster,
so
the
cluster
can
now
obtain
that
image
from
the
registry
in
which
it
sits.
So
now
you
have
all
of
the
software
that
you
eventually
want
to
install
in
your
cluster
is
now
unpackaged
from
that
bundle
and
then
inside
of
the
cluster,
any
additional
configuration
can
be
applied
and
we
can
ensure
that
we're
using
the
exact
Shaws
that
were
specified
by
K
build.
So
you
know
that
you're
going
to
download
exactly
what
you
want.
B
So
it's
sort
of
a
declarative.
The
the
excuse
me
that
consumer
has
a
declarative
mechanism
to
consume
software,
which
goes
back
to
that
requirement
of
low
touch,
no
touch
deployment.
B
Workflow
for
the
producer
and
a
declarative
workflow
for
the
consumer
again,
the
consumer
can
also
replace
any
of
these
tools
with
an
equivalent
tool
because
they
are,
they
are
interoperable,
so
whether
it's
excuse
me,
whether
it's
helm
or
whether
they're
getting
they're
fetching
the
image
from
from
a
different
Source
cap
controller,
actually
supports
all
these
cases.
We're
of
course
highlighting
that
you
can
use
an
image
package
for
it,
but
but
the
product
is
a
little
bit
more
flexible
than
than
that.
B
Okay,
so
I've
shown
you
a
sort
of
a
a
workflow
that
highlights
each
individual
tool
which,
by
Nature
sort
of
shows
that
it's
it's
it's
very
powerful,
but
perhaps
a
little
cumbersome
to
call
one
tool
at
a
time.
So
at
this
point,
I'm
going
to
hand
it
over
to
gabri
to
show
you
how
to
make
this
even
easier
and
Gabby.
Do
you
want
to
share
your
screen?
Sure
I
think
you
need
to
stop,
though
otherwise
I
don't
see.
Okay,
now.
C
Okay,
now
we
go
over
here:
okay,
yes,
so
there
is
kind
of
a
Time
missing
over
here
that
we
just
found,
and
the
name
of
the
tile
is
key
control-
why
we
are
really
interested
in
this
K
controller
component
from
Comfort.
Well,
okay,
controller,
it's
the
CLI
that
you
can
use
when
interacting
with
chaot
controller.
C
So
that's
great,
because
we
can
use
that
to
do
to
talk
with
the
K
app
controller
and
check
what's
happening
with
our
applications
that
we
deploy
through
km,
but
the
the
things
that
is
particularly
relevant
for
us
at
this
point.
It's
that
it
helps
in
facilitating
the
creation
and
the
consumption
of
packages.
C
We
can
think
at
Key
control
like
an
orchestrator
for
all
of
the
other
Carvel
tool
set
like
the
YT
kvld
web
Bender
image
package.
Okay,
up
with
through
using
K
control
and
a
simple
subset
of
commands,
you
can
actually
reproduce
the
entire
flow
that
quora
was
showing
before
just
using
one
comment:
let's
take
a
look
in
the
in
the
example
in
the
conversation
before
with
quora,
she
was
saying:
let's
say
that
we
have
this
software
component
and
the
software
component.
C
It's
going
to
be
really
interesting
because
it
actually
can
orchestrate
everything
from
using
vendir
to
download,
what's
necessary
and
and
then
to
put
in
the
right
sequence,
ytt,
kbnd
and
image
package
with
the
purpose
of
creating
our
package
for
our
application.
So,
let's
take
a
look.
We
have
specifically
two
Samba
comment
inside
the
K
control
CLI
that
we
are
going
to
use
the
first
one
is
packaging
in
it.
What
package
in
it
does
is
this
portion
of
package
build
and
package
resources
and
eventually
vendir?
C
If
there
are
external
component
that
we
want
to
render
in
and
as
we
use
key
control
package
in
it,
we
will
see
a
few
parameters
that
will
be
supplied
to
it,
so
we
are
using
an
imperative
Approach.
At
this
point,
we
are
the
output
of
this
command.
It's
going
to
be
to
generate
a
number
of
yaml
file
for
us
that
contains
all
of
the
necessary
configuration
for
our
package.
C
Then.
The
second
thing
that
we
do
is
to
call
a
key
control
package
release
and
the
package
release
what
it
does
is
essentially
taking
versioning
whatever
it
we
put
in
our
original
package
and
creating
a
metadata
and
package
file
that
contain
all
of
the
information
for
this
package
to
be
deployed,
but
also
it's
gonna
ask
for
the
information
on
the
registry
that
we
want
to
use
in
order
to
use
image
package
to
bundle
all
of
this
configuration
file
and
then
save
into
the
specific
register.
C
B
C
Our
configuration
component,
like
all
of
the
yamas
that
we
need
to
deploy
our
application,
but
also
we
said
we
wanted
to
rendering
radius
so
that
we
are
going
to
really
deploy
everything
at
once.
Oh,
this
is
great,
but
now
probably
I
have
more
than
one
application,
with
his
own
components
that
I
need
to
give
to
my
consumer
and
in
our
example,
we
would
have
another
giant
application
that
we
want
to
deploy,
but.
C
C
So
if
the
customer
now
the
consumer
now
has
to
in
do
the
installation
of
each
package
well
now
this
can
again
be.
C
This
is
already
much
more
than
our
original
idea
of
experiencing
a
kind
of
an
install
where
I
double
click
on
something
and
everything
that
need
to
be
installed
in
my
system.
It's
gonna
go
there
well
with
karbala.
This
is
possible.
We
are
going
to
introduce
the
concept
of
the
meta
package
The
Meta
package.
C
What
it
does
is
that
it
creates
the
structure
of
the
package
around
all
of
the
packages
that
we
need
to
deploy,
and
essentially
we
can
see
how
inside
the
mechata
package
we
have
as
usual,
as
we
were
saying
before
configuration
on
the
package
and
the
meta
package
of
the
data,
and
then
we
have
a
directory
that
contains
the
packaging
installer
and
for
each
application.
We
have
the
opportunity
to
say
exactly
how
sorry
for
each
of
the
packages
that
are
referenced
in
in
this
meta
package,
we
can
say
what
is
the,
which
are.
C
What
is
the
configuration
that
we
want
to
apply
so
this?
The
concept
of
the
mega
package
is
the
one
that
allow
us
to
deliver
this
single
entry
point
to
installation
for
a
system
that
can
be
quite
a
complex
and
we
will
see
how,
even
though
we
can
add
the
opinionated
default,
we
can
also
provide
the
user
with
the
possibility
to
change
some
of
default
for
with
what
is
more
appropriate
in
in
that
system
and
one
other
concept
that
we
need
to
keep
in
mind.
While
doing
this
is
the
concept
of
profile.
B
C
That
starter
smaller
than
custom
array,
so
customer
B,
it's
gonna,
have
a
profile.
It's
going
to
use
a
profile
that
is
slightly
small.
It's
going
to
be
just
it's
not
a
full
profile,
and
at
this
point
it's
going
to
have
the
a
different
type
of
configuration
and
we
can
allow
for
this
to
happen.
B
C
B
You
know
what
I'm
a
little
bit
concerned
about
our
time.
So
why
don't
we
talk?
Why
don't
we
go
to
the
demo
and
then
we'll
come
back
to
this.
A
A
C
A
B
C
C
Container
and
what
I'm
interested
right
now,
it's
only
in
building
the
package
for
this
application,
so
I'm,
taking
a
look
at
the
configuration
file
that
I
am
I
need
in
order
to
deploy
the
application
on
a
kubernetes
file
and
I
see
that
right
now,
I
have
those
file
that
contains
the
standard
configuration
now,
let's
start
with
the
package
in
it,
but
I
want
to
to
start
packaging.
My
application
and
the
way
I
am
going
to
do
this.
I'm
gonna
give
an
aim.
C
So
a
lot
of
the
yaml
is
automatically
produced
by
key
control.
Now,
let's
take
a
look.
I
want
to
create
the
actually
package
repository
form
for
my
application,
so
I
want
to
release
so
first,
we
initialize
the
package,
and
now
we
want
to
release
the
package
and
to
release
the
package.
We
need
to
say:
where
is
that
we
are
going
to
save
the
image
package
bundle,
so
the
parameter
that
I'm
providing
over
here
is
exactly
the
my
my
registry.
C
What
I'm
going
to
say
over
here
is
that
I
want
to
release
the
giant
application,
and
this
is
the
version
and
I
also
want
to
put
everything
inside
this
Repository
and,
as
you
can
see,
kbfd
is
behind
the
scene
running
sorry,
K
controller
is
behind
the
scene
running
other
tools
from
the
carbon
belt
on
his
own,
and
now
I
can
see
that
what
was
before
empty
now
contains
two
files,
one
with
the
release
and
a
metadata
in
the
release
file.
C
What
we
have
is
that
now
we
have
the
specific
image
bundle
that
we
are
going
to
use
that
we
are
pushing
to
our
registry.
We
have
the
version,
and
we
are
also
pointing
to
that.
There
are
images
with
like
the
shaft
or
the
images
that
I'm
using
have
been
also
saved
over
here,
so
they
unlocked
now
before
and
after
the
release.
What
happened
to
those
files?
Well,
we
quickly.
You
can
see
that
specifically
if
it
content.
If
we
concentrate
onto
only
on
the
package
side
from
zero,
we
went
to
the
specific
version.
C
We
added
the
information
for
the
imagine
that
we
are
going
to
use
and
also
we
add
information
on
kbld
and
all
where
all
of
these
files
are
plus
we
are
saying
look.
There
is
a
bit
in
open
API
specification
with
the
parameters
that
can
be
specified
and.
C
So
this
is
really
handy,
because
now
you
have
and
also
an
easy
way
to
query
these
parameters
and
know
what
you
can
configure
and
we
are
going
to
do
the
same
thing
also
for
the
low
app
so
I'm
gonna
go
and
try
to
go
first
over
here
and
again,
there's
gonna
be
one
and
it's
gonna
be
concrete
perfect.
Now
we
want
to
release
the
package
and
again
to
release
this
package.
C
A
C
Doing
is
that
we
are
going
to
init
there's
key
control
is
going
to
render
in
our
radius
application.
By
first
of
all,
now
we
are
going
to
use
a
git
repository
as
a
source,
not
a
local
directory,
as
we
did
before
and
as
you
can
see,
there
are
also
other
options
that
can
be
used
to
accomplish
the
same
so.
A
C
What
I
want
to
give
is
the
URL
with
that
that
is,
files
are
contained
and
I'm
gonna
say
take
from
there.
Only
and
all
we
find
that
starts
with
redis,
and
you
can
see
that
bang
beer
is
now
orchestrated
directly
so
now,
I
see
that
there
are
from
Upstream.
All
of
these
files
were
downloaded
plus
all
of
the
file,
the
one
in
red
that
key
control,
while
creating
the
the
package
already
produced
for
us.
So
you
can
see
Independence.
C
Are
going
to
push
this
into
our
image
bundle
in
either
image
bundle
into
our
registry,
and
at
this
point
the
only
thing
that
we
need
to
do
is
to
really
work
with
the
meta
package.
So
we
already
populated
a
couple
of
information
for
Maria
in
particular,
let's
look
at
the
Hello
app.
C
What
we
are
doing
is
that
we
are
reusing
the
packagings
that
were
built
before,
but
also
we
are
adding
some
overlay,
some
Starlight
syntax
through
ypt
to
change
information
so
that
these
are
going
to
be
specific,
for
if
the
profile
is
is
full
or
if
it
is
not
full.
So
if
it
is
full,
it's
going
to
be
created,
it's
not
full.
It's
going
to
be
cold,
so
it's
going
to
do
deployment
instead
of
using
K
native
service
is
going
to
deploy
using
standard
deployment
and
service.
C
We
are
also
changing
some
of
the
variable
for
from
some
of
the
parameter
for
our
from
for
the
value
to
of
the
for
the
configuration
of
our
application,
and
so
now,
as
we
do
this,
we
see
that
we
have
in.
In
our
repository.
We
have
packages
for
the
three
application,
and
now
we
want
to
add
the
other
package.
That
is
the
meta
package
that
will
contain
information
on
how
to
deploy
the
application.
C
Okay
and
now
I
also
have
the
meta
package
added
to
the
repository.
So
now,
the
only
thing
that
I
need
to
do
is
to
release
the
to
create
a
repository
with
all
of
these
packages.
So
I
am
adding
information
for
the
repository
and
for.
C
B
Awesome
thanks,
sorry
I
think
I
mean
to
make
you
too
nervous
with
the
time,
but
okay,
so
I'm
gonna
share
my
screen
and
basically
I'm
going
to
show
you
the
consumer
experience
now.
I'm
gonna
share
screen:
okay,
okay,
so
just
to
recap
right
so
gabri
has
just
built
as
a
very
sophisticated
software
producer.
Gabri
has
a
system
that
I
want.
The
system
has
three
different
individual
applications:
redis
a
Hello
app
and
a
giant
app.
B
So
gabri
has
created
a
meta
package
so
that
I
can
have
that
single
touch,
the
single
click
experience
and
just
say,
install
the
meta
package
and
that
will
install
each
of
those
individual
three
packages
for
me
and
then,
in
order
for
me
to
be
able
to
obtain
that
software,
easily
gabri
put
it
into
a
repository,
created
a
repository
out
of
it
and
wrap
that
into
an
oci
image
so
that
I
can
easily
just
download
this
oci
image
and
again
so
a
single
download
and
a
single
step
installation
with
a
meta
package.
B
So
my
experience
as
a
consumer-
let
me
just
show
you
the
slide
quickly.
Is
that
I'm
going
to
use
also
K
control
and
I'm
going
to
add
the
repo
I'm
going
to
do
a
repo
ad?
Take
that
repository
Gabby
created
for
me
put
it
into
my
cluster
and
then
I'm
going
to
say,
I
want
to
install
the
meta
package
and
expect
that
to
download
to
all
of
them.
B
B
Is
it
a
profile,
a
or
profile
B,
in
this
case
we're
using
as
examples
large
profile
somal
profile,
but
it
could
be
any
profile
you
want
and
in
a
large
profile
as
gabri
has
configured
it
for
me,
I
will
have
all
three
applications
installed.
If
I
do
a
small
profile,
I
only
get
the
Hello
app
with
the
redis,
but
not
the
giant
app.
B
That's
too
big
for
my
small
targets
and
also
I
have
the
ability
to
tailor
other
configuration
values
for
every
Target,
so
I'm
going
to
show
you
how
I
can
take
advantage
of
what
gabri
has
built
for
us
and
okay,
so
50
minutes
so,
okay,
so,
first
of
all
I'm
working
on
a
cluster.
This
cluster
has
cap
controller,
installed
right,
I'm,
going
to
work
with
that
declarative
consumer
experience
so,
as
I
apply
yaml
to
my
cluster.
B
To
tell
Carvel,
in
this
case
cap
cap
controller,
how
to
to
download
that
repository
and
how
to
unpack
it.
Cap
controller
is
the
Carvel
tool.
That's
in
the
cluster.
That's
going
to
do
those
things
for
me.
The
other
thing
that
I
happen
to
have
here
is
k-native
serving
with
a
cni,
and
that's
because
it's
you
know
it's
always
great
to
have
K
native.
It
makes
running
applications
easier
and
in
the
profile
configuration
that
gabri
prepared.
B
For
me,
she
the
if
I
she
assumed
that
a
full
cluster
or
a
that
a
full
cluster
will
have
K
native
installed,
and
so
the
configuration
will
produce
yaml
for
a
k-native
service
or
if
I
have
a
small
cluster
and
maybe
I
don't
have
k-native,
then
that
tailored
configuration
will
automatically
produce
the
ammo
for
a
simple
deployment
and
service.
But
in
in
my
case
my
cluster
has
k-native.
B
So
those
are
the
only
two
things
I've
prepped,
my
cluster
with
other
than
that
it's
a
brand
new
cluster,
so
I,
first
of
all,
I
want
to
create
a
namespace
so
that
I
can
do
my
my
work
as
an
operator.
B
So
I'm
going
to
add
the
repository
that
Gabby
created,
so
you
can
see
package
repo
ad
is
the
First
Command
that
I
run
now
I'm,
giving
it
the
URL
for
where
gabri
published
that
oci
image
that
contains
all
of
these
installation
files,
so
essentially
I've
installed.
I
have
I
have
all
of
the
files
that
I
need
now
in
my
cluster,
nothing
has
been
installed
yet.
No,
the
Hello
app
and
the
giant
app
aren't
running,
but
I've
I
have
a
I,
have
a
single
artifact
that
I
can
use
to
obtain
all
the
software.
B
So
we
can
see
already
how
Carvel
facilitates
software
distribution,
and
so
then
I
can
see
okay.
Well,
what
does
this
software
that
I?
What
does
this
installer?
Essentially
that
I
downloaded?
What
does
it
contain
and
I
can
see
that
it
contains
a
meta
package
and
it
contains
three
individual
packages,
and
you
know
because
I
I
know
what
I'm
installing
I
am
interested
in?
Actually
installing
only
The
Meta
package
and
the
meta
package
should
install
the
redis,
Hello,
app
and
giant
app
for
me.
So
I
want
that
now.
B
I
want
that
single
click
installation
so
I'm
going
to
create
a
namespace
for
the
for
the
for
these
installation
for
these
things
to
actually
be
installed,
and
now
I
can
think
about
well
before
I
install
meta
package.
What
kind
of
what
what
is
my
Target
location
and
what
kind
of
configuration
values
do
I
need
to
set
so
here
I
can
say:
well,
let's
assume
that
this
is
a
full
profile.
This
is
my
largest
cluster.
B
You
saw
that,
based
on
the
schemas
that
each
app
had
an
open,
API,
a
V3
schema
was
automatically
generated,
so
I
can
use
that
to
see
what
what
are
the
values
that
I
could
possibly
set,
and
so
here
I've
decided
that
I
wanna.
This
is
the
way
I
wanna
name
these
apps
in
my
cluster
I'm,
the
deployment
type.
It's
it's
the
default
anyway,
but
just
to
kind
of
highlight
to
you
that
we're
going
to
use
k-native
it's
the
default
for
the
pro
full
profile.
So
this
isn't.
B
Actually
it
doesn't
need
to
be
set
here
in
this
case
and
for
Hello
app
I
can
set
a
message
that
the
app
will
return
and
so
I'm
going
to
say
full
happy
package,
so
I'm
customizing
it
a
little
bit
so
now,
I'm
going
to
say,
install
a
package
but
I'm
choosing
to
install
metapackagecorp.com
version,
one
zero,
zero,
so
I'm
choosing
to
install
this
one
and
not
the
other
individual
ones.
So
this
is
my
my
installer
experience
with
a
single
command
I'm
going
to
actually
install
three
applications
right
meta
package
is
not
really
an
application
right.
B
It's
just
sort
of
a
way
to
wrap
the
other
three
applications
so
that
they
are
all
installed
as
as
one
thing
and
now-
and
the
other
thing
that's
happening
of
course-
is
that
instead
of
cue
cuddle
right
we're
using
this
cap
in
the
background.
B
So
if
I
make
this
a
little
smaller
you'll
see
Cube
cuddle
wouldn't
go
through
a
bunch
of
yaml
and
give
you
this
kind
of
summary,
but
but
because
we're
using
cap
I
can
see
all
of
the
different
things
that
it's
installing
and
so
it's
going
to
extract
the
package
install
and
and
then
we
can
see
that
cap
controller
takes
that
package
install
file.
It
takes
this
package,
install
configuration
and
actually
goes
ahead
and
installs
the
packages.
B
So
now,
if
I
say
hey,
which
packages
have
been
installed,
I
can
see
that
they've
all
been
installed
right,
the
one
that
I
manually
installed
and
the
other
three.
So
what's
the
effect
of
installing
these
packages?
Well,
this
a
tiny
bit
smaller,
so
I
have
two
apps.
These
are
the
K
service.
Apps
redis
is
is
a
is
a
different
product.
It
doesn't
have
a
kubernetes
k-native
service
associated
with
it.
B
So,
of
course
it
doesn't
show
up
on
the
screen,
but
I
have
giant
app
and
it's
giant
app
is
big,
and
so
it's
not
that
it's
not
working.
It's
just
still
starting
up,
but
Hello
app,
which
is
light
and
quick,
has
already
started.
So
I
can
already
test
this
application
and
I.
B
Is
running
well
because
that
number
that
every
time
I
refresh
the
page,
it's
storing
the
count
in
redis
and
so
and
you
can
see
that
we
have
happy
full
happy
package,
which
was
the
configuration
value
that
I
set
in
my
file.
So
so
what
we've
seen
here
is
that
as
a
consumer
I
have
I
can
tailor.
My
configuration
and
I
can
use.
B
I
can
simply
download
one
artifact,
which
is
the
repo
and
then
I
can
install
one
package,
which
is
a
meta
package
and
the
result
is
a
basically
a
single
step,
a
two-step
and
installation
of
an
entire
multi-system
multi-component
system.
Now,
let's
talk
about
time
check:
okay,
152!
Let's
talk
about
what,
if
I
want
to
change
something?
What
if
I
want
to
do
any
kind
of
update?
In
this
case
the
example
I'm
going
to
show
you
is
a
configuration
values
so
I,
let's
say:
I
want
to
change
a
set
of
a
full
happy
package.
B
B
That's
my
new
configuration
values,
so
I
simply
reinstall
the
package
again
I'm
only
working
with
meta
package,
because
this
one
will
transitively
update
the
other
three
as
necessary
and
I'm,
providing
my
new
values
file
here
so
with
a
single
command,
I'm.
Basically,
updating
the
software.
That's
installed.
B
So
we'll
give
it
a
second,
so
it's
reconciling
and
again
Cube
cuddle
would
simply
apply
the
yaml.
It
wouldn't
tell
you
how
things
are
going,
but
since
this
is
using
cap
in
the
background
and
interacting
with
cap
controller,
it
continues
to
check
on
if
the
reconciliation
of
the
resources
is
done,
and
it
also
tells
me
well,
you
know
in
this.
B
We
up,
you
updated
two
Resources
with
this
change
and
you
created
two
new
resources,
so
it's
it's
very
informative
as
to
what's
actually
happening,
and
of
course
it
gives
me
the
logs
in
the
background,
as
things
are
progressing
so
just
give
it
another
few
seconds
to
finish
I'll
check.
What
is
this
so
the
chat?
What
is
the
advantage
of
using
Carvel
to
deploy
on
kubernetes
when
compared
to
other
Git
Up
Solutions
like
Argo,
CD
or
Flex
so
Argo,
so
it
can
be
in
a
workflow
together
with
Argo,
CD
or
flux.
B
Again,
this
is
sort
of
composable.
You
can
pick
and
choose,
but
Carville
is
serving
a
much
broader
sequence
of
of
youth
uses
right
with
this
imperative
packaging
model,
plus
the
declarative,
and
you
can
see
that
it
has
different
different
pieces
of
functionality,
but
they
can
certainly
work
in
in
concert
with
tools.
If
you
are
using,
if
you're
already
using
Argo,
CD
or
flux
you
could
you
can
use
them
together.
B
So
this
is
finished.
Reconciling.
C
B
So
we've
updated
our
local
package,
so
if
we
see
what's
now
installed,
we
can
see
that
again
everything
is
installed,
everything
is
reconciled
and
if
I
try
to
get
the
kubernetes
services
remember
last
time
we
got
the
case
service,
the
K
native
service,
sorry
for
both
applications,
but
now
they're
not
there
and
that's
because
in
our
new
configuration
we
chose
not
to
use
k-native.
We
told
it
to
use
core
app
core
resources.
A
B
C
B
That,
if
I
can't
access
the
image
repository
where
all
of
these
images
are
located,
then
how
could
I
install
because,
when
I,
when
I
install
the
meta
package,
what
actually
happens
is
that
it
has
to
reach
back
out
to
the
registry
in
this
case
that,
on
this
this,
this
registry
is
running
outside
on
in
the
cloud,
so
I
need
that
internet
access
to
go
and
get
all
of
the
package
images,
and
then
I
need
to
go
back
out
to
get
the
actual
oci
image
for
Hello
app
and
for
all
the
red.
B
The
red
is
follower,
the
redis
leader.
So
there's
sort
of
this
transitive
relationship
of
of
images
and
I
keep
having
to
go
to
the
internet
to
get
them.
But
if
I'm
working
in
an
air
gapped
environment
I
may
not
I
can't
I,
don't
have
access
to
all
of
those.
So
image
package
actually
gives
us
a
copy
utility
and
what
it
does
is
it
looks
through
that
image
and
all
of
the
the
yaml
configuration
inside
of
it.
B
It
finds
all
of
the
images
on
the
internet,
it
brings
them
down
and
and
it
copies
them
to
a
destination
registry.
So
you
would
either
do
this.
B
This
is
just
to
show
you
what
was
pulled
and
I'm
going
to
extract
it
into
a
temp
directory
on
my
local
machine
and,
if
I,
look
inside
of
that
temp
directory
I
can
see
that
all
of
the
files
are
there
and
then,
if
I
explore.
What's
inside
of
this
images
file,
which
is
just
a
piece
of
metadata
right,
these
are
the
four
packages
that
were
actually
in
that
in
that
repository
that
I
copied.
B
That
was
in
this
network
accessible
registry
that
is
now
in
your
air
gapped
registry,
and
so
it's
basically
giving
me
the
new
image
location
and
so
with
between
the
with
the
Carvel
tools,
and
this
will
be
automatically
replaced,
and
so,
when
I
want
to
do
the
local
install
it's
going
to
pull
from
the
air
gap
registry,
and
you
can
see
that
it's
pulled
all
of
the
different
images
that
it
needs
and
then
the
last
thing
that
we
wanted
to
show
you
was
that
what,
if
your?
B
B
Well,
then,
you
can
use
vendor,
for
example,
to
pick
and
choose,
and
then
I'll
just
show
you
the
command
here,
because
I
think
we're
going
to
you
could
basically
generate
a
new,
a
new
repository
and
just
tag
it
as
a
small
one
and
not
in
this
case
we're
not
even
including
the
giant
app
so
that
the
giant
app
image
itself
is
not
copied
to
the
air,
gapped
Edge
location,
and
so
that
way
you
can
really
tune
the
size
of
the
repository
as
well,
for
your
Target,
so
I
think
I
think
that's
all
we
have
time
for
demo-wise,
but
that's
really
the
that's
the.
B
What
we
wanted
to
show
you
anything
else
would
have
just
sort
of
added
a
little
color
to
that,
and
so
the
other
thing
that
we
wanted
to
mention
is
that,
as
far
as
VMware
sort
of
dog
fooding
this
technology,
because
VMware
is
behind
project
Carvel
vmware's
commercial
software
is
VMware
tons
of
the
application
platform,
and
this
is
the
strategy
that
we
use
in
order
to
package
and
distribute
our
own
application
platform.
So
this
is
sort
of
under
the
covers
of
how
VMware
is
approaching
this
problem.
B
For
ourselves
and
how
we
try
to
make
it
really
easy
for
consumers.
This
is.
This
is
a
system
that
has
45
different
components,
and
so
this
is
how
we've
made
it
easy
for
ourselves
to
install
and
test,
as
gabri
was
saying,
solving
the
cons,
The
Producers
challenges
and
also
make
it
easy
for
people
who
need
to
install
this
platform
for
themselves
to
have
this
one
click,
download,
one-click
installation,
but
also
support
different
kinds
of
profiles.
B
So
that's
sort
of
an
example
not
not
the
only
one,
but
the
one,
of
course,
as
VMware
that
we're
most
familiar
with
under
the
covers
of
how
Carvel
is
used
in
the
wild
and
yeah
gabri.
Any
final
words.
C
B
Yeah
I
think
that
I
think
the
answer
to
that
question
also
is
that
that's
Carvel
doesn't
answer
that
question
specifically,
but
there's
other
things.
There's
other
solutions
to
the
question
of
like
how
would
you
take
any
any
piece
of
yaml
and
deploy
it
on
multiple
clusters
so
that
there's
yeah
I
think
there's
different
ways
to
solve
that
problem?
Probably
Argo,
CD
cartographer,
there's
different,
there's
different
solutions
for
that.
B
But
that's
not
one
of
the
problems
that
Carvel
is
focused
on
the
the
multi-cluster,
but
it
does
help
you
in
making
it
uniform
that
what
needs
to
land
at
different
targets
can
be
managed
in
the
same
easy
low
touch:
Central
Way
with
custom
configuration
for
every
site
so
that
because
I
don't
know
that
it
doesn't
answer
the
question.
I
guess
and.
C
Then
yeah.
C
Well
so
I
I
don't
know
it's
I.
There
is
a
screen.
Can
you
close
over
there?
We
have
so
I
feel
like
we
were
able
to
to
show
everything
that
we
wanted.
So
that's
great
and,
as
we
were
saying
at
the
beginning,
the
github's
approach
was
a
big
thing
in
our
mind,
as
well
as
Automation
and
easy
way
to
consume,
not
only
to
build
the
packages,
but
also
for
the
experience.
So
here
is
a
worker
that
is
available
on
that
git
repository,
and
there
is
the
demo.
C
The
two
demo
that
we
were
running
are
also
available
over
there
and
a
few
links
in
order
to
learn
more
about
Carvel,
so
I.
We
hope
you
enjoyed
this.
Thank
you
very
much.
A
Thank
you
both
so
much
thanks,
everyone
for
joining
us,
Cora
and
gabri.
Thank
you
for
your
expertise
and
everyone
remember
that
we
will
have
the
slides
and
presentation
online
later
today
join
us
again
for
another
cncf
webinar
and
we'll
see
you
soon
thanks
everyone.