►
From YouTube: Rust Linz x Global Azure, April 2021 - Ryan Levick & Thomas Taylor - Rust, Kubernetes, and the Cloud
Description
Moving to the cloud is a Big Deal™. So why would you want to throw a new language like Rust into the mix? Join us as we demonstrate how Rust can be used with Azure to simplify and bring safety to your code. We'll give a brief overview of the strengths and weaknesses of using Rust in the cloud in general before demoing how you can use Rust to connect to and leverage the Azure APIs. Kubernetes more your thing? We've got that covered too! We'll show how Rust makes interfacing with and writing tooling for Kubernetes a breeze, followed by a practical demo of a Rust project (Krustlet) in action on AKS.
Thomas on Twitter: https://twitter.com/_oftaylor
Ryan on Twitter: https://twitter.com/ryan_levick
Rust Linz on Twitter: https://twitter.com/rustlinz
Submit your talk: https://sessionize.com/rust-linz
On the web: https://rust-linz.at
A
A
All
right
welcome
everybody.
It's
very
nice
to
be
here
we're
going
to
be
giving
a
talk
today
about
rust,
kubernetes
and
the
cloud,
but
before
we
get
started,
who
are
we
well?
I'm
brian
levick,
I'm
a
cloud
developer
advocate
at
microsoft,
and
I
spend
all
my
days
and
weekends
and
nights
thinking
and
dreaming
about
the
rust
programming
language.
B
Hi
everyone
I'm
taylor,
thomas,
I
am
also
a
developer
at
microsoft.
I
am,
I
work
more
in
the
cloud
side,
the
cloud
native
as
we
like
to
call
it
in
buzzword,
language.
I
work
more
on
that
side.
I
do
more
than
a
little
bit
than
dream
and
rest,
and
that
is
no
knock
against
ryan,
because
ryan
is
quite
good
at
rest,
but
I
do
a
lot
of
things
with
kubernetes
and
have
for
a
while
and
basically
a
lot
of
my
career
has
been
in
the
cloud
space.
So
that's
kind
of
my
background.
A
So
we're
talking
about
the
rust
programming
language
today,
maybe
you've
heard
of
it
before,
but
today
we're
gonna
be
talking
about
how
rust
has
come
to
find
a
home
at
microsoft,
how
we
think
about
rust
at
microsoft
and
sort
of
where
rust
fits
in
in
the
the
cloud
space
today
and
to
begin
with
that,
we're
gonna
talk
about
microsoft's
problem,
our
problem,
and
it's
not
just
our
problem.
It's
really
our
all
problem.
A
It's
a
problem
that
the
software
industry
in
general
has-
and
that
is
the
fact
that
our
systems
are
more
interconnected
and
performing
more
and
more
tasks
every
single
day,
but
along
with
that,
what
that
means
is
that
our
systems
are
more
vulnerable
and
attackers
have
more
incentive
to
attack
us,
and
so
you
might
be
thinking
okay.
What
does
that
have
to
do
with
rust?
Well,
if
we
look
at
over
time
the
number
of
cves
that's
the
most
secure
security
are
the
most
serious
security
vulnerabilities
over
time.
A
You
can
see
that
the
number
is
just
going
up.
This
stops
at
2018,
but
over
the
past
three
years
it's
basically
been
the
same
story.
It's
going
up
and
up
and
up,
fortunately,
we
see
a
little
bit
less
of
those
vulnerabilities
being
actually
exploited
in
practice,
but
that's
not
out
of
magic
or
anything
like
that.
A
A
A
That
happens
in
production,
so
this
figure
is
probably
much
larger
nowadays,
because
our
systems
are
much
more
complex
and
how
many
of
these
do
we
have
every
year.
This
figure
is
a
little
bit
more
recent,
but
I
think
this
was
2019.
We
had
468
of
them,
and
so,
if
you
just
think
that
we're
spending
just
on
addressing
the
issue
directly
in
the
tens
of
millions
of
dollars
and
and
2002
dollar
figures,
that's
a
lot
of
money
and
that
again
does
not
take
into
account
all
the
headache
that
comes
with
it.
A
A
The
fact
that
a
lot
of
the
security
vulnerabilities
come
from
exploiting
the
incorrect
use
of
memory
and
if
you
look
at
the
percentage
of
these
very
severe
security
vulnerabilities
about
70
of
them,
are
due
to
memory
safety
issues,
so
the
incorrect
use
of
memory
safety
and
then
30
percent
of
them
don't
have
to
do
with
that
they're
kind
of
logic
bugs
or
something
like
that.
So
it
kind
of
stands
to
reason.
A
If
we
can
address
this
this
memory
safety
issue
the
incorrect
use
of
memory,
then
presumably
70
of
our
worst
security
vulnerabilities
will
just
disappear
and
that
would
be
fantastic,
wouldn't
mean
that
our
systems
are
magically
completely
secure,
but
70
going
away
is
means
we
can
focus
our
our
time
and
attention
on
that
30
percent
and
really
try
and
hone
in
on
those
which
would
be
a
fantastic
thing
is
russ.
The
answer
to
this.
A
A
That
might
be
true
for
for
your
particular
applications,
but
I
still
implore
you
to
think
about
this
because
you're
running
on
top
of
system
software,
the
software
that
you
rely
on,
like
your
database,
your
operating
system,
all
the
tools
that
come
around
with
it
usually
are
written
in
these.
These
memory,
unsafe
languages,
like
c
and
c,
plus,
plus
and
with
rust.
We
can
replace
those
languages
and
still
keep
the
reason
that
we
use
those
languages
in
the
first
place,
which
is
usually
performance
and
control.
A
On
top
of
that
and
related
to
memory.
Safety
is
the
idea
of
correctness.
So
when
we're,
when
we
use
rust,
we
get
a
lot
of
features
in
the
language
that
are
there
in
order
to
make
sure
that
the
programs
that
we're
writing
are
correct,
that
we
don't
have
bugs
in
them.
Now
it's
totally
possible
to
write
bugs
and
rust
taylor,
and
I
we
have
both
written
our
fair
share
of
bugs
and
rust.
A
But
one
thing,
that's
kind
of
hard
to
quantify
is
that
when
you
do
write
a
rus
code,
you
tend
to
write
code
that
is
less
buggy
than
in
other
languages,
and
that
includes
languages
with
garbage
collectors
like
c
sharp
or
java.
So
this
is
a
you
know.
We
don't
have
kind
of
numbers
to
really
concretely
say
how
much
this
is
true,
but
it
is
certainly
something
that
we're
finding
anecdotally
to
be
true,
and
along
with
that,
you
know
you.
A
That's
much
faster
than
you
potentially
would
in
other
languages,
which
is
is
fantastic
and
then,
above
all
else,
you
can
tell
I'm
a
I'm
a
big
fan
of
rust.
You
know
you
might
be
thinking
this
guy
up
here
on
on.
My
screen
is
just
you
know
spouting
the
rust
gospel,
but
I
don't
you
know
I
don't
you
know,
he's
just
one
person,
but
I'm
not
alone.
You
know
stack
overflow
submits
their
yearly
survey
for
developers
and
rust
for
the
past.
A
Five
years
has
been
number
one
on
that
list,
and
so
you
know
it
seems
to
be
that
other
people
also
and
enjoy
this
language.
So
you
know,
even
if
you
don't
think
rust
is
right
for
you,
it
could
be
a
fun
language
to
learn
and
it
is
at
times
a
joy
to
use
really
at
the
core
of
this.
Is
that
rust
that
we
want
to
reduce
the
use
of
memory
unsafe
languages
like
c
and
c,
plus
plus
through
the
use
of
of
rust?
B
And
this
raises
the
question
for
a
lot
of
people,
I'm
assuming
in
this
audience
you're
like,
but
wait,
I'm
using
c
sharp
or
I'm
using,
and
but
what,
if
I'm
using
this
memory
safe
language?
So
that's
a
really
good
question
and
that's
something
I
want
to
address
because,
like
I
said,
my
experience
is
coming
from
those
in
in
the
cloud
world
coming
from
those
that
background
of
memory
safe
languages,
whether
that's
doing
something
like
go,
which
is
my
which
is
my
original
background
you
have.
B
This
is
the
go
go
for
in
case
you're,
not
sure
rust
is
a
crab
because
we're
rust
stations
and
goes
or
go
go
programmers
or
gophers,
and
so
this
is
the
go
mascot
and
I
and
a
lot
of
people
who
do
things,
especially
with
kubernetes,
do
things
with
go
and
people
always
say
but
wait.
My
language
is
already
memory
safe,
and
so
I
wanted
to
address
that
a
little
bit,
but
in
context
of
a
project
that
we
have
called
crestlet
crestlet
is
a
we're.
Gonna
talk
a
lot
about.
B
I'm
gonna
show
a
lot
of
demos
around
it
and
we're
gonna
get
into
the
demo
thing.
We
wanna
kind
of
explain
why
we're
even
talking
about
rust
here
in
this
in
in
this
conference
like
well,
why
russ?
What
does
this
have
to
do
with
azure?
Well,
that's
what
we're
getting
into
here
so
cressley
is
a
project
we
started.
That
is
essentially
a
kubernetes
kubelet
which,
if
you
are
not
familiar
with
kubernetes,
is
the
node
aspect.
So
it's
what
run
it
it's!
B
What
runs
on
every
node
in
a
cluster
of
kubernetes
nodes
and
that
thing
connects
it
to
the
main
api
and
registers
and
does
all
those
tasks,
and
so
we
wrote
a
kublet
in
rust
and
for
what
crazy
purpose
you
might
ask,
that's
actually
for
webassembly
or
wasm,
which
you
saw
was
also
one
of
the
most
loved
languages
on
there.
That's
just
a
little
aside,
but
we
are
doing
a
lot
of
things
with
webassembly,
which
is
somewhere
where
we
see
the
cloud
moving
towards
here
in
the
near
future.
B
But
more
importantly,
there's
things
such
as
what
we
like
to
call
the
conversion
traits
these.
If
you've
heard,
if
you've
experimented
with
rust
at
all,
you've,
probably
seen
as
ref
there's
things
like
azref
dref,
whole
bunch
of
them
and
all
of
these
traits
allow
you
to
actually
convert
types
over
or
use
a
type
as
another
type
in
a
very,
very
safe
and
generic
way,
they're,
just
very
flexible
and
powerful,
and
we'll
kind
of
go
over
some
some
examples
of
that
in
a
little
bit
next
office.
B
B
The
next
thing
we
really
love
is
the
air
handling
and
iteration
tools.
So,
if
you're
familiar
with
a
link,
style
program
or
anything
from
the
functional
programming
world,
a
lot
of
that
is
available
in
rust,
and
it
goes
together
with
the
error
handling,
because
error
handling
is
their
values
but
they're
van
they're
values
that
have
to
be
handled
or
they
raise
a
compiler
warning
and
the
tool
for
the
tools
for
handling
those
errors
are
really
really
nice.
B
You're
able
to
map
what
like
a
type
into
another
type
or
if
it
is
an
error,
do
something
all
with
with
relative
ease.
And
then
you
have
the
iteration
tools
as
well
that
allow
you
to
go
into
filtering
and
mapping
and
collecting.
You
can
basically
do
an
example
of
of
filtering
or
putting
out
a
bunch
of
asynchronous
tasks.
B
Basically,
a
fanout
fan
in
job
in
a
very,
very
short
amount
of
code,
we're
talking,
10
15
lines,
and
that's
really
really
incredible
for
for
a
language,
and
especially
when
you
do
a
lot
of
things
like
that,
with
data
massaging
and
things
in
in
cloud
computing
and
last
or
not
last,
but
one
of
the
other
things
we
really.
We
really
like
is
dependency
management
tooling.
B
Now,
dependency
management
is
a
hard
problem
to
solve
in
general,
but
the
dependency
management
and
build
tool
chain
for
rust,
which
is
called
cargo,
is
very,
very
powerful
and
very
useful.
I
have
fought
a
lot
in
languages
like
go
that
are
just
a
nightmare
to
upgrade
any
dependent
because
you
have
to
get
the
right
shots
and
do
all
these
things
and
and
even
with
ones
that
are
they're
a
little
bit
more
fully
featured.
B
You
still
have
a
lot
of
problems
with
dependency
resolution
and
what,
if
I
want
to
try
out
something
locally
or
patch,
something
and
and
cargo
makes
that
very,
very
easy
for
you.
It
is
just
that's
one
of
the
other
things
I
will
gush
about
is
cargo,
just
because
it
is
so
powerful
and
useful,
and
that's
why
we
that's.
Those
are
some
of
the
big
reasons
we
chose
like
rust
over
something
like
go
and
last
off.
Is
that
mentioning
of
correctness
so
memory
safety?
B
Is
you
see
something
you're
like
no?
This
is
right
and
the
compiler
is
telling
you
no
you're
wrong
and
you're
like
no,
but
I
am
right
and
then
you
like
sit
there
and
you
look
through
it.
You
dig
through
you're
like
oh,
oh
I'm
accessing
that
data.
When
I
don't
have
actual
like
something
else,
it
could
be
accessing
it
simultaneously
or
I
don't
have
the
correct
ownership
over
it.
So
that
correctness
is
very,
very
important
to
us
as
we've
been
coding
things
for
the
cloud,
so
this
also
brings
up
the
other
question.
B
Why
not
rest
for
the
cloud
like
when's
reasons
you
should
or
shouldn't
use
rest
for
the
cloud?
So
let's
talk
about
that.
The
first
thing
is
the
async
environment.
So
async
was
something
that
was
added
a
little
bit
later
in
rust's
development.
It's
still
technically
very
new,
it's
about
a
year
year
and
a
half
old
in
terms
of
being
in
the
stable
branch,
and
it
has
some
rough
edges
still
now.
That's
not
to
say
that
it's
not
that
it's
impossible
or
overly
difficult,
but
and
but
there's
currently
lots
of
work
being
done
here.
B
There's
a
current
there's,
a
work
group
that
was
started.
That's
gathering
different
requirements
and
things
from
community
members
to
make
the
async
story
better,
but
it
is
if
you're
used
to
something
like
go
in
particular,
where
you
can
just
say:
go
run.
Something
like
just
go.
Do
a
function.
You're
gonna
have
a
lot
of
rough
edges
to
get
used
to
but,
like
I
said,
there's
a
correctness
benefit
that
comes
from
using
async
with
rest.
B
Another
thing
is
that
the
ecosystem
can
sometimes
be
immature
for
cloud
usage.
A
quick
example
here
is:
we
were
trying
to
do
something
like
parsing,
a
multi
multi-part
data
from
an
http
request
turns
out,
basically,
all
the
libraries
only
support
multi-part
form,
and
so,
if
you're
trying
to
send
any
other
kinds
of
data
now,
that's
something
like
really
simple
and
really
small
might
only
affect
some
projects,
but
you'll
find
lots
of
gaps
like
that,
because
people
haven't
really
used
all
of
it
in
the
cloud
until
recently.
B
Now,
like
ryan
mentioned,
there
is
a
learning
curve
to
rest,
and
it
really
is
just
the
initial
learning
curve.
I
like
to
call
it
logarithmic
and
don't
take
that
in
like
an
extreme
way.
It's
just
that's
what
the
curve
looks
like
you
kind
of
have
this
initial
period
of
where
it's
just
a
very
sharp
curve.
A
All
right,
so,
I
think
now
we're
going
to
be
going
to
a
demo
to
show
off
what
russ
code
looks
like.
This
is
a
very
short
presentation,
and
so
it's
we're
not
going
to
be
able
to
show
what
you
know
how
rust
works.
This
is
not
a
rust
101
course,
or
something
like
that.
This
is
really
meant
to
be
kind
of
a
an
overview
of
what
you
might
experience
if
you
use
rust.
A
So
don't
worry
if
you
don't
understand
every
line
you
if
you
haven't
done
rust
before
you
certainly
won't,
but
this
should
just
give
you
a
flavor
of
of
what
that
kind
of
looks
like
all
right.
So
I'm
sharing
my
screen
here
now
and
hopefully
you
should
be
able
to
see
what
I
have
going
on
here,
and
this
is
a
simple
project
that
I've
started
and
what
you're
looking
at
right
here
is
the
cargo.tamul
file
for
my
project.
This
is
a
rust
project.
A
Cargo
is
rust's,
build
tool,
slash
dependency
manager,
slash
test
runner
kind
of
does
everything
around
building
and
testing
and
running
rust,
and
this
is
sort
of
a
manifest
file
describing
some
metadata
about
my
project.
Like
the
name,
the
version
you
know
who
the
author
was
and
things
like
that
and
then
down
here.
This
is
kind
of
one
of
the
best
parts
about
about
rust
is
the
dependency
management
is
quite
simple,
so
I'm
going
to
be
using
two
of
our
libraries
from
from
azure
here
one
is
azure
core.
A
The
other
one
is
azure
cosmos,
because
we're
going
to
be
writing
a
small
little
demo
with
cosmos
db,
then
I'm
going
to
be
using
tokyo,
which
tokyo
is
an
async
runtime
now
rust,
because
it's
a
systems,
programming
language
doesn't
have
a
runtime
built
into
it
like
javascript
does
or
c
sharp.
Does
you
have
to
provide
the
runtime
for
you
what's
really
great
about?
That
is
that
you
can
switch
runtimes
out
depending
on
your
use
case.
A
So
if
you
need
something
that
runs
on
a
raspberry
pi,
that
might
be
very
different
than
something
that
runs
on
a
beefy
server
in
azure,
and
this
allows
you
to
kind
of
switch
them
out
to
use
which
one
you
want
to
use
and
then
request
here
is
a
simple
http
library
that
runs
on
top
of
of
tokyo
that
we're
going
to
be
using
to
actually
actually
power.
The
http
requests
that
we
make
to
azure
here
and
then
I'm
going
to
pop
on
over
here
to
our
main.rs
file.
A
This
is
kind
of
everything
that
we
we
have
so
far
in
our
little
app
that
we
have
going
here.
You
can
see
that
we
have
a
main
function.
That's
going
to
be
run
automatically
when
we
run
our
binary
and
it's
annotated
with
this
funky
thing
here
called
tokyo
main
and
that's
because
normally
main
functions,
just
like
in
c
are
not
asynchronous.
A
But
this
little
tokyo
main
annotation
here
allows
you
to
make
your
main
function
asynchronous
and
it
builds
a
tokyo
runtime
for
you
and
runs
your
main
function
on
that
runtime.
So
it's
very
there's
a
lot
going
on
here
underneath
the
hood,
but
you
get
very
nice
short,
concise
annotations
that
help
you
build
up
your
application.
This
is
an
example
of
what
taylor
was
talking
about
with
macros.
This
tokyo
main
here
is
a
macro
that
is
generating
some
code
for
running
our
code
on
a
tokyo
runtime.
A
This
is
because
our
cosmos
client,
all
the
azure
sdk
clients
that
we
are
building
right
now
are
agnostic
to
what
each
underlying
http
library
that
they
use,
so
you
can
plug
in
your
favorite
http
library
and
that's
what
will
be
used
by
the
by
the
the
various
libraries
that
we're
building
for
azure.
Now
I
just
want
to
mention
one
other
thing
about
the
the
azure
sdk
that
we're
using
here
today,
I'm
going
to
pop
back
over
here.
A
A
This
is
coming
from
crates.io,
which
is
something
that
you
can
think
of,
like
npm
or
or
some
kind
of
package
store
that
you
that
you
might
use.
We
do
not
yet
publish
these
on
crates.I
o
our
our
azure
sdks
are
not
currently
on
craigslist,
because
they're
under
heavy
construction
right
now,
it's
it
was
a
community
project
and
has
been
moved
on
to
the
azure
organization
as
a
alpha,
unsupported
unofficial
sdk.
A
So
while
we
do
have
microsoft
people
working
on
it
full
time,
I
you
know,
I
work
on
it.
Quite
often,
as
does
taylor,
it's
not
yet
to
the
point
at
where
we
can
provide
official
support.
Where
you
can,
you
know,
call
somebody
up
and
have
them
help
you
with
it,
but
we
hope
to
one
day
get
to
that
point.
It
doesn't
necessarily
mean
that
it's
bad
software
or
anything
like
that.
It's
just
we
what
we
say.
A
A
So
what
I
want
to
go
ahead
and
do
here
real
quick,
is
try
and
show
how
to
make
a
request
to
cosmos
db,
using
our
cosmos
client
to
just
fetch.
The
various
databases
that
I
have
inside
of
my
cosmos
db
account
that
I
have
here
so
if
we
type
out
cosmos
client
here
and
you
can
see,
there's
a
whole
bunch
of
methods
that
come
with
this,
and
I
can
call
list
databases
here
and
then
I
can
call
execute
because
list
databases
just
gives
us
back
a
request,
object
that
we
can.
A
We
can
add
some
additional
optional
features
to
and
then
we're
going
to
call
execute
on
it
and
then
await
on
the
result
of
calling
execute,
and
then
we
can
store
that
into
a
variable
that
I'll
call
response
here
now,
you'll
notice,
I
didn't
type.
This
result
thing
right
here.
This
is
not
me
typing
it,
but
this
is
rust's
rust,
analyzer,
plugin
extension
for
vs
code.
That
gives
some
very
nice
additional
information
about
our
rust
code.
A
So
it's
telling
me
the
type
here
and
the
result
type
here
is
just
saying
that
this
operation
might
fail.
It
might
error
out
and
error
handling
and
rust
is
real.
Nice
and
easy.
All
you
have
to
do
is
add
a
question
mark
here
and
it
basically
pops
the
error
out
from
the
main
function
and
returns
an
error.
A
If
our
our
call
to
execute
errors
here
pretty
plain
and
simple,
and
then
in
order
to
get
the
names
of
our
databases
that
we
have
here,
we
can
go
ahead
and
do
something
like
we'll
call
print
line
here
and
then
I'm
just
going
to
say
the
lists
are
sorry,
the
databases
are
going
to
be
the
response,
dot,
databases
and
we
have
to
sorry.
We
have
to
call
dot
itter
here
and
then
map
and
we
get
each
database
in
turn
and
then
we
can
call
db
dot
name.
A
That
gets
the
name
of
the
database,
and
then
we
collect
all
of
these
to
get
oops
and
I'm
in
the
wrong
place.
Here
we
collect
all
of
these
into
a
vector
which
is
basically
like
an
array
of
string
objects
just
like
this.
So
if
you've
not
done
rust
before
you
might
be,
you
know
confused
with
some
of
the
syntax
and
stuff
like
that.
That's
part
of
learning
rust,
but
this
hopefully
should
work
and
I'm
just
gonna
pop
up
this
here.
A
You
know
this
is
a
terminal
right
here
and
I'm
going
to
go
ahead
and
run
cargo
run
which
will
build
and
run
my
executable
and
and
we'll
see
what
it
what
it
says.
I've
already
set
the
cosmos
primary
key
and
cosmos
account
in
my
environment,
and
it
should
hopefully
work
out
just
fine
and
and
there
we
go
so
I
do
have
one
database
in
my
account.
A
It's
the
test
one
database
and
we
have
been
successfully
able
to
use
the
azure
sdk
for
rust
and
its
current
form
in
order
to
fetch
that,
from
my
cosmos
account
so
nothing
new
here,
you
probably
are
already
doing
this
with
your
sdks
in
your
current
language,
but
it
goes
to
show
that
rust
being
a
systems.
Language
doesn't
mean
that
it's
a
huge
verbose
monster.
B
Yep
and
so
just
while,
I'm
starting
my
my
screen
share,
I
just
wanted
to
point
out
like
that.
I
love
how
simple
we're
able
to
go
and
iterate
over.
Like
that's
one
of
those
things
is
if,
if
you're
in
the
cloud
world,
you're
you're
basically
going
to
be
like
mashing
data
around
and
doing
things,
but
you
were
able
to
quickly
pull
in
all
the
all
the
information
from
from
that
project
and
and
then
just
iterate
across
it
and
and
mash
all
the
stuff
together.
A
B
Yes,
these
some
of
these
things
are
under
construction
like
the
sdk,
but
if
you're
interested
in
doing
it-
and
you
want
to
interact
with
the
azure
apis,
there
are
tools
there
that
you
can
even
at
this
point,
if
you
were
to
start
using
them
in
the
next
few
months,
be
able
to
give
us
important
feedback
and
say
hey.
I
found
this
bug.
I
need
this
feature.
Why
doesn't
it
do
this
or
oh,
I
really
like
this:
can
you
make
the
other
things?
B
Do
it
like
this
or
whatever
you
want
to
do
so,
just
something
good
to
point
out
from
that
code
yeah.
So
here
I
just
want
to
actually
first
and
first
of
all
I'll
share
my
some
things
about
crestlet.
So
now
we're
going
to
go
into
the
kubernetes
portion.
This
we
talked
a
little
bit
about
azure.
Now
we're
going
to
talk
about
kubernetes,
azure
and
rust
all
together.
B
So
right
here
is
the
crestlet
project.
You
can
find
it
on
deus
labs
crestlet
on
github,
but
before
I
start
with
kind
of
showing
some
of
the
cool
things
that
russ
can
do
for
you,
I'm
going
to
first
start
off
basically
adding
crestlet
to
an
aks
cluster
for
you.
So
we
have
something
that
walks
you
how,
through
how
to
do
this
inside
the
docs
folder.
B
You
actually
can
see
various
examples
inside
our
how
to
we
have
it
for
pretty
much
every
kind
of
major
cloud
provider,
but
here
on
azure
you'll
see
that
it
has
a
very,
very
quick
guide.
So
the
first
thing
you'll
need
to
do
is
create
a
service
principle
which
I've
already
done
and
then
make
sure
you
have
an
ssh
key.
But
then
you
have
this
deployed
azure
button.
B
So
I'm
going
to
move
over
here
where
I
already
clicked
on
that
and
I'm
going
to
create
a
new
resource
group
called
I'm
just
going
to
call
it
crusty,
because
krusty
the
crab
and
also
crestlet,
and
then
I'll.
Just
put
this,
I
like
to
put
things
actually
since
we're
doing
in
europe.
I
will
find
a
area
over
in
the
eu.
Let's
do
let's
do
west
europe
and
then,
basically,
all
the
things
are
all
set
up
for
you.
You
can
even
specify
your
kubernetes
version,
I'm
actually
going
to
specify.
B
We
recently
released
a
newer
version
of
crestlet
0.7,
so
I'm
going
to
change
it
to
make
sure
it
downloads
that
and
that's
it
all
I
have
to
do,
is
then
do
the
review
and
create
let
it
validate
the
template.
No,
it
looks
like
it
failed.
Let's
see
what
I
did
because
of
course
I
am
angering
the
demo
gods.
B
B
B
This
is
a
crate
we
released
that
allows
you
to
write
kubernetes
operators
in
rust,
and
so,
if
that's
something
that
interests
you,
this
is
probably
a
good
place
to
start,
because
kublet,
dark
kubelet
is
actually
built
on
this.
This
crate
that
we
that
we've
created
so
this
actually
we're
hoping
to
make
a
something.
That's
completely
separate
from
the
crescent
project
in
the
future,
but
there's
a
great
example
in
here
that
shows
how
you
can
use
macros
and
things
to
your
advantage
so
inside
of
kubernetes.
B
This
is
this
is
a
part
where
we're
getting
to
a
little
bit
of
prior
kubernetes
knowledge,
I'm
going
to
explain
a
little
bit,
but
if
anyone
has
any
questions,
please
feel
free
to
drop
those
in
in
chat
or
in
discord,
and
I
can-
and
I
can
answer
those
but
inside
of
kubernetes.
You
have
kubernetes
resources
and
all
of
them
kind
of
have
a
similar
similar
look
to
each
other.
B
They
have
a
very
common
set
of
of
parameters
that
are
set
with
them,
but
there's
also
a
a
type
of
resource
in
kubernetes
called
a
custom
resource
or
a
crd,
and
that
stands
for
custom
resource
definition.
This
allows
you
to
basically
add
on
arbitrary
apis
to
the
kubernetes
api,
and
then
it
starts
handling
them
like
normal
kubernetes
objects,
and
then
you
can
write
controllers
or
pieces
of
software
that
can
handle
those
objects
and
do
things
for
you.
So
people
do
this
to
set
up
things
like
various
clusters
that
need
to
be
orchestrated.
B
So
like
database
clusters
are
a
common
thing.
You'll
see
also
to
set
up
custom
resources
for
you
for
your
company,
that's
also
quite
common,
so
this
one
is
a
funny
one
that
uses
moose
as
the
as
the
example,
but
we
have
this
custom
resource
derived
that's
going
on,
so
these
are
all
macros
here
at
this
top
level
and
let's
kind
of
walk
through
what
this
is
all
doing
for
you.
B
So
if
you're
used
to
doing
this
probably
in
go,
you
might
have
also
done
it
in
python
or
another
another
language,
but
you
have
to
generate
a
lot
of
code,
so
you
have
to
generate.
You
have
to
create
your
object,
and
then
you
have
to
generate
the
code
for
that
object.
That
does
that
creates
the
client
for
it
and
the
handling
for
it,
and
then
you
have
in
go.
At
least
you
have
to
commit
that
code.
B
These
derive
an
implementation
for
a
powerful
library
in
rest,
called
certi,
which
stands
for
serialized,
serialize
and
basically
any
data
model
that
has
an
implementation.
So
we're
talking
tamil
yaml
json
message
pack,
any
of
those
things
can
now
serialize
or
deserialize
these
objects
into
their
specific
message
format.
So
there's
no
extra
like
attaching
it
on
it's
just
you.
You
derive
those
two
things,
and
then
this
also
has
the
bonus
of
adding
on
a
json
schema.
B
B
This
example
a
little
bit
I'll
see
because
right
now,
it's
a,
I
think
it's
under
some
active
construction
on
the
on
the
main
branch,
but
it
really
gives
us
some
some
power
there
to
to
do
what
we
need
to
and
another
thing
that
we
find
very
useful,
particularly
in
the
cloud
world
that
we
didn't
mention
before
is
something
called
features.
So
I'll
show
you
actually
what
this
looks
like
so
inside
of
kubla
inside
this,
the
cargo
file
that
we
talked
about,
that
we
were
showing
that
ryan
was
showing
earlier.
B
You
can
see
this
that
it's
declaring
the
kubelet,
it's
saying
our
version,
all
the
different
things
that
are
in
there,
but
then
you
see
this
feature
section
and
large
libraries
generally
have
this.
Now.
What
this
does
is
allows
you
to
selectively
import
code
and
turn
on
and
off
things
you
don't
need
with
ease.
So
the
way
we
use
this
quite
a
bit
is
with
the
derive
feature,
but
also
the
cli
feature.
So
the
cli
feature
is
an
optional
thing.
B
B
This
config
object
now
this
config
files,
this
config
things
a
little
gnarly,
there's
a
bunch
of
stuff
going
on.
In
here,
but
a
lot
of
different
things
like
we're
not
importing
in
things
unless
we
need
it,
so
this
is
just
saying
if
I
have
a
feature
called
cli,
please
import
this
code,
but
this
also
goes
down
I'm
going
to
scroll
down
to
get
to
it.
Sorry.
B
The
actual
struct
that
does
all
the
parsing
so
we're
basically
not
importing
an
entire
struct
based
on
whether
or
not
we
enabled
a
feature,
and
so
right
here,
you'll
see
that
we
have
the.
If,
if
we
have
cli
set
or
if
we're
building
our
documentation,
then
we
are
going
to
use
it,
and
so
these
things
add
on
you
can
also
conditionally
build
parts
of
your
code
depending
on
your
operating
system.
B
All
these
things
are
very,
very
useful
when
you,
you
have
something
that
you
want
to
run
on
any
system
anywhere
and
only
import
exactly
what
it
needs.
So,
when
you
build
the
stuff
for
for
your
windows
code
or
for
mac
os,
if
there's
some
like
in
our
case,
where
there's
a
bug
we
had
to
work
around,
then
we
we
are
able
to
only
pull
in
those
fixes
or
those
hacks
when
we
need
them,
and
so
it's
really
really
powerful.
B
B
So
let's
go
ahead
into
a
terminal
and
here
in
the
terminal
I'm
on
I'm
in
the
crestlet
repository
I'm
actually
on
a
branch
because
I
like
to
live
on
the
edge
and
so
right
here
we're
going
to
go
ahead
and
just
first
pull
down
our
credentials.
If
you
are
not,
if
you're
not
familiar,
it
is
aks
credentials.
Actually,
here
I'm
just
going
to
pull
it
from
the
dock.
So
you
can
see
what
this
looks
like.
B
B
So
this
will
actually
go
fetch.
The
credentials
put
them
into
your
local
coupe
config.
If
you're
new
to
kubernetes-
and
it's
going
to
tell
me-
I
already
have
it
because
I
I
had
one
before,
as
I
was
testing
this,
but
now
I'm
actually
talking
to
that
cluster.
You
can
see
if
I
do
to
control
cluster
info,
it's
going
to
return
information
about
the
cluster.
B
B
And,
like
I
said,
you
don't
have
to
use
this
to
to
run
webassembly
modules.
If
that's
not
your
thing,
the
point
of
this
is
to
show
that
we
were
able
to
use
rust
to
build
a
very
powerful
kubernetes
application,
which
is
kind
of
becoming
one
of
the
de
facto
things
for
running
in
the
cloud
in
rest,
without
lots
of
crust
and
extra
bloat
and
really
in
a
in
a
powerful
and
safe
and
correct
way,
and
so
let's
go
ahead
and
show
that.
B
And
it
was
created
so
we'll
see
that
it
should
have
run
all
the
way
to
completion
yeah,
see
so
exited
with
an
exit
code
of
zero,
because
it,
it
was
just
only
doing
one
thing,
but
you
can
interact
with
this.
Just
like
you
would
a
normal
kubernetes
node,
so
I
can
say
cube
control
logs
on
hello,
world
wazi
rust,
and
you
can
see
that
it.
It
printed
the
standard
out
in
standard
error.
B
It
printed
out
some
environment
variables
we
set
and
then
also
the
bacon
ipsum,
which
is
our
our
funny
version
of
the
laura
mipsum
filler
text,
and
so
you
can
see
that
it
printed
out
that
all
of
that
information
so
basically,
like
I
said
all
of
this
is
running
in
rest.
We
didn't
take
any
shortcuts.
We
didn't
do
anything
anything
to
like
work
around
this.
This
is
all
rust
and
we're
able
to
implement
the
same
apis
that
kubernetes
has
and
be
able
to
pass
through
and
get
this
kind
of
information.
B
So
there's
that
I
just
want
to
pause
in
case.
Anyone
has
any
questions
and
then
I
think
we
have
a
little
bit
more
time
for
one
more
demo,
but
let's
just
stop
in
case
there's
any
questions
that
come
through
on
the
comments
or
on
discord.
Anything
you
want
to
add
to
this
ryan.
While
I
was
talking
about
anything
that
I
may
have
missed
or
glossed
over.
B
B
So
in
the
moose
example
here
actually
is
meant
to
run
an
admission
controller
and
a
whole
bunch
of
other
kubernetes
things.
So
if
you're
familiar
with
kubernetes
you're,
probably
like
ooh,
that's
cool
if
you're
not
you're
like
what
is
when
the
world.
Is
that
don't
worry?
It's
there's
just
a
lot
of
things
going
on
here.
In
the
background,
you
can
actually
see
that
there
are
there's
these
scripts
that
will
allow
you
to
run
like
for
different
moose,
that
you're,
creating
and
all
sorts
of
stuff.
B
So
we're
gonna
go
ahead
and
give
it
a
whirl
live
and,
like
I
said
this
could
utterly
fail.
But
why
not?
We
have
a
little
bit
of
extra
time,
so
I
will
I'll
go
ahead
and
share
that.
So
I
believe
the
instructions
you
can
follow
are
out
here
or
maybe
not.
If
not,
then
we're
going
to
be
trying
to
do
it
from
memory,
which
is
always
fun.
B
B
So
this
is
going
to
run
basically
a
whole
kubernetes
operator
and,
while
that
this
might
have
to
build
for
a
second,
so
all
that's
building
you'll
see
here
that
we
have
all
these
different
things
that
are
being
implemented,
which
I'm
not
going
to
go
into,
but
it's
actually
implementing
a
full
state
machine
to
handle
each
part
of
the
moose's
life
cycle
and
there's
some
funny
things
in
here.
That
we'll
see
like
the
sounds
that
the
moose
makes
and
if
it's
munching
or
roaming
see.
B
So
we
have
a
state
called
rome,
but
all
of
these
things
are
are
fairly
easy
to
write.
So
this
whole,
this
is
a
whole
like
fully
featured
if
kind
of
contrived
controller,
and
let
me
check,
I
think
it's
400
lines,
yeah
413
lines
that
does
all
this.
So
it's
if
you've
ever
written
a
controlling
kubernetes
before
generally,
it's
a
lot
more
work
than
a
controller
for
kubernetes.
There's
normally
a
lot
more
work
than
this.
So,
let's
see
if
it
ran
oh
oops,
I
forgot
to
add.
B
B
Like
everything,
new
and
rust,
I
mean
maybe
you're
at
that
state
where
you
want
to
try
something
completely
green
field
and
new,
but
we're
going
to
put
put
up
some
resources
here
for
you
to
to
look
at
the
the
first
one
being
the
wrestling
book.
This
is
basically
the
rust
bible.
It's
the
way
that
it
explains
every
single
part
of
the
rest
language,
starting
off,
really
easy
and
then
going
into
exquisite
detail
about
each
of
the
underlying
things.
It's
it's
a
very,
very
good
resource.
B
B
Our
next
releases
will
be
our
1.0
alphas
and
so
having
people
try
it
out
and
tell
us.
Oh,
this
is
great
or
to
try
out
new
things
with
what
we're
doing
is
also
very,
very
useful
for
us
to
have
the
feedback
that
we
need.
So,
oh
and
we
have
one
question
coming
in
here:
one
was
if,
if
I
would
like,
if
I
would
like
to
build
and
run
a
web
api
in
aks,
could
you
do
that
with
crestlet?
In
a
sense?
B
Yes,
you
could
use
cressit4
inspiration,
but
also
you
can
use
if
you're
going
to
be
doing
it
like
very
embedded
into
kubernetes,
with
the
kind
of
crd
things
I
mentioned
before.
You
can
do
that,
definitely
with
what's
called
with
crestlet,
with
the
crater
crate
that
one
will
allow
you
to
build
your
own
controller
with
some
with
it's
pretty
simple
and
straightforward.
B
B
B
Okay,
I'm
not
seeing
anything
else
come
through,
so
I
think
we'll
go
ahead
and
call
it.
So.
Thank
you,
everyone
really.
This
was
a
great
experience
for
us
I
have
enjoyed
and
also
yes,
thank
you
for
the
last
comment
that
you
hadn't
heard
about
crater
glad
we
could,
let
you
know,
feel
free
to
try
it
out
and
really
thank
you
so
much
for
coming
to
this.
We,
we
appreciate
all
the
the
excitement
that
comes
from
events
like
this
and
everyone's
involvement.