►
From YouTube: Build, Share, Run WebAssembly Apps Using the Docker Toolchain - Chris Crone & Michael Yuan
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe 2023 in Amsterdam, The Netherlands from April 17-21. 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.
Build, Share, Run WebAssembly Apps Using the Docker Toolchain - Chris Crone, Docker & Michael Yuan, Second State
WebAssembly has emerged as a secure, portable, lightweight, and high performance runtime sandbox for certain types of workloads that make up cloud native apps. Chris and Michael will show how familiar Docker commands can be used to develop and share Wasm applications. Today, developers need to learn new & complicated tooling for Wasm apps. By having Docker manage the Wasm runtime, existing container tooling that Cloud Native developers are familiar with can be used, and the dev ex is fast & efficient. Docker can use WasmEdge as a security sandbox, side by side with Linux containers on the same dev machine or in a deployment cluster. They will cover how to create WebAssembly OCI images using buildx, how to publish the annotated image to Docker Hub, and how the enhanced Docker engine can distinguish the image and automatically run it with WasmEdge. They will demonstrate a complete demo of creating and running a Wasm-based microservice application using these Docker tools. We see this as a first step towards making Wasm as easy a target for developers as their existing platforms.
A
A
So
I'll
start
by
introducing
myself
and
then
head
over
to
Michael
I'm
Chris
krona,
I'm,
a
director
of
engineering
at
Docker
in
the
content
group,
we're
responsible
for
some
of
the
low-level
pieces
like
runtime,
build
and
registry,
as
well
as
content,
you'll
know
of
things
like
Docker,
official
images,
Docker
verified
Publishers
and
some
of
the
newer
things
we've
been
doing
at
Docker,
which
include
desktop
extensions
and
atomist
Michael.
Okay,.
B
A
A
The
the
first
case
is
facilitating
reuse,
and
we
heard
a
lot
of
this
earlier
about
the
component
model.
When
you,
when
you
build
well-defined
interfaces,
you
can
create
these
boxes
of
value
and
reuse
them,
and
that's
not
just
for
yourself
inside
your
own
company
or
just
you
know,
on
your
own
projects,
but
you
can
then
share
them
with
other
people
and
that's
a
really
valuable
thing.
It
has
this
compounding
effect
of
not
rebuilding
everything.
A
The
second
one
is
about
sharing
compute
resources.
So
by
isolating
your
workload,
you
can
share
compute
resources
in
different
ways.
This
starts
with
you
know
my
dad
was
an
engineer
as
well,
and
he
he
would
use
punched
cards
and
the
scheduling
mechanism
was
literally
a
piece
of
paper.
You
write
your
name
on
the
list
and
you
get
a
slot
of
time
and
you
get
to
go
and
run
your
Punch
Cards.
A
That
theme
in
Computing
of
we
want
to
use
the
maximum
we
can
of
a
shared
resource
which
is
compute,
has
continued,
except
the
boundaries
have
changed
a
little
bit
right.
So
we
wanted
to
find
good
boundaries
because
we,
we
might
not
necessarily
trust
the
people
we're
running
code
next
to
we
might
not
trust
our
own
code
not
to
pull
down
somebody
else's
workload
as
well.
A
Like
that's
another
case
where
we
want
to
have
these
well-defined
boundaries,
so
you
want
to
be
able
to
say
what
what
are
the
capabilities
of
what
I'm
running?
Can
it
hurt
other
workloads?
Can
other
workloads
hurt
me?
How
do
we?
How
do
we
make
sure
that
that
the
code
doesn't
interfere
with
other
code
running
and
and
then
ease
of
delivery
of
applications?
I
think
this
is
another
thing.
That's
really
made.
Software
unique
in
in
its
velocity
is
the
speed
with
which
we
can
deliver
value
to
customers.
A
If
you
know,
if
you
have
a
well-defined
box
like
a
shipping
container
or
a
container
a
software
container,
you
can
build
infrastructure
that
allows
you
to
deliver
much
much
more
quickly
and
that's
a
really
really
powerful
thing
that
isolation
and
separation
enables
so
taking
a
look
at
some
of
the
isolation
techniques
that
we
have
in
in
our
domain.
We
have
kind
of
a
spectrum
and
there's
lots
of
different
ways
of
doing
this.
So
one
example
on
the
extreme
side
is
air
gapped.
A
This
is
where
you
literally,
don't
trust
anybody
outside
of
your
compute
space,
and
you
make
the
compromise
on
that
ease
of
delivery
by
literally
having
to
physically
be
next
to
the
machine
and
to
deploy
it,
but
that
comes
with
a
bunch
of
security
guarantees.
Hardware
virtualization.
This
is
kind
of
the
thing
that
kicked
off
cloud
computing
right.
You
no
longer
need
it
to
plug
a
computer
in
or
have
access
to
a
data
sensor.
You
could
use
an
API
I
mean
this
is
crazy.
A
If
you
think
about
it,
you
could
you
could
literally
call
an
API
and
create
a
an
instance
of
compute.
Then
you
know
we're
at
Western
day
I
have
to
bring
up
stack
virtualization
when
you
control
the
runtime
in
the
language.
You
can
start
looking
at
what
kind
of
guarantees.
What
kind
of
how
can
we
cut
this
up?
What
what
boundaries
can
we
create?
What
interfaces
can
we
create
to
to
give
us
these
these
these
this
isolation
in
in
various
different
forms
to
to
improve
the
software
delivery
containers?
A
Of
course,
I
work
at
Docker
I
have
to
bring
up
containers
at
some
point.
Containers
are
interesting
because
they
leverage
the
same
kernel,
but
they
isolate
the
processes
from
each
other,
so
they
can't
see
file
system
that
lets
you.
Let
them
you.
They
can't
see
each
other
unless
you
let
them.
This
also
gives
you
some
of
those
guarantees
of
my
workload,
won't
bring
down
somebody
else's
workload.
A
You
can
set
up
limits
in
terms
of
memory
and
things
like
that
to
ensure
that
and
then
raw
processes,
we
kind
of
defer
to
the
OS
to
say
you
handle
the
boundaries
between
things
by
default.
A
lot
of
the
time
that
is,
it's
open
bar
on
the
file
system
within
that
user's
space,
Mac
OS,
for
example,
it
started
locking
the
standard
bits
if
you
touch
sensitive
things,
they'll
prompt
the
user
for
for
permission.
But
that's
you
know.
A
This
is
another
box
where
you
can
ship
a
raw
process
and
you
have
access
to
lots
of
things
and
then
kind
of.
Finally,
on
the
extreme
end,
you
have
Dynamic
libraries,
which
have
you
know,
well-defined
interfaces.
You
can
get
a
header
file,
for
example,
which
tells
you
exactly
what
inputs
you
put
in
what
outputs
you
get
out
and
you
can
share
memory
inside
the
process,
so
you
can
get
really
high
performance
So.
A
That
obviously
brings
up
the
question
well,
which
which
isolation
mechanism
which
of
these
tools
should
I
use
and
I,
get
to
pull
out
the
Simpsons
Meme
here
it
really,
it
really
just
depends
and
it's
kind
of
hard
when
I
started.
This
talk,
I
thought
I
could
throw
up
something
like
this
and
I
have
to
quickly
push
it
down
arrow
before
you
try
to
take
a
photo
of
that
I
thought.
I
could
put
up
three
three
dimensions
and
say
you
know
if
you
care
about
isolation.
Use
this.
A
A
B
All
right,
thank
you,
Chris,
so
when
to
use
water,
and
we
are
quickly
go
through
those.
Those
points
of
course
running
something
in
the
browser.
That's
original
use
case
right
if
you're,
building
application
from
source
and
output
bottom.
That
startup
is,
you
know,
prerequisite
right.
You
know
you
have
you
have
to
have
a
language
that
can
output
bottom.
You
know
if
you
don't
like
in
python
or
JavaScript,
you
have
to
have
a
wrong
time,
that
embedded
in
waso
and
what
I
find
most
interesting
is
something
that
need
a
quick
startup
time.
B
So
you
know
that's
the
serverless
use
case.
You
know
where
you
know.
If
you
look
at
AWS
Lambda,
you
know
one
of
the
biggest
complaints
that
the
the
codes
are
too
slow.
So
how
do
you
deal
with
that?
You
can
have
warming
up
instance
right.
You
know,
however,
with
awesome
like
we
have
seen
inferior
Spain.
You
know
that
you
can
just
spin
up
as
a
requests
come
in.
B
You
know
so
you
do
don't
need
warm
up,
and
even
if
in
cases
where
we're
going
to
talk
about
in
a
minute
where
you
do
have
long
lived
servers,
you
know
like
a
CRM.
You
know
something
like
that.
One
takes
a
lot
less
space
than
say
you
know
a
container
plus
Linux
kernel
and
all
that
right,
you
know
so
for
shortly.
You
know
so
for
something
I
need
startup
time,
whether
it's
start
on
demand
or
it's
a
web
lab
instance.
B
While
both
offers
significant
advantages
and
then
there's
we
have
seen
from
early
talks
about
component
model,
you
know
there's
a
lot
of
security
considerations,
that's
especially
relevant
today,
with,
with
all
the
you
know,
supply
chain
software
supply
chain
security
issues
and
require
a
small
incremental
overhead.
You
know
decide
wasn't,
can
run
in
a
much
smaller
package
than
anything
and
then
most
discount
creditors
and
when
not
use
wasm.
Of
course
you
know
application
requirement
is
trading.
B
However,
there's
you
know,
as
we
have
also
seen
there's,
you
know
threading
proposals
in
in
webassembly
already
and
it
was
managed.
We
were
already
we
already
implemented
that
you
know
that's.
You
know,
but
currently
this
is
one
of
the
limitations,
but
I
also
want
to
point
out
that
if
you
look
at
common
server-side
languages
like
JavaScript,
it's
also
single
threaded.
It's
just
another
task
and
a
single
thread
right.
B
You
know,
and
the
second
is
a
garbage
languages
at
this
moment
you
know:
I'm
I'm,
pleasantly
surprised
to
see
fermian's
presentation
that
you
know
Java
actually
runs
and
there's
a
way
to
get
around
in
DC.
You
know
because
the
short-lived
application-
you
don't
need
this
in
and
I
thought.
That
was
you
know
very
interesting
and
then
the
the
third
time.
B
The
third
thing
is
that
you
know
that's
what
to
borrow
all
the
industry
term
is
that
is
it's
opinionated
setup
you
know
so
awesome
is
that
it
needs
something
that
you
have
to
develop.
Based
on.
You
know
its
ideas,
you
know
so
very
much,
unlike
you
know,
on
the
docker,
that's
you
know
that
has
been
popular
for
a
very
long
time.
You
know
you
can't
just
take
a
Linux
application
and
Iran
wants
them.
B
So
you
have
to
you
know,
use
a
different
set
of
tools
that
also
give
rise
to
the
need
for
developer
tools.
So
you
know
I
want
to
give
you
a
quick
demo.
You
know
that's
to
show
you
some
of
the
things
that
we
have
done
in
the
developer
tuning
area,
so
the
application
I
want
to
show.
You
is
a
microservice.
You
know.
So
if
you
look
at
so
it's
written
in
Rust,
if
you
look
at
this
code,
you
know
it's
a
it's
a
Tokyo
application,
it's
a
normally.
B
It
will
not
compile
to
awesome
or
you
know
it
will
not
run
or
wasn't.
But
I'll
tell
you
in
a
minute
how
we
did
it
so
make
it
run
on
Watson.
You
know.
So
it's
a
Tokyo
application.
Let's
start
up
a
web
server,
the
lessons
at
port
8080.
So
it's
a
it's
using
the
standard,
Tokyo
Mio
and
Hyper
library
in
Rust
and
what
it
does
is
that
when
request
comes
in
it
asynchronously
start
a
Handler
method
called
classify.
You
know
what
it
does
is
that
does
AI
inference.
B
It
calls
a
tensorflow
model
to
look
at
the
input
image
and
then
generate
the
output
right.
You
know
so
it's
it's
it's
what
I
just
said.
It's
a
single
shredded
automatic
tasking.
You
know
it's
utilize.
The
non-blocking
io
that's
available
in
a
in
a
in
a
system.
So
it's
so
you
know
it's.
While
the
data
comes
in,
it
doesn't
have
to
wait
it
can.
It
can
handle
the
next
request
and
the
classify
method
is
not
difficult
either.
If
you
have
familiar
with
machine
learning
or
AI
inference
on
python,
you'll
find
it's.
B
You
know
it's
it's
very
easy
to
follow,
even
in
a
raster
language.
So
what
it
does
is
that
it
has
a
request
body.
So
you
know
because
it's
Handler
method,
so
it
gives
you
the
HTTP
body,
and
then
you
know
you
are
supposed
to
return
the
HTTP
response
right
and
so
in
in
the
messages
first
loads.
The
tensorflow
model,
which
is
the
mobile
analysis,
image
classification
model,
and
then
it
gets
the
image
from
the
from
here.
It's
a
post
classifier.
B
It
gets
the
image
itself
from
the
HTTP
body
and
then
transform
that
into
a
tensor
and
then
runs
the
tensor
model
through
the
through
the
tensorflow
runtime,
which
gets
back
another
tensor.
That
tensor
is
a
list
of
probabilities
of
different
image
labels
of
their
probability
in
the
in
a
file.
Then
you
look
up
your
English
names
for
that
label
and
then
print
it
out.
You
know,
so
that's
all
there
to
it.
B
You
know:
that's
that's
the
entire
microservice
that
does
you
know
AI
inference
on
you
could
do
that
on
a
very
small
device.
So,
let's,
let's
see
the
action
so
I'm
going
to
do
live
demo
here
you
know
so
you
know
so
to
see
if
it
works.
Although
I
did
a
lot,
you
know
and
cheat
a
little
so
that
you
know
I
cache
the
the
cargo
build
from
last
time.
So,
if
I
do
the
cargo
build,
you
know,
I
can
build
this
yeah.
B
You
know
so,
but
because
there's
because
it's
everything's
up
to
date
right
so
I
can
build
this
rust
application
into
awesome
and
then
I
use
the
Wasatch
runtime.
You
know.
What's
the
major
runtime
supports
the
whole
wasi-earned
standards,
you
know,
so
it
does
tensorflow
high
torch,
open,
Rhino
and
all
that.
So,
if
I,
if
I
run
this,
what
it
does
is
that
it
lessens
on
the
port
8080,
you
know:
that's,
it
starts
the
server
inside
water.
B
It's
not
it's,
not
a
host
function
that
that
embeds
one
but
inside
volume
is
a
starter
server
and
then
on
this
side
under
the
terminal,
I
encourage
the
server
I
can
send
it
a
picture,
send
the
picture
and
it
would
return
immediately
because
this
is
the
native
you
know
in
tensorflow.
So
what
it
says
is
the
pictures
there's
a
high
confidence
that
the
picture
contains
a
military
uniform.
So
what
is
that
picture?
You
know.
So
that's
the
picture.
If
someone
is
something
that
everybody
has
seen
in
the
past,
you
know
it's.
B
B
So,
just
to
summarize,
you
know
what
is
water
match?
What's
the
message
is
awesome
runtime
in
cncf,
it's
it's
com,
it's
compliant
with
all
the
I
say
published
was
on
standards
and
it's
also
a
strive
to
implement
a
lot
of
those.
You
know
standards
in
the
pipeline
and
we
very
much
would
be
loved
to
be
part
of
the
component.
B
You
know
model
process,
you
know
to
be
to
be
one
of
the
implementers
in
in
our
space,
and
so
while
we
conform
to
all
the
awesome
standard
and
I
think
one
of
the
interesting
that
we
we
do
is
that
we
are
llvm
based
aot.
You
know,
so
that's
that's!
That
gives
us
you
know
and
there's
a
lot
of
benchmarks
that
give
us
a
near
native
performance
with
you
know.
B
You
know,
between
the
one,
bytecode
and
and
and
and
Native
application
compared
from
rust,
and
we
support
our
wide
variety
of
os,
including
non-posite
OSS,
like
like
cell
four.
You
know
that's
it's
a
real-time
operating
system,
widely
used
in
drones
and
in
almost
autonomous
vehicles,
and
it
supports
popular
CPU
architectures,
like
you
know,
like
Risk,
five
right,
you
know
so
and
then
we
are.
You
know
our
use
case
where
I
specially
optimized
for
the
cloud
and
Edge.
So
like
you
have
seen
you
know
we
have
done.
B
That
has
you
know,
Network
capabilities
like
Tokyo
right,
let's,
let's
open
store
for
connecting
microservices
databases,
you
know
and
other
web
services,
and
we
also
have
a
driver
for
Kafka
queues,
and
you
know
things
like
that.
It
works
well
with
service
Frameworks
like
diver
SDK,
which
I'm
going
to
talk
about
tomorrow
in
dappercon,
and
it
has
native
support
for
AI
inference.
B
So
if
the,
if
the
underlying
tensorflow
or
Pi
torch
model
runs
on
GPU
or
TPU,
the
bottom
runtime
will
be
able
to
take
advantage
of
that
as
well,
and
it
has
first
class
support
for
JavaScript.
You
know
so
we
are
striving
to
be
a
full
node.js
compatibility
within
this
quarter.
You
know
so
we
have
you
know
we
have
several
developers
that
implementing
the
entire
node.js
apis,
you
know
our
JavaScript,
so
I
think
that's
yeah.
A
Thank
you
Michael,
so,
looking
at
the
developer
tooling
for
Western,
it
was
brought
up
in
one
of
the
talks
earlier
today.
It's
not
that
easy
to
get
things
set
up.
Rust
and
golang
have
made
things
a
lot
easier
to
do.
Things
like
cross
compiles
I
come
from
a
c
plus
era
where
it
was
much
darker
and
much
more
difficult
than
with
those
tools,
but
you
still
have
a
lot
of
those
same
problems
of
I'm
running
rust
version.
A
This
you're
running
rust
version
of
that
the
CI
is
running
some
other
rust
version
and
and
then
there's
all
the
other
tooling.
You
may
have
different
runtime,
like
Western
Edge
setup.
You
may
have
testing
tools
or
other
other
things
that
you're
using
and
what
that
lands
up.
Meaning
is
you
you
run
into
that
same
problem
of
well.
It
works
on
my
machine
I.
A
Don't
know
why
it's
not
working
on
yours
or
on
CI,
which,
as
a
developer,
really
hurts
me
I
hate
that
it
also
requires
learning
a
lot
of
new
tools
and
new
flows
and
I.
Think,
especially,
people
like
you
who
are
on
the
Leading
Edge
of
Technologies
you're
kind
of
used
to
playing
in
the
tooling
space,
and
this
is
okay
for
you,
but
for
developers
who
are
you
know
nine
to
five
developers
working
in
companies.
This
is
really
really
painful.
A
A
So
we
talk
about
the
magic
of
Docker
and
I.
Think
there
are
two
core
Magics.
The
first
one
is
what
works
in
my
machine
works
on
yours
and
then
in
production.
If
you
use
the
way
that
I
use
Docker
now,
I
have
many
fewer
instances
where
I
have
to
do
web
commits
against
the
CI,
because
if
I
have
a
dockerized
flow
that
I
run
locally
and
then
on
the
CI
I'm
sure
it's
going
to
run
the
same,
that
magic
is,
is
really
really
profound.
A
The
second
one
is
I,
can
build
things
and
then
share
them,
and
you
can
build
on
top
of
them
or
I
can
consume
things
that
you've
built,
and
this
is
that
compounding
effect
that
that
isolation
gives
us
the
ability
to
build
on
top
of
what
others
have
done.
That
makes
our
industry
move
so
quickly
and
deliver
so
much
value.
A
The
foundation
of
that
in
our
in
the
container
ecosystem
is,
is
images
so
this
ability
to
store
things
in
oci
artifacts
and
then
either
consume
them
directly
as
a
as
a
networked
service
or
to
build
on
top
of
them,
and
the
other
magic
of
Docker
is
now
that
we've
got
millions
of
developers
using
it.
There's
a
simple
flow
that
developers
already
know.
A
So
this
didn't
happen
by
accident
right.
The
core
thing
behind
the
success
of
what
runs
in
my
machine
runs
on
yours
runs
on
CI,
it
runs
in
production,
is
standardization
the
reason
you
can
run
a
container
on
your
desktop
with
Docker
desktop,
then
in
GitHub,
Ci
or
GitHub
action,
CI
and
then
on
and
deploy
to
ECS.
Aws
ECS
is
because
of
these
runtime
the
runtime
specification,
the
image
specification
and
the
distribution
specification.
These
are
the
core
things
that
provide
that
magic.
A
That
really
allows
you
to
develop
these
Open
Standards
and
collaborate,
not
just
within
your
company
or
your
team,
but
across
companies
and
industries.
This
really
is
the
you
know.
The
rising
tide
lifts
all
boats
and
the
reason
the
container
ecosystem
is
so
big
is
because
of
these
Open
Standards,
and
because
we
can
work
across
and
not
you
know
not
have
one
one
thing
in
in
any
of
these
domains.
On
our
side,
we
or
we're
using
the
oci
to
do
this
mechanism,
which
is
kind
of
analogous
I
guess
to
some
of
the
bicode
alliance
pieces.
A
A
It
is
working
yay
already
yay
for
live
demos.
So
what
I'm
going
to
demo
is
I'm
going
to
demo
a
a
technical
preview
of
Docker
desktop
I'll
share
links.
Don't
worry,
you'll
be
able
to
get
it
which
has
waxy
support
built
in
we're
using
lassim
Edge
through
a
containerdy
stream
at
the
moment,
but
that's
that
should
be
pluggable
as
well.
I'll
start
with
the
docker
compose
file
here,
I
hope.
Most
of
you
are
familiar
with
Docker
compose,
but
I
have
I,
have
the
canonical
three
service
application.
A
So
what
this
will
do,
then,
is
the
the
server
the
rust
server
will
write
things
to
a
DB
and
be
able
to
query
them,
and
the
GUI
will
be
able
to
read
them
out
and
notice
that
two
of
the
services
are
in
containers
and
the
one
is
a
is
a
wassum
module
to
build
this
I
have
a
Docker
file
and
what
this
does?
Is
it
cross-compile
from
my
local
architecture
straight
to
wassce,
Western
32
you'll
also
see
here
that
I'm
running
Western
edges
aot
optimizations.
A
So
we
get
much
higher
performance
here
and
with
Tokyo
and
Co
routines.
Essentially
we
can.
We
can
handle
many
more
requests
in
parallel
and
then
speaking
to
Ralph
earlier
this
is
you
close
your
eyes,
but
we're
using
a
from
scratch
image
and
we're
copying
the
the
Western
results
into
that.
So
we
can
reuse
some
of
the
oci
pieces.
So
what
I'm
going
to
do
is
like
a
good
cooking,
show:
I've,
pre,
I've
pre-baked
this,
but
I'll
do
a
compose,
build
and
you'll
see
if
it
can
resolve
everything.
A
Hopefully
everything's
cached
there
we
go
and
if
I
inspect
this
image,
you'll
see
that
it's
a
it's
got
the
architecture,
Wesson
32
and
an
OS
webc.
This
is
just
if
I
do
a
Docker
images.
You'll
actually
see
it
pop
up,
so
you
can
see
it's
the
Western
day,
one
or
the
server
one
I've
just
retagged
it,
and
then,
of
course,
if
I
do
a
Docker
compose
up,
this
would
implicitly
build
it,
but
otherwise
it
just
launches
everything
for
you.
So
this
is
a
flow
that
specifically
front-end
developers
are
very
familiar
with
with
Docker.
A
We
just
do
a
Docker
compose
up.
It
builds
everything
it
needs
to
build
it
downloads,
all
the
images
it
needs
and
you've
got
something
up
and
running
I'm
going
to
start
up
a
second
terminal
here.
Hopefully
it's
it's
not
too
too
big
and
I'm
just
going
to
initialize
this
and
then
I'm
going
to
upload
a
couple
of
orders.
So
you
can
tell
I'm
a
backend
engineer,
because
this
is
my.
A
This
is
my
home
and
if
I
go
over
to
here,
I
can
reload,
and
this
is
querying
that
front-end
service
now
so
what's
happening
is
I've
queried
the
front-end
service.
That's
hitting
the
the
Wesson,
the
West
Wesson
server,
which
is
querying
the
database
and
pulling
things
up
and
I
can
do
operations
here
that
kind
of
travel
through
as
well.
So
that's
containers
and
Wesson
sitting
side
by
side
kind
of
transparently
actually,
which
is,
it
seems
like
an
anti-climactic
demo.
But
but
there
you
go.
A
So
so
here
it
is
inside
desktop
as
well.
We
also
made
it
so
you
can
see
that
this
is
a
western
32
thing,
that's
running
and
notice
that
the
networking
is
working
as
well,
just
as
it
does
with
compose
and
of
course,
I
pushed
this
earlier
to
to
Docker
Hub.
So
you
can
see
up
here.
We
have
it
up
on
on
a
demo
repo
right
I'm,
going
to
pull
it
back
to
the
the
slides.
So
so
what
we've
done
here,
then,
is
we?
A
We've
got
the
same
workflow
that
a
lot
of
developers
use
containers
today
already
know
this
Docker
composer
and
then
you're
just
going,
someone
will
do
Docker
build.
Some
of
them
will
do
Docker
push
as
well,
but
they've
got
the
same
flow
that
they've
used
for
containers
before,
but
this
time
they're
using
Wesson,
we
are
put
an
oci
image
and
because
we
output
an
oci
image,
we
can
reuse
oci
compliant
Registries,
and
this
is
great
because,
having
worked
with
teams
who
run
Registries,
it's
less
fun
than
it
sounds,
and
it's
you
know
reusing.
A
A
All
of
this
is
built
into
Docker
desktop
and
we
have
millions
of
developers
who
use
Docker
desktop.
So
this
means
that
they
would
just
have
this.
Have
this
right
there
for
them
to
use
and
the
interoperability
with
containers.
I
think
is
an
important
piece
too,
because,
like
VMS
haven't
been
displaced
by
containers,
containers
are
not
going
to
be
displaced
by
Wesson
and
we
need
an
interrupt
story.
A
So
what's
next
well
we're
just
getting
started.
Docker
is
new
to
the
wasm
space
and-
and
we
realized
that
we
want
to
work
with
the
Western
Community.
We
really
do
want
to
do
this
in
a
collaborative
fashion
and
we
want
to
share
our
experience
from
the
container
ecosystem.
We've
learned
a
lot
over
the
last
several
years
and
we
want
to
bring
this
to
to
help
bring
Western
to
more
people
and
I.
Think
some
of
you
may
have
already
seen
the
blog
post,
but
we're
actually
joining
the
bytecode
alliance
as
well.
A
Of
course,
it
also
wouldn't
be
a
worsened
speech
if
I
didn't
show
you
Solomon's
tweet,
which
is
notorious
in
your
circle.
So
so
you
know
I
I,
think
people
as
Justin
pointed
out
in
the
keynote
people
kind
of
misinterpreted.
This
and
I
feel
like
we
really
are
coming
full
circle
with
what
I
demo
today,
where
in
that
second
tweet,
where
he
says,
imagine
a
future
where
Docker
runs:
Linux
containers,
Windows
containers
and
Western
containers
side
by
side.
A
Well,
that's
exactly
what
we've
demoed
today
so
I
know
you're
all
most
well,
most
of
your
property
Engineers!
You
want
to
get
the
code.
I've
got
a
QR
code.
You
can
scan
there.
Otherwise,
you
can
look
at
my
GitHub
repo
I've
got
links
to
the
versions
of
Docker
desktop
and
some
and
some
demo
repos
that
were
provided
by
Michael's
team
as
well.
So
you
can,
you
can
just
Docker
compose
up
and
play
around
right
thanks.
Everyone.
D
A
Oh
wow,
nice,
nice,
soft,
Global,
m,
M
I
think
some
of
the
I
I
wasn't
there
for
the
very
beginning.
So
I
don't
have
a
strong,
a
strong
story
to
tell
there
but
I
think
the
things
that
I'm
seeing
on
the
western
side
is
a
lot
of
these
initial
settling.
We
saw
where
we
were
trying
to
work
out
what
standards
matter,
which
things
need
to
be
standardized
which
things
where
should?
Where
should
people
differ?
A
Where
should
companies
differentiate
all
of
that
sort
of
stuff
I'm,
seeing
those
sorts
of
analogies
happening,
and
that's
why
I
kind
of
called
out
the
the
oci
work?
Where
we've
done?
Where
think
about
think
about?
How
do
we
build
an
end-to-end
story,
because
I
think
that
we
need
to
find
killer?
We
need
to
find
a
couple
of
killer
use
cases
that
are
end
to
end,
so
developers
can
really
start
adopting
Western
right
now.
It
still
feels
quite
fragmented,
which
makes
it
really
difficult
for
people
to
adopt.
A
There
are
obviously
there
are
people
who
are
using
it
in
production
in
very
various
different
cases,
but
there's
no
mass-market
easy
way
of
doing
that
and
Scott's
going
to
have
to
cover
his
ears,
but
I
think
because
you
could
throw
processes
existing
binaries
into
Docker
containers,
and
they
were
just
better
just
doing
that.
That
kind
of
helped
us
as
well,
because
there's
a
lot
of
brand
field
software
out
there
and
and
helping
people
get
that
running
in
or
putting
that
inside.
A
A
A
Right
now
it's
configured
inside
my
compose
file,
and
let
me
just
hide
this:
oh
come
on
there,
we
go
I've
configured
it
inside
my
compose
file
to
make
it
explicit
to
show
that
I
want
to
use
the
containerdy
shim.
So
what's
happening
here
is
the
docker
engine
is
it's,
it
runs
things
through
container,
D
and
contanity.
You
can
have
different
shims
for
doing
different
types
of
workloads.
In
this
case
we
have
a
wasamed
shipment,
so
I've
told
it.
Please
run
it
with
the
West
submission.
A
So
the
question
was:
you
now
have
Docker
with
Wesson:
does
that
mean
we're
part
of
the
the
kubernetes
ecosystem
and
to
clarify
that
so
the
way
we've
integrated?
This
is
through
container
D,
which
is
a
low
level
piece
for
managing
how
it
works
with
containers.
Is
it
manages
that
process
life
cycle
and
setting
up
namespaces
and
things
like
that?