►
From YouTube: Extending the Kubernetes API: What the Docs Don't Tell You [I] - James Munnelly, Jetstack
Description
Extending the Kubernetes API: What the Docs Don't Tell You [I] - James Munnelly, Jetstack
At the heart of Kubernetes is its API. Whilst on the surface it may appear relatively simple to use, under the hood is a beast of complex conversions, codecs and generators. In this talk, I'll show you how the Kubernetes maintainers have created their own tooling to make this process easy when contributing to core, and how you can use this to build your own custom controllers, operators and API servers. I'll then demonstrate this technique with a pager extension to Kubernetes.
About James Munnelly
I'm a Solutions Engineer at Jetstack, which involves helping customers bend and break Kubernetes to their will. I've created a number of extensions to Kubernetes core, including cert-manager (a kube-lego successor), Navigator (DBaaS for Kubernetes), and built my own simple cloud provider for bare metal clusters. I mostly spend my time browsing GitHub and then tweeting about it
Join us for KubeCon + CloudNativeCon in Barcelona May 20 - 23, Shanghai June 24 - 26, and San Diego November 18 - 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.
A
B
A
Welcome
and
thank
you
for
coming
along
to
extending
Cuba
Nettie's,
what
the
Doc's
don't
tell
you.
Funnily
I
wrote
this
well
I
read
this
title
a
few
months
ago
and
the
doctor
didn't
tell
you
a
lot
of
this
stuff,
then
we're
gradually
getting
better
at
actually
documenting
some
of
this
stuff.
So
you
might
be
able
to
find
some
bits
in
the
documentation
now.
You
should
anyway
complain
us
if
not
so
yeah
Who
am
I.
Oh
a
jet
stack
so
I'm
from
a
uk-based
Cuban,
FTS
consultancy.
A
So,
first
of
all
like
what
is
all
of
this,
and
why
do
it?
Yeah
kubernetes
has
got
a
really
nicely
formed.
Api
I
think
it
has
its
problems,
occasionally
I'm
sure
many
of
you
know
run
into
issues
at
points,
but
you
know
it's
relatively
consistent
between
types.
You
interact
with
everything
in
a
similar
way.
You
create
your
manifest.
It's
all
nice
and
declarative,
and
things
eventually
happen.
They
converge.
A
A
It's
got
a
lot
of
tooling
for
building
all
of
these
reconciliation
loops.
So
you
probably
hear
a
hell
of
a
lot.
This
desired
versus
actual
state
in
kubernetes
yeah.
The
kubernetes
project
itself
has
a
lot
of
code
helpers
utilities
to
actually
help
building
all
of
this,
and,
of
course,
we've
got
the
CLI.
We
all
know
and
love
cube,
CTL
yeah,
so
we
have
a
lot
of
things
in
the
project
and
we
can
kind
of
reuse.
All
of
this.
A
We
can
extend
yeah,
there's
a
number
of
examples
of
this
out
there
I
mean
the
NCD
operator
was
probably
one
of
the
first
things
I
remember
hearing
about,
but
now
even
the
kubernetes
project
itself,
large
parts
of
it
are
implemented
through
extensions,
yeah
and
gradually
more
and
more.
Obviously,
this
whole
track
all
day
is
about
this.
It's
it's
becoming
a
big
big
deal,
extending
Cuba
Nettie's,
and
it
lets
us
do
things
like
this
I
think
this
is
kind
of,
in
my
mind,
the
most
basic
way
of
looking
to
it.
A
A
A
A
You
can
go
and
create
a
role
binding,
a
role
that
works
and
operates
on
your
types
and
mean
that's
pretty
powerful,
it
seems,
might
seem
insignificant
initially,
but
you
know,
as
you
start
to
grow,
you
don't
want
20
different
authorization
systems,
and
so
you
can
start
using
extensions
from
all
over
writing
your
own
and
manage
them
all
in
the
exact
same
way
and
yeah.
That's
that's
pretty
great
and
yeah
to
me.
It
just
kind
of
feels
natural.
You
know
cube
CTL
get
my
type,
that's
great.
A
So
how
do
we
actually
do
this,
though?
We've
got
custom
resource
definitions,
so
these
are
a
nice,
quick,
easy
way
to
add
a
new
type.
We've
all
seen
it
I'm
sure
well,
I
hope
anyway,
and
then
you
know
it's
good,
it's
quick.
It
gets
you
up
and
running,
but
there's
a
few
things
we
don't
have
with
that.
We
don't
have
the
versioning
that
we
just
spoke
of
just
yet
admission
control.
We
kind
of
do
have
these
now,
with
things
like
web
hooks
coming
out.
We
don't
have
defaulting
on
fields
and
so
on.
A
So
if
this
isn't
set
then
make
it
this,
we
don't
get
that
with
CR
DS
right
now,
anyway,
and
there's
one
other
option
which
is
custom
api
service,
so
you've
probably
seen
cube
aggregator
being
able
to
put
something
behind
the
standards,
sounded
kubernetes
api
and
have
it
act
as
if
it's
part
of
you
know,
cuba,
Nettie's
core.
Behind
the
scenes,
you're
you've
got
proxies
going
roundabouts
all
over
the
place,
but
that
complexity
is
hidden
from
the
end-user
to
make
a
custom
API
server.
Though
it's
a
bit
more
work.
A
We
have
to
actually
write
our
custom,
API
server
and
yeah.
It's
there's
a
bit
more
of
a
learning
curve
and
just
you
know,
keep
CTL
create
my
custom
resource
yeah,
but
it
is
very
similar
to
how
API
is
in
kubernetes
are
already
done.
You
know
the
actual
kubernetes
api
server,
it's
based
on
the
same
code
that
you
can
build
your
own
API
server
from
so
you
get
a
very
very
you
know.
All
of
these
similarities
are
right.
A
There
you
get
your
admission
control
and
everything
else
works
as
normal,
and
we
can
do
things
like
versioning
downside
of
this.
We
do
need
to
actually
kind
of
persist.
Some
data
somewhere.
We
can
no
longer
just
chuck
it
at
the
API
server
and
it
goes
away.
We
need
EDD,
CD
or
the
like.
Well
EDD.
That's
it
right
now
to
store
this
data.
It
has
to
go
somewhere.
So
there's
a
definitely
more
of
an
onus
on
your.
You
know,
cluster
administrators,
the
people
using
your
extensions.
A
A
But
they
both
do
require
some
supporting
code,
that's
supporting
code.
However,
we
don't
have
to
write
all
ourselves,
there's
some
bits
we
do
and
some
bits
we
don't
and
I
hope.
I
really
hope.
People
are
aware
of
all
the
generators
in
the
Kuban
''tis
project.
Sig
api
machinery
do
absolutely
great
work.
Putting
all
this
together
and
it
really
is
the
you
know
supporting
it,
supports
all
of
the
kubernetes
project,
I
think
anyway,
it
you
know
everything
works
together
and
yeah,
but
this
is
the
API.
A
This
is
a
really
cool
piece
and
getting
it
right
and
consistently
right
between
all
of
these
different
API
groups.
All
these
different
versions
is
really
important,
because
if
you
had
a
bug
in
say,
one
API
groups,
client
that
can
get
pretty
difficult
to
track
down
so
generating
code
in
a
consistent
way
is
important.
A
So
a
lot
of
you
seen
client
go
again.
I'd
have
thought
and
client
go
ultimately
at
its
core.
Is
a
client
set,
so
you
know
it's
a
rest
client
and
introduces
informers
and
Lister's,
and
all
of
these
other
utilities
fare
building
and
extending
against
Kiva
Nettie's
and
we'll
get
into
kind
of
what
these
things
mean
and
do.
But
this
is
well,
it's
not
just
useful
for
building
extensions
to
call
kubernetes
types,
but
it's
kind
of
essential.
You
could
just
do
it
all
through
a
rest
client.
A
You
know
you
can
even
do
it
with
curl
and
bash,
but
it's
you
end
up
with
inconsistencies
and
how
everything
works.
So
when
we're
writing
our
own
types,
we
can
generate
these
ourselves.
Client
go
a
large
majority
of
it
is
generated
and
we
can
do
exactly
the
same
and
you
can
go
from
kind
of
nought
to
a
project
in
30
minutes
once
you
get
the
hang
of
it,
and
this
is
just
a
list.
I
don't
think
this
is
exhaustive.
A
This
is
a
list
of
some
of
the
generators
you
see,
so
we've
got
client
generators
generating
that
restclient.
You
know
nice
typed,
go
conversion
generators
so
when
we
need
to
do
these
breaking
changes
got
deep
copy
generators,
which
are
it's
more
of
a
technical
thing
here.
But
you
know
if
you
want
to
just
take
a
copy
of
the
struct
and
start
working
on
it
again.
You
need
deep
copies
defaulters,
as
we've
mentioned
go
to
protobufs,
so
we
need
to
generate
some
protobuf
definitions,
for
our
go
structures
go
to
protobuf.
A
Does
that
it's
kind
of
weird,
because
you'd
normally
write
your
proto
bar
first
and
generate
the
go?
We
don't
do
that
with
kubernetes
yeah
and
some
more
we've
got
informers
Lister's.
So
this
is
like
a
nice
cache
when
you're
writing
your
extensions,
you
don't
want
to
be
hitting
the
API
server
constantly
for
every
single
loop
because
it
gets
really
expensive
on
the
network,
as
it
doesn't
scale.
Well,
yeah
and
a
few
more
open
API.
It's
like
the
swagger
specs.
We
can
generate
specifications
for
the
types
there.
A
To
do
this.
We
write
our
types
go
file.
We
use
comments
to
give
it
more
information
here.
So
like
telling
it
whether
it's
a
namespace
tree
source
or
not,
and
so
on
and
saying
whether
to
generate
a
client
for
this
particular
structure
and
kind
of
just
hit
run
on
the
generators
and
off
we
go.
It's
pretty
convenient
and
pretty
easy
easy.
A
So
yeah
don't
write
this
code
yourself,
I've
seen
a
number
of
projects
around
where
they
have
they've
either
tried
to
write
some
parts
of
it.
I've
never
seen
someone
writing
for
me
yet,
but
hey,
maybe,
but
yeh,
don't
don't
go
and
write
this
yourself
because,
honestly,
it's
so
much
easier
to
generate
it
and
it's
so
much
more
consistent.
It
gives
you
the
runway
for
the
future
too.
You
know
you
can
generate
it
against
the
latest
version
of
the
generator
and
you
keep
up
to
date
with
the
latest
things
in
cuba,
Nettie's
so
I've
put
together.
A
Example,
application
kind
of
demonstrate
all
of
this,
which
is
the
API
pager
demo
I.
Did
this
talk
in
London
without
the
API
server
which
you'll
see
soon,
and
this
is
kind
of
an
extension
of
it
so
Zul
on
github,
under
my
name,
space
you'll
put
the
link
up
in
a
minute.
I
think
it's
towards
the
end,
so
it's
a
small,
simple
pager
for
Cuba
Nettie's.
This
is
not
something
no
to
go
and
use
as
a
pager
in
Cuba,
Nettie's,
really
I.
A
Guess
you
create
an
alert
resource
in
the
API
server
and
you
get
alerts
from
pushbullet.
If
anyone
knows
pushbullet,
it's
a
little
paging
application
and
yeah
here's,
the
link
I
did
put
on
there.
So
I'll
quickly
show
you
that
running
just
so
we're
all
on
the
same
page,
so
I've
got
a
cluster.
This
is
me
making
sure
the
internet
works
first
yeah,
so
I've
got
a
cluster,
a
gku
cluster
and
I've
written
a
helm
chat
for
this
pager.
A
There
we
go
cool
and
you
can
see
there.
We've
deployed
our
service
accounts,
our
vac
roles
and
our
controller
and
API
server.
So
when
I
go
get
pods
in
the
pager
namespace
just
probably
bump
this
up
slightly,
we
can
see
here
now:
we've
got
our
API
server
and
controller
running.
We
can
see
here
we'll
see
a
lot
of
things.
We
can
see.
We've
actually
registered
this
with
the
cube
aggregator
soo.
A
A
I'm
creating
a
dirt
and
shirt
on
my
phone.
You
can
see
there,
we've
got
an
alert
come
through.
Yeah
I
really
hate
that
bit,
because
my
face
appears
very,
very
big
on
the
screen
and
cool.
So
that's
lost
my
slides
watching
keynote
earlier.
I
thought
I
closed
all
my
windows.
Clearly,
not
here
we
go
so
yeah.
That's
the
pager!
That's
what
we're
working
with
right
here.
So
what
have
I
used
to
do?
This
I've
used
the
client
generator
conversion
generator
deep,
caca
generator,
Informer
and
Lister.
So
what
is
all
of
this?
A
So
first
we've
defined
like
this,
so
we
have
our
type
alert:
we've
got
our
standard,
metadata
blocks,
type
metadata
and
then
a
spec
and
a
status
just
like
you
see
with
other
cuba
Nettie's
types.
This
is
a
really
simple
one.
We
have
our
message
as
part
of
the
spec
and
then
the
status
at
the
end
of
AIDS
yeah
and
the
status
just
records
a
boolean,
which
is
whether
or
not
the
message
has
already
been
sent,
because
these
types
will
persist
in
the
API.
We
have
a
declarative
API
in
kubernetes.
They
don't
just
go
away
afterwards.
A
We
could
delete
them.
Maybe
that
gets
a
bit
racy
there,
potentially
so
yeah
we've
defined
these
types.
There's
some
extra
comments
that
go
in
here
and
we'll
see
those
in
a
second
and
then
we
run
the
generators
so
follow
the
rules
with
these
generators.
If
anyone's
used
them
already,
you
might
have
run
into
random
panics.
You
might
have
not
got
the
code
you
want
at
the
end,
you
have
to
follow
the
rules
and
these
work
they're
their
depth.
They're
documented
in
I
think
the
client
go
repository.
A
A
Our
client
page
of
V
1,
alpha
1,
dot
alerts
and
then
namespace
and
we
can
do
an
update
and
under
the
hood,
that's
hitting
a
REST
API
and
it's
actually
going
to
go
and
perform
this
update
for
us
in
form
a
generator.
So
I
don't
know
how
many
people
are
using
Informers
right
now,
but
you
want
to
know
when
something
in
your
API
server
has
changed.
That
is
the
core
of
this
reconciliation
they
desired
and
actual.
A
So
here
we
add
an
event
handler,
and
we
say
when
something
has
been
added:
when
a
new
resource
is
added,
we
queue
it
to
be
processed
when
it's
updated.
We
do
a
quick
check
to
see
if
it's
actually
changed,
because
there's
not
a
guarantee
of
you
know
once
only
once
delivery
here.
This
can
be
called
multiple
times
multiple
times,
which
is
why
you
have
to
always
look
at
the
desired
and
the
actual
state
of
the
world
and
writing
these
and
a
simple
delete
function
as
well,
so
responding
to
your
resource
going
away
conversion
generator.
A
Now
this
is
an
exciting
one.
I
think
if
you
get
excited
about
api's
and
maintenance,
so
this
is
one
example
say:
we've
written
our
v1
of
our
elasticsearch
cluster
resource
type
and
we
thought
we
could
just
have
a
simple.
You
know
three
data
nodes,
three
ingest
nodes
so
on,
and
we
want
to
change
that
to
something
more
like
what
we
see
on
the
right.
Conversions
allow
us
to
do
this
without
causing
massive
problems
for
our
users.
A
The
users
can
still
go
and
create
the
old
resource
type
and
everything
continues
working
with
the
next
bit
and
that's
like
super
powerful.
It
means
you
can
more
confidently
push
out
an
API
and
get
users
using
it
without
thinking
that
you're
gonna
go
and
break
everything
next
week,
when
you
realize
that
you've
done
something
wrong
and
will
see
an
example
this
in
a
minute.
So
let's
actually
take
a
look
at
some
of
this
code
quickly.
First
I
did
say
it's
a
bit
of
a
technical
talk,
so
this
is
the
repository
here.
A
Yeah
I've
already
linked
to
it,
and
you
can
see.
This
is
a
very,
very
simple
controller
and
if
I
jump
into
it,
I'll
have
to
talk
you
through
it.
We
can
see
here
the
actual,
creating
our
Informer,
so
we
grab
an
informer
here
from
our
shared
informer
Factory.
Now
this
allows
us
to
build
multiple,
different
control
loops
that
all
use.
A
These
same
types
and
not
kind
of
have
to
watch
20
times
it's
only
one,
there's
a
nice
big
shared
cache,
but
we
here
we
just
add
our
new
function,
so
in
queue,
update,
delete
and
so
on,
and
the
reason
why
we
actually
in
queue
things
we
don't
directly
do
stuff
here.
Instead
of
we
don't
like
to
send
the
notification
immediately,
we
have
a
work
queue
internally
to
the
application,
and
this
is
all
part
of
client
go.
You
can
see
just
a
little
bit
further
down.
A
You
can
see
that
we're
actually
reading
messages
off
of
a
queue
periodically.
We
have
like
a
one,
two
three
four
workers
and
that
prevents
that
stops
you
having
to
where
it
stops.
You
processing
the
same
item
twice
at
the
same
time,
which
is
quite
a
big
thing.
You
know
you
don't
want
to
be
otherwise.
I
could
end
up
getting
two
alerts
instead
of
one
just
just
then,
when
I
sent
that
and
it
does
a
number
of
other
things
too.
A
You
can
see
here
in
our
sync
function,
so
our
sync
function
is
called
each
time
that
a
message
is
read
our
resources
right
off
of
the
queue
and
the
first
thing
we
do
is
check
to
see
if
it's
already
been
sent
and
if
it's
already
been
sent,
we
can
just
kind
of
return
nil.
Here
we
don't
error,
we're
done,
there's
nothing
more
to
do.
Otherwise
we
prepare
our
new
message
and
we
go
and
post
this
note
and
that's
how
it
gets
through
to
my
phone.
A
So
it's
pretty
simple
there
and
at
the
end
here,
if
we
have
just
sent
the
message,
we
now
need
to
actually
mark
it
as
sent
in
the
status,
so
we
set
sent
here-
and
this
is
where
the
deep
copy
comes
in,
because
a
minute
ago,
I
mentioned
this
shared
cache.
Well,
we
don't
want
to
modify
resources
in
that
shared
cache
because
it
can
cause
all
kinds
of
inconsistencies.
So
we
use
the
deep
coffee
function
here,
which
was
automatically
generated
by
the
deep
coffee,
gen
and
then
modify
our
resource
and
then
called
update
great.
A
So
where
does
the
API
server
come
into
this
well
yeah?
Sorry,
first
of
all
that
tip
don't
modify
resources
in
the
cache
bad
things
can
happen
and
you
probably
won't
see
the
bad
things
happening
for
quite
a
while
and
then
they
suddenly
will-
and
you
won't
know
why
and
yeah-
it's
not
good,
not
good
cool.
So
I
was
talking
about
these
conversions
so
creating
the
new
version
of
our
API
v1
beta
one
so
I'm,
you
know,
I've
had
a
breakthrough.
I've
realized
message,
isn't
quite
what
I
want
I
want.
A
Content
and
I
want
a
title
field
too,
so
I'm
going
to
launch
my
v1
beta
one
version
of
the
API
yeah,
so
jumping
to
that
just
so,
you
can
see
what
I'm
doing
here.
This
is
our
alpha
version
here.
I've
got
a
cube
con
alert
and
this
is
our
beta
version.
You
can
see
the
title
has
switched
sorry,
we've
added
the
title
field
and
the
field
content
has
changed.
So
thanks
to
these
conversions,
you
know
this
is
possible.
So
I
can
show
you
here.
A
A
So,
first
of
all,
that's
that
we
can
see
we've
got
content
and
title
set
and
now,
if
I
want
to
get
this
in
alpha
1
format,
I
can
to
just
by
changing
that
there
and
you
can
see
this
same
resource.
It's
got
the
same,
UID
everything's
the
same,
but
the
API
server
can
dynamically
convert
that
for
us.
So
your
old
controller
that
is
written
against
the
alpha
version
of
the
API
will
continue
to
work
if
someone's
created
something
in
the
beta
format.
So
you
get
this
kind
of
nice
seamless
upgrade
process.
A
You
don't
need
to
do
everything
all
at
once.
You
know
turn
it
off
and
then
spin
it
all
back
up.
It
all
happens
for
us,
so
yeah
I'll
quickly
show
you
how
these
actual
conversions
are
done
because
I
think
it's
something
you
don't
actually
there's
a
lot
of
complexity
in
Cuban
Etta's
itself,
and
it
really
does
make
it
hard
to
see.
So
here
we
have
our
conversions
and
we're.
Basically,
a
lot
of
this
can
automatically
be
generated,
but
some
bits
you
know,
content
to
message.
A
A
generator
is
never
going
to
be
able
to
work
this
out.
So
we
do
have
to
help
it
out
here
and
tell
it
how
to
do
it.
So,
if
I
just
jump
in
start
into
the
beta
version
here,
we
can
see
first
of
all,
we're
converting
the
alert,
spec
and
we
say
out
content
equals
iNDOT
message.
So
it's
a
simple
one
equals
the
other
we're
just
mapping
these
two
fields
together.
A
But
how
do
we
manage
that?
So
there
are
external
API
versions
and
you'll
see
this
in
cube
Nettie's.
If
you
go
into
kate
diag
work,
sorry
into
the
actual
Cuba
Nettie's
repo
you'll
be
able
to
see.
We
have
external
versions
and
we
have
internal
versions
well,
an
internal
version,
so
the
external
ones,
the
ones
that
you
actually
see
they're
the
ones
that
you
can
request
and
do
things
with,
whereas
the
internal
API
version
is
used
solely
internally
by
the
API
server.
Now
that
is
kind
of
a
basis
for
conversions.
A
You
don't
write
a
conversion
between
v1
l4,
1
and
V
1
beta
1.
You
write
a
conversion
between
the
internal
version
and
the
alpha
version,
and
then
the
internal
version
and
the
beta
version
and
back
and
the
API
server
can
then
use
that
internal
version
as
kind
of
a
way
to
go
anywhere.
So
if
you
need
to
go
from
V
1,
alpha
1
to
beta
2,
V,
1
or
anything,
it
can
just
go
from
the
external
to
the
internal,
to
whichever
other
external
version
you
like,
and
we
can
see
that
here
in
the
pager
demo.
A
We
have
our
internal
version
to
find
here,
there's
a
few
differences
that
you'll
notice
there's
no
JSON
struct
tags.
So
if
we
go
here,
we
have
all
of
this
JSON.
That's
because
we
do
actually
convert
this
to
Jason
at
some
point.
But
the
internal
version-
you
don't-
and
this
is
one
of
the
rules
that
you
have
to
follow.
If
you
go
and
put
some
JSON
tags
here,
the
generator
it
doesn't
even
our
nicely
it
just
doesn't
it
doesn't
do
what
you
expect
it
to
do.
A
It
tries
to
make
it
in
an
external
internal
version,
and
things
start
to
fall
apart
a
little
bit.
Maybe
that
will
get
better
I,
don't
know,
and
you
can
see.
We
actually
have
these
tags.
We
say
gen
client
here,
so
this
is
telling
the
client
generator
to
go
and
generate
the
client,
so
yeah
cool
I've
jumped
ahead.
There
take
a
look.
We
just
did
so
you
define
conversions
between
the
external
versions
and
the
internal
versions.
That's
it
never
between
the
different
external
versions,
so
yeah
kind
of
wrapping
all
this
up,
the
API
aggregation
really
is.
A
It
makes
it
it's
far
more
flexible.
You
can
do
a
hell
of
a
lot
more
with
it.
When
you
start
writing
your
admission
controllers
and
so
on.
So,
as
a
resource
is
submitted
to
the
API
being
able
to
change
that
or
modify
it
manipulator
or
even
reject
it,
you
can
get
that
with
API
aggregation,
obviously
don't
generate
you
don't
write
your
code
by
hand,
there's
no
need
generate
it
and
yeah.
A
So,
following
the
rules
not
modifying
the
cash
and
defining
your
conversions
between
the
different
boats
between
the
external
and
the
internal
version,
so
yeah,
this
is
a
nice
big
slide
with
tons
of
different
things.
We've
got
Stefan
actually
sitting
at
the
front
here.
He's
done
a
great
blog
post
on
all
of
these
conversions
and
I'd
highly
recommend.
Sorry
on
all
these
generators,
I'd
highly
recommend,
taking
a
look
if
you're
gonna
be
doing
this,
but
yeah
and
yeah
that's
kind
of
wrapping
up
there.
A
A
So
the
question
was:
if
you
do
cogeneration,
does
it
work
with
an
older
version
of
kubernetes,
so
it
does
work
with
an
old
version.
It
does
work
with
older
versions
if
you're
a
their
remote
API
server
is
a
different
version.
You
do
need
to
use
the
right
version
of
the
generators
with
the
right
version
of
the
kubernetes
api.
Is
it's
like
dependency.
Pinning
is
important,
but
yeah
you
can.
It
does
work
backwards.
Yeah.
A
Yep,
so
the
question
there
is:
why
did
I
do
I
think
the
reflect
DP
equal
there
I
actually
think
you
are
right.
We
recently
put
together
a
sample
controller,
and
that
was
pointed
out
to
me
as
well
that
we
can
just
look
at
the
resource
version
instead
and
it's
yeah.
It
is
more
efficient
because
that
update
function
called
quite
a
lot.
C
A
So
so
the
question
there
is:
does
everything
will
have
to
be
in
one
repository?
Do
we
have
to
have
our
controller?
Our
API
server
are
tied
together.
No,
you
don't.
You
know,
there's
a
certain
amount
of
repository
infrastructure.
You
need
to
make
sure
you've
got
to
manage
that,
but
it's
just
the
same
as
every
other
project.
There's
nothing
specific
to
this
that
enforces
it.
You
could
generate
elsewhere.
A
A
It's
just.
It
becomes
kind
of
harder
to
understand
your
code
and
read
it
straight
away
because
you
are
just
using
some
cache
new
shared
index.
Informer
I
think
is
the
function
and
your
shared
Informer
factory
as
well.
That
does
rely
upon,
like
some
typed
generated,
typed
informants,
but
actually
under
the
hood
to
share
in
the
shared
informer
factory
does
just
return
one
of
these
kind
of
generic
looking
types
and
the
informer
generator
ultimately
is
generating
you.
A
These
factories
that
yeah
make
easier
I
can
quickly
show
you
actually
the
output
of
that,
because
it
is
a
bit
of
a
confusing
one
because
the
Informer's
it
is
a
shared
resource
here.
So
ultimately
it
automatically
the
generator
automatically
writes
this
bit
for
you.
So
you
can
see.
We
still
have
the
cache
new
shared
index
Informer
and
then
this
list
function
and
watch
function
yeah.
This
is
written
for
you
already.
Basically.
A
A
So
yeah
documentation
in
this
area
has
been
weak
in
the
past
and
it's
something
we're
all
trying
to
improve.
We
actually
had
a
meeting
just
yesterday
to
try
and
get
some
more
things
together.
I
think
there's
gonna
be
some
blog
posts
on
it.
We've
got
the
sample
controller
repository
now,
I'm,
not
sure
if
you've
seen
that
it
doesn't
go
enough
into
depth,
I
think
on
what
each
generator
does
and
how
and
why.
But
it
does
give
you
a
bit
of
a
blueprint
to
doing
it.
A
There
is
also
a
new
like
script,
which
will
eventually
become
a
full
binary,
like
an
application
which
will
take
care
of
actually
running
the
generators
for
you,
because
they've
all
got
different,
Flags
different
arguments
and
so
on
so
I
think
that
said,
there's
generate
internal
groups
and
generate
external
groups.
I
can't
remember
the
exact
name.
You
can
actually
see
just
here,
I'm
no
longer
actually
having
to
cool
these
generators.
A
Myself
I
instead
just
call
the
generate
internal
groups.
Script
from
the
code.
Gen
package
tell
it
where
to
generate
the
code
into
so
PKG,
slash,
client,
and
then
we
point
to
at
my
internal
and
actually
the
directory
containing
my
external
files.
And
you
can
see
we
just
give
it
a
list
of
groups
and
versions
to
generate
for
so.
A
Yep
so
the
way
I'm
yeah,
because
I
need
the
actual,
so
this
will
comes
from
this
Kate's
io
/
code
generator
package,
so
I,
basically
vendor
this
and
using
my
I
think
this
is
with
Det
I've.
Basically
just
got
sorry
I'm,
Tamil
syntax,
highlighting
in
sublime
I
list
these
as
required
packages,
and
then
I've
got
all
of
the
dependency
pinning
below
so
just
making
sure
I
stick
to
these
versions.
A
How
do
we
validate
the
CR
okay,
so
this
is
actually
one
thing
so
by
having
this
API
server
and
writing
ourselves,
the
API
server
is
able
to
do
that.
Validation
automatically,
and
that
happens
as
part
of
the
API
server
library
that
you've
build
your
API
servers
from
because
it's
actually
got
a
copy
of
that
type
it
can.
A
It
can
automatically
like
fail
if,
if
there's
any
kind
of
an
issue,
so
it's
kind
of
done
for
free
when
you
do
API
aggregations,
if
you
needed
to
do
anything
more
advanced
than
that,
you
can
write
in
a
mission
controller
that
could
check
things.
But,
for
example,
if
I
come
along
here
and
force
a
typo
or
something
so.
But
you
know
that
if
I
make
this
a
I,
don't
know
an
integer
so
very
wrong
and
then
I
do
a
create
yeah
I,
create
there.
A
Internet's
getting
a
bit
contended
clearly,
but
it
tells
me
that
it
can't
be
hand
reserved
because
they're
read
string
well.
This
is
actually
a
much
more
ugly
error
messages
than
I
error
message.
Then
I
expect
it.
But
it's
telling
me
here
that
it
can't
be
had
as
an
alert,
because
the
type
is
invalid
on
that
field
and
if
you're
doing
this
with
a
custom
resource
definition,
there's
new
API
validation,
stuff
that
Nikita
worked
on
and
that
actually
works
great.
A
It's
not
why
well
yeah
you
can
do
you
can
basically
do
the
same
thing
with
it,
but
obviously
you
still
don't
get
your
full
of
mission
controller
yeah,
it's
better
in
1/9,
so
use
it
to
step
up
and
yeah
I
actually
had
to
play
this
on
the
plane
over
and
it
it
is
really
good
so
yeah.
Thank
you,
Nikita
shoutout,
so
any
more,
oh!
Well,
more
quick.