►
Description
WebAssembly is the next big thing on the server and in the cloud. By leveraging tools like Krustlet (https://krustlet.dev/), we can get rid of containers in Kubernetes! What does that mean? What can you achieve today, and what is still experimental? And how can you get hands-on right now? Join this talk by Azure MVP and cloud-native enthusiast Thorsten Hans to get those questions answered. It's time to embrace the platform of the future.
Slides: https://speakerdeck.com/thorstenhans/webassembly-beyond-the-browser
Github: https://github.com/ThorstenHans/krustlet-at-rust-linz
Thorsten on Twitter: https://twitter.com/ThorstenHans
Rust Linz on Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz
A
And
torsten
the
stage
is
yours
yeah.
Thank
you
rhino.
So,
as
rhino
already
mentioned
today,
I
will
give
you
a
quick
introduction
into
chrysler
what
it
is
and
why
you
should
care
about
it.
So,
first
of
all
quick
introduction
to
myself,
my
name
is
thorsten.
I
work
as
a
consultant
in
germany
with
think
texture.
A
I've
been
diving
into
rust,
let's
say
a
couple
of
months
ago:
I
really
enjoy
it.
It's
it's
really
refreshing.
You
know
to
to
look
into
different
languages
and
at
some
point
I
stumbled
upon
crust
blood
and
that's
yeah.
Why
I
invested
a
lot
of
time
in
the
last
weeks
or
so
to
dive
deeper
and
to
see
what's
possible
and
what's
not
possible
yet.
A
A
Somehow,
and
my
my
guess,
is
that
webassembly,
with
wazi
with
webassembly
system
interface,
is
able
to
achieve
that.
So
we
have
wazi
as
the
platform
that
we
can
compile
to
and
then
fuzzy
takes
care
about
all
the
underlying
operating
systems
specifically
like
how
files
are
handled,
how
network
interaction
is
done
and
so
on
and
so
forth.
So
that's
the
kind
of
the
yeah
underlying
idea
of
going
beyond
the
browser
with
webassembly
and
obviously
there
are
yeah
multiple
busy
compliant
run
times
available.
A
A
We
we
end
up
with
having
a
single
binary
right,
that
we
can
take,
throw
it
over
over
the
wall
and
get
it
executed
by
a
by
a
buzzy
compliant
runtime,
no
matter
which
one
it
is
and
no
matter
who's
operating
that
one.
So
is
it
in
perhaps
it
didn't.
Perhaps
the
cloud
vendor
is
in
charge
of
you
know
ensuring
or
operating
or
taking
care
about
the
runtime
being
as
efficient
as
possible.
A
So
or
it
is
me
so
there
are
a
bunch
of,
I
would
say,
clis
or
applications
already
leveraging
wasn't
time
or
vazi
as
its
runtime.
So
we
download
the
actual
application
as
a
as
a
vessel
module
and
we
are
using
wesemtime
to
invoke
it.
So
portability
is
one
of
the
main
whys
why
we
should
care
about
web
assembly
beyond
the
browser
and
the
other
one
is
security
and
I've
taken
to
to
explain
portability
and
security.
A
I've
taken
some
of
the
pictures
from
one
of
the
first
blog
posts
or
articles
written
about
vazi,
so
the
the
link
is
in
the
slides
and
I
will
share
the
slides.
Obviously,
after
the
talk
so
portability.
As
I
already
said,
we
compile
against
the
vesm
32
buzzy
platform,
and
then
we
will
end
up
with
having
a
wasm
module,
which
we
can
then
run
by
leveraging
wasn't
time,
for
example,
on
linux,
on
windows
or
on
mac
os,
so
yeah
for
us
it's
easier.
A
We
just
have
that
one
distributable
as
an
application
developer
that
we
must
provide
and
we
could
or
we
are.
We
have
to
guarantee
right
that
the
underlying
run
time
takes
care
about
interacting
with
the
operating
system,
the
more
interesting
aspect
or
the
more
interesting.
Why
is
obviously
security
right?
So
if
we
take
a
look
at
how
applications
get
executed
traditionally
is
we
have
something?
So
we
have
the
kernel
right,
the
operating
system
with
all
its
apis,
and
then
we
have
the
so-called
user
mode.
A
So
that's
where
you
know
I
execute
applications
and
they
those
applications
typically
interact
with
the
operating
system
apis
by
issuing
system
calls
in
behalf
of
my
user
account.
So
what
typically
happens
as
an
application
say:
hey
as
an
as
written
on
that
on
a
picture
here:
hey
I'm
I'm
I
got
invoked
or
I'm
running
in
the
user
mode
of
alice,
and
can
you
please
open
that
file
right
or
that
directory?
In
that
case
and
the
underlying
operating
system
checks?
A
Okay,
does
alice,
have
the
permission
to
open
that
directory
and
if
so
it
hands
over
or
it
allows
the
application
to
read
the
directory
or
the
files
in
the
directory.
That's
how
it
it
works
today
right.
So
we
have
you
can
think
of
in
if
you're
familiar
with
with
open
authentication,
two,
for
example,
in
open
authentication
we
have
always-
or
we
have
a
user,
and
we
have
a
client
so
the
application
right
that
we
are
actually
using
and
in
the
traditional
mode
how
applications
are
executed
on
an
operating
system.
A
We
are
lacking
control
over
the
application
somehow,
so
the
application
always
talks
with
the
operating
system
in
behalf
of
the
user,
so
a
malicious
application
could
ask
the
operating
system
hey.
Can
you
open
that
bitcoin
wallet
for
me
and
provide
the
path
to
that
bitcoin
wallet
on
the
logical
disk
on
the
physical
disk,
the
operating
system
checks?
If
the
user
bob
has
permission
to
that
file?
A
So
with
the
web
assembly
system
interface,
what
we
can,
what
we
can
do
there
is
so
a
web
assembly
module
is
always
sandboxed
right,
so
the
sandbox
itself
we
can-
or
we
can-
let's
say,
white
list
certain
apis.
So,
for
example,
if
we
come
back
to
the
sample
of
right
doing
some
kind
of
file
access
well,
that
may
be
maybe
allowed.
A
However,
if
we
not
allow
that
risky
app
to
do
any
kind
of
network
communication,
then
the
web
assembly
run
times
opposite
time.
In
that
case,
won't
allow
that
particular
application
to
do
that.
Yeah
to
to
access
the
underlying
network
infrastructure
right
where,
on
the
other
side,
for
example,
the
the
trusted
app
that
may
get
granted
the
permission
to
take
or
to
to
communicate
via
network,
but
the
app
doesn't
need
any
kind
of
local
file
system
interaction.
A
So
it
may
not
have
the
permission
to
read
the
file,
so
basically,
webassembly
and
buzzy
would
allow
us
to
define
permissions
based
on
the
actual
application,
which
is
a
good
thing
which
was
which
we
were
missing
in
yeah
in
a
desktop
application
space.
Let's
say
that
way
for
a
long
time.
So
that's
why
I
think
security
is
one
of
the
most
important
aspects.
What
what
webassembly
and
especially
wazi,
brings
to
the
table.
A
So
in
kubernetes
the
cubelet
is
responsible
for
running
workloads.
So
basically,
if
we
as
a
developer,
let's
say
we
interact
with
the
kubernetes
cluster.
We
say:
hey
kubernetes,
please
run
that
application
right.
So
we
persist
something
on
the
in
kubernetes
api
server.
So
in
ad
cd
and
what
kubernetes
does
it
fires
an
event
that
a
port
is
the
atomic
unit
of
work
in
kubernetes
has
been
requested,
and
then
there
is
a
scheduler.
A
I
I
am
aware
of
what
I
should
do,
so
it
pulls
down
a
container
image
if
we
speak
about
containers-
and
it
runs
that
using
container
d
as
a
runtime
and
crosslat
with
crosstalk,
we
get
rid
of
container
d
because
we
don't
need
containers
because
we
use
a
web
assembly
and
buzz
and
time
so
the
buzzy
comply
and
run
time
as
an
isolation
layer
as
an
application
platform.
Right
so
still,
crosslet
gets
the
request
to
execute
a
workload.
A
A
A
A
bit
more
yeah
to
when
you
get
when
you
do
hands
hands-on.
Basically,
crustlet
is
just
a
binary
right.
It's
a
binary
that
you
can
run
on
any
kind
of
machine
and
it
brings
in
that
compute
power
from
that
particular
machine
into
your
kubernetes
cluster
right.
So
we
can
install
chrysler
in
a
wide
variety
of
kubernetes
distributions.
It
starts
small
with
kint,
so
kubernetes
and
docker.
A
That's
what
I
use
locally
for
testing
or
working
with
kubernetes
in
the
inner
loop
or
if
you
grow,
or
if
you
are
your
requirements
grow
you
can
obviously
install
crust
led
in
regular
kubernetes
clusters
or
if
you
use
a
managed,
kubernetes
environment.
For
example.
Aks
is
azure
kubernetes
service
or
the
aws
or
google
compute
cloud
competitors.
Then
you
can
install
or
bring
in
crust,
led
there
too.
A
So
the
question
is:
why
azure
right?
Why?
Why
should
you
take
a
look
at
azure
when,
when,
when
you're,
focusing
or
diving
into
chrysler,
so
obviously
trustlet
is
an
open
source
project.
But
if
you
take
a
look
at
the
actual
contributor
who's,
maintaining
the
project,
those
are
most
mostly
full-time
employees
that
work
at
microsoft.
A
So
microsoft
has
a
huge
interest
in
making
trustless
successful,
because
that
would
allow
them
to
drive
the
utilization
of
computer
resources
right
because
basim,
the
the
wesm
runtime
and
web
assembly
itself,
I
mean
it's,
we
don't
need
any
kind
of
docker
hosts
right
to
run
applications
isolated
from
each
other.
There
is
the
web
assembly
runtime,
which
is
from
my
point
of
view.
So
my
experience
is
what
I
tested
on
on
on
the
environments
I
got
my
hands
on.
A
And
what
always
stands
for
or
for
what
microsoft
always
stands
for?
Is
integration
right,
so
adding
things
or
integrating
with
existing
services
is
always
top
on
top
on
mind
when
a
at
microsoft
so
and
the
same
applies
about
how
to
get
your
hands
on
crasslet,
I
mean
getting
a
kubernetes
cluster
full-blown
kubernetes
cluster
in
azure
takes
like
five
minutes
and
that's
the
that's
the
competition
right.
A
The
competition
is
always
between
those
public
cloud
vendors
who
is
able
to
to
reduce
the
the
time
till
till
you
can
access
your
kubernetes
cluster
and
when
it
comes
to
crosslit
it's
a
one-liner
right.
You
need.
Obviously
you
need
an
extension
which
is
currently
in
preview
that
you
can
install
locally.
A
Let's
say
that
way,
but
on
a
way
more
fi
on
a
fine
granular
on
a
fine
grainer
level
right.
We
can,
for
example,
say
well
this
action.
I
can
use
rust
to
get
that
up
and
running
in
minutes
and
perhaps
for
another
route,
go
or
c-sharp
is
way
more
efficient
to
get
that
work
done.
So
I
can
focus
more
on.
A
How
can
I
achieve
that
that
workload
efficiently?
I
just
have
to
compile
it
against,
whereas
on
32w,
okay
enough
of
slides,
let's
quickly
take
a
look
at
crustlet
in
azure,
so
let
me
jump
over
to
the
browser,
so
I've
already
provisioned
kubernetes
cluster.
There
is
no
crosslit
integration
yet
and
I've
also
provisioned
a
container
registry.
We
will
take
a
look
at
that
in
a
second.
So
if
we
dive
into
the
kubernetes
cluster,
we
can
take
a
look
at
the
node
pools
and
we
see
there's
a
regular
node
pool
which
is
running
linux.
A
So
let
me
quickly
go
to
the
notes.
That
should
be
easier.
So
we
see
there
is
an
regular
ubuntu
1804
running
and
it's
able
to
run
containers
using
container
d
as
a
runtime
okay.
So
what
I've
done?
Let
me
switch
over
to
the
terminal.
Is
the
font
size
big
enough?
If
not
just
reach
out
in
the
in
the
comments,
then
I
can
bump
it
even
more
okay
and
if
you're
wondering
which
terminal
I
use
so
I
always
interested
in
terminals.
I
use
barb.
A
If
you
know,
war
warp
is
terminal
written
in
rust
and
I
have
five
invitations
left.
So
it's
currently
close
preview.
If
you
want
one
please
reach
out
on
twitter,
so
just
mention
address
lintz
and
we
will
yeah.
We
will
raffle
the
five
invitations,
so
yeah
someone
will
get
access
to
that.
One
and
everyone
who
gets
success
can
again
invite
five
others,
so
maybe
we
can
spread
barb
a
little
bit
more
because
I
I
think
it's
a
super
efficient
terminal.
It
yet
has
to
catch
up
with
item
but
yeah.
A
Let's
go
back
to
topic.
Okay,
so
I
have
a
cube
ctl
installed
on
my
machine
cubesat,
but
I'm
a
lazy
guy.
So
I
have
an
alias
k
which
is
cube
ctl,
so
don't
so
bear
with
me.
So
I
have
different
clusters.
I'm
able
to
talk
to.
Let
me
quick
quickly,
config
get
context
verify
if
I'm
looking
oops,
okay,
config
get
context.
A
A
Aks
note
pool,
add
and
let
me
bring
that
one
from
the
history,
because
that's
easier
than
remembering
the
name
of
my
resource
group.
So
what
I
basically
can
say:
hey
there
is
an
existing
kubernetes
cluster
with
that
name
and
that
resource
group
please
create
a
no
a
new
node
pool.
A
node
pool
is
like
a
logical
construct.
So
technically
it's
a
virtual
machine
scale
set,
and
I
say
in
that
scale
you
said:
please
provision
one
vm
and
hey:
please
use
wasn't
as
the
workload
runtime
okay,
so
it's
a
one-liner.
A
Let's
give
it
a
shot
and
yeah
we
see.
Okay,
that's
part
of
the
preview
extension
that
that
you're
you're
you've
installed
and
in
a
couple
of
minutes
we
should
be
good
to
go.
But
let's
keep
that
running
over
here
and
let's
move
on
to
the
crosslet
side.
So
this
is
the
official
crosslit
websites
or
crosslet.def,
and
maybe
I
don't
know
when
the
meetup
was
when
the
guy,
the
guys
from
the
team
were
talking
about
crosslets.
A
Obviously
there
was
a
crust
that
had
that
momentum
when
they
released
the
first
major
version
and
then
there
was
ignite
when
microsoft
announced
the
preview
for
crossfit
and
a
cast.
So
if
it
has
been
a
while,
since
you
double
checked
the
guides,
give
it
a
give
it
a
shot
they
they
they
improved
massively
in
the
last
weeks
or
so.
A
Okay,
so
I
think
it
should
be
up
and
running.
I
don't
know
it
takes
some
takes
a
while,
I'm
not
good
in
waiting
at
something.
So,
let's,
let's
move
on
to
whittlestudio
code,
we
can
revisit
that
in
a
second.
So
the
question
is:
how
can
we
get
a
vessel
module?
Obviously
we
can
use
rust
up
to
bring
in
vesm,
wasn't
32
buzzy
as
a
target,
and
then
we
can
compile
against
that
one.
So
I
have
two
really
really
fundamental
samples
right,
so
it
it's
it's
nothing!
Fancy
here
right.
A
A
So
I
can
compile
that
one,
obviously
against
against
it
wasn't
platform.
Let
me
let
them
go
to
hello,
crossland
and,
let's
say
cargo
build
and
let's
say
I
want
to
do
the
release
build
and
I
have
to
target
for
the
for
our
desired
platform,
all
right,
so
that
one
is
built.
Obviously
I
didn't
do
any
change,
so
I
can
run
that
using
basm
wasn't
time
time
run
target.
A
Then
there
is
this
one.
There's
this
one
and
there's
my
wasm
module
and,
as
you
can
see,
every
750
milliseconds,
a
hello,
chrysler
method
message
will
be
printed
to
a
standard
output
so
having
a
module,
we
can
leverage
every
oci
distribution,
spec
compliant
container
registry,
so
basically
every
docker
registry,
that's
able
to
deal
with
oci,
open
container
initiative
artifacts
because
we
can
take
a
weather
module
and
just
push
it
to
that
registry.
A
A
So
the
question
is:
how
can
we
get
the
vasom
module
as
an
oci
compliant
add
effect
to
our
acr
so
or
azure
container
registry?
And
there
is,
as
always,
there's
a
small
tool.
That's
called
wasm2oci,
which
is
just
a
cli
that
we
can
use.
Let
me
switch
back
to
real
studio
code.
Let
me
go
into
target
release
and
power
target
release
target,
wasn't
32
peace,
so
here's
my
weapon
module
right,
so
hello,
crosstalk
wasn't
so
I
can
use
oci
to
resin.
A
Wasn't
that
in
my
path?
Now,
why
isn't
true
oci,
obviously
push,
and
then
I
can
say
hello,
crossland.wasm
and
just
I
just
have
to
provide
a
name
how
that
artifact
should
be
called
or
should
be
persisted
in
my
azure
container
registry,
an
azure
container
registry
has
a
requirement
that
I
have
that
you
have
to
fully
qualify
your
artifact.
So
it's
always
your
individual
name
of
your
acr
instance:
dot
azure,
azure,
cr,
dot,
io,
and
then
you
can
obviously
specify
the
name
of
that
artifact
or
of
the
repository.
A
A
So
how
can
that
be
pulled?
Because
acr
obviously
requires
some
kind
of
authentication,
and
as
of
today,
we
have
to
specify
credentials
for
that
container
registry
as
a
in
kubernetes
as
a
secret
right.
It's
so-called
image
pull
secret
that
we
can
then
list
on
the
on
the
actual
yeah
part.
So
on
the
vehicle
that
we
use
to
run
our
workload.
A
Azure
does
a
great
job
in
integrating
things,
as
I
mentioned
earlier
right.
So
normally
what
you
can
do
when
you
rely
on
containers,
you
can
just
you
know,
say:
hey
this
aks,
so
my
kubernetes
cluster
can
leverage
a
so-called
managed
service
identity,
with
robust
access
control
to
pull
so
to
download
things
from
that
container
registry.
A
That
does
not
work
with
trustlet
yet
hopefully
yet
so
we
have
to
specify
we
have
to
persist
a
kubernete,
a
special
kind
of
kubernetes
secret
in
the
cluster
that
the
cr
that
crust
that
is
able
to
take
into
consideration
in
order
to
pull
that
that
webassembly
module
from
azure
container
registry
okay.
So
we
have
a
workload
in
our
container
registry.
Let's
jump
back
to
the
terminal
and
you
there
we
go.
We
on
boarding
a
crust,
let
in
aks
worked.
A
So
we
got
a
not
so
good
looking
table
output
over
here,
because
there's
so
many
metadata
involved.
So,
let's
dive
into
the
cluster
itself,
let's
say
cube
ctl
get
nodes
and
you
see
right
now.
I
have
a
resom
wazi
pool
with
a
vm
there
running
in
version
1.0
alpha
one,
and
if
we
dive
into
that
one,
so
let's
say
cube
cdl
describe
node
like
that
one:
let's
go
scroll
a
little
bit
up
there.
A
A
If
we
bring
in
crusted
to
other
kubernetes
distributions,
as
we
will
do
in
a
second,
there
will
be
vasim
32
bazi.
So
this
is
a
value.
Add
from
azure
again
that
we
get
the
web
assembly
gateway
interface
on
top
for
free
right,
so
that
we
can
leverage
you
know,
or
we
can
run
workloads
as
responder
to
http,
calls
and
stuff
like
that,
so
that
that
was
the
good
story
about
the
actual
state
of
the
preview.
A
A
So
I
have
a
kind
cluster
running
locally
in
my
where
is
it
in
my
docker
desktop
environment,
so
I
have
docker
running
locally
and
if
I
do
cube,
cdl
get
nodes
right
now
you
see,
I
have
just
running
a
control
plane
just
and
a
master.
Obviously
so
so
there's
nothing
installed.
Yet.
There's
no
crosslit
and
what
I
have
is.
A
So
what
I've
done?
I've
also
downloaded
the
bootstrap
script,
which
is
a
shell
script
that
takes
care
about.
You
know,
building
a
cross-led
configuration
for
your
needs,
so
that's
estimate
that
estimates,
the
current
kubernetes
the
cube,
cdl
context
and
based
on
that
it
creates
let's
say
current
config
file,
which
is
located
in
config
dash
roots
and,
as
you
can
see,
there
is
a
certificate
you
know
for
doing.
Tls
based
authentication
between
the
crosslat
and
the
kubernetes
cluster,
and
that's
everything
over
here
is
obviously
tied
to
the
kint
cluster.
A
I
am
looking
at
right
now,
so
I've
downloaded
the
crosslet
binary,
so
that's
crossed
crossleft
russia
and
upon
bootstrap.
I
have
to
provide
that
conflict
so
again.
Download
crosslit
the
binary
download
the
bootstrap
file
run
the
bootstrap
file
and
then
we
use
that
output.
So
the
generatedbootstrap.conf.
A
A
A
So
with
that
let's
bring
some
actual
workloads
to
that
cluster.
So
before
I
forget,
I
mentioned
about
how
to
make
chrysler
able
to
pull
docker
or
to
pull
vessel
modules
from
the
docker
registry
so
from
the
private
docker
registry
right.
So
I
have
to
provide
credentials
and
I
have
stored
them
over
here.
So
that's
a
regular
kubernetes
secret
cut
acr
polycrates.
A
So
that's
just
the
base64
encoded
representation
of
the
docker
config
json,
which
is
basically
telling
okay.
There
is
an
acr
instance
running
at
my
individual
name:
dot
rcr,
dot,
io,
use
that
whole
username
and
use
that
password
in
order
to
pull
down
oci
compliant
artifacts,
no
matter
if
it
is
a
docker
image
or
no
matter.
If
it
is
a
web
assembly
module
right.
A
A
A
A
A
Oh,
let
me
copy
that
one.
So
if
I
do
a
mistake
over
here
and
then
name,
then
democrats
will
not
be
good
to
me.
Okay,
we
have
to
specify
some
resources-
that's
totally
optional,
but
definitely
one
of
the
most
important
things
to
do
in
kubernetes.
So
let's
say
our
app
needs
memory,
because
it's
super
complex
right.
It
needs
16
megabytes
of
ram
and
it
needs
let's
say
whatever
had
it.
A
A
A
So
that
is
normally
that's
all.
You
have
to
do
to
run
a
workload
in
kubernetes,
but
we
have
multiple
nodes
right.
There
was
that
one
node,
which
is
able
to
run
containers
and
there's
our
crosslit
and
we
have
to
target
crossland.
And
if
you
remember
we
looked
at
the
we
looked
at
a
cast
over
there.
We
looked
at
aks
and
scroll
up
and
we
have
labels
and
we
have
tens
over
here
and
let's
revisit
those
chains
in
our
got.
A
A
A
So
in
our
case
we
want
to
target
nodes
with
wasm
32
vasi.
Okay,
let's
save
that
one!
That's
everything
we
need
to
specify
in
order
to
target
that
workload
always
and
only
to
nodes,
running
crestlet.
Okay,
let's
go
there.
Let's
go
in
the
other
folder
that
was
cd01,
hello,
crossland,
let's
clean
up
the
thing
and,
let's
say:
cubectl
apply
from
file,
and
that
is
part.
A
A
Okay,
there
we
go
so,
let's
double
check,
cube,
ctl
get
po.
So
give
me
all
the
parts
and
we
see
hey
this
one
is
already
running
and
let's
give
out
some
more
information,
we
see
it's
running
on
my
machine.
So
if
I,
if
I
go
back
to
this
one
so
where
the
crosslet
is
running,
I
see
okay,
there's
no
output
yet
so
that
looks
pretty
good.
A
Let
me
get
get
some
locks
cube,
ctl
logs
and
I
can
provide
the
name
of
the
part
which
is
hello,
crust
led
and,
as
you
can
see,
there
have
been
generated
a
bunch
of
locks
already,
so
that
is
the
most
simple
or
the
simplest
workload
we
can
run
with
webassembly
in
kubernetes,
but
typically
applications
need
to
interact
with
things
right.
They
need
to
interact,
for
example,
with
the
file
system
again
pretty
similar,
very
easy
application.
A
It's
just
taking
a
configurable
target
which
is
a
folder
right
and
then
every
now
and
then
so,
basically
every
two
seconds.
It's
writing
a
file
to
that
particular
folder.
And
you
know
the
file
is
just
a
random.
It's
just
the
iteration,
so
in
the
in
in
32.
That
gets
increased
every
time
and
then
I'm
writing
instant.
Now
so
milliseconds
since
I
don't
know
what
it
is.
First
off
blah
blah
90
something
to
that
file,
so
that
doesn't
matter
it's
more!
A
A
A
A
A
A
That
the
apps
keep
running
and
it
will
let's
kill
that
thing
and
let's
do
a
list,
all
files
of
my
downloads,
folder
and,
as
you
can
see,
there
is
the
file
being.
There
are
three
files
already
being
created,
so
basically
I
have
to
bring
in
or
to
allow
that
module
access
to
certain
file
locations
to
certain
operating
system.
A
Apis
that
I
want
that
application
to
leverage
right-
and
this
is
a
concept
we
can
super
easily
adopt
and
kubernetes,
because
if
we
take
a
look
at
the
pod
spec,
let
me
quickly
bring
up
just
a
template
and
what
we
can
do.
We
can
take
something:
that's
called
volumes
right,
so
we
can
bring
in
persistent
storage,
for
example.
Let's
say
I
don't
know
sample
and
a
sample
can
be
over
there.
A
A
So
what
I
do
over
here,
I
specify
a
port
called
hello,
buzzy
and
reference
it
again
from
the
same
acr.
I
set
the
target,
so
I
the
target
environment
variable
to
mount
slash
data
and
mount
slash.
Data
come
from
comes
from
something
that's
called
volume
and
the
volume
allow
will
allow
that
particular
wasm
module
to
have
access
to
the
out
folder
sitting
here
in
vs
code.
So
we
can
easily.
A
So
let's
go
to
cd
kubernetes,
where
you
know,
there's
the
pod
file
and,
let's
say
hey
cube,
I
think-
and
that's
created-
and
you
see
logs
popping
up
over
here
and
we
should
also
see
if
we
say
cube
ctl
to
wide
all
the
information.
And
you
see
this
one
is
running
since
30
seconds
ago,
and
it's
also
running
on
my
on
my
crestland
machine
okay,
so
we
are
able
to
integrate
seamlessly
seamlessly
and
to
find
granularly
control
what
the
weather
modules
are
able
to
do
in
kubernetes
by
leveraging
first-class.
A
Yeah,
so
obviously
what
you
have
to
do,
you
need
access
to
some
kind
of
oci
distribution,
spec
compliant
container
registry.
I
I
use
azure
container
ranges
free
all
the
time
I
loving
it
loving
the
experience
they
provide
and
you
have
to
add
that
platform
to
your
tool
chain.
So
and
then
you
have
to
build
against
wasm
32
vasi
yeah.
We
looked
at
very
simple
workloads.
How
to
invoke
then
on
using
crossland
on
kubernetes,
which
brings
me
to
the
conclusion.
A
So
I
think
crossland
obviously
is
better
than
containers
for
when
it
comes
to
resource
utilization.
Is
that
something
I
have
to
care
about?
Well,
obviously,
obviously
not
from
a
hosting
perspective,
because
most
of
my
workloads
are
running
in
the
public
cloud,
but
from
monetarization
perspective,
because
if
I
can
add
more
workloads
to
the
same
amount
of
compute
power,
I
can
run
or
I
can
leverage
or
I
can
deal
or
serve
to
more
customers
with
the
same
amount
of
money.
So
yes
at
some
point,
it
becomes
interesting.
A
A
So
basically
it
will
enhance
the
overall
security
and
robustness,
because
I
can
really
I
can
specify
okay.
This
workload
is
able
to
do
x,
y
and
z,
whereas
the
other
one
isn't
and,
to
be
honest
from
my
point
of
view,
it
is
still
a
bit
early
and
I
got
that
yes,
akas
and
crossland.
I
didn't
get
it
up
and
running.
I
ssh'd
into
that
note
that
it's
actually
running
chrysler
and
I
was
not
able
to
spot
the
arrow,
so
it
is
a
it
is
still
early
and
right
now.
A
My
point
of
view
is:
I
would
rather
go
with
a
virtual
machine
scale
set
in
azure,
for
example,
and
bring
in
chrysler
using
desired
state
configuration
on
my
own,
but
then
I
have
full
control
over
the
crosslet
right.
So
as
I
have
it
on
my
machine
right,
you
saw
I
just
fired
up
that
binary
and
I
was
able
to
integrate
that
one
as
a
node
into
my
kubernetes
cluster.