►
From YouTube: The Rusty Boat - Matt Butcher & Taylor Thomas, Microsoft
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon North America 2021 in Los Angeles, CA from October 12-15. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
The Rusty Boat - Matt Butcher & Taylor Thomas, Microsoft
One year ago, our team released Krustlet, a Kubernetes Kubelet implementation for running WASM modules written in Rust. Since then, we've spent plenty of time out on the frontier, implementing full Kubernetes functionality, all in Rust. In this session, we'll cover why we chose Rust and what the benefits and rough edges are. Using code from Krustlet as a practical backdrop, we'll show you how we wrote the core components of Kubelet from scratch and by leveraging various community crates (including gRPC, controllers, volume mounting, and more!) to highlight how you can also use Rust for your next Cloud Native project.
A
B
A
Yeah
and
like
he
said,
I'm
kind
of
a
little
bit
less
consistent
with
the
social
media.
So
there's
all
my
social
media
handles
and
that's
just
because
you
know
common
name
and
common
last
name.
So
it's
kind
of
hard,
sometimes
so.
First
off
I'm
one
of
the
crescent
core
maintainers
we'll
talk
about
that
project.
A
lot
today
and
one
a
an
emeritus
helm
core
maintainer
I've
also
been
doing
containers
in
kubernetes
for
a
long
time.
It
makes
me
quite
old
in
container
years
as
we
like
to
joke.
A
I've
been
just
doing
it
for
for
a
while,
not
as
long
as
matt
has,
but
for
a
while,
and
then
I
am
a
restation,
what
we
call
rust
developers
right
by
way
of
go,
which
makes
sense,
given
my
background
and
so
we're
going
to
go
ahead
and
and
kind
of
kick
off
and
talk
about
different
things.
We've
learned
from
rust
and
in
cloud
computing.
B
So
this
all
kind
of
started
with
an
aha
moment
or
maybe
a
couple
of
aha
moments.
I
was
doing
a
one-on-one
with
with
one
of
the
people
on
our
team,
brian
and
we
were
kind
of
wandering
around
boulder.
This
was
summertime
2019..
We
had
a
couple
cups
of
iced
coffee
and
we
were
just
kind
of
walking
around
talking.
It
was
a
couple
of
days
before
we
all
got
together
for
an
on-site
and,
as
happens,
you
know
the
topic,
a
led
to
topic
b
and
all
of
a
sudden.
B
We
were
talking
about
hey,
remember
when
assembly.js
was
going
to
be
the
next
big
thing
and
we
both
sort
of
vowed
to
go
off
and
look
at
this
well
unbeknownst
to
us.
Other
people
on
the
team
had
accidentally
stumbled
on
the
webassembly
world
at
the
same
time,
and
when
we
got
together
about
a
week
later,
we
had
this
kind
of
brainstorming
session
and
we
all
sort
of
blurted
out
at
the
same
time.
B
Wouldn't
it
be
fun
to
work
on
webassembly
and
who's
doing
what
with
webassembly
and
here's
some
ideas
and
if
you
take
a
look
at
the
webassembly
ecosystem,
these
days,
they're
really
kind
of
two
prongs
of
the
cutting
edge.
There's
the
m
script
in
javascript
implementation
and
then
there's
a
whole
bunch
of
work,
much
of
which
started
out
of
mozilla.
B
That's
really
oriented
more
around
rust,
and
so
we
kind
of
came
to
rust,
we'd
all
dabbled
with
it
here
and
there,
but
really
our
first
production
endeavors
with
rust,
all
had
to
do
with
web
assembly
and
kubernetes
and
and
that's
kind
of
what
got
us
originally
started
on
it.
But
we
feel
really
good
about
that
selection
and
and
here's.
Why.
A
Yeah,
so
the
really
these
are
kind
of
the
over
overarching
reasons
why
we
picked
rust
and
and
then
we'll
go
a
little
bit
deeper
into
each
into
all
the
things
we
discussed
here
so
first
off,
we
have
safety
if
you're
here
at
a
rest
conference,
you
probably
know
that,
but
just
to
mention
it
like
safety
is
a
huge
thing
with
rest,
and
that
was
an
excellent
benefit
that
we
picked
up
basically
for
free
for
using
the
language.
The
developer.
A
Experience
in
rest
is
quite
amazing,
which
we'll
also
dive
into
and
like
matt
mentioned,
we
have
wasm
support
in
it.
Wasm
support
in
rust
is
probably
one
of
the
best
of
all
the
languages,
at
least
for
the
side.
Wasm,
that's
meant
for
the
server
side
and
then
there's
an
extensibility
thing
with
with
rest
apis.
That's
just
really
elegant
and
beautiful.
That
has
been
very
helpful
as
we've
extended
external
apis
and
also
consumed
other
internal
apis,
which
we'll
talk
about
here.
Yeah.
B
Rust
is
usually
considered
a
systems,
development
language,
but
we've
been
using
it
almost
exclusively
on
our
team
for
cloud
development
and
have
found
it
to
be
very
much
a
good
fit.
Cloud.
Development,
of
course,
is
a
type
of
system
development,
but
often
with
a
lot
more
emphasis
on
http
and
networking,
and
things
like
that
that
our
colleagues
originally
were
saying.
But
why
did
you
choose
rust
for
that?
Wouldn't
you
just
use
language
x
or
language
y.
How
come
you
didn't
just
stay
with?
Go.
A
So
one
of
the
good
things
we
love
is
traits
traits
are
pretty
much
amazing.
There's
not
really
a
better
way
to
say
that
they
are
flexible,
they're
expressive,
we've
loved
the
conversion,
reference
traits
like
the
ones
displayed
here.
So
this
is
like
from
try
from
from
string
d
ref
all
those
different
traits,
because
it
allows
just
such
flexible
things
compared
to
other
interface
types.
A
A
This
is
an
example
from
our
bundle
project
which
we
won't
talk
about
here,
but
it
just
allows
us
to
pass
in
pretty
much
any
type
that
can
be
parsed
as
a
string
and
then
a
few
others
and
convert
it
into
our
internal
id
type,
which
is
really
really
powerful
compared
to
other
languages.
We've
used
yeah.
A
Yeah
now
this
error
handling-
I
always
have
people
ask
well
why
don't
you
use
just
this
error
crate?
This
is
actually
using
this
error
crate,
I
just
it's
already
fat
and
big,
so
I
didn't
want
to
include
any
more
but
using
some
of
the
other
crates
and
just
leveraging
these
enums
allow
for
really
really
expressive
errors,
and
so
they're
not
just
like
single
values,
but
they
can
carry
associated
data.
So
each
variant
can
have
different
data
structures
like
a
discriminated
union,
and
then
you
can
work
with
these
using
pattern
matching.
A
So
this
pattern
matching
is
converting
some
types
over
for
us
in
our
real
code
and
so
we're
able
to
make
sure
that
we
handle
every
single
kind
and
get
the
data
out
all
in
one
beautiful
statement
I
mean
you
can
read
this
coming
from
any
language
that
you
and
you'll
go
like.
Oh,
I
see
what
this
is
doing
like
you
might
go.
A
What's
this
unwrapper
default
or
what's
this
like
some
of
it
might
be
weird,
but
like
the
basic
structure
of
what
it's
doing
is
really
really
elegant
and
powerful,
and
we
see
this
all
over
the
place.
We've
just
kind
of
like
matt
said
had
this
aha
moment
like
wow,
like
you,
can
use
these
for
some
amazing
cases,
in
particular
errors
now
macros.
A
Let's
just
say
we
we
absolutely
love
macros.
Now
they
writing
them
can
be
a
little
finicky,
but
we're
not
going
to
worry
about
that
right.
Now.
Just
be
aware
that
that
happens,
we've
learned
that
quite
a
bit,
but
macros
are
great
for
cloud
development,
because
there's
so
many
times
we're
consuming
external
apis.
So
seeing
that
this
is
a
kubernetes
adjacent
event.
A
Right
now
you
probably
know
what
a
crd
is,
if
not
it's
a
custom
resource
definition,
a
hook
into
the
kubernetes
api
in
go
even
with
all
these
other
libraries
that
people
have
generated,
you
still
have
to
auto
generate
code
and
commit
code
and
have
all
these
different
things
to
make
it
work.
Here
literally,
I
have
the
data
I
care
about
specified
and
then
I
can
derive
custom
resource
and
pass
it.
Basically,
some
configuration-
and
I
automatically
when
the
thing's
built
that
code
expands
out
to
all
the
code
needed
implement.
I
don't
have
to
commit
anything.
A
It
builds
it
correctly.
Every
time
you
can
also
see
this
inheriting.
No,
I'm
not
inheriting
that's
the
wrong
word
in
rest,
but
taking
and
deriving
a
json
schema,
so
we're
attaching
a
whole
json
schema
to
this
object,
basically
for
free.
So
this
we
as
a
matt-
and
I
were
talking
over
this
code
sample-
we
realized
that
this
block
of
code
in
go
where
you
would
generally
write
something
like
this
is
probably
at
least
200
lines.
If
not
more,
and
a
lot
of
it
is
just
committed
or
auto
updated
code,
and
this
is
10.
A
B
B
This
this
particular
example
probably
would
be
two
three
four
hundred
lines
of
go
code
with
lots
of
with
the
the
cyclomatic
complexity
of
it
would
have
been
fairly
deep
because
you'd
have
a
lot
of
nested
ifs
and
a
lot
of
nested
loops,
and
it's
just
so
elegant
to
look
at
code
like
this
and
see
everything
sort
of
laid
out
laid
out
linearly
and
again
we
find
the
readability
of
this
to
be
very
high.
I
remember
taylor,
I
don't
think
you
liked
this
style
at
first.
Has
that
changed.
B
A
This
is
a
very
high
on
our
impre
on
our
very
impressive
list
of
rust
features
and
we're
gonna
have
to
make
a
confession.
We
pretty
much
love
cargo
like
love
it.
It
is
flexible.
It
tells
you
exactly
what's
wrong
when
a
version
can't
resolve-
and
it
really
it's
another
thing
that
where
we
feel
like
it's
completely
changed
how
we
look
at
dependency
management-
and
this
just
shows
some
examples
here,
but
you
can
patch
in
dependencies
from
other
places,
and
these
four
show
four
different
ways
you
can
do
stuff.
A
So
in
the
top
example,
we're
pulling
in
only
a
very
small
portion
of
basically
what's
a
big
auto-generated
open
api
spec
and
we're
just
pulling
in
exactly
what
we
need
we're
not
pulling
in
this
massive
code
base
and
compiling
it
all.
In
with
the
struct
with
struct
opt
we
expose
and
cresla
an
optional
command
line
flag,
which
is
what's
shown
below.
If
a
user
specifies
it,
it
downloads
all
the
command
line,
management
stuff
and
all
these
other
structs
arranging
the
ops.
A
But
if
you're
not-
and
you
don't
want
to
use
a
command
line
tool
for
it,
you
don't
have
to
include
it.
The
dependency
doesn't
get
pulled
down,
the
structs
don't
get
compiled
in,
which
is
amazing,
and
then
you
can
also
do
stuff
like
the
bottom,
where
you're
pointing
to
a
local
path.
So
when
you're
local,
it's
going
to
use
a
local
path,
but
when
you
push
it
up
into
crates,
it
uses
the
proper
version.
So
I
mean
these
are
just
two
examples,
but
we
love
cargo
and.
B
This
is
coming
from
people.
We
have
both
worked
on
multiple
dependency
management
and
and
package
management
systems
like
helm
and
cnab
and
and
glide,
and
things
like
that,
and
we
just
we
look
at
cargo
and
we're
like
well.
This
is
just
better
than
all
of
those
things
that
we
wrote,
but
I
think
the
last
thing
we
really
wanted
to
highlight
in
the
good
one
is
the
community.
B
A
Yeah
so,
let's
start
off
with
dachshund
clarity.
This
is
an
interesting
one
that
people
go
like.
Oh,
I
didn't
really
think
about
that,
so
a
pattern
that
we've
seen
in
lots
of
great
documentation,
that's
something
to
really
be
aware
of,
as
you
consume
things,
especially
if
you're
new
to
rust
and
especially
rust
with
cloud
nano
development
is
that
the
docks
are
sometimes
very
unclear
about
what
is
happening
in
the
actual
code.
A
They
describe
the
functionality
well,
but
then
you
have
to
go
digging
through
the
code
to
find
out
whether
it
is
a
zero
cost
abstraction
or
if
there's
side
effects.
So
like
is
something
flushing
a
file
oftentimes,
it
doesn't
tell
you
and
I
have
to
go
down
on
the
code
and
figure
out
what's
going
on,
but
you
also
get
what's
displayed
here.
So
this
is
something
from
the
tonic
crate,
which
I'll
talk
a
little
about
a
little
bit
later
and
as
a
new
developer.
A
When
you
come
in
and
you
see
this
code,
you
just
go
what
is
going
on
here
and
you
like
click
through
well.
What's
this
make
connection-
and
it's
like
linking
to
another
trait
in
another
crate
which
links
to
two
more
traits
and
another
crate
and
you're
like
whoa,
like
what
am
I
supposed
to
implement
here,
turns
out.
All
we
needed
was
the
little
code
snippet
below,
which
is
quite
simple,
but
what
had
happened
is
there
was
an
example
in
the
examples
directory
of
the
of
the
actual
repo,
but
the
first
thought
wasn't
to
go.
A
Look
there
now
granted.
This
is
before
they
change,
they've,
updated
these
docs,
and
it
points
to
that
new
example,
and
it's
great.
But
this
is
something
we
saw
quite
a
bit
of
as
we
started
things
so
just
remember
to
keep
your
docs
clear
as
you
write
stuff
and
be
aware
that
you
might
have
to
dig
a
little
bit
to
understand
what
this
is
asking
you
to
implement.
B
A
A
It
just
has
a
very
steep
initial
curve
and
it
flattens
out,
but
there's
one
other
little
bump
we
ran
into,
and
that
is
how
to
design
proper
apis,
so
that
first
example
with
traits
was
you
with
using
try
into
that
was
when
I
finally
got
it,
but
it
took
a
lot
of
looking
at
other
crates
and
understanding
what
was
going
on
about
what
makes
a
good
and
flexible
rest
api
when
you
design
them,
users,
love
them,
but
sometimes
getting.
There
is
a
bit
of
a
hiccup.
A
So
with
that,
let's
go
into
the
ugly,
which
is
just
one
thing:
it's
async
now
to
be
clear.
I
don't
want
this
is
not
bashing
on
anything.
I
have
worked
with
these
people.
I've
talked
to
these
people.
They've
started
a
working
group.
This
is
not
that
I'm
just
pointing
out
what
you're
going
to
run
into
in
the
cloud
native
space
and
the
first
off.
Is
this
competing
and
incompatible
runtime.
A
So
you
have
multiple
runtimes
tokyo,
async
standard,
small
and
it's
possible
to
use
interchangeable
ones,
but
a
lot
of
times
once
you
buy
into
a
stack,
you're
kind
of
stuck
there,
and
you
have
a
little
bit
of
lock-in.
It's
not
perfect
and
it
depends
on
what
you're
doing
sometimes
there's
shim
layers
that
you
can
add
in.
But
just
keep
that
aware
here
we
have
our
ugly
code.
A
I
hope
these
code
examples
show
exactly
what
we're
talking
about,
but
there's
so
many
chained
calls
and
that
one
on
the
left
was
one
that
we
called
move
clone
move
clone
move
clone
with
clone,
because
I
mean
we
know
exactly
where
the
date
is
going,
but
to
make
rest
happy,
we
had
to
move
something
then
clone.
It
then
move
it
again,
then
clone.
It
then
move
it
again
to
make
it
so
that
it
was
all
in
the
right
place
and
again.
A
Yes,
all
this
is
async
related
to
async.
This
is
not
outside
of
async.
This
doesn't
happen,
but
something
to
be
aware
of,
and
then
that
also
adds
some
craft
and
bloat,
where
you're
re-implementing
async
methods
for
a
type
that's
already
async.
I
would
be
rich
if
I
had
money
for
every
single
time,
I
had
to
re-implement
async,
read
or
write
for
a
type,
that's
async
underneath
the
hood,
but
it's
constantly
getting
better.
B
So
for
this
last
part
of
our
presentation,
we
wanted
to
switch
and
focus
on
sort
of
what
happened
when
we
decided.
We
wanted
to
build
this
project
crestlet.
It
was
going
to
be
a
kubernetes
kubelet,
written
in
rust
and
kind
of
walk
you
through
the
initial
stages
and
then
some
of
the
things
that
caused
us
to
have
to
really
dive
deeply
into
the
the
under
the
underbelly
of
kubernetes
and
how
rust
really
has
ended
up
making
this
a
sort
of.
B
I
don't
know
if
I'd
call
it
a
pleasurable
experience,
but
definitely
one
that
was
manageable
by
a
little
small
team
like
ours
that
didn't
require
hundreds
of
engineers
to
be
able
to
sort
it
out.
When
we
first
wrote
crestlet,
we
wrote
a
proof
of
concept
and
the
proof
of
concept
was
maybe
a
few
hundred
lines
of
code.
That
was
all
it
took
us
to
be
able
to
take
a
very
basic
pod
definition
from
kubernetes
start
up
a
web
assembly
runtime
and
report
back
to
kubernetes
yeah
we're
running
this
thing.
B
Here's
the
output
of
it
and,
and
so
the
proof
of
concept,
went
well
and
was
deceptively
simple
because
we
went
oh
yeah
from
here.
We
got
it
we're
going
to
move
on
to
a
minimum
viable
product,
we're
going
to
get
this
thing
to
a
1.0
that
people
can
actually
use
in
production
and
then
it
wasn't
easy
yeah.
It
really
wasn't.
A
So
this
is
just
kind
of
a
list.
I
don't
think
it's
even
a
complete
list,
but
it's
close
of
all
like
the
worst
things
we
ran
into
to
try
to
figure
out.
We
had
to
figure
out
the
grpc
plug-in
system.
We
had
to
figure
out
how
to
make
state
machines
and
controllers
work
in
rust.
There's
also
the
idea
of
how
how
does
bootstrapping
work
underneath
the
hood
like,
what's
the
proper
way
to
do
it
and
exchange
it,
and
do
it
properly?
There's
things
about
how
do
we
handle
oci
image,
pulling?
A
A
This
is
just
something
where,
like
we
mentioned,
there's
some
gaps
in
the
system
sometimes-
and
so
you
just
out
here
on
the
frontier,
have
to
do
it
yourself,
so
we
re-impartially
re-implemented
the
oci
spec
to
be
able
to
pull
modules,
because
we
assume
that
even
for
our
wasm
modules
that
we're
using
here,
we
assume
they'd
be
stored
in
an
oci
registry.
Just
like
a
container
would
yep
now
the
api
contract.
This
was
interesting
because
there's
no
documentation
here,
which
makes
sense.
It's
not
really
like
a
public
api.
A
Many
people
consume,
but
it
turns
out
there's
two
parts
here,
so
if
you're
interested
in
the
underlying
internals,
this
is
a
great
slide
to
go
reference
later.
But
there's
these
three
end
points
that
we
see
and
then
there's
also
the
duties
of
the
kublet
itself,
which
is
watching
for
new
pods,
handle
the
entire
pod
life
cycle
and
resource
management
and
then
updating
the
node
status
and
heartbeat.
So
let's
go
into
some
code
things
that
are
right
here
that
matt.
B
A
Yeah-
and
we
can
see
actually
some
of
the
power
of
rest
here
so
right
in
this
example,
we
see
first
off
why
generics,
especially
rust
generic
trade
system,
are
so
useful.
We
are
allowing
this
to
do
a
client,
that's
a
using
the
wonderful
tube
crate,
which
is
the
basically
the
official
rest
client
for
go
for
for
go
wow,
the
official
rest
client
for
kubernetes.
A
Just
like
you
have
the
client
go,
and
in
here
you
can
see
it,
it
doesn't
matter
what
type
this
is
this
actually
underlying
type,
doesn't
matter
if
it's
a
pod
or
a
custom
resource
or
whatever,
as
long
as
it
implements
a
kubernetes
definition.
This
this
code
will
work,
but
it
also
has
the
matching
and
unwrapping
that
we
love
that
we
talked
about
as
well
and
you'll,
see
if
inside
we're
going
to
now
dive
into
the
handle
event.
A
Lastly,
we
have
our
patch
status
stuff
so
patching.
So
this
is
how
we
patch,
I
guess,
there's
we
also
have
to
talk
about
node,
but
for
the
for
the
actual
managing
the
life
cycle
of
things
you
have
to
patch
the
status
of
the
pod.
Now
we're
leveraging
the
awesome
cube
crate
again.
That
allows
us
to
do
this
patch
status
operation
with
pretty
much
an
easy
thing,
we're
just
able
to
get
out
an
api
client
and
then
we're
able
to
talk
to
it
and
then
unwrap
that
error.
A
A
What
happens
with
a
node
is
that
you
update
the
lease
and
you
have
to
update
the
status.
There's
two
things
that
you
do
to
keep
it:
keep
it
registered
with
the
kubernetes
cluster
and
all
this
we
kind
of
had
to
go
figure
out.
Okay!
Well,
how
long
does
it
expect
like
when?
Is
it
expected
to
be
updated?
What's
the
documentation
for
this
object,
all
those
things.
A
Yes,
where
we
wrote
our
own,
so
we
have
the
grpc
plugin
system
this
here
there
be
monsters.
I
cannot
stress
this
enough,
so
turns
out
to
be
able
to
enable
oc.
Sorry,
not
ocd,
that
meant
to
be
csi
support,
they're.
We
needed
to
have
some
sort
of
plug-in
system
available
which
matches
the
one
that
kubernetes
expects,
so
the
plug-in
manager
there's
actually
two
of
them.
A
If
you
go
look
at
the
code
underneath
the
hood,
but
one
is
only
for
device
plugins
and
one
handles
other
ones,
so
we
implemented
one
of
them
that
handles
the
csi
interface.
There's
no
way
to
figure
out
how
this
works,
except
by
reading
code,
but
what
the
cool
part
of
all
this
was
and
you'll
see.
Some
of
it
is
rust,
shrunk,
the
amount
of
code
needed
from
several
thousand.
A
So
this
is
big,
I
know,
but
if
you,
if
you
see
here
this
is
the
run.
This
is
how
we
start
things
inside
of
the
plug-in
manager
and
it
watches
a
configured
plug-in
directory
for
new
sockets
to
appear
and
when
it
discovers
them,
it
tries
to
register
them.
But
we
can
see
here
some
good
examples
of
using
iterators
to
run
multiple
futures
at
the
same
time
again
and
how
to
consume
a
stream.
So
we're
able
to
just
take
these
turn
them
into
an
async
object
that
just
returns
something
every
time
it
detects
it.
A
So
there's
nothing
super
crazy
here
with
rust,
but
instead
of
having
to
do
all
this
other
channel
management
stuff
that
you
saw
on
the
go
one,
it's
really
concise.
We
shrunk
it
down
to
a
single
thing
that
runs
it
all,
and
then
we
have
this
handle
create
thing
that
actually
does
the
creation
when
it
sees
under
the
creation
of
a
new
plugin,
and
these
are
the
actual
steps
that
are
performed
in
case
you're
curious.
A
I
tried
to
include
some
stuff
in
here
that
people
could
go
back
and
look
at
when
I
say
as
we
looked
and
we
created
these
these
samples-
and
this
is
the
exact
process
that
goes
on
underneath
the
hood
in
case
you're
curious,
but
more
interestingly,
in
the
next
slide
is
we
have
what
actually
goes
on
underneath
with
watching
the
file
system.
So
this
is
where
things
get
really
exciting.
So
this
is
a
demonstration
of
the
awesomeness
of
conditional
compilation,
which
I
mean,
isn't
we've
we've
run
into
several
times.
A
It
turns
out
that
the
underlying
libraries
in
mac
do
not
detect
when
a
socket
is
created
only
when
it's
modified,
which
I
opened
a
bug
for
in
case
you're
ever
curious
about
that,
but
we
had
to
basically
write
our
own
hacky
version
for
mac,
but
now,
instead
of
having
to
include
that
everywhere,
we
have
specific
versions
that
are
called
depending
on
the
operating
system.
So
if
it's
a
mac
os
target,
it
uses
the
hack,
otherwise
it
uses
the
great
notify
crate
that
gives
us
all
this
with
the
proper
way
and
not
hacky.
B
A
Yes,
we
love
the
build
rs,
so
one
of
the
things
this
is
first,
I
mentioned
this
earlier
about
the
tonic
crate.
So
tonic
is
a
grpc
library
for
rust.
If
you
haven't
used
it
like,
we
use
grpc
libraries
and
interfaces
all
the
time
in
the
cloud
native
space,
not
just
in
kubernetes
but
everywhere,
and
so
this
is
something
you'll
likely
run
into
no
matter
what
you're
writing
for
the
cloud
and
it's
awesome.
This
is
10
lines
and
it
takes
the
protobuf
definition
and
builds
you
can
you
can
tweak
how
you
want
to
build?
A
It
builds
everything
and
you
don't
even
have
to
commit
the
code.
There's
no
auto
generated
client.
It
is
generating
code
underneath
the
hood,
but
because
of
the
use
of
macros,
plus
the
build
file
you're
able
to
just
have
it
be
built
at
runtime
and
have
it
included,
which
is
awesome.
I
mean
we
just
get
soup.
This
is
where
we
nerd
out
about
it.
B
In,
in
contrast,
the
typical
go
repository
that
does
the
same
thing
includes
dozens,
if
not
hundreds
of
files
that
you
have
to
remember
to
manually,
auto,
generate
and
keep
in
sync,
with
your
protobuf
definitions
and
it's
all
incumbent
on
the
developer
to
do
the
auto
generation
and
then
all
that
code
gets
checked
in
and
then
every
time
somebody
goes
through
their
your
source
code,
repo.
They
have
to
read
through.
A
Now,
last
off,
this
will
be
pretty
quick
because
there's
actually
going
to
be
a
talk
on
all
of
this
by
one
of
our
fellow
co-maintainers
of
crestlet
at
the
same
conference
he's
going
to
talk
more
about
it,
but
we
had
to
discover
how
to
do
controllers
and
state
machines
inside
of
rust.
Now
kubernetes
is
best
represented
by
a
state
machine,
but
actually
under
the
hood.
A
Our
our
fellow
maintainer
kevin
will
talk
about
that
more.
But
when
we
combine
all
this,
we
created
something
called
crater,
which
is
an
operator
crate
for
kubernetes,
and
this
took
a
whole
bunch.
This
took
several
false
starts
in
different
versions,
and
it
took
about
three
months
of
us
just
like
building
on
other
people's
work
and
trying
things
again
and
again,
and
it
the
the
ending
api
is
actually
quite
flexible,
which
I'll
show
right.
Now
we
have
this.
One
is
the
most
simple
thing
where
it
basically
does
nothing,
but
you
have
to
implement
two
methods.
A
A
The
next
one
is
actually
a
more
complex
example,
as
you
can
see
a
lot
longer,
but
it
shows
how
to
how
it's
what
happens
when
a
pod
is
running
inside
a
presslet,
and
there
are
multiple
things
that
happen,
but
you're
able
to
pass
state
around
and
just
go
next
and
you'll
see
at
the
very
top
there's
a
there's,
this
derived
transition
to.
So
we
wrote
a
derived
macro
that
allows
you
to
put
on
a
transition
automatically
to
a
struct
and
make
sure
that
it
is
compile
time
checked.
A
If
you
don't
have
the
proper
things
in
place,
it'll
tell
you
that
your
state
machine
is
invalid,
which
is
incredibly
powerful
because
then
you're
not
accidentally
checking
like
checking
in
something
that
you
think
works,
but
there's
a
missing
edge
in
your
graph.
Essentially,
so
that's
pretty
much
the
stuff
we
learned
from
from
kubernetes.
B
Yeah-
and
this
has
been
a
very
pleasurable
journey
for
us
as
we've
done
this-
and
we've
learned
a
lot
about
rust-
a
lot
about
kubernetes.
Of
course,
we're
really
invested
in
the
web
assembly
space.
So
if
you're
around
for
web
assembly
day
take
a
look
at
some
of
the
stuff
there
as
well,
but
we
wanted
to
end
up
with
a
couple
with
a
slide
with
a
couple
of
resources.
B
Of
course,
kevin's
talk
on
crater
is
also
in
rust
today
today.
So
we
encourage
you
to
watch
that
one
and
then
here
are
several
links
that
will
give
you
some
reading
material
if
you'd
like
to
catch
up
on
how
we
did
the
state
machine
that
the
good
the
bad,
the
ugly
section
we
went
through
there,
a
written
version
of
that
or
is
that
the
slides?
I
don't
remember
if
that's
written.
A
B
That's
okay
and
then
then,
of
course,
the
async
code.
That
was
our
only
entry
in
the
ugly
there's
a
lot
of
work
going
on
there
and
we're
really
excited
about
the
work
and
looking
forward
to
the
future
of
rust,
because
we
know
that
it's
just
a
matter
of
time
before
everything
sort
of
falls
into
place
and
gets
it
right,
but
there's
a
place.
You
can
go
and
take
a
look
at
at
what
everyone
is
working
on
on
the
cutting
edge
of
that
anything
else.
To
add.
No,
I.