►
From YouTube: WebAssembly Filters Meeting (June 21st, 2021)
Description
WebAssembly Filters Meeting - June 21st, 2021
Join the community at https://layer5.io/community
Find Layer5 on:
GitHub: https://github.com/layer5io
Twitter: https://twitter.com/layer5
LinkedIn: https://www.linkedin.com/company/layer5
Docker Hub: https://hub.docker.com/u/layer5/
A
Let's
get
started,
let's
jump
into
the
webassembly
filters
meeting
for
june
21st
monday.
Oh,
this
meeting
is
perpetually
doomed.
It's
a
monday
morning,
meeting
at
least
morning
here
so
happy
monday,
okay,
couple
of
topics
that
are
lined
up
as
a
recap
of
last
week,
since
this
is
sort
of
the
second
I
think,
like
you,
know,
formal
meeting
official
meeting
where
wherein
we're
dedicating
was
a
half
an
hour
or
an
hour
or
something
today
to
awesome
filters.
A
We
should
review
last
week's
discussion
review
part
of
the
purpose
of
the
meeting
and
make
sure
that
we've
got
all
of
our
topics
listed,
so
so
to
do
that,
let's
review
part
of
the
purpose
of
the
meeting,
so
some
of
you
most
of
you
are
familiar
with
webassembly,
which
is
has
a
number
of
interesting
characteristics
about
it
as
a
technology.
A
Some
things
that
are
reminiscent
of
reasons
why
docker
came
into
popularity
or
containers
came
into
popularity.
A
Also
has
some
attributes
about
it
that
are
somewhat
reminiscent
of
uni
kernels
for
those
of
you
who
might
have
spent
some
time
in
that
area.
The
nice
thing
about
webassembly
is
well,
it
doesn't
have
some
of
the
same.
It
has
some
of
the
same
security
properties,
some
of
the
same
portability
properties,
but
not
some
of
the
same
restrictions
that
uni
kernel
has
unicorn
is
missing.
Can
a
lot
of
a
lot
of
tooling
has
some
of
its
own?
Is
his
own
thing,
but
webassembly
is
almost
like
a
modern
jvm.
A
A
And
so
one
of
those
virtual
stacks
is
now
being
supported
in
envoy.
Has
a
data
plane
proxy,
that's
used
by
four
or
five
or
more
depends
on
how
you
want
to
count
them?
A
But
but
it's
used
envoy
is
used
as
a
proxy
by
a
number
of
service
meshes,
and
so
its
extensibility
model
is
being
augmented
to
support
or
has
been
augmented
to
support,
insertion
and
running
of
small
web
assembly
programs
envoy
as
a
proxy
only
exposes
certain
functionalities
through
its
abi,
its
application,
binary
interface
and
exposes
that
those
its
abi
surface
area
to
webassembly
programs,
and
so
some
of
the
considerations
that
we're
making
in
this
in
this
set
of
discussions
is
about
how
to
well
it's
about
what
filters
are
available,
how
to
write
new
ones,
different
use
cases
for
what
those
might
do,
how
to
manage
their
life
cycle.
A
A
Filters
in
webassembly
now
so
anyway,
there's
the
backdrop,
that's
kind
of
why
the
purpose
of
the
call
we're
doing
this
in
context
of
primarily
in
context
of
measuring
as
a
service,
mesh
manager
and
meshri
has
some
nascent
capabilities
to
manage
filters
in
its
current
stable
release.
Those
have
broadly
not
been
exposed,
as
they
are
early
in
nature,.
A
A
B
Okay,
cool
I'll
just
begin,
I'm
looking
forward
to
do's
topic,
so
I'm
just
going
to
keep
this
short
and
straight
hopefully,
can
I
share
my
screen.
A
And
yep
and
don't
ask
if
it's
if
we
can
see
it
just
assume
someone
will
tell
you
if
they
can.
A
B
B
Right
so
sameer
this
one's
for
you,
hello,
if
you're
on
the
call
cool,
so
I
just
took
the
liberty
to
create
this
I'll
just
get
into
it
quickly,
starting
a
little
bit
of
context.
Samir,
please
do
correct
me.
If
I'm,
you
know,
if
I'm
understanding
something
differently
or
whatever,
but
basically
samir
has
a
situation
where
he's
getting
a
job
from
an
authentication
service.
So
this
jot
is
being
passed
from
the
front
end
or
whatever
source.
It
goes
to
an
authentication
service.
B
B
So
there
are
a
couple
of
headers
within
the
jot
and
some
of
it
is
in
the
payload,
and
some
of
it
is
in
the
header
section
and
what
samir
wants
to
do
is
he
wants
to
be
able
to
remove
the
ones
that
he
won't
be
needing,
since
authentication
is
already
done,
so
you
won't
be
needing
the,
I
guess,
the
authentication,
the
algorithm
or
the
type
and
and
in
the
payload
section
he
has
things
like
email
subject
and
normally
he
would
and
his
desires
to
be
able
to
move
those
email
and
subject
headers
from
the
payload
to
the
header
section
of
the
jot,
and
to
do
that,
the
configuration
that
you
have
to
pass
to
the
filter
currently
is
going
to
look
something
like
this.
B
So
you'll
have
an
ad
header
delete
header,
add
payload,
delete
payload,
I
haven't
added
those
yet
but
and
there's
gonna
be
what
is
a
payload
to
header
and
header
to
payload
so
over
here
you
basically
name
your
key
value
pair,
like
the
header
name
and
the
header
value.
If
you
want
to
add
something
you
have
to.
You
know
just
mention
the
header
name
for
delete
payload
to
header
headed
to
payload.
The
format
is
going
to
look
the
same,
we're
going
to
talk
about.
B
You
know
which
header
is
present
or
sorry,
which
key
is
present
in
the
in
the
payload
or
header
of
the
jot
and
you're
going
to
go
on
and
pass
that
as
a
base
64
to
your
yammer.
So
you'll
take
this
jason
over
here
and
you
would
oh,
my
god,
I'm
not
prepared.
You
would
essentially
yeah.
You
would
have
your
image
of
filthy
ammo
for
now
a
shortly.
B
You
would
be
able
to
do
this
through
directly
through
measuring,
but
for
now
you
will
be
able
to
just
modify
this
field
over
here
and
convert
this
to
convert
this
part
to
base64
and
just
paste
it
in
over
here.
Whatever
you
want,
that
will
be
your
configuration,
so
this
you
will
have
to
do
first
on
a
per
service
base
per
service
basis,
and
once
you
do
that
you
can
get
into
the
code,
so
I
have
uploaded
it
on
my
github
page.
I
can
I'll
be
sharing
you.
The
link
to
that
lead.
B
Tell
me
if
you
want
me
to
shift
it
elsewhere,
but
my
main
goal
was:
it
should
be
as
readable
as
possible.
So
all
the
structures
and
if
it
looks
like
a
lot
of
code,
it
isn't
it's
just
a
lot
of
functions.
You
know
meant
to
keep
things
as
clear
as
possible
since
sami
is
not
too
good
with
programming
languages
and
all
so.
B
Okay,
rather
than
getting
into
the
code.
Essentially
you
compile
this
I'll
come
be
compiling
this
to
wasm,
and
I
I
still
need
to
test
it
out,
but
I
guess
I
can
do
that
through
the
measuring
performance
patterns,
performance
testing,
and
I
can
do
that
as
I
can
just
give
it
to
samir
and
ask
if
it
works
out
of
the
box.
That
would
be
great.
So
I
think
I
need
to
have
another
discussion
just
for
him
to
take
a
look
at
the
code
and
we
can
well.
B
I
can
walk
through
the
code
separately
with
him.
There's
no
need
to
do
that
on
the
call.
Basically,
this
is
just
to
you
pass
in
that
json
and
you'll
get
whatever
behavior.
You
want
a
behavior.
You
want
so.
C
So
you
know
these:
can
you
go
to
the
particular
json.
C
Yeah
headed
to
my
yard,
so
are
these.
C
B
B
C
B
Really
helpful,
so
we
still
have
to
have
our
call
separately
and
I
just
want
to
make
sure
everything
is
fine.
B
A
Okay
early,
I
yield
my
time
so
in
terms
of
testing.
This
is
ideally
ideally
something
that
that
we're
able
to
do
now
like
using
using
measuring,
have
you
were
you
able
to
try
generating
load.
B
B
So
I've
got
that
part
figured
out
now.
I
actually
have
to
test
whether
through
the
ui,
I
I'm
able
to
generate
the
load
and
observe
the
jot
being
constructed
properly.
A
So,
and
do
we
know
if,
if
mescheri's
ability
to
generate
load,
even
if
it's
you
know
just
a
handful
of
requests
or
one
request,
does
it
does
it
expose
the
all
of
the
necessary
headers
that
you
would
need
to
generate
the
right
load,
a
load
that
would
match
what
you're
trying
to
change.
B
So
again,
one
of
the
things
that
I
was,
what
do
you
say
trying
to
do
is
keeping
it
as
generic,
so
I
could
take
the
what
is
it
jot
passed
along
by
image
hub
itself
and
you
know
use
that
in
order
to
sort
of
you
know
test
it
out
so,
like
you
have
the
username
and
the
plan
type
in
imagehub,
so
I
could
just
take
that
add
another
header
and
the
way
I've
created
it
is.
B
It
adds
everything
first
and
then
allows
you
to
delete
so
it's
kind
of
a
hacky
way,
but
I
can
add
and
then
check
if
I
can
shift
my
added
header
to
the
payload
or
the
header
of
the
jaw.
So
again
I
can
answer
a
lot.
I
can
answer
your
questions
a
lot
better
once
I
actually,
you
know,
compile
it
and
deploy
it.
If
that's
fine,
so
maybe
another
day
or
two
I'll
be
able
to
tell
you
and
give
feedback
on
the
performance
stuff.
A
Yeah
sounds
good,
so
it
sounds
like
all
of
the
headers
that
measure
is
able
to
pass
along
as
it
generates
load
like
what
are
those
that
you
need
to
send
along.
You
need
to
send
a
jot
that
contains
a
specific
you
know,
set
of
key
value
pairs.
B
So
the
key
value
pairs,
not
necessarily
so
again
like
the
filter
here,
the
point
is,
you
can
configure
it
right
so
that
json
that
I
showed
you
earlier
that
I
can
actually
mention.
So
I
could
say,
delete
plan
and
then,
ideally
from
that
jot
that
I
get
from
the
image
hub
or
whatever
I
guess
the
measuring
load
generator
sends.
I
could
delete
it.
B
So
again,
it
totally
depends
on
the
I
guess
kind
of
information
being
sent
and
that
I
can
generate
so
I
can
create
a
so
since
it's
a
pull
request
and
sorry,
since
it's
a
get
request
and
along
with
that
get
request,
you're
attaching
that
base64
encoded
jot,
I
can
put
in
any
jot.
I
want,
and
I
can
send
it
as
a
request.
If
it
will
come
up,
come
back
successfully.
B
That's
a
question
mark
because
then
the
application
you
know,
takes
a
look
at
that
and
says:
oh
wait!
This
is
not
what
I
expected,
but
other
than
that
I
can
actually
craft
that
from
what
I
can
see
and
I
can
send
it
so
again.
I
think
I'll
be
better
equipped
to
answer
that
in.
A
There,
too,
hey
good
so
thus
far,
it
sounds
like
mesh.
We
have
the
load,
generating
capabilities
has
what
you
need
to
be
able
to
test
it
out,
save
for
like
verification
after
the
app
has
like
as
processed
like
what
what's
been
modified.
So
you
should.
A
This
sending
in
packets,
the
filter
would
modify
it
pass
it
along
to
the
app
you'd
then
want
to
take
a
look
at
to
verify
that
that
modification
was
propagated
and
so
yeah
yeah.
That's
a
that's
an
air,
an
interesting
thing
for
like
an
interesting
use
case
for
us
to
be
aware
of
one
of
the
things
we
desire
for
mastery
to
be
able
to
do
is
to
like
is
to
do
such
testing
is
to
let
people
dry
run
a
config
change,
so
so
an
individual
like
samir
might
say
you
know
this
filter
is
great.
A
A
You
know
facilitating
testing
of
it
like
a
dry
run,
to
verify
that
his
change
has
the
effect
that
the
desired
effect,
so
so
some
some
amount
of
thought
as
you
go
to
test.
This
would
be
good
like
it
might
be
the
case
that
so
it's
one
of
the
things
that
messry
will
ultimately
be
able
to
do
is
to
yeah
right.
A
This
is
to
add,
to
be
able
to
configure
this
through
mesh
map,
one
to
samir's
point,
but
also
meshri
would
be
able
to
capture
traffic
and
replay
traffic
as
well,
and
so
like
in
the
testing
of
this
particular
use
case.
A
It
might
be
that
one
of
the
things
that
we
might
look
for
measuring
to
be
able
to
do
is
well
deploy
a
a
dummy
service
or
or
another
upstream
service
behind
the
initial
one,
so
that
measuring
can
capture
that
out
that
traffic
like
in
front
and
behind
the
app
so
things
to
kind
of
think
about
as
we
walk
through
this
use
case.
This
is
oh,
this
is
packing
capturing
and
okay
yeah.
One
of
the
things
is
packet,
capturing,
yeah,
yeah
and
then
potentially
replaying
as
well.
A
Another
thing
is
like
yeah:
it
might
not
be
packet
capturing
as
much
as
maybe
just
sending
some
telemetry
about.
A
Things
that
were
received
or
facilitating
like
having
a
dummy
service-
that's
a
utility
service.
That's
generally
held
instrumented
very
well
and
generally
helpful
for
using
meshri
to
view
the
output
of
that
transformation
like
if
a
filter
does
a
transformation
like
this
one.
Then
you
know
like
a
the
the
ability
to
test
the
changes.
The
ability
to
confirm
the
changes
could
come
in
different
ways:
traffic
capturing
and
replaying
in
general.
There's
a
number
of
use
cases
for
that
functionality
as
well.
So
so,
thanks
for
this,
this
is
good.
B
No,
no,
I
just
pushed
it
again.
Once
I
have
got
this
working
and
sort
of
locked
down,
I
will
push
a
pr
to
be
wasn't
into
the
truffle
yeah,
okay
cool,
I
okay,
I
guess
in
finishes
and
then
now
it's
fitting.
Then
I
guess
to
us.
E
E
So
I
this
isn't
really
a
completed
spec,
but
it
really
just
talks
about
what
the
different,
what
the
different
components
are
and
how
it
needs
to
be
fit
together.
So
this
design,
specs
talks
about,
wasn't
filters
supporting,
wasn't
filters
in
measuring,
so
we
recently
added
the
group
support
like
where
users
can
upload
their
voice
and
files
have
some
filter
files
to
measure
and
store
it,
but
we
don't
have.
We
can't
actually
deploy
this
filter
onto
their
service
mesh,
so
this
designs
pack
is
to
support
that
and
like
measuring
patterns.
E
The
this
needs
to
be
this
needs
to
this
needs
to
be
om,
compatible
or
b.
It
should
follow
the
om
specification,
which
means
that,
like
the
user
can
use
the
user,
define
their
filters
in
a
patent
file
and
then
use
that
pattern
file
and
apply
it
to
their
service
mesh
using
measuring.
So
that
should
work
and.
E
So,
as
lee
mentioned
at
the
beginning
of
this
meeting,
the
sto
service
mesh
has
a
has
an
envoy
custom
resource
so
that
basically
handles
these
these
filter
files
and
applies
it
and
all
the
stuff.
E
So
once
we
have
a
filter
file
uploaded
in
the
measuring
server
or
in
the
measuring
cloud,
if
that's
the
case,
so
if
the
user
has
a
filter
file,
then
based
on
our
discussion,
what
we
have
decided
to
do
is
that
mesherie
will
serve
these
filter
files
and
these
filter
files
can
be
accessed
by
the
the
on
vm
in
in
the
istio
steer
mesh.
And
then
it
will
pull
these
filter
files
and
apply
it,
and
that's
one
consideration.
Another
consideration
is
is
how
we
create
the
config
file.
E
So
gaurav
has
been
recently
working
on
adding
a
ui,
adding
this
in
the
ui
like
having
the
like,
allowing
the
user
to
specify
a
configuration
for
a
particular
filter
file.
So
it
will
be,
it
will
be
a
basically
a
form
which
will
have
some,
which
will
have
some
values
and
the
user
can
pass
in
these
values
and
it
will
be
sent
sent
to
the
service
mesh
along
with
the
filter
file.
E
So
so
the
actual,
so
the
form
should
be
dynamically
generated
and
the
the
actual
values
that
needs
to
be
part
of
the
form
can
be
fetched
from
the
istio's
onward
crd
and
we
need
to
like.
We
need
to
dynamically
generated
of
generator
form
based
on
these
data,
and
the
final
consideration
is
that,
as
I
mentioned
before,
like
we
need
so
these
filters
should
be
is
part
should
be
part
of
the
om
specification.
It
should
follow.
E
The
om
specification
and
a
user
can
basically
define
these
filters
in
their
pattern
files
and
their
associated
config
in
their
pattern
files
and
then
deploy
it
as
a
as
a
pattern
file
with
all
their
other
configuration
other
services
configurations
and
all
the
stuff
and
to
like
this.
These
are
some
high
level,
high
level
ideas
or
plan
of
actions
to
how
we
can
move
to
move
forward,
to
support
this
and
like
we
need
to.
E
We
need
to
figure
out
how
to
proceed
with
this,
like
what
what
should
be
a
next
step
so
so
for
the
first
first
first
thing
to
do
is
to
serve
the
pattern
file
and
it
should
be
like
luxury
server
should
we
should
serve
these
files
and
it
should
be
accessible
from
the
from
inside
there
on
one
by
vm
and
to
generate
the
custom
form
the
custom
configuration
form.
E
We
need
to
fetch
the
fetch,
the
those
the
schema
from
the
voice,
crb
and
then
yeah,
and
then
we
need
to
decide
how
we
will
represent
this
in
pattern
file.
So,
like
you
know,
I
showed
before
like
like
encoding
and
decoding
into
b64,
so
that
may
be.
That
may
be
a
way
to
go
from
here
and
yeah
so
so
like
what
I
need
is
I
need
to
like
see
if
this
is.
E
B
So
I
had
a
question
basically
so
you
mentioned
that
okay,
so
gaurav
has
been.
You
know
like
communicating
with
me,
and
you
know
how
to
exactly
create
that
dynamic
ui
form.
My
only
query
is,
if
so,
that
what
do
you
say
that
form
it's
using
react?
B
Json
schema,
I
think,
as
the
package
to
render
that
form
that
is
based
off
of
a
fixed
schema
that
I
have
given,
and
this
is
something
I
have
defined
and
like
okay,
if
you,
if
you
see
that
json,
it's
basically
the
name
of
the
path
and
then
the
rule
that
the
path
implements.
B
So
if
you
want
to
implement,
let's
say
rate
limiter
for
that
path,
you
would
write
rule
it
will
open
up
into
another
segment,
it
will
say,
rule
type
rate,
limiter
parameters,
blah
blah
blah
and
so
on.
So
that
is
a
that
is
something
I
have
defined,
and
that
is
something
I
was
fine.
This
would
definitely
be
like
you
know
sensible
as
of
now,
but
that
form
is
based
off
of
what
I
have
defined
now,
if,
let's
say
someone
wants
to
come
and
they
have,
they
want
to
define
their
own
custom
json.
B
The
only
option
I
am
seeing
is
to
allow
them
to
enter
the
the
raw
json
manually
and
then
save
it,
so
I
I
just
want
to
know.
I
just
wanted
to
bring
this
topic,
because
I
just
wanted
to
ask
if
there
was
a
way
to
handle
all
jason.
B
What
do
you
say
construction
without
like
as
a
form
like?
Does
that
even
make
sense-
and
I
just
wanted
to
bring
the
topic
so
like
is
what
I'm
saying?
Does
it
make
sense.
C
I
can
I
can
I
say
something
like
when
you
said
that
user
would
enter
their
own
json
for
like
schema.
I
I
didn't
exactly
get
it.
Why
would
a
user
need
to
enter
a
json
okay.
B
C
So,
okay,
let
me
just
understand
correctly,
are
you
talking
about
something
like
inline
code?
Sorry,
could
you.
B
So
you
have
your
yaml
editor
currently
that
pops
out
right.
So
when
I
meant
cust
entering
custom
code,
I
meant
something
like
that.
I'm
just
going
to
be
sending
a
link
on
chat.
Okay,
there's
a
lot
of
just
give
me
a
second
okay.
So
I
keep
bringing
up
this
pr
quite
a
bit,
but.
B
In
this
pr
over
here,
you
can
see
this
is
the
json
object
that
I
have
defined
now
I
have
said:
okay,
there's
going
to
be
a
path
name,
and
this
is
where
it's
entered.
There's
going
to
be
a
rule,
rule
function,
sorry,
a
rule
parameter
and
that's
going
to
have
what
do
you
say,
sub
parameters
in
within
it
and
that's
where
you
can
define
something
like
rule
type
rate
limiter,
let's
say
another
user
comes,
they
have
their
own.
B
What
do
you
say
filter
and
they
don't
want
they're,
not
interested
in
the
path
name
and
they're,
not
interested
in
the
rule
type
and
it
doesn't
suit
them.
So
how
now
why
that
would
matter
is
because
the
current
form
that's
being
generated
is
based
off
of
this
schema,
it's
based
off
of
how
I've
structured
this
json
and
to
make
it
dynamic
from
whatever
I
saw
in
that
packet.
B
Sorry
in
the
in
the
meeting
with
gaurav,
I
do
not
know
if
it's
very
straightforward,
so
all
I'm
saying
is
there
needs
to
be
thought
put
in,
because
people
might
not
want
this
format
for
their
thing
and
they
would
want
to
pass
their
own
json
their
own
custom
resource,
and
in
that
sense,
how
are
you
handling
the
form
is
what
I'm
saying
I
I
know
this
is
a
topic
for
a
later
day
here
and
it
can
be
covered
later,
but
if
the
idea
is
for
keeping
it
keeping
the
ui
generic
so
that
the
person
can
just
come
in
and
add
whatever
they
want,
how
does
that?
F
I
think
there
are
two
ways
of
doing
that:
one
is
you
know
it
just
not
have
a
a
ui
just
just
allow
the
person
to
edit
a
file
and
put
in
the
json.
E
F
F
F
I
mean
that
implies.
There
is
already
a
json
file,
you
know
so
so,
basically,
what
your.
C
B
So,
for
example,
like
oh,
the
perfect
example
would
be
my.
What
do
you
say?
Http
modifying
thing
right
so
currently
I
don't
have
any
path.
I
don't
have
any
rule
type.
I
just
have
this
add
header,
remove
delete
header
payload
to
header
header,
to
payload
that
sort
of
structure,
so
it's
completely
different
from
the
json
we
just
saw
now.
How
would
a
user
like?
Yes,
of
course,
you
know
the
user
entering
that,
as
is
fine,
as
is
as
a
json.
B
That
would
be
perfectly
there's
no
issues
whatsoever
with
that,
but
I'm
saying
if
the
ui
is
meant
to
you
know
make
it
easier
for
someone
to
do
this.
I
was
just
you
know,
opening
up
a
discussion
as
to
is
it
possible
to
handle
even
those
cases
where
you
know
you
have
some
ad
hoc
scheme
and
you
can
just
generate
what
is
adjacent
from
the
form
and
the
form
will
dynamically
populate
or
depending
on
what
sort
of
element
you
want
it
will.
C
C
B
So
that
standard
we
need
to
sort
of
polish
a
bit
more.
I
feel
because
we
would
need
to
incorporate
use
cases
like
what
I
just
said
so
the
current
standard.
It
assumes
that
there's
a
path
that
you
want
to
apply
the
filter
to
is
that
assumption
going
to
be
applicable
for
all
services?
Now,
that's
that,
that's
exactly
what
why
I
wanted
to
open
up
this
discussion,
so
the
standard
that
the
ui
is
currently
being
implemented
for
is
itself
not
a
standard.
F
I
think
you're
talking
about
something
like
intelligence
or
something
like
that.
You
know
so.
You
you'll
have
a
drop
down
with
possible
templates
where
you'll
be
able
to
define
your
own
format
on
the
go
right,
so
you'll
be
able
to
say,
choose
from
or
specify
one,
maybe
they'll.
F
C
Yeah,
so
I
wanted
to
actually
just
like
to
put
my
thoughts
on
this
one,
but
maybe
my
mic
was
not
working
earlier
so
like
coming
back
to
your
point,
which
you
said
for
now
that
if
user
wants
like,
if
a
user
is
using
some
different
filter
than
image
hub
and
if
it
has
a
different
json
schema
than
what
you
have
defined
in
that
pr,
there
can
be
two
things
that
we
can
do.
C
The
first
thing
is
that
when
we
fetch
that
filter
from
the
crd-
or
I
guess
wherever
we
are
fetching
that
filter
from
we
can
have
a
schema
already
attached
to
that
filter
somehow
so
that
we
can
just
pass
it
to
the
user
interface.
That
is
one
thing.
I
guess
that
we
can
do.
The
other
thing
that
we
can
do
is
that
if
you
are
just
giving
me
the
json,
that
is
in
the
pr
itself,
like
the
one
with
the
pull
rules,
rate,
limiter,
etc,
etc.
C
We
can
try
to
convert
this
into
the
schema
that
the
library
that
we
are
using
accepts
in
in
a
manner.
Those
are
the
two
things
that
we
can
do.
I
guess,
and.
B
So
so
you're
saying
that
there
should
be
another
drop
down
sort
that
will
let
you
select
the
schema.
You
want
to
generate
the
json
for.
B
B
A
Potentially,
let's
actually
make
it
easy
on
ourselves
and
agree
to
a
couple
of
things
initially
and
maybe
we'll
achieve
the
goal
of
of
a
purely
dynamic
configuration.
A
I
think
one
one
there's
an
assumption
that
the
configuration
that
would
be
given.
That's
that's
cost
the
custom
configuration
for
a
filter
that
it
would
be
in
json
is
an
assumption
as
it
may
not
be,
and
so
to
start
it
might
it
one.
We
should
clarify
on
a
couple
of
terms
and
then
two.
I
think
we
should
make
this
in
a
couple
of
phases.
A
Probably
so
correct
me
if
I'm
wrong,
but
actually
the
the
this
faq
here
may
help
in
our
the
language
that
we
use
or
the
discussions
that
we
have,
and
so
I
think,
there's
two
configurations
that
we're
concerned
with
one
of
those
is
a
configuration.
That's
service,
mesh,
specific
the
surface
mesh
that
you're
using
is
aware.
Well
may
or
may
not
be
aware
of
filters.
A
Its
control
plane
is
unaware
of
the
fact
that
there
is
or
is
not
such
filters
deployed,
but
to
the
extent
that
they
are
so
in
this
case,
istio
to
start
with
that
that
service
mesh
that
control
plane
will
be
will
have
it'll,
be
cognizant
of
the
fact
that
a
filter
is
present
or
isn't,
and
it
will
require
configuration
to
identify
which
proxies
in
the
data
plane
have
which
filters
and
so
for
that
service
mesh
there's
just
there
is
just
sort
of
a
generic
configuration.
A
A
The
second
type
you
know
needs
to
be
provided
to
which
filter,
and
so
the
second
type
of
configuration
is
well
one
of
the
examples
that
pranav
was
showing,
with
that's
specific
to
the
custom
filter
that
he's
writing
right
now
to
transform
jots,
and
so
it
just
so
happens
that
that
in
his
in
that
specific
filter,
it
expects
json
and
it
expects
it
using
key
value
pairs
to
identify
certain
and
do
do
whatever
it's
going
to
do.
A
That
is
something
that
I
would
suggest
that
we
we
like
critically
need
to
facilitate
for
to
capture
that
config
and
pass
it
along,
but
at
the
moment
I
think
would
be
remiss
to
jump
to
something
so
difficult
as
trying
to
a
enforce
that
that
config
is
always
in
json
b
that
we
can
dynamically
discern
what
input
types
are
most
appropriate
to
show
to
an
end
user.
It's
like
hey.
A
We
do
need
to
capture
for
both
if
we
remain,
if
measurey
remains
ignorant
of
the
specifics
of
a
given
filter's
configs,
I
think
that's,
okay,
to
start
with,
there
might
be
certain
filters
that
we
find
are
commonly
used
and
we're
heavily
invested
in,
and
so
maybe
we
provide
either
a
hard-coded.
You
know
improved
experience,
that's
visual
in
nature
or
whatever.
That
is,
let's
discuss
that
after
we're
successfully
deploying
filters
specific
to
a
mesh
capturing,
what
filters
should
go
on
what
you
know
against
what
service
or
against
what
proxies
passing
along
the
custom
config.
A
One
of
the
first
steps
that
we
can
take
is
in
the
mesher
ui
is
to
be
able
to
open
up
and
allow
users
to
edit
that
string
in
whatever
format
that
is
yaml
or
json
or
just
text,
and
then
in
istio's
case
it
expects
that
string,
I
think,
is
base64
encoded.
So
that
might
be
a
use
case
for
meshri
to
help
facilitate
on
the
user's
behalf
is
like
make
that
convenient,
so
you
don't
have
to
bring
in
other
tools.
B
A
E
What
what
about
the
like?
The
other
questions
I
had
like.
C
And
now
you
talked
about
the
custom
crd
for
envoy,
so
now
do
we
need
to
does
it
comes
under
the
istio
crd
or
it's
or
we
have
to
install
the
envoy
also.
E
You
know,
I
think
it's
it's
specific,
like
the
it's
with
with
this
to
you,
it
still
deploys
it.
The
android
thing
as
the
crt
okay,
okay,
be
like
like
how
how
will
a
user
define
it
in
pattern?
Friends
like.
D
Yes,
sir,
right
now,
if
we
talk
about
only
this
generic
different
generic
onward
filter,
so
in
that
case,
actually
it's
like
it's
a
comp.
It's
a
normal
pattern
file.
Just
in
the
settings
you
will
be
able
to
access
every
field
that
you
have
access
to.
You
know
you
know
in
this.
Basically
in
the
onward
filter,
spec
field,
initials
onward,
filter,
spec,.
D
Let
me
share
this
link
to
that,
so
I
think
for
the
generic
one
that
is,
and
that
is
when,
when
we
are
not
concerned
with
what
the
configuration
should
look
like,
I
think
that
would
just
work
fine,
but
for
the
one
that
is,
that
gets
specific
to
the
filter.
D
I'm
not
quite
sure
that
how
we'd
be
I'm,
I'm
not
even
sure
if
we
discussed
if
we
should
be
interested
in
discussing
it
right
now,
but
the
idea
was
that
we
can't
probably
create
multiple
resources,
that
is,
like
rate
limit,
filter
and
short
modifying
filters.
Something
like
that,
and
if
we
have
that,
then
I
think
that's
that
that
should
be
enough
to
get
a
dynamic
keyword
for
that.
D
Because
I
mean
it's
not
schema,
let's
try
to
try
to
expect
some
schema
it
to
have
and
that
schema
just
has
to
go
into
adjacent
schema.
That's
actually.
A
On
that
concept,
by
the
way
it
might
be
that
so
so
pranav
has
written
this
beautiful,
jot
transf
transformation,
filter
that
everyone
and
their
grandma
uses,
and
so
well,
maybe
that's
in
a
quote-unquote
official
filter
or
what
I
mean
to
say
is
to
utkarsh's
point
well
that
one's
been
around
been
round
long
enough.
A
D
A
So,
in
some
respects
in
the
venue,
in
answer
to
your
question,
the
way
in
which
users
will
describe
a
filter
and
capture
it
in
their
pattern,
file
should
be
relative.
I
mean,
should
be
relatively
straightforward.
I
would
imagine
that
there
needs
to
be
a
uri
like
an
http
endpoint
that
identifies
the
location
of
the
filter,
the
encoded
well
encoded,
or
not.
A
Just
like
the
the
custom,
the
string
for
the
any
custom
configuration
that
might
be
applied
to
the
filter,
which
I
expect
could
be
empty
in
some
cases,
part
of
it
will
be
like
it
to
navindu's.
Question
is
like
well,
it
might
be
that
you
have
you're
describing
an
application
in
your
pattern
file,
and
maybe
the
application
is
comprised
of
six
services
well,
but
it
turns
out,
like
only
the
first
service
needs
to
have
this
jot
transformation
filter
and
the
other
four
or
five
should
have
some
other
telemetry
filter.
A
Something
like
that
that,
inside
the
pattern
file,
if
you,
if
you
use
your
imagination,
to
think
about
a
a
kubernetes
manifest
or
a
docker
compose
file,
probably
more
like
a
docker
compose
file
that
that's
kind
of
the
same
experience
that
someone
would
have
in
designing
their
pattern
file.
They
would
have
under
each
service
under
each
section
that
describes
the
six
services
that
that
section.
You
know
if
it
was
applicable.
B
Yeah,
my
grandmom
can
only
use
a
keyboard
phone,
so
I
don't
think
it's
so
long.
I'm.
A
E
Yeah
and
another
thing
is
like
the
for
the
first
point
like
we
can
like
we,
we
we
will
serve
the
filter
file
in
measuring
right,
like
will
it
be
stored
in
measuring
or
in
measuring
cloud
and.
A
Yeah,
that's
a
great
question
so
so,
where
what
line
item
are
we
on?
I
should
just
take
a
quick
note
here.
A
A
A
I
think,
as
utkar
shares
kind
of
the
the
current
definition
of
how
to
describe
a
filter
in
a
pattern
file
that,
irrespective
that
that
pattern
file
and
that
custom
configuration
and
the
filter
itself,
the
binary
itself
like
they
need
to
be
persisted
somewhere
and
they
need
to
be
made
available
as
well
like
by
made
available
like
when
the
proxy
spins
up
and
it
is
to
be
or
or
it's
sitting
there
spinning
and
it's
actively
serving
traffic
to
its
side
card
application
and
the
control
plane
for
that
proxy
says.
A
Well,
it's
time
for
you
to
receive
a
filter
well
and
so
here's
the
location
of
that
filter.
It's
like
well,
okay,
that
one
one
that
filter
needs
to
be.
You
know
the
network
connectivity
needs
to
be
guaranteed
that
it
can.
You
know
that
filter
can
be
accessed
and
that's
usually
like
probably
the
control
plane
itself
is
the
one
that
needs
to
be
able
to
access
where
the
filters
are
so
it
can
pull
it
and
then
pass
it
along
to
the
data
plane
proxy
generally.
A
That
would
be
what
I
would
expect
that
most
of
the
service
meshes
would
do,
and
so
it's
like
okay.
Well,
where
are
the
filters?
Where
are
they
being
loaded
and
where
they
where's
the
configuration
available?
Well
in
meshri,
so
meshri
you
load
up
your
performance
profiles,
your
profile,
your
test
results,
your
pattern,
files,
your
filter,
binaries,
your
filter,
config,
good
measuring,
becomes
like
the
the
title
of
this
dot.
Well,
I
don't
know
if
it's
this
dock,
but
but
the
title
of
the
other
dock
is
called
filter
hub.
A
It's
like
well
well
as
measury
servers
measure
that
filter
hub.
Maybe
maybe
not
you
know,
I
think
we
sort
of
jumped
the
I
jumped
the
gun
on
sort
of
using
the
term
filter
hub,
mostly
because
it
was.
I
was
trying
to
genericize
image
hub
and
other
things,
but
yeah.
So
the
answer
here
is
a
mystery
server
and
whether
someone
is
using
a
local
provider
or
a
remote
provider,
persistence
in
how
persistence
is
done
would
be
handled
the
same
like
so
yep.
A
A
The
individuals
that
are
using
that
mesh
reservoir
may
be
using
a
local
provider
or
remote
provider
either
way
measuring
server
needs
to
make
its
artifacts
the
filter
binary
available,
and
so
the
way
that
this
a
lot
of
this
operates
today,
so
so
navindu
is
doing
a
good
job
of
calling
out
that
this
flow
in
number
one
is
slightly
divergent
from
the
general
flow
by
the
way
in
which
mescheri
generally
propagates
instructions
and
invokes
operations
like
invokes
configuration
on
a
service
mesh
control
plane.
A
Part
of
that
in
this
case
will
be
handing
over
an
artifact
and
depending
upon
how
that
control
plane
likes
to
receive
the
artifact
or
come
get
the
artifact.
In
this
case
it
probably
likes
to
come.
Get
the
artifact
measuring
needs
to
make
sure
the
artifact
is
available
over
http,
and
so
mastery
is
sitting
there
as
a
server.
It's
ready
to
serve
those
artifacts
meshri
becomes
an
artifact
repository
in
this
particular
case,
and
there
are
other
use
cases
from
for
meschery
or
measuring
cloud,
the
local
provider
or
the
remote
provider
to
be
that
artifact
repository.
A
Does
that
help?
So
so
if
the
user
is
using
a
remote
provider,
meshery
cloud
if
they've
signed
into
meshre
cloud
becomes
probably
that
artifact
repository.
We
need
to
expand
on
this
and
have
a
couple
of
sequence
diagrams,
a
couple
of
flows,
so
we
understand
whether
or
not
network
connectivity
would
always
be
facilitated.
We
need
to
you
know,
guarantee
that
it
is.
A
E
Yeah,
that's
it
like
that
was
good
since,
like
I
have
something
to
go,
look
into
and
operate
upon,
so
I
guess
we
will
be
in
the
next
meeting
by
the
next
painting.
We
will
have
something
more
concrete
in
this,
and
maybe
we
can
even
start
working.
A
A
A
Map
vendor
sounds
like
an
iteration
on
the
spec
in
terms
of
like
artifact
serving
it's,
probably
one
part
of
that.
The
other
part
is
like.
We
should
be
taking
this
initial
jot,
the
the
jot
transformer
9000
and
and
using
it
as
probably
an
example
within
the
pattern
file
for.
A
So
anyway
help
me
so
I'm
I'm
here.
I
can
just
dish
out
the
action
items
all
day
long
so
anyway,
if
you
guys
want
to
write
down
some
of
the
things
that-
and
so
you
know
for
samir,
it
might
be
that
assuming
that
that
he
might
be
able
to
to
test
out
the
filter
in
in
one
of
his
environments,
potentially
and
so.
A
On
measuring
ctl,
so
the
there
in
concept
there
may
not
be
any
changes
necessary
so
long
as
the
custom
configuration
is
captured
inside
the
pattern
file.
So
it
might
just
be
more
about
testing.
A
A
A
Cool
and
then
since
I
just
verbalized
those
I
won't
make,
everybody
hang
out
to
watch
me
write
them
down,
but
anyone
have
anything
else
before
we
wrap
up.
A
Does
anyone
think
you
know
so
pl,
please
do
give
for
all
of
you
that
are
here
like
give
this
some
consideration?
Are
there
yeah
we've
we've
been
loose
on
painting
a
high
level
vision
for
like,
like
the
thing
that
novendi
was
asking
is
like
part
of
that
high
level
vision
like
is
so
it
sounds
like
meshri
server
might
become
something
of
a
filter
hub.
A
C
A
Cool
okay,
we're
five
after
so
it's
time,
navendu
and
pranav.
Samir
thanks,
guys,
we'll
hear
more
from
garav
and
soham
next
week.
I
think
thank
you.
Yeah.