►
Description
Managing WebAssembly apps with Kubernetes - Shivay Lamba, Layer5
Developers can leverage container tools such as Kubernetes, Docker and CRI-O to deploy, manage, and run lightweight WebAssembly applications. In this talk, there will be a demonstration of how Kubernetes ecosystem tools work with WasmEdge WebAssembly applications. Compared with Linux containers, WebAssembly could be 100x faster at startup, have a much smaller memory and disk footprint, and have a better-defined safety sandbox. However, the trade-off is that WebAssembly requires its own language SDKs, and compiler toolchains, making it a more constrained developer environment than Linux containers. WebAssembly is increasingly used in Edge Computing scenarios where it is difficult to deploy Linux containers or when the application performance is vital. One of the great advantages of Linux application containers is the rich ecosystem of tools. The good news is that you can use the exact same tools to manage WebAssembly applications, enabling Linux containers and WebAssembly apps to run side-by-side in the same system.
A
A
Very
quick
introduction,
myself,
I'm
siwai
lamba,
I'm
a
developer
advocate
at
millisearch.
It's
our
open
source,
rust
based
search
engine
and
I'm
also
a
contributor
at
layer,
5
layer
5
is
the
service
mesh
community.
That
runs
a
lot
of
different
open
source
programs
that
are
currently
incubated
in
the
cncf
landscape
and
I'm
also
an
evangelist
for
wasa
med's
project
which
I'll
be
talking
about
a
lot
more
about
today.
And
if
you
want
to
connect
with
me,
you
can
connect
me
on
twitter,
but
yeah.
A
What's
next,
what
things
are
for
the
future
for
running
with
the
same
web
assembly
applications
with
kubernetes?
Well,
so,
first
of
all,
just
a
very
quick
recap
of
what
exactly
is
webassembly
right.
So
you
can
just
think
of
webassembly
as
a
binary
instruction
format.
Essentially,
it's
a
format
that
is
primarily
deviced
a
long
time
back
as
a
method
to
actually
run
alongside
in
the
web
browser,
because
we
know
that
with
javascript
there
are
a
lot
of
performance
limitations
that
actually
comes.
A
If
we
want
to
run
like,
let's
say
some
kind
of
really
high-end
applications
like
such
as
video
editing
on
web
browsers,
using
javascript
can
be
having
a
lot
of
limitations.
So
that
is
why
web
assembly
was
born
and
the
main
idea
was
to
be
able
to
actually
use
languages
such
as
c
c,
plus
plus,
and
create
byte-sized
executables.
A
That
could
actually
run
on
the
browser
with
the
help
of
this
binary
instruction
format,
that
is
web
assembly
and
that
allowed
for
very,
very
highly
intensive
and
highly
computational
applications
to
actually
be
run
directly
in
the
browser
with
the
help
of
assembly.
So
you
could
actually
run
these
c
or
c
plus
compiled
programs
and
run
them
directly
in
the
browser.
But
today
web
assembly
has
grown
and
matured
and
is
now
no
longer
just
part
of
the
browser.
A
So
you
can
definitely
try
it
out
if
you
are
trying
to
run
machine
learning,
applications
on
edge-based
devices-
and
it
also
comes
with
support
for
a
lot
of
different
scripting
languages
like
javascript
python
as
well,
and
there
is
also
oci
compliant.
That
means
it's
your
you
can
use
it
with
any
kind
of
container
applications
and
it
supports
all
the
different
policies
that
are
there
but
yeah
before
we
move
on
to
the
next
part.
I'll
definitely
recommend
checking
this
particular
ros
mx
project.
A
Of
course
I
mean
it's
a
relatively
new
project
right
now,
so
if
you
are
curious
and
if
you
are
interested
in
web
assembly,
it's
a
really
good
platform
to
be
at
it's
still,
a
very
small
community
that
is
there.
We
have
weekly
meet
monthly
meetings
and
working
group
meetings
for
the
vasomets
project
and,
of
course
there
is
a
lot
of
scope,
so
you
can
also
join
the
slack
channel
for
web
assembly,
but
yeah
moving
towards
like
why
does
the
kubernetes
community
actually
need
wasa?
A
Ms
right,
why
why
are
we
just
talking
about
communities
on
on
this
platform
for
communities
on
edge?
Why
does
it
actually
need
was
was
a
match,
so
one
of
the
biggest
important
reasons
is
that
today,
edge
competition,
of
course
we
are
talking
about
edge
today-
has
like
increased
quite
considerably.
But
if
you
talk
about
the
standard
containers
right,
these
are
usually
the
linux
based
containers.
These
occupy
a
lot
of
space
and
they,
of
course,
with
edge
competition.
A
But
of
course
there
are
some
pain
points
when
it
comes
to
web
assembly,
one
of
the
biggest
ones
that
we
have
is
that
it
requires
its
own
set
of
tool,
chains,
sdks,
and
that
of
course
makes
it
a
a
little
bit
more
like
you
know,
difficult
to
actually
set
up,
especially
if
you
have
already
a
very
well
set
up
infrastructure
for
your,
like.
You
know,
linux
based
containers
right,
but
the
good
part
is
that
you
can
actually
run
both
your
standard,
docker
or
your,
like.
A
You
know
your
normal
linux
based
containers,
side
by
side
with
web
assembly
containers
as
well,
and
that's
what
we
are
going
to
be
seeing
how
this
entire
infrastructure
sort
of
looks
like
on
the
on
the
upper
way.
But
yes,
I
mean
developers
can
actually
use
a
lot
of
different
container
tools
like
communities
docker
to
actually
deploy
webassembly
applications,
because
we
have
support
for
doing
basically
for
deployment
of
these
lightweight
web
assembly
runtimes
applications
with
any
of
these
different
platforms
like
docker
or
communities.
A
A
We
have
our
lower
level
runtimes
and,
of
course,
we
have
the
entire
community
stack
that
you
can
see
and
of
course
the
goal
is
that
if
we
can
actually
load
both
your
linux
container
images
and
web
assembly
images,
both
together
inside
just
one
simple
one
single
application.
So
what
you're
seeing
over
here
are
some
of
the
highlighted
ways.
A
So,
for
example,
if
you
want
to
implement
communities
and
to
basically
help
manage
these
webassembly
applications,
you
could
either
use
cryo
or
you
could
use
container
d
or
you
can
even
like
you
know,
use
a
docker
as
well
to
help
run
these
applications
and,
for
example,
we
know
about
different
types
of
low
level.
Oci
compliant
runtimes,
like
c
run
right.
So
the
reason
why
c
run
is
chosen.
It's
a
very
lightweight
c
based
runtime.
A
A
Like
you
know,
if
you
have
a
larger
setup,
you
could
use
standard
communities
or,
if
you
have
a
lighter
set,
you
could
use
k3d
k3
s
right,
smaller
communities
as
well,
so
that
essentially,
what
this
particular
entire
ecosystem
sort
of
is
sort
of
demonstrating.
Is
that,
as
we
talk
about
our
standard
kubernetes
deployment
right
when
we
are
talking
about
the
different
type
of
container
runtimes,
typically,
that
involves
just
linux
containers
right,
but
in
instead.
A
There
are,
of
course,
some
requisites,
for
example,
you'll
have
to
install
rust,
you'll
have
to
install
kubernetes,
but
apart
from
that,
you
will
also
need
to
require
some
of
the
other
different
tools,
including
cryo,
which
is
a
high
level
container
runtime
that
pulls
a
lot
of
different
images
from
things
like
docker
hub.
You
need
was
image,
so
you
can
install
osms
very
easily
by
going
to
github.com
and
it's
very
easy
to
set
up.
A
Of
course
I
mean,
if
you
have
a
linux
based
system,
it
will
be
the
easiest
and
of
course
you
need
communities
as
well.
So
once
you
have
actually
installed
all
of
these
different
things,
we'll
just
cover
some
of
the
different
steps
in
which
you
can
very
easily
set
up
and
actually
run
a
aussie
image
application
inside
of
your
community
spot.
A
So
the
first
thing
is
like
you
can
just
follow
these
set
of
commands
and,
at
the
end,
I'll
also
just
share
some
links.
I've
already
done
that
over
here
in
this
slide,
you
can
just
follow
some
of
these
steps
in
the
documentation
to
very
easily
set
up
communities
awesome
edge
on
site
in
in
your
system,
but
yeah.
The
first
step
would
be
to
actually
go
ahead
and
start
communities.
Of
course.
A
This
particular
example
showcases
running
communities
in
your
local
development
environment,
but
if
you
have
a
hosted
instance
of
capabilities,
you
can
also
do
that.
So
just
run
these
commands
and
then
of
course,
once
your
you
run,
these
particular
commands
your
communities,
cluster,
your
local
cluster
will
set
up
and
it
will
run
and
then
the
next
thing
is
to,
like
you
know,
start
the
actual
cluster.
A
So
once
you
follow
these
particular
steps
where
you
provide
your
craveness
provider
and
then
we
basically
are
going
ahead
and
running
all
these
different
commands
to
essentially
allow
for
the
web
assembly
applications
to
start
running
in
kubernetes
spots,
and
once
we
are
able
to
accomplish
that.
Basically,
we
have
a
very
simple
to
use.
Github
project
open
source
project,
where
essentially,
we
have
created
our
docker
image,
so
you
can
pull
that
as
a
container
image
from
docker
hub
and
we'll
run
that
inside
our
kubernetes
cluster.
A
And
what
you
see
is
the
end
result
is
that
we
have
successfully
actually
run
the
web
assembly
application.
It's
a
simple
version
demo
and
has
successfully
run
inside
of
our
communities
cluster
because
normally,
if,
if
you
were
to
actually
run
these,
like
you
know
this
web
assembly
application,
of
course,
there
are
different
other
runtimes,
where
you
can
support
them.
A
But
it's
super
simple
with
just
at
max,
like
in
half
an
hour
or
one
hour
to
set
up
and
start
running
your
web
assembly
application
on
on
inside
of
your
kubernetes
cluster.
Similarly,
you
can
also
use
this
for
doing
machine
learning
in
inference
as
well.
Of
course,
what
you're
essentially
doing
with
the
wasom
edge
webassembly
interface,
is
that
you're
offloading
all
of
your
machine
learning
tasks
into
your
web
assembly
application.
A
So
you'll
have
basically,
let's
say,
a
rust
function
that
takes
into
account
all
the
different
inferences
that
you
can
do
with
machine
learning,
and
you
can
also
set
up
that
entire
infrastructure
directly
inside
of
your
kubernetes
cluster.
Similarly,
for
if
you're
like
running
some
side
cars
instead
of
on
y
proxy,
you
can
also
very
easily
set
that
up
and
put
that
in
puts
that's
inside
your
cabinet's
cluster.
A
Of
course,
the
one
the
implementation
that
we
covered
covers
there
was
a
mets
project,
but
outside
of
the
vasomets
project,
there
are
other
different
ways
in
which
you
can
also
run
web
assembly
applications
using
using
kubernetes.
So
one
of
the
projects
is
crustlet.
It's
a
rust
based,
like
you,
know,
runtime
that
allows
for
running
web
assembly
workloads
in
kubernetes
cluster.
So
you
can
also
check
this
out
as
well.
A
It
has
a
very
good
support
and
really
great
developer
documentation,
as
you
speak,
and
this
is
also
a
good
good
way
of
actually
running
your
web
assembly
workloads
inside
of
a
kubernetes
cluster
and
then,
of
course,
these
are
some.
This
resources
you
can
have
look
at
these.
There
are
dedicated
working
groups
today
for
webassembly.
You
can
join
those.
Of
course.
A
One
of
our
one
of
the
co-founders
of
second
state,
michael
luon,
had
also
given
a
talk
just
yesterday
for
the
cloud
native
awesome.
It's
so
if
you
are
also
in
like,
like
generally
interested
in
the
ecosystem
of
cloud
native
and
how
web
assembly
is
like
you
know,
interacting
with
it
yesterday,
there
was
the
co-located
event
for
the
cloud
native
awesome
day.
A
So,
of
course,
a
lot
of
the
activities,
especially
for
the
wasa
project,
are
going
on
inside
of
that
particular
conference
co-located
event
as
well.
But,
of
course
today
we
are
now
also
starting
to
see
a
lot
of
different
companies
using
different
types
of
communities.
Platforms
like
k3d
k3s,
to
also,
like
you
know,
start
using
wasa
meds
instead
of
their
workloads.
A
But,
of
course
what
I'd
like
to
conclude
is
that
web
assembly
is
the
future
for
serverless
and
for
edge
and,
like
you
know,
communities
is
a
very
great
way
to
be
able
to
actually
manage
these
applications
that,
if
you
have
a
webassembly-based
application
yeah,
if
you
have
any
other
questions,
feel
free
to
ask.
Otherwise.
Thank
you
so
much
for
attending
today's
talk.
C
C
C
A
Yeah,
so
that's
a
really
good
question.
First
of
all,
of
course,
right
we
have
seen
that
if
you're
running
arduino,
if
you
have
a
arduino
like
let's
say
you
have
a
that's
in
nano
right,
nvidia
just
nano,
so
those
are
completely
capable
of
running
like
let's
say
machine
learning
inference
and
we
usually
talk
about
how
machine
learning
on
edge
today
is
becoming
very
popular.
So
if
you're
talking
about
actually
running
these
highly
computational,
like
you
know,
competitions,
for
example,
with
machine
learning.
A
So
you'll
basically
have
your
rust
act
as
a
way
of
being
able
to
implement
all
the
highly
computational
functions,
and
this
will
run
inside
of
the
wasm
container
and
version
container
is
a
lot
more
smaller
as
compared
to
a
like
linux
based
container,
and
the
other
benefit
is
also
that
web
assembly
provides
a
lot
more
secure
environment.
It's
a
lot
more
secure.
A
So
essentially,
this
is
the
way
in
which
you'll
architect
your
program
to
run
on
a
very
less
resource.
Intensive,
like
a
hardware,
limited
system
like
let's
say
an
arduino,
so
you
can
deploy
your
was
image.
Instance
on
that
and
then
offload
all
of
your
different
high
combination
tasks
to
like,
let's
say
rust
and
then
run
them
so
yeah.
C
Maybe
I'll
come
up
with
another
one
then
do
you
have
any
recommended
platforms,
because
I
think
for
a
lot
of
us
we're
used
to
docker
at
this
point,
but
web
assembly
is
kind
of
new.
So
what
would
you
recommend
the
steps
be
if
I
just
want
to
play
around
with
it
on
my
laptop
or
something
or
would
you
recommend
using
a
pie
instead
or
how
would
you
go
about
that.
A
A
So
the
way
I
got
started
with
wasm
was
simply
just
first
of
all
understanding
how
wasm
actually
works
in
the
web,
because
that's
one
of
the
easiest
way
to
get
started
because
there's
a
lot
of
wide
developer
support,
special,
specifically
for
using
bosom
on
the
web
browser.
How
basically,
like
you
know,
you
are
converting
your
like,
let's
say
a
c
plus
function
into
a
wasm
executable.
D
A
Yeah
so
basically
I'll
recommend
two
things:
it's
of
course
the
standard
communities
itself
is
relatively
simple,
but
if
you
are
like,
let's
say,
if
you
want
to
run
a
lightweight
instance
of
communities,
you
can
look
at
k3d
and
g3s,
because
those
are
lighter
weight.
Like
you
know,
communities
instance
that
you
can
set
up
so
I'll
definitely
recommend
using
those.