►
From YouTube: Managing WebAssembly Applications Using Docker and k8s Tooling - Michael Yuan, Second State
Description
Don’t miss out! Join us at our next event: KubeCon + CloudNativeCon Europe 2022 in Valencia, Spain from May 17-20. 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.
Managing WebAssembly Applications Using Docker and k8s Tooling - Michael Yuan, Second State
WebAssembly is a high-performance, lightweight, polyglot, portable, and secure application runtime. It is ideally suited for many cloud-native use cases, such as service mesh, embedded APIs for SaaS, and serverless functions for edge networks. However, as Docker and k8s’ success in cloud-native infrastructure has shown, orchestration and management solutions are crucial for the adoption of application runtimes. In this presentation, Michael Yuan will use the CNCF sandbox project WasmEdge as an example to discuss how to integrate and use widely used cloud-native orchestration tools to manage WebAssembly workloads. Specific topics include the following. - WebAssembly use cases in cloud-native infrastructure - Use runw to add WebAssembly management capabilities in CRI-O - Use crunw to support WebAssembly in k8s - Support WebAssembly as a service mesh sidecar in Dapr and others - Standardization efforts around WebAssembly orchestration and management
A
A
A
Well,
so,
let's
dive
right
into
it.
What
we
are
talking
about
in
the
and
and
the
first
is
why
you
know
why
do
we
need
you
know
manage?
Why
do
we
need
to
manage
webassembly
in
kubernetes
tools?
And
this
is
a
a
picture
I
I
often
use
for
you
know
I
like
to
use
this.
I
didn't
draw
that
ibm,
open
risk
draw
it
and
they
talk
about
the
evolution
of
you,
know
cloud
or
server-side
technologies
right,
you
know.
So
it
comes
start
from
bare
metal,
and
I
you
know.
A
I
still
remember
the
days
when
data
centers
have
you
know
your
own
dedicated
servers.
You
know
you,
you
do
the
iris
scan
or
do
the
fingerprint
scan
go
there
and
you
can
actually
find
where
your
software
is
on
those
servers
that
provides.
You
know,
use
hardware
to
isolate
software
right.
It's
provide
the
level
of
abstraction
and
then
the
virtual
machine
come
along.
It
becomes
cloud
and
become
containers,
and
now
we
are
at
the
at
the
new
age
of
deploying
functions.
A
You
know
to
me,
I
think
you
know,
as
rob
had
said
and
liam
had
said
earlier.
You
know
you
know
earlier
today
that
this
represents
a
new
level
of
abstraction.
You
know
it's
the
abstraction,
the
the
separation
from
infrastructure
called
to
the
business
logic
code,
which
is
something
that
people
on
the
server
side
on
the
back
end
has
always
strived
to
right.
You
know,
so
I
I
think
to
have
to
have
the
infrastructure
completely
abstracted
away
and
for
developers
to
only
write
functions
is
one
of
the
major
step
forward.
A
So
I
think
this
is
you
know
one
of
them.
You
know
one
of
the
big
the
context
of
my
talk
right.
You
know
so
so
what
happened
this
this
mask
and
said
serverless?
Why
do
we
do
serverless?
Is
we
want
to
make
servers
great
again
right?
You
know
so
I
have
this
here
and
if
you
guys
want
it,
I
have
quite
a
few.
You
know.
So
it's
so
everyone
wants
to
go
and
get
it.
A
That's
so
we
want
to
do
serverless.
You
know.
The
reason
we
want
to
serve
less
is
to
is
to
make
server-side
programming
or
back-end
programming
easier.
However,
there
are
still
dark
cloud
on
the
horizon,
so
to
speak.
Is
that
to
say
you
know
people
say
you
know
today,
most
serverless
functions
of
or
functional
service
functions
are
implemented,
using
what
we
call
micro,
vm
or
darker
light
containers
right.
A
You
know,
so
you
are
essentially
running
the
the
function
inside
of
an
inside
application
container
and
just
to
think
about
the
work
you
have
to
go
through
to
run
a
function
say.
The
function
is
10
20
line
of
javascript
code,
you
have
to
start
backer
or
the
micro
vm
and
start
opening
system
unit,
start
node.js
and
run
10
lines
of
code
and
then
shut
it
all
down
right.
You
know:
that's
it's
not
a
very
effective
way
of
using
system
resources,
and
so
here
are
two
graphs.
A
You
know
again,
those
are
not
mine.
Those
are
you
know.
People
have
done
the
measurements.
You
know
when
datadog
presented
this
graph
to
say
half
of
lambda
functions
finish
less
than
800
milliseconds.
My
reaction
is
really
half
of
the
laminar
functions
took
more
than
800
milliseconds.
You
know,
that's,
it
seems
very
long.
You
know
it
seems
you
know
0.00
seconds,
you
know,
that's
if
you,
if
you
are
into
the
you
know,
jam
stack
application
paradigm.
You
know
that's
that
sort
of
thing.
A
You'd
think
you
know
each
webpage
would
have
10
20
different
microservices
on
the
back
end,
and
it's
like
you
know
if
each
one
of
them
take
us,
take
a
second,
it's
a
it's
a
very
long
time.
So,
even
with
what
we
call
mega
cloud
in
in
super
sized
data
centers,
we
are
still
you
know.
You
know
facing
the
problem
of
cold
start
and
things
like
that
and
that's
spells
problem
for
having
the
serverless
paradigm
available
everywhere.
A
In
you
know,
on
the
network's
edge
and
on
each
devices
you
know
so
even
in
today's
mega
data
center,
we
we
have
problems,
so
you
know
that's
so
we
want
to
we
want.
So
what
we
want
is
a
is
a
lighter
application
container
or
something
that
is,
that
is
significantly
smaller
and
faster
than
dark
than
docker,
like
application
containers
to
run
those
lightweight
functions,
so
we
don't
have
to
go
through
all
the
process
of
starting
docker
starting
operating
system
start
node.js
and
run
everything
right.
A
So
maybe
the
answer
is
webassembly.
You
know,
that's
that's
why
we
are
here.
That's
why
we
have
a
cloud
native.
Wasn't
it
right,
you
know:
could
web
assembly
become
a
container?
You
know
so
at
the
time
there's
there's
talk
on
the
internet
to
say
maybe
webassembly
gonna
be
replacing
docker
or
become
next
docker,
but
it's
probably
not
you
know,
because
web
assembly,
as
of
today
or
maybe
for
a
long
time,
wouldn't
provide
the
same
kind
of
developer
experience.
A
However,
what
we
think
is
more
likely
to
happen
is
to
have
web
assembly
running
side
by
side
with
docker,
so
you
would
have
a
for
lack
of
a
better
word,
a
service
mesh
or
something
like
that
right,
you
know,
that's
is
something
controlled
by
it's,
something
that
is
managed
by
the
kubernetes
or
you
know
some
other
framework,
and
it
can
start
darker
for
some
workload
and
it
can
start
a
web
assembly
for
some
other
workload.
It
depends
on
what
kind
of
workload
you
have
and
where
do
you
want
to
deploy
it?
A
So
this
is
the
main
focus
of
the
talk
is
to
use
web
assembly
as
a
container
use
web
assembly
itself
as
a
container,
but
not
to
replace
docker,
but
to
go
where
docker
cannot
go
or
darker
is
too
heavy
to
go
right.
So
so
I
want
to
tell
you
a
little
bit
about
what
you
know.
You
know.
That's
you
know
what
is
a
framework
or
what
is
a
tool.
You
know
this
is
a
shameless
plug
for
for
the
project
I'm
involved
in
you
know
it's
called
wasm
edge
right.
You
know,
that's
a
web.
A
It's
a
web
assembly
runtime
that
is
optimized
for
hyper.
You
know
cloud
native
applications
and
I
wanna
talk
a
little
bit
about
why
it
makes
watermage
such
a
good
fit
for
for
microservices
or
or
or
as
a
serverless
container.
So
one
of
the
one
of
the
key
features
it
has.
It
has
rlvm
ao
based
aot,
so
it's
one
of
the
fastest.
A
I
wouldn't
say
it's
the
fastest
because
you
know
there
are
different
workloads.
Different
vms
has
different
characteristics,
but
in
a
lot
of
benchmarks
we
come
up
top.
You
know,
so
it's
one
of
the
fastest
web
assembly
vms
on
the
market
with
aot
compilation,
and
we
do
custom
extensions
because
you
know
when
you
talk
about
things
like
you
want
to
run
it
as
a
microservice.
You
need
networking
capabilities
inside
the
inside
of
the
vm.
A
You
know
so,
but
javascript
supports
asynchronous,
as
we
already
experienced
from
node.js,
find
out
that
that
is,
you
know
appropriate
for
a
lot
of
use
cases
so
have
a
synchronous,
porting
and
have
things
like
you
know:
ai
inference
like
a
quad
to
tensorflow
and
to
have
database
connectors
and
things
of
that
nature,
and
one
of
the
other
things
that
we
put
a
lot
of
focus
on
is
to
provide
first-class
javascript
support.
You
know,
I
think
we
are
reaching
our
consensus
from
multiple
talks
today.
A
You
know
from
from
the
shopify
talk
and
the
you.
You
know
it's
that
we
want
to
compile
the
javascript
runtime
into
webassembly
and
then
run
javascript
inside
that
runtime
and
people
keep
asking
why
you
know.
Why
do
you
do
that?
Don't
you
know
this
isn't
javascript
already
runs
in
some
kind
of
runtime.
You
know
using
node.js
and
v8
design.
For
that.
Yes,
it
is,
you
can
run
in
v8,
but
the
v8
is
never
designed
as
a
container
right
v8.
A
A
By
the
way.
The
work
we
have
done
so
far
is
also
based
on
quickjs,
because
qks
is
easy
to
understand.
Javascript
implementation.
We
can
provide
ways
for
web
assembly
to
supplement
the
javascript,
meaning
that
we
could
have
javascript
apis
but
implemented
in
rust.
Right.
You
know,
so
you
so
in
your
javascript
application.
You
may
want
to
do
something
like
image
processing,
but
instead
of
you
know,
you
know
using
interpreted
javascript
to
process
the
image
you
could
have
a
rust
function
on
the
back
end,
to
provide
this
functionality
pretty
much
the
same
way.
A
You
use
c
plus
plus
functions
to
to
extend
v8
right,
so
you
know
so
so
we
so
once
image
provides
a
lot
of
your
you
know
those
javascript
support.
We
I'm
going
to
give
you
a
link
later
in
the
talk.
You
know
to
talk
about
those
and
then
there's
management
features,
which
is
the
the
focus
of
the
remainder
of
the
talk
is
that
we
made
wasm
edge,
oci
compliance,
runtime,
meaning
that
it
can
it's.
It
can
be
managed
by
systemd
and
the
c
group
fs.
A
You
know,
meaning
at
the
process
level.
You
can
allocate
resources
to
it
and
there
was
also
an
excellent
question
earlier.
You
know
today
is
to
do
we
have.
Finally,
you
know
more
finely
grained,
you
know
resource
allocation
for
web
assembly
runtime,
because
webassembly
long
time
are
lighter,
so
you
may
not
want
to
you
know
just
provide
you
know:
resources
as
a
process
level.
You
may
want
to
provide
resources
at
a
threat
level
right.
A
You
know
this
is
a
page
we
borrowed
from
the
blockchain
people,
which
is
what
they
call
gas
meters
right.
You
know,
that's,
essentially
you
give
each
web
assembly
up
code
or
instruction
a
gas
value
and
then
say:
when
you
start
this
vm,
I
would
allocate
say
a
million
gas
and
then
for
you
know,
then
it
computes
how
many
instructions
it
went
through
after
you
exhausted
all
the
gas
it
stops
right.
A
You
know
so
you
can
even
get
people
to
pay
you
based
on
gas,
they
can
pre-buy
those
gas
as
credits
and
then
you
know-
and
they
use
that
you
know
this.
We
have
this.
We
have
this
gas
support
built
into
our
our
c
api
go
api
and
the
rust
api.
I
believe
quantum
time
also
have
it.
You
know
it's.
If
you
look
into
the
rust
api,
they
actually
have
something
called.
A
I
forgot
the
name,
they
didn't
call
it
gas,
but
but
it's
a
very
similar
concept.
So
those
are
some
of
the
unique
features
that
what
I
what
I
would
say
that
made
what
midwasm
edge
you
know
appropriate
vm
for
cloud
native
applications
where
I
skip
the
use
cases,
so
we
can
go
right
to
how
you
know
how
we
do
that,
how
we
make
a
webassembly
workload,
run
side
by
side
with
docker
workload
in
kubernetes
cluster
right.
A
We
have
three
approaches
and
some
you
know
I
would
be
focus.
I
would
mostly
focus
on
number
one
because
this,
because
this
approach
that
we
took
the
the
other
two
approach
approaches
is,
is
one
that
you
have
heard
from
the
end
group.
They
have
a
webassembly
runtime
that
manages,
I
think,
the
last
time
they
told
me
it's
500
000
machines,
500
000
machines
in
their
data
center
right.
You
know
that's
and
they
use
container
dcm
and
then
there's
the
excellent
work.
A
A
It's
this
approach
is
actually
not
unique
to
us.
You
know
a
lot
of
people
have
done
it.
You
know
so.
There's
wrong
c,
which
is
a
goal-based
container.
Runtimes
code
means
wrong
container
and
then
there's
c
wrong.
It
means
c
based
run,
you
know
c
based
container
runtime
and
there's
wrong
e.
You
know
it's
a
sgx
based,
you
know
a
zero
knowledge
proof.
You
know
trusted
computing
environment
container
around
time
and
then
there's
cut
around
time.
A
There's
guys
are
there
surroundings
see,
you
know,
they're
sponsored
those
you
know
so
so
so
people
have,
you
know,
as
a
community
has
innovated
to
to
change
those
long
time,
buyers
to
change
those
runtimes
to
make
some
run
different
workloads
right.
You
know
so
so
some
of
them
application
containers,
some
of
them-
are
not
and
wrong
application
containers
in
different
places.
A
So
the
work
that
we
have
done
is
to
is
to
fork
serum
and
we,
you
know
and
we're
trying
to
merge
it
up
upstream,
but
but
still
in
the
process
of
that
right,
you
know
so
so
the
work
on
our
side
is
mostly
a
da
it's.
We
call
this
tool:
zero,
w
and
there's
a
github
link
there.
So
it's
it's
based
on
sera,
but
it's
it
has
some
logic
in
it
to
detect
whether
we
are
running
a
docker
container
or
we
are
running
a
web
assembly
image.
A
If
it's
a
web
assembly
image
it's
loads
or
just
use
the
oci
interface
to
to
load
the
web
assembly
image
and
then
run
it
right,
so
it's
zero
on
w
means
based
on
zero,
but
runs
webassembly
right.
You
know.
So
it's
like.
I
said
it.
Utilizes
the
the
the
crio
and
kubernetes
extends
extensible
architecture.
You
know
kubernetes
and
crio
are
both
set
up
to
allow
you
to
add
your
own
custom
runtimes.
A
So,
instead
of
using
serum,
we
replace
the
serum
binary
with
our
with
our
build
here
that
allows
you
know,
that's
because
this
this
is
the
dropping
serum
replacement,
it
runs
darker
containers,
just
like
crown
does,
and
this
also
runs
web
assembly.
So
it
allows
us
to
run
docker
and
web
assembly
side
by
side
in
the
same
in
the
same
cluster
environment,
and
then
up
from
that,
you
know
you
have
you
know
you
would
be
able
to.
You
know,
store
web,
wasn't
files
web
assembly
files
directly
in
docker
hub.
A
A
A
You
know
download
this
download
that
you
know
and
resolve
this
conflict,
and
that
so
you
know,
but
I
I
walk
through
the
the
main
steps
here
so
from
the
first
part
you
can
see
this
is
this
is
to
create
a
docker
image.
The
docker
image
has
no
operating
system.
It
just
has
a
web
assembly
file
that
is
the
oci
compliance
so
to
the
so
to
speak.
A
Oci
compliant
web
assembly
application,
that's
been
packaged
in
the
container
format
and
it
can
be
stored
and
pulled
from
the
docker
hub
right,
so
we
publish
to
to
to
docker
hub,
and
then
we
use
the
crio
command
line
tool.
It's
cri
cri
ctl,
and
we
can
pull
that
from
the
well
before
we
get
to
this
step.
We
have
already
replaced
the
serum
binary
in
the
cr
in
our
cio
installation,
with
our
build
of
the
serum
w
binary
right.
A
You
know
so
so
there's
a
slash
being
slash
zero
and
we
replace
that
binary
with
the
binary
that
we
have
built.
You
know
to
make
it
be
to
make
it
aware
of
the
different
type
of
you
know:
content
container
images
right,
so
we
can
just
do
things.
The
way
that
you
normally
would
do
with
stock
images.
You
can
pull
them
and
you
can
run
them.
You
can
create
a
part
and
they
can.
You
can
run
them
and
it
would
just
you
know,
start
the
container.
A
It
would
run
that
web
assembly
application
that
webassembly
application
happens
to
be
a
a
washi
application,
that
they
read
something
from
the
command
line
and
then
generate
some
output
print
out
through
the
command
line,
and
you
can
see
all
the
results
in
the
logs
right.
You
know
so
so
that's
that's
a
easy
way
to
test
it
right.
You
know,
so
that's
with
that
modification
for
the
sierra
you
can.
You
can
try
it
with
docker
images
and
you
can
try
to
use
web
assembly
images
and
both
of
them
work
right.
A
So
now
we
go
to
the
next
step
we
want
to
build.
You
know
we
want
to
use
this
modified
cio
to
build
a
kubernetes
cluster.
However,
in
order
to
do
that,
we
need
a
webassembly
application
that
is
long
running,
meaning
that
we
need
a
webassembly
application.
That's
in
itself
act
as
a
microservice,
there's
no
docker
around
it,
there's
no
docker
or
another
host
application
around
it
that
web
assembly
application.
When
you
start
it
should
listen
to
the
network
and
respond
to
the
network.
A
That
requires
us
to
support
the
wazzy
socket
specification
and
the
wazi
socket
specification.
As
I
understand
it
has
been
fairly
slow.
So
you
know,
different
teams
have
come
up
with
different
ways
to
do
it.
You
know,
that's
that's
what
we
did
as
well,
that's
gross
out
of
necessity!
That's
because
we
because
we
need
to
have
this
run
in
the
kubernetes
environment.
So
we
we
we,
we
must
have
a
you
know,
a
micro
service
that
can
listen
to
the
http
network,
so
we
have
so
I'm
going
to
demonstrate
two
ways
to
do
that.
A
The
first
is
just
to
use
to
use
our
rust
api
and
because
this
is
not
a
w3c
standard,
so
it's
so
we
can't
just
you
know,
use
the
standard
rust
api
to
create
network
connection
or
socket.
Yet
we
have
to,
as
you
can
see,
we
have
to
import
wasn't
edge
while
the
socket
for
the
tcp
listeners
and
tcp
stream-
and
you
know
things
of
that
nature,
but
once
you
have
it,
the
the
the
main
application
becomes
fairly
simple.
You
know
you,
this
looks
just
like
you
know.
A
A
The
screenshot
is
the
entire
application.
You
know
this
entire
app.
You
can
just
have
this
much
code
right,
you
know.
So
if
you
look
at
the
the
handle
client
it
basically,
you
know,
gets
the
input
http
and
the
pass
out.
You
know
decode
it
and
pass
out
different
elements
from
it,
and
then
it
generates
a
response,
and
this
response
is
basically
just
to
echo
back
the
the
body
right.
You
know.
A
So
if
the
the
post
request
has
a
body
and
then
you
know
from
the
command
lines
which,
from
the
command
line
that
you're
on
the
server
you
don't
just
echo
back
to
combat,
it
would
just
just
it'll
just
echo
the
back.
So
that's
a
very
simple
rust,
rust-based
http,
http
server
that
runs
inside
wasmage
and
that
allows
we
that
allows
us
to
have
a
long-running
was
image
instance
that
can
be
managed
by
kubernetes
can
be
started
by
our
modified
version
of
zero
right,
zero
w
and
then
the
second
way
to
do
that.
A
A
Like
I
just
said
we
can
use
rust
to
implement
javascript
apis,
so
meaning
that
we
can
define
a
javascript
api
that
is
available
to
javascript
developers.
But
when,
when
the
javascript
program
calls
it,
it
actually
causes
underlying
rust
program
to
execute
it
and
all
inside
was
a
match
right.
You
know
so,
taking
that
you
know
rust-based
sdk,
we
can
make
it
into
a
javascript
api
called
http
server.
A
So
this
so
all
the
all
the
raster
code
becomes
this
couple
lines
of
javascript
code,
and
so
it's
just
a
starter,
http
server,
and
then
you
know,
and
for
the
sake
of
simplicity,
I'm
I'm
I'm
showing
it
as
a
as
a
blocking
example
right.
You
know,
so
it's
just
the
infinite
loop.
It
keeps
getting
the
request
and
once
you
get
the
request,
it's
spread
out
the
body
and
the
it's
in
yeah.
A
So,
but
I
also
said:
there's
there's
another
there's
another
work
that
we
did
with
wazi
is
to
support
asynchronous
supporting.
So
we
can
do
that
in
a
way.
That
is
asynchronous
both
using
javascript,
async
or
using
rust
futures,
so
both
of
those
are
supported
as
well,
but
you
know
here
we
are,
we
are,
you
know,
shooting
a
very
simple
javascript
example.
That's
only
I
would
say
less
than
10
likes
of
code,
20
lines
and
10
lines
of
code.
You
know
that's
and
it's.
It
starts
a
container.
A
As
you
know,
it's
this
experience
goes
very
similar
to
it
strongly
reminds
me
of
the
old
days
of
java
right,
you
know,
that's
when
you
have
a
jvm,
you
use
jvm
to
do
application
server.
You
do
exactly
this
right,
you
know
that's,
but
you
know,
that's
well
you.
You
know.
I
think
this
is
what
enterprise
software
demands.
You
know
that's,
so
we
are
we're
evolving
toward
that
stage
at
the
web
assembly
as
well.
So.
A
So
on
kubernetes,
once
we
have
the
crio
set
up
and
the
the
c
run
in
crl
setup
and
also
the
the
web
watson,
edge-based
micro
services,
that's
the
long-running
setup.
We
can
now
set
up
kubernetes
and
it's
a
it
becomes
really
simple.
You
know
you
just
in
a
standard,
kubernetes
setup.
You
can
pass
the
argument
set
container
runtime
right,
you
put
container
runtime
as
a
remote
and
then
put
it
in
pointing
to
cio
or
in
minicube.
A
Okay.
So
there
are
a
couple
of
real
world
use
cases,
and
you
know,
because
I
spent
a
lot
of
time
in
asia.
You
know
that's
most
of
the
use.
Cases
are
actually
from
from.
You
know:
internet
providers
in
from
internet
providers
in
china.
So
you
know
they
are
leveraging,
like
cdn
network
to
do
distributed
computing.
So,
for
instance,
you
know
there's
there
are
distributed
cdn
networks
where
they
put,
you
know
those
setup
boxes
into
people's
homes,
and
then
they
did
pre-distribute
tonight's
movies
onto
those
onto
those
boxes.
A
And
then
you
know,
because
for
each
neighborhood
you
know
the
movies
you're
gonna
watch
are
probably
just
that
three
or
four
you
know
that's
so
so
so
they
would
predict
that
and
put
that
all
that
and
put
that
on
the
box
right,
you
know
and
from
those
boxes
they
can,
they
can
act
as
a
distributed
cdn
and
serve
a
lot
of
clients,
but
that
box
essentially
only
has
a
has
a
cell
phone
chip
in
it.
It's
it
has
a
arm7
chip
in
it.
A
So
so
before
weber,
simulator
used
to
run
docker
on
it
and
this
this
device
can
run
for
dockers
and
they
serve
four
big
big
enterprise
customers.
You
know
something
of
something
of
land
land
nature
right,
so
now
they
can
with
web
assembly
they
can
run
a
lot
more.
So
so
you
know
so
there
are
cd
and
network
testing
and
there's
you
know
there
are
other.
You
know
cloud
providers
that
does
sidecar
runtime.
You
know
that's
managed
by
kubernetes
and
doing
service
mesh
using
using
the
works
that
we
have
done
so
well.
A
So
then
the
first
approach
is
our
approach
right
and
then
the
second
approach
really
is
runwas
maps
as
container
dcms.
That's
what
one
of
the
previous
talk
has
you
know
has
talked
about
right.
You
know,
there's
you
know
that's
ali
and
and
and
financial
stuff,
so
I'll
skip
over
that
and
then
the
third
approach,
which
I
thought
also
was
very
very
interesting,
is
the
crossland
approach.
Obviously
we
have
experts
here.
You
know
people
who
have
developed
that
you
know.
So
I
wouldn't
assume
ignorance.
You
know
that's.
A
So
if
you
have
questions
about
crossland
you
go,
you
can
ask
the
experts
so
beyond
kubernetes,
you
know
that's,
so
we
now
have
a
way
to
run
what
I
would
say
wasn't
workload
in
a
docker-like
fashion
in
a
kubernetes-like
cluster.
You
know
that's
so
beyond
the
regular
kubernetes.
What
are
the
other
use
cases?
There
are.
A
Obviously,
there
are
quite
a
few
kubernetes
variations
for
edge
computing
and
I
think
the
all
three,
the
there's
four,
the
top
three
are
owning
cncfs
today
you
know
those
are
all
what
they
call
kubernetes
for
the
edge
right,
cube,
edge,
super
edge
opening
up,
and
you
know,
and
then
there's
coop
sphere,
which
is
a
private
cloud,
kubernetes
deployment
and
they
they're
integrating
with
data
microsoft
dapper
and
they
are
also
you
know,
having
their
own
function
as
a
service.
You
know
so
there's
lots
of
innovations
around
this
area.
A
You
know,
that's
that's
that
that
goes
slightly
out
of
the
regular
kubernetes,
but
still
use
the
same
oci
infrastructure.
So
that's
one
of
the
areas
that
that
we
thought
our
approach
could
be
really
interesting,
because
that's
because
underneath
of
them,
they
all
use
cira
or
wrong
c.
You
know
now
we
change
that
to
zero
w
and
then,
of
course
there
are,
you
know
a
service
mesh
in
service
mesh.
There
are
two
strong
use
cases.
One
is
just
to
use
the
web
assembly
runtime
of
the
web
assembly
application
as
a
site
application.
A
You
know,
so
the
web
assembly
provides
micro
services
itself
right.
You
know
so
we
have
examples
that
we
have
done
with
with
dapper.
You
know
that's
you
know,
there's
a
there's
case
study
published
that
on
on
info
cue,
and
you
can
look
at
that
and
you
know
there's
multiple
ways
to
do
it:
how
to
integrate
that
into
the
side.
Car
right,
you
know,
that's.
A
A
You
know
natively
managed
by
coordinators,
like
linker
d
right,
you
know,
those
are
the
things
that
we
are.
You
know
we
are
very
actively
looking
at
try
to
integrate
yeah
then
on
service
mesh,
there's
other
side
of
the
story
which
is
which
is
a
the
the
traffic
proxy.
You
know
so
in
the
service
mesh
you
have
you
have
those
side
cars,
but
then
you
have
proxies
to
direct
traffic
to
the
side.
Cars
right
and
there
is
a
growing
trend.
A
I
think
start
from
one
way
is
to
have
is
to
make
a
web
assembly
into
a
scripting
language
for
the
for
the
proxy
replacing
lua
right.
You
know,
that's
so
onware
has
a
standard,
it's
called
you
know
proxy
awesome
and
then
it's
being
adopted
by
you
know
a
bunch
of
other
guys.
So
so
this
is
also
a
very
interesting
area
that
that
that
we
find
you
know,
that's
it's
a
it's
not
directly
related
kubernetes,
but
it's
tangentially
related
right.
A
Then,
of
course
you
know.
As
early
as
speakers
has
also
spoke
to
you
know,
there's
there's
also
a
growing
need
to
run
webassembly
directly
on
devices.
That's
you
know.
That's
where
web
assembly
become
really
interesting
because
there's
different
implementation
web
assemblies,
they
all
have
different
characteristics.
Some
of
them
are
really
small.
That's
like
the
earlier
talk
talking
about
running
web
assembly
on
camera
right,
you
know,
but
for
larger
systems,
that's
increasingly
popular,
for
instance
autonomous
cars
or
smart
factories.
A
That's
they
all
have
not
regular
linux,
but
real-time
linux
operating
systems,
and
they
all
need
containers.
I
think
wind
river.
You
know
the
vx
works
guys
published
something
called
vxworks
containers.
I
think
a
couple
months
ago
and
they
were
talking
about
using
container
technology
in
fighter
jets
right.
I
have
seen
toyota
using
containers
in
their
using
docker
containers
in
their
next
generation.
Cars
just
think
about
it
using
darker
in
cars.
You
know
that's
the
docker
controlling
something
as
vital
as
autonomous
driving
right.
You
know.
That's
you
know.
A
In
my
opinion,
this
is
a.
This
is
a
it's
not
a
good
fit.
You
know,
there's
much
better
fit,
which
is
you
know,
that's
to
have
a
to
have
a
much
more
abstract
and
and
lighter
runtime,
the
based
on
web
assembly,
so
so
so
on
that
ground
we
we
work
with
a
project
also
linux
foundation,
project
called
cell
4,
and
that's
that's
a
formally
verified,
real-time
micro
kernel
system
and
it's
I
think
it's
been
adopted
by
quite
a
few.
A
You
know
autonomous
driving
companies-
and
you
know,
electric
car
companies
cell
phone
is
based
in
australia,
and
you
know
its
users.
Almost
a
lot
of
them
are
in
asia
and
the
u.s
military
as
well.
They
have
to
put
it
on
the
on
on
the
drones,
and
you
know
things
like
that.
So
you
know
so
that
is
another
potential.
You,
okay,
okay,
this.
B
A
Another
this
is
another
use
case.
You
know,
that's
so
so
not
directly
related
to
kubernetes,
but
that's
also
something
when
you
run
it
in
in
a
real-time
operating
system.
You
also
need
orchestration
solution
and
is
kubernetes
going
to
be
or
a
modified
version
of
kubernetes
or
something
else
would
be
part
of
the
would
be
part
of
the
solution.
It's
also
something
that's
that
that
we
are
very
interested
in
exploring
yeah.
So
then
I
think
I
pretty
much
covered
that
you
know.
That's
then
there's
data-driven
orchestration.
A
You
know,
meaning
that
you
know
we
are
not
thinking
about
computer
instances,
but
thinking
about
a
flow
of
data.
You
know
when
data
comes
in.
We
want
to
react
to
it.
You
know,
like
conor
just
said
right,
you
do
a
create
a
reactive
framework
and
then
you
know
and
and
then
web
assembly
becomes
becomes
a
reactor
or
becomes
a
reactive
function
in
that
framework.
Maybe
that's
the
way
you
know.
A
C
A
Yeah,
the
upstream
is
zero,
so
we
want
to
merge
back
to
to
to
zero.
However,
as
you
might
imagine,
it
needs
convincing
right.
You
know,
because
you
know
we
need
to
tell
that.
We
need
to
tell
the
crm
developers
why
you
need
to
support
web
assembly
right
so
and
we
are
trying
to
talk
to
them.
Try
to
you
know,
that's
why
we
come
to
meetings
like
this
right.
You
know
try
to
try
to
get
consensus.
B
We're
gonna
go
ahead
and
have
oscar
come
up,
but
while
we
do
that,
go
so
oscar
go
ahead.
While
we
do
that,
while
we're
here,
let's
ask
one
or
two
more
questions
on
the
virtual
stream.
You
may
get
cut
off,
I'm
not
really
sure,
but
so
there
was
another
question
over
here.
Yeah,
I'm
curious:
what
is
the
approach
that
a.
A
Right,
so
the
question
is:
how
would
the
developer
take
advantage
of
the
custom
extensions
that
we
break
into
watson
edge?
So
for
all
the
extensions
that
we
have,
we
must
first
have
a
rust
sdk.
Then
we
we
attempt
to
have
a
javascript
sdk
as
well,
so
for
developers
you
know
that's
in
a
way:
it
breaks
the
compa
compatibility
with
rust
with
webassembly,
because
you
know
once
they
use
our
roster
sdk
to
to
build
application
and
compile
into
rust.