►
From YouTube: Kubernetes SIG API Machinery 20210811
Description
Aug 11th
-Demo + KEP preview: CEL as embedded expression language for CRDs validation/defaulting/conversion (@jpbetz, @cici37) slides
-(Kevin Delgado) Discuss Server-Side Unknown Field Validation. Align on the goals and proposed API changes.
Next step for kevindelgado@ is KEP, initial performance numbers for strict vs not-strict decoding
-[@howardjohn] Discuss https://github.com/kubernetes/enhancements/pull/2836
Next steps: look into how this can be used with default controllers (for upgrade benefits), how it handles multi-locks, and how we can make sure there is no overlap of the locks
Would be great to review the API part (they `key` field) early to make it more likely that we can try the change in our own controller before upstreaming, without compatibility issues when upgrading to the upstreamed version.
-[eddiezane] Discuss https://github.com/kubernetes/kubernetes/pull/103619#issuecomment-887921598
Please confirm wether the other clients have the same behaviour or just the discovery client, so we can better decide if the fix needs to go into client-go code, or is a documentation problem we have to fix.
A
Okay,
there
we
go
good
morning.
Everybody
today
is
august,
11
2021.
This
is
our
kubernetes
api
machinery.
By
weekly
meeting
we
have
a
number
of
interesting
topics
today
in
the
agenda
and
I
think
we're
going
to
see
some
good
discussions
and
presentations.
So
without
further
ado
who
do
I
handle
the
presentation
powers
to
joe
or
cc
for
the
first
topic?
Let's
start
with
cc,
okay,
so
I
will
stop
presenting
cc.
I
think
you
have
to
request
permission
to
present
or
some
to
share
your
screen,
and
I
will
approve.
A
A
B
A
B
Yeah
so
today
we're
presenting
an
improvement
for
the
crd
validation,
so
we'll
cover,
like
the
overview
of
the
current
way,
we're
doing
crd
meditation
and
the
pinpoint
of
the
identifying
another
proposal
and
we'll
list
some
alternatives
under
consideration.
And,
finally,
there
will
be
a
demo
to
show
the
proof
of
concept
and
all
the
comparisons.
B
So,
let's
start
with
the
overview.
So
current,
the
crd
is
one
of
the
main
way
people
extend
the
kubernetes
and
currently
like
the
validation,
support
kind
of
aligned
with
three
parts
went
through
the
theater
destructor
schema
for
type
checking,
and
the
second
is
the
open,
through
the
open
api
with
revitation,
which
covers
the
regular
expression,
rank
limits,
size
limits
for
maps
and
list
and
also
api
expression.
B
B
So
here
comes
some
of
the
pinpoints
for
the
first
two
building
validation
does
not
support
like
the
complex,
the
validation
rules
and
the
admission
bad
hook.
Just
takes
too
much
effort,
not
only
in
terms
of
the
users
have
to
put
a
lot
of
development
efforts
on
developing
their
own
web
hooks,
but
also
they
have
to
like
integrate
it
with.
Maybe
the
monitoring,
alerting
or
release
processes,
and
also
it
increased
the
operational
complexity
also
like
the
potential
bad
hook.
Failures
might
cause
the
whole
community
uncontrolled
plan
outage.
B
C
Yeah,
I
can
talk
over
them
really
quick,
so
rego
is
used
by
like
the
what
is
it
open
policy
system?
It's
a
it
runs
this.
They
run
that
as
a
web
hook.
You
can
do
a
lot
of
validation
in
it.
It's
a
pretty
full-fledged
language.
It's
designed
to
be
written
as
like
a
separate
file
that
you
wrote
in,
so
you
wrote
in
your
lego,
rego
all
as
a
separate
file.
It's
a
pretty
like
complicated
thing
that
you
can
have
modules
and
packages
for
and
dependencies
between
those.
C
So
as
an
inline
language,
it's
not
really
appropriate.
It
does
do
a
lot
of
advanced
stuff,
but
we're
kind
of
trying
to
target
that
more
specific
use.
Case
of
I
want
to
be
able
to
just
write
some
expressions
that
economy
do
things
like
cross
field,
validation
and
checking
things
not
covered
by
the
very
basic
validation
they
get
with
open
api
expr
is
actually
very
similar
to
cell,
so
I'm
not
actually
going
to
say
that
that's
necessarily
a
bad
choice.
C
When
we
looked
at
at
options,
a
couple
of
the
reasons
we
chose
cell
would
also
be
a
couple
of
the
reasons
you
would
choose.
Expr,
so
as
we
do
experimentation,
we
could
potentially
like
decide
to
pick
something
else.
But
cell
seems
like
a
good
starting
point.
Web
assembly
is
another
interesting
way
to
do
like
loading,
the
validation
you
can
imagine
people
could,
you
know,
write
in
any
program
language,
they
want
some,
you
know,
validation
rules
and
then
they
could
load
them
up
into
webassembly
and
run
them
in
a
sandbox
way.
C
It
turns
out
that
running
like
creating
web
assembly
and
integrating
it
is
a
fairly
involved
thing,
and
this
might
be
good
for
larger
programs.
It's
not
really
good
for
really
small
snippets
and
expressions,
and
it's
also
a
lot
harder
to
sandbox
and
something
like.
So
there
are
examples
out
there
of
people
building
systems.
Where
you
can.
You
write
your
own
web
hook
and
then
you
can
tell
it,
which
is
webassembly
modules.
C
C
What's
going
on
in
these
expressions,
they're
pretty
easy
to
read,
so
we
think
it's
actually
we're
not
to
the
point
where
we're
going
to
like
bail
out
and
say
we
need
to
build
our
own
thing,
although
you
know
who
knows,
maybe
maybe
it
will
come
to
that?
I
hope
I'm
hopeful
it
doesn't,
and
then
you
know
the
other
option
would
be
to
make
web
hooks
easier
to
use.
C
C
I'm
going
to
try!
I've
been
having
the
worst
trouble
getting
a
demo
today,
but
I'm
going
to
try.
I
had
a
trouble
with
this
demo
once
before.
I'm
going
to
try
and
show
this.
If
I
can,
my
kubernetes
cluster
just
crashed,
so
it
might
not
be
doable
again,
but
we're
going
to
try
it.
I'm
going
to
share
my
screen.
C
So
if
I
put
it
in
the
spec,
I
would
have
direct
access
to
all
the
fields
in
the
spec
which
includes
replicas,
min
replicas
and
max
replicas,
and
the
rule
I
want
to
say
here
is
that
min
replicas
should
be
less
than
equal
to
replicas
and
replicas
should
be
less
than
equal
to
natural.
Look,
it's
a
pretty
simple.
You
know,
crossfield
validation
rule
the
way
I'm
going
to
run.
This
is
I'm
going
to
run
a
web
hook
and
I'm
going
to
run
what
sell
on
the
web
hook
and
I'm
going
to
hook
it.
C
So
all
of
these
crd
objects
go
through
that
web
hook,
and
so,
instead
of
having
this,
I'm
just
going
to
switch
it
out
and
just
say
this
format
rule
it's
the
same
exact
logic,
I'm
just
jamming
into
this
format,
string
which
I'm
allowed
to
kind
of
put
anything
into,
and
I'm
going
to
kind
of
hijack
that
just
for
this
demo.
This
isn't
how
we
do
it
for
real.
C
C
The
other
thing
that
I
would
like
to
show-
and
this
is
one
of
the
reasons
I
like
cell-
is
if
you
modify
this
field
name
and
make
it
like
invalid
that
when
I,
when
I
reapply
this
crd,
it's
actually
going
to
not
let
me
it's
not
going
to.
Let
me
make
that
change,
because
there
is
no
field
called
macrap,
because
there's
only
one
called
mac.
C
It
seems
kind
of
nice
to
type
check
this
one
of
the
things
that
might
not
be
so
obvious,
but
it's
really
great,
is,
if
you
decide
to
rename
this
field
down
here.
You'll
also
get
the
error
right,
because
you
didn't
keep
this
in
sync,
and
so
now,
there's
no
field
called
that,
which
means
it's
really
easy
for
developers
to
make
sure
everything's
kept
in
the
proper
state,
and
I
think,
that's
kind
of
a
really
nice
feature
to
have.
C
It
just
makes
things
a
lot
safer
to
develop.
Let's
see,
I
think,
we've
almost
got
that
same
and
then
the
last
thing
I
was
going
to
mention
is
that
you
can
go
and
we
wanted
to.
We
wanted
to
make
sure
that
any
solution
that
we
provided
was
going
to
work
not
just
for
validation,
but
also
for
other
use
cases
where
you
might
want
an
expression,
language
and
the
other.
Two
that
immediately
came
to
mind
were
defaulting
and
crd
conversion,
so
see
one
of
the
nice
things
about
cell.
C
Is
that
not
only
can
you
return
like
a
boolean,
true
or
false
for
an
expression?
You
can
return
any
value,
so
you
know
one
of
the
things
that
we
might
want
to
be
able
to
do
is
say.
I
want
to
rename
a
field
so
here
I
call
this
image
2
for
the
v2
of
this
schema
and
in
v1
it
was
just
called
image
right,
so
I've
just
named
it
renamed
the
field
from
image
to
image.
To
now.
We
wouldn't
really
express
this
this
way,
but
so
I
have
to
jam
stuff
in
a
format
stream.
C
This
is
what
I've
done.
I've
just
said:
well
we're
going
to
convert
a
field
from
v1
and
I'm
going
to
rename
it
to
image
two.
We
can
probably
come
up
with
really
nice
formats
for
this
and
we're
not
going
to
probably
put
it
in
the
schema,
we're
probably
going
to
go
ahead
and
put
that
down
in
the
crd
conversions.
I
don't
know
if
you
saw
that
in
in
the
examples,
but
we
would
probably
have
like
you
know
where
you
have
like
the
weapon
converter.
C
C
C
In
my
invalid
object,
I
I
put
min
replicas
all
the
way
up
to
seven,
which
is
doesn't
match
a
rule.
So
if
I
put
that
back
down
to
three,
then
I
go
apply
that
again
now
it's
fine.
Now,
let's
go
back
and
let's,
let's
mess
with
the
crd,
really
quick,
just
to
show
one
of
those
examples.
So
let's
take
and
misname
min
replicas,
and
then
we
will
go
ahead
and
just
apply
the
crd
again-
and
this
is
this-
is
where
you
get
that
compiler.
C
E
I
got
it
was
a
nice
demo.
I
do
have
some
questions
about
capability,
and
much
of
this
is
just
because
I'm
not
very
familiar
with
cells,
it
said
cell,
so
does
it
have
the
idea
of
predicated
statements?
A
lot
of
cases
where
I
have
validating
admission
web
hooks
is
a
case
of
if
this
value
is
set
to
something
I
want
this
rule
to
have
an
effect.
C
Yep,
yes,
you
do
yep,
you
have
you
have
if
else
expressions,
there
are
some
transform
utilities,
so
yeah
a
lot
of
that's
in
place
so
like
if,
if
we
use
it
in
defaulting,
you'd,
be
able
to
say
like
if
this
field
over
there
is
x,
then
do
y
right
set
this
to
y,
otherwise
set
it
to
something
else,
and
you
could
also
be
concatenated
together.
Other
fields
or
you
know
doing
things
like
that.
C
Yeah
we'd
have
to
look
into
those
use
cases,
but
that's
one
I'll
write
down.
Well,
I
think
one
way
or
another.
We
do
want
to
support
that,
whether
or
not
we
give
you
access
to
like
the
previous
state
of
the
object,
and
you
can
check
that
make
sure
it
hasn't
changed.
Or
has
it
changed
in
a
particular
way?
C
That's
something
that
wouldn't
be
built
into
cell,
but
we
can
choose
what
data
cell
has
access
to
like
your
program,
basically
give
it
a
bunch
of
root
objects,
and
then
it
has
access
to
the
things
within
those,
and
so
we
can
kind
of
we
could.
We
could
potentially
like
in
conversion.
We
give
it
the
all
the
contents
of
the
object,
you're
converting
from
you
know-
and
you
know
in
a
defaulting
case,
you
might
be
able
to
have
access
to
a
bunch
of
other
fields.
E
G
G
C
Yeah,
let
me
add
it
to
our
list.
I
think
it's
worth
looking
at.
It
sounds
like
other
people
enough
people
have
seen
it
that
we
should
have
an
answer.
I
also
want
to
say
that
right
now
we're
not
super
tied
to
sell
specifically
we're
more
tied
to
like
a
feature
set
of.
We
want
something
we
can
compile
and
type
check.
We
want
something,
that's
sandboxed,
we
want
something.
That's
expressive
enough
and
right
now
cell
is
a
great
thing
to
experiment
with
so
yeah.
C
F
I'd
also
say
that
the
at
least
the
paradigm
you
chose
where
you're,
adding
little
snippets
of
rules
depends
on
those
snippets
being
an
expression
and
starlark
from
what
I've
dealt
with.
It
is
more
suited
for,
like
procedural,
like
blocks
of
code,
so
yeah
different
paradigm,
not
that
that's
necessarily
a
blocker
just
just
observation.
Okay,
let's
go
to
the
next
hand,
jason.
H
Hi
yeah,
I
love
cell
great
language,
good
choice
in
the
tekton
community.
We
have
also
experimented
some
with
cell
for
similar
sorts
of
things,
and
it's
been,
it's
been
pretty
successful
so
far.
I
wonder
if
you
so,
if,
if
this
is
successful
and
these
take
off,
I
can
imagine
lots
and
lots
and
lots
of
validation
rules.
H
The
way
that
you
described
it
in
the
demo
was
cell,
inline
and
yaml,
which
two
white
space
aware
languages
in
the
same
file
might
be
a
difficult
developer.
Experience
we've
experienced
that
as
well
in
tecton.
Don't
get
me
wrong
if
you've
thought
at
all
about
the
developer.
Experience
of
writing.
You
know
very
very
complex
expressions
or
many
tiny
expressions
either
way
and
how
that
works.
H
Would
that
be
something
like
you
could
explore
something
like
coup
builder
validation,
where
it's
done
in
go
struct
tags
now
you've
got
white
space,
aware
cell
inside
of
go
comments
which
is
differently
hard
or
you
could
imagine
some
sort
of
embedding
where
you
have
dot
cell
files
that
you
somehow
compile
into
those
things.
I
I
just
wonder
if
you
thought
about
any
of
these,
like
the
developer.
Experience
of
writing
a
bunch
of
cell
in.
C
This
probably
not
enough,
I
I
think
it's
something
we're
gonna
have
to
spend
some
time
and
look
at
some
bigger
examples.
One
of
the
things
I
like
about
the
inline
approach
is
that
you
don't
necessarily
have
to
have
like
a
huge
thing
right
like
if
you
can
do
individual
fields
right
there
with
the
field
you.
C
So
one
of
the
things
that
you
can
do
in
cell
is
that
you
can
provide
a
built-in
set
of
functions
and
we're
gonna
have
to
be
very
careful
when
we
define
these
there's,
probably
things
that
we're
gonna
want
that
are
maybe
kubernetes
specific,
that
we're
gonna
want
to
have
really
easy
ways
to
validate
with,
and
we're
not
going
to
want
to
make
people
write
like
a
complex
rule
every
time
they
want
to
do
something
basic
so
for
that
kind
of
stuff.
Maybe
we
can
help
keep
keep
things
trim.
C
I
I
really
want
to
see
how
far
we
can
go
and
keep
things
from
getting
really
huge
if,
if
things
do
get
really
huge,
I
kind
of
feel
like
this
approach
of
inlining
stuff
isn't
working
super
great,
but
I
would
love
to
see
use
cases.
I
would
love
to
see
counter
examples
that
prove
me
wrong
is
like
this
is
a
totally
reasonable
thing
to
do,
and
here's
like
it
has
to
be.
It
has
to
be
big
and
messy
and
cell.
So
if
you
have
those
I'd
love
to
see
them.
H
H
C
F
E
A
A
I
The
general
idea
behind
this
is
that
today
we
use
leader
election,
but
we
run
to
some
issues
because
we
have
multiple
different
instances
of
our
controller
that
has
different
properties.
So
the
the
like
most
useful
or
like
most
common
issue
we
have
is
that
we
run
multiple
different
versions
of
the
same
controller
because
we
do
like
a
canary
rollout.
I
If
version
one
is
leader
versus
version,
three
potentially
worse
behavior,
because
hopefully
version
three
has
had
some
improvements,
and
so
what
we're
interested
in
doing
is
kind
of
having
a
prioritization
or
a
weighting
on
who
becomes
the
leader,
and
so
the
the
cap
is
kind
of
generic,
where
you
can
define
any
sort
of
key
and
then
some
comparison
function
to
decide.
If
you're
kind
of
a
higher
weight
in
the
case
of
versions
that
would
be
like,
if
my
version
is
newer
than
the
current
leaders
version,
then
I
will
take
the
leader
election
lock.
I
I
I
Yeah,
so
I
guess
in
rollback,
when
you
have
both
still
running
concurrently,
the
newest
one,
if
you
set
up
your
leader
election,
that
way
would
still
be
the
leader,
but
eventually,
once
the
new
one's
gone
it
would,
you
know,
release
the
lock,
whether
that's
automatically
or
after
it
times
out,
so
it
would
still
work
somewhat
in
that
way.
In
our
actual
use
case,
this
would
be
for
istio.
We
actually
are
not
planning
to
use
newest
version,
always
wins.
I
E
I
I
E
I
Yeah,
it
does
impossible,
like
you,
could
somehow
indicate
to
the
other
client
like
I
am
going
to
take
over
the
lock.
Please
release
it
and
then
once
you've
released
it.
I
will
take
it
over
one
issue:
if
we
do
that
is
it
would
require
that
everyone,
like
all
the
clients,
are
updated
to
have
that
code.
Otherwise
they
won't
understand
that
someone's
about
to
take
the
log
condition
should
lose
it
right.
I
guess
maybe
not.
I
guess.
I
E
I
E
E
E
F
F
I
I
F
If,
if
you
package
this
with
also
fixing
the
default
controllers
to
take
advantage
of
this
and
improve
the
upgrade
experience,
then
then
upgrade
safety,
then
then
I
become
more
interested,
I
think
yeah,
I
think
walter
and
maybe
jordan
could
be
persuaded
to
be
interested
in
that.
Also,
that's
my
guess.
C
C
I
F
J
Yeah
no
worries,
I'm
not
sure
that
it'll
cause
a
problem,
but
I
do
think
one
thing
you
want
to
make
sure
you
walk
through
a
couple
of
our
migration
use
cases
involve
halting
holding
multiple
sort
of
ordered
leader
election
locks,
and
so
I
think
both
when
we've
done
things
like
migrated
from
one
type
of
leader,
elect
lock
resource
to
another
and
also
the
controller
manager.
Migrator
both
have
this
tendency
to
hold
multiple
leader
election
locks,
so
we
should
make
sure
we
walk
through
those
use
cases
with
this.
F
I
D
You
know
the
dash-validated
flag
on
on
cube
control,
and
this
creates.
This
has
a
lot
of
issues.
You
can
read
the
attached
issues
there
in
the
motivation
section
and
for
years
we've
been
trying
to
get
rid
of
of
the
client-side
validation
it
you
know
it.
It
needs
to
be
re-implemented
across
clients
stuff
like
that
and
the
the
only
blocker.
That's
that's
stopping
us
from
being
able
to
remove
validation.
The
one
kind
of
use
case
that
we
want
to
keep
is
for
unknown
field.
D
So
if
you
send
in
an
object
to
the
api
server
and
you
pass
on
some
unknown
fields
with
the
validate
equals
true
flag,
it'll
it'll
error,
if
you
give
it
unknown
fields
and
it
won't
air
it'll,
just
drop
those
fields.
If
you
don't
have
that
validate
flag,
and
so
basically
you
know
the
goal
here
is
to
implement
that
on
the
client
on
the
server
side
and
the.
If,
if
everyone's
in
agreement
that
we
want
to
do
that,
then
kind
of
the
question
at
hand
is:
is
how
do
we
want
the
api
to
to?
D
You
know,
learn
about
this.
How
do
we,
how
do
we
opt
into
this
on
the
api
on
the
api
server
and
the
there's
a
couple
ways
that
I
proposed,
and
I
think
the
most
consistent
way
is
the
content
type
header
so
passing
in
you
know.
Currently
we
have
media
type
parameters
that
we
can
pass
in
on
the
content
type
header
so
like.
E
E
D
Yeah,
so
the
the
answer
to
the
json
iter
question
is
that
that
also
supports
the
disallow
unknown
fields
in
the
same
way
that
encoding
slash
json
does
so.
I
don't
think
that
shouldn't
be
an
issue.
It's
it's.
I
think
it
claims
to
be
a
you
know,
a
exact
match
of
the
of
the
standard
libraries
json
package,
just
it's
more
performant
or
something.
F
D
Right
so
duplicate
fields,
it
also
checks
for
in
the
strict.
We
currently
have
a
test
case
for
this
in
the
json
test,
serializer
package
in
kubernetes
kubernetes,
so
that
should
work
there
and
for
the
the
protobuf
question.
I
think
that's.
That
is
a
good
question.
There
was
a
discussion
I
had
with
joe
about
this
and
I'm
trying
to
find
those
notes,
but
basically.
F
C
E
D
F
F
D
Yeah,
so
I
think
the
next
step
from
here
is
that
I
will
finish
the
the
cap
around
the
implementation
kind
of
design
of
the
patch
use
case,
which
I
think
is
a
lot
more
involved
than
the
create
an
update
use
case
and,
and
I
think
from
there
we'll
have
kind
of
a
full
cap
and
a
better
understanding
of
the
effort
and
the
review
time
required
for
this.
But
those
are
the
next
steps.
F
E
I
do
have
another
question:
once
you
have
the
ability
to
detect
this,
do
you
plan
to
send
back
warnings
when
fields
are
unknown
sort
of
unconditionally
or
or
do
you
not
see
value
there?
Are
you
saying
warning
when
you
don't
set
the
validate
flag
or
when
validate
is
false?
I'm
saying
if
you
can
detect
that
someone
is
trying
to
set
a
field
that
isn't
present.
Is
that
worthy
of
a
warning.
F
E
F
C
Yeah,
when
I
heard
I
was
thinking
of
like
you
know
that
that
parameter
having
like
a
third
state
right,
so
you
could
either
have
it
absent,
which
is
the
current
behavior.
You
could
have
it
strict,
which
is
air
out
or
you
could
have
even
another
state
which
warns
and
then
people
would
even
have
to
opt
into
the
warning
which
might
be
nice
for
rolling
this
out,
because
there
might
be
a
performance
implication.
F
So
I
I'm
actually
thinking
about
this
and
and
like
for
post
and
put
like
you're
just
gonna
decode
it
with
a
special
option
and
if
there's
no
problem
with
it,
you
don't
have
to
like
redecode
it
or
anything
like
that.
So
I
think
the
performance
implication
should
be
very
minimal
for
for
patch.
I
agree
that
that
it's
less
obvious
how
that's
going
to
shake
out.
D
F
Okay,
I
in
that
case,
I
I
do
think
if
you
can
prototype
and
get
us
some
just
preliminary
ballpark
performance
numbers,
it
seems
like
we
might
want
to
just
do
it
all
the
time,
rather
than
only
when
you
ask
for
it
that
would
simplify
the
design.
A
lot
actually
yeah
yeah
sounds
good
to
me
yeah.
So
I
think
that's.
The
next
step
here
is
to
is
to
get
some
performance
numbers.
A
K
Sure
so
this
is
hopefully
a
quick
one.
We
had
an
issue
come
through.
This
user
observed
that
they
were
not
seeing
their
timeout
respected
with
cube
control,
and
the
issue
turns
out
to
be
that
discovery.
Clients
well
because
of
go's
default
typing.
A
value
of
0,
which
is
what
we
specify
in
the
documentation
for
client
go,
is
to
pass
a
0,
which
means
no
timeout.
K
The
problem
is
that
the
code
specifically
says:
if
it's
zero,
it
adds
the
default
timeout.
So
it's
kind
of
just
like
weird
loop,
so
like
a
negative
one
will
work
to
not
do
a
timeout,
but
if
a
user
tries
to
set
zero,
which
is
what
we
specify
it
ignores
that
and
does
the
default
timeout
anyway,
and
this
is
for
all
discovery,
clients.
K
K
E
K
F
F
E
E
K
F
Yeah
there
are
some
dragons
lurking
in
the
in
the
timeout
handling,
because
we
have
different
notions
of
timeouts
for
different
requests,
especially
watches.
Like
you
tell
the
server
what
the
timeout
you
think
should
be,
and
then
the
server
will
close
your
connection
eventually,
which
is
not
how
most
normal
people
think
a
timeout
should
work
yeah.
So
it
may
be
more
confusing
than
you
expect.