►
From YouTube: Experimenting with CUE and Carvel to Enable GitOps for Your... - Dmitriy Kalinin & Shatarupa Nandi
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe 2023 in Amsterdam, The Netherlands from April 17-21. Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Experimenting with CUE and Carvel to Enable GitOps for Your Applications - Dmitriy Kalinin & Shatarupa Nandi, VMware
You might have heard about Cue (https://cuelang.org) -- an open source language for defining, generating, and validating all kinds of data. Wait, Kubernetes configuration is data! You also probably heard about Carvel (https://carvel.dev) -- a set of composable tools that embrace GitOps principles and help with building, configuring, and deploying applications to Kubernetes. So... what happens when we try to use these two projects together for GitOps? In this session we'll explore (and run through some live demos): - Why would you want to use Cue to define your Kubernetes configuration - How does Carvel tools help with managing deployed Cue configuration - How we can safely adopt Cue configuration in our existing environments
A
Thank
you
by
the
way.
This
is
a
big
picture
that
took
about
five
minutes
to
download
on
the
Wi-Fi
outside
so
appreciate
it.
Please
all
right
experimenting
with
q
and
Carvel
So
This
Is
Us
I'm
Dmitry
I've
been
working
at
VMware
for
quite
a
while
now
infrastructure
related
stuff,
kubernetes
related
stuff,
a
little
bit
of
Carvel
nowadays.
B
And
I'm
Rupa
I
also
have
been
working
with
Dimitri
for
a
while
at
VMware
we
work
on
Samsung
application
platform
and
on
Project
Carvel,
and
previously
we
were
doing
some
interesting,
Cloud,
Foundry
stuff
and
today
we'll
talk
a
little
bit
about
q
and
Carvel.
This
is
more
of
us.
Sharing
our
learnings
we've
been
playing
around
a
little
bit
with
q,
and
so
we
wanted
to
share.
B
So,
just
to
set
the
context,
we'll
kind
of
talk
about
it
in
in
this
idea
of
how
to
deploy
a
change.
So
you
know
thinking
about
making
a
change,
whether
that's
a
change
in
your
source
code
or
in
your
kubernetes
configuration
you
typically
after
you
make
that
change.
You
want
to
create
a
PR
to
a
git
repo.
You
have
various
sorts
of
verifications
tests
running
then.
After
all,
that
is
clear.
You
fast
your
checks,
the
pr
is
merged
and
then,
once
it's
merged,
there's
something
sitting
on
your
cluster.
B
A
All
right
so
jumping
in
Q
configure
unify
execute
so
I've
been
in
a
configuration
land
for
quite
a
while.
It's
started
out
with
you
know,
playing
around
with
various
ways
of
how
to
augment
configuration
that
you
don't
really
own.
You
know,
there's
been
name
thrown
around
like
Ops
files.
A
lot
of
you
are
familiar,
probably
with
projects
like
customize,
similar
space
right
and
then
there's
obviously
a
lot
of
tools
out
there.
Templating
tools,
like
you,
know,
helm,
Json
it
right.
A
So
there's
all
these
tools
out
there
that
allow
you
to
do
this
different
types
of
kind
of
a
configuration
building.
Right
queue
seems
to
be
the
the
latest
one,
but
it
has
a
very
unique
twist.
So
maybe
a
first
question
to
the
audience.
Raise
your
hand
if
you
actually
heard
about
Q
before
all
right,
quite
a
few
people,
and
then
maybe
people
who
used
it
please
raise
their
hands.
Oh
quite
a
few
people
too
right
and
then
maybe
how
many
people
use
it
in
production,
so
production
will
break
a
few
breaks.
A
A
You
know,
full-blown
programming,
language
right
and
that's
to
me
at
least
quite
exciting,
because
in
a
lot
of
this
other
tools,
right,
you're
able
to
go
so
far,
but
then
at
some
point
it's
kind
of
it's,
maybe
not
enough,
or
maybe
it
doesn't
quite
fit
the
ideas
that
you
kind
of
want
to
express
right,
and
so,
in
our
case,
what
we're
mostly
interested
in
is
using
queue
with
kubernetes.
Right
specifically,
how
do
you
define
various
kubernetes
configuration?
You
know,
how
do
you
you
know
mingle
it?
A
Maybe
how
do
you
allow
your
application
teams
to
express
some
kind
of
application
related
definition
right,
so
that's
kind
of
the
space
that
we're
most
interested
in.
That's
obviously
what
you
know,
this
kind
of
a
talk
is
about
so
here's
a
little
example
just
to
dive
in
deep.
So
we
have
yaml.
Obviously
everybody
knows
yaml
on
the
left
side
and
we
have
q
on
the
right
side.
So
you
may
notice
they're
actually
quite
quite
similar
right,
but
there
seems
to
be
a
little
bit
of
more.
A
Maybe
you
can
argue
noise
on
the
right
side,
but
maybe
to
some
people.
It's
actually
a
nut
noise
right.
It's
those
very
important
differences
that
make
yaml
sometimes
ambiguous
right.
So
for
me,
for
example,
I'm
a
big
fan
of
being
explicit
with
what
type
of
data
it
is
right
now
in
yaml,
that's
a
little
bit
vague
right.
So
you
know,
if
you
look
on
the
side
over
here
right,
you
end
up
with.
Actually
it's
my
pointer
yeah.
You
can
see
my
pointer,
so
you
can
see
over
here
right
that
config
Maps
right.
A
They
store
string
to
string,
and
then
you
have
to
really
remember
to
quote
your
values
right,
and
so
that's
that's,
potentially
a
common
Pitfall
that
somebody
might
run
into
and
actually
you
know,
cause
some
kind
of
a
problem
right
now.
In
this
case,
the
problem
would
show
up
when
you
submit
this
resource
to
kubernetes,
but
seems
like
it's
a
little
bit
too
late
right.
A
Maybe
it
would
be
nicer
to
get
that
error
message
much
much
earlier
now
on
the
Queue
side,
if
we're
taking
a
look
at
it
in
this
example
at
least
right,
you
do
also
have
to
quote
things,
but
you
have
to
quote
every
single
string
right.
So
that
means
that
you
can't
have
strings
that
are
unambiguous
and
not
quoted
right.
They
always
have
to
be
quoted
now.
The
other
thing
here
is
that,
instead
of
indentation,
you
do
have
to
use
the
curly
braces
right.
A
Curly
braces
really
allow
you
to
specify
that
explicit,
like
what
is
this
data
really
related
to
now?
Funny
enough,
though,
you
might
think
that
hey
this
is
the
you
know.
Explicit
nature
is
actually
quite
helpful,
but
a
few
days
back,
I
was
trying
to
figure
out
starting
on
my
Q
configurations,
trying
to
figure
out
what
was
wrong
with
it
and
turns
out.
I
actually
forgot
to
put
the
curly
braces
around,
but
visually
it
looked
like
the
name
under
metadata
actually
did
belong
in
that
section,
but
it
actually
was
right.
A
It
was
name
and
the
metadata
were
in
the
same
section
just
because
the
curly
braces
are
we're
not
there
right.
So
I
don't
know.
If
there
is
some
interesting
question
to
Q
developers,
you
know:
how
can
we
prevent
cases
like
that
and
maybe
it
actually
a
Dancewear
will
be
a
little
bit
more
obvious
down
down
to
this
next
few
slides.
By
the
way
there
is
a
command
called
Q
import.
You
can
import
all
your
stuff
into
to
this
Q
format
right
and
then
you
know,
supposedly
you
can
do
more
usage
of
Q
wizard
directly.
A
Values
are
ordered,
and
that's
actually
going
to
help
us
in
in
the
next
slide
over
here.
So
this
is
actually
a
little
screenshot
from
the
Q
documentation.
By
the
way
queue
documentation
might
seem
a
little
bit
You
Know
Rich
and
a
little
bit
hard
to
navigate,
at
least
for
me
when
I
started
out,
you
know
playing
with
q
a
while
ago,
but
once
you
kind
of
get
the
Core
Concepts
down,
it
really
becomes
much
much
easier
to
just
Orient
within
the
queue
landscape.
A
So
what
is
this
thing
so
going
back
to
our
example
over
here
right
when
you
define
the
type
for
this
values
over
here,
a
string
right
what's
Happening
Here
is
Q.
Has
this
unique
system
where
it's
able
to
describe
the
values
in
the
lattice
now
I'm,
not
a
mathematician
or
related
to
mathematician
in
any
way
so
I
don't
know
if
that's
actually,
some
proper
terminology
related
to
mathematics
probably
is
pretty
sure
it
is.
But
the
way
this
works
out
right
is
that,
and
maybe
let's
go
with
the
most
simplest
example
right.
So
Boolean.
A
Imagine
as
a
big
group
right.
What
is
the
subset
of
that
group
right
subset
of
that
group
is
true,
and
another
subset
of
that
group
is
false
right
and
there's
nothing
else
inside
booleans
right.
So
that
means
that
if
you
define
something
of
value
Boolean,
you
can
only
have
either
Boolean
as
just
it's
still
a
Boolean
right.
So
we
don't
know,
we
can't
really
refine
it
further
or
it
can
be
one
of
the
children
effectively.
Is
it
either
true
or
false
right
now
with
numbers?
A
Of
course
it
gets
a
lot
more
complicated
right,
because
you
know
there's
lots
of
different
types
of
numbers
right.
There's
ins
floats,
you
know
you
can
potentially
Define
some
rules
around
it
right.
Hey
is
some
number
bigger
than
10,
let's
say
or
less
than
10
right
and
so
Q
builds
up
for
each
one
of
the
values.
A
system
like
that
right
and
you
can
actually
get
as
complex
as
you
want
right.
A
You
can
have
a
Boolean
or
a
number,
for
example
right,
so
a
q
is
able
to
figure
out
how
to
kind
of
boil
it
down
to
this
what's
possible
and
what's
concrete
versus
more
or
less
concrete,
I
guess
right,
and
so
one
of
the
goals
for
you
as
a
configuration
author,
all
right
at
the
end
of
your
queue
evaluation
is
to
get
to
a
point
where
all
of
the
values
are
concrete
right.
So
if
I
generate
myself,
you
know
a
config
map.
A
Right
and
half
of
my
values
are
just
type
string
right,
that's
totally
meaningless
to
kubernetes
right.
You
need
to
have
something
within
that
string,
value
right
either.
Maybe
empty
string-
or
maybe
some
non-empty
string
right,
but
something
right
so
just
the
type
is
not
good
enough
right
now
to
queue.
That's
perfectly
fine
right,
but
to
us
as
humans.
Let's
say
working
with
kubernetes
definitions
right,
that's
just
not
good
enough,
and
so
you
want
to
be
able
to
get
to
those
concrete
values.
A
So
that's
where
the
power
of
Q
comes
in
is
that
to
get
to
those
concrete
values,
you're
able
to
fill
them
in
from
multiple
places
right
and
so
in
this
example
over
here.
This
value
string
is
not
concrete
right,
but
three
over
here
is
obviously
concrete
right.
So
for
this
value,
you're
able
to
get
to
the
concrete,
you
know
point
right
and
so
going
a
little
bit
further
going
a
little
bit
further
to
the
next
slide
right.
A
If
you
just
think
of
hey,
you
know,
I
got
booleans
I
got
numbers
great
right,
but
then
you
actually
want
to
be
able
to
combine
them
into
more
complex
types
right,
and
hopefully
this
slide
is
interesting.
I
have
to
look
at
right
because
you
have
a
lot
of
this
basic
Concepts
right
like
strings
and
maybe
some
maps
right
or
actually
pretty
much
strings
and
maps
in
this
case
right
and
so
you're
able
to
build
up
the
definition
of
something
higher
level
right,
so
a
config
map.
A
A
So
if
you,
if
you
don't
specify
something
explicitly
like
you,
don't
specify,
you
know
an
explicit
string
saying:
oh,
this
is
whatever
apps
V2
or
something
like
that
right.
It's
going
to
be
V1
right,
so
this
is
concrete
client
config
map.
That's
concrete,
metadata
right!
Well,
the
name
here
is
actually
a
regex
definition.
A
The
labels
and
annotations
here
are,
you
know,
Maps
those
thing
to
string.
We
don't
really
care
about
those
and
by
the
way,
actually
here.
I
would
argue
that
this
should
be
marked
with
a
little
question
mark
to
mark
this
field
as
optional
right,
so
you
don't
really
have
to
have
it
and
then
finally,
data
string
to
string
again,
we've
already
kind
of
looked
at
that.
So
here
we
make
those
things
concrete
right
or
we
technically
could
leave
it
empty
as
well
if
we
Mark
that
as
optional.
A
So
this
is
my
own
kind
of
a
hand-coded
example.
Probably
very
incomplete,
probably
slightly
incorrect,
but
can
you
imagine
if
all
of
the
configuration
for
the
kubernetes
that
you
write
right
would
have
this
level
of
typing
in
much
more
detail
right
based
on
the
goal,
types
that
the
kubernetes
service
provides
right?
And
so,
if
you
go
and
look
at,
for
example,
kubernetes
slash,
API,
git,
repo
I
think,
where
I
think
I
think
it's
kubernetes,
API
right,
you'll,
see
that
4v1,
apps,
V1,
etc,
etc.
A
All
the
built-in
stuff
right
is
all
in
that
repository
all
of
the
go
definitions
right
so
wouldn't
it
be
nice
to
be
able
to
use
this
kind
of
type
information
when
you're
authoring
your
configuration
so
that
you
don't
end
up
making
the
mistakes
that
potentially
either
get
swallowed
by
a
kubernetes
cluster
or
maybe
just
get
it.
You
know
end
up,
you
know
catching
maybe
Downstream,
where
it's
maybe
too
late
or
just
too
inconvenient.
A
But
obviously
it
was
a
much
more
detail
to
what
you
can
fill
in,
and
you
know
there's
a
concept
of
actually
I,
just
remembered:
there's
a
slide
modules
and
packages.
So
when
you
do
import
kubernetes,
API
definitions,
you
are
able
to
reference
to
them
uniquely
right
and
for
those
who
are
familiar
with
go
programming.
Language
Q,
I
think
is
in
a
lot
of
ways
inspired
by
the
go
team.
A
Actually,
the
creator
of
cube
might
have
being
on
the
go
team
at
some
point
and
so
there's
a
lot
of
kind
of
a
same
type
of
feel
for
packages
and
modules
that's
taken
and
that
you
can
use
in
queue
now.
Actually,
the
reason
why
I
put
in
the
slide
is
that,
because
we
have
this
common
problem
of
being
able
to
define
configuration
per
type
of
environment
right
so
like
development,
environment
stage,
environment
production,
environment,
maybe
you
have
you
know
510
production
environments
right.
A
A
It's
probably
there's
some
duplicate
configuration
somewhere,
that's
sitting,
that's
maybe
setting
it
to
another
concrete
value
and
that
potentially
you
didn't
intend
right
like
we
want
to
be
able
to
capture
that
explicitness
between
hey
I
actually
have
this
field
that
I'm
intending
for
somebody
to
configure
versus
here.
I
have
this
field?
That's
not
really
meant
to
be
configured
or
maybe
configured
in
two
different
places
right.
So
that's
what
Q
actually
by
default,
gives
you
and
what
was
interesting.
A
That
I
kind
of
stumbled
upon
at
some
point
which
which
I
didn't
realize
was
was
the
the
features
that,
when
you,
when
you
evaluate
Q
package
or
module
I,
guess
in
a
particular
way
right
so
in
this
example,
I'm
Q
export
dot,
for
example
right.
It's
actually
going
to
only
evaluate
the
kind
of
the
first
depth
of
your
module
and
that
actually
surprised
me
a
little
bit.
A
But
then
I
actually
realized
that
you
know
what
the
reason
why
they've
done,
that
right
is
that
you
want
to
be
able
to
kind
of
a
nest.
Your
your
further
configuration
right
so
for,
for
example,
for
a
staging
environment
for
a
development
environment
in
the
same
kind
in
this
kind
of
hierarchy.
Right.
So
when
you
executeexport.dev
what's
happening,
is
it's
going
to
evaluate
the
module
plus
this
kind
of
a
nested
thing?
A
And
apparently
you
can
kind
of
go
as
deep
as
you
want,
and
as
long
as
you're,
not
specifying
duplicate,
concrete
values
right
you're,
effectively,
adding
in
more
to
your
kind
of
a
base
configuration?
And
so
really
you
end
up
with
this.
You
know
final
configuration
that
has
a
bunch
of
concrete
values
that
are
specified
once
right.
Now
you
can
refine
the
config.
You
can
refine
each
while
you,
you
know,
through
this
layers,
I
think
so,
maybe
more
concretely
right,
you
can
start
with
saying
hey.
A
A
This
is
not
the
only
way
to
re
to
kind
of
Define
the
configuration
you
can
also
import
modules
from
one
module
to
another,
and
so
you
can
kind
of
imagine
how
you
can
reuse
the
types
and
rebuild
you
know:
rebuild
kind
of
certain
pieces
of
configuration
in
composable
way,
but
that's
kind
of
a
little
bit
of
an
introduction
to
kind
of
modules
and
packages
there
all
right.
Okay,.
B
B
Okay,
how
many
of
us
are
familiar
with
like
the
Unix
philosophy,
great
okay,
okay,
I,
think,
I
I
know
where
we're
at
and
hopefully
you
had
a
chance
to
move
your
hands.
You
have
a
little
bit
more
blood
flowing,
so
carvo
is
kind
of
trying
to
bring
that
Unix
philosophy
to
running
applications
on
kubernetes.
So
we
want
to
be
building
like
a
reliable
single
purpose
composable
to
chain,
and
you
can
use
that,
for
you
know,
building
your
applications,
configuring,
your
applications,
deploying
your
applications.
Really.
B
The
idea
is
taken
from
you
know
how
you
you
might
be
used
to
okay
I.
Do
this
thing,
I
pipe
it
to
the
next
command,
I
pipe
it
to
the
next
command?
That's
what
carbo
tries
to
bring
to
application
deployment
on
kubernetes,
so
the
dual
chain
is
made
up
of
a
few
different
tools
and
we'll
talk
about
all
of
them
today.
So
there
is
vendor.
There's
image
package
cap
controller
cap
K
builds
secret,
gen,
controller
and
ytt.
B
So
let's
talk
about
the
local
development
workflow
using
carpool,
and
so
you
know,
let's
say
I
I've
made
some
changes
and
I
maybe
have
an
application
which
has
configuration
in
different
sources
right,
so
I
may
have
a
hump
chart
in
a
git
repo
I
may
have
some
ytt
configuration
somewhere.
I
may
have
some
queue,
configuration
and
different
people,
but
my
application
uses
all
of
that
so
I
wanted
to
which
allows
me
to
sync
this
configuration
from
different
sources
and
that's
where
I
use
vendor.
B
Then
the
next
thing
I
want
to
do
is
I've
got
all
these
dependencies,
but
I
want
to
customize
them
like
I
want
to
provide
certain
values.
Maybe
something
some
help.
Charts
are
not
exactly
exposing
the
configuration
I
want.
So
I
may
want
to
write
my
own
overlays,
and
so
that's,
where
I
use
ytt
to
do
that.
B
The
next
thing
I
want
to
do
is
I
really
want
to
lock
down
the
images
that
I
want
to
use.
So
maybe
I'm
consuming
an
open
source
home
chart
and
it's
tagged
by
a
particular.
The
image
is
tagged
with
a
version
number
right,
so
it
may
be
like
V
1.2.0,
but
I
don't
want
to
consume
an
image
which,
with
the
tag
I
want
to
consume
it
with
a
digest.
So
I
know
exactly
what
I'm
getting
and
I
know
that
that
digest
will
change
when
that
image
changes.
B
So
that's
where
I'll
use
cables
to
resolve
my
image
reference
and
convert
it
to
being
referenced
by
Digest,
then
I
have
a
bunch
of
this
different
dependencies
right.
So
I
talked
about
my
application
being
made
up
of
you
know
having
a
dependency
on
a
hum
chart.
Maybe
I
have
I
some
Q
dependencies,
so
I
want
to
bundle
up
my
applications,
configuration
and
all
of
the
dependent
images
I
want
to
treat
them
as
one
oci
artifact.
B
It
may
not
be
one
giant
image,
but
I
do
want
a
way
for
me
to
declare
that
these
are
all
the
things
that
I'm
dependent
on
and
I
want
to
treat
it
as
a
single
oci
artifact.
That's
where
I
use
image
package
to
create
that
bundle
and
then
finally,
I
have
everything
I
need.
I.
Have
my
configuration
I've
done.
The
customization
I
need
I've
locked
down
my
images
so
I'm
going
to
deploy
it
using
cap.
B
Now
these
steps,
I
could
I
could
run
these,
as
is
but
with
the
cncf
ecosystem.
One
of
the
great
things
we
have
is
we
have
a
lot
of
variety
of
tools
and
each
of
the
tools
are
good
at
doing
different
things.
So
I
want
something
which
is
composable
and
that
I
can
replace
any
of
these
with
a
tool
of
my
choice,
which
means
that
I
could
use
ytt
for
templating
or
maybe
I
use
Q
here
and
that's
kind
of
what
this
Unix
philosophy
and
the
composability
gives
you
is.
B
You
can
leverage
the
goodness
in
the
ecosystem
and
use
different
tools
of
your
choice
when
you
want
to
so.
Let's
look
at
some
example:
local
development
workflows
again,
you
know
looking
at
Unix,
this
may
look
familiar
to
you.
I
could
be
using
Q
export
and
then
getting
getting
that
output
in
yaml
and
then
using
cook
cuddle
to
apply
it
or
I
could
be.
You
know,
pulling
down
an
image
that
I've
bundled
using
image
package
and
I
could
be,
then,
can
you
know
templating
it
with
you,
deploying
it
with
cap
or
the
final
one?
B
The
last
one
that
I
have
here
is
really
interesting,
because
I
am
using
q,
but
I'm
also
using
ytt
to
apply
a
particular
overlay
on
top
of
it,
so
that
that
kind
of
shows
you
like
how
you
can
mix
and
match
these
different
things
to
really
suit
your
environment.
And
you
know
what
what's
best
for
that
workflow.
B
So,
let's
talk
about
how
we
take
this
to
a
cluster,
we're
all
running
kubernetes.
A
lot
of
us
are
running
it
in
production.
So
what
do
we
do
on
cluster?
So
we
talked
about
before.
Basically,
you
know
your
steps.
Looking
a
little
bit
like
okay,
I'm
fetching
some
images,
then
I'm
templating
that
and
I'm
deploying
it
that's
the
three
steps
you're
going
through.
B
So
it
would
be
great
if
we
could
express
exactly
that
to
run
on
a
cluster
and
that's
what
we
did
so
also
we
want
to
be
able
to
sort
out
these,
you
know
have
various
fetch
strategies
have
various
templating
strategies,
but
that's
exactly
what
we
did
with
cap
controller.
So
with
the
cap
controllers,
app
CR,
you're,
able
to
Define
here's
what
I'm
fetching
here's,
what
I'm
templating
here's,
what
I'm
deploying
and
you're
able
to
swap
out
at
each
of
these
steps,
just
like
we
talked
about
in
the
local
development
workflow.
B
So,
let's
talk
a
little
bit
about
you
know
what
what
this
could
look
like.
So
this
is
what
your
local
development,
your
piping,
your
commands.
You
have
that
quick
feedback
loop,
but
then
on
the
cluster
you
have
cap
controller,
which
is
syncing
or
yeah
syncing
to
your
git
repo
or
your
fetching.
You
know
your
fetch
source
of
choice,
every
10
minutes,
so
it's
continuously
reconciling
every
10
minutes,
it's
configurable,
so
you
could
change
that,
but
every
10
minutes
preventing
any
kind
of
configuration,
Drift
But.
B
Also
it
gives
you
that
same
feeling
of
what
you're
doing
in
development
right.
So
the
idea
here
is
to
really
showcase
how,
if
in
development,
you're
used
to
doing
render
and
then
q
and
then
cables
in
which
package
and
cap
that's
exactly
what's
going
to
happen
on
your
cluster,
so
it
makes
it
really
easy
for
you
to
follow
through
debug.
B
B
But
here
we
are
just
maybe
we're
doing
local
development,
and
we
just
want
to
fetch
from
this
config
map
we're
templating
using
q
and
then
we're
deploying
using
cap.
So
again
the
the
the
idea
being.
You
could
run
exactly
these
commands
in
your
local
development
flow
and
now
you've
taken
that
on
cluster.
A
Yeah,
apparently
we're
pretty
bad
on
time.
I
think
there
was
a
five
minute
reminder
so
yeah
the
core
apis
appcr.
Is
you
already
see
an
example
in
the
slide
right
package,
install
package
and
package
reposit
code
is
really
an
optional
layer
that
allows
you
to
take
that
app
CR
and
maybe
distribute
it
to
somebody
else.
But
when
you
do
distributed
you
don't
really
have
to
know
what
exactly
is
happening
within
the
app
CR
right.
A
A
A
What
we'll
do
here
real
quick
is
we're
going
to
say
cab
deploy,
Dash
a
example,
Dash
F
and
we'll
throw
in
a
cert
manager
here
and
I'll
close
this,
so
we're
about
to
install
an
app
CR,
we'll
click
on
yes
here
and
so
what's
happening
here.
While
this
is
going
to
tell
us
things
are
reconciling
it's
we're
actually
fetching
a
module
of
Q
from
GitHub
right.
A
This
is
the
person
who's
authored
bunch
of
Q
configuration
for
all
of
their
services
that
they
run
on
their
clusters
and
we're
telling
you
hey:
let's,
let's
use
this
module
and
this
particular
package
under
the
emerge
under
that
module,
which
is
cert
manager
here
and
we're
also
saying
hey,
please
get
us
only
the
list
portion
of
the
output
from
q
and
the
list
portion
is
a
little
bit
funny.
Ask
us
questions
about
it
later.
If
you
want
so,
we
actually
did
deploy
search
manager.
A
Here
you
can
actually
see
that
the
cert
manager
namespace
ended
up
here
and
then,
if
we
take
a
look
at
pods
over
here,
so
we
got,
we
got
a
pod
for
cert
manager
right
and
so
all
we've
done
right
is,
we
just
said:
hey
we
got
some
few
configuration
in
this
git
place,
that's
execute
it
with
q
and
then
let's
deploy
it
with
cap,
and
this
is
going
to
happen.
Reconciling
you
know
continuously
on
a
cluster
walk
away,
come
back
still,
there
still
being
deployed
so
I
think
we're
out
of
time.