►
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
Thank
you.
Everyone
for
joining
us.
Welcome
to
today's
cncf
live
webinar,
breaking
tradition,
the
future
of
package
management
with
kubernetes,
I'm
libby,
schultz
and
I'll
be
moderating.
Today's
webinar
I'm
going
to
read
our
code
of
conduct
and
then
hand
things
over
to
dmitry
kalanin
engineer
at
vmware
a
few
housekeeping
items
before
we
get
started
during
the
webinar.
A
You
are
not
able
to
speak
as
an
attendee
there's
a
q,
a
box
on
in
the
chat
on
the
right
hand,
side
of
the
screen
so
just
drop
any
of
your
questions
in
the
chat
and
we'll
get
to
as
many
as
we
can.
A
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
are
also
available
via
your
registration
link.
You
use
to
sign
in,
and
the
recording
will
be
on
our
online
programs
youtube
playlist
as
well.
With
that,
I
will
hand
things
over
to
dimitri,
so
take
it
away.
B
Hey
folks
feels
a
little
weird
without
all
the
little
zoom
boxes
of
seeing
everyone
else,
but
that's
that
I
guess
we'll
do
for
now.
Well,
thank
you
or
maybe
later
viewing
this.
This
talk,
I'm
dmitry.
I
work
at
vmware
in
the
map
bu
unit,
mostly
working
on
kubernetes,
but
I
I
do
have
quite
a
interesting
background.
You
know
coming
from
cloud
foundry
and
you
know
before
that,
working
on
various
consulting
projects
with
pivotal.
B
So
today
we
really
want
to
talk
about
kubernetes
package
management
with
carvel
and
specifically
one
of
the
carvel's
project
called
cap
controller
carvel
is
an
oss
project
sponsored
by
vmware.
It
was
born
probably
around
two
years
ago.
Maybe
it's
actually
a
toolkit
of
various
kubernetes
related
tools.
B
Now
some
of
those
tools
are
generic
they're,
not
necessarily
specifically
written
for
kubernetes,
but
they
work
well
with
kubernetes,
and
some
of
those
tools
are
obviously
very
much
kubernetes
specific,
so
we
have
a
little
site
there
carvel.dev
that
actually
lists
out
all
of
the
tools,
and
we
are
also
talking
about
revamping
that
stuff
to
make
it
a
little
bit
more
new
user
friendly.
B
So
tell
us
what
you
think
when
you
visit
the
website:
here's
a
slack
pound
caravel
on
the
kubernetes
slack
instance.
We're
very
active
there
actually
recently
reached
a
thousand
really
excited
for
me.
Seeing
kind
of
a
community
grow
over
time,
and
you
know
we
welcome
anybody
to
drop
in
chat
with
us
on
carvel
related
questions
or
maybe
even
just
how
you
use
kubernetes,
we're
always
eager
to
learn.
B
You
know
what
you
all
are
doing,
so
one
thing
that
you
might
have
seen
from
recent
kubecon
is
a
talk
by
one
of
my
colleagues
chaterupa.
There
was
a
keynote
called
breaking
traditional.
The
future
of
package
management
with
kubernetes,
there's
going
to
be
a
link
that
you
can
click
in
the
slides
and
I'm
sure
you
can
find
it
on
youtube.
B
The
talk
kind
of
talked
about
what
we
have
been
up
to
within
carvel
community,
and
you
know
what
are
some
of
our
you
know,
desires
and
visions
for
package
management,
so
it
actually
serves
like
a
good
background.
Maybe
for
this
talk
now,
this
talk
is
maybe
more
of
a
continuation
to
kind
of
dive
in
a
little
bit
deeper
into
the
details,
and
I
actually
love
doing
a
lot
of
demos,
so
I
will
be
doing
a
lot
of
live
demos.
B
Hopefully
things
go
go
well,
but
if
they
go
wrong,
that's
actually
more
fun
than
usual
all
right.
So
one
of
the
slides
from
that
talk
was
this.
This
specific
slide.
It
was
calling
out
declarative,
kubernetes,
apis,
immutable,
bundles
distributor
of
oci
registries
and
really
picking
the
right
tool
for
the
job
right
and
when
I
say
the
right
tool
for
the
job.
What
I
mean
is
being
at
the
abstraction
level
that
your
problem
deserves
right,
so
most
users
right,
don't
necessarily
have
the
same
exact
problem.
B
It's
similar
problems
or
or
it's
really
kind
of
stacked
up
in
different
ways,
and
so,
at
least
from
my
experience,
I
think
it's
important
to
find
the
tool
that
actually
solves
your
problem
and
doesn't
actually
do
too
much
extra,
because
if
it
does
do
too
much
extra,
then
you
know
you're
dealing
with
all
the
extra
complexity
or
maybe
vice
versa.
Right.
You
found
a
tool
that
does
bare
minimum,
but
it's
not
quite
enough
for
your
for
your
problem.
B
One
of
the
actually
other
things
that
we'll
we'll
touch
on
is
is
is
using
oci
registry
as
a
storage
system.
Now,
obviously,
we
all
use
ocr
registry
for
container
images,
but,
as
you
probably
have
noticed,
the
industry
have
turned
into
using
registries
for
variety
of
other
artifacts,
and
we
also
caught
up
on
that
trend.
I
would
say
quite
a
bit
early
and
are
very
excited
in
how
we
use
the
registries
and
how
we
deliver
some
of
the
software.
B
So,
let's
jump
in
into
this
last
bullet
point
layered
approach,
so
carvel,
as
I
mentioned
before,
is
a
toolkit
right.
There's
various
tools
and
these
tools
try
to
follow
unix
philosophy.
B
We
have
a
tool,
for
example
that
allows
you
to
manage
kubernetes
resources
in
bulk,
as
kind
of
seen
as
an
application.
You
know
we
have
tool
that
allows
you
to
interact
with
registries,
and
you
know
do
interesting
things
with
with
the
assets
stored
in
the
registries
and
there's
a
few
other
tools.
One
of
the
tools
specifically
we'll
start
with
is
is
cap.
Cli
cap
cli
is
that
tool
that
allows
you
to
manage
multiple
resources
in
bulk
right.
B
You
can
think
of
it
as
cube
ctl
on
steroids,
we'll.
Actually
one
of
the
first
demos
is
to
actually
look
at
that
tool
and-
and
you
know,
deploy
something
with
it.
Since
I've
said
you
know,
different
problems
should
probably
be
solved
at
different
levels
of
abstraction,
so
capsule
is
really
a
cli
that
you
get
to
use,
maybe
yourself
or
maybe
in
your
ci
system,
but
we
also
thought
well,
there's
definitely
cases
where
it's
much
more
useful
to
have
an
abstraction
within
kubernetes.
B
That
represents
the
deployment
of
some
configuration
to
your
cluster
right
and
that's
what
app
cr
is
all
about.
It's
really
meant
to
describe.
How
do
you
fetch
configure
and
deploy
your
application
to
the
cluster?
The
next
oops?
Oh,
no,
oh
pressing,
the
wrong
button,
all
right.
The
next
layer
that
we'll
actually
talk
about
is
two
other
crs
package,
install
cr
and
a
package
right.
So
this
is
where
we
get
a
little
bit
into
maybe
more
traditional
thinking
around
package
management
right.
B
B
So
all
right,
the
next
final
top
level,
at
least
in
our
current
stack,
is
package
repository
and
a
package
repository
is
all
about
delivering
a
set
of
package
crs
to
the
cluster
right
so
similar
to
a
linux
distribution.
Right,
a
repository
contains
a
collection
of
packages.
In
our
case,
a
package
repository
contains
a
collection
of
package
crs
that
could
ultimately
be
installed.
B
So
we'll
take
a
look
at
this
entire
stack
as
we
go
along
and
see
what
happens.
Let's
dig
in
live
alrighty,
so
I'll
I'll
jump
over
to
my
terminal
here
and
I
do
have
a
cluster
over
here.
B
That's
authenticated
and
I'm
using
cap
cli
to
interact
with
this
cluster
right
now
right.
So
what
I'm
saying
is,
let's
list
all
of
the
applications
that
we
have
installed
to
the
system.
Now
we
haven't
currently
installed
anything,
so
the
list
is
empty,
and
so,
if
we
go
ahead
and
I've
prepared
a
few
handy
commands
to
run
for
ourselves
to
kind
of
explore
some
of
the
stuff.
B
B
We'll
see
that
cap
is
going
to
tell
us
what
things
we
will
install
with
this
yaml
right,
so
the
yaml
is
actually
from
one
of
our
carvel,
simple
apps
running
on
kubernetes.
It's
a
little
go
app,
but
in
our
case
over
here,
as
you
can
see,
we
have
a
service,
a
kubernetes
service,
that's
being
added,
and
we
also
have
a
deployment
that's
being
added
and
the
deployment
is
pointing
to
some
image.
That's
been
built
somewhere
and
similar
to
tools
like
terraform,
maybe
cloud
formation,
you
get
this
little
nice
diff
right.
B
That
tells
you
what
are
the
exact
operations
that
will
take
now?
One
of
the
benefits
of
using
cap
is
that
these
are
the
only
operations
that
will
be
taken
right.
So
you
know
exactly
what
would
happen
to
your
cluster.
This
gets
a
little
bit
interesting,
of
course,
once
you
actually
start
changing
the
objects,
not
just
creating
them
and
deleting
them
right.
So
let's
go
ahead
and
actually
press
confirm
and
we'll
have
our
app
being
deployed
here
and
it
succeeded
pretty
quick
and
we
can
actually
inspect
what
kind
of
resources
got
created.
B
So
here
I've
used
a
simple
app
as
the
name
so
we'll
say,
simple
app,
and
we
will
see
that
simple.
App
now
is
composed
of
two
six
resources
right
deployment
and
service-
that's
the
stuff
that
we
have
put
in
and
then
the
kubernetes
cluster
also
added
in
the
endpoints
for
the
service,
and
then
you
know,
of
course,
the
deployment
got
broken
down
into
the
replica
set
and
the
pod
and
etc
so
that
that's
the
that's
the
basic
of
cap
right,
you're,
able
to,
for
example,
go
ahead
and
say:
okay.
B
I
I
no
longer
want
this
app
on
my
cluster
and
you're
able
to
delete
it,
and
you
know
it
will
find
all
of
these
resources
and
get
rid
of
them.
One
of
the
you
know-
maybe
basics
around
cap
operation-
is
that
we're
not
trying
to
do
anything
outside
of
just
the
basic
kubernetes
feature
set
right,
we're
not
trying
to
hide
the
apis
or
anything
like
that.
For
example,
the
way
that
cap
knows
which
resources
are
associated
with
this
app
is
really
a
true
label.
A
B
Generating
a
unique
label
and
getting
that
deployed
all
right,
so
cap
cli,
you
know,
could
be
used
in
your
ci
environments,
for
example,
if,
if
you're
really
pushing
out
the
content
to
your
to
your
cluster-
or
maybe
you
are-
I
don't
know-
maybe
you're
for
whatever
reason
playing
locally
yourself
right
and
gives
you
ability
to
converge.
B
This
set
of
resources
in
you
know
in
some
kind
of
a
deterministic
manner
right
rather
than
trying
to
hunt
down
which
resources
were
in
a
previous
version
of
the
thing
that
you
were
deploying
and
removing
it
and
whatnot
so
with
cap.
Of
course
you
know
so
that
was
a
simple
little
example
right
and
you
know
we
can.
Of
course,
cap
is
used
in
production
environments
to
deploy
more.
You
know
serious
software
and
so,
for
example,
here's
an
example
of
here's
an
example
of
cert
manager
from
161
release
from
github.
B
I
will
install
that
real,
quick
as
well,
just
to
showcase
that
you
know
it's
it's
it's
happily
deploying
things.
It
does
show
you
a
little
progress
log
telling
you
what's
going
on
what
kind
of
research
is
getting
implied?
You
know.
A
B
Resources
are
getting
applied
in
parallel,
so
I'm
not
we're
waiting
for
some
pods
to
start
up
and
whatnot,
but
all
in
all,
all
it's
trying
to
do
is
just
deploy.
Converge.
Make
sure
that
the
resources
are
in
a
particular
state
and
we'll
go
ahead
and
also
delete
the
same
thing.
So
cap
delete
dash
acm.
B
Go
ahead
and
say:
yes,
all
right,
so
that
was
a
lowest
abstraction
level
that
we
typically
start
with
right.
Very
simple.
Now
in
our
next
example
over
here,
we're
actually
throwing
in
a
little
bit
of
a
configuration
challenge
right.
So
let's
take
a
look
at
this
config
right.
So
this
is
the
config
that
we
deployed
from
the
github
and
it
had
a
service.
It
had
a
deployment
and
it
had
something.
You
know
environment
configuration
going
on
there
and
a
particular
url.
B
Now
we
also
have
a
tool
within
carvel
called
ytt.
Ytt
is
all
about
changing
your
data
structures
that
are
represented
within
yaml
right
via
various
approaches.
Right.
Some
approaches
that
are
allowed
is
templating,
for
example,
another
approach-
that's
very
common,
is
overlaying
and
some
folks,
for
example,
mix
them
because
sometimes
the
overlaying
is
much
more
useful
for,
after
the
maybe
environment
specific
configuration
versus
maybe
templating
is
useful
when
you're
still
kind
of
reconfiguring
your
configuration
in
the
first
place
right.
B
So
we
allow
both
of
the
approaches
to
be.
You
know
either
solely
used
or
mixed
together,
found
it
very
powerful
when
dealing
with
especially
large
amounts
of
configuration.
B
So
let's
grab
that
and
do
a
little
deploy
over
here
so
we'll
have
well
actually,
let's
see
so
we'll
do
a
deploy
over
here
and
in
our
case
since
we're
just
updating
the
simple
app
that
we
previously
installed.
It's
actually
telling
us
that
we're
only
going
to
change
replicas
to
to
be
set
to
three
and.
C
B
Based
on
that
overlay
right,
that's
saying:
hey
we
will
set
replicas
on
the
deployment
within.
You
know
the
configurable
that
it
found
right,
so
it
matched.
This
particular
object
all
right.
So
let's
go
ahead
and
say
yes
and
I
think
to
nobody's
surprise.
You
know
if
we
go
ahead
and
say:
okay,
get
pod
right,
we'll
see
that
there's
three
pods
now
running
versus
what
it
was,
is
one
foot
running
before
right.
Nothing
too
complicated
right,
so
just
scoping
the
discussion
for
a
second
to
this
two
tools,
cap
and
ytt.
B
Right,
you
get
a
variety
of
possible
usages
right.
You
could
be
doing
all
kinds
of
things
with,
for
example,
using
other
tools
to
generate
the
yaml,
but
then
doing
a
cap
deploy
or
maybe
you're.
Actually,
maybe
you
actually
gen
using
ytt
to
generate
or
modify.
Let's
say
upstream
configuration
right.
If
I
wanted
to
tweak
something
insert
manager,
yama
that's
been
published
with
ytt
and
then
maybe
send
that
to
cube
ctl
or
some
other
tool,
for
example.
Mixing
and
matching
is
what
kind
of
a
brings
the
power
to
some
of
those
tools
right.
B
We're
not
trying
to
tell
you
what
is
the:
what
is
the
entire
tool
stack
that
you
should
be
using
right,
we're
really
trying
to
say.
Okay,
you
have
a
problem
on
your
hands.
We
have
this
particular
tool
that
solves
this
particular
problem.
B
Okay,
so
easy!
So
far,
all
right,
let's
get
a
little
bit
more
interesting
with
with
maybe
a
non-cli
option
right,
so
cap
deploy
is
great.
You
might
be
doing
it
yourself
or
maybe
you're
doing
it
in
the
ci.
That's
all
cool!
Some
of
our
users
do
appreciate
a
github's
first
approach
right
and
so
for
that
we
actually
have
a
project
called
cap.
B
So
let's
actually
go
ahead
and
install
cap
controller
with
cap
deploy
onto
the
cluster
and
I
think
we're
installing
the
latest
version
of
cap
controller
here
from
github
I'll
just
go
ahead
and
say:
yes,
you
know,
of
course
you
could
be
using
cube
ctl
to
do
this,
but
I'm
just
using
cap
deploy
here
and
what
we'll
do
is
actually
check
out.
What
is
it
doing
inside
this
number
three
directory?
B
So
what
does
app
cr
look
like,
so
actually
that's
not
a
directory
that
I
wanted
to
take
a
look
at
which
oh
yeah,
maybe
apps.
You
are
config
map,
oh
yeah,
that
is
the
directory,
so
app
cr
is
really
composed
of
three
pieces,
fetch
template
and
deploy.
B
We
felt
like
this
is
the
right
amount
of
balance
that
allows
you
to
mix
and
match
certain
things
right.
For
example,
you
might
be
fetching
things
from
a
config
map
in
this
case
right,
so
we
have
a
config
map
that
actually
contains
a
bunch
of
yaml
and
overlay
and
you're
able
to
combine
it
in
particular
ways.
So
in
this
particular
case,
you
can
combine
it
with
ytt
and
finally,
as
a
last
step,
you're
doing
a
cap
deploy
right,
and
so
what
this
app
cr
is
meant
to
describe
is
your
way
of
deploying
this
application.
B
You
can
imagine
right
if
you
have
a
hundred
apps,
it's
very
beneficial
to
have
that
consistency
across
all
of
them
right.
They
always
get
deployed,
let's
say
by
app
cr
driven
through
git,
for
example,
now
node.
We
also
have
a
service
account
over
here,
because
appcr
doesn't
give
you
any
kind
of
privileges
you
do
have
to
bring
your
own
service
account
so
that
the
fcr
will
use
it
and
actually
deploy
it.
So,
in
our
case
over
here
we
have
a
config
yaml
that
we
want
to
deploy.
B
So
let's
go
ahead
and
do
that
the
cap,
so
we
have
a
cap
control
already
installed
on
the
cluster.
We
will
actually
go
ahead
and
do
a
delete
of
simple
app,
because
that's
where
we're
going
to
be
installing
through
app
cr,
so
that
hopefully
gets
rid
of
pods
real
quick
here
goes
all
right.
So
we
only
have
cap
controller
now
and
we
will
go
ahead
and
apply
the
we'll
create
a
service
account
here.
So
I'll
actually
copy
this
out
over
here,
we'll
create
a
service
account
so
that
our
app
cr
can
deploy
things.
B
And
we're
using
in
this
example,
of
course
default
namespace.
But
you
know
this
is
not
really
namespace
specific
and
so
we'll
go
ahead
and
actually
deploy
our
appcr
right
and
a
config
map
to
our
cluster
here
goes
so.
Cap
is
actually
smart
enough
to
wait
for
app
cr
to
reconcile,
and
you
can
actually
see
that
that
app
cr
reconciled
pretty
quick
and
there
is
some
nice,
some
nice
status
information
that's
available
to
you.
B
We
have
you
know
our
spec
of
how
we
told
appcr
to
do
things,
but
we
also
have
the
status
getting
that
hey.
The
deploy,
have
succeeded
and
note
over
here
the
deploy
that
that
output
may
look
very
familiar
and
the
reason
why
it
may
look
very
familiar
is
because
app
cr
actually
internally
uses
cap
deploy
to
deploy
the
application
right
so
we're
building
on
top
of
that
lower
primitive
within
this
higher
level.
B
Now
you
also
notice
that
the
fetch
step
succeeded
over
here.
It
it
fetched
some
stuff
from
a
config
map,
nothing
too
exciting.
Right
and
finally,
you
know
the
templating
steps
succeeded
over
here
and
we
do
have
this
nice
little
handy,
inspect
output
indicating
what's
been
what's
been
created
so
now,
after
that,
appcr
has
succeeded.
You
actually
get
to
see
via
cap.
B
That
simple
app
exists
here
deployed
three
pods
over
here
happily
running
right
and
you
know
we
can
go
ahead
and,
for
example,
change
something
inside
this
config
map.
Let's
say
we
want
to
scale
it
down
to
four
and
we'll
go
ahead
and
apply
the
same,
we'll
even
make
it
a
little
fancy
here
and
show
you
that
that's
what
we're
changing
here,
we're
changing
the
replicas
for
yes
and
then
the
app
cr
should
pick
up.
It
might
have
already
picked
up.
So
okay
get
pod.
B
Now,
there's
four
pods
running
right,
all
right!
So
that's
the
app
cr
level
layer
that
we've
been
talking
about
and
let
me
flip
back
to
the
slide
real
quick.
So
we've
covered
the
cap
cli
and
then
we're
also
covering
right
now
the
app
cr.
B
Now,
let's
take
a
look
at
the
app
cr,
that's
a
little
bit
more
complicated
than
what
we
have
right.
So
what
we
had
was
just
hey,
read
some
stuff
read
some
content
from
a
config
map,
but
that
might
be
useful
for
maybe
a
local
tweaking
local
development.
Maybe
even
you
can
imagine
building
little
clies
that
that
that
allow
you
to
fill
in
the
config
map
from
your
local
resources
more
on
that
later,
maybe
beyond
the
talk,
come
talk
to
us
about
your
use
cases
in
the
slack
channel.
B
Here's
on
the
other
hand,
a
more
complicated,
app
cr
that
actually
quite
powerfully
captures
what
most
people
want
right.
So
they
have
a
maybe
a
git
repository
somewhere
that
contains
some
configuration
and
they
want
to
be
able
to
munch
this
configuration
a
little
bit
and
then
finally,
they
want
to
deploy
it
right.
So
same
exact
steps
in
this
case,
though,
we're
only
fetching
from
git
we're
doing
a
little
bit
of
ytt
massaging
for
for
that
configuration,
we're
deploying
this
right.
So
let's
go
ahead
and
again
we'll
do
cap
delete.
B
Oh
actually,
this
is
oh
yeah,
that's
true!
Okay,
so
you
can
actually
see
that
it's
changing
from
inline
to
get
it's
changing,
ytt
from
doing
nothing
to,
for
example,
including
a
particular
set
of
directories
within
what
it
fetched
and
then
it's
actually
getting
rid
of
this
config
map,
because
there's
no
need
for
it.
B
And
so
that
happened
awfully
fast,
but
here
it
is
reconciled.
We
can
actually
take
a
look
at
this
and,
as
you
can
actually
see,
because
we're
fetching
from
git
this
time
there
is
actually
a
little
bit
of
handy
information,
that's
being
included
over
here,
we're
actually
showing
what
is
the?
B
What
is
the
commit
that
it
fetched,
and
you
know
here-
you
can
actually
see
that
it
converged
based
on
the
changes
right
so
previously
this
our
config
map
was
containing,
I
guess,
a
deployment
in
the
service
and
after
it's
been
fetching
this
stuff
from
the
actual
git
repository,
there's
been
a
little
bit
of
changes
and
you
can
actually
configure
appcr
to
show
you
the
exact
difference
similar
how
we're
doing
locally,
but
at
least
in
this
case
it's
it's,
not
it's
not
configured
to
do
it,
and
then
we
also
have
the
little
inspect
over
here.
B
So
back
to
capital
s
here,
you
can
see
we're
back
to
back
to
app
ctrl
being
now
managed
by
the
by
the
git
source.
B
Okay,
so
that's
a
git
repo
with
some
yaml
and
you
know
nothing
nothing
too
exciting,
because
app
cr
is
really
somewhat
agnostic.
Right
to
the
content
that
it's
fetching
right
and
the
split
between
fetching,
templating
and
deploying
is
really
this
powerful
way
of
thinking
about
stuff
right.
We
can
do
all
kinds
of
other
things
that
you
know
a
lot
of
the
common
use.
B
Cases
call
for
right,
so
here
we're
fetching
from
a
bitnami
chart,
git
repository
at
a
particular
reference,
we're
actually
saying:
let's,
let's
do
a
little
bit
of
helm
templating,
this
particular
nginx
values
and
this
chart,
I
guess,
supports
the
configuration
of
nginx
server
and
then
we're
also
on
top
of
that.
So
not
just
we
did
the
helm
template,
but
on
top
of
that,
we're
also
doing
ytt
overlay
that
allows
us
to
change
something
that
is
not
configurable
in
that
chart.
B
All
right
so
we'll
go
ahead
and
say
so
we
are
creating
the
nginx
app
cr.
We
are
deleting
our
simple
app
because
I
guess
we
don't
need
it
anymore
in
this
config
and
we're
also
applying
the
nginx
values.
So
let's
go
ahead
and
say
yes
to
that.
B
So
that
may
take
a
little
bit
since
it's
going
to
you
know,
deploy
the
resources
to
the
cluster,
fetch
the
images
etc.
You
can
actually
see
well,
not
quick
enough.
I
guess
you
can
actually
see
incremental
output
as
things
progress
right,
so
we
don't
just
update
the
status
at
the
end,
we
actually
update
the
status
as
as
the
app
cr
reconciliation
progresses
and,
as
you
can
see
over
here,
the
nginx
helm
chart
here
was
it
had
the
deployment
and
the
service
and
and
the
config
map.
B
I
guess
nginx
server,
server,
block
and
ultimately
deployed
that,
and
supposedly
there
is
some
nginx
running
here,
yep
there's
engine
export
running
inside
the
default
namespace,
where
I'm
installing
it.
B
So
that's
that
kind
of
showcases
right,
the
power
that
you
can
really.
You
know
we
could
actually
be
within
app
cr.
You
know
there's
like
different
ways
of
fetch
things,
and
so
you
could
be
using
a
helm
chart
directly
to
fetch
it
from
the
helm
repository
or
it
could
be
using
git
or
you
can
actually
be
doing
something
that
we've
been
doing
at
vmware.
B
B
Actually
one
thing
that
recently
somebody
was
was
really
appreciative
of
is
the
feature
of
being
able
to
decrypt
a
certain
configuration
via
sops
as
part
of
the
templating
section.
So
we
do
have.
B
We
do
have
a
sops
configuration
that
you
can
provide
over
here
to,
for
example,
use
the
age
backend
to
decrypt
some
of
the
configuration
that
might
be
encrypted
in
your
git
repository
and
in
theory
you
know,
if
you
haven't
noticed
here,
fetch
is
an
array,
so
you
could
actually
be
fetching
multiple
things,
so
one
of
those
things
could,
for
example,
be
your
encrypted.
B
You
know
credentials,
maybe
right
if
that's
how
you
manage
your
credentials
in
the
production
right.
So
a
lot
of
the
flexibility
here,
because
a
lot
of
people
have
different
choices
made
for
their
production
environments
for
their
dev
environments,
et
cetera,
all
right.
So
let's
keep
on
going
here.
So
the
next
example
that
we've
got
going
on
is
an
app
cr
that
actually
uses
this
concept
of
an
image
package
bundle.
B
And
so
what
exactly?
Are
these
image
package
bundles
well
to
break
that
down
a
little
bit
more,
maybe
in
a
more
visual
way?
Let's
actually
look
at
this
slide
over
here,
I'm
not
going
to
press
the
present
mode,
because
it's
a
little
bit
don't
see
my
screen.
So
it's
it's
a
little
bit
terrifying.
B
So
we'll
we'll
break
this
concept
of
a
bundle
into
a
few
things
right
so
to
deploy
something
to
kubernetes.
You
need
some
configuration
right
now
that
configuration
may
come
in
different
types
of
formats,
for
example,
it
might
be
a
configuration,
that's
a
plain
yaml
manifest
right.
It
might
be.
You
know,
helm
template,
it
might
be
a
ytt
template.
Maybe
it's
some
new
templating
mechanisms
that
you
know
have
recently
been
invented
right
now.
Previously
I've
mentioned
that
similar
to
the
rest
of
the
industry.
B
There's
a
recent
trend
that
let's
use
registry,
because
it's
such
a
common
api,
now
that's
available
everywhere.
Let's
use
the
registry
to
actually
store
content,
that's
not
directly
container
images!
So
we've
we've
started
doing
that
quite
a
bit
ago,
with
this
tool
called
image
package
and
one
of
the
things
that
we've
kind
of
organically
grew
is
in
image
package.
B
Is
this
concept
of
a
bundle
we
want
to
be
able
to
not
not
just
to
store
the
configuration
of
something,
but
we
also
want
to
be
able
to
reference
other
oci
artifacts
so
that
we
can
build
up
a
graph
of
the
software,
and
so
this
image
kind
of
tries
to
showcase
that
right.
B
So
you
may
have
some,
let's
say:
yaml
configuration
file,
2
yaml
file,
3
yaml,
but
we
also
have
this
dot
image
package
images
ymo
that
references,
this
other
images
that
are
being
let's
say,
referenced
by
this
file,
2nd
file,
3
ammos
right
now
we
do
have
another
tool
that
actually
easily
is
able
to
evaluate
like
hear
the
x
number
of
images
that
you've
been
using
and
then
actually
create
the
images
yaml
for
you.
But
the
general
concept
of
being
able
to
build
up
this
graph
is
quite
powerful.
B
What's
even
more
powerful
about
this.
Is
that
when
we
do
this
reference
to
another
image,
it
could
in
here
be
another
bundle
right,
so
you
can
kind
of
see
how
we're
building
up
this
graph
and
image
package
itself
doesn't
actually
have
an
opinion.
What's
inside
those
images,
it
doesn't
even
know
right.
It
just
knows
how
to
deal
with
oci
registry
references.
B
Now
these
oci
register
references
don't
even
have
to
be
in
the
same
registry
right.
You
know
if
you've
seen,
for
example,
you
know
you
may
want
to
push
your
configuration
up
into
your
registry,
but
that
configuration
is
actually
pointing
to
the
other
registries.
Maybe
something
to
you
know
in
gcr
or
docker
hub,
et
cetera,
et
cetera,
because
I
don't
know
depend
depending
on
your
level
of
confidence
with
some
of
the
external
assets
right.
You
may
be
just
consuming
the
external
assets
directly
versus
like
trying
to
rebuild
them
yourself
directly
right.
B
So
how
does
this
actually
look
like
when
somebody
is
building
image
package?
Bundles
right?
Well,
it
actually
looks
very
close
to
what
you
typically
do
with
with
docker
commands
right.
So
you
have
this
image
package
push
that
takes
a
reference
and
you
also
get
to
specify
the
content
of
the
bundle
right
and
so
inside
this
my
bundle
directory.
You
typically
would
have
that
image
package
bundle
subdirectory
that
contains
a
little
bit
of
metadata
and
the
content
that
you
want
to
put
in
there.
B
So
that's
that's
that
that's
where
it
gets
interesting
right.
Once
you
have
this
graph,
you
can
do
cool
things
around
it.
Now
more
recently,
we
actually
added
a
functionality
to
also
grab
the
cosine
signatures.
B
We,
you
know,
we
know
the
entire
graph,
and
so
that
means
that
we
can
actually
check
if
for
each
one
of
the
nodes
in
the
graph,
is
there
an
associated
signature
or
multiple
signatures
right?
We
can
also
start
bringing
in
things
like
as
bombs,
and
you
know
at
the
stations
right.
It's
really
you
know.
Once
you
have
the
graph,
you
can
do
all
kinds
of
additional
things
that
you
know.
B
Production
system,
for
example,
may
want
to
take
advantage
of,
and
finally
you
know
once
you've
carried
that
over
maybe
to
your
own
registry
or
maybe
you've,
you
know
kept
the
bundle
in
the
original
location.
You
know
you
can
always
pull
it
unpack
it
into
a
directory.
This
just
unpacks.
The
contents
of
the
bundle
directly
like
doesn't
actually
bring
over
all
the
referenced
images
or
anything
like
that,
but
it
does
give
you
a
list
of
referenced
images
that
you
can
take
advantage
of,
and
you
know
put
it
in
into
you-
know,
consume
it
via.
B
You
know
some
other
system
and
actually
use
those
references
right
now,
because
we
are
requiring
everything
to
be
digest
based,
digest
referenced
right.
We
have
that
guarantee
that
your
bundle
digest
represents
the
entire
graph
that
it
captured
right.
So
again
you
can.
You
can,
for
example,
cosine
the
bundle
itself
right
and
then
that
that
effectively
translates
into
the
confidence
that
you're
bringing
over
the
entire
thing
and
it's
all
exactly
the
same
digest.
B
So
that's
a
little
bit
of
image
package,
and
so,
where
does
that
leave
us
right?
So
in
our
example
over
here
we're
actually
using
image
package
bundle.
I
think
this
is
one
of
the
images
that
we
use
in
in
our
end-to-end
test,
suite
for
cap
controller,
but
you're
able
to
download
this
bundle
and
then
you
know
run
some
configuration
munching
on
it.
B
B
And
so,
as
you
can
see
over
here,
where
we're
adding
our
app
cr
that
that
uses
the
image
package
bundle
we're
actually
deleting,
in
this
case
the
engine
x,
related
bits,
because
I
guess
this
example
no
longer
needs
it,
and
so
first
step
right
fetching.
We
will
take
advantage
of
image
package,
pool,
grab
the
bundle
and
deploy
it,
and
you
can
actually
see
it
here
again.
Nothing
too
exciting
again
we're
back
to
we're
back
to
our
deployed
applications
pretty
quickly.
B
So
that's
how
you
would
use
a
bundle
now
what's
interesting
about
oci
registry.
Is
they
do
give
you
this?
You
know
location
where
you
can
find
various
things
right,
and
so,
once
you
get
to
that,
you
can
get
a
little
bit
fancy
with,
for
example,
your
tags
right.
B
So
here
we're
saying,
use
the
particular
tag
right
now,
but
also,
for
example,
if
you,
if
you
really
wanted
to
do
this,
for
a
production,
would
probably
do
something
like
you
know,
k
build
through
it
and
actually
grab
and
have
your
yaml
have
the
digest
right
to
to
be
referenced
to
that
exact
image.
However,
in
this
example
we're
saying
you
know
what
we
don't
want
to
know
which
tag
is
going
to
get
picked,
which
image
is
going
to
get
picked.
B
It
will
happen
automatically
based
on
this
tag,
selection
policy
right
so
in
in
here
we
have
semver
as
the
way
to
decide
what
to
fetch,
and
so
within
this
oci
registry
repository
there's
a
few
tags.
I
think
this
one
was
using
v1.
This
one
will
most
likely
pick
v2
because
I
think
that's
what
it
is,
and
so
let's
go
ahead
and
actually
apply
that
as
well.
B
So
we'll
say,
I
think
it's
that,
and
so
here
we're
changing
to
the
tag
selection,
we're
also
throwing
in
some
ytt
stuff,
not
that
it's
really
necessary,
but
so
here
it
goes,
it
goes
in
and
image
package
will
talk
to.
The
registry
will
figure
out
what's
going
on,
which,
which
is
the
tag
you
want,
and
so,
if
we
look
at
that
app
status,
we
will
actually
see
what
happened
here.
So
you
can
actually
see
that
it
pick
tag
vo
now
by
default.
B
Actually
we
don't
pick
pre-release
versions
right
because
pre-releases
are
not
necessarily
maybe
production
man.
However,
you
could
you
could
add
a
little
bit
more
configuration
over
here.
That,
for
example,
says
include
the
prereleases
or
maybe
even
even
one
of
my
favorite
features,
maybe
include
certain
pre-releases
that
have
let's
say
rc
in
them
right
and
so
that
kind
of
acts
as
a
way
for
you
to
filter
out
like
what.
What
do
you
actually
want
your
environment,
to
be
consuming
right
and
in
different
types
of
environments?
B
You
might
be
consuming
slightly
different,
artifacts
right
all
right,
so
that
was
an
example
of
how
we
use
more
flexible
fetching
right
to
determine
what
you
actually
want
to
install
right.
B
So
so
far,
we've
gone
through
the
examples
of
cap
cli
doing
the
deploy
directly.
You
are
responsible
for
running
the
cap,
deploy
right
wherever
you
are
right.
We
looked
at
app
cr
that
allows
you
to
explicitly
say
concretely
how
to
deploy,
how
to
fetch
template
and
deploy
your
application
right
and
cap
controller
will
facilitate
that
continuously.
B
By
the
way.
Maybe
I
haven't
made
that
clear
sorry
this
is
this
is
something
that's
been.
That's
maybe
been
not
talked
about
is
that
the
app
cr
deployment
process
happens
continuously
actually
for
app
crs.
The
default
is
fairly
short.
It's
it's.
I
think
it's
about
30
seconds
or
something
like
that
right.
B
So
this
this
loop,
if
actually
is
happening
all
the
time
now,
there's
definitely
a
few
optimizations
to
react
to
the
system
in
various
ways
more
quickly,
but
at
the
least
right
there
is
that
reconciliation
period
happening,
and
so,
if
your
artifact
is
changing
right,
like
you
might
be
pointing
to
an
origin
develop
here,
right
and
origin,
develop
keeps
on
changing.
Cap
control
will
pick
up
those
changes
and
redeploy
them
right
at
that.
You
know
at
that
time.
B
App
cr
you
get
to
specify
concretely
how
to
deploy
something
now
in
a
higher
level
block
right.
If
we
go
back
to
our
to
our
slides
over
here,
the
next
layer
of
this
notion
of
a
packaging
style
impact
cr
well,
sometimes
right
times,
users
don't
want
to
actually
decide
how
to
deploy
something
right.
They
don't
know.
Maybe
some
other
team
is
responsible
for
determining
that.
Maybe
somehow
they
receive
that
piece
of
software,
so
they
want
to
not
worry
about
it
right,
and
so
that's
exactly
what
package
tr
is
about.
B
Let
me
just
kind
of
focus
on
this
particular
cr,
so
we
have
kind
package
cr
right.
It
has
a
name
ref
name
here,
and
it
has
a
version
right.
So
this
is,
what's
you
can
think
of
it
similar
to
how
crgs
have
a
fully
qualified
name
right?
We
expect
each
package
to
also
have
a
fully
qualified
name
right
so
that
there
is
no
funky,
maybe
aliasing
conflicts
going
on
and
whatnot,
and
we
also
want
a
version
to
be
provided
right
now.
This
two
pieces
of
information
is
is
actually
this.
B
This
section-
and
this
section
is
what's
required
in
package
cr
everything
else
is
optional.
Obviously,
it's
good
to
provide
all
kinds
of
useful
metadata
to
whoever
is
consuming
this
package
crs,
but
for
our
example
here
really
the
focus
is
the
ref
name,
the
version
and
the
template
section.
Now
the
template
section
is
actually
app
cr
type
embedded
in
right.
So
this
is
a
similar
pattern:
how
the
deployment
in
kubernetes
embeds,
for
example,
a
pods
pack
right.
B
So
this
is
exactly
the
same
thing,
and
this
is
ultimately
how
this
how
it
gets
translated.
Is
that
package
install
that
operates
on
the
package?
Cr
that
reads
it
in
right
through
a
reference,
it
will
create
that
app
cr
based
on
this
template
right.
So
all
of
the
functionality
that
you
might
have
been
using
directly
with
app
cr
right
could
be
interior
used
here.
B
Right
now
for
our
own
usage,
we
have
mostly
stuck
with
image
package
bundles
because
they
provide
you
that
nice
guarantee
of
immutability,
especially
when
pointed
through,
digest
right,
but
you
may,
for
whatever
reason,
want
to
hide
what
a
piece
of
software
how
the
piece
of
software
is
actually
being
installed,
and
maybe
that
software
is
being
installed
from
a
git
repository
at
a
particular
git
show,
or
something
like
that
right
or
maybe
just
continuously
changing
right.
B
So
that's
the
package
cr
right
and
once
it
gets
loaded
into
the
system
right,
you
can
now
use
package
install
to
install
it
based
on
a
ref
name,
based
on
a
particular
version
selection.
Now,
no,
the
version
selection
kind
of
sounds
like
that
tag,
selection
that
I've
previously
mentioned
in
the
app
cr.
Well,
it's
actually
backed
by
the
same
little
struct,
and
what
that
allows
you
to
do
ultimately
is
allows
you
to
specify
the
policy
of
which
version.
Do
you
want
to
select
right?
B
And
so
because
the
package
crs
are
actually
require
you
to
have
versions
to
december
format.
B
You
get
to
potentially
put
in
some
interesting
constraints
here
that
have
your
system
automatically
evaluate
and
kind
of
maybe
keep
things
updated
continuously
right.
So
let's
actually
go
ahead
and
install
this
package
cr
to
our
cluster
over
here.
So
we'll
grab
that
and
we'll
do
oops
unauthorized.
Well,
that's
unfortunate.
I
think
my
session
expired
for
the
cluster.
Let
me
stop
sharing
for
a
second.
B
B
That's
right,
I
was
kind
of
you
know.
I
I
did
the
refresh
my
tokens
and
whatnot
right
before,
but
I
wasn't
actually
sure
how
long
and
when
they
expire.
So
there
was
a
calculated
bet
that,
hopefully,
maybe
they
last
an
hour,
but
I
guess
they
last
a
little
less.
B
All
right,
hopefully,
we're
back
so
as
I
was
saying,
we're
going
to
run
the
cab
deploy,
and
here
it
goes
again
all
right.
So
here
what
we're
doing
is
we're
adding
a
package
cr
to
the
cluster.
We
have
an
app
over
here
and
we
have
a
package
installed
and
in
fact,
what's
actually
going
to
get
a
little
funky
here
is
that
both
packaging
style
and
app
they're
called
simple
app
here,
and
so
let's
go
ahead
and
actually
still
go
for
it,
but
because
package
install
installs
the
app
it
might
get
a
little
confused.
B
If
you
will
so,
let's,
let's
see
what's
going
on
over
here,
so
oops.
So
so
we
have.
B
I,
I
guess
it's
finished
all
right
and
so
still
was
pretty
quick.
We
have
the
app
that
simple
app
and
we
also
now
have
a
package
installed
oops.
Is
it
not
package
install
like
that?
I
actually
don't
recall
what
it's
supposed
to.
Oh,
it
must
be
package
install
yeah.
The
shortcut
is
the
the
short
name.
Is
packager
and
I've
been
using
it
for
for
long
enough
to
remember
the
la
to
forget
the
long
name,
all
right.
B
So
we
have
a
version,
two
that's
been
installed
and
we
have
the
app
that
ultimately,
the
package
install
created
as
a
result
of
this
package
cr.
Now
we
also
have
package
record
here
right.
That's
the
thing
that
we
imported
version
two
here
is
it
in
its
yaml
shape
and
form,
and
it
actually
tells
you
all
the
information
that
we
saw
in
the
yaml.
Actually
one
thing
I
forgot
to
mention
was
the
little
section
over
here
in
the
package.
Yaml
that
I
hidden
away
is
the
little
values
schema.
B
So
you
can
actually
know
what.
Potentially
your
package
is
exposing
as
configuration
we'll
get
to
that.
I
think
in
a
moment,
so
package
install
successfully
installed
version.
Two
sounds
great.
Nothing
fancy
again.
B
What
we
have
here
is
the
following,
so
the
package
install
can
be
configured
with
certain
values
and
unfortunately
I
think
this
this
example
doesn't
actually
showcase
the
values
that
it's,
how
it's
configuring,
let's
say.
Maybe
this
one
yeah
so
here's
an
example
of,
for
example,
packaging
style
allows
you
to
specify
certain
values
and
this
values
are
referenced
through
a
secret
and
inside
the
secret
right.
You
could
be
dropping
in
you
know
that
configuration.
So
this
is
very,
you
know
exactly
the
same.
Actually
as
the
app
cr.
B
B
True
values
right
like
well,
somebody
authored
some
software
and
they
just
don't
have
they
just
don't
have
a
certain
configuration
up
that
you
really
need
in
your
environment
right,
that's,
ultimately
how
we
actually,
you
know
why
ytt,
for
example,
includes
templating
and
overlaying,
because
we
do
see
that
80
20
match
between
80
of
templating,
let's
say
and
20
of
overlaying
right,
especially
in
production
environments,
where
with
different
kind
of
ways
of
configuring
things.
B
So
in
this
example
we're
saying
package
install:
please
use
this
secret
as
an
additional
overlay
on
top
of
this
package
so
that
by
the
time
gets
installed,
things
get
modified
a
little
bit.
So
in
this
case
we're
actually
say
setting
replica
5
in
our
overlay
and
right
now,
there's
only
three
pods.
So
if
we
go
ahead
and
think
again,
I
have
real
handy
copy
paste.
B
So
I'm
cheating
a
little
bit
over
here.
I'm
using
this
dash
p
dash
p
flag
and
what
that
means
is
actually
don't
try
to
delete
anything
only
do
the
create
or
update
actions,
which
is
handy
if
you're
just
kind
of
iterating
on
stuff-
and
maybe
you
don't
want
to
provide
the
entirety
of
the
config
every
single
time,
and
so,
as
you
can
see
over
here,
the
diff
is
add
the
little
overlay
on
the
package
install
and
we
actually
have
well.
B
Our
secret
is
hidden
away
from
us
because
who
knows
maybe
it's
sensitive
information,
but
the
overlay
yaml
includes
you
know,
setting
two
five
replicas,
and
so,
if
we
go
ahead
and
cap
deploy
this,
hopefully
a
few
seconds
later,
we
can
see
that
now
there
is
five
parts
instead
of
three
parts
right,
so
our
overlay
is
actually
modifying
our
overlays
modifying
the
underlying
package
in
a
particular
way
right.
B
So
this
is
a
really
great
way
to
adopt
something
from
let's
say
upstream
right,
but
you
don't
necessarily
have
you
know,
ability
to
modify
it
and
you
don't
want
to
fork
it.
You
don't
want
to.
You
know,
do
something
special
just
for
yourself
right,
so
you
get
to
use
the
overlay
to
override
and
add
in
your
opinions,
all
right,
so
here's
another
example
package
install
of
nginx.
It's
not
that
exciting.
I
would
say,
since
we've
already
seen
app
cr
taking
advantage
of
that
nginx.
B
So
if
you
actually
look
at
the
package
yaml,
you
can
actually
see
that
this
is
a
straight
copy
of
that
app.
Cr
put
it
in
here
wrapped
in
a
package
cr,
we
give
it
a
name,
nginx
testcarvel.dev
version.
One
right
and
in
package
install
you're,
saying
I'd
like
to
install
version,
one
of
nginx
test,
carveldev,
right
and
you're,
providing
those
values.
So
given
the
time
where
I
think
running
a
little
low
here,
I'm
just
going
to
skip
over
this
example
and
maybe
jump
straight
through
this
example
of
package
repository
our
highest
layer.
B
B
Well,
you
could
definitely
throw
it
in
into
let's
say
an
image
package
bundle
or
a
git
repository
and
have
another
app
cr
that
keeps
on
updating
your
cluster
totally
valid
way
of
using
it,
but
we
figured,
let's
actually
add
a
higher
level
concept
package
repository
that
allows
us
to
specify.
Where
is
this
repository
located
through?
You
know
the
fetch
section
right
and
ultimately
being
able
to
install
things
from
that
package
repository
right,
so
an
example
of
this
would
be
so.
B
B
B
So
we
have
a
package
repository
and
a
package
install.
Let
me
go
ahead
and
say
yes
right
and
what
would
happen
oops?
What
will
happen
is
that
if
we
look
inside
our
cluster,
the
package
repository
brought
to
this
three
package
crs
of
different
versions
right
and
our
packaging
style,
actually
decided.
Okay,
I'd
like
to
actually
install
version.
One
now,
there's
actually
a
few
variations
I
put
in
here
for
just
the
sake
of
entertainment
here.
B
So
this
is
how
you
specify
an
explicit
version,
but
you
may
actually
specify
just
give
me
the
latest
thing
right:
we're
not
specifying
any
constraints
right.
So
in
this
case
the
latest
thing
would
have
been
200
right
versus
1
0
that
I
explicitly
selected
and
remember.
I
said
that
we
don't
actually
do
rc
or
we
don't
do.
Pre-Release
builds
right
and
so
minus
rc
is
the
pre-release
build,
so
you
could
actually
enable
it
and
say:
okay
well,
actually
get
me
the
latest
any
build
or
see
you
or
not
right.
B
So
that's
that
one
thing,
maybe
worth
mentioning
real
quick,
really
running
out
of
time
is
okay,
well,
package
repositories,
right
who's,
creating
this
package
repositories.
Well
recently,
one
of
the
teams
was
in
vmware
tanza,
actually
made
a
opened
up,
an
open
source
project
called
tanzu
community
edition
right
and
so
an
example
of
a
a
real
package.
Repository
comes
from
folks
from
from
those
folks
over
there,
a
really
great
job
at
at
making
that
all
happen.
B
So
if
we
go
ahead
and
say
cc
f
and
I
think
it's
9.1
tce
tc
yaml
I'll
just
go
ahead
and
add
this
repository
here,
real
quick,
so
we'll
go
ahead
and
say
yes
and
give
it
a
few
seconds
here,
and
so
previously
we
only
had
this
set
of
packages
right
now.
If
we
go
ahead
and
say,
show
me
the
packages
inside
this
namespace,
we
got
lots
of
different
packages
right
now.
B
As
you
can
see
here,
we
actually
have
multiple
versions
of
cert
manager
that
the
tc
community
has
included
in,
and
you
can
actually
see
package
metadata,
which
is
kind
of
a
more
combined
view.
It
doesn't
have
any
versions
or
anything
just
the
package
names,
and
so
you
can
see
we
have
search
manager,
contour,
etc,
etc.
B
Right,
but
this
is
just
an
example
right
and
in
addition
to
our
other
repo
that
brings
in
some
other
packages
you
know
from
from
our
earlier
examples,
I'm
now
going
to
go
and
do
maybe
an
install
of
cert
manager.
I
think
you
all
got
the
point
already
that
it
just
all
it
is,
is
a
standard
now.
Api
was
in
kubernetes
package
installed,
something
right,
and
it's
done
so
we'll
we'll
maybe
get
back
to
the
window
over
here.
So
the
last
slide
I
had
was
you
know:
please
join
us
in
the
carvel
slack.
B
We
love
the
discussions.
We
want
to
hear
your
feedback
when
you
hear
your
ideas.
Carvel
dev
is
a
also
a
good
starting
point
to
find
out
more
about
all
these
carvel
tools
and
do
do
tell
us
the
suggestions
of
how
we
can
improve
any
of
this
stuff.
What
are
your
use
cases
and
how
we
can
be
helping?
You
potentially
solve
those
use
cases,
and
I'm
going
to-
I
guess,
flip
over
to
the
to
the
chat
over
here
and
see
any
questions
here
that
might
be
worth
calling
out
and
by
the
way.
B
If
anybody
wants
to
discuss
their
questions
further
jump
in
jump
into
the
carvel
slack,
we
can.
We
can
discuss
there
too.
So
what
do
we
have
here?
So
hello
from
slovakia,
hello
from
brazil,
hello,
all,
hey,
hey
all
to
you
too
hello
from
prim?
Is
it
prem
or
or
is
it
perm
from
france
just
to
level
set
package
management
with
skates
that
will
be
discussed
here
is
fully
upstream
compatible,
not
being
very
timezo
specific.
Yes,
absolutely
it's
all
oss.
B
It
just
happens
to
live
within
a
vmware
tanzu
github
organization,
but
it
is
a
just
like
all
the
other
projects
contour.
You
know
valero
they're,
all
open
source,
anything
you
can.
You
can
take
to
to
use
yourself
and
that's
been
already
replied
any
insight
on
difference
between
argo,
cd
and
cap.
Well,
cap
cli
is
a
cli
right
that
allows
you
to
do
that
deployment.
So
it's
a
little
different
in
the
sense
that
argo
cd
is
a
system
to
to
it's
a
higher
level
system
right.
B
So
arguably
one
would
want
to
compare
argo,
cd
and
cap
controller.
That
goes
a
little
bit
into.
We
feel,
like
the
feature
set,
that
we
have
and
the
way
that
the
apis
are
designed
is
more
kubernetes
centric
rather
than
argo
cd,
and
we
also
like
the
laying
that
we've
got
going
on
on
top
of
the
cap
cli
the
app
crs
the
packages
etc.
So
that's
that's
our
take
on
it
and
and
possibly
this
helm
and
customize
huge
topic.
B
We
do
have
some
notes
in
in
the
ytt
documentation.
How
we
feel
like
ytt
is
comparing
to
some
of
them.
Are
these
atomic
operations?
Can
we
add,
custom
template
engines
tools,
so
some
folks
try
to
extend
a
little
bit.
We
do
want
to
work
on
out
of
the
box
extensibility
a
little
bit
more,
but
we
haven't
had
a
chance
to
actually
collect
more
feedback
from
a
community.
Do
come
over
and
tell
us
from
tell
us
in
the
slack
channel.
B
You
know
what
kind
of
what
kind
of
tools
you
would
wanna
extend.
What
kind
of
what
kind
of
integrations
would
you
look
forward
to,
or
maybe
how
would
you
want
to
extend
those
things
and
by
the
way,
I
think
I
realized
your
name
was
prem
now
that
wasn't
the
location
so
hello,
all
right,
we
had
a
need
for
oops.
Something
hey
squat
package
is
amazing.
Thank
you.
Thank
you
for
that.
Vmware
tca
supports
cargo
pack.
B
I
have
no
idea
about
vmware
tca,
but
I'm
sure
we
can
find
out
that
answer
for
you.
We
have
a
need
for
the
combination
of
customizing
solves
great
to
see
you're
considering
it.
Yes,
I
think
you
know.
So
we
got
the
integration
for
already
customized.
We
don't
have
it
yet,
but
we
definitely
like
to
hear
the
feedback
of
how
you
all
you
know
would
like
to
use
it.
B
What
kind
of
features
customize
hat
does
have
a
lot
of
features
and
there's
definitely
some
considerations
in
how
it's
best
to
expose
those
features,
but
otherwise
we're
open
to
ideas
all
right
so
I'll
leave
it
I'll
leave
it
at
that,
come
by
to
carvel
channel
glad
you
all
could
make
it
and
thank
you
for
for
joining.