►
From YouTube: Tutorial: Mastering Multi-version CRDs: From YAML to a Serious Devel... Stefan Schimanski & Joe Betz
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Tutorial: Mastering Multi-version CRDs: From YAML to a Serious Development Project - Stefan Schimanski, Red Hat & Joe Betz, Google (Limited Available Seating; First-Come, First-Served Basis)
Please bring your laptop fully charged as we will have limited charging stations available in the room. To prepare for the session, follow the setup instructions at: https://bit.ly/2JWsbxC CRDs have become the main vehicle to extend the Kubernetes API. They are ready to build serious products on-top of them. But with more and more features like admission and conversion they are no longer just a hundred lines of YAML, but involve real software development. In this talk/tutorial we will start with a YAML-only CRD project and step-by-step go through the development life-cycle towards a powerful multi-version CRD: - add schema validation using OpenAPI schema generators - enable pruning - add defaulting - add an admission webhook for powerful turing-complete validation - evolve the CRD to a new version with a conversion webhook - including comprehensive testing. On this journey we will learn a lot of about the expected webhook behaviour, how they fit into API machinery, and about API compatibility and good & bad API practices.
https://sched.co/Uaen
A
A
B
A
A
A
You
gotta
use
rapid
channels,
so
I'll
show
you
how
to
do
that
in
just
a
moment
but
yeah
we,
it
is
there.
It's
just
hidden
away
a
little
bit.
First
of
all,
really
quick.
Let's
just
go
ahead
and
introduce
ourselves
and
then
we
will
start
getting
set
up.
My
name
is
Joe
Betts
I
work
at
Google,
I'm,
an
STD
maintainer
and
a
contributor
to
API
machinery.
Most
recently,
I've
been
working
on
bringing
er,
DS
and
web
hooks
to
GA
ya.
B
A
All
right,
so
this
is
designed
to
be
an
interactive
tutorial.
If,
following
along
is
optional,
it's
pretty
pretty
complete.
So
there's
plenty
to
watch
if
you
just
want
to,
but
I'm
following
along
as
encouraged
I'm
gonna
leave
this
link
on
the
bottom
of
the
slides
for
the
next
couple
slides.
It's
got
everything
you
need
to
go
ahead
and
get
started.
It's
also
got
a
link
to
these
slides.
A
So
if
you
want
to
jump
around
or
be
able
to
copy
and
paste
out
of
the
slides
as
we
work
encourage
you
to
get
that
open
in
a
browser,
we're
just
gonna
do
three
steps
to
get
started.
The
first
is
we're
going
to
create
a
kubernetes
cluster
and
there's
a
couple
different
ways.
You
can
do
that
then
we're
gonna
check
out
our
tutorial
project
and,
lastly,
we're
going
to
set
up
some
basic
go
development
tools.
So
we
can
write
your
meal
code.
There's
two
main
ways
that
you
can
get
a
kubernetes
cluster
started.
A
You
can
bring
your
own
cluster,
so
you
could
use
something
kind
or
if
you
have
a
cluster
already
running
somewhere,
you
can
go
ahead
and
use
that
the
main
restriction
is.
It
needs
to
be
115
or
newer.
We're
going
to
be
using
some
more
modern,
kubernetes
features.
The
other
option
is
we
have
some
Google
temporary
cloud
accounts
around
in
the
room.
So
if
you
already
have
one
of
those,
you
can
go
ahead
and
get
started
with
that.
A
B
A
And
the
first
thing
I'm
going
to
go
over
just
briefly,
is
how
you
go
ahead
and
create
a
gke
cluster.
If
you're
using
the
google
cloud
account,
you
can
do
that
from
the
command
line.
If
you
already
have
google
cloud,
but
usually
it's
pretty
straightforward
to
just
do
it
from
the
web
UI.
Now,
if
you
are
already
using
google
cloud
for
other
things,
you
might
want
to
use
a
nick
Cognito
window
for
this.
It
keeps
things
nice
and
separate.
A
It
makes
it
really
easy
to
log
in
and
then
clear
things
out
when
you're
all
done
with
it
tutorial.
But
the
first
thing
you're
gonna
do
is
just
navigate
to
cloud
console
cloud.
Google.Com
and
you'll
be
immediately
prompted
for
the
user
name
on
the
temporary
account
once
you've
logged
in
accepted
a
couple
of
the
terms
you're
going
to
have
the
option
to
you're
going
to
see
an
option
to
select
a
project
at
the
very
top
of
the
window,
open
that
and
there's
a
pre-existing
project
called
multi
version.
Cr
DS.
A
You
just
want
to
select
that
one
after
you've
done
that
you're
going
to
navigate
using
the
very
top
left
in
the
navigation
there's
a
menu
there's
like
three
little
horizontal
bars,
click
that
go
down
to
google
kubernetes
engine
and
click
clusters
and
then
you're
going
to
create
a
cluster
from
there.
There's
only
two
things
you
need
to
do
with
your
cluster
you're
gonna
create
a
standard
cluster.
It
can
just
be
zonal,
you're,
going
to
give
it
a
cluster
name.
I'm
going
to
use
this
name
here
of
coop
con
CRD
tutorial
throughout
my
aside.
A
So
if
you
want
to
be
consistent
with
the
slides,
you
can
just
use
that
and
then
you
need
to
click
use,
release
channels
to
get
a
new
enough
version
of
kubernetes.
It's
really
important!
You
do
this
and
you
get
a
115
newer
version.
If,
if
you
accidentally
created
one
older
than
that
when
you
got
started
before
go
ahead
and
just
delete
it
and
create
a
new
cluster,
the
next
thing
we're
going
to
do
is
setup,
and
it's
okay.
If
you
fall
behind
me
here,
you'll
get
caught
up
is
we're
gonna
set
up
our
development
environment.
A
A
little
bit
so
we
would
encourage
you,
if
possible,
to
go
ahead
and
just
use
your
local
machine.
I'm
use
your
terminal
on
your
local
machine
and
do
everything
there.
If,
for
whatever
reason,
you
can't
do
that,
you
can
use
the
Google
cloud
shell
and
we
don't
have
a
super
packed
room,
so
we
might
actually
have
good
enough
connectivity
for
a
lot
of
people
to
do
it
this
way,
but
still
your
terminal
is
going
to
be
the
most
reliable
way.
A
If
you
do
use
Google
Cloud
shell
I'll
show
you
how
you
can
do
everything
from
inside
there.
So,
if
you're
doing
local
development,
the
first
thing
you
want
to
do
is
install
g-cloud
that
will
allow
you
to
connect
your
kubernetes,
your
gke
kubernetes
cluster.
So
go
ahead
and
start
getting
that
downloaded
and
then
you're
just
going
to
run
three
simple
commands
to
login
load
up
your
project
and
establish
a
connection
for
tube
cuddle
to
that
project.
A
If
you're
using
cloud
shell,
once
your
kubernetes
cluster
is
running,
you
can
kind
of
see
with
the
red
circle
I've
got
down
here
in
in
the
bottom
right
here.
There
will
be
a
connect
button.
It
appears
you
can
just
go
ahead
and
click
that
and
then
click
run
and
cloud
shell
and
it's
going
to
open
the
terminal
for
you
right
there
in
your
browser,
it's
going
to
be
pre-populated
with
a
command
just
to
enter,
to
run
that
command,
and
then
you
should
be
able
to
use
cube
cuddle.
A
A
Thank
you
there's
a
little
button
right
here.
It
looks
like
a
pencil
if
you
click
that
it
will
open
a
web-based
editor
for
you.
It
won't
have
all
the
bells
and
whistles
of
a
full
IDE,
but
at
least
we'll
be
able
to
do
some
basic
work
in
it.
You
can
go
ahead
and
click
that
to
open
it
up.
If
you're
doing
everything
locally
make
sure
you
have
go.
1,
12
or
newer.
A
We've
got
go
modules
all
vendored
into
the
checkout,
so
you
shouldn't
need
to
pull
much
from
the
internet,
but
you'll
need
to
go
1-2
over
newer.
If
you
don't
have
that
version,
go
ahead
and
download
it
now
and
get
it
set
up.
I'm
also
encourage
you
to
you.
If
you
use
an
ID
like
IntelliJ
or
Visual
Studio
code
go
ahead
and
start
connecting
the
project
now
and
getting
that
set
up.
We're
gonna
want
to
have
code
completion
and
all
the
good
things
of
a
modern
IDE.
A
B
Before
I
go
into
details
here,
I
want
to
hear
about
your
experience
so
who
is
created
some
CDs
in
some
projects,
so
most
of
you
that
also
I
hope
who
has
programmed
controllers
or
anything
was
client.
Oh
it's
the
most
of
you
are.
Maybe
it
wasn't
half
of
you
who
has
looked
into
the
more
advanced
things
like
admission,
webhooks,
also
couple
sweat
books
are
always
already
available
for
quite
some
time
and
we
will
use
them.
B
B
We
have
this
slide
here
about
all
the
features
which
we
call
I
mean
from
a
height
in
the
circle,
to
the
left.
What
we,
what
we
call
advanced
so
OPI,
CMOS
I,
guess
most
of
you
have
used
them
in
some
way
or
the
other
they're
available
for
Ino
for
more
than
two
years.
I
think
the
tooling
around
was
always
not
so
it.
B
A
B
B
This
will
be
or
it's
it's
a
default
in
v1
API
CID.
So
if
you
have
a
CID
and
you
use
the
API
v1,
which
is
available
in
116,
this
is
the
default.
So
you
don't
have
to
do
anything
to
get
pruning
eiffel
later,
what
it
really
does
and
how
it's
used,
but
it's
just
one
field
and
very
simple
to
enable,
so
there
was
not
much
go
yet
so
everything
was
in
Jam.
It
also
looks
very
simple:
Moochie
Bourbons
exist
for
comes
for
quite
some
time.
Also
yamir.
B
You
can
define
multiple
versions
in
the
CID
and
they
are
served,
but
before
we
had
actually
conversion
so
at
the
next
stop
here
on
the
left
before
we
had
conversion,
all
girlfriends
were
the
same,
so
there
was
not
much
sense,
I
mean.
Could
you
find
them,
but
they
all
looked
the
same.
At
least
they
had
the
same
schema.
This
conversion.
A
B
Changes
so
conversion,
it's
that
book,
written
and
go
I
mean
any
language
can
do
that,
but
the
libraries
and
types
everything
isn't
go
over.
So
it's
maybe
preferred
language
here,
it's
another
step,
it's
another
level
of
development.
That's
why
we
called
this
talk
here,
something
about
a
development
project.
We've
right
go
code,
it's
much
more
than
Yama
and
the
last
thing
it's
not
so
new
admission.
It's
of
course
also
usually
developed
and
go
yeah.
So
this
is
our
agenda
for
today.
The
first
thing
we
did
already
Joe
will
introduce
the
example.
B
In
some
seconds
we
will
use
cogeneration,
especially
this
controller
Jen
tool.
You
will
start
simulator
and
sermons.
All
the
components
were
of
this
example
and
the
simulator
we
will
go
into
open,
API
generation
because
yeah,
it's
not
so
new,
but
this
generation
is
new
and
we
want
to
do
two
more
people
should
should
learn
about
controller
Jen
and
how
nicely
it
works
and
makes
all
about
Omega
are
much
easier,
pooling
will
be
enabled,
and
in
the
last
part
we
go
to
go
and
we
will
look
on
burning.
So
we
write
a
burgeoning
bear.
B
Poop,
a
confirm
conversion.
Vet
book
and
we
will
test
test
test
web
who
we
will
write
our
tests
and
yeah,
deploys
the
thing
in
a
cluster
and
see
different
versions
being
magically
converted
and
last
but
not
least,
there's
admission
part
where
we
were.
We
will
write
an
admission
beppu,
which
is
non-trivial,
so
it
does
more
than
just
validating
something
locally
by
some
sums:
unstructured
object
that
it
will
also
access
different
resources.
So
it's
much
more
than
what
you
can
do
with
open
api
all
right.
So
now
we
know
what
you
will
do
and
so.
A
Thank
You
Stephan,
there's
gonna,
be
a
bunch
of
interesting
code
to
do
so.
For
example,
today
we're
gonna
be
working
with
some
research
on
this
thing
called
the
deep-sea
research
station,
it's
kind
of
hidden
down
there
in
the
water.
It's
a
big
metal
tube.
It's
really
important
to
these
guys,
that's
what
they
you
do.
Their
research
in
and
up
here
in
front
we
have
Walter
Walter
is
nice.
We
like
Walter
up
at
the
surface.
We
have
about
one
bar
of
pressure.
That's
a
unit
of
measure.
A
We're
just
did
that
my
sphere
of
pressure,
that's
basically
where
we
all
in
are
now
in
this
room.
This
research
station
is
down
deep
in
the
water
at
about
90
meters
or
300
feet
or
so,
and
down
there
it's
about
10
bar
so
10
times
the
pressure
pushing
in
on
side
on
every
side
of
this
tin
can
that
our
researchers
live
and
work
in.
So
it's
really
important
that
we
keep
the
pressure
inside
our
research
station
at
10
bars
as
well.
A
If
the
pressure
were
to
increase
too
far,
the
station
could
burst
if
the
pressure
were
to
decrease
too
far,
the
station
could
implode.
So
we
don't
want
either
of
these
things
to
happen.
Remember
Walters
inside
and
we
like
Walter.
Now
our
research
station
is
sometimes
connected
to
a
surface
vessel
through
this
cool
thing
called
an
umbilical
cable.
It's
this
conglomeration
of
different
things:
it
conveys
electricity
and
data,
and
even
air
between
the
surface
vessel
and
our
research
station
I'm
gonna
focus
in
on
that
last
item.
There,
air,
that's,
really
important.
A
We
have
now
opened
a
conduit
for
air
flow
between
our
research
station
and
the
surface,
which
means
the
pressure
could
change.
Fortunately,
we've
got
some
pumps.
We
can
use
to
help
manage
this
now
the
way
that
our
pumps
were
working
really
simple.
If
our
pressure
is
too
low,
we
can
run
more
pumps.
If
our
pressure
is
too
high,
we
can
run
fewer
them.
A
Equilibrium
should
usually
be
about
three
pumps.
We've
got
six
pumps
total
and
we're
gonna
do
all
of
this
with
kubernetes,
and
so
here
is
a
kind
of
a
quick
glimpse
at
two
of
the
custom
resources
that
we're
going
to
be
dealing
with.
Today
we
have
devices
which
are
this
just
these
kind
of
the
general
internet
of
things,
type
of
items
and
we're
gonna
represent
those
here
in
an
API
group
called
things.
Koukin
do
and
we're
gonna
give
them
all
names
and
all
they
do
is
have
inputs
and
outputs.
A
Now
inputs
are
things
from
kubernetes,
so
those
are
in
this
back.
Outputs
are
things
about
our
device,
so
those
come
in
through
the
status.
You
could
imagine.
Some
connector
connects
to
some
external
device
and
reports,
the
output
status
and
the
observed
inputs
of
that
thing,
and
then
the
only
thing
we
can
do
is
set
inputs.
A
Now
we
also
have
our
research
modules.
We
have
three
of
them.
We
have
a
command
and
a
research
and
crew
module
and
all
of
them
are
gonna,
have
a
custom
resource
that
looks
kind
of
like
this.
Each
of
them
has
three
devices
a
pump
and
alarm,
and
a
sensor
and
we're
gonna
be
using
this
CR
to
refer
to
the
other
CR.
So
here
we
know
that
this
module
pump
is
pumped
number
one.
A
So
we
could
then
go
look
that
up
so
a
little
bit
going
on
with
our
series
here
now
to
make
this
a
little
more
fun
we're
going
to
deal
with
multiple
versions
of
our
CR
D
and
the
one
that
we
have
multiple
versions
of
is
our
device.
We
had
originally
created
a
v1
alpha,
one
where
we
defined
three
fields
for
all
inputs
and
outputs.
We
had
the
name
of
the
input
or
output.
A
We
had
some
value,
which
was
just
this
quantity
string,
and
then
we
then
we
would
declare
the
type
separately
in
a
separate
field,
and
we
could
say
it
was
an
inter
float
or
boolean,
but
there
was
nothing
really
tying
the
the
type
checking
of
that
value
to
what
we
said.
The
type
was
so
later.
We
came
back
and
introduced
the
v1
and
the
v1
is
structured
a
little
differently.
A
You
only
have
to
put
an
optional
integer
float
or
boolean
field,
and
then
the
value
can
only
be
an
actual
value,
so
our
boolean
is
now
actually
true
or
false.
It's
not
just
0
or
1,
it's
a
little
better,
but
the
key
thing
I
want
you
to
know
from
this
slide
is
that
both
of
these
versions
of
our
CRD
are
available
at
the
same
time
and
clients
are
using
them
both
concurrently,
some
clients
are
using
v1
alpha,
one
other
clients
are
using
v1
if
they
print
both
read
and
write
to
our
CRD.
A
They
are
both
being
served
concurrently
and
we're
going
to
deal
with
that.
That
means
that
there
has
to
be
has
some
conversion
going
on.
We
have
to
choose
which
version
we're
actually
going
to
store.
We'll
talk
more
detail
about
that
shortly.
Now
we
have
a
UI
for
our
simulator,
we're
going
to
load
this
into
our
clusters
in
just
a
moment,
and
what
it
will
do
is
it'll
actually
show
you
in
real
time
all
three
of
your
modules
for
your
research
station
and
the
current
values
for
all
the
devices.
A
Now,
how
many
of
you
have
gotten
to
the
point
where
you
have
a
working
cluster?
Oh
great,
ok,
how
many
of
you
have
checked
out
the
code?
Awesome?
Okay!
So
that's
what
we're
gonna
do
next!
Is
we're
going
to
start
looking
through
that
code,
so
go
ahead
and
open
up
your
code
in
an
editor
and
I'm
gonna.
Give
you
a
couple
pointers.
The
first
place,
I'd
like
you
to
look,
is
in
the
api's
directory
inside
of
here.
A
A
The
other
thing
we
generate
is
in
the
generated
directory.
We
have
generated,
go
client
bindings,
we're
gonna
be
able
to
use
those
in
the
write
code.
In
addition
to
those
main
things
which
are
all
are
related
to
the
types
we
have
an
admission:
the
controllers
in
a
conversion
directory
those
are
all
where
we're
gonna
be
writing
code.
The
admission
contains
an
omission.
Webhook
conversion
contains
a
conversion.
Web
book
and
controllers
can
train
some
controllers
that
we're
going
to
be
using
with
our
series.
A
Our
examples
directory
contains
some
some
actual
custom
resources
that
we're
going
to
load
into
our
cluster
just
a
minute
so
that
we
have
the
modules
and
the
devices
for
our
specific
example
and
within
the
conversion,
admission
and
controllers
directories,
there
are
manifest
yeah
moles
that
we
can
use
to
load
those
things
into
our
cluster
and
I'll.
Show
you
how
to
do
that
in
just
a
moment
for
convenience.
We
have
in
our
hack
directory
two
code,
gen
utilities.
These
are
pretty
small
you're
encouraged
to
go
ahead
and
look
and
see
what
they
do.
Mostly.
A
What
they're
doing
is
setting
up
the
parameters
to
call
our
code
gen
tools
and
we
can
use
those
to
regenerate
our
client
bindings
or
to
update
our
open,
API
schemas
inside
of
our
CRT
definition
at
the
at
the
end
of
the
talk,
we're
going
to
be
using
some
doctor
repositories
and
our
make
file
has
some
utilities
so
that
we
can
easily
build
and
push
our
doctor
images
so
we'll
get
back
to
that
later.
But
the
first
thing
I'd,
like
you
to
do,
is
just
go
ahead
and
start
executing
these
few
commands.
A
The
first
one
is
going
to
load
your
kubernetes
CRTs
into
your
cluster
use,
the
appropriate
version
for
this
cluster
version
that
you
started
once
those
CRTs
are
created.
We're
also
going
to
load
up
a
conversion
webhook
we're
going
to
need
that
from
the
get-go.
We'll
continue
to
improve
it
later,
but
we
need
it
running
from
the
very
beginning.
So
go
ahead
and
run
cube,
cut'
will
apply
on
conversion
manifests
as
well.
Next,
you
can
go
ahead
and
run
cube.
A
Cut'
we'll
apply
for
all
three
of
our
modules
and
once
you've
done
that
you
can
go
ahead
and
do
a
couple
get
to
have
a
look
at
all
the
CRS
that
you've
loaded
and
we
added
some
custom-
calls
columns
to
our
CRTs
so
that
you
can
kind
of
see
some
of
the
device
values
mark
easily
once
you've
done
all
that.
The
next
thing
we're
going
to
do
is
run
our
simulator,
and
so
it's
in
the
simulator
directory
there's
a
manifest
Gemmell.
There
could
probably
apply
that
as
well
and
then
to
get
access
to
it.
A
There
are
two
options:
you
can
either
use
port
40,
which
is
option
B
here,
which
will
kick
on
almost
immediately
or
you
can
open
an
ingress
if
you're
using
gke,
and
it
will
take
about
a
minute
for
the
address
of
that
ingress
to
appear
in
another
three
to
five
minutes.
For
that
actually
become
available.
You
get
a
404
for
a
couple
minutes,
and
so
you'll
need
to
do
cube.
A
Travel
get
a
couple
times
to
get
that
loaded,
but
go
ahead
and
run
those
commands
and
either
depending
which
one
you
used
either
on
port
80
or
port
8080
you're
now
going
to
have
your
UI,
so
you
can
go
ahead
and
get
that
loaded
up
or
if
you
just
prefer
to
do
everything
from
the
command
line
you
can
use
this
watch
command
and
you'll
get
roughly
the
same
information
just
in
a
different
presentation.
Here
these
are
what
are
called
quantities.
That's
a
kubernetes
type
and
the
M
just
means
I.
Think
Millie's
is
so.
A
Once
you
get
your
simulator
started,
you
might
notice
that
there's
not
a
lot
going
on.
You
can
manually
change
the
values
and
you
could
read
them
back
using
cube
cuddle
if
you
wanted,
but
there's
not
really
a
lot
happening.
So
we're
also
going
to
start
up
a
controller.
That's
going
to
simulate
some
pressure
changes
it's
going
to
kind
of
sinusoidally
in
and
decrease
that
pressure
over
time.
A
So
once
you
kick
that
on
you'll
see
that
these
values
are
starting
to
change
fairly
rapidly
and
we'll
continue
to
work
on
introducing
additional
controllers
to
keep
that
pressure
as
close
to
10
and
bars
as
possible.
Later
so
again,
here's
all
those
commands
you
can
run
and
continue
to
work
on
that,
and
hopefully
you
will
be
all
caught
up
with
us
soon.
B
Yeah,
so
I
will
also
prepare
our
local
cluster
here.
So
we
are
working.
I
was
a
kind
cluster
on
this
notebook.
So
it's
running,
you
see
ya
binaries.
We
want
to
deploy
a
couple
of
pots,
so
Mission
Bay
pukka
supports
its
pre
deployed.
So
I
did
that
already
before
the
talk
simulator
is
running
and
the
conversion
webhook
is
running
I.
B
B
Everything
aesthetics,
there's,
no,
no,
no
action.
Yet
in
this
cluster,
so
everywhere,
every
of
those
spots
is
waiting
we
have
to
deploy,
is
a
controller
to
get
something
here,
which
is
more
interesting.
So
let's
do
that
controller
directory
I
said
before
there's
many
fast
inside
and
if
we
do
that,
it's
in
some
seconds
we
should
get
a
controller
you're,
not
creating
and
an
air
war,
for
whatever
reason,
I
have
no
idea,
it's
not
the
sensor.
So
it's
not
doing
much
at
the
moment,
so
controller
just
increases
or
decreases
the
pressure.
B
A
B
You
have
seen
those
two
CDs
before
we
had
some
other
slides
and
we
will
mainly
look
for
okay
appear.
At
least
we
will
look
on
the
side
on
the
left,
one.
So
we're
interested
in
specifying
the
structure
of
the
device
CID
yeah,
you
can
see
here.
We
have
inputs
inputs,
our
values
also
so
type
instead
of
go
is
called
value
and
observed.
Inputs
and
outputs
are
also
values.
Everything
is
a
value
basically
and
value
in
version.
V1
I
for
one
has
a
structure
here.
It
has
a
name
as
a
value
which
is
quantity.
B
B
Inside
of
a
CID,
you
have
to
specify
open
API,
so
you
see
it
looks
very
similar
to
to
the
structure
of
the
CID
here
in
the
middle,
as
this
blue
bar
is.
This
is
owed
me.
Api
schema
for
version
one,
so
we
have
a
version.
One
here,
I
think
I
switch
to
version
on
this
slide,
so
yeah
I
did
so
here.
This
was
so
over
p1
I
for
one
type
here
we
have
the
v1
type.
It's
a
bit
simpler,
so
integer
has
really
one
field.
It's
it's
some
type,
that's
how
we
call
it.
B
Integer
can
be
set,
float
can
be
set
or
boolean
can
be
set,
and
on
the
right
side
we
have
to
specify
our
create
some
house,
the
schema.
So
this
is
a
topic
of
the
section
yeah.
Just
one
word
here
about
metadata,
so
this
must
be
complete.
We
will
show
in
a
minute
why
it
should
be
complete,
so
I
have
to
specify
everything
you
can
have
in
your
CID.
There's
one
small
exception,
the
metadata,
so
the
object
meta
from
from
client
go.
This
doesn't
have
to
be
specified
and
it
even
cannot
be
specified.
B
So
there's
restrictions
in
the
last
version
of
Queenie,
so
you
can
say
types
object,
but
don't
start
to
specify
every
three
below
so
don't
specify,
I,
know
annotations
and
labels
and
stuff
don't
do
that.
It
doesn't
even
work
if
you
have
all
T
IDs
which
have
that,
because
Cupid
are
created.
This
originally
get
a
new
Cupid
and
regenerate
a
CID
in
115
or
116,
which
wants
to
use
new
features,
cannot
have
those
few
definitions
inside
of
metadata,
alright,
how
to
create
that
we
don't
create
it
from
from
the
customer
resources.
B
It's
just
an
example
here.
On
the
left
side
we
created
from
goal
encode
and
it's
basically
inspired
from
what
we
do
for
native
types
in
Cuban
leaders.
Already
we
do
the
same
for
CDs,
so
you
start
defining
your
typed-in
go
along.
So
here's
a
value
start
as
I
said
it's
the
most
important
part
which
it's
used
for
the
inputs
and
outputs
and
observed
inputs.
It's
always
this
value
and
yeah.
You
can
see.
B
There's
a
pretty
clear
translation
so
as
to
act,
becomes
an
object
here
and
fact,
as
we
fear,
so
you
have
to
define
them
as
properties
so
name
there
are
you
and
type
here
from
the
left
show
up
on
the
right
side
again,
so
you
could
write
that
manually.
But
of
course
we
don't
want
to
do
that.
We
want
to
use
a
tool
and
the
tool
here
is
this
control
again
comes
from
pupil
die
from
the
controller
tools,
repository
and
yeah.
That's
a
new
command
sub-command.
B
It
was
in
a
pitch,
so
this
can
be
used
to
just
create
a
schema.
You,
you
write
your
cid
yourself
so
manually
why
to
manifest
for
a
CD
and
then
you
patch,
in
the
schema.
So
this
can
be
done
by
this
command
line.
Very
very
simple:
the
quant
line
can
read
any
kind
of
manifests
here.
The
manifest
here
you
give
it
a
go
along
like
path
of
api's.
In
our
case
the
deep-sea
API
and
the
things
API
M,
V,
1
and
V
1
I
have
one
and
it
will
match
automatically.
B
B
Schema
generation
is
driven
by
Marcus,
so
the
marker
idea
it's
everywhere
in
cupola,
so
it's
easels,
plus
Q
blog
comments
inside
of
CID
types
here,
Q
builder
validation
as
I
switch
I.
We
are
interested
here
in
enum,
for
example.
We
want
to
specify
that
the
type
can
only
be
one
of
those
three
values
and,
oh,
maybe,
hey
open
it.
Guy
has
enums,
so
you
can
define
that
and
there's
a
equivalent
marker
here
in
am
equal
to,
and
then
you
give
a
list
of
values
of
strings.
B
Yeah
we
use
a
default
as
well,
so
defaulting
is
new
in
1/16.
That's
why
we
have
those
tools
here,
the
manifest
directories
in
115.
You
don't
get
the
default,
so
you
have
to.
If
you
use
115,
you
want
to
update
your
schemas,
you
have
to
disable
or
move
this
line.
West
default
is
actually
specified
and
then
we
generate
and
then
you
get
something
which
is
compatible
with
115,
but
in
116
you
have
that.
So
it's
it's
convenient.
B
A
B
Is
it's
here?
Yes,
one,
the
name
is
required
and
values
declared
as
well
type
is
not
keep
in
mind
if
you
require
something.
It's
also
required
on
the
client
side
and
cue
cutter
will
validate
so
cue.
Cattle
will
reject
objects
which
don't
have
the
required
fields,
and
this
is
the
reason
why
we
don't
have
the
type
here.
So
a
quiet
field
you
can
use,
you
can
leave
it
out,
don't
require
it
and
say
there's
a
default
and
then
you
know
every
object
gets
this
value,
but
technically
it's
not
required.
Anyway.
A
B
Sure
it's
a
value
asset
required
an
optional.
Those
of
you
who
have
used
Q
builder
before
the
default
is
that
everything
is
required,
and
this
is
kind
of
unnatural
for
many
people,
that's
why
we
built
in
the
mode
or
mechanism
to
set
a
default
for
the
whole
package.
So
you
can
say
you
build
a
validation
optional
in
the
dock,
go
file,
so
it's
a
wood
of
the
package
and
then
everything
by
default
is
optional
and
you
have
to
opt
in
in
to
be
being
required.
B
So
this,
for
many
cases,
is
much
more
convenient
and
I
said
before
this
controller
Jen
will
match.
So
it
has
to
know
how
good
names
are
much
gülen's
names
are
what
the
building
name
is
and
a
couple
of
texts
to
do
that.
So
you
say,
group
name
is
in
this
case
things
cubic
on
Io
by
default.
It
will
use
a
package
name,
but
the
package
name
is
just
things
I.
Think
in
our
case,
so
we
specify
that
here
specifically,
and
the
word
name
is
V
ones.
B
It
should
also
be
dy
from
the
package
name,
I
think
I've.
In
my
case
it
was
a
box.
That's
why
it
didn't
work
in
this
version,
maybe
it's
fixed
by
now.
That's
why
I
specified
it
as
well
as
here
alright.
So
that's
how
open
API
is
generated
before
we
do
that,
actually
practically
somewhere
about
pruning,
so
pruning
is
default
in
v1
series.
The
reason
is
that
we
want
everybody
to
use.
B
The
pruning
pooling
is
important
because
it
it
removes
fields
from
a
CID
which
are
not
specified,
so
it
can
always
be
sure
nobody
stores
anything
in
LCD
which
is
not
defined
by
by
you.
As
an
author
of
a
CID
in
V
1,
meter
1,
you
can
anywhere
as
well
so
just
set
reserve
unknown
fields,
defaults
and
v1s
default.
B
B
What
happens
if
something
is
missing
here
so
here
for
CR
like
this
one
and
there
is
unknown
42.
Somebody
just
passed
that
edits
that
it's
not
specified
on
the
right
side.
So
the
schema
doesn't
include
unknown,
and
if
you
create
this
object,
it
will
just
I
mean
the
server
will
just
go
up
unknown
42.
Even
if
you
skip
validation,
so
Q
cuttle
will
complain
you
cattle
will
client-side
by
default,
will
complain
that
unknown
is
not
in
the
schema,
but
even
if
you
say
a
validate
faults
on
the
command
on
of
Q
cutter
unknown.
B
This
drop
by
the
service
so
you're
sure
there's
never
an
unknown
only
fields
which
you
know
yeah,
and
if
you,
if
you
use
the
controller
gen
and
if
you
set
this
field,
this
is
pretty
simple
to
use.
Just
as
a
side
note,
we
won't
use
it
here.
There
are
ways
to
opt
out
of
that,
so
you
you
can
specify
that
a
sub,
a
subtree
of
your
CID
of
your
CR,
is
actually
pure
jason.
B
So
if
you
have
something
you
embed,
some
jason
construct
from
another
API,
for
example-
there's
a
way
to
say
that
so
you
can
opt
out
of
pudding,
but
it's
not
suggested
I
mean
just
do
it
there,
where
it's
really
necessary
in
the
normal
case,
just
depend
on
depend
on
pooling
all
right.
So
so
much
more
open
API.
B
B
B
If
you
use
the
CAG
is
like
the
API
extensions
API
v1
beta
one
like
you
do
in
a
114
113
cluster
because
it
was
not
v1.
V1
is
new.
If
you
define
a
v1
I
for
one
CID
for
some
kind
of
API
group
in
an
old
cluster
or
using
V
1
beta
1
in
a
new
cluster,
then
tuning
is
not
enabled
so
you
have
to.
If
you
use
the
old
API
for
4c
IDs,
you
have
to
enable
it
manually,
but.
A
B
What
so
the
task
is
to
to
add
civilizations
which
are
missing?
Obviously,
names
of
inputs
should
not
be
empty,
empty
I
mean
you
can
do
it.
It's
just
strange
to
have
empty
names,
and
names
should
also
follow
some
some
patterns.
So
what
we
want
to
have
names
are
just
letters
and
numbers,
so
the
task
is
to
add
that
to
the
types
I
added
I
added
here,
the
that
remark,
everything
you
do
so
we
have
two
versions
of
the
cid
v
1
and
v
1
I
for
one.
So
everything
you
do.
B
You
should
better
do
in
both
types
go
files.
If
you
do
it
just
on
one
side
later
on,
you
will
be
able
to
create
in
one
version,
you
will
be
able
to
create
something,
an
object
which
is
not
valid
and
in
a
different
version,
so
always
try
to
match
them.
Try
to
to
have
validation
which
make
sure
that,
even
after
conversion,
if
you
change
the
version
of
your
object,
it's
still
relatively
non-invasive.
B
B
B
Origin
internally
applies
a
new
cid
to
the
cluster
and
just
verify
that
it's
really
now
validating
so
create
an
object
or
edit
an
existing
object
like
an
existing
device
and
change
your
name
into
something
which
is
invalid,
and
hopefully
this
is
reject
it
now
and
if
you
have
too
much
time,
it's
too
easy
for
you.
We
have
two
advanced
steps
here.
One
is
in
v1.
We
have
the
some
type,
so
we
have
integer
boolean
and
float
and
there
are
fields
in
this
value
type
and
just
one
is
allowed
to
be
set.
B
He
knows
that
from
volumes
volumes
in
in
kubernetes
they
also
have
some
type
structure,
so
you
have
host
path
and
MTE
and
secret
and
so
on,
and
only
one
can
be
set,
and
the
goal
is
here
to
express
that
in
open
api,
it's
possible
it's
not
even
so
hard
yeah,
just
try
it
and
yeah
the
last
one.
This
is
really
pretty
advanced
and
open
api.
If
it's
boolean,
you
better
only
have
the
two
values:
one
and
zero,
not
half
doesn't
make
sense
for
boolean.
It's
also
hard
to
convert
later.
B
A
A
A
B
A
B
All
right
so
now
we
are
trying
to
to
debug
why
the
controller
doesn't
work
here.
There's
some
panic.
It's
not
Accenture!
So
controlled
us
just
cosmetics
get
some
nice
animation.
Actually
we
have
a
slide
later,
where
you
see
what
really
happens.
So
we
don't
need
that
for
the
moment
very
quickly.
Yeah.
Let's
take
a
look
here
on
one
of
the
types
we
are
in,
which
one
we
are
in
devices
v1
now.
So
we
have
this
nice
some
type
here
and
if
we
want
to
say
that
the
name
it's
not
empty,
this.
B
Sum
in
length-
and
you
can
just
say
zero
and
we
have
something
called
patterns
with
just
just
regular
expression,
so
get
an
equal
and
I
think
you
have
to
put
it
in
the
crowds
and
it's
a
to
that
capital.
A
to
that
zero
to
nine,
and
you
want
anything.
Of
course
you
can
also
use
something
like
plus
and
then
get
rid
of
the
main
lines
same
thing
and
let's
see
whether
we
have
any
effect.
If
we.
B
It
works
for
you,
so
where's,
my
my
typo
or
something
I
said
I
know,
I,
know
where
my
typos
everything
must
be
capital
and
please
I,
guess,
there's
an
issue
to
makes
us
more
I
mean
to
make
several
messages
better
and
kupida.
Give
me
some
support,
but
put
a
plus
one
there.
You
have
seen
why
and
I
hope
we
get
something
now
yeah
all
right,
so
Cupid
as
a
control
again
is
not
really
good
in
error
messages.
So
you
don't
see
that
something
was
wrong
there.
Okay,
so
I
don't
do
the
other
examples.
B
Everybody
who
wants
to
see
the
solution,
especially
for
the
stretch
codes,
it's
pretty
complex
compared
to
the
one
I
just
showed,
but
it's
interesting
if
you
especially
if
you
are
interested
in
you,
know,
logic,
propositional
logic.
This
is
involved
here,
all
right,
so
x1
next
one
we
want
to
have
multi
version,
so
we
have
seen
this
before
all
right.
Yeah.
B
B
We
have
seen
this
before.
We
have
two
versions
of
devices
and
we
have
seen
already
where
the
difference
is.
One
has
a
some
type
with
those
three
fields,
and
one
has
just
value
and
type
and
important
here
is
that
you
have
to
convert,
and
the
conversion
is
something
which
is
done
in
place
or
in
it's
really
than
life.
When
a
request
is
possessed,
there's
nothing
like
some
people,
think
there's
an
object,
envy
version
one
and
it
doesn't
exist
at
the
same
time
in
v1
I
for
one
it's.
This
is
wrong.
B
An
object
exists
in
all
versions
of
the
API
group.
At
the
same
time,
of
course,
EDD
is
kind
of
opinionated,
so
EDD
will
store
just
one
version
as
something
called
a
storage
were
in
which
you
can
define
in
the
burton's
field
of
the
CID
spec.
But
logically,
when
a
client
comes
to
the
server
and
asked
for
an
object,
the
client
says
which
one
it
wants
and
as
life
lost,
less
conversion
into
the
target
version,
because
the
client
wants
to
have
if
the
version
in
the
sed
is
wrong.
B
Of
course,
I
mean
if
it
matches
is
the
same.
There's
no
conversion
going
on,
so
we
have
two
white
FF
book.
This
is
basically
the
reason
why
we
need
115
conversion
via
web
hookahs.
It's
pretty
new,
it's
new
from
in
115
as
a
beta
and
be
promoted
to
116,
so
in
at
least
a
115
classify
multi
versions
without
conversion
we
had
earlier,
but
it's
not
really
useful.
B
So,
let's
look
at
our
our
type
value,
as
has
had
or
inputs
our
values.
So
this
was
the
core
of
the
CID.
He
has
a
representation
which
we
invented
in
v-1
FR,
one
when
we
maybe
didn't
have
lots
of
experience
mr.
API
type.
So
we
chose
this
representation
and
we
don't
like
it.
We
want
to
offer
this
one,
the
right
one
to
the
customers
for
v1
API
and
it's
different
right
I
mean
it
looks.
B
Conversion
is
enabled
in
the
custom
resource
definition.
So
if
you
have
so
many
fest
of
a
cid,
you
define
versions
most
of
you,
even
if
you
just
that's
just
one
bill
nowadays,
you
get
this
versions
flies
here
in
the
manifest,
as
I
said,
one
is
a
store
which
were
so
one
is
thought
in
LCD,
it's
in
our
case,
here's
v1
I
for
one,
for
whatever
reason
you
can
yeah
think
about
when
it
makes
sense
to
really
change
the
storage
version.
B
Of
course
you
change
it
at
some
point
when
you
don't
want
to
F,
we
won't
ever
want
anymore,
but
the
interesting
part
here
for
for
us
now
is
to
add
a
convert,
and
this
is
a
new
thing.
It's
also
in
the
series
back
and
it's
for
all
versions.
So
there's
just
one
report:
you
cannot
have
multiple
of
them.
It's
always
just
one.
You
change
the
strategy
to
Babu.
B
We
have
put
this
into
the
things
namespace
and
we
gave
the
service
name
convert
from
that
book
and
the
past
is
just
actually
free
pass,
which
is
called
in
the
baboon's
College
and
it
must
be
secured.
So
there
must
be
a
CSC,
a
bundle
as
well
which
matches
the
serving
sort
of
the
epic
it's
all
done
in
repository.
Everything
is,
is
there
already
is
a
make?
File
will
be
able
to
create
that
and
take
a
look
at
that,
how
it's
done
so
it's
secure
by
default
and
our
exam
pitar
set
as
well.
B
There's
something
we
see
in
a
second.
We
have
convert
from
the
reviews,
so
this
there's
an
object
that
is
sent
to
the
web
book
and
that's
called
convert
from
that
cook.
Conversion
of
you
and
this
convert
the
rebel
API.
It
exists
in
different
versions,
so
V
1,
beta
1,
was
the
one
we
introduced
in
115.
B
We
also
have
a
v1
version
of
that
nowadays,
but
we
have
pasted
everything
on
V
1,
beta
1,
because
yeah
it
should
work
in
115
and
as
far
as
I
know,
it's
also
require
that
FF
4
supports
this
version,
even
in
116.
So
it's
enough
to
have
P
1,
beta
1,
but
just
about
details
in
this
object.
They
don't
really
matter
fast
yet
and
yeah
a
lot
less
conversion
we
have
seen
and
it
can
be
easy.
Ta
pok
is
called
more
than
once.
B
So
it
can
be
that
it's
called
when
something
is
wet
from
exodus,
an
LCD.
Maybe
you
have
different
versions
of
the
request
and
when
it's
wet,
that's
a
conversion
going
on
and
requesters
possess,
something
is
written
back
to
HDD
and
then
a
second
conversion
is
going
on
just
a
quick
glimpse
here
on
what
queue
cutter
does
internally.
So
if
you
say
cue
cutter
get
devices,
it
use
the
highest
version.
It
knows
it's
a
preferred
version
and
there's
a
fixed
order.
If
you
have
to
be
one
it,
you
cracker
will
use
that.
B
If
you
don't
have
that
it
will
try
I
mean
it
knows,
which
reference
exists,
its
users
discovery,
but
it
will
order
them
in
this
way.
So
v1
I
for
one
is
not
used
by
default.
So
you
really
have
to
tell
it
you
see.
One
I
have
one
as
soon
as
every
you
v1
in
this
category.
So
in
your
city,
ID
manifest
if
you
party,
we
use
it
and
discovery
will
makes
us
just
transparent
for
the
user.
If
you
don't
deploys
a
conversion
there
Pook
and
you
just
try
queue
cutter
get
devices.
B
B
Alright,
so
I
said
already,
it's
just
a
different
picture
of
what
what
I
said
before
that's
a
server
and
your
request
comes
in
there's
no
conversion
going
on
for
CDs
it's
bit
different
and
for
native
types.
The
conversion
happens
for
cides
when
it's
it's
wet
from
HDD,
it's
converted
to
the
world
from
so
request,
so
from
green
tube
to
blue
here.
In
this
case,
the
rest
logic
is
done
like
an
update
or
patch
is
done,
and
when
it's
written
back
there's
a
second
conversion
so
expect
two
of
them
at
least
they
can
be
more.
B
If
you
have
epics
involved
that
books
might
require
different
versions,
there
might
be
many
more
of
those
calls
to
a
report.
But
the
normal
case
for
for
a
white
operation
is
to
at
these
two
points
in
the
API
server,
the
APS,
our
coils
out
to
your
epic,
and
to
do
that
you
have
to
register
every
side
web
book
already
it's
in
the
manifesto
society.
So
it
knows
about
that
and
we'll
do
those
codes
and
those
calls
will
get
an
object.
B
A
A
So
let's
look
a
little
bit
at
the
code
in
the
conversion
directory
is
where
we
have
the
code
for
our
conversion
web
hook
and
if
you'd
like
you,
can
look
briefly
at
main,
go
we're
not
going
to
make
any
changes
there,
but
it
will
give
you
a
sense
of
what
some
of
the
setup
in
handling
code
for
a
conversion
web
poky
is
and
then
the
bulk
of
our
actual
business
logic
is
over
in
convert.
Go
we've
got
three
main
functions
that
we're
gonna.
A
Look
at
really
briefly
and
we're
gonna
see
see
how
this
is
works
and
how
we
test
it
and
how
we
make
sure
it's
right.
So
this
is
the
main
function
and
it's
only
responsible
for
converting
one
object.
We
get
lists.
We
get
lists
of
object
to
convert
from
the
API
server,
but
we've
already
looped
through
that
in
a
separate
function
and
just
called
this
individually.
A
So
our
two
inputs
here
are
the
object
that
needs
to
be
converted
and
what
we
need
to
convert
it
to
the
API
version
string
tells
us
what
we
need
to
convert
it
to.
We
need
to
either
successfully
convert
that
object
or
return.
Some
back
some
meaningful
error
about
why
we
couldn't
now,
in
our
particular
case,
we're
only
supporting
the
conversion
of
the
device
customer
resource
type.
So,
in
our
switch
statement,
we're
gonna
handle
both
of
converting
from
v1
alpha
1
and
from
v1.
A
So
that's
our
two
cases
and
let's
just
look
at
one
of
those
cases,
because
the
other
one
is
going
to
be
symmetrical
to
it.
So,
in
the
case
where
we
get
a
v1
alpha,
one
we're
going
to
make
sure
that
we're
actually
converting
it
to
v1.
It's
the
only
other
thing
we
could
convert
it
to
so
far,
because
we
only
have
two
versions,
so
we
just
make
a
check
on
that
and
then
what
we're
gonna
do
is
we're
gonna
return
back
as
v1
device.
A
This
is
the
same
as
the
input,
except
that
the
values
are
different,
because
that's
the
only
thing
that
we
changed
about
our
devices
was
how
we
structured
our
values,
so
you'll
see
everywhere,
have
a
value
list
we're
just
going
to
call
conversion
function
there,
but
otherwise
we're
building
a
device
result.
That
is
the
same
as
what
we
were
provided
with
and
we
would
do
basically
the
same
thing
for
v1
interest
in
the
reverse.
A
Now
testing-
and
this
is
interesting-
you-
you
really
don't
want
to
put
something
like
this
into
production
until
you've
tested
it
pretty
carefully,
and
fortunately,
kubernetes
has
been
building
and
testing
converters
internally
for
a
long
time
for
all
the
built-in
types.
So
we
can
kind
of
leverage
the
strategies
have
been
used
there
to
do
some
testing
and
go.
Has
a
utility
library
called
the
fuzzer
that
we're
going
to
take
advantage
of
what
the
fuzzer
will
do
is
if
we
give
it
some
type,
some
go
type
that
represents
say
our
device.
A
It
can
populate
that
with
values.
Now
we're
gonna
have
to
augment
that
a
little
bit,
and
so
what
we've
done?
If
you
go
and
look
in
the
api's
directory,
you
can
see
the
directory
here
listed
right
up
at
the
top.
If
you
go
and
look
at
this
file,
what
we've
done
is:
we've
augmented
our
fuzzer
to
know
how
to
handle
and
produce
a
valid
value
in
the
case
where
you
can
either
have
an
integer,
a
boolean
or
float.
These
were
all
for
kind
of
the
purposes
of
the
fuzzer.
A
It
just
thought
that
these
were
three
optional
fields,
and
it
didn't
know
that
it
should
only
populate
one
of
them
every
time
it
creates
an
object.
So
we're
telling
it
to
do
that
so
we're
just
taking
a
random
value
between
this
value
of
zero
and
three
and
picking
which
of
those
possible
options
to
produce,
and
once
we've
done
this
we've
now
told
the
fuzzer
everything
it
needs
so
that
it
can
generate
valid
devices
for
us,
and
you
would
do
this
for
whatever
types
of
objects
you
have
in
the
cases
of
basic
fields.
A
The
fuzzer
already
knows
what
to
do.
In
the
cases
where
you
have
more
complex
types
or
validation
rules,
you
might
need
to
teach
it.
What
is
valid
once
you've
done
that,
then
it
gets
pretty
straightforward.
Here
we
have
some
fairly
general
purpose
code,
that's
just
iterating
over
the
types
that
we
have
and
the
versions
of
those
types
and
then
it's
going
to
run.
You
know
a
thousand
iterations
of
what
we
call
a
round-trip
test,
and
so
all
we're
going
to
do
is
you
take
advantage
of
our
fuzzer
to
create
an
object?
A
We
create
an
object
X,
we
populate
it
with
our
fuzzer.
We
stamp
on
the
correct
route
version
kind
for
it,
and
now
we
have
a
generated
object.
We
then
figure
out
which
version
we're,
which
is
just
the
opposite
version
we're
already
at
so.
If
we're
already
at
v1
we're
gonna
convert
to
view
1
alpha
1,
and
then
we
just
do
two
conversion
steps
right
here.
First,
we
convert
it
from
the
version
we're
at
to
the
other
version,
and
then
we
just
convert
it
back
again.
That's
round-tripping!
A
Once
we've
done
that,
we
should
be
able
to
assert
that
what
we
started
with
is
also
what
we
ended
with
right
as
long
as
you
as
long
as
we
can
say,
it
went
back
from
one
version
of
the
other
and
then
back
again
with
round
round
trip
tested
ax.
So
here
you
can
see
that
flow.
You
start
with
v
1
you
go
to
V
1
alpha
1,
you
go
back
to
V
1
and
you
check,
if
they're,
equal
and
we'll
do
that
in
both
directions,
and
we
can
actually
run
this.
A
B
So
it's
in
the
conversion
directory,
so
it's
part
of
converting
their
book
and
there's
a
convert
test
and
that's
where
we
have
put
the
tests
here
and
yeah.
We
have
a
very,
very
simple
test,
convert
which
just
has
two
examples,
or
something
like
that
and
yeah,
just
small
cast
very
simple,
but
it
doesn't
use
passing
and
the
second
one
if
you
go
down
here.
This
is
what
what
Joe
just
talked
about
and
everyone
that.
A
A
Yes,
this
is
it
so
this
is
the
air.
It
was
on
our
deep
equal
comparison.
So
let's
look
at
what
this
does.
First,
it
does
a
reflect
D
people
and
checks.
If
what
we
originally
passed
in
is
what
we
got
back
and
if
that's
not
equal,
then
it
prints
our
air
and
it
uses
a
diff
object--
reflect
diff
to
print
out
how
the
object
had
expected
differs
from
what
it
got
and
so
a
is.
What
is
it
expected
and
B
is
what
it
got
now.
This
is
a
little.
A
It
takes
a
little
bit
of
go
knowledge
to
interpret
what
these
two
strings
mean.
The
first
string
means
that
you
have
a
a
slice
of
type
V
Wanda
value,
but
it's
nil,
and
this
second
one
says
you
have
a
slice
of
v1
dot
value,
but
it's
empty.
So
it's
not
nil.
It's
just
an
empty.
It's
just
an
empty
array,
so
to
speak,
where's
the
first
one
is
actually
in
nil
array.
Well,
that's
a
problem,
so
I
think
the
next
step
would
be
to
go
and
find
where
in
the
code
that
happened.
A
So
what
we
could
do
is
go
into
our
convert
function
and
I'll.
Give
you
guys
all
a
second
to
see
if
you
can
find
it,
but
what
we're
looking
for
is
when
we
have
v1
values-
and
you
know
we
converted
those,
presumably
from
v1
to
v1
alpha-1
in
the
back
to
v1
again
because
and
we
were
expecting
to
get
a
nil,
but
instead
we
got
an
array.
B
Man,
this
kind
of
analysis.
We
show
it
because
it's
what
we
do
when
we
build
api's
with
conversion.
It's
it's
really
about
very
detailed
and
rigorous
work
to
get
things
right
to
get
this
equality
which
we
had
on
the
sound
trip,
100%
correct,
so
it
makes
a
difference
whether
there
is
nil,
which
is
a
null
in
undefined
and
Jason,
usually
or
it's
an
empty
element,
because
you
can
imagine
when
your
own
trip
sudden
these
object
changes,
and
this
is
nothing
you
want
to
have.
B
So
it's
really
something
we
do
every
day
when
we
build
native
API,
it's
the
same,
the
same
procedure,
the
same
steps
here
you
must
be
this
impaired
and
get
it
yeah
as
wide
as
possible.
Remember
that
we
said
exhaustive
tests
so
only
test
things
I
mean
test
as
much
as
possible,
with
fuzzing
with
random
values,
but
only
rarely
dated
objects,
there's
no
sense
to
convert
something
which
is
not
wedded.
So
this
whole
process
here
of
getting
out
rips,
writes
it's
a
kind
of
counter
play
or
a
counter
part
of
validation.
B
In
the
moment,
you,
you
define
the
validation
like
the
open,
API
based
we
have
here.
You
also
work
on
your
own
trips,
so
it's
always
both
sides
and
get
them
to
match.
This
is
the
basic
idea
here
and
if
I
won't
rip
works,
and
you
are
sure
it's
pretty
exhaustive
what
you
do
there,
what
we
test
there
then
you're
pretty
sure
that
validation
is
good
and
yeah,
so
our
trip
is
really
something
which
is
by
active.
So
it
goes
really
without
any
data
loss
in
both
directions.
So.
A
A
A
B
Enough
all
right
so
1000
times
it
works.
The
trance
is
high
that
this
wood
will
be
correct
in
the
native
types.
Actually,
we
have
it
sometimes
even
after
1000,
iterations
in
CIA
might
be
fake,
so
maybe
after
100
runs.
We
find
some
some
case,
some
random,
where
you
spent
still
wrong,
but
1000
already
pretty.
A
Good,
but
there
are
some
advances
at
the
buzzer,
so,
for
example,
if
later
somebody
went
and
added
a
new
field
to
this-
and
it
was
just
a
string-
the
fuzz
would
automatically
pick
that
up
and
start
testing
it.
So
it
means
that
in
many
cases,
you're
going
to
have
to
do
less
work
to
keep
your
tests
in
sync,
which
could
result
in
fewer
defects
than
having
to
manually
manage
that.
So
there's
a
trade-off.
A
B
Maybe
before
before
I
do
that
I
just
show
once
in
such
a
manner
that
it
really
works
so
I
haven't
proofs
a
new
change.
Now
I
mean
this
nail
is
not
really
visible.
It's
it's
not
so
far.
I
mean
it's
important
to
get
it
right,
but
I
haven't
pushed
it
now
so
get
devices,
as
I
said
it
will
just
take
say.
One
version
looks
fine.
Let's
look
at
one
of
them
and
maybe
shows
me
lots
of
modules.
I
wanted
to
see.
No,
because
the
controller
doesn't
work.
Quite
oh.
B
I
work
there
would
be
value,
so
you
don't
really
see
any
difference.
But
what
do
you
see
at
the
moment?
It's
it's
a
v1,
so
Q
part
uses
v1
and
if
you
want
to
use
a
different
version,
you
have
to
do
it
like
that.
So
you
have
to
white
the
resource,
names
and
subversion,
and
then
the
group
name-
and
in
this
moment
the
conversion
is
called.
We
could
look
at
the
conversion
there
poop
now
there
might
be
a
lock
line,
but
you
see
here
it's
now
v1
i1,
so
this
works
yeah.
B
Here
we
actually
have
something.
Why
do
we
have
I'd
say
list
I
thought
every
everything
not
only
yeah,
so
we
have
some
values
here
and
you
see
them
there.
We
need
to
be
one
I
for
one
variance
where
you
have
the
value
and
the
type
all
right
so
much
about
conversion,
so
home
tube
testing.
Please
do
it
if
you,
if
you
start
with
that,
it's
a
super
useful
tool
and
we
learnt
when
we
really
use
that
in
upstream
development.
B
The
chance
is
very
high.
Is
that
we
get
it
right.
Conversion
is
hot,
so
don't
be
afraid,
it's
hard
for
everybody,
everything
which
is
non-trivial
and
conversion
to
get
it
completely
right
and
without
data
loss
it
takes
time
it
takes
gray
hair.
So
it
gives
you
a
gray
hairs.
It's
it's
a
hard
task,
Oh.
What
attrition
a
lot
of
things
you
can
do
an
open
API,
but
you
cannot
do
everything.
Open
API
is
limited
to
a
certain
degree,
especially
you
cannot
do
things
like
here.
B
I
want
I
want
to
to
check
if
I
create
a
module
that
all
the
devices
actually
exist.
So
it's
something
which
is
far
beyond
open
API,
so
it
wants
to
to
check
devices
life
when
a
request
for
module
comes
in.
So
if
you
create
no
module
or
an
update
module,
it
will
check
those
three
devices
exist,
so
it
has
to
make
calls
as
a
API
server.
So
it's
much
more
than
you
really
do
this
open
API,
which
you
can
do
admission
yeah.
It's
a
big
yellow
block
here
in
the
chain.
B
Validation
of
open
API
happens
here,
whereas
white
block
of
validation
is
validation,
of
using
admission
happens
just
after
so
we
will
each
one
of
those
blocks
here
on
the
right
of
validation
and
our
admission.
Dep
observer
will
serve
that,
so
it
will
get
every
object,
so
there's
one
call
per
object
or
per
request.
Actually,
we
want
to
check,
of
course,
create
an
update,
because
I
mean
the
leads.
We
don't
care
about
as
a
devices
exist
and
gets.
We
are
also
not
interested
in
so
the
updates
and
creates
a
into
a
cell.
B
Interesting
and
pictures
are
part
of
updates.
So
we
really
just
need
those
two
and
our
implementation
here
down
here
it
will.
It
will
have
a
watch
to
the
API
server,
so
it
will
be
qualifies.
The
API
saw
up.
At
the
same
time,
it
also
uses
the
API
to
get
everything
which
has
changed
for
devices
and
we
will
use
an
informer
in
the
code,
so
this
is
really
fast
because
there's
a
memory
cache
of
devices
inside
of
a
book.
So
it's
not
really
life
go
home,
read
to
the
API
servers.
B
That
might
be
some
lag,
maybe
half
a
second.
So
it
can
be
that
device
already
exists,
but
for
this
use
case
it's
good
enough
all
right.
You
have
to
register
that
the
repo
exists,
so
there's
some
object
called
validating
their
pool
configuration
everything.
I
talked
about
here.
It
also
exists
in
a
mutating
form,
so
you
can
also
register
mutate,
mutating
webhooks
to
change
request
to
change
objects
before
they
created
or
updated,
but
we
will
just
use
as
a
validating
case
here,
but
it's
basically
the
same
and
no
much
more
complex.
B
This
is
a
computation,
so
the
object
which
registers
our
webhook
in
the
cluster
and
you
create
this
object.
Asta
white.
We
give
it
a
nice
name
deep-sea
you.
Can
I
oh
I'm
very
important
to
fader
policy
so
when
our
poop
doesn't
work
like
the
pot
goes
down
or
something
like
that
or
network
goes
down
and
we
want
to
fail.
So
we
can
also
yeah
react
open
on
errors
here.
I
think
it
knows
a
key
word.
So
if
you
put
ignore
here,
it
will
try
to
cause
a
red
book.
B
If
it
gets
the
response,
I
mean
it.
It
will
be
followed,
but
it's
we're
focused
on
down
network
or
whatever
it
doesn't
matter,
but
we
want
to
failure.
So
this
is
a
very
important
yeah.
We
want
you
to
tell
it
when
we
are
called.
We
want
to
be
called
on
this
API
hopes
or
own
on
v1
I
for
one.
It's
only
version
four
modules
on
create
and
update,
and
only
on
modules,
be
pretty
strict
here,
I
mean
really
restrictive,
don't
put
white
cards
they're
everywhere.
This
is
about
the
class
testability.
B
So
if
your
web
hoop
goes
down
those
objects,
in
our
case,
the
modules
are
basically
not
working
anymore,
so
yeah
be
prepared.
If
you,
if
you
validate
pots,
for
example-
and
your
web
book
goes
down,
you
will
have
a
hard
time
to
restart
it,
because
the
pot
for
the
red
book
is
also
going
through
the
book
and
it's
it's
circle.
Safe
affluence,
so
try
to
restrict
its
and
be
prepared
for
those
safe
references
when
he's
similar
to
to
the
conversion.
Again,
you
have
you
have
a
client
config
here.
B
So
it's
the
same
thing
I
think
it's
even
the
same
implementation
behind
it's
behind
the
service
and
services.
Name
and
there's
a
path
and
again
there's
admission
review
version
so
abused
the
objects
you
get
are
perfect.
We
have
v1,
so
admission
is
promoted
to
tree
a
meanwhile
but
again,
there's
a
v1,
a
beta
one
version
for
admission
that
I've
used
and
we
will
just
use
that
one
yeah
and
by
that
I
guess
over
knows
everything
about
our
book
and
it
with
chords.
A
A
It's
great
now
that
you've
already
seen
conversion
review.
You
can
kind
of
guess
at
how,
in
addition
review
is
going
to
work
so
I
don't
need
to
say
too
much
more
about
this
side.
Now
admission
review
has
a
lot
more
fields.
This
is
great.
This
means
that
if
you
are
doing
security
checks
or
policy
checks,
you
have
a
lot
at
your
disposal
to
compare
against.
A
In
our
particular
case,
we're
we're
just
interested
in
contents
of
what's
being
changed,
we're
not
interested
in
who
did
it
or
you
know
what
name
space
it
was
in,
or
things
like
that,
so
we're
gonna
focus
in
on
just
two
of
the
fields:
the
object
in
the
old
object.
In
fact,
we're
only
really
going
to
focus
on
the
object,
because
that
is
what
we're
gonna
change.
The
value
to
the
old
object
for
an
update
is
what
it
was
before
it
changed.
That
can
sometimes
be
useful
and
remember
what
we're
doing
here.
A
We've
got
in
every
single
module.
We've
got
three
devices
with
device
names,
and
we
want
to
make
sure
that
those
device
names
that
were
entered
in
they're
only
changed
to
values.
The
point
to
actual
existing
devices
now,
if
it
does
match
an
existing
device,
we
can
return
allowed.
True.
That
means
that
we
are
admitting
this
request.
Everything
looks
fine
if
it
doesn't
we're
gonna
say
a
lot
equals
false
and
we
also
should
provide
back
some
errors
in
the
result
saying
why
this
can
go
all
the
way
back
to
the
client.
A
This
is
the
only
way
they're
gonna
be
able
to
know
what
went
wrong
and
how
to
correct
the
request.
So
if
they
fixed
it
and
tried
it
again,
they
could
be
successful.
It's
very
important
to
provide
something
useful
to
them.
They're,
also,
just
in
passing
now
we're
talking
about
validating
web
hooks.
So
this
doesn't
apply
to
us
directly,
but
if
you
were
to
be
building
a
mutating
web
hook,
the
patch
is
where
you
would
send
whatever
change
you
want
to
make
to
the
object.
A
A
B
B
A
So
now
now
we
have
our
handler
function
and
we
can
look
briefly
at
some
of
the
work
that's
done
there
now.
One
of
the
things
we
have
to
be
able
to
do
is
get
a
list
of
valid
device
names
and
the
way
that
we're
gonna
do
that
is
we're.
Gonna
use.
One
of
the
kubernetes
client
library
is
called
an
informer.
A
What's
going
on
is
a
little
interesting
and
then
former's
first
gonna
list
the
devices
that
you
asked
it
about,
and
then
it's
going
to
establish
an
a
watch
and
it's
going
to
keep
that
cache
up
to
date
and
if
it
ever
gets
too
stale
or
gets
out-of-date
or
needs
to
it
can
relist
and
keep
doing
that.
But
at
any
given
point
in
time.
You're
gonna
have
this
eventually
consistent
cache
and
then
we're
we're.
Gonna
use
the
types
of
findings
that
we
generated
from
our
client
types
to
do
that.
A
So
we've
got
this
nice
convenient
way
of
saying
things
that
v1
alpha
one
devices.
So
we
know
exactly
what
thing
we're
dealing
with
and
then
we're
gonna
create
a
Lister
and
the
Lister
allows
us
to
probe
or
ask
questions
to
our
in-memory
cache.
We
can
get
or
lists
those
devices
and
those
those
are
gonna
be
really
cheap
requests
because
it's
just
a
local
in-memory
lookup
so
now.
A
Well,
now
that
we
have
devices
that
we
can
check,
the
names
of
all
we
need
to
do
is
figure
out
where
to
do
our
validation,
and
you
can
see
that
we
have
this
handler
function.
That's
already
done
some
work,
it's
already
decoded
our
admission
review.
It's
already
decoded
the
request,
and
then
we
get
down
to
a
switch
and
the
case
that
we
care
about
is
when
we're
handling
the
module.
Now
we
configured
our
web
hooks,
so
we
should
only
ever
be
called
four
modules.
A
So
if
we
didn't
get
called
from
module,
it
makes
sense
that
we'd
report
a
failure
back,
which
is
exactly
we
do
in
our
decays
here
in
our
default
case
here.
But
let's
just
go
ahead
and
look
at
that.
The
case
where
we're
handing
a
module
and
see
what
I
could
look
checking
now,
so
we've
got
our
handler.
You
can
see,
there's
our
Informer
there's
our
Lister.
Just
like
I
expected
here's
a
standard,
HTTP
request
handler
it's
reading
the
body,
it's
decoding
it.
A
A
A
Front
of
you,
it's
actually
cool,
it's
got
a
lot
of
nice
keys
and
there's.
Oh
there's
our
pump
and
our
water
and
our
sensor.
Those
are
all
three
of
our
devices
right
there.
So
we
can
just
take
one
of
those.
Now
we've
got
our
device
and
that's
literally
a
device
name
that
dereferences
to,
and
so
then
the
next
thing
that
we're
gonna
have
to
do
and
I'm
gonna.
Let
you
guys
take
over
in
just
a
second
I'll.
Show
you
one
more
small
step.
A
B
A
B
I
think
forwards:
that's
it
enough
at
German
keyboards,
so
here
I
released
at
least
us
basically
the
access
to
the
cache
and
it
has
to
get
function
so
and
just
take
the
water
alarm
here
and
get
gives
us
back.
Watson
advice.
We
don't
care
about
the
device
actually,
but
we
care
about
the
error.
So
if
ever
is
not
nil,
we
have
this.
Nice
I
was
slice
there
already,
so
we
just
edit
and
what
do
we
need.
A
B
B
B
B
A
There's
just
a
to
do
there
if
you
go
into
the
controller
and
find
the
pressure
reconciler,
there's
just
a
little
fun
implemented
function.
If
you
implement
that
you
you'll
actually
see
that
you're
controlling
how
many
pumps
are
running
at
in
any
given
point
in
time.
It's
a
good
exercise
that
you
hear
at
the
end.
Alright.
B
B
B
Where'sa
module
it's
in
module,
Yama's,
so
I
edit,
the
yamen
and
I
just
put
which
one
did
we
fix
actually
alarm,
I
think
so
we
didn't
do
all
of
them.
We
just
checked
the
water
alarm
here.
So
let's
put
something
here
which
doesn't
exist
and
there
we
go
so
it
tells
us
the
device
does
not
exist
and
this
is
is
a
string
which
you
can
pass
back
here.
So
it's
this
message,
yeah,
you
can
put
anything
and
the
user
of
Q
cutter
will
just
see
the
message
as
never
cool.
B
Alright,
so
Wi-Fi
works
fine
looks
like
so.
We
can
skip
the
warning,
your
item,
that
it
doesn't
work
yeah.
So
some
last
task,
so
we
are
nearly
at
the
end
of
the
of
the
talk
yeah,
the
first
step.
You
have
just
done
life
we've
done
at
least
one
one
check
of
one
of
the
devices
here.
Of
course,
there
are
three
of
them
so
test
all
of
them
deploy
that
locally
play
with
it,
maybe
even
try
to
make
it
mutating
at
Mission,
Bay
food
and
see
how
this
work
should
be
the
same.
B
So
it's
very
similar
and,
of
course,
take
a
look
on
the
controller,
so
controller.
If
you
just
run
the
simulator
its
Boeing,
nothing
happens.
What
I
will
die
pretty
soon,
because
Russia
moves
pretty
fast
at
yeah,
some
logic
which
sets
the
pumps
so
use
the
client.
The
client
go
client
for
devices,
depending
on
the
pressure
which
is
wet
from
the
device
from
the
pressure
sensor
and
adapts.
The
controllers.
Adaptive
programs
at
the
pumps
and
yeah
get
to
some
some
pressure,
which
is
near
210
around
10.
A
Right,
well,
we've
seen
a
bunch
today,
so
we
can
just
while
you
continue
working
that
we
can
just
recap,
since
we
only
have
a
couple
minutes
left
so
that
that's
what
we
worked
on.
We
worked
on
the
research
station
and
hopefully,
hopefully,
you've
done
a
good
job
and
kept
walter
alive
and
healthy.
We
covered
a
lot
today,
so
we
covered
versioning.
A
We
talked
about
how
you
can
have
multiple
versions
in
the
same
CRD
and
have
a
deal
about
that
and
we
talked
about
pruning,
which
is
a
really
important
idea:
we're
moving
to
a
really
type
safe
system
for
CRTs,
that's
essential
for
that.
We
talked
about
validation
both
on
single
fields,
and
then
we
talked
about
how
to
validate
across
fields.
We
talked
about
our
webhook
how
to
do
some
more
advanced
cases.
We
wrote
code
to
update
our
api's
using
cout
builder.
A
B
B
B
They
are
new,
but
they're
very
well
tested
inside
of
kubernetes
admission
is
there
for
quite
some
time,
and
we
have
seen
some
projects
or
policy
agent
here
of
course.
So
it's
not
new,
but
conversion
is
new,
is
try
it
if
you've
got
issues
report
them
make
issues
in
queue
builder,
so
we
have
shown
cubed
it's
a
cool
tool.
It
has
some
has
some
rough
edges,
but
we
don't
want
to
live
without
it,
especially
for
open
API.
It's
very,
very
powerful
and
yeah
contribute
to
that
as
well.
A
A
B
B
You
don't
have
to
write
a
gangster's
for
I,
don't
have
like
15
or
20
different
formats.
We
support
and
it's
not
documented
in
116.
If
you
look
in
master
of
cube
inators
and
we
look
on
the
cid
types
we
just
recently
some
days
ago
documented
that
for
like
20
different
formats
exist
already
eyepiece
name
durations
time
stems
all
those
things.
B
You
remove
four
fields,
the
moving
of
fields;
it
doesn't
hold
trip
by
definition,
so
you
probably
I
mean
strictly
speaking,
you
cannot
remove
few
years.
You
cannot
do
anything
with
us
here,
the
obvious
missus.
He
asked
if
you
have
conversion,
which
is
not
by
active
which
uses
data,
it's
just
not
not
allowed.
B
If
you
change
things
like
you,
change
validation,
it's
also
incompatible
because
suddenly
objects
do
not
vary
any
more
there's
one
concept.
Maybe
it
also
applies
here.
There's
one
concept:
we
call
it
ratcheting
updates,
so
we
allow
old
objects
to
be
invalid,
for
certain
fields
even
allow
to
update
them,
but
everything
new
is
really
strictly
validated,
so
this
can
help
sometimes
to
adapt
or
to
change,
validation
or
to
add
fear
to
the
move.
B
Use
for
adding
fields
we
have
defaulting
so
defaulting
is
very
helpful
for
that,
because
even
old
objects
from
Exedy
are
defaulted,
so
you
can
add
fields
and
even
have
values
for
them,
even
for
all
three
old
objects
which
are
created
months
ago.
So
it's
pretty
powerful,
but
deletion
keeps
the
fields
documented
deprecated
and
at
some
point,
do
validation,
maybe
and
restricted
ability,
but
keep
it
because
on
trooping
must
work.
A
The
question
is:
is
is
admission,
the
only
way
to
validate
a
CR
is
created
in
either
cluster
scoped
or
namespace
code.
I
believe
it
depends
on
what
you
want.
You
can
say
when
you
create
a
custom
resource,
you
can
say
whether
or
not
it's
scope
to
name,
sir
yes
or
request
only
just
one.
So
so
you
already
get
out
of
the
box
the
option
of
saying,
if
you
want
this
to
be
a
clustered
scope
to
see
Rd
or
not,
and
then
it's
their
custom
resources
you
create
from
that,
will
automatically
follow
that
rule.
B
A
That's
kind
of
the
classic
thing
you'll
see
like
for
many
of
the
common
cases.
You
don't
necessarily
need
to
use
an
extension
mechanism.
There
are
components
built
in
the
crew
Bernays
to
do
it.
The
nice
thing
about
having
very
general-purpose
extension
mechanisms
like
we
have
is
for
all
those
things
where
you
can't
find
any
weather
other
way
to
do
it.
You
still
have
an
option.
B
B
B
Yes,
only
one
can
so
yeah
one
consideration
is
downgrades
if
the
customer
downgrades,
so
if
you
introduce,
we
won
and
also
set
star
driven
to
be
one
in
this
moment.
You
cannot
download
anymore,
because
a
cluster
suddenly
has
the
ones
in
LCD
and
the
old
controller
cannot
handle
that
anymore.
So,
usually
you
have
this
at
least
one
version
delay,
that's
what
we
do
upstream
at
least
yeah,
and
after
that
you
change
it.
B
But
there's
also
one
thing:
if
you
change
the
storage
Raven,
you
still
have
some
old
objects,
so
keep
in
mind,
you
have
to
migrate.
A
pair
machinery
has
a
tool.
It's
either,
maybe
beta.
Now
it's
called
a
storage
version.
Migrator
it's
under
the
cube
22:6,
where
you
can
tell
this
controller
the
controller
tell
it
Reeve
right
every
see,
IDs,
where,
after
you
change,
the
storage
Worthen
tells
us
migrator,
whose
migration
and
then
everything
is
written
and
everything
is
v1.
If
you
change
to
be
one
yeah.
A
We
also
have
on
the
main
CRD
documentation
for
kubernetes
there's,
there's
a
list
so
kind
of
a
recommended
set
of
migration
steps.
I
think
we
still
have
some
work
to
get
that
a
little
firmer,
but
it
does.
It
doesn't
mention
the
storage,
migrator
and
kind
of
a
basic
flow
and
some
of
the
considerations
you
might
want
to
take
there
yeah.
A
B
Which
advanced
features?
We
are
planning
yeah,
there's
one,
not
sure
it's
advanced
mutability,
there's
a
cap
for
mutability,
so
you
can
say
fields
cannot
be
changed
anymore
after
creation.
I
mentioned
that
briefly
in
the
API
machinery
deep-dive.
So
if
you
want
to
look
to
watch
the
video,
it's
there,
it's
a
cap
at
the
moment.
There's
implementation,
let's
not
merged.
We
targets
to
have
neither
of
that
next,
probably
1:18.
So
this
comes.
We
are
discussing
voodoo
before
any
kind
of
binary
encoding,
but
it's
undecided.
So
it's
very
very
fresh.
What.
B
So
you
can
define
for
a
list
that
it's
actually
a
set
with
named
objects
and
as
we
are
working
on
ready
dating
that
the
name
is
just
used
once
like
containers
and
pots
every
container
as
a
name,
and
they
cannot
really
use
them
as
it
cannot
be
a
conflict,
and
this
kind
of
check
it's
hot.
It's
it's
impossible
to
be
clear
that
an
open,
API
admission
can
do
it,
of
course,
but
you
don't
want
to
write
code
just
to
check
that
this
type
map
type,
that's
new,
okay,.