►
From YouTube: TGI Kubernetes 124: KUDO
Description
Show notes: https://github.com/vmware-tanzu/tgik/blob/master/episodes/124/README.md
- 00:00:00 - Welcome to TGIK!
- 00:03:50 - Week in Review
- 00:23:21 - Start talking about KUDO
- 00:24:50 - Comparison to other projects
- 00:26:13 - Operators defined and KUDO overview
- 00:33:06 - Limitations of KUDO and some future plans
- 00:35:16 - Using KUDO with Zookeeper operator
- 00:35:44 - Install KUDO commandline
- 00:36:07 - kubectl kudo init
- 00:46:24 - Install zookeeper
- 00:50:37 - Run validation task (and hit a bug!)
- 01:00:17 - Noodling on how backup/recovery would integrate
- 01:02:25 - Operator index and publishing operators
- 01:07:30 - Looking at zookeeper operator
- 01:13:15 - Compared to Helm, templating options, gitops?
- 01:17:28 - Validation as Job
- 01:19:03 - Exploring other Operators
- 01:22:32 - Different Task types
- 01:26:33 - Testing with Kuttl
- 01:31:05 - Final thoughts and goodbye
Come hang out with Joe as he does a bit of hands on hacking of Kubernetes and related topics. Some of this will be Joe talking about the things he knows. Some of this will be Joe exploring something new with the audience. Come join the fun, ask questions, comment, and participate in the live chat!
This week we are covering KUDO (https://kudo.dev/). KUDO is the Kubernetes Universal Declarative Operator. It is a structured toolkit for creating operators. Lots of interesting ideas and examples to dig into.
A
Hello,
everybody
and
welcome
to
tgi
kubernetes.
My
name
is
joe
bida
and
I
am
super
super
happy
to
be
back
doing
tgik
for
those
who
might
be
joining
us
on
the
archive
who
have
never
tuned
in
before
tgi
kubernetes
is
a
weekliest
live
weekly
ish
live
stream
that
we
do
here.
It
started
when
we
were
heptio
and
now
we're
continuing
it
and
we
have
a
rotating
cast
of
characters
hosting
it.
A
I
started
it,
but
duffy's
been
doing
a
lot
more
lately
and
what
we
try
and
do
is
go
over
sort
of
what's
happening
in
the
kubernetes
world.
What's
interesting,
what's
new
and
then
we
do
a
deep
dive
on
a
particular
project
or
subject,
try
and
keep
it
rooted
in
open
source,
and
I
try
and
explore
things
either
something
that
I'm
a
super
expert
on,
and
I
want
to
sort
of
approach
it
as
a
sort
of
a
lesson.
A
So
that's
some
really
exciting
stuff
to
see,
but
I
also
love
to
be
able
to
say
hello
to
everybody
in
the
comments.
So
let
me
go
through
and
actually
scroll
back
here,
so
we
have
jared
I'm
an
ed
g-e-r-r-r-e
if
I'm
pronouncing
your
name
wrong.
Try
and
correct
me
in
the
comments
who's
the
kudo
creator
here
and
so
really
excited
to
have
him
online.
So
that
way,
if
I
screw
up
or
if
I
get
something
wrong,
he
can
correct
me.
A
What
I
see
right
now,
I
see
a
couple
of
things
that
are
giving
me
pause,
and
so
hopefully
we
can
have
a
little
bit
of
a
good
discussion.
Lamati
good
to
see
you,
let's
see,
okay,
so
we
can
follow
cue
builder,
kudo
builder,
I'm
sorry
on
twitter
and
then
there
it's
on
the
kubernetes
stack
and
it
sounds
like
they're
really
working
to
make
this
be
a
collaborative
open
governance
thing
as
part
of
the
the
cncf,
and
so
that's
really
good
to
see
also.
A
Should
and
will
work
with
operator,
sdk
operators
as
to
now,
okay,
we'll
get
into
that?
Okay,
let's
we're
jumping
ahead
here,
so
martin
from
the
netherlands
walid
good
to
see
you
moz
good,
to
see
you
well,
okay,
I'm
sorry!
I'm
butchering
your
name!
Awesome
awesome!
Awesome
bogdan
from
bucharest,
let's
see
tiffany's
joining
us
how's
it
going
tiffany
and
peter
and
philippe
from
paris.
A
Awesome
awesome
yogi
from
singapore
very
great!
Well!
Thank
you,
everybody
for
joining
us
and
let's
just
jump
right
in
what
do
you
say
here?
So
let
me
go
through
and
I'm
gonna
switch
to
my
screen
and
what
we
have
here
is.
We
have
a
sort
of
crowdsourcing
notes
here,
so
this
is
using
a
site
called
hackmd.
A
If
you
go
to
and
duffy
can
or
me
or
duffy
can
drop
a
link
here,
it's
I
think,
hps
tgik.io
notes.
If
you
go
there,
that'll
take
you
to
this
doc
and
if
you
log
in
you
can
you
know,
put
in
time
stamps
or
other
notes,
as
we're
talking
to
be
able
to
sort
of
you
know,
share
links
and
stuff,
because
a
lot
of
that
stuff
gets
lost
in
the
in
the
comments,
as
they
actually
thread
through
jordy
good
to
see
you
so
yeah.
A
So
let's
go
through
some
of
the
interesting
stuff,
that's
happening
in
the
kubernetes
community.
We
got
a
lot
of
stuff
duffy
pulled
this
together,
so
thank
you
very
much
duffy
helping
out
here.
So
the
first
thing
is
interesting
is
that
there
are
three
new
cves
that
dropped
and-
and
you
can
see
that
these
things
all
have
sequential
numbers
which
gives
you
a
clue
that
they
kind
of
all
hit.
At
the
same
time,
none
of
these
things
is
sort
of
stop
the
world
critical,
but
they're
all
important.
A
A
A
Okay,
well,
we'll
have
to
dig
into
that
one,
but
that
one
I'm
not
as
familiar
with
and
then
there's
a
there's,
a
privilege,
escalation
type
of
thing.
So
if
somebody
owns
a
node,
that
means
they
can
own
the
cluster,
definitely
serious,
but
not
sort
of
like
stop
the
world
serious,
and
so
you
know
definitely
stuff
that
we
want
to
fix
that.
We
want
to
take
advantage
of-
and
I
think,
there's
two
interesting
things
when
we
look
at
this
so
number
one
is
that
these
all
went
through
the
the
kubernetes
security
process.
A
I
believe
so.
This
is
kate's
dot,
io
security,
and
so
this
is
sort
of
responsible
disclosure
of
these
things.
So
it's
really
great
to
see
this
process
working
and
so
that
as
people
find
this
stuff,
they
report
it
in
a
way
such
that
we
can
get
everybody
on
the
same
page
and
get
it
fixed
as
much
as
possible
and
reduce
the
amount
of
harm
the
amount
of
risk
that
folks
in
the
community
go
through.
We
also
have
a
bug
bounding
program
for
kubernetes.
A
Now
also
I
don't
know
if
these
things
took
advantage
of
the
bug
bounty
program.
That's
something
that
we're
not
super
clear
on
the
next
thing
to
actually
take
in
mind
here
is
that
you
know
this
is,
I
think,
for
me,
a
sign
of
a
maturing
product.
These
are
the
types
of
issues
that
you
know.
Unless
people
are
looking
for
them
and
catalog
cataloging
them,
you
know
they
just
gonna
go
like
and
then
fix
it,
but
the
fact
that,
like
these
things
are
being
taken
seriously,
people
are
reporting
these.
A
This
is
you
know
the
whole
sort
of
like
lots
of
eyes
make
you
know
all
bugs
shallow,
or
what's
that
saying
right
like
we're,
starting
to
see
some
of
those
impacts,
as
people
really
take
kubernetes
and
kubernetes
security
seriously.
So
for
me,
I
think,
seeing
these
types
of
issues
be
identified
and
fixed
and
and
identified
and
disclosed
in
a
responsible
way,
is
really
really
exciting.
It's
really
about
the
maturity
of
the
project,
and
so,
as
part
of
that
we
have
a
set
of
new
dot
releases.
A
My
guess
here
is
that
these
things
are
to
address
a
lot
of
the
cves.
This
is
part
of
sort
of
making
this
stuff
be
as
coordinated
as
possible.
So
there
you
go,
that's
a
quick
summary
of
what's
happening
in
core
kubernetes.
Now,
there's
a
lot
of
other
stuff,
that's
actually
happening.
I'm
gonna
go
through
these
things
really
quickly,
because
we
got
a
lot
going
on.
A
We
have
a
contour
which
is
one
of
the
projects
we
started
as
heptio
has
joined
the
cncf
at
the
incubating
level.
This
is
really
excited.
We've
done
tgik
episodes
on
contour.
It
is
an
ingress
controller,
backed
by
envoy,
so
two
great
tastes
that
tastes
great
together.
The
thing
that
I
think
is
really
really
interesting
here,
though,
is
that
contour
is
that
team
is
working
to
be
well
aligned
with
the
evolution
of
ingress
and
services.
A
That's
happening
upstream,
and
so
hopefully
it
follows
fast
and
it
becomes
sort
of
one
of
the
first
and
sort
of
reference
implementations
for
the
new
apis
and
the
new
ways
of
of
thinking
about
services.
That's
happening
upstream.
That's
a
pretty
invasive
interesting
set
of
changes.
Tim
hawkin
is
driving
a
bunch
of
that
stuff
with
a
cast
of
thousands,
but
it's
really
good
to
see
that
moving
forward
and
having
something
like
contour
playing
a
part
of
it.
A
A
Instead
of
having
to
write,
go
so
lots
of
really
good
stuff
going
on
there,
so
the
maddie's
asking
do.
I
have
thoughts
on
ingress,
v2,
the
nurse
new
services
stuff?
I
don't
know
enough
honestly.
I
haven't
dug
in
enough
to
really
wrap
my
head
around
it.
I
do
think
that
when
I
think
about
sort
of
the
core
kubernetes
apis-
I
you
know
the
ones
that
I'm
least
happy
with
is
is
services,
because
I
think
we
tried
to
make
the
service
object.
A
It
also
helps
to
allocate
you
know,
essentially
cluster
service
ips
that
are
handled
by
the
cube
proxy,
and
then
it
also
does
things
like
node
port
and
then
it
layers
on
top
of
that
being
able
to
go
through
and
allocate
resources
in
your
cloud
for
doing
external
load
balancing.
So
I
look
at
sort
of
the
type
field
of
of
the
service
object
that
we
have
and-
and
I
think
that
that's
a
bug-
the
fact
that
we're
trying
to
overload
so
much
behavior
into
service.
A
I
think,
really
shows
that
it's
not
working
well,
combined
with
the
fact
that
that
ingress
is
still
intimately
tied
with
the
rest
of
this
stuff.
But
it
is
a
separate
object
and
I
think
we've
learned
a
lot
of
lessons
with
respect
to
ingress.
I
mean
ingress
started
before
we
had
crds,
and
so
it's
a
built-in
schema,
but
it
hasn't
really
evolved.
A
Let's
see
so
so
jared
says,
we
also
started
a
convo
of
how
to
move
forward
on
this
in
the
sig
architecture.
Deep
dive
during
the
contrib
summit
in
2018
and
a
lot
of
the
motivation
of
v2
is
in
what
we
went
through
back
then
yeah,
yeah,
okay,
so
cool.
If
you
want
to
jared,
if
you
want
to,
if
you
can
find
that
video
and
drop
it
in
the
notes,
that'd
be
super
appreciated,
because
I
think
you
know
folks
can
then
dig
into
that
a
little
bit
deeper,
okay,
cool!
A
So,
let's
keep
going
through
here,
cncf
ambassador
spotlight
series
with
with
alex,
so
this
is
really
cool.
Alex
is
a
very
passionate
contributor
to
the
cloud
native
space.
He
started
open
fast
and
has
done
a
whole
bunch
of
other
really
interesting
stuff.
So
that's
super
cool.
There's,
a
new
certificate
certification
coming
the
security
specialist
certifications.
That's
really
interesting!
I
hadn't
heard
about
this.
So
now
there's
three
there's
the
administrator,
the
developer
and
the
security
specialists.
A
You
know
three
in
the
series
collect
them
all,
so
this
looks
really
really
interesting,
so
super
cool
there.
This
is
crazy.
I
didn't
know
that
this
is
happening
so
andrew
speicher
who's,
a
long-term
engineer
at
netflix,
is
talking
about
how
netflix
has
moved
their
environment
over
to
mesa
from
mesos
to
kubernetes
and
so
really
interesting
to
see
them
be
able
to
complete
that
transition.
Sorry
to
all
the
mesosphere
folks
that
are
dialed
in
here,
but
I
think
you
know
it's
really
interesting
to
see
them
do
this.
A
The
thing
that
I
think
is
fascinating
here
is,
and
my
understanding
here
is
that,
let's
see,
oh,
you
shared
a
link
with
me.
I
I
believe
they
were
able
to
do
this
in
a
way
where,
most,
if
not
all,
of
their
application
developers
were
essentially
had
no
idea
what
was
happening,
and
I
think
this
really
sort
of
you
know
talks
to
you
know.
A
The
whole
sort
of
kubernetes
was
built
to
be
built
upon
is
that
this
type
of
thing
where
you
can
actually
create
your
own
sort
of
flavor
and
curated
experience
on
top
of
kubernetes?
I
think
that's
really
a
great
example
that
kubernetes
is
flexible
enough
to
enable
a
transition
like
that.
So
that's
a
really
really
interesting
thing
to
see
them
complete
that
transition.
I
have
somewhere
here
at
titus
sticker
or
actually,
I
think
it's
my
office.
A
A
Yeah,
so
they
they
did
that
without
in
about
a
year
and
most
of
the
application
teams
didn't
even
know
that
the
change
was
happening
so
super
cool
to
see
that
happening
all
right.
Let's
keep
going
fluent
bit
version,
so
I
want
to
do
a
tgik
on
fluent
bit
at
some
point.
I
think
this
is
really
interesting
because,
there's
you
know
fluentd
started
as
this
sort
of
super
flexible.
A
But,
as
you
start
to
do
that,
something
like
fluentd
starts
to
feel
a
little
bit
heavyweight
when
you're
doing
it
on
a
per
pod
basis,
and
so
fluent
bit
was
really.
It
was
started
a
while
ago
and
I
haven't
had
a
chance
to
really
dig
into
it
to
to
be
a
much
sort
of
you
know:
streamlined,
lighter
weight
version
to
essentially
you
know,
upload
and
collect
logs,
and
so
seeing
that
work
be
a.
I
think,
that'd
be
a
really
fun
project,
a
really
fun
tgik.
A
At
some
point,
let's
see
bogdan
is
saying
using
fluent
bit
in
production
thinking
about
doing
a
write-up
about
it.
Yeah
that'd
be
great
I'd
love
to
see
that
I
think
it
would
make
a
really
interesting
tgik
episode,
also
because
logging
is
definitely
something
that
is
a
top
of
mind
for
a
lot
of
folks
for
sure
all
right,
so
kubecon,
eu
virtual
and
apparently
you
can
now
get
a
complimentary
pass.
A
So
there's
a
program
around
that,
so
that's
really
exciting.
Also
so
go
ahead
and
sign
up
and
and
join
in.
I
think
we're
all
making
this
stuff
up
as
we
go
along
for
sure,
but
it's
really
good
to
see
to
see
the
cncf
making
this
so
widely
available
to
everybody
and
look
at
the
diamond
sponsors
there's
rancher
and
suse.
So
you
know
they're
hitting
it
up
twice
all
right.
A
I
think
that's
a
really
interesting
path,
and
so
seeing
that,
through
the
lens
of
of
folks,
like
you
know,
nvidia
brought
melanox
they're
running
smartnix
now,
seeing
that
you
know
as
playing
a
part
and
being
able
to
extend
cni
through.
That
is
a
really
exciting
place
where
that's
going
and
the
entry
of
folks
in
general
are
adding
a
lot
of
really
cool
features
around
debugability
visibility.
A
A
Okay,
more
I'm
gonna,
keep
moving
sorry,
I'm
moving
slow
here,
tim
hawkin
did
a
bunch
of
tweets
talking
about
how
networking
works
sort
of
from
the
ground
up.
He
he
puts
together.
These
sort
of
mini
slide
shows
and
then
uploads
them
to
speaker
deck,
and
he
has
a
really
great
way
to
sort
of
take
these
complex
things.
A
This
thing
called
the
open
usage
commons
and
istio
is
one
of
the
three
sort
of
starting
projects
in
that,
and
this
is
this
weird
thing
that
google's
trying
to
do
where
they
move
the
trademarks
into
a
semi-independent
body.
I
think
there's
questions
in
terms
of
how
independent
it
is
considering
that
there's
no
other
industry
partners
that
are
joining
them
there
yeah
well
the
the
sort
of
governance
of
the
project.
Stills
I
mean
it
stays
pretty
tied
to
google,
the
you
know,
there's
a
lot
of
drama
here.
A
This
is
sort
of
open
source
foundation
drama.
I
think
you
know
it's
really
important
to
to
look
at
through
the
lens
of
the
ecosystem
and
and
where
the
you
know
how
this
is
actually
going
to
benefit
sort
of.
You
know
general
users
and
developers
here,
and
I
you
know,
I'm
still
taking
sort
of
a
wait
and
see
approach,
I'm
not
quite
sure
how
it's
all
going
to
turn
out.
I
don't
think
anybody's
really
happy
with
this
move.
A
A
We
wanted
to
focus
on
making
sure
we
got
the
apis
and
the
control
flow
right
and
really
done
didn't.
Take
really
didn't.
You
know,
drive
scalability,
because
we
knew
that
hey.
We
could
always
fix
that
later.
That
was
like
sort
of
under
the
covers
type
of
stuff
that
we
could
do
but,
like
you
know,
back
in
the
sort
of
like
hey,
mesos
or
docker
swarm
or
kubernetes
or
this
or
that
or
the
other
one,
we
really
talk.
A
And
so
you
know
and
voytech's
been
you
know
critical
to
all
of
that
stuff.
So
if
we
look
at
sig
scalability
kubern,
if
we
look
for
that,
what
you
can
see
here
is
configs
and
limits.
There's
this
dock
here
of
thresholds,
where
they
have
this
idea
of
the
scalability
limits
and
here's
like
okay,
you
know
how
many
pods
per
name
space
per
cluster-
and
you
know
starting
to
fill
these
things
out
and
then
start
to
qualify
and
quantify
these
things
over
time.
A
So
you
know,
wojtek
is,
you
know,
is
the
driving
force
behind
a
lot
of
this
stuff,
all
right
so
cool?
So
that's
really
cool
to
see
that
happening
all
right.
So
that's
that
23
minutes
in
I'm
sorry,
I
try
and
go
fast,
but
I'm
bad
at
it.
Let's
go
ahead
and
start
talking
about
kudo.
So,
let's
start
with
I'm
gonna
start
playing
around
with
and
I
have
a
development
environment.
I
have.
I
have
a
kind
cluster
kinda
get
clusters
with
a
single
node,
so
you
know.
A
Can
I
do
no
there's?
No
okay!
Let
me
go
ahead
and
start
an
octant
instance
here
running
so
that
we
can
actually
see
this
stuff
and
see
what's
happening.
This
is
a
little
small.
So
let
me
make
this
be
a
little
bit
bigger
and
so,
as
we
go
through
and
start
doing,
a
bunch
of
stuff
with
kudo,
we
can
go
through
and
actually
see.
A
What
are
the
resources
that
it's
actually
putting
here
and
one
of
the
things
I'm
going
to
say
here
is,
I
don't
think
it
exists,
but
it
might
be
fun
to
think
about
what
would
a
octant
extension
for
kudo
look
like
so
that
you
can
start
getting
kudo
specific
visibility
on
this
stuff.
I
think
the
the
extensibility
model
of
octant,
mixing
and
matching
that
with
all
these
different
projects
is
something
that's
a
lot
of
fun
to
think
about.
A
Octan
already
knows
how
to
actually
look
at
custom
resources,
but
there's
a
ability
to
actually
have
plugins
around
sort
of
like
more
domain,
specific
visualizations
of
different
crds,
so,
okay,
so
I
got
that
set
up
and
my
plan
today
and
I've.
I've
read
some
of
the
documentation
for
kudo
and
we'll.
Let
me
close
some
stuff
here
and
trying
to
sort
of
put
it
in,
and
I
think
one
of
the
interesting
I
always
love
when
projects
do.
This
is
there's
a
comparison
here
of
like
okay.
A
So
how
does
kudo
compare
to
some
of
the
other
tools
that
you
may
be
that
you
may
be
familiar
with,
and
for
me
this
is
always
a
really
sort
of
a
great
sign
that
that
the
that
the
community
is
looking
to
make
sure
that
they're
informing
their
users
of
like
where
they
fit
in
the
ecosystem,
the
trade-offs
that
are
being
made
and
a
lot
of
times
when
folks
do
this?
It's
not
like
hey
we're
awesome
and
these
other
things
suck
it's
more
like
hey.
A
This
is
a
confusing
space,
here's
the
decisions
that
we
made
why
we
made
them
and
why
we
might
be
a
better
choice
versus
these
other
things.
So
I
love
to
actually
see
that
so
some
of
the
things
is
that,
like
we
have
sort
of
infrastructure
as
code
static
format,
so,
like
you
know,
hey,
you
can
always
do
things
like
raw
yaml
or
customize.
How
does
how
does
kudo
compare
to
that
metacontroller?
A
I'm
a
big
fan
of
metacontroller
as
an
idea,
I
think
it's
you
know
as
a
project,
it's
stalled,
and
so
looking
at
meta
controller
versus
kudo,
I
think
there's
a
lot
in
common
there.
In
some
ways,
but
a
different
approach
and
then
versus,
like
writing,
your
own
custom
controllers,
which
is
you
know
you
can
do
a
lot,
it's
also
really
really
hard,
and
so
what
kudo
is?
Is
it's
a
streamlined
way?
A
So,
like
a
lot
of
times
when
we
think
about
operators-
and
when
I
describe
operators
at
least
my
definition
of
operators
is-
and
this
is
from
the
official
documentation-
I
guess
says
that
operators
are
software,
extensions
to
kubernetes,
that
make
use
of
custom
resources
to
manage
applications
and
their
components,
and
I
think
that's
a
good
definition.
Actually.
A
What
I
would
say
here
is
that
a
controller
is
something
that
runs
a
control
loop
and
an
operator
is
a
specialized
version
of
a
controller
that
has
domain
knowledge
around
a
specific
type
of
workload,
and
so
the
idea
is
that
you
write
an
operator
to
manage
something
like
mysql
with
the
end
goal
of
having
an
rds
like
experience
built
on
top
of
kubernetes,
where
it's,
where
you
can
say,
hey,
create
me
a
database.
Here's
the
replication
settings
make
the
magic
happen.
I
don't
want
to
actually
sweat
the
details.
A
Is
that
you
know
it's
not
just
the
day.
One
experience
is
that
day,
two
experience
of
what
happens
over
time.
How
do
you
deal
with
failure
modes?
How
do
you
deal
with
upgrades?
How
do
you
deal
with
with
backup
and
recovery
and
all
that
types
of
things
and
really
what
that
means?
Is
that
we're
taking
all
that
knowledge?
A
Okay.
So,
let's
see
jared
says
a
lot
of
kudos
believe
center
in
kubernetes
as
a
programming
model,
with
those
crds
and
additional
controllers,
cool
and,
and
then
shout
out
to
elena
one
of
the
maintainers
of
kudo
and
former
ci
signal
team
lead
for
kubernetes
all
right.
Thank
you,
elena.
I
don't
know
if
you're
joining
us,
but
thank
you
for
all
your
hard
work
here
so
yeah.
So
it's
really
about
that
day.
A
Two
and
that's
where
operators
are
different
from
something
like
a
helm
chart
and
making
it
such
that
folks,
who
are
not
programmers,
or
at
least
don't
self-identify
as
programmers
or
are
not
super
deep
in
the
kubernetes
world.
To
be
able
to
do
this
stuff
is
really
really
interesting.
So
I
think
that
intersection
is
is
really
interesting.
Oh
jared
said
that
elena
is
is
with
him
now
as
a
cncf
project.
A
A
And
when
you
look
at
this,
this
looks
a
lot
like
something
like
a
helm
chart
where
you
have
parameters
coming
into
the
helm
chart.
But
the
critical
thing
here
is
that
you
actually
have
a
trigger.
So
the
idea
is
that
when
a
user
changes
a
parameter
because
that's
a
day
two
operation,
what
happens
next
right?
And
so
here
it's
like.
A
Oh,
when
you
change
this
parameter
run
this
run
book
and
it'll
actually
do
the
reconciliation
to
actually
deal
with
the
parameter,
and
so,
let's
see
so
la
maddie's,
saying
tgik
still
going
strong
yeah.
We
don't
have
the
gong
anymore,
though
jared
says
a
lot
of
the
meat
of
the
plan
is,
let's
see
I'm
I'm
reading
the
wrong
thing
is
what
will
change
we're?
Looking
at
a
more
terraform-like
graph
approach,
the
equal
sequencing
events
become
much
more
declarative,
so
a
helm
chart
could
just
be
something.
That's
part
of
that.
A
So
work
with
helm,
charts
and
operators
versus
actually
being
a
pure
alternative.
That's
a
great
attitude.
I
think
it's
really
a
matter
of
not
like
here's
a
world,
but
here's
how
we
can
actually
build
something
that
can
work
with
a
lot
of
the
other
things
that
are
happening
in
the
larger
ecosystem,
all
right
so
and
then
there's
default
plans,
so
deploy
is
the
only
one
that's
required
acquired,
but
generally
there's
like
upgrading
cleanup
and
then
under
the
hood.
A
There's
the
core
things
is
that
you
have
operators
which
is
essentially
you
know
the
sort
of
like
hey.
I
want
to
launch
a
zookeeper.
You
have
an
operator
version
which
is
a
concrete.
You
know
version
of
that,
and
then
you
have
an
instance
which
essentially
binds
the
the
operator
version.
Plus
the
parameters
brings
that
all
together
and
runs
that
deploy
script.
So
that's
is
how
I
believe
things
work.
A
couple
of
limitations
here,
the
only
thing
that
kudo
knows
how
to
reconcile
is
instance,
operator
version
and
operator.
A
A
Essentially
everything
uses
these
three
different
crd
types.
Let's
see
so
I'm
reading
the
comments
here,
you
all
are
having
a
good
discussion.
Without
me,
dynamically
creating
managed
crds
is
on
the
roadmap
for
us,
but
we
couldn't
do
that
until
crdv1
hit
there's
a
long
tail
implementation
actually
get
there
yeah.
That
sounds
sounds
about
right,
and
so
it
all
uses
these
sort
of
super
generic
crds
and
then
a
lot
of
things
that
change
in
crds
to
actually
start
getting
there
yeah.
A
So
the
downside
of
this-
and
I
you
know
a
lot
of
constraints.
The
downside
of
this
versus
having
sort
of
a
crd
per
operator
is
that
it
doesn't
work
as
well
with
something
like
r
back,
because
with
our
back
rules
you
can
say
hey.
I
want
to
like
let
somebody
create
a
my
sequel,
but
not
let
them
create
zookeepers
and
that's
something
that
you
can't
do
out
the
gate
with
something
like
kudo,
because
you
only
have
like
everything
is
using
an
instance
type.
A
So
maybe
you
can
prevent
people
from
creating
new
operators,
a
new
operator
versions,
but
if
something's
in
kudo,
then
anybody
can
actually
create
it
in
there
in
their
in
their
namespace.
So
that's
something
to
think
about
there.
Yeah
our
back
is
a
pain
until
the
dynamic
crds.
Then
it's
a
real
story.
A
A
A
A
A
A
A
A
And
insert
manager
crds,
oh,
I
have
to
have
cert
manager
installed.
Oh
man,
okay,
I
didn't
know
that
okay,
sir
manager-
I
haven't
done
that
recently.
Do
I
need
to
have
like
the
acme
stuff
set
up
and
all
that
or
do
I
just
need
to
have
some
cert
manager
installed,
so
james
left
jet
stack
and
he's
gonna
still
be
working
on
certain
manager.
He
hasn't
announced
where
he's
going
yet
that's
brand
new
you're
hitting
a
rough
edge.
While
we
automate
this,
you
just
need
the
base
controller
installed.
Okay,
so
that's
easy
enough!
A
A
A
A
Okay,
so
let's
see
what
we
got
here,
so
we
have
a
crd
for
the
operator.
Okay,
that's
a
bunch
here
and
you
all
don't
have
schemas
in
there.
So
you
don't
have
that.
Yet
we
have
a
crd
for
the
operator
version.
Oh
this
one
does
have
schemas.
Okay,
maybe
there's
just
not
much
to
the
operator
okay
and
then
a
crd
for
an
instance
and
so
okay.
So
there's
a
bunch
of
properties
there.
So
we're
not
going
to
do
anything.
Okay
and
then
let's
say
we
have
a
namespace
called
kudo
system.
A
A
A
A
Okay
and
their
flags
install
is
not
rude
as
well:
okay,
cool
exactly
on
the
web
hook
and
then
and
then
somebody's
asking.
What's
the
limitations
of
using
as
non-root,
I
think
it
probably
just
works
within
one
namespace,
but
there's
still,
the
awkwardness
of
like
the
crds
need
to
be
installed
globally.
So
you
need
route
to
install
the
crds,
but
maybe
it
just
operates
within
a
singular
namespace
all
right
and
then
with
cert
manager,
there's
a
self-signed
issuer
and
so
using
sort
manager
to
essentially
do
the
ca
stuff.
A
A
A
A
End
of
the
m
does
dot
dot
mean
end
of
a
yaml
file.
Is
that,
like
a
yaml
thing,
did
I
not
know
that
that's
kind
of
cool
all
right,
so
custom
resources
there's?
No.
This
is
not.
This
is
actual
custom
resources,
not
custom
resource
definitions,
that's
custom
resources
in
the
namespace,
but
we
can
go
through
and
we
can
look
at
the
kudo
system.
Namespace
and
here
we
have
the
certificates,
request,
manager
issuers.
So
we
have
an
issuer
here.
A
A
All
right,
so
this
is
a
web
hook,
conversion,
so,
okay,
so
cool,
so
okay,
so
you're,
essentially
using
cert
manager
for
doing
your
own
search,
I'm
assuming
that's
for
managing
the
certificates
for
talking
to
the
to
the
api
server.
This
is
something
that
spiffy
inspire
would
help
with.
If
we
actually
got
that
well
well,
working
out
through
through
the
ecosystem,
so
add
that
to
the
list
of
things
we
gotta
do
all
right
cool.
So
now
all
right,
so
we
have
kudo
installed
at
this
point.
Where
are
we
at
okay?
A
A
A
Is
there
I
bet
you
there's
like
a
way
to
say,
install
but
don't
actually
launch
an
instance
right,
create
namespace
instance,
so
there's
an
instance
name
skip
instance
yeah
all
right,
but
this
is
the
idea
of
like
make
it
all
magic.
Okay.
So
let's
see
what
we
got
going
on
here,
so
this
will
be
in
the
default
name
space.
Probably
so
now
we
have.
A
Okay,
so
this
is
something
so
it's
interesting
that
operators
actually
gets
installed
into
this
namespace,
the
zookeeper
operator.
Does
that
mean
that
it's
not
available
in
a
different
name
space
or
it
gets
installed?
So
this
is
interesting,
because
now
these
operators
feel
like
they're
like
kudo.
It's
is
in
itself
is
installed
across
the
system,
but
the
operators
all
exist
within
the
existing
system.
I
would
have
kind
of
expected
operator
and
operator
versions
would
show
up
in
kudo
system,
while
the
instance
would
actually
show
up
in
the
namespace.
A
So
that's
something
that's
a
little
bit,
but
I
guess
like
this
is
like
hey.
You
give
this
namespace
access
to
to
be
able
to
use
this
thing,
so
we
can
look
at
the
yaml
here
and
again
so
status
is
that
it's
deployed
and
it's
completed
and
like
magic
stuff
happened.
So
as
far
as
kudos
concerned,
this
thing
is
actually
good,
but
I
should
be
able
to
cube
control,
kudo
and
then.
A
A
A
A
Now
I
am
not
a
zookeeper
expert,
so
I
assume,
though,
I
assume
that
if
I,
if
I
found
the
way
to
connect
to
to
zookeeper
from
the
client,
I
could
just
go
ahead
and
start
using
this,
but
these
things
are
running
and
we
have
yeah
data
dir
there
so
like
wow,
so
this
thing's
all
up
and
running.
That's
super
cool,
okay,
so
now
so
yeah.
So
now
we
have
the
stateful
set.
We
can
get
the
pods
and
all
right,
so
there's
a
validation
task.
A
A
A
A
A
All
right
failed
update
instance,
overriding
currently
schedule
or
running
plan
validate
with
validation
is
not
supported.
Oh
interesting,
so
like
the
thing
got,
triggered
for
a
non-existent
plan
and
now
it's
like
running,
but
it
doesn't
exist,
and
so
we
found
our
first
bug.
Okay,
how
can
I
go
through
and
fix
this?
Is
there
like
a
you
know?
Is
there
sort
of
a
crd
that
actually
keeps
track
of?
What
is
the
running
like
where's?
The
state
here
for
this
stuff
is
this:
is
this
in
ram
and
the
controller?
A
Oh,
it's
it's
actually
written
into
the
instance
okay.
So
if
we
go
through
and
we
look
at
the
instance,
so
we
can
do
custom
resource
instances,
zookeeper
instance.
Here
if
I
go
and
if
I
look
at
the
yaml
here,
oh,
I
think
the
newer
version
of
octane
actually
lets
you
do
this
stuff
validation
never
run
deploy,
plan
status,
okay,
it
says
we're
doing
validate
now,
but
it's
like.
I
don't
know
what
that
thing
is,
and
so
it
should
probably
like
this.
Should
things
should
error
out
and
actually
clear
the
plan
execution
at
that
point?
A
All
right
and
now
we
can
go
in,
and
I
assume,
if
I
just
sort
of
like
let's
delete
this
and
does
would
that
work
from
argentina
nice
to
meet
you
did.
I
just
delete
those
things:
let's,
let's
give
that
a
try,
yeah
that
should
be
okay,
cool.
So
now
now
we're
going
to
try
and
trigger
validation.
Oh
did
it
not
apply.
A
Wait
see
if
you're
not
be
patching
mission
web
hook
denied
the
request
failed
to
update
instance.
Canceling
a
currently
scheduled
running
plan
validate
does
not
support
it.
Oh
delete
and
remake
the
incidents.
I
guess
yeah,
so,
okay,
both
the
admission
hook
and
everything
so
okay.
So
this
is
a
good
bug.
This
is
a
good
bug.
A
I
think
there's
a
way
that
we
can
go
through
and
and
like
with
root
bypass
the
whole
thing.
But
what
we're
going
to
do
is
we're
going
to
do
cube
control,
delete
instances
zookeeper
instance
we're
going
to
go
ahead
and
delete
that
when
we
do
that,
what
we're
going
to
see
is
that
I
didn't
use
the
kudo
command
line.
But
what
should
happen
is
that
that
should
actually
go
through
and
actually
deletes
the
stateful
set
also
and
either
the
controller
is
doing
that
or
what's
happening
here.
A
A
A
A
All
right
we'll
do
that
again,
we
created
the
instance.
It's
like
hey
it's
already.
There
don't
worry
about
it
now.
This
thing
is
the
stateful
set
is
actually
booting
up.
This
is
one
of
the
nice
things
right
now
about
octan
is
that
it
actually
has
a
live
connection,
and
so
the
thing
updates
all
the
time
you
don't
have
to
be
refreshing,
the
thing
which
is
really
nice,
okay,
so
now
we're
up
and
running.
A
I
will
be
careful
to
actually
do
the
trigger
validation
not
validate.
If
I
do
that,
oh
it's
still
deploying
currently
scheduled
or
running
so
okay.
So
it's
still
the
plan.
I
thought
I
did
the
same
thing
again,
so
we
do
instances
this
thing,
and
so
this
is
the
place
where
it's
like
having
a
nice
view
here.
That
shows
the
plans
and
the
history
and
all
that
would
be
nice.
Okay,
so
deploy
is
run
to
completion,
we're
in
good
shape,
and
now
we
can
trigger
it
again
and
and
now,
if
we
look
at.
A
So
kudo
plan
status
and
then
I
have
to
do
instance,
z,
z,
keeper
instance,
all
right
cool,
it's
completed,
okay,
so
I
guess
one
of
the
things
that
I
think
would
be
interesting
here
and
I
think
I'm
wondering
about
sort
of
the
day
two
stuff.
Do
you
need
to
manually
trigger
something
like
a
validation?
A
Or
can
you
set
up
the
thing
that
says
like
hey,
you
know
every
hour
run
this
validation
and,
like
you
know,
and
then
the
validation,
there's
sort
of
some
auto
remediation
and
then
there's
also
like
hey.
I
found
a
condition.
I
don't
know
how
to
deal
with
and
like
maybe
you
could
hook
this
up
to
something
that
would
then
start
paging
people,
and
so
that
would
actually
be.
A
That
would
be
really
interesting
to
actually
see
like
how
does
this
work
sort
of
in
reality
to
make
sure
that
things
don't
drift
and
that
things
stay
valid
and
that
you're
running
these
sanity
chests?
Okay,
so
yeah,
so
that's
a
event
triggered
plans
with
cloud
events
this
one.
Oh
cloud
events,
yay,
okay,
so
then
you
could
start
dealing
with
like
hey,
there's,
an
event
that
something
happened
and
you
could
have
a
whole
ecosystem
of
what
you
want
to
be
able
to
do:
okay,
cool
and
then
that
might
be
a
oh.
A
This
has
a
lot
in
common
with
something
like
the
argo
workflow
engine
right
and
so
and
there's
there's
definitely
a
you
know.
Cloud
events
triggering-
and
you
know,
interaction
with
with
argo
also,
and
so
I'm
wondering
if
there's
some
sort
of
you
know
synergy
there
to
actually
be
thought
about
and
created.
So
that
would
be
pretty
cool
too
all
right.
So
that
gives
you,
I
think,
gives
us
the
general
idea
of
what
this
looks
like
and
then
you
could
have
an
arbitrary
set
of
plans
that
you
could
trigger
here.
A
So
you
could
have
something
to
do
an
upgrade.
You
could
have
something
to
do
a
backup,
that's
what
I'm
assuming
now.
One
of
the
things
that
I
think
is
interesting
is,
and
I
think
this
might
be
a
limitation
of
the
kudo
point
of
view.
Is
you
know
how
do
you
want
to
model
doing
a
backup
with
something
like
an
operator
right
and
one
way
that
you
could
think
about?
It
is
that
maybe
you
have
another
crd,
which
is
a
backup
of
your
database,
and
then
you
have
a
restore
action.
A
That's
going
on
from
that
and
like
like
modeling
out
a
richer
set
beyond
instances.
I
think
is
something
that
would
be
missing
out
of
here
or
it's
like
you
know,
let's
say
you're
doing
a
database
and
you
actually
have
primaries
and
replicas
and
you
want
to
create
and
each
of
those
things
has
a
crd
and
and
then
there's
a
parent
crd
that
represents
the
replica
set
and
then
there's
ways
to
actually
interact
with
those
things
dynamically.
A
Yeah
yeah,
I
think
you
know,
there's
there's
backup
and
restoring
disaster
recovery.
How
does
that
relate
with
sort
of
more
generic
systems
like
valero?
And
how
would
you
actually
have
valero
interact
with
operators?
I
think
that's
something
that
I
haven't
seen
anybody
explore
yet
either
that
would
be
really
interesting,
yeah
and
then
actually,
maybe
like
the
backup
scheduling,
is
something
like
a
valero.
A
Okay,
cool,
all
right,
so
that
I
think,
is
a
good
run
through
of
what
it's
like
to
use
kudo
now.
What
I
want
to
do
is
I
want
to
take
a
look
at
what
does
it
look
like
behind
the
scenes
here
so
there's
a
whole
set
of
the
docs
here
which
talks
about
developing
operators,
and
I
think
you
know
I
I
do
like
reading
through
docs
I'm
a
depth.
First
learner
I
like
to
read
all
the
docs
and
understand
everything,
but
I
think
for
tgik.
A
There's
this
repo
called
well,
first
of
all,
there's
a
repo
called
operators
index,
and
so,
when
I
say,
install
zookeeper
what
it's
doing
is
actually
going
and
fetching,
and
caching
this
and
here's
sort
of
this
this
this
metadata
object.
This
is
not
a
crd,
but
it
uses
the
same
format
which
I
think
is
really
or
maybe
this
is
no.
This
is
not.
This
is
a.
This
is
an
index
api
version,
so
this
is
actually.
This
is
one
of
the
things
I
think
is
fascinating.
A
Is
that
the
whole
api
version
kind
and
name
stuff,
that
sort
of
triad
is
finding
its
way
out
as
a
useful
sort
of
like
you
know
marker
on
any
sort
of
data
file.
You
know
yaml
or
whatever,
to
say
here's
what
this
thing
is,
even
if
you're,
not
checking
that
thing
you
know
or
submitting
that
thing
to
to
a
kubernetes
reap
kubernetes
cluster,
which
is
really
interesting.
So
I'm
guessing
if
I,
if
I
look
at
kudo.
A
This
repository
is
repositories.yaml
which
actually
set
points
to
this
thing
here,
so
this
guy
hooks
up
to
here
well,
the
url
here
is
in
is
in
a
cloud
storage
thing
because
probably
to
prevent
people
from
hitting
github
api
issues,
but
I'm
assuming
then
that
if
I
go
through
and
look
at
this,
if
I
do
let's
go
through
that,
this
is
a
snapshot
of
the
stuff.
That's
in
that
github
repo,
no
such
key.
A
A
A
This
points
so
there's
probably
a
build
process
that
gets
built
out
of
this.
So
in
any
case,
this
stuff
gets
all
uploaded
to
google
storage,
you
know
or
s3
or
wherever.
So
it's
just
dumb
old
things
doubled.
You
know
http
hosting
to
be
able
to
host
one
of
these
things,
which
is
always
nice
to
see,
and
then
I'm
assuming
that
like
this
is
just
a
tar
file
that
has
a
whole
bunch
of
files
in
it.
Those
files,
then,
are
actually
coming
here
from
the
the
operators
repo
here,
and
so
I
have
that.
A
A
Cool
okay
and
then
it
says
where
this
is
going
to
match
the
oci
artifacts
effects
so
that
we
can
push
any
artifact,
oh
cool,
I
love,
so
this
is
a
whole.
Other
thing
that
we
got
to
explore
at
some
point
is
the
idea
that
oci
registries
are
turning
into
a
generic.
A
generic
artifact
store,
which
I
think
is
super
super
cool
because,
like
s3,
is
great
but
s3,
plus
a
little
bit
of
life
cycle
and
versioning
metadata
around
it
for
artifact
management
is
even
better.
A
Also
so
really
like
where
that
world
is
going,
that's
really
exciting,
okay,
so
the
operator
here
fundamentally,
this
is
what
we
got.
There's
a
bunch
of
templates
that
are
involved
here
which
are
interesting
and
then
there's
and
then
there's
the
params
file
and
so
the
params
file.
Here
again
so
this
is
like
this
looks
a
lot
like
a
helm
chart
right.
I
mean
it,
but
it's
it's
again
focused
for
sort
of
what
happens
when
you
change
these
things
and
having
a
general
sort
of
reconciliation,
run
book
type
of
thing.
A
That
happens
if
the
default
way
that
you
change
these
things.
When
you
change
these
things,
it
it
reruns
the
deploy
trigger.
I
I
saw
that
in
the
documentation,
but
there
are
some
things
like
right
now.
This
particular
thing
doesn't
know
how
to
handle
changing
of
the
storage
class
and
so
that'll
actually
trigger
something
called
a
not
allowed
trigger.
But
I'm
guessing
that
this
will
tickle.
That
bug
that
we
hit
earlier
will
get
you
into
a
hork
state
where
it's
like.
A
Hey,
I
don't
know
what
not
allowed
is,
but
I
can't
run
it
so
I'm
not
sure
what
to
do
and
I'm
in
a
stuck
state.
So
this
is
probably
something
that's
worth
testing
out,
but
things
like
this
size
and
storage
class.
Those
things
are
too
big.
A
change
for
this
particular
operator
to
deal
with
so
it'll
actually
keep
you
from
doing
that,
but
there's
a
bunch
of
other
stuff
that
you
can
do.
That'll
actually
cause
a
essentially
a
redeploy
of
zookeeper
and
you're
up
and
running
here.
A
One
of
the
interesting
things,
and
I'm
wondering
how
that
would
fit
in
here-
is
that
you
know,
and
and
thinking
of
some
of
the
experiences
from
like
bosch
in
the
in
the
cloud
foundry
world
is
that
you
know
if
I
go
through
and
I
change
the
cpu
limit.
How
disruptive
is
that
going
to
be?
Is
that
going
to
actually
sort
of
take
all
of
these
things
down,
or
is
that
the
type
of
thing
that
can
do
a
rolling
update
and
it's
not
going
to
be
disruptive?
A
Is
there
a
way
to
essentially
do
a
little
bit
of
a
dry
run
of
these
things?
So
maybe,
like
hey,
is
there
a
way
that
you
can
have
you
know,
parameters
to
a
particular
trigger
so
that
you
can
do
a
dry
run
and
then
have
that
thing
have
output?
That's
something
that
I
think
would
be
interesting
to
look
at:
oh
duffy's,
taking
off.
Thank
you
duffy,
for
all
your
help
really
appreciate.
A
It
have
a
great
weekend,
man,
so
that's
something
that
I'd
love
to
explore
and
it
sounds
like
not
yet,
but
that
might
be
an
area
to
to
take
a
look
at
and
again
that's
the
type
of
thing
where
it's
like.
You
start
looking
at
this
through
the
lens
of
like
you
know
something
like
an
argo
event,
type
of
thing
now.
The
interesting
thing
here
is
that
let's
look
at
the
operator
here
so
that
so
we
have
a
bunch
of
tasks
and
plans.
A
The
validation
plan
happens
in
serial
and
there's
a
let's
see
the
steps
are
connection
and
cleanup,
so
validation,
okay,
so
there's
a
so.
This
is
essentially
a
a
dag
here
where
the
tasks
can
be
reused
across
multiple
plans,
and
that's
really
interesting.
I
think,
and
then
the
individual
tasks
here
are:
hey
just
apply
these
resources
and
so
okay.
So
we
look
so
we're
doing
a
deploy.
A
The
infra
and
the
app
tasks
are
what
we're
doing,
and
so
there's
the
infra,
which
does
a
boot
bootstrap
health
check,
services
and
then
pdb
and
then
and
then
apply.
Oh
wait.
This
is
so.
This
is
okay,
I
see
so
there's
infra
and
app
and
then
apply
is
the
type
of
task,
and
I
think
that's
something
we
can
look
at
the
docs
of
the
different
types
of
tasks
that
can
actually
come
into
play
here.
A
So
the
idea
is,
you
do
a
bunch
of
stuff
to
set
it
up,
and
then
you
do
the
stateful
set,
and
so
there's
an
implication
here
that
these
things
are
actually
sequenced
right
or
that's
the
parallel
here.
Okay,
the
steps
are
sequenced
or
no.
This
is
one
step.
Okay,
in
any
case
now.
The
interesting
thing
here
is
that
when
we
go
through-
and
we
look
at
bootstrap-
let's
look
at
these,
so
we
have
bootstrap.
A
This
is
a
lot
of
bash
because
you
know,
but
it's
a
config
map,
so
at
the
end
of
the
day,
we're
creating
a
config
map
and
there's
templating
built
in
here,
and
so
what
we
see
here
is
again.
This
looks
a
lot
like
helm.
It
uses
golang
templating
behind
the
scenes
to
be
able
to
do
this
stuff,
and
so
the
you
know,
as
we
look
from
the
params
on
down.
A
But
if
we
look
at
bootstrap
here,
there's
name
is
there
other
places
where
we
see
yeah,
and
so
here's
the
params
client
board
server
port
election
port,
that
type
of
thing
cool
and
then
then
health
check
similar
thing.
Here's
the
script
that
gets
run.
So
the
idea
is
that
we
do
expansions
these
things,
get
written
into
config
maps
and
then
I'm
guessing
that
the
stateful
set
loads,
the
config
maps
and
that
image
knows
to
actually
run
these
things
and
they
get
mapped
into
a
specific
mount
path.
Yeah.
A
A
Very
cool,
so
this
I
mean
so
in
this
case
this
looks
a
heck
of
a
lot
like
a
helm
chart
with
some
more
sort
of
prescriptive
ways
of
what
you
do
when
you
change
parameters
and
the
ability
to
have
these
extra
triggers
with
the
idea
that
this
thing
is
actually
running
in
an
ambient
way
and
yeah.
But
you
know,
and
so
like
you're
like,
oh
but
helm,
had
tiller
and
it
got
rid
of
tiller
and
v3,
and
this
thing
has
a
controller.
Well,
how
does
this
controller
compare
to
tiller?
A
So
that's
something
that
I
think
is
interesting
to
examine.
I
think
the
big
problem
with
tiller
was
that
the
security
model
around
tiller
was
not
something
that
was
well
understood
and
tiller.
Didn't
have
this
rich
sort
of
triggering
model
that
could
happen
at
any
time,
and
so
really
the
value
prop
around
tiller
and
the
the
security
considerations
meant
that
it
was
something
that
you
know
really
made
sense
to
move
away
from
with
helm3
for
those
folks,
because
everything
that
happens
here
works
through
crds
custom
resources.
A
There
aren't
nearly
as
many
security
considerations
as
tiller,
because
tiller
had
a
separate
grpc
api
direct
to
tiller
and
that
created
a
whole
bunch
of
problems
there
around
auth
and
confused
deputies.
So
jared's
asking
we're
considering,
would
like
your
thoughts
on
being
a
bit
more
structured,
ytt,
jsonnet,
starlark,
etc.
To
get
around
some
of
the
templating
hell,
yeah
templating
hell
is
the
way
I
would
view
this
through.
A
You
know
like,
like
one
of
the
things
that
I
would
think
about,
is
that
as
we
look
at
apply
here,
you
know
you
could
have
a
legacy
apply
and
then
you
could
have
something
along
the
lines
of
where
you
have
a
you
know.
You
know,
custom
apply
where
you
had
the
ability
to
actually
have
custom,
appliers
or
processors
that
could
be
installed
in
some
ways,
and
whether
this
is
a
custom
container
image
that
you
run
on
this
thing
to
be
able
to
do
this
transformation
or
what
have
you?
A
The
idea
that
you
sort
of
separate
that
out
and
you
have
sort
of
less
knowledge
now
the
output
of
this
thing
would
be
like
you
apply,
and
then
it
leaves
some
breadcrumb
with
all
the
yaml
and
then
so,
maybe
it's
like.
Maybe,
instead
of
calling
that
thing
apply,
you
would
actually
call
it
sort
of
a
processor
right,
and
so
that
starts
to
look
like
meta
controller
web
hooks
you're
right,
but
I
would
do
it
like
it's
really
about
which
tool
set.
A
Do
you
want
to
use
and
generally
like
people,
wouldn't
be
writing
custom
code
there
they
would
be
like.
Oh
I'm
going
to
use
the
ytt
or
the
json.
You
know
processor.
It
might
be
worthwhile
to
take
a
hint
from
something
like
customize,
because
customize
does
have
this
extensibility
model
for
being
able
to
essentially
do
custom
processors
that
take.
You
know:
okay,
here's
some
parameters
run
it
through
this
thing
and
it
generates
some
yaml.
A
One
of
the
things
that
I
think
you
know
we've
been
thinking
about
inside
of
vmware
and
brian
lyles
has
been
playing
around
with.
Is
you
know?
How
do
we
deconstruct
git,
ops
and
think
about
git
ops
as
being
not
about
git,
but
about
being
having
a
a
external
system
of
record
and
a
continuous
application
of
that?
And
so
one
way
to
think
about
this
would
be
that.
Maybe
you
know
you
know,
we
have
a
way
to
create
an
external
system
of
record
and
instead
of
using
git.
A
This
is
actually
using
a
internal
sort
of
you
know,
system
of
record
and
then
there's
a
generic
applier.
That
knows
how
to
apply
that,
whether
you're
pulling
stuffing
from
get
so
there's
like
there's,
definitely
a
spectrum
between
the
way
that
we're
we're
looking
at
doing
this
templating
with
the
automatic
application.
When
you
run
this
versus
something
like
get
op
and
that's
something
that
I
think
is
is
worth
exploring
a
little
bit.
A
There's
no
right
answers
here
and
I
think,
there's
a
soup
of
ideas
and
over
time
we're
going
to
be
building
up
the
right
sort
of
building
blocks.
None
of
these
things
is
rocket
science
to
get
started
with.
I
think
it
gets
more
complicated,
as
you
start
thinking
about
some
of
the
some
of
the
edge
cases
and
how
you
deal
with
those
so
yeah.
So
this
is
super
cool
and
then
sort
of
validation
here
ends
up
being
just
a
job
that
runs
okay,
cool
and
so
what
this.
A
So
one
of
the
things
that's
missing
here
is
that
okay,
you
validate
it
has
a
restart
policy
of
never,
which
means
that
it
can
fail
if
it
fails.
I
assume
that
there's
like
hey
you're,
just
reading
the
sort
of
the
result
of
the
job
and
then
maybe
you're
reporting
that
back
understanding
the
result
of
the
validation
is
something
that
would
be
interesting
and
then
like
okay.
So
then
that
plan
fails
and
now
it's
like
okay,
the
plan
failed
now.
What
now?
A
What
you
need
to
do
is
understand
a
lot
about
kudos
so
that
you
can
actually
go
down
and
dig
into
like
oh
well,
this
you
know
this
trigger
ran
this
plan.
This
plan
ran
a
job.
This
job
ended
in
a
failure
and
here's
where
the
logs
are,
and
so,
if
you
don't
have
that
sort
of
connection
between
the
logs
of
the
job
with
that
so
like,
I
would
really
be
thinking
about.
What's
a
way
for
a
plan
to
be
returning
richer
information
about
what
happened.
A
I
think
we
see
this
a
lot
of
times
with
things
like
ci
cd
systems.
You
know
you
can
run
a
ci
cd
run
and
when
everything
works
great,
it's
great
when
things
fail
you're
like
groveling
through
log
files
that
are
hard
to
find,
and
you
have
no
idea
what
the
hell
happened
and
I
think
that's
the
thing
that
I
would
be
afraid
of
here.
Is
that
like
how
obvious
can
we
be
make
it
that
things
are
are
to
debug
right?
And
you
know
when
these
things
fail?
A
A
A
Let's
see,
kafka
is
a
good
one.
Spark
is
a
good
one.
Okay,
all
right,
oh
and
then
jared
says
that
there's
a
testing
framework
yeah.
So
let's,
let's
look
at
that
real
quick!
Oh
I'm!
Looking
at
docs,
okay,
here's
the
operator
template,
there's
a
bunch
of
parameters,
but
the
operator
itself,
there's
a
bunch
of
applies.
A
All
right
cool,
so
that's
a
bunch
of
tasks
all
right.
So
with
spark
you
can
do,
there's
the
deploy
plan
and
that
goes
through
and
that
does
preconditions
install
some
sort
of
web
hooky
thing.
I
guess:
installs
spark
installs,
monitoring,
history,
okay,
cool
and
then
it
looks
like
there's
only
one
one
plan
there
then
for
that
one,
and
then
you
said
that.
A
A
Called
sort
out
I'm
assuming
okay,
so
I
have
to
look
at
the
pipeline
stuff.
Yeah
generate
the
sort
make
it
available
to
later
tasks.
Okay,
yeah.
I
mean
this
is
the
type
of
thing
where
it
starts.
Looking
a
lot
like
something
like
argo
or
even
techton,
right
so
understanding
like
you
know
how
many
sort
of
like
you
know,
directed
graphs
for
running
tasks.
Do
we
need?
Are
there
ways
to
actually
bring
these
things
together?
That's
something
that
I
would
be
thinking
about
so
cool.
A
A
So
this
actually
runs
something
and
then
saves
things
as
either
a
secret
or
a
config
map.
So
you
essentially
save
it
out.
Okay
and
it
sort
of
knows
magic
like
like.
Oh,
it
has
to
be
a
nick
container
and
an
empty
dirt
and
sort
of
probably
completes
the
sort
of
pod
spec
to
bring
it
all
together,
and
so
this
is
a
way
that
you
can
essentially
do
random
commands
to
generate
data
here.
A
So
that's
pretty
cool
and
kudo
operator
task,
specify
dependency
on
other
operators
and
parameterization,
then
a
dummy
task.
What
is
the
sa
failing
succeed
on
demand
for
debugging?
Okay,
that
looks
useful,
so
one
of
the
things
that
I'm
wondering
here
and
I'm
wondering
how
you
actually
think
about
this,
and
maybe
probably
jobs,
are
the
way
you
would
do
it.
A
It
into
the
cluster
and
have
the
cluster
sort
of
quiesce,
and
I'm
wondering
like
what
would
that
trigger
be
like
I'm
like,
like
maybe
you
know,
one
of
the
things
that
would
be
needed
here
would
be
like.
Oh,
if
you
see
a
restart
of
any
of
these
pods
then
trigger
a
cloud
event
and
then
have
that
cloud
event
trigger
a
plan
and
have
that
plan
run
a
job
and
have
the
job
go
like
hey.
Let
me
make
sure
that
everything
is
hooked
up
talking
to
each
other
and
configured
correctly.
A
So
maybe
the
missing
piece
there
is
that
sort
of
reactivity
loop
of
generating
the
event
based
on
generic
things
that
are
happening
in
your
cluster
and
I'm
wondering
if
that's
something
that
you
all
are
thinking
about,
that
sort
of
automatic
remediation,
because
clearly
you
can
get
to
the
point
where,
where
you
know
oh,
like
something
failed,
I
need
to
remediate.
Let
me
go
through
and
do
kudo
you
know
trigger
and
actually
trigger
things
manually,
but
like
the
the
holy
grail
is.
A
We
want
to
make
this
stuff
be
automatic
and
foolproof
and
debuggable,
right
and
obvious.
So
jared
here
says
we're
working
with
a
user
right
now
who
wants
to
manage
this
for
on-prem
cassandra
cassandra's
a
great
great
example,
data,
node
failures
and
they'll?
Let
the
operator
intervene,
and
am
I
standing
it
back
up
or
rebounds
to
another
shah
that
type
of
thing
yeah.
So
that's.
A
I
think
the
interesting
thing
I'm
thinking
about
some
of
the
operator
work
that
we're
doing
inside
of
vmware
as
we
continued
some
of
the
efforts
that
we
started
with
pivotal
coming
from
pivotal
around
creating
operators
around
things
like
gemfire
is
a
great
example,
so
gemfire
or
or
oh
gosh
yeah.
So
I'm
trying
to
think
what
else
we're
working
on
there
but
yeah.
So
that's
sort
of
like
you
know,
hey
something
unexpected
change.
A
Okay
cool
all
right.
Let's
look
at
the
the
testing
stuff,
real,
quick
and
then
I
think
I
should
probably
call
it
because
we're
about
an
hour
and
a
half
in
so
okay,
so
you
can
stall
kudos
so
the
first
test.
What
does
the
test
look
like
inside
the
example
test?
We
create
our
first
test
install,
so
this
creates
an
example
deployment,
and
now
we
have
a
test.
A
A
Oh
interesting,
so
so
this
is
a
fascinating
way
to
view
it
now.
Is
this
built
into
kudo,
or
is
this
a
separate
type
of
thing
that
you
all
are
doing
so
what's
happening
here?
Is
that
if
you
have
a
yaml
called
assert?
What
you're
essentially
saying
is
that
it's
sort
of
a
partial
overlay
and-
and
I
think
what
you're
saying
is
that
this
should
be
able
to
overlay
on
top
of
the
real
resource
without
any
changes,
and
so
it's
like.
I
want
to
assert
that
everything
listed
here
matches
up
there.
A
A
Like
hey.
Is
there
a
way
to
sort
of
break
this
out
as
being
a
a
way
to
test
things
in
a
kubernetes
cluster?
Sorry
jared
I
I
was
just
saying
that
none
of
this
stuff
here
requires
kudo.
It's
really
an
interesting
way
to
think
about.
You
know
applying
and
testing
and
breaking
it
out.
Oh,
you
already
did
okay,
so
it
comes
with
kudo,
but
it
also
it.
A
It
looks
like
it's
maybe
broken
out
already
so
very
cool
tips
and
tricks
loading
built
images
into
kind
kubernetes
event,
oh
yeah,
because
you
want
to
helm
testing
test
suite
very
cool.
I
like
that.
That's
a
really
interesting
set
of
ideas
there
all
right!
Well,
let
me
go
ahead,
and
so,
first
of
all
you
know
jared
and
the
team.
Thank
you
so
much
for
joining.
Oh,
I
got
blurry
there
for
a
second
hello
you
can
tell
I'm
like
my
my
green
screen
is,
is
confused?
A
A
A
My
spelling
q-u-t-t-t-l
there
we
go
so
very
cool
to
see
that.
Oh
sorry,
what
I
did
is
I
added
that
to
show
notes
here:
cool
test
tool
that
is
not
kudo,
specific,
so
yeah,
so
my
thoughts
about
kudo.
I
think
I
really
really
like
that.
Kudo
is
a
way
for
folks
who
don't
necessarily
consider
themselves
programmers
to
start
playing
in
the
operator
world
and
I'm
really
interested
to
see
where
this
goes
over
time,
especially
with
the
sort
of
dynamic
crd
creation.
A
The
idea
that
you
know
we
can
take
you
know
the
typical
operator
automates
their
job
by
creating
a
bunch
of
you
know,
bash
scripts,
and
and
how
do
we
turn
those
bash
scripts
and
turn
the
corner
from
like?
I
have
to
be
at
my
computer
and
I
have
to
debug
some
things
before
I
run
my
bash
script,
to
here's
a
way
to
automate
this
and
have
it
auto,
remediate
and
sort
of
turn
those
bash
scripts
into
something
that
is
over
time.
A
The
fact
that
the
user
of
this
system
is
not
a
programmer,
but
is
an
operator
themselves,
and
so
that
is,
I
think,
really
really
interesting
and
I'm
and
I'd
love
to
you
know.
I'm
gonna
definitely
keep
an
eye
to
see
where
the
kudo
folks
take
the
project
and
and-
and
I
think
that
there's
a
lot
of
opportunities
to
find
ways
to
integrate
this
and
leverage
other
parts
of
the
ecosystem
at
large,
and
I
think
you
know
doing
that
in
a
way
such
that
you
know
the
the
sort
of
getting
started.
A
Experience
that
is
here
right
now
is
not
lost,
but
those
who
want
to
become
more
experts
have
the
ability
to
get
fancier
and
use
more
advanced
tools.
I
think
that's
definitely
a
challenge
with
systems
like
this,
but
definitely
worth
chasing
down,
so
very,
very
cool
stuff.
Thank
you
again
for
jared
and
the
kudo
team
for
joining
in
and
helping
out
and
not
sure
who's
doing
tgik
next
week.
But
thank
you
so
much
everybody
for
joining
me
and
I'm
going
to
sign
off
and
we
will
see
you
next
time
all
right.