►
From YouTube: Kubernetes KubeBuilder Meeting 20201119
Description
KubeBuilder Meeting for 2020/11/19. See https://sigs.k8s.io/kubebuilder for more details.
A
All
right,
good
morning,
this
is
or
afternoon
or
whatever
time
it
is
wherever
you're
watching
right
now.
This
is
the
q
builder
controller,
runtime
and
controller
tools
meeting
for
thursday
november
19th
2020..
As
a
reminder,
we
are
currently
recording
so
don't
say
anything
that
you
don't
want
recorded
for
all
of
posterity
all
right.
I
think
we
have
two
items
on
the
agenda
today.
I
think
the
first
is
from
phil,
so
why
don't
you
take
it
away?
Phil.
B
Great
thanks:
I'm
gonna
try
and
figure
out
how
to
do
zoom
sharing.
Here
it's
been
a
little
while
we
used
to
have
windows,
but
all
right.
Let's
try.
B
All
right:
let's
try
that
again,
I'm
back
all
right,
let's
go
so
there
you
go,
that's
what
we
get
for
the
pre-recorded
kukan
talks,
universes
and
balance
again.
B
Okay,
so
what
I'm
going
to
demo
quickly
is
just
like.
Looking
at
we
kind
of
taking
a
look
at
different
ways.
We
can
do
the
configuration
generation
for
cool
builder
projects.
B
The
kind
of
where
I
landed
is
that
it
would
be
really
nice
to
have
an
abstraction,
rather
than
just
pure
patches
kind
of
the
way
we
do
it
now.
I
think,
there's
a
lot
of
reasons
that
crew
builder
is
more
complex
than
your
typical.
B
Your
typical
bundle
of
configuration
one
is
that
a
portion
of
the
configuration
is
actually
generated
from
code
like
the
crds
and
the
r
back
rules
and
some
of
the
web
hooks,
and
so
you
have
the
source
real
source
of
truth
for
some
of
the
configuration
being
the
actual
code
directory.
Some
of
the
configuration
is
scaffolded
it
out
at
the
time
you
create
the
objects
and
some
of
the
configuration
is
scaffolded
it
out
at
the
time
you
or
create
the
api.
B
Some
of
the
time
you
create
the
projects
and
then
when
you
want
to
change
something
like
enable
web
hooks
for
instance,
or
enable
insert
the
cert
installer
that
this
involves
like
changing
a
bunch
of
different
places
in
the
files
and
and
probably
what
you
want
is
like.
You
just
want
to
enable
web
hooks
or
you
know
you
want
to
disable
them
or
you
want
to
have
the
cert
installer
enabled
or
not.
B
Customize
has
this
notion
of
functions
which
are
essentially
programs
that
are
able
to
generate
transform
configuration
and
you
can
drop
them
into
a
customization
email
and
they
can
do
arbitrary
stuff,
and
so
I
wrote
a
customized
functions
that
works
as
a
standalone
program
which
I'll
demo
now
it's
called
config
gen
right
now
and
basically
have
this
program
here
and
if
I
run
it
inside
the
queue
builder
directory
here,
then
it
looks
at
the
project
file
and-
and
I
added
a
couple
fields
to
the
project
file
here-
this
this
spec
with
image
and
enable
web
hooks
and
then
the
metadata
with
the
name.
B
And
so
it
looks
at
the
project
file
and
goes
ahead
and
generates
or
runs
runs
the
configuration
generator
or
controller
gen
libraries,
and
so
you
can
see
it
creates
the
custom
resource
definitions
here
and
then
the
roles
and
does
like
all
the
stuff
you'd
normally
get
out
of
customize.
But
if
I
do
something
like
you
know,
change
web
hooks
to
false
up
here,
so
you
can
see
right
now
it
has
a
validating
web
hook
and
if
my
demo
works
correctly,
it
won't
anymore
down
here.
B
Yeah
you
can
see,
it
doesn't
have
that
web
hook
anymore,
so
allows
you
to
do.
We
can
start
to
build
out
like
high
level
fields
that
do
arbitrary
things
right,
and
so
I
can.
For
instance,
I
can
disable
the
controller
manager,
creation
and
namespace
creation,
and
just
do
crds
or
these
sorts
of
things,
and
I
think
what's
interesting
about
this
approach,
and
how
is
this
different
than
like
just
doing
a
helm
chart
there's
a
couple
ways.
This
is
different.
B
B
So,
if
you
look
at
this
patch
here,
it
has
like
set
the
replicas
to
three,
and
so,
if
I
run
it
with
that
patch
here
you
can
see
it
says
the
replicas
to
three.
If
I
run
it
without
the
patch
there's
a
little
bit
going
on
here
behind
the
scenes,
but
if
I
run
it
without
the
patch,
you
can
see
it's
replicas
one.
B
So
the
way
I've
written
this
is
you
know
by
default
it
if
you
give
it
no
arguments
and
you're
going
to
build
a
directory.
It'll
look
at
the
project
file.
If
you
give
it
one
argument,
that's
the
project
file
or
or
the
api.
It
doesn't
actually
have
to
be
a
project
file.
It's
anything
with
those
fields
and
then
additional
arguments
are
patches
now
what's
kind
of
cool
about.
This
is,
if
I
run
config
gin
here.
B
B
If
I
run
config
gen
here
it
just,
it
works
like
a
customized
function.
So
if
you're
running
it
in
a
container
or
running
it
as
part
of
a
customized
pipeline
or
kept
pipeline,
or
something
like
that,
then,
instead
of
reading
files
from
disk,
it
re
waits
for
standard
in
and
we'll
have
like
patches
or
different
things
passed
to
it,
and
that
means
it
also
writes
them
out
in
the
customize
function
format.
So
it's
easy
to
chain
this
with,
like
other
modules
or
functions
or
plugins
or
whatever.
B
We
want
to
call
them
now,
and
so
you
can
say
you
can
easily
then
say:
okay,
I
want
to
apply
the
namespace
customization
on
top
of
all
this
stuff,
and
so
you
so
we
get
the
full
capabilities
of
what
customize
offers
today,
which
is
you
can
give
patches.
You
can
do
common
labels,
common
annotations,
generate
config
maps
and
do
all
that
random
stuff.
B
But
if
you
look
at
the
like
source
directory
here,
we
don't
have
this
like
bundle
of
directory,
bundled
full
configuration
where
you
need
to
comment
and
uncomment
things
to
do:
high-level,
stuff
and
regenerate
the
crds.
B
B
So
that's
the
demo
of
the
using
it
any
questions
before
I
kind
of
show
how
this
is
how
you
can
implement
something
like
this.
C
Real
quick-
maybe
you
talked
about
this
and
I
missed
it,
but
like
where
the
things
that
are
scaffolded
like
during
project
initialization,
that
kind
of
set
out
the
boilerplate
for
the
operator,
deployment
or
controller
deployment,
for
example,
is
that
encoded
in
config?
Or
is
there
still
some
base
file
somewhere
that
exists.
B
Great
question
yeah
that
I'll
I'll
show
that
right
now
in
the
implementation,
how
this
is
actually
architected
cool,
all
right,
I'll
go
share
a
different
tab.
Now
that
has
so
so.
What
I
just
shared
was
a
sorry.
What
I
just
shared
was
like
a
new
coup
builder
project
right
where,
where
one
would
use
this,
and
so
now,
I'm
going
to
share
the
actual
builder
project
here,
which
is
this
is
like
the
the
real
tubular
code
repo,
and
so
here's
there's
a
pr
out
for
this.
B
I
think
it's
even
linked
on
the
dock,
so
anyone
can
go
dig
around
in
the
code
as
as
they
like,
but
I
created
this
new
directory
right
here,
just
to
hold
this
command
right
now
it's
a
standalone
command
and-
and
so
the
main.go
is
really
simple
here-
it's
just
like
executes
a
cobra
command,
so
the
meat
of
it
is
really
in
this
api's
directory
and
so
sorting
through
this
I'm
leveraging
pretty
heavily
a
couple
things.
B
One
is
the
customized
framework
for
writing
functions,
there's
a
framework
that
allows
you
to
do
them
as
templates.
I
decided
to
do
them
as
templates
simply
because
it
was
the
easiest
way
to
map
our
existing
structure,
and
so
so,
as
I
implemented
this
there's
many
ways
we
can
implement
it,
none
of
which
impacts
user
experience
or
the
api
or
backwards
compatibility,
or
any
of
that.
B
We
can
change
this
out
and
swap
it
for
templates
and
then
go
to
something
else
like
manually,
writing
objects
and
then
back
to
templates
or
some
combination
of
the
above
yeah.
So
the
point
is
none
of
that
actually
matters
from
the
perspective
of
the
consumer
of
this
tool,
but
I
chose
to
implement
those
templates
mostly
to
evaluate
you
know
if
this
is
a
feasible
option
and
if
it's
a
clean
approach
and
it
maps
closely
to
kind
of
how
we
do
things
today.
B
So
I
basically
have
this
templates
directory
here
or
templates
field,
where
each
one
of
the
files
that
that
we
scaffolded
it
out
is
now
a
template.
So
so
we
can
kind
of
fill
in
the
different
fields
here,
based
on
kind
of
higher
level
values,
and
so
this
is
like
structure.
I've
chosen
where
I
just
have
like
exposed
and
high
level
api
kind
of
for
each
piece,
the
ability
to
either
disable
or
enable
it
based
on
whether
it's
you
know
scaffolded
by
default
on
or
scaffolded
by
default
off.
B
So
in
this
case
we
scaffold
the
namespace
by
default.
So
I
say
you
know
you
can
disable
it
here.
Otherwise,
you
know
fill
this
in
and
substitute
this
in
here
and
so
here's
the
controller
manager
again
created
by
default,
scaffold
and
the
image
and
working
hard
to
keep
these
very
simple.
Like
the
the
substitutions.
B
I
try
and
keep
very
minimal
without
doing
a
whole
bunch
of
like
complex
logic,
and
I'm
able
to
do
that
because,
instead
of
just
having
like
a
template
or
just
having
a
chart,
this
is
actually
run
as
part
of
a
program.
So
I
can
scaffold
out
bases
and
then
I
can
patch
them
later,
which
I'll
show
in
a
minute.
So
here's
like
the
controller
manager-
and
I
say,
okay,
if
you're,
enabling
web
hooks,
create
the
service
that
goes
along
with
the
roller
manager.
B
And
if
you
have,
you
know
if
you're
not
disabling
the
off
proxy,
again
like
whether
it's
on
or
off
by
default,
scaffold
up
the
service
for
the
off
proxy
here's,
the
rbac
rules
for
the
manager.
B
Again,
we
can
break
these
into
multiple
templates.
Single
template
doesn't
really
matter.
I
chose
to
make
a.
I
chose
this
structure
because
I
happen
to
find
it
to
be
mapping.
I
think
well
to
what
we
have
today.
So
this
is
the
r
back
for
the
leader
election.
Again,
we
just
substitute
this
stuff
in
here.
I
find
this
a
little
easier
to
follow,
because
it's
kind
of
clear
how
all
like
these
things
are
wired
together,
the
metrics
that
are
back
for
the
metrics
epoxy.
B
So
some
of
the
things
are
here
like
if
you're,
enabling
you
know
different
things
you
the
control,
normally
the
controller
manager
would
have
be
changed
right,
and
so
I
chose
for
this
particular
demo
to
instead
of
making
this
template
complex,
to
keep
it
relatively
close
to
again
the
what
we
scaffold
out
and
the
framework
allows
you
to
specify
patches
as
well,
so
I've
templated
out
the
patches
here
and
so
the
patches
have
selectors,
so
we'd
say:
okay,
apply.
B
You
know
to
these
different
kinds,
this
conversion
web
hook,
if
you've
enabled
cert
manager
right
and
that
again
maps
to
the
patches
we
had
for
those
things
already,
it's
a
little
bit
different
in
that
we're
matching
by
kind
and
applying
the
patches
to
all
those
kinds,
instead
of
just
instead
of
individually
patching
them.
B
B
Same
thing
here,
if
enabling
web
hooks,
you
know
then
patch
again,
this
is
a
patch.
We
apply
with
customize
trying
to
keep
that
similar.
If
you
didn't
disable
the
off
proxy
patch
with
the
off
proxy
again
maps
to
the
patch
we
have
today
and
if
you
enable
web
hooks
again
another
patch.
So
essentially
we
have
similar
to
what
we
have
today.
We
have
you
know
these
templates.
We
have
these
patches,
but
but
both
have
some
substitution
capabilities,
and
then
we
combine
that
with
a
couple
of
things
here.
B
So
looking
at
the
framework
you
have
kind
of
these
templates,
those
are
the
templates
that
are
listed.
You
have
these
patch
templates.
Those
are
the
patch
templates
that
are
listed.
We
define
this
api
here,
that's
fed
to
the
templates,
but
we
also
have
this
pre
and
post
process
step,
and
this
allows
us
to
do
things
that
you
can't
really
do
just
with
patching
alone.
B
For
instance,
we
have
this
controller
gin
filter
which
generates
resources,
and
again
this
was
what
makes
it
fit
into
a
customized
plugin
is
that
it
takes
it
doesn't
just
generate
it
actually
takes
resources.
Customize
would
pass
to
it
from
other
bases
and
whatnot,
but
then
it
calls
the
generator.
So
you
know
generates
web
hooks
generates
r
back
optionally,
depending
on
whether
you've
enabled
these
or
not
generates
the
crds
here
and
then
produces
the
resources
they
got
from
the
code
and
so
in
the
run
function.
B
What's
in
the
controller
gin
filter
or
what
was
produced
by
the
control
of
gen
filter
and
possibly
through
a
validation
error,
if
you
have
fields
that
don't
make
sense
together
in
this
case,
what
we're
doing
is
we're
just
sorting
the
resources.
B
This
is
another
nice
thing
is
you
know
we
can
have
a
lot
of
control
over
how
we
sort
this
specifically
for
coup
builder,
instead
of
relying
on
what
customize
does
by
default
for
sorting
these
things
and
and
so
for
this.
I
just
implemented
this
dumb
little
filter
here
that
you
know
I'm
ordering
by
the
kind
of
the
resource
and
then
just
do
a
little
in
place
sort
of
the
resources
based
on
that.
B
This
is
the
api,
so
this
can
be
written
as
its
own
configuration
file
or
as
part
of
the
project
file,
either
one's
fine,
there's
extra
code
in
here
just
to
check
the
project
file,
but
you
can
see
so
there's
you
know
the
directory,
the
name,
the
namespace,
the
image
you
know
and
what
you
want
disabled
enabled-
and
this
will
allow
us
to
do
other
stuff
too,
like
if
we
want
for
development
mode
for
web
hooks
to
create
you
know
our
own
certificates
and
secrets
and
nca
that
are
valid
for
like
one
hour
or
something
that
would
allow
folks
to
just
run
config
gin
and
then
apply
that
and
have
like
the
web
hooks
working.
B
You
know
almost
immediately
just
after
creating
them
without
having
to
screw
out
them
with
any
certs
or
anything
for
their
dev
cluster
right
and
they'll
be
valid
for
an
hour
or
something
like
that,
and
then
here's
how
kind
of
the
we
test
this.
So
this
project
here
that
just
has
some
apis
and
controllers
here,
and
so
we
have
kind
of
you
know
if
you
have
this
configuration.
This
is
what
a
configuration
file
would
look
like.
B
It
spells
out
that
directory
says
the
image
latest
and
then
this
is
kind
of
what
it
spits
out
and
then,
if
you
disable
the
off
proxy,
you
get
a
slightly
different
configuration.
If
you
enable
cert
manager.
D
I
do
have
one
if
no
one
has
one:
how
can
you
integrate
this
with
the
whole
plugin
system
that
we
are
developing
right
now
I
mean,
can
you
hook
the
prepost
process
and
post
process
functions
that
you
mentioned,
or
something
like
that,
or
will
we
have
to
process
the
the
generated
file?
At
the
end,
the
full
configuration
generated
file.
B
Yeah,
that's
a
great
question,
that's
something
I
was
thinking
about.
I
think
natively.
This
is
going
to
integrate
much
better
with
for
extension
than
most
other
capabilities,
but
it's
going
to
look
a
little
different
so
rather
than
trying
to
like
extend
like
we
could
do
something
like
crazy
right
where
we
could
be
like.
Oh,
we
take
a
list
of
templates
or
something
like
that
on
the
like
and
then
and
then
you
specify
templates
and
we
overlay
templates
or
patches
or
these
sorts
of
things.
That
would
probably
be
like
the
way.
B
Maybe
I'd
think
about
it
in
the
past.
But
the
way
this
is
intentionally
designed
is
to
compose
as
part
of
a
pipeline.
B
B
So
the
way
this
is
designed
to
work
right
is
that
these
filter
this
this
resource
list
that,
in
this
preprocessor,
for
instance,
gets
all
the
resources
from
some
upstream
thing
in
the
pipeline,
and
so
one
way
we
could
do.
We
could,
for
instance,
do
extensions
right
is
in
the
pro
in
the
project
file,
which
I
don't
have
an
example
of
here
but
say
I'll,
just
put
in
the
comments
here
so
say
you
had.
B
We
add
like
something
like
extensions
right
and
then
we
have
you
know
my
extension
here
in
the
project
file
and
this
you
know
this
would
be
maybe
a
map,
I'm
just
kind
of
off
the
cuffing
here
kind
of
how
you
might
do
this
right
but
like
so,
if
you
say
you
have
a
map
of
like
you
know,
string
to
interface
or
string
two
in
this
case
you
could
do
yaml
dot
node,
which
would
mean
basically
anything
parses.
B
You
see,
you
could
have
your
extension
here
and
then
you
say:
okay,
some
field
you
care
about
is
like
you
know,
policy,
yeah
or
would
say
like
say
secure.
That's
true!
Something
like
this
right
and
you
want
to
generate
the
configuration
based
on
the
secure
equals.
True,
you
can
have
the
same
project
file
and
then
the
way,
essentially
how
we'd
want
to
do
this,
and
this
gets
down
to
us
having
some
choosing
the
right
pipeline
to
do
this
stuff
right.
But
we
essentially
want
to
run
this
as
as
in
series
right.
B
So
it
would
be
like
you
know,
functions
and
then
the
first
one
would
be.
You
know
name
boo,
and
that
would
be
the
configuration
api
right.
B
B
And
so
what
this
allows
you
to
do
is
actually
compose
arbitrary
extensions
in
my
extension
right.
So
this
might
be
exact.
You
know
my
config
gen
when
my
config
gen
runs
it's
going
to
get
all
the
output
from
config
gen,
and
so
that
means
and
the
total
output
of
this
right
is
going
to
be
whatever
my
config
gen
ends
up
transforming
right,
so
that
would
mean
if
configuring
is,
if
you
want
to
patch
a
resource
from
configuring,
you
could
write.
B
You
know
myconfigion
such
that
it
finds
that
resource
selects
all
resources
that
have
a
label
or
by
name
or
you
know
whatever
it
is,
and
then
patches
them.
If
you
want
to
delete
a
resource,
you
can
delete
a
resource
if
you
want
to
change
the
kind
of
a
resource
from
and
then
and
then
patch
it
to
have
additional
fields
like
from
deployment
to
staple
set.
That
can
be
done
if
you
want
to
add
new
resources.
B
If
you
want
to
in
theory,
you
could
even
like
make
a
network
call-
and
you
know,
find
out
some
piece
of
data
based
on
the
user
running
the
command
and
go
make
a
decision
based
on
that
right.
So,
in
terms
of
the
capability
and
the
flexibility,
I
think
kind
of
the
sky's,
the
limit
you
can
take,
whatever
we
produce
and
layer
on
top
of
it,
it's
maybe
like
what
are
the
best
practices?
Do
you
really
want
to
be
talking
to
network?
D
B
And
yeah,
I
think
this
means
that,
like
that
that
yeah
we
can,
you
can
just
add
stuff
to
the
project
file
here.
If
you
want
to
do
extensions
and
then,
if
we
just
you
know,
I
mean
there's
other
ways:
we
can
do
this
too
right,
like
I
could
even
within
here
you
could
do.
We
could
do
something
like
my
extension
and
then
you
know,
provider
exact,
equals.
You
know
my
config
gen
right
and
like
again,
like
there's
different
ways.
We
can
design
this
right.
B
If
we
have
this
the
project
file,
then
then
we
could
like
actually
down
here.
You
can
imagine
in
post
process.
We
do
something
like
you
know:
exact
dot
command,
whatever
right
right,
like
my
config
gen,
and
then
you
know
we
do
something
like
c
dot
set
standard
n
equals.
You
know
whatever
like
rl.items,
you
know
hand
wave
about
how
we
convert
all
the
items.
There's
a
format,
I'd
call
the
right
library
right
and
then
we'd
say
you
know
out
equals
buff.
B
B
I
think
because
it
allows
us
to
you
know,
take
it
allows
us
to
separate,
like
the
orchestration
of
a
bunch
of
different
generators
and
plug-ins
from
the
individual
plug-ins,
which
I
think
is
a
better
overall
design
right,
but
but
if,
if
we
didn't
want
to
take
that
extra
dependency
on
an
orchestrator
and
we're
like
no,
that
adds
a
layer
of
complexity
or
whatever
it
is,
we
just
want
it
to
be
native
and
embedded
like.
B
I
could
imagine
like
doing
a
very
light
embedding
of
an
orchestration
inside
in
itself,
just
by
parsing
out
these
extensions
and
running
them.
D
Okay,
so
from
the
plugin
viewpoint,
the
first
option
you
mentioned
would
be
like
creating
a
binary
that
is
called
my
config
yen
and
it
would
be
piped
by
an
orchestration
system.
And-
and
you
would
forget
about
that-
and
will
I
mean
the
the
final
project-
will
only
have
like
a
couple
binaries
that
are
a
config
yen
and
my
on
the
other
configurations
from
the
different
plugins.
And
they
will
be
run
when
you,
when
you
try
to
deploy
your
system
right.
B
Right
exactly
this
would
look
more.
This
I
mean.
Potentially
this
could
even
be
like
go
run.
You
know
github.com
like
this
and
then
right
and
then
you
can
control
this
so
then,
like
in
the
plugins
we
have
like
require.
B
You
know
my
config
gen
is
v,
you
know
0.1.0,
and
so
in
that
case,
like
bundled
with
the
project,
the
only
thing
we
bundle
with
the
project
is,
you
know
configuring
and
in
theory
we
don't
even
have
to
bundle
convention
with
the
project,
because
we
could
just
in
the
make
file,
go
run
configin
directly
from
another
repo
it
doesn't
actually
have
to
be,
but
but
it
could
be,
but
then
the
other
plugins
like
so,
for
instance,
if
you
were
to
write
them
as
using
that
framework,
I
demonstrated,
then
you
could
just
run,
go
run
on
that
thing
and
then-
and
then
this
is
this
down
here.
C
So
this
seems
really
cool
one,
so
I'm
joe
from
operator
sdk
team.
I
wonder
so.
We've
got
other
phase,
one
plugins
which
what
we've
been
calling
them,
which
know
how
to
scaffold
different
project
types
so
other
than
go.
C
So
I
wonder
like
does
this
same
and
we
might
put
different,
you
know
we
might
have
different
resources
for
some
reason
that
you
would
want
to
use
that
are
not
the
standard
set
of
ones
that
we
use
for
go
projects.
Does
this?
Do
you
think
that
this
could
be
usable
in
non-go
based
projects,
and
it
looks
like
they?
C
They
are
like
if
you
look
at,
if
you
look
at
what
the
operator
sdk
does
for
a
helm
project
versus
a
go
project,
the
customize
config
directory
is
basically
identical,
because
at
that
point
it
doesn't
really
matter
what
the
underlying
language
is.
All
that
matters
is
like
we're,
deploying
some
images
and
some
other
api
resources
to
the
kubernetes
cluster.
C
But
I
wonder
like
would
this
like?
Would
this
be
directly
applicable
to
other
language
types
like?
Would
we
just
be
able
to
use
it
right
out
of
the
box?
No
problem.
B
C
Crds,
that's
a
great
question,
so
no
we
don't
use
controller
gen,
because
control
gen
requires
some
go
types
right
now.
The
helm
crds
are
generated
when
you
run
create
api
and
they
just
say
allow
all
for
helm
in
particular,
if
you
have
a
helm
chart
that
has
a
values.schema.json
file
in
it,
you
can
use
that
to
construct
an
open
api,
b3
schema,
but
it's
not
a
one-to-one.
The
ap,
the
kubernetes
api
server
is
more
strict
than
than
everything
that's
allowed
in
the
api.
V3
schema.
C
B
I
think
yeah
this
will
work
like
there's.
There's,
like
the
you
know,
I'll
qualify.
The
statement
with
like
some
pieces
of
this
will
work
some
pieces
of
this.
We
can
make
better
potentially
like
it's
not
inherently,
not
to
work
as
well
and
in
some
pieces
of
this
right.
If
it's
like
the
controller,
gen
parsing
from
go
files
obviously
aren't
going
to
work
so
I'll,
give
you
a
demonstration
of
kind
of
what
I
mean
I'm
actually
going
to
switch,
which
screen
I'm
sharing
so
so
going
back
to
this
one.
B
This
is
like
your
two
builder
go
project
right,
so
so
in
the
project
file.
Let's
like
so.
This
has
an
implicit
like
the
directory
is
the
current
directory
right.
So
like
let's
say,
I
said
that
you
know
directory
was
temp
or
something
like
that.
Where
there's
you
know
no
go
files
this.
Actually,
that
might
help
that
might
just
blow
up.
Let
me
see,
let's
say
I
make
directory
called
empty
right,
and
so
I
call
the
directory.
B
You
know
empty
so
something
like
that
right
and
then
I
do
now
run
config
gen
and
then
I'll
I'll
give
it
the
you
know,
project
file
here.
B
You
can
see
that,
like
it
still
generates
all
this
stuff,
it
just
doesn't
generate
anything
from
the
go
right
like
there's.
There's
no
custom.
You
know
resource
in
here
because
it
doesn't
like
there's
no
go
in
that
project
right
and
then,
if
I
you
switch
this
back
to
directory
here,
we
should
see
the
custom,
whoops
custom,
resource
definitions,
so
so
yeah
a
large
pieces
of
this
will
work
for
you,
know
non-go
projects
and
we
could
yeah.
B
If,
if
you
come
up
with
some
technique
for
generating
generating
resources
from
other
files
or
generating
custom
resource
definitions
from
something
else,
then
I
believe
it
could
be
composed.
With
this
pretty
easily.
C
Yeah
yeah,
that
was
kind
of
my
question.
I
wonder
we
haven't
encountered
this
in
operator
sdk,
but
well
so
there's
kind
of
two
more
questions
I
have
so
so
one
is
like.
Do
we
think
there's
a
case
where,
like
you
know
the
customized
things
that
we
currently
scaffold
and
these
templates
that
are
in
config
gen,
which
are
kind
of
one
to
one?
B
Project,
oh,
I
see
what
you're
saying
I
think
I
do
I'll
like
to
so
one
thing
different
about
this
than
the
current
approach
is
like
we're
not
actually
scaffolding.
Anything
in
this
case
right
like
at
most,
were
scaffolding,
the
like
project
file,
to
say
the
image
right
that
you
want
to
run
and
this
sort
of
stuff.
In
this
case,
what
we're
actually
doing
is
we're
embedding
all
of
the
logic
inside
a
binary
that
is
executed
and
is
capable
of
producing
the
configuration
right.
B
So
I
guess
the
difference
between
the
scaffolding
approach,
where
you
know
once
it's
scaffolded
your
ability
to
make
a
completely
different
decision
about
the
structure
of
the
project
or
what
sort
of
resources
are
produced
or
that
sort
of
stuff
is
kind
of
gone
right.
It's
difficult
to
say
actually
like
we're
doing
a
new
type
of
scaffolding
and
all
the
old
projects
would
like
to
upgrade
to
this
new
type
of
scaffolding,
but
like,
for
instance,
components
would
be
a
concrete
example
of
that,
like
customized
components
we
could
take
advantage
of
it
would
look
different.
B
B
B
Right,
like
you
know,
or
we
want
to
at
least
enable
that,
with
this
approach
like
making
that
exposing,
that
is
as
simple
as
updating
the
api
to
have
a
new
field
saying
you
know,
you
know
you
know,
split
out
or
multiple
can
multiple
deployments
or
something
like
that
right
and
simply
by
adding
that
field
within
update
the
binary
to
you,
know
and
use
a
separate
set
of
templates
or
do
something
else
right,
but
essentially
produce
those
resources,
so
we're
not
really
locking
ourselves
into
any
particular
set
of
resources
or
the
same
way.
C
So
it's
funny
you're
saying
that
I
I
it
reminds
me
of
the
issues
we
had
in
the
past
with
operator
sdk,
where
we
actually
like
we're
doing
a
lot
of
plumbing
of
things
in
a
binary
which
which
made
operator
sdk
extremely
opinionated,
is
like
here's.
The
way
to
you
know
produce
this
output.
We
actually
backed
off
from
that
we're,
like
you,
know,
no,
let's
hand
control
more
to
the
users
so
that
we
don't
keep
getting
pinged
like
hey.
I
want
to
do
this.
One
custom
thing
with
you
know
the
the
way
that
the
deployment
works.
C
You
know.
Can
you
add
that
code
into
the
api
so
that
I
can
do
that
and
a
lot
of
times
we
end
up
like
either
having
to
try
to
figure
out
how
to
plumb
that
in
or
just
saying,
no
because
we
became
the
controllers
of
all
of
the
templates
and
everything
that's
in
it.
So
I
wonder
if
you
can
sit
like-
and
I
know
like
with
this
like:
yes,
you
can
patch
and
there's
there's,
maybe
some
release
valves
there.
So
so
maybe
that's
a
good
way
to
solve
it.
Have
you
talked.
B
Yeah,
the
api
allows
you
to
disable,
like
that's
kind
of
where
the
fine
grain
here
I'll
share.
Again,
it's
probably
worth
thinking
about
like
what
does
customize
provide
you,
and
is
it
possible
to
provide
something
like
comparable?
An
experience
like
how
does
I
think
your
question
is
maybe
like
how
does
this
degrade
when
we
cannot
provide
the
things
that
the
user
wants
in
the
abstraction
right?
And
so,
like
you
mentioned,
one,
one
thing
is
patching
right
in
like
it's
like.
B
Oh,
I
want
to
set
these
random
fields
right,
so
customize
supports
that
or
because
this
again,
because
this
is
a
customized
plug-in,
we
can
anything
you
can
do
with
customized
to
a
base.
For
instance,
you
can
do
this
thing
or
you
could
use
this
as
a
base
effectively
what
you
know
then
there's
stuff
where
it's
like.
Well,
I
can't
deal
with
customize
because
I
don't
want
like
the
way
you're
generating
that
resource
is
completely
wrong
right,
like
so
the
controller
manager.
B
I
want
multiple
deployments,
for
instance,
and
so
that's,
where
kind
of
these
the
ability
to
disable
like
if
we
have
fine
grain
disable
this
thing
and
you
bring
your
own
right.
I
think,
then,
that
then
the
this
degrades
into
okay,
you
don't
like
the
way
we
did
the
manager
at
all
right,
like
you
can't
patch
it
to
get
it
the
way
you
want
fine,
don't
create
the
manager
instead
create,
and
these
aren't
just
actually
patches,
I
think-
or
maybe
they
are
the
way
you
do
this
like.
B
C
So
you
don't
think
there's
so
I
guess
maybe
as
a
hypothetical,
so
say
someone
you
know
we
get
all
this
out
there
we
get
in
front
of
the
users,
it's
not
the
default,
and
so
you
know,
new
projects
are
now
using
this
versus
the
customized
templates
that
we
scaffold
and
the
user
comes
and
says:
hey
you
know,
can
you
change
config
gen
to
do
x?
What
are
our
responses
generally,
like?
C
No
here's
a
better
way
to
do
it
like
with
it
within
a
customized
pipeline
or
is
it
oh
yeah,
we'll
add
this
one-off
thing
and
maybe
it's
you
know,
maybe
maybe
I'm
just
simplifying
too
much
and
it
would
depend
on
what
the
request
was
but
kind
of
the
default
stances.
B
Like
the
the
non-satisfying
answer
is
it
depends,
but
you
know
different
ways
we
could
like
approach.
This
right
is
this
is
where
the
extensions
come
in
right
and
if
we
say
it
depends
on,
like
kind
of
who
the
user
is
and
and
how
valid
the
case
is
and
and
that
sort
of
thing,
but
I
could
easily
imagine
right
like
if
it's
if
it's
something
like
if
a
user
is
asking,
can
I
have
this
feature
right
like
they're,
that
level
of
competence
where
they're
like
I
I
you
know,
I
would
contribute
this
feature.
B
You
know
I'm
moderately
capable
and
go
right.
Our
answer
would
be
you
know,
here's
how
you
know
write
your
own
framework
run
the
preprocessor.
B
You
know
manipulate
the
resources
as
you
want
and
then
in
the
project
file
in
your
own
project
file,
define
it
as
your
own
extension
right
and
now
you
don't
have
to
talk
to
us.
You
can
do
absolutely
anything,
you
want,
you
can
add
or
remove
resources,
and
you
can
configure
your
own
project
free
file
to
like
not
generate
resources,
to
simplify
how
some
of
our
created
that
that
would
be.
B
I
guess
if
someone
is
capable
of
programming
their
own
thing,
if
it's
like
something
like
a
customer
where
they
don't
want
to
create
the
thing
they
just
need
you
to
be
able,
they
just
want
the
capability,
then
I
think
our
answer
would
still
if
it's
if
it
feels
like
feature
creep,
and
it's
like
okay
for
this
one
use
case
that
isn't
typically
general,
then
I
think
what
we
need
to
do
is
figure
out.
How
do
we
expose
the
ability
for
you
to
do
it
with
customize?
B
B
I
want
that,
but
I
don't
want
the
roll
or
vice
versa
right.
Okay,
like
can
we
split
this
out
into
two
things
right
and
then
you
disable
the
creation
of
one
and
then,
and
then
you
use
customize
use
this
as
part
of
customize
to
bring
whichever
one
we
didn't
we
stopped
generating,
for.
You
seems
reasonable.
C
And
what
so
like
another
example
I
can
think
of
is
like
in
the
deployment
and
maybe
we're
getting
into
details
here,
and
this
is
pointless
but
like
in
the
deployment
where
we
have
the
resources
that
we
have
like
hard-coded.
Basically,
so
I
can
easily
see
someone
saying
like
yeah
those
resources
don't
work
for
me.
I
want
to
change
those.
A
B
Let's
look
at
it
like
sorry,
I'm
switching
back
and
forth
here
this.
So
this
starts
to
get
into
what
is
the
api
right?
Look
like
right
so
say
we
had
patches
directories.
B
Right
and
then
you
know,
this
is
patches
right,
other
patches
and
then
say
we
had
something
like
additional
resources
directories.
B
So
what
can't
you
do
if
you,
if
you
can
give
us
additional,
if
you
can
tell
us
not
to
generate
resources
and
bring
your
own
if
you
can
apply
patches
to
the
resources
we
generate
and
then,
if
you
can
run
this
in
a
customized
pipeline,
so
that
you
can
do
common
labels
common
annotations,
then
the
thing
you
don't
get
is
I
mean
the
I
can
imagine
the
ux
is
in
one.
B
I
think
90
percent
of
the
time
ux
will
be
better
if
you're,
a
user
where
you're
like
you
know
what
I
want
to
change.
I
want
to
change
some
random
field
in
the
manager
and
I
don't
want
to
create
a
new
patch
file.
I
just
want
to
edit
it
in
place
in
a
scaffolded
file.
A
I
think
one
of
the
things
that
I
that
seems
to
be
here
is
it's
much
more
obvious
as
to
like,
what's
what's
safe,
to
change
right,
like
at
least
to
me,
the
customized
directory
was
kind
of
it's
a
little
bit
impenetrable,
there's
a
lot
of
like
weird
like
interlocking
dependencies
of
files,
whereas
this
feels
like
it's
a
lot
more
like
linear.
A
Almost
like
I
know,
config
gen
is
going
to
spit
out
some
files.
I
I
just
have
one
set
of
patches.
Everything
in
the
patches
directory
is
something
that
I
own,
as
as
a
user
or
whatever
so
like.
I
can
change
that
as
needed,
and
I
know
like
I,
I
am
responsible
for
those
files.
It's
not
some
weird,
like
quirk
of
like
oh
kubernetes,
requires
this,
so
this
patch
file
must
always
be
here,
even
though
like
and
it's
a
patch
file
due
to
some
weird
quirk
of
customize,
or
something
like
that.
C
B
E
A
A
Oh,
I
I
just
want
to
say
like
if
we
have
any
final
comments
on
this
for
now,
that's
fine
make
them
quick.
We
have
10
minutes
and
there's
one
more
thing
that
I
think
we
should
really
cover,
because
we
said
we
were
going
to
cover
it
last
meeting
and
we
should
probably
move
the
rest
of
this
discussion,
maybe
offline
to
a
design
pro
like
just
like
a
quick
proposal
or
or
the
pr
or
something
like
that.
B
I'll
put
together
a
cap
kept
I'll
put
together
a
cap
I'll
take
the
feedback
I
got
here
I'll,
put
together
cap
and
then
I'll
present
again,
when
the
cap's
done
at
a
follow-up
couponer
meeting
thanks
ali.
A
Yeah
sorry
to
cut
you
off
there,
I
just
want
to
make
sure
we
get
this
one
last
thing
in
and
if
we
have
any
more
time
we
can
go
back
all
right.
So
the
last
thing
that
I
wanted
to
cover
because
we
said
we
were
going
to
cover
it
for
last
meeting
and
we're
overdue
for
a
while
is
just
release
check
on
controller
runtime
and
controller
tools
so
for
background.
A
We
said
last
meeting
that
if
we,
if
we
didn't,
have
any
blockers
in
between
the
last
two
meetings,
we'd
go
ahead
and
do
a
controller
runtime
release
today.
So
I
have,
I
have
two
things
say:
maybe
here
I
don't
think
there's
currently
any
blockers
from
controller
runtime
that
I
saw
in
my
brief
glance
yesterday.
A
A
C
E
Great,
so
this
this
one
in
particular,
is
bumping
the
default
and
tests
kate's
version
to
119.2,
we
bumped
all
the
other
communities
dependencies
and
this
one's
still
on
16-4.
So
this
should
probably
go
in.
A
E
I
don't
think
so.
That's
in
is
that,
in
this
is,
is
this
in
controller
runtime
or
controller
tools.
A
That
was
in
control
runtime.
Basically,
the
api
server
sends
us.
Web
hook
requests
in
a
particular
version
and
we
can't
handle
the
v1
version
right
now
or
we
could,
and
then
they
removed
conversion
between
the
two
that
we
were
relying
on
to
handle.
A
Has
a
like
just
splits
it
and
duplicates
it,
so
you
have
two
different
handlers:
okay,
I'll,
take
another
look
at
this
one.
A
E
A
A
E
A
Jordan
seems
to
imply
that
we
were
slightly
doing
the
wrong
thing
before
and
getting
away
with
it
by
accident
yeah.
It
wasn't
quite
perfect
before.
A
So
like
we,
we
may
want
to
intentionally
say
like
look.
It
turns
out
that
we
were
doing
the
wrong
thing
before
the
way
to
fix
this
in
your
code
is
add
this
like
add
this
extra
line
that
handles
both
if
you're
using
the
high-level
web
hooks,
we
handle
it
for
you,
if
you're
using
the
low-level
web
hooks
you
have
to
handle
the
message
yourself
like
you
have
to
handle
the
difference
yourself.
A
C
A
C
A
Yeah
yeah,
okay
yeah,
so
we
we
need
we
should
in
our
re.
We
like
we
should
have
a
good
answer.
Kind
of
is
my
point
here
like
if
we're
making
that
we're
we're
gonna
need
to
make
that
break
in
some
capacity.
It
looks
like
because
of
the
way
upstream
works
change
things.
We
just
need
to
have
a
good
answer
as
to
like
why
and
what
the
migration
path
is
right
like
if
we
were
like,
if
we
mostly
supported
v1,
your
thing
was
working
now,
it's
not
and
there's
no
passive
for
b1
anymore.
A
Okay,
yeah
I'll,
take
another
look
at
this
this
afternoon.
I
guess
and
then
we'll
resolve
that
and
resolve
the
update
and
test
dependencies
as
well,
and
then
I
guess
we
should
be
good
to
do
the
release.
E
Yeah,
can
you
let
me
know
when
you
respond
and
I
can
help
out
with
whatever
needs
to
be
done.
A
Sure
who
would
just
to
make
sure
I'm
not
confusing
someone's
voice
eric
that
was
okay,
yeah!
That's
what
I
thought
I
just
wanted
to
make
sure
yeah
yeah
we'll
do.
E
Awesome
thanks
was:
were
there
any
other
pull
requests
or
issues
that
anybody
would
like
to
put
forth
to
get
results?
E
Okay,
we
can
go
through
these.
I
guess
I
don't
know
of
any
help
anything
else
that
needs
to
get
in.
A
A
I
don't
see
anything
here,
so
I
think
probably
we
just
go
to
stable.
D
E
E
Okay,
I
I
gotta
drop
for
another
meeting,
thanks
for
going
through
that.