►
From YouTube: Extending WebAssembly Hub to Istio Service Mesh
Description
Solo.io, Google and Istio have teamed up to support WebAssembly in Envoy Proxy and Istio to bring the dynamic extensibility of WebAssembly to Envoy with unmatched agility, reliability and security.
What is WebAssembly?
WebAssembly (Wasm) is a fast, efficient, portable binary instruction format, providing an embeddable and safe execution environment for platform extensions. Wasm extensions, which can be written in multiple languages and executed at a near-native speed, became a popular way to extend web based applications.
Speakers from Solo.io and Google will cover the community feedback and collaboration that led to support for WebAssembly and the joint effort to iterate on WebAssemblyHub to ensure the best developer experience in on-boarding, developing, deploying, managing and sharing WebAssembly extensions.
Learn More:
https://www.solo.io/
https://istio.io/
https://webassemblyhub.io/
Join the Discussion https://slack.solo.io
Follow https://twitter.com/soloio_inc
A
So
with
that
I'd
like
to
introduce
our
speakers
for
today,
quick
Louie,
Ryan
principal
engineer
at
Google
working
on
our
merrily
working
on
the
history
project
and
many
others,
we've
got
indeed
indeed
Levine
the
founder
and
CEO
solo,
IO
and
Christian
posta
field
CTO
here
at
solo.
Third,
one,
it's
it's
balls
in
your
court!
Now,
hey.
B
C
So,
let's
first
look
at
the
two
project
that
we
are
all
talking
about.
The
first
one
is
sto,
which
is
the
server
base
coming
from
Google,
with
a
collaboration
with
IBM
and
lyft,
and
the
idea
this
is
the
ability
to
actually
to
actually
have
the
ability
to
actually
control
the
visibility,
the
security
and
they
enter
routing
for
your
micro
services
in
your
environment.
C
In
order
to
do
this,
basically
SEO
is
taking
what
call
a
data
plan
in
that
case
envoi
and
putting
it
next
to
any
service
that
exists
in
the
infrastructure
in
order
when
the
request
is
coming
to
the
proxy,
the
proxy
need
to
know
what
to
do
with
this,
and
for
that
we
have
the
control
plane.
So
sto
control
plan
is
basically
in
charge
to
give
all
the
information
to
envoi.
In
that
case,
and
when
the
request
is
coming,
sto
control
plan
is
not
involved
whatsoever
and
Enver
just
would
know
what
to
do.
With
this.
C
Sending
exactly
is
going
on
with
glue
just
glue
is
doing
exactly
the
same
thing
just
is
very
focusing
on
the
edge
right
so
on
the
entry
to
your
cluster.
So
before
buffet
before
it's
in
the
a
the
control
plan
is
actually
giving
the
conversation
to
and
voi
and
on.
They
actually
run
time
when
the
user
is
coming
with
the
request,
and
we
just
know
what
to
do
with
your
some
quest.
You
know
to
reach
service
throughout.
C
C
But
it's
really
really
working
exactly
the
same
thing
with
STL
and
the
user
is
basically
giving
me
any
configuration
that
is
interested
in
it
and
that
point
they
want
to
route
to
a
service
one,
and
you
want
to
make
sure
that
actually
allows
us
it
so
glue
responsibility
in
that
case
and
again,
as
sto,
is
basically
to
configure
that
the
day
they
external
server.
In
that
case
the
external
server
and
the
rate-limiting
server,
there
are
global
services.
C
They
need
to
be
on
the
level
of
the
infrastructure
and
therefore
you
know
they
should
not
live
in
the
data
plan
and
besides
that,
it
will
configure
the
data
plan
and
the
way
to
configure
the
data
plan
is
basically
this
am
make
a
make
a
it
configure
it
that
way.
That
II
need
to
configure
what
called
the
filter
chain
and
the
filter
chain
where
its
mean
is
that
when
a
new
quest
path,
a
quest
will
come,
those
requests
is
going
to
go
through
those
filters.
C
So
in
that
case
the
control
plan
is
responsible
to
I
decided
what
is
disorder
as
well
I
of
the
filters
as
well.
What
is
the
configuration
that
each
of
them
will
have
so
that
way,
when
a
requests
coming
to
the
user
to
about
troop
all
those
services
again,
they
will
know
what
to
do
with
this
and
we
make
a
decision
to
be
allowed
to
go
and
then
go
all
the
way
to
the
upstream
and
on
the
way
back.
It
will
do
exactly
the
same
thing
and
we
respond.
We
return
the
response.
C
So
what
beautiful
about
this
system
is
that
you
basically
can
totally
customize
that
and
you
can
actually
add
a
filter
to
the
chain
and
change
the
order
of
the
chain
have
the
ability
to
actually
customize
that
the
way
you
want.
So
this
is
really
really
powerful,
and
this
is
why
I
am
very
so
special.
The
question:
is
it
still
create
a
lot
of
problematic
to
do
this,
for
instance,
every
time
that
you
are
adding
a
filter,
you
need
to
write
it
in
C++,
a
sink
which
is
pretty
complex.
C
The
second
thing
is
that
after
you're
writing
it
you
need
actually
compile
it
compile
anyway,
and
this
is
not
an
easy
task
at
all.
So
there
is
a
lot
of
you
know.
It's
a
really
good,
powerful
technology,
but
there
is
a
lot
of
limitation
which
which,
which
is
it's
not
as
easy
as
we
hope
to
do
so.
First
of
all,
to
be
very
great,
if
you
can
you
any
language
and
not
just
be
forced
to
use
C++,
we
wanted
to
be
as
fast.
C
C
So,
let's
see
how
we
chose
in
glue
to
actually
do
this
and
when
we
chose
in
glue,
we
said
that
this
thing
that
is
most
important
to
us
is
how
fast
you
are
efficient
it
in
the
data
path.
But
what
does
it
mean
is
that
we
basically
mean
that
we
are
the
one
who
need
to
write
the
custom
filters
right
as
the
request
to
a
customer
and
give
them
a
solution
that
it's
telling
back
to
them.
So
we
are
writing
the
C++
filters.
C
We
are
actually
cool,
recompiling
and
boy
and
then
we're
basically
giving
it
to
our
customer.
So
there
is
a
lot
of
a
of
advantage
for
it,
because
it
would
be
very
fast
and
very
efficient.
It's
really
really
safe,
but
you
we
have
to
use
the
plus
plus,
which
means
that
we
need
most
of
the
time.
We
need
to
do
the
work
and,
besides
that,
and
we
need
to
compile
it,
and
it's
not
really
really
easy.
So,
let's
do
decided
to
choose
a
different
approach
and
what
they
said.
C
He
said
it's
really
really
important
to
us
that
people
will
be
able
to
write
their
own
logic
and
therefore
we
will
create
we
will
they
created
a
component
called
mixer
and
that
even
make
sense
just
the
GOP.
So
in
the
nut
shells
in
proxy,
you
have
some
add
some
filter
that
will
know
how
to
write
to
a
reach
out
to
mixer
and
mix
it
mix.
C
The
error
is
still
need
to
send
all
the
body
and
all
the
information
that
he
has
to
mixer
and
that
can
cause
potentially
a
problem,
so
you
can
use
any
language
most
of
the
people
using
go.
So
it
is
you
know,
but
if
there
is
a
potential
here
it
is
safe,
I'm,
sorry,
but
it
is
very
safe,
exactly
as
safe
as
running
inside
and
boy,
there
is
no
need
to
compile
it,
which
is
a
huge
advantage,
and
it's
easy.
You
know
the
developer.
C
Experience
is
not
the
best
it
can
be,
but
it's
definitely
it's
definitely
easier
than
writing
their
own
business.
So
now,
when
we
look
at
this,
we
felt
that
webassembly
has
a
lot
of
potential.
Do
sold
those
to
those
problem
and
now
we'll
move
there.
This
to
Louie
will
talk
a
little
bit,
enjoyable,
webassembly
and
then
about
webassembly
and
boy.
B
So
webassembly
was
a
technology
that
we
had
been
looking
at
for
a
while.
Google
actually
does
a
lot
of
work
with
webassembly
as
part
of
the
chromium
project,
but
you
know
we
were
looking
at
solving
this
problem
of
extensibility
and
envoy
and,
looking
for
you
know
an
embeddable
runtime
that
we
could
use
in
Envoy.
That
would
give
us
the
performance
envelope
that
we
were
looking
at,
but
also
enable
a
much
greater
flexibility
around
the
development
model.
B
B
They
designed
it
in
such
a
way
that
it
would
be
equally
applicable
to
embed
in
other
types
of
environments,
because
it's
born
from
the
browser
world.
You
know
we
had
to
make
sure
that
web
assembly
was
portable
right.
It
has
to
run
on
every
major
operating
system
in
platform
about
these
major
browsers
work
on.
B
B
Windows
Edge,
obviously
is
now
using
Chrome
and
WebKit
also
has
an
implementation
of
what
assembly.
So
all
the
major
browsers
are
platform
support
web
assembly
today,
which
means
that
there's
really
really
good
cross-platform
support
the
other
thing
that
it
enables,
because
it's
this
intermediate
form
right,
you
the
developer.
When
you
write
web
assembly
code,
you
take
your
code
and
you
compile
it
to
the
was
on
bytecode
format
and
then
that
same
code
will
run
anywhere
that
there's
a
web
assembly
runtime
right
and
a
matching
environment.
B
B
Your
average
web
browser
today
is
opening
webpages
from
lots
and
lots
of
different
places,
and
so
all
these
different
programs
running
inside
your
browser
right,
you
have
to
make
sure
that
they
aren't
able
to
interfere
with
each
other,
we're
all
probably
pretty
familiar
with
all
the
different
forms
of
attacks
and
it
being
performed
against
web
browsers
over
the
years.
So
you
want
to
make
sure
that
all
these
applications,
which
are
you
know
in
some
cases,
quite
low
level
and
highly
performant
applications,
aren't
able
to
attack
each
other.
B
So
what
web
assembly
does
is
it
defines
a
sandbox
for
the
application
that
is
very
well
banded.
It
provides
this
kind
of
what
they
call
a
contiguous
memory
region
boundary
and
you,
the
runtime,
will
load
the
application
into
this
block
of
memory
and
the
application
cannot
access
anything
outside
that
block.
The
only
thing
you
can
do
to
talk
to
the
outside
world
is
to
talk
to
a
well-defined
interface
exposed
to
it
by
the
environment.
B
So
this
allows
you
to
take.
You
know
what
might
be
a
very
risky
application
and
not
give
it
access
to
anything.
You
know,
don't
give
it
access
to
the
network,
don't
give
it
access
to
anything
on
the
screen,
run
the
application
and
have
a
very
high
degree
of
confidence
that
it's
no
matter
what
no
malicious
intent
it
has.
B
It
can't
escape
its
sandbox
and
this
is
really
important
for
the
web,
and
it's
also
going
to
be
important,
I
think
on
the
server
side
and
we'll
get
a
bit
more
into
that
you
know,
weather
suddenly
was
primarily
envisioned.
You
know
to
make
sure
that
we
could
build
high-performance
applications
in
the
web,
and
so
its
primary
competition
in
that
realm
is
JavaScript.
B
You
know
similar
to
what
you
would
see
with
something
like
LLVM
and
clang,
that
the
decode
phases
is
much
shorter,
because
what
the
format
is
binary.
The
compilation
phase
really
just
means
the
the
just-in-time
compilation
phase,
where
the
the
web
assembly
runtime
converts
the
web
assembly
by
good
format
into
an
optimized
form
for
the
specific
hardware
platform,
and
then
it
executes
sit,
and
so
what
you
typically
see
is
programs
of
equivalent
complexity
in
JavaScript
and
web
assembly
web
assembly
loads
much
faster,
compiles,
much
faster
and
executes
so
much
faster.
B
In
fact,
if
you
look
at
benchmarks
today,
you
know,
if
you
take
an
equivalent,
you
know
a
fairly
simple
C++
application,
compile
it
to
your
native
platform,
compile
it
to
web
assembly
and
then
benchmark
them
against
each
other.
You'll
often
find
that
web
assembly
comes
in.
You
know
no
more
than
10
or
20
percent
slower
than
that
C++
application,
which
is
pretty
impressive
right.
That
means
the
compilers
are
doing
a
good
job
and
the
runtimes
are
very,
very
efficient.
B
So
you
can
get
this
almost
native
performance
and
we
expect
to
see,
as
web
assembly
evolves
over
the
next
few
years,
that
we'll
see
that
gap
close
and
the
situations
in
which
that
you
know
where
that
gap
is
wider,
become
less
and
less
common,
as
people
do
a
better
job
with
optimizations.
But
for
the
most
part
you
can
kind
of
assume
that
web
assembly
ones
at
near
native
speed
and
that's
a
really
important
thing
when
we
start
talking
about
a
networking
next
line.
B
B
You
can
focus
all
the
different
compiler
tool
chains
to
produce
that
intermediate
representation
and
then
the
runtimes,
which
are
in
a
bound
any
specific
hardware
platform
like
x86
or
arm
MIPS,
or
they
end
other
platforms.
People
could
be
using.
It
makes
this
compiler
tool
chain
simpler
to
reason
about
right.
They
focus
on
producing
that
intermediate
representation,
that
web
assembly
bytecode
format
as
efficiently
as
possible,
and
then
the
different
virtual
machine
implementations
for
web
assembly
focus
on
producing
the
most
efficient
binary
executable
form
on
the
given
hardware
proper.
B
So
this
is
pretty
typical
for
most
platforms
today
through
familiar
Java.
Java
works
in
a
similar
way,
but
Java
doesn't
have
as
efficient
of
compiler
tool
chain
right,
Java
representation,
the
intermediate
representation
is
still
pretty
abstract
from
the
harbor
platform
and
from
what
the
actual
code
might
do.
The
intermediate
representation
web
assembly
is
much
more
low-level.
It's
much
more
like
an
assembly
language,
okay,
next
thing.
B
B
B
No
v8
is
widely
used
in
Chrome,
which
you
know
is
extremely
widely
used
with.
We
know
the
team
quite
well
and
it
has
very
good
performance
characteristics.
So
what
we
want
to
be
able
to
do
you
know
is
any
of
these
kind
of
functions
that
it
showed
you
in
the
earlier
slide,
instead
of
having
them
to
be
compiled
natively
into
Envoy,
which
can
take
quite
a
bit
of
time.
It's
a
long
and
complex
build
process.
B
So
we
did
the
embedding.
We
took
v8,
we
embedded
the
runtime
inside
of
Envoy,
and
then
we
made
sure
that
you
could
implement
modules
in
webassembly
against
the
Envoy
ABI
and
then
load
them
dynamically
into
the
Envoy
runtime
right.
So
you
can
take
a
a
stock,
build
of
Envoy
and
tell
it
using
the
control
plane
to
load
up
a
wiser
module
and
then
that
wasn't
module
now
it
will
execute
in
the
data
plane
of
envoy,
and
you
can
do
this
dynamically
right.
You
don't
have
to
redeploy
envoy
after
restart
it
right.
B
It
can
be
done
completely
on
the
fly
and
these
wazzle
modules
can
do
whatever
you
want
right.
They
can
do
the
same
set
of
things
that
the
code
compiled
to
native
being
Tom
boy
can
do
for
the
most
part
right,
I
can
implement
a
rate
limiting
module
in
webassembly
I
could
implement
something
that
does
a
protocol
transformation.
I
could
implement
something
that
does
an
authorization
show.
B
So
we
actually
have
the
ability
to
switch
back
and
forth,
and
so
far
we've
been
pretty
happy
with.
You
know
the
relative
performance
difference
of
running
the
code
in
on
in
web
assembly
or
running
it
as
natively
compiled
code
into
C++.
You
know
we
see
some
performance
degradation,
but
not
enough
to
actually
be
meaningful
to
us
and
the
flexibility
that
it
gives
us
in
terms
of
the
ability
to
load
and
reload
modules
dynamically
and
to
use
stock.
B
B
So
here's
an
example
of
a
method
that
envoy
will
call
on
a
web
assembly
module,
and
this
is
kind
of
shown
using
C++
syntax,
saying
look
I've
received
some
HTTP
headers,
you
know
do
whatever
you
want
with
the
headers
and
then
tell
me
what
to
do
next,
all
right
so
envoys
calling
into
the
module
and
you
can
mutate
the
headers.
You
could
remove
headers
right.
You
can
tell
envoy
I
want
to
reject
the
requests
right.
I
want
envoy
to
start
processing
the
body
right.
This
is
these:
are
the
types
of
interactions
you
can
perform.
B
These
ABI
is
tend
to
be
fairly
low-level
right
if
you
go
and
look
at
the
ABI
is
for
Linux,
for
instance,
they're
very
low-level
things.
So
typically,
you
know
if
you're
going
to
have
a
developer
community
sitting
on
top
building
plug-ins
for
envoy
they'll
probably
want
to
be
using
an
SDK
that
provides
a
nice
level
of
a
distraction
above
this
API,
and
so
what
we've
done.
B
So
now
you
know
we
have
the
ability.
You
know
it's
a
take
where
these
SDKs
start
writing
a
plug-in
they're
in
the
language
of
choice,
compile
that
module
down
into
the
web
assembly
by
code
format
and
then
using
one
of
the
control
planes,
whether
it's
glue
or
sto,
or
some
directly,
configuring
envoy
or
some
other
envoy
configuration
push
these
wads
of
modules
into
running
envoys
dynamically.
B
So
what
we
get
out
of
this
well,
we
can
use
a
much
larger
variety
of
languages
than
we
were
able
to
use
before
right,
pretty
much
anything
that
works
with
the
LLVM
tool.
Team
today
will
work
with
web
assembly.
It's
fast,
the
byte
code
format
is
very
efficient
and
the
existing
runtimes
that
implement
these
virtual
machines.
You
know
get
close
to
near
native
performance.
We
have
safety
because
of
the
memory
sandboxing
the
guarantees
that
those
VMs
provide
and
when
the
Wisel
module
is
loaded
into
envoy
the
compilation
step
of
converting
the
bytecode
format.
B
It's
the
native
format
is
very,
very
fast
and
similarly
I
also
don't
have
to
recompile
envoy
every
time.
I
want
to
make
a
change,
which
is
a
much
larger
compilation
thing
it's
now.
The
only
thing
that's
left
to
be
done
is
to
make
this
easy
for
developers
to
consume
and
for
operators
to
kind
of
push
out
module
as
an
experiment
with
them
and
manage
them
in
production.
B
C
Yeah,
exactly
Christian
will
do
the
demo,
but
before
that,
I
just
wanted
to
say
that
when
we
look
at
all
the
work
that
Google
is
doing
and
wanted
to
help,
I
think
that
was
really
really
cool
to
us
is
that
this
is
a
very
a
very
amazing
technology
that
that
it's
it's
good
power,
a
lot
of
people
to
do
whatever
they
want.
That
was
the
create
the
experience
to
our
customer
and
make
it
really
really
easy
for
them.
C
But
then
I
saw
this
tweet
from
Solomon
Hayek,
and
what
I
realized
is
that
there
is
a
lot
of
similarity
between
what
was
demand
was
ministering
to
basically
what
doctor
did
before
right.
I
mean
in
the
nutshell,
the
sandbox
is
giving
you
the
ability
to
run
it
safe
and
fast,
and
whatever
all
this,
the
problem
that
that
docker,
basically
try
to
you
so
in
a
way,
can
be
solved.
But
it
wasn't
so
when
I
look
at
it.
C
I
said
this
is
great,
but
then
what
if
we
can
bring
all
the
amazing
experience
the
doctor
brought
you
Linux
container
and
brought
it
to
Wasserman,
specifically
with
that
anyway.
So
this
is
why
we
created
webassembly
hub,
and
that
was
really
inspired
by
the
docker
hub
and
the
docker
tools,
which
is
basically
the
ability
to
make
it
very,
very
simple.
For
someone
to
build
a
model
again,
we
hide
all
the
complexity
behind
the
scene,
and
there
is
still
quite
a
lot
of
complexity.
C
You
will
be
able
to
publish
it
first
of
all
for
you
to
do
consume
it
later
or
for
even
people
from
the
community
will
be
able
to
share
exactly
that.
Dr.
hobbies
doing
you'll
be
able
to
discover
if
you
didn't
build
one,
and
you
just
want
to
get
one
that
someone
else
do
you
can
totally
discover
that
and
then
you
can
actually
also
one
more
step
that
we
did.
A
differentiator
from
dr.
is
the
fact
that
we
are
also
deploying
it
automatically
on
those
platforms.
C
So
right
now
we're
supporting
glue,
we're
supporting
estia
and
we're
also
supporting
local
NV,
and
that's
mainly
for
bugging
your
extension
and
make
it
very
easy
and
now
I
think
that
we
really
achieve
everything
that
we
wanted.
You
can
use
a
lot
of
language,
it's
fast,
safe,
it's
nothing
to
compile
and
it's
easy
and
then
Christian.
We
show
you
a
demo
to
see
how
easy
it
is.
D
Okay,
so
if
you
go
to
web
assembly
hub
dot
IO,
that
will
take
you
to
the
landing
page
of
the
of
the
registry,
where,
as
Edith
said,
folks,
can
build
their
own
web
assembly
modules
and
push
them
to
this
registry
and
share
them
with
the
wider
community.
So
you
can
come
here
and
you
can
search
for
a
particular
interesting
piece
of
functionality
that
you
might
want
to
deploy
into
a
non-void
based.
D
You
know,
service
mesh
for
a
PA
gateway
like
like
glue
and
sto
and
and
then
from
there.
You
can
pull
them
down
and
deploy
them
into
those
those
particular
pieces
of
infrastructure.
If
we
click
on
the
docks
link
here,
that
will
take
us
to
a
set
of
tools
that
can
be
used
to
automatically
create
or
bootstrap
these
web
assembly
projects
in
various
programming
languages,
the
the
tool
chains
to
build
and
publish
the
the
modules.
If
you
click
on
tutorials,
we
have
also,
for
example,
in
deployments.
D
We
can
see
how
to
deploy
into
various
envoy
based
frameworks.
What
we're
going
to
look
at
in
the
demo
today
is
how
to
use
the
web
assembly
hub
with
the
Oise
me
tooling.
That
comes
along
with
the
web
assembly
hub
and
deploy
web
assembly
modules
into
SEO
and
specifically,
is
do
1.5
again.
I
want
a
costume
that
this
is
still
alpha
level,
but
it's
as
Louis
said
coming
along
pretty
quickly
and
should
get
it
to
beta
and
more
GA
status
fairly.
Very
quickly.
D
Sco
1.5
announced
various
a
few
few
exciting
things
about
the
project,
but
you
can
come
into
the
one
at
five
announcement
and
read
more
about
the
assembly
mechanisms
for
extensibility
and
if
you
look
at
all
of
the
posts
in
SEO
blog,
there's,
there's
quite
a
bit
of
exciting
information
in
there.
So
from
here.
Let's,
let's
get
right
to
it.
D
We're
going
to
be
taking
a
look
at
the
book
info
app
as
one
does
when
demoing
sto
and
we're
going
to
be
looking
at
the
communication
between
the
product
page
here
and
the
details
service
in
the
backend
is
we're
gonna.
Look
at
the
calls
between
those
two
services
and
we're
going
to
create
some
new
web
assembly
modules
and
inject
that
into
the
sto
sidecar
service
proxies.
So
we
can
alter
the
behavior
of
the
the
network.
Club
request
has
to
go
over
the
over
the
network.
So,
let's
here
and
we're
gonna
start
off.
D
This
is
a
live
demo.
I
do
have
a
hot
little
helper
script
here.
To
help
me
type
things
as
at
times
might
be
inclined
to
miss
type
things,
but
hopefully
the
script
will
help.
For
the
first
thing
we're
going
to
see
is
that
we
have
an
sto
1.5
deployed.
You
can
see
that
because
the
control
plane
has
been
built
using
the
newest
EOD
functionality,
we'll
also
take
a
look
at
a
running
book
info
sample
with
the
sto
sidecar
is
injected
and
we'll
also
take
a
look
at
the
call
between
the
product
page
and
the
details.
D
Service
and
I've
done
this
to
both.
Well,
we
can
see
the
output
here.
We
can
see
that
it
was
returning
successfully
and
we
can
also
examine
some
of
the
headers
in
the
response
and
the
reason
we're
showing.
That
is
because,
in
the
other
assembly
module
that
will
billable
we'll
do
some
manipulations
with
that
first
thing:
we're
gonna
do
is
use
the
web
assembly
or
Waze
me
tooling,
to
bootstrap
a
new
web
assembly
module.
So
if
we
was
me
to
knit
call
it
filter
right
now,
we
see
C++
I'm
webOS
our
assembly
script
as
options
shortly.
D
We
should
have
rust
and
as
we
mentioned,
there
was
some
folks
showing
off
tiny,
go
and
philemon
get
tiny
go
into
here
as
well.
We're
gonna
choose
assembly
script
and
then
we're
going
to
choose
which
envoy
based
frameworks
that
we
want
to
target
in
their
in
their
versions,
and
this
becomes
important
because
we
want
a
behind-the-scenes,
make
it
easy
to
wire
up
the
correct
ABI
s
and
the
SDKs
to
the
version
of
envoy
that
you'll
be
deploying
into
so.
We
do
that
and
that
should
create
our
project.
D
That
we
generated
a
few
descriptor
files
if
you're
familiar
with
typescript
and
nodejs,
you
can
see
that
it
has
added
to
the
dependency
chain
or
dependency
list
here,
the
the
correct,
SDKs
and
api's.
If
we
come
here,
we
can
see
the
exact
versions
that
were
targeting
and
it
has
automatically
generated
a
a
source
code
file
that
you
can
then
use
to
implement
the
functionality
that
you
want
in
the
way
of
assembly
module.
D
So
in
this
we've
the
the
skeletal
structure
here
we
can
see
that
we're
calling
or
we're
overriding
the
on
response,
headers
function
here
and
what
we're
doing
is.
If
we
have
some
configuration,
then
we're
going.
If
we
don't
have
configuration,
then
we'll
just
add
the
hello
world
header.
If
we
have
some
configuration
injected
in
will
add
hello
and
then
the
value
of
the
configuration,
which
means.
Not
only
can
we
make
code
changes
here
to
add
and
change
functionality
as
the
request
gets
processed
in
Envoy.
D
We
can
also
inject
configuration
into
our
module
to
have
it
behave
differently
depending
on
how
we
configure
it.
So,
let's
just
go
ahead
and
build
that
web
web
assembly
module
we're
going
to
do.
Was
we
build
assembly
script
and
give
it
a
tag?
Give
it
a
tag
name
just
like
we
would
with
with
with
docker
right
so
he'd
mentioned
that
we're
trying
to
have
a
nice
developer
experience
and
we've
modeled
it
out
of
kind
of
like
docker.
So
this
ends
up
building
a
no
CI
image
with
the
web
assembly
module
and
descriptor
files
in
it.
D
Actually,
if
we
come
over
here,
just
quickly
go
off-script.
If
we
look
at
the
store
here
so
this
this
is
what
was
built
locally
see.
This
is
my
scripted
demos.
This
is
what
was
just
built
this
image
right
here
and
if
we
take
a
look
at
that,
we
can
see
what's
included
in
the
image
we
have
the
wasum
binary.
D
So
that's
all
good.
Let's
now
so
watch
me
list,
we
can
see
our
demo
add
header,
v4
was
just
added,
and
the
last
thing
we're
gonna
do
is
push
this
to
the
web
assembly
club
crossing
our
fingers,
things
that
go
over
the
wild
network.
You
never
know
it
looks
good,
and
now,
let's
come
back
to
the
web
assembly
hub
and
login
login
as
me,.
D
Okay,
I
remembered
my
password
correctly.
Don't
say
that
now
under
demo
add
header,
which
is
the
image
that
we
just
built
under
tags.
We
can
see
our
new
the
new
tag
that
we
just
created
and
pushed
now.
This
is,
if
I
click
the
over
here
on
Explorer.
We
can
see
all
of
the
different
web
assembly
modules
that
folks
have
shared
and
ours
would
be
included
in
there.
D
D
What
we're
gonna
do
here
is
we're
gonna
run
Waze
we
deploy
now
Waze
me
deploy
well,
alright.
Let's
make
sure
that
we
can
still
call
our
product
page
to
detail
service
and
see
we
don't
have
any
extra
headers.
We
don't
see
the
hello
header
in
there
yet
Waze
me
deploy
is
going
to
allow
us
to
very
quickly
deploy
the
filter
or
the
web
assembly
module
that
we
want
into.
In
this
case,
sto.
D
We
could
have
also
have
chosen
glue
as
API
gateway
built
on
Envoy
or
unvoiced
Anila
directly
itself,
and
what
we're
gonna
do
in
this
particular
case
is
injected
into
a
all
the
workloads
running
in
a
particular
namespace,
but
we
can
also
be
very
surgical
or
very
specific
about
which
workloads
should
get
this.
This
web
assembly
module
by
specifying
the
selector
to
select
which
labels
will
receive
the
web
assembly
module
and
had
that
injected.
So
let's
do
webisode
or
logging
deploy.
D
Let's
do
the
the
tag
and
that
an
image
that
we
just
created
and
what
we
should
see
that
it
it's
doing
hopefully
correctly-
will
it'll
pull
down
that
web
assembly
module.
It
will
cache
it
locally
into
the
into
the
kubernetes
cluster
and
then
oh,
that
didn't
look,
didn't
look
too
promising.
That's,
oh!
No!
It
is
okay,
just
momentary,
heartburn
heartache.
It
looks
it
looks
fine
now,
so
what
it's?
What
is
doing
is
pulling
it
down
and
deploying
it
into
sto
and
configuring
s
Tio's
sidecar
proxy,
to
use
that
particular
web
assembly
filter.
D
If
we
look
at
in
is
the
other
way
to
do,
that
is
to
configure
using
a
non-void
filter,
there's
sort
of
a
way,
it's
part
of
the
control
plane
to
give
overrides
to
override
the
specific
configuration
that
you
want
to
give
to
the
Envoy
proxies.
We
see
that
it
created
that
filter
for
these
different
workloads,
all
of
the
ones
in
the
book
info
namespace.
If
we
look
at
a
particular
filter,
we
can
see
exactly
what
it's
doing.
D
It's
it's,
creating
a
Wasley
filter
that
will
use
v8
and
is
loading
in
this
case
the
wasum
module
off
the
file
system
which
which
got
injected
in
there.
We
have
an
update
to
Waze
me
that,
should
it's
in
full
request,
we're
reviewing
it
right
now
that
well
update
it.
So
we
don't
actually
do
do
it
over
the
file
system,
but
that
we
stream
the
module
directly
to
the
ISTE
Oh
sidecar
proxy,
and
we
don't
have
to
mess
around
with
with
this.
D
But
this
is
in
this
particular
demo
how
it's
working
so
now
we
see
that
everything
is
up
and
still
running.
Let's
make
the
call
between
book
and
product
page
and
the
detail
service,
and
we
should
see
our
new
hello,
header
and,
and
we
do
and
we've
configured
if
you'll
notice.
If
we
come
back
here
to
where
we
deployed
it.
D
We
passed
in
a
config
of
tomorrow
which,
if
you
remember
back
in
the
source
code,
where
we
did
that,
if
statement
where
we're
gonna
pull
the
value
dynamically,
depending
on
how
we,
how
we
configured
the
web
assembly
module
and
display
that
as
the
value
for
our
hello
header
now,
this
was
done
using
the
Oise
me
tool
directly.
This
could
be
a
nice
quick
way
to
do
this
in
in
development,
but
there
is
also
in
our
alright.
D
One
of
these
blogs
right
here
on
on
mystia,
where,
instead
of
using
the
CLI
tool,
you
define
a
CR
D
that
defines
the
various
parameters
of
the
deployment
and
where
to
inject
a
web
assembly
module
and
then
at
runtime.
This
happens
using
that
using
a
controller.
So
this
is
something
that
you
could
have
in
your
git,
ops,
pipeline
and
and
so
forth,
and
not
depend
on
the
CLI.
D
A
B
B
Given
webassembly
is
pretty
impressive
performance
and
look,
there's
not
a
huge
amount
of
limit,
but
there
are
some
probably
pragmatic
choices
that
will
be
making
in
conjunction
with
the
Envoy
community.
You
know,
envoy,
being
a
proxy.
You
know
probably
90%,
plus
of
the
traffic
that
it
sees
is
TCP
or
ACP
or
one
of
the
kind
of
common
HTP
variants,
and
so
it
probably
doesn't
make
sense
for
kind
of
fundamental
common
low
level
protocol
handling
to
move
into
web
assembly
modules.
B
B
There
are
well
there's
just
a
lot
of
other
filters
that
are
built
into
the
main
line
of
Envoy
and
in
talking
to
the
Envoy
maintainer
'he's
right.
They
would
like
to
get
out
of
the
business
of
shipping
all
these
extensions
built
into
their
pre-built
releases
when
it
makes
their
lives
easier
right.
They
don't
have
to
review
all
of
these
things.
They
don't
have
to
be
responsible
for
them.
B
So
on
that
one
we
don't
have
an
immediate
timeline.
I,
don't
certainly
there's
not
somebody
on
my
team
currently
actively
working
on
it,
but
go
has
pretty
good
support
for
webassembly,
but
there
are
a
few
limitations
to
using
go
and
because
go
is
a
garbage-collected
language.
You
need
good
runtime
support
for
garbage
collection
to
make
this
efficient
and
which
is
why
we
focused
on
C++,
rust
and
assembly
script
first,
because
they
don't
have
that
requirement.
B
But
there
is
a
variant
of
Go
called
tiny
go
which
is
not
garbage
flattened
and
there
was
a
tweet
yesterday
from
somebody
in
Japan
who
developed
an
SDK
and
gotten
it
working
with
the
Envoy,
ABI
and
so
I
expect.
You
know
we'll
probably
see
that
come
out
quite
soon,
and
once
the
web
assembly
vm's
pick
up
the
garbage
collection
support
which
is
on
their
roadmap,
then
I
think
you'll
see
first
class
those
support,
but
for
the
types
of
code
people
are
lucky
to
be
writing
in
go
tiny.
B
A
A
good
that's,
actually
a
good
segue
to
the
next
question,
which
kind
of
brings
us
that
topic
together,
along
with
some
other
aspects,
is,
can
I
use
tiny
coats
or
bright
filters
that
can
be
used
in
glue.
One
of
the
things
that
the
deep
that
you
mentioned
was
that
with
the
was
and
support
for
envoy,
based
solutions
and
glue
being
one
of
them.
Yes,.
C
So
so
in
glue
be
supporting,
you
know,
whatever
is
in
apps
in
envoi,
we
are
supporting
what
there's
no.
He
said
there
is
no
yet
SDK
for
tiny
go
and
it's
not
supported
yet
once
it
will
be
supported,
we
will
bring
it
to
was
me
and
it
so
automatically
support
sto
and
voi
Angelo,
so
we'll
be
able
to
run
it.
But
today
we're
supporting
and
glue
the
same
thing
that
we're
supporting
in
sto,
which
is
assembly
school
assembly,
as
well
as
as
a
simple
space
and
Russ,
is
coming
very
very
soon.
C
B
This
kind
of
speaks
the
power
of
webassembly
right.
If
somebody
out
there
built
an
SDK
for
Fortran,
let's
say
then,
as
soon
as
that,
SDK
was
working
and
the
compiler
toolchain
for
it
was
working.
Then
everything
downstream
of
that
would
work
right
from
webassembly
hub
all
the
way
to
the
on-board
runtime
and
live
deployment
right.
So
that's
that's
that
layering
that
separation
that
we
talked
about
earlier.
B
If
you
go
to
the
web
assembly
organization,
they
have
a
list
of
languages
that
have
existing
compiler
tool
chains
that
support
it.
It's
about
60
languages
right
now,
now
we're
not
going
to
take
on
trying
to
add
support
for
all
of
them,
but
the
community
could
certainly
very
easily
write
an
ABI
binding
for
an
SDK
or
any
one
of
those
languages
and
get
it
working
as
an
envoy
module.
C
B
Yes,
so
the
example
ABI
that
I
showed
in
the
Christian
kind
of
showed
you
in
the
example
was
just
one
piece
of
the
API
surface.
There
are
api's
or
callbacks
effectively
that
occur
that
go
into
the
module
for
the
response
side,
processing
of
HDPE
or
you
know
if
you're
writing
a
module
that
needs
to
interact
with
TCP
and
you
would
interact
with
data
passing
out
on
the
response
side.
So
both
sides
of
the
floor
were
covered.
B
A
C
Hey
I
would
just
add
that
guys
we
are
on
the
slack
of
soulless
Lackey
and
I
really
recommend
you
guys
to
join.
There
is
a
lot
of
wasum.
You
know
there
is
a
channel
called
webassembly
hub
and
there
is
a
lot
of
very
a
lot
of
people
that
actually
very
interesting
in
this
and
writing
and
as
a
community
I
think
we
could
do
crazy
stuff.
So
please
join
the
slack,
I
think
I
with
any
question
or
any
requests.
C
B
And
if
you
have
lower-level
questions
about
the
on
boy,
integration
or
you
want
to
write
an
SDK
or
have
questions
about
the
ABI
or
how
you
contribute
to
the
the
support
of
webassembly
and
envoy.
That
discussion
is
mostly
right
now
happening
in
the
issue
of
slack,
which
you
are
also
very
welcome.
To
join.