►
From YouTube: !go, Interacting with and Extending Kubernetes in a Polyglot World - Brendan Burns, Microsoft
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
!go, Interacting with and Extending Kubernetes in a Polyglot World - Brendan Burns, Microsoft
Kubernetes is implemented in golang and most of the tools around extending it or automation using it (such as kubebuilder) are written in golang. Accessing APIs in another language and writing controller loops or automation tools using non-go languages helps expand the community and tooling around the project and give more options to users. Kubernetes-client is a project started a year ago around the idea of accessing kubernetes in as many programming languages as useful. It based on OpenAPI spec generated from main kubernetes repository and standard client generators such as swagger-codegen. This talk will cover these topics: OpenAPI for standard types Structure of kubernetes generated clients Example: Python client Pros/Cons of generated clients Builder pattern (e.g. Java client) ProtocolBuffer Generation (and challenges) Client generation for CRDs Demo: A controller loop in python
To learn more: https://sched.co/GrUa
A
Hi
I'm
Brendan
I'm
gonna
talk
today
about
some
of
my
work
and
really
it's
team
work
on
developing
alternate
client,
libraries,
the
official
alternate
client
libraries
for
kubernetes.
This
was
actually
intended
to
be
a
co
presentation
with
mehdi
from
Google
who
I
work
with
on
this
particular
project.
Unfortunately,
he
couldn't
be
here
because
he
his
plane
conflicted
with
the
talks
lot.
So
when
we
submitted
the
talk,
he
actually
did
most
of
the
hard
work
to
get
the
talk
submitted.
But
I
get
to
be
up
on
stage
to
talk
to
you
today.
A
So
I,
don't
know,
I,
don't
know,
I,
don't
know
whether
that's
a
fair
trade
or
not,
but
but
many
thanks
to
him
for
for
helping
kick
this
off
and
actually
do
a
bunch
of
the
work
that
I'm
going
to
talk
about
all
right.
So
I
wanted
to
start
first
with
our
goals.
The
real
idea
behind
this
part
of
the
project
was
that,
as
you
know,
kubernetes
has
gained
in
popularity
and
everything
else
like
that.
There
are
more
and
more
people
who
want
to
be
able
to
interact
with
the
API
in
a
specific
programming
language
either.
A
This
is
because
of
familiarity
or
existing
code,
or
because
of
integration
with
a
larger
project.
Tools
like
Jenkins
are
written
in
Java.
So
having
a
Java
client
makes
sense
tools
like
Visual
Studio
code
are
written
in
typescript,
so
having
a
typescript
client
makes
sense.
There
are
people
who
are
passionate
around
certain
communities.
A
Now
one
of
the
things
that
you
realize
is
that
and
I'm
sure
that
all
of
you
are
aware
at
this
point
is
that
kubernetes
is
a
very
rapidly
changing
target
and
if
we
were
sitting
down
and
I,
don't
know
how
many
api's
there
are
at
this
point,
but
I'll
show
you
the
JSON
file.
That
represents
all
the
api's,
and
it's
like
three
megabytes
at
this
point.
I
think
something
like
that.
A
So
that's
a
lot
of
api's
if
we
were
hand
carving
out
all
of
those
all
of
those
api's,
it
really
wouldn't
be
feasible,
and
I
think,
if
you
look
at
the
handwritten
libraries
that
exist
out
there-
and
there
are
a
few
of
them-
they
cover
you
know
eight
or
ten
of
the
most
popular
objects
and
then
they
stop.
Whereas
if
you
use
a
code
generator
approach,
you
can
you
can
cover
the
entire
api,
even
as
the
api
changes,
and
so
we'll
talk
a
little
bit
about
that.
A
When
we
talk
about
the
goal,
the
the
approach
that
we
took,
but
the
one
of
the
goals
is
not
just
to
have
great
libraries
for
kubernetes
and
all
these
different
languages,
but
actually
to
have
libraries
that
cover
the
entire
space
of
the
API
so
that
we
don't
have
to
say
hey.
You
know
what
you
can't
use
that
particular
new
alpha
feature,
because
we
haven't
bothered
to
write
down
a
lot.
A
A
They
have
wide
heterogeneity
in
terms
of
the
feature
sets
that
they
have,
and
people
who
program
in
those
languages
want
them
to
feel
fluent
and
want
them
to
feel
idiomatic,
and
so
we
need
to
be
able
to
sort
of
each
individually
or
collectively
become,
if
not,
experts,
at
least
familiar
enough
with
the
languages
that
we're
building.
For
that
we
build
libraries
that
feel
right
and
that
people
aren't
sort
of
chafing
against
as
they
as
they
use
those
libraries.
A
So,
in
addition
to
having
a
bunch
of
libraries
that
target
kubernetes
successfully,
we
also
want
to
make
sure
that
those
programming
language
communities
also
feel
very
natural,
and
that's
this
extends
also
into
tool
integration,
so
that
you
know
in
the
Java
world,
there's
a
set
of
ways
that
people
manage
dependencies,
making
sure
we're
integrated
in
that
via
maven
and
Gradle,
and
all
of
these
tools
that
exist
that
people
expect
to
just
work.
Similar
things
are
true
with
NPM
in
the
JavaScript
world,
with
nougat
in
the
c-sharp
world,
you
know
pip
in
the
Python
world.
A
There's
a
bunch
of
these
things,
though,
so
it's
not
sufficient
to
just
write
good
libraries.
It's
actually
also
a
case
that
you
have
to
go
and
learn
how
to
actually
distribute
software
into
each
of
these
different
communities,
and
actually
that's
been
a
very
interesting
learning
for
me
anyway,
and
then
I
think.
A
You
know
how
capable
a
particular
client
library
is
as
well
as
the
fact
that
it-
and
this
is
one
of
the
challenges
actually
as
they'll
talk
to
you
in
a
little
bit-
ensuring
that
if
you
know
Cube
control
and
a
particular
cube,
config
work
that
the
library
and
that
same
cube,
config
work
all
right.
So
if
user
can
use
the
go
client
or
can
use
the
command-line
tooling,
and
then
they
use
the
Java
library
and
suddenly
they
can't
load
the
same
config
file
or
it
doesn't
authenticate
properly.
A
That's
a
problem,
obviously,
and
and
and
as
we'll
see,
that's
actually
an
ongoing
challenge,
because
it's
that
behavior
is
more
or
less
totally
unspecified,
except
for
in
the
code.
But
before
we
move
on
to
some
of
the
challenges
that
we
see,
I
wanted
to
give
you
some
examples
of
what
this
looks
like,
and
this
is
actually
drawn
from
the
Python
library.
A
Hopefully
that's,
legible
and
so
much
like
anything
else.
Any
other
library
you're
going
to
import
a
bunch
of
files,
and
this
pattern
actually
looks
at
the
oh
you'll,
see
that
the
code
looks
fairly
similar.
We
load
up
our
config
to
load
in
the
cube
config
file,
and
then
we
can
open
up
a
yamo
file
as
a
file
descriptor.
We
can
use
them
the
yamo
library,
the
built-in
Python
Yamma
library,
to
load
that
into
an
object.
A
We
can
create
a
client
and,
and
the
clients
are
per
API
group,
so
you'll
see
there
I'm,
creating
a
client
for
the
tensions,
view
and
beta1
api
once
I
have
that
client
for
the
extensions
v1
beta
one
API
I
can
make
a
call
to
create
namespace
deployment.
Give
that
body
that
I
loaded
in
from
yeah
mol
give
the
namespace
and
then
once
that
all
works
I
can
print
out.
You
know,
yeh
I've
created
a
deployment
and
I
think
that
this
this
shows.
A
You
that
the
libraries
do
actually
you
know
that
looks
largely
just
like
Python
code
that
you
might
otherwise
write
with
a
few
weirdnesses
like
the
camel
casing
of
the
extensions
v1,
Beta
API,
and
things
like
that,
and
that's
one
of
the
challenges
we'll
talk
about
in
a
little
bit
a
typescript,
very
similar
import
statement
to
pull
the
library
and,
at
the
top,
creating
of
a
cube.
Config
object
loading.
A
The
cube,
config
object,
creating
the
API
object,
in
this
case
we're
using
generics
to
be
able
to
parameterize
and
instantiate
the
extensions
v1
beta
one
API,
creating
a
deployment
by
loading
in
from
Y
Amal
again
using
a
built,
not
a
built
in,
but
a
yam,
a
library
that
exists
out
there.
That
has
been
integrated
into
the
client
and
that's
another
aspect
of
what
we
do.
It's
not
sufficient
to
just
build
these
client
libraries.
A
You
actually
have
to
build
a
bunch
of
utilities
around
them
that
people-
well,
you
don't
have
to,
but
it's
nice
to
build
a
bunch
of
utilities
around
them
that
people
expect
so
the
ability
to
easily
load
code
from
you
Amal
in
some
languages.
That's
more
built-in
yeah
milles!
Pretty
native
to
Python
in
other
languages
like
typescript,
not
as
native
and
then
finally
we're
going
to
create
this
deployment
and
again
you'll
see
this
is
idiomatic
more
more
idiomatic
JavaScript,
where
or
typescript
we're
like
so
du
Maurier,
di-o-matic
typescript.
A
Actually,
if
I
was
using
a
wait,
but
it's
idiomatic
JavaScript,
where
I'm
making
a
call
into
creating
a
namespace
object
and
I'm,
giving
some
promises
I'm
getting
back
a
promise
and
some
handlers
that
are
called
depending
on
how
that
promise
outcome
comes
out.
But
it's
doing
exactly
the
same
thing,
and
so
the
Python
developer
can
create
a
deployment
using
the
Python
code.
In
the
previous
slide,
the
JavaScript
developer
can
create
a
deployment
using
the
JavaScript
code
here
and
similarly
for
Java
and
c-sharp
and
Haskell
and
and
so
on
and
so
forth.
A
Speaking
of
the
cluster
configuration
I
think
it's
an
interesting
topic
because
it
sort
of
describes
some
of
the
challenges
that
we
that
we
had
when
we
sat
down
to
write
this
object
or
write
these
libraries.
So
can
anybody
out
there
tell
me
what
the
loading
order
is
for
cube?
Config
files
like
if
you
read
cube
control?
Do
you
know
the
order
in
which
it
looks
for
files,
anybody,
sorry,
what
okay
environment
variables?
First,
that's
right.
A
Home
local
directory
is
the
next
one.
In
many
cases
it
looks
in
the
cluster.
It
looks
for
some
magic
stuff
inside
the
cluster
and
then
it.
Finally,
if
all
else
fails
it
defaults
to
localhost
8080
and
that's
actually
not
entirely
true,
because
on
Windows
there's,
actually
multiple
different
places
that
you
might
call
a
home
directory
and
so
there
in
the
go
client
and
totally
undocumented
anywhere
until
a
customer
or
a
user
yelled
at
us
that
this
cube
config
didn't
work
for
them.
A
A
So
now
we
actually
do
have
parity,
I,
think
and
the
reason
that
I
say
I
think
is
because
I
don't
have
a
test
right.
I
can
write
unit
tests
for
this
behavior,
but
I
don't
have
any
like
canonical,
hey
I
can
download
a
set
of
directories
and
a
set
of
environment
variables
and
I
can
run
all
my
libraries
through
it
and
validate
that
you
know
the
same.
Config
was
loaded
in
all
of
them.
There
is
nowhere
in
the
project.
Is
there
specified
this
behavior
and
the
corresponding
sort
of
compatibility
tests
that
you
might
expect?
A
And
then
there's
this
added
wrinkle,
which
is
not
true
of
the
loading
you
know
from
a
command-line
tool,
which
is
that
in
a
programming
and
programmatic
environment,
many
people
expect
to
be
able
to
build
their
config
from
scratch
or
be
able
to
build
their
config
from
in-memory
objects
such
that
you
know,
if,
initially,
when
we
had
the
clients
the
way
they
were,
we
would
have
to
tell
people
like.
Oh
you
want
to
build
it
from
memory.
You
should
write
it
to
some
temporary
files
set
this
environment
variable
right.
A
This
yanil
from
these
temporary
into
a
temporary
file,
set
an
environment
variable
and
then
call
the
load
file,
Oh
config
file.
Obviously,
in
some
environments,
that's
just
not
possible,
and
in
other
environments,
that's
a
pretty
awkward
hacky
thing
to
do,
and
so
there's
this
added
kind
of
capability
that
that
we
added
for
these
client
libraries,
which
is
the
ability
to
sort
of
programmatically
construct
your
client
code
and
in
Java.
This
looks
like
this
builder
pattern
is
sort
of
an
idiomatic
pattern
for
Java.
A
We
can
say
you
know
what
I
want
to
create
an
API
client
via
this
client
builder.
I
can
set
my
certificate
authority
in
this
case.
I
actually
am
using
a
path
to
a
file,
but
I
could
easily
just
use
a
byte
stream
or
anything
else,
I'm
setting
the
host
eventually
I
get
to
build
my
client
right.
So
this
is
a
new
part
of
building
an
SDK
as
opposed
to
building
a
command-line
tool,
and
again
this
is
about
providing
a
user
experience
for
these
libraries.
That
is
more
than
just
the
ability
to
call
the
individual.
A
The
individual
functions
I
mentioned
as
well
that
one
of
the
the
core
is
so.
This
is
an
example
of
parody
right.
We
want
to
make
sure
that
all
of
these
libraries
have
exactly
the
same
capabilities
and
exactly
the
same
experiences
to
achieve
that.
We
actually
have
a
set
of
standards
defined
for
these
client
libraries,
starting
with
a
bronze
standard
that
basically
describes
the
rough
capabilities
that
we
expect
of
a
client
library
at
the
bronze
standard,
and
this
includes
things
like
loading
from
a
cube
config
file.
A
A
It
is
also
the
case
that
that
file
pointer
is
relative
to
the
location
of
the
cube
config
file,
not
to
the
home
directory
of
the
process.
That's
running.
Currently,
we
had
that
bug
in
a
couple,
client,
libraries
and
again
totally
unspecified
anywhere
right,
like
the
only
way
you
understand
the
behavior
is
by
seeing
what
happens
when
you
try
and
use
cube
control
or
when
you
try
and
use
the
client
go
client,
libraries
and
then
also
things
like
TLS
TLS
is
interesting,
because
every
programming
language
is
a
little
bit
different
about
how
they
handle
custom.
A
Cas
basic
API
calls
like
pods
and
everything
else
like
that
and
then
finally,
working
within
the
cluster
environment,
because
when
people
often
oftentimes,
these
SDKs
are
being
used
to
build
containers
that
run
inside
the
cluster.
Actually,
the
ability
to
load
in
from
the
cluster
environment
is
actually
probably
the
most
important
version
of
that
it
may
be
documented
somewhere,
but
the
locations
of
all
of
those
certificates
are
again
something
that
I
found
by
digging
through
the
code.
It's
possible
that
it's
located
somewhere
but
I,
don't
know
where
it
is.
A
If
that's
the
case
and
again
it's
a
lot
of
what
we
do
is
taking
doing
spunky
through
the
client
code
to
find
out
the
various
places
that
things
are
defined.
As
you
move
out
for
bronze,
we
add
capabilities
like
watch
watch
is
an
interesting
thing
because,
as
we
mention
as
I'm
going
to
talk
about
later,
we
use
open,
API
and
cogeneration
to
generate
the
code
that
we
use.
Unfortunately,
there
is
exactly
no
specification
for
anything
like
watch
anywhere
in
the
world
of
API
schemas
right.
A
There
is
no
equivalent
to
open
API
that
exists
for
HTTP
based
watch
I
mean
we
invented
the
watch
protocol
at
the
bone.
The
actual
JSON
protocol
that's
used
for
watch
is
invented
by
the
curb
entities
API
server
anyway,
but
there
wasn't
even
something
we
could
have
adopted
or
something
where
we
could
generate
the
client
libraries.
A
So
in
the
case
of
watch
and
and
if
people
don't
know
haven't
seen,
watch
before
watch
is
the
ability
basically
to
open
up
a
hanging
connection
to
the
API
server
and
say:
please
tell
me
about
changes
either
to
an
entire
collection
or
to
a
specific
object.
All
of
that
code
is
written
from
scratch.
Alright,
so
none
of
that
code
is
code
generated
as
a
result,
it's
not
the
most
awesome
code
to
work
with,
because
you
have
to
do
things
like
pass
entire
paths.
You
have
to
you,
know,
slash
api's,
slash,
namespaces,
slash
my
object
dot.
A
If
you
get
it
wrong,
the
error
messages
that
you
get
aren't
particularly
intuitive
and
so
the
because
we
because
we
can't
code,
generate
for
this
particular
class
of
calls.
We
can't
provide
as
great
a
user
interface
experience
as
we
do
for
non
watch
calls
and
then,
at
the
higher
end
of
things,
exec
attach
port
forward
again,
not
supported
out
of
the
box
again
with
a
protocol.
That's
not
defined
anywhere
and
we'll
talk
a
little
bit
about
that
protocol
in
a
second
proto
buffer
encoding,
which
again
has
the
same
problems.
A
The
API
server
chose
to
use
protocol
buffer
encoding,
but
they
did
not
choose
to
use
the
protocol
buffer
service
definitions.
So
we
can't
generate
the
client
libraries
for
talking
protocol
buffer.
We
have
to
again
hand
roll
all
the
client
libraries
for
talking
protocol
buffers
and
then
finally
generated
examples.
So
the
state
of
the
world
here
is
that
we
have
five.
Is
that
five
yeah?
We
have
five
client
libraries
that
are
supported.
A
Well,
you
sorry
for
client
libraries
that
are
supported
basically
up
to
the
goal
of
the
gold
level,
except
for
the
generated
examples
were
saying.
None
of
them
have
done
that,
for
whatever
reason,
actually,
no
it's,
because
it's
kind
of
annoying
to
do
it
and
nobody's
bothered.
But
if
you're
looking
for
a
starter
project
and
a
but
things
like
exec
and
watch
work
throughout
Python,
net
Java
and
typescript
and
JavaScript,
obviously,
because
typescript
compiled
down
to
JavaScript,
there's
also
a
Haskell
library,
it
is
less
it
has
less
cave.
A
It
is
less
capable
it's
roughly
at
the
Silver
level,
has
all
the
basic
functionality
and
and
has
the
ability
to
do,
watches
but
doesn't
have
the
port
forwarding
and
some
of
the
more
advanced
functionality.
I
should
also
say.
Actually:
I
lied
a
little
bit.
None
of
the
libraries
except
for
the
Java
library
have
a
support
protocol
buffer
encoding
either
the
Java
library
does
support
protocol
buffer
encoding
and
that's
partially
because
of
some
challenges
with
the
produce,
the
protocol
buffer,
compiler
and
partially.
Just
because
again,
it's
work
that
that
people
have
to
do.
A
It's
handwork
that
people
have
to
do
to
make
it
work.
Okay,
so
we'll
go
on
to
the
basic
approach
that
we've
taken
to
building
this
out.
We
start
with
an
open,
API,
spec
and
we'll
dive
into
the
open,
API
spec
in
just
a
second.
It
goes
through
code
generation.
The
code
generation
tool
is
a
tool
that
we
actually
don't
build.
It's
a
it's
a
tool
called
swagger
code
gen
that
is
out
there
on
the
in
github.
A
It's
run
by
mule
soft
I
think
a
face
book
now,
I
guess,
and
then
we
on
top
of
that
generated
code.
We
add
some
custom
code
that
does
the
things
like
cube.
Config
loading
does
things
like
watch
those
things
like
port
forward,
all
of
that
stuff
mix
all
of
that
stuff
together
and
you
have
a
client
library
that
comes
out
the
other
side.
A
A
We
get
coverage
of
overall
of
the
api's
relatively
little
work
to
to
do
that.
Upgrade
it's
a
walk
through
the
manual
process,
but
it's
that
the
that's
got
some
major
advantages
in
terms
of
an
ability
to
keep
up
with
the
project
cover
the
full
set
of
api's
we're,
not
good
SDKs
I.
Don't
think.
If
you
know
we
don't
cover
every
API,
we're
not
a
fit.
You
know
we're
not
really
doing
our
job
if
we're
not
covering
every
API
that
people
write.
A
A
You
know
we
can
do
some
work
to
kind
of
dress
it
up,
but
it's
it's
hard
to
do
that
in
a
really
good
way,
so
there's
definitely
some
warts
and
and
there's
a
number
of
gaps
as
well
in
in
the
process
and
I'll
step
through
the
gaps
in
a
little
more
detail
in
a
couple,
slides
I'm
going
to
give
you
a
sense
for
what
the
generating
code
process
actually
looks
like
so
inside
of
a
container,
we
download
the
open,
API
spec
from
a
particular
release.
We
are.
We
are
always
generating
code
for
a
particular
release.
A
We
munch
up
that
open
API
spec
because
it
doesn't
fit
with
a
swagger
code,
generator
code
quite
perfectly
in
particular.
It
doesn't.
It
doesn't
weird
things
with
packaging
of
the
various
API
groups
that
don't
generate
very
idiomatic
libraries
when
you
jet
and
I,
don't
do
idiomatic
packaging
when
you
generate
the
code,
so
we
bunch
that
up
there's
an
additional
amount
of
munching
that
happens
to
do
some
custom
typing
so
and
I'll
talk
about
that
in
just
a
second.
A
It
generates
all
of
the
code
and
one
of
the
interesting
you
know
again,
choices
that
happens
when
you
do
this
code,
generator
I
should
probably
to
mention
it
in
the
cons.
Is
the
code
generator
is
made
a
choice
about
what
HTTP
library
it's
going
to
use,
or
rather
you
you
get
to
choose.
When
you
generate
the
code
which
HTTP
library
you
choose,
but
you
are
limited
by
the
implementations
and
implementing,
as
you
can
imagine,
implementing
a
code
generator
or
the
templates
for
code.
A
Generator
is
a
non-trivial
task,
and
so
you
know
it's
when
somebody
comes
along
and
says:
hey,
you
know
what
that
HTTP
library
that
you
have
and
the
one
that
we
use
is
from
square
called:
okay
HTTP
in
Java
at
least
they
say
that
that
HTTP
library
is
like
five
years
old
and
deprecated
and
you're
saying
yeah,
but
like
do
you
want
Nick?
This
is
one
of
these
examples
of
like
an
easy.
What
is
seemingly
an
easy
bug?
Why
don't
you
just
go
to
upgrade
the
HTTP
library
that
turns
into
this?
A
Like
sorry,
like
here's,
the
path
of
steps
you're
gonna
have
to
do
in
order
to
to
make
that
change,
and
then
Simon.
Similarly,
like
the
JavaScript
client
only
works
in
node
right,
you
can't
use
it
in
the
browser
right
now,
because
the
HTTP
library,
that's
underneath
it
is
the
node
HTTP
library
and
then.
Finally,
once
all
that
code
generators
happened,
we
copy
the
code
out
then
inside
the
client
code
inside
the
client
that
that
generates
the
code.
Now
we
have
to
sort
of
integrate
it
into
the
project.
We
bring
it
into
the
client
library.
A
Each
client
library
has
its
own
repository
on
github.
The
generator
code
has
its
own
repository.
We
bring
it
into
the
client
library
we
overwrite,
the
existing
client
code
generate.
You
know,
giant
diffs
that
nobody
ever
really
looks
at,
and
then
we
have
to
update
the
example
code
because
oftentimes
with
the
alpha,
api's
they've
changed
and
sometimes
actually
the
code
generator
itself
has
changed.
The
parameters
move
around
or
new
parameters
are
added.
Do
that
PR
and
then
once
we're
done
with
everything
push
up
to
a
repository.
A
So
I've
learned
a
lot
about
how
you
manage
packages
in
maven
in
NPM
in
all
of
these
they're
and
they're
all
different,
and
so
that's
another
piece
of
the
puzzle.
We're
really
until
we've
actually
pushed
these
things
out
to
a
place
where
they're
consumable
by
our
target
audience
or
our
end
users.
We
haven't
actually
fixed
the
code
right.
In
most
cases,
people
don't
want
to
be
forking
from
github
their
client
library
and
compiling
it
on
their
machine.
They
want
to
consume
them
from
these
package
managers,
and
so
we've
had
to
figure
out
the
right
way.
A
So,
managing
that
and
managing
that
for
for
all
a
lot
of
different
approaches:
okay,
so
looking
at
the
gaps
in
this,
what
are
the
gaps
in
in
open
API?
Well,
one
of
the
first
bugs
that
was
filed
on
the
Java
client
is
the
fact
that
if
you
delete
something
every
once
in
a
while,
somebody
gets
an
exception.
It's
a
pardoning
exception,
and
the
reason
for
this
is
that
delete
in
kubernetes
actually
is
multi
is
multi
value
return.
When
the
signing
of
a
multi
value
return,
it's
multi
type
return.
A
It
can
either
return
a
status
object
or
it
can
return
the
actual
object
that
you
deleted,
depending
on
whether
the
delete
has
completed
or
not.
It
turns
out
that
open
API,
the
open,
API
spec
that
the
2.0
version
of
the
open,
API
spec,
simply
cannot
represent
this
right
and
it
is
not
in
the
spec
that
you
could
have
and
as
this
concept
called
one
of
and
one
of
can
be
used
for
parameters,
but
it
can't
be
used
for
return
types
now,
an
open,
API.
A
Three
that's
been
changed,
so
you
can
have
one
of
return
types,
but
none
of
the
code.
Generators
really
support
open,
API
3,
yet
so
we're
stuck
in
this
world
where,
every
month,
someone
files
another
issue
on
their
Java
client
saying:
hey
I
tried
to
delete
something
in
it
through
an
exception
and
I
say
yeah.
It's
duplicated
see
this
issue
here,
and
this
is
the
long
view
of
why
it
doesn't
work
properly
same
thing
with
parrot
types
right,
so
lots
of
these
object-oriented
programming
languages.
A
They
would
really
love
so
in
the
in
the
go
client,
because
it's
all
handwritten
people
have
done
things
like
said:
hey,
there's
a
runtime
object
and
runtime
object
is
a
base
object
for
every
other
object
that
exists
metadata
field.
Things
like
that
are
defined
on.
That
interface
makes
it
very
easy
to
write
generic
code
around
these
objects.
A
Swagger
doesn't
or
open
API
doesn't
have
a
way
of
representing
hey,
there's
this
parent
class
that
everybody
inherits
from
it
does
actually
again
in
open,
API,
3,
but
again
code
generators
haven't
caught
up
and
then
I
mentioned
as
I
mentioned
earlier.
You
you
can't
represent
these
streaming
operators
and
you
can't
represent
protocol
buffers,
and
so
the
gaps
in
open
API
definitely
caused
problems.
A
In
our
end
user
custom,
our
end
user
client
library
facing
experience
there's
a
lot
of
gaps
in
generated
code,
one
of
the
very
first
things
we
noticed
as
we
started
to
try
and
implement
things
like
watch.
Was
we
really
needed
the
ability
to
separate
prepare
request,
meaning
get
the
authentication
on
it?
A
Don't
want
to
rewrite
all
of
the
code
that
attaches
certificates
that
does
all
the
stuff
necessary
to
get
an
HTTP
request
ready
to
go.
That's
why
I'm
using
client
generator
right?
That's
why
I'm
using
code
gen
but
I
needed
to
actually
go.
Do
some
some
refactoring
in
the
code
generator
in
order
to
enable
other
kinds
of
behaviors
that
I
needed
to
implement,
like
port
forwarding
and
exec
and
and
watches
I.
A
A
There
are
lots
and
lots
and
lots
of
null
parameters
right
so
like
swagger,
doesn't
have
a
good
way
of
representing
optional
parameters,
or
at
least
in
some
languages
like
Java
is
a
great
example.
Optional
parameters
aren't
really
easy
to
represent,
and
so,
when
you
use
the
Java
client
in
many
cases,
you're
going
to
say,
create
object.
This
object
this
namespace
and
then
like
known
old,
old,
old,
old,
right
and
and
again
they're
in
without
going
and
doing
a
whole
bunch
of
surgery
on
the
code.
A
Generator
there's
not
a
really
good
way
to
fix
that,
and
so
it's
a
kind
of
a
lousy
and
user
experience
as
a
result,
and
then
I'm
gonna
mention
yeah
I
mentioned
the
the
advanced
features
like
watch
aren't
there
and
then
this
one
is
a
great
one.
Someone
filed
a
bug
on
me
and
said
found
the
bug
on
the
Java
client
and
said:
hey
I.
Have
this
view
on
secret
object,
the
secret
object
and
I?
A
Have
this
other
secret
object
and
I
to
requests,
gave
me
the
same
secret
I
did
dot
equals
on
them
and
they're
not
equal
seems
like
that's
a
bug
and
I
we
dug
into
it
I
dug
into
it.
It
turns
out
that
Java
array
equals
is
pointer,
equals
by
default.
So
you
say,
array
dot
equals
some
other
array.
It's
pointer
equals
it's,
not
value
equals
so
the
and
and
in
the
secret.
It's
an
array
of
bytes.
The
data
is
an
array
of
bytes,
compares
the
pointers.
They're,
not
equal
returns.
A
False
swagger
cogent
actually
had
this
bug
and
fixed
it
by
using
array
equals,
which
actually
does
the
right
thing,
but
then
actually,
and
so
I
was
like
well
I.
Think
it's
fixed
and
they're
like
no
still
here
and
I
looked
at
it
again
and
it
turns
out
actually
in
a
secret
object.
The
secret
object
has
a
map
from
string
to
array
of
bytes,
and
while
the
swagger
Kochan
has
fixed
it
for
array
of
bytes,
it
hasn't
fixed
it
for
map
of
anything
to
array
of
bytes.
A
And
if
you
look
at
the
implementation
of
equals
in
map
under
the
deep
down
into
the
java
libraries,
it
just
calls
object
on
equals
again
and
you're
back
at
square
one
right,
and
so
this
this
bug
continues
to
exist,
secrets
and
java,
still
don't
equal
each
other.
If
we
want
to
fix
it,
we
need
to
go
into
the
code
generator
and
put
a
whole
bunch
of
special
casing
logic
in
to
be
like.
A
A
But
of
course
that's
a
lot
of
work
as
well,
and
then
finally,
we
also
find
a
lot
of
gaps
in
kubernetes
itself,
so
many
parts
are
under
specified
or
not
specified
or
just
specified.
In
code
I
mentioned,
how
does
a
cube
config
file
loaded?
What
are
the
streaming
protocols
we'll
actually
go
over
the
streaming
protocols
in
just
a
second
but
as
a
nice?
Little
example
of
this
I
actually
have
a
bug
that
is
still
open,
that
I'm
actually
going
to
show
you
how
we're
gonna
fix
that
root
caused
it,
but
I
haven't
actually
fixed
it.
A
A
A
This
is
where
is
this
one
writer
support,
request,
body
and
proxy
methods,
so
this
is
someone
maybe
they're
out
there
today,
who
said
hey,
you
know
what
I'm
trying
to
you've
generated
this
method,
that
is
a
post
to
the
proxy,
so
the
API
server
has
this
proxy
endpoint,
which
proxies
the
request
from
the
API
server
to
a
pod
in
the
cluster.
You
have
this.
Excuse
me
post
method,
I'm
trying
to
use
it.
A
A
You
know
what
you
can
see
here
is
this
local,
the
local
var
post
about
a
is
equal
to
a
body
per,
am
if
there's
a
body
per
am
otherwise
no
alright.
So
basically
what
that
saying
is
if,
in
swagger
there's
a
body
per
am
defined,
make
it
equal
to
the
body
per
am,
which
is
a
parameter
that
got
passed
into
this
method.
If
in
swagger
there
was
no
body
per
am
to
find
just
make
it
null
and
there
will
be
no
body
right.
So
that's
a
bit
of
a
clue.
We
said.
A
First
of
all,
you
had
to
learn
mustache
conditionals,
which
I
hadn't
learned
until
I
started
doing
this
stuff,
but
that's
what
the
pound
that's,
what
this
pound
and
not
thing
is
doing
so
a
little
more
about
mustache
templating
than
I
ever
really
wanted
to
know,
and
but
now
we
know
so
now
we
actually
have
some
sense
for
why
there's
an
issue
here.
We
know
we
know
why
the
the
where
the
problem
is
coming
from,
but
now
we
need
to
go
to
the
swagger
spec,
and
so
we
can
go
over
to
the
swagger
spec.
A
I
should
actually
open
that
in
a
new
new
tab,
we
can
go
over
to
the
spike
respec
and
we
can
wait
till
it
fully
downloads
because,
as
I
mentioned,
it's
a
little
bit
big,
we
can
search
for
proxy
here's
the
get
version
if
you've
never
looked
at
swagger
before
this
is
swagger.
So
you
can
see
here,
here's
the
definition
of
the
post
and
that's
probably
not
very
readable.
So.
A
You
will
see
that
the
it
doesn't
contain
this
body
parameter
method,
and
so
what
I'm
gonna
have
to
do
and
I,
since
my
time
is
up,
I
won't
actually
go
and
do
it.
I'm
gonna
have
to
go
into
that
part
that
swagger
object,
add
in
that
body
parameters
field
and
then
go
through
the
full
code.
Regen
process
right
and
so
I
think
this
gives
you
an
idea
of
in
some
ways
it's
the
gold
garbage
in
garbage
out
thing.
A
A
I'm
gonna
run
out
with
a
new
talk,
but
if
you
want
to
learn
more,
please
come
check
out
all
the
kerbin
Nettie's
client
libraries
there
under
Kurban
get
hub
kubernetes,
client,
Java,
C,
sharp
JavaScript,
Python
Haskell,
there's
a
ruby
client.
There,
that's
mostly
abandoned
where.
So
if
you
wanna,
if
you're
interested
in
Ruby
and
you
want
to
play
around
come,
come
take
that
over
there's
also
a
go
client
library
there.
A
That
is
also
needing
of
assistance
and
then,
finally,
if
you
like
lists
as
I,
do
I
actually
hand
coded
I
actually
hand
coded
a
lisp,
kubernetes
client
library.
That
I
would
also
love
to
have
people
come
party
with
me
on
so
come
check
it
out.
Thank
you.
So
much
I
hope
you
enjoyed
the
conference.
Alright,.