►
From YouTube: WebAssembly Filters Meeting (Nov 15th, 2021)
Description
WebAssembly Filters Meeting - November 15th, 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
So
we
are
only
two
minutes
after
let's,
I
think
lead
beach
running
quite
late.
Ellen
is
not
in
the
meeting.
Yet
nothing
would
you
mind
if
you,
if
we
start
from
your
topic,
okay
here
so
probably.
B
Oh,
very
good,
oh
good!
Well
we're
up
to
the
first
topic
already.
I
thought
you
were
all
right,
very
good.
So
so,
let's,
let's
jump
in
there
is
two
considerations
around
the
seating
of
content
in
providers
so
his
so
she
shares
with
us
good
he's
done
a
fair
bit
of
work
here
on
the
local
provider
and
so
yeah.
B
If
utkarsh,
if
you
don't
mind,
if
you
open
up
that
design,
spec
or
or
I
can
share,
if
it's
more
convenient
either
way,
there
is,
can
you
do
me
a
favor
and
that
related
box,
the
gray
table
at
the
top
there
yep?
It's
got
a
link
in
there
yeah.
If
you
would
go
to
that
link
as
well?
B
Okay,
so
so
we
have
two,
you
know
different
types
of
providers
with
meshri,
and
so
this
this
doc
is
talking
about
the
local
provider
and
how
the
local
provider
deals
with
content
and
how
to
get
that
content
to
users
quickly,
and
we
want
to
do
that
because
so
that
way,
users
can
you
know
the
time
to
value
in
using
measuring
is
fast
like
it
comes
with
this
seed.
It
comes
with
content
that
is
preceded.
B
Now
there
are
two
types,
just
as
a
refresher
for
all
of
us
who've.
You
know
looked
at
this
in
the
past
or
who
haven't
looked
at
it
yet
there's
you
know
more
or
less
what
we
consider
two
types
of
content:
I'm
sorry,
there's
three
types
of
content
patterns,
service,
mesh
patterns,
webassembly
filters
and
kubernetes
applications
of
those
three
types:
those
can
be
produced
by
either
individual
users
who
go
to
import
that
content
or
by
produced
by
the
provider
or
by
the
community
and
so
user
produced
or
provider-produced.
B
So
in
the
event
of
provider,
produced
content,
which
is
to
say,
the
provider-produced
content
that
we
have
today
is
primarily
in
the
it
comes
in
three
forms,
so
we
said
filters
patterns
applications,
but
but
where
those
three
forms
are
located
where
they're
stored
is
github,
github
get
up
our
individual
github
repos
so
for
web
assembly
filters,
it's
awesome
filters,
surface
mesh
patterns,
there's
service,
mesh
patterns,
repo
and
then
the
applications
as
we
have
them
under
mesh
ops,
v1,
which
is
to
say
the
non-pattern
format.
B
These
applications
are
stored
in
each
individual,
meshri
adapter
and
that
that
is
because,
historically,
it's
been
because
the
adapters
have
been
considered
a
delivery
mechanism
of
a
venue
for
a
vehicle
for
delivering
things
like
sample
apps.
The
apps
have
been
sometimes
there's
specific
service
mesh,
specific
consideration.
That
needs
to
be
done
for
when
you
deploy
an
app
as
we
move
forward.
B
I
wonder
if
that
will
continue
to
be
the
case
if
there,
if
we
will
continue
to
have
well,
certainly
individual
service
meshes
function
differently
and
will
need
to
have
different
considerations
made
as
you
onboard
an
app.
B
B
B
A
Actually,
one
of
the
advantages
of
keeping
these
application
sample
application
or
any
application
with
adapters
is
that
basically
that
case
where
adapter
is
not
present,
while
the
artwork?
So
let's
say
our
application
relies
on
a
component
which
depends
on
is
this:
is
the
adapter,
so
measuring
server
needs?
Is
the
adapter
to
perform
that
operation
it
has
that
listed
in
there?
You
would
try
to.
You
would
try
to
invoke
that
operation.
Obviously,
nothing
would
go
wrong
with
infrastructure,
because
we
have
designed
stuff
like
that.
A
We
will
stop
the
operation
beforehand,
because
we
know
that
that
thing
is
not
available,
but
if
you
would,
if
you
would
keep
these
sample
apps
or
any
application
in
the
in
the
adapters,
then
if
the
adapter
is
not
present,
then
there
is
no
registration.
If
there
is
no
registration,
we
don't
show
that
thing
to
the
user.
That's
that's!
Actually,
one
of
the
advantage.
The
disadvantage
is
that
you'll
have
to
build
something
on
new
interrupters
just
so
that
they
can
start
registering.
B
C
Right
now,
last
time,
when
we
had
a
discussion
about
this,
one
of
the
one
of
the
considerations
were
that
we
packaged
this
with
the
server
and
when
the
adapters
registered
their
capabilities
at
the
server
side.
We
know
that
these
are
the.
These
are
the
basically
the
applications
that
we
have,
and
these
are
the
applications
that
we
can
actually
deploy
or
support.
C
So
one
point
of
discussion
was
what,
if
we
show
all
of
them
to
the
user,
but
we
gray
out
the
ones
that
we
cannot
support,
so
we
have,
and
basically
like
utkar,
said,
adapter
tells
the
message
server
that
these
are
the
registered.
These
are
the
things
that
I
can
handle,
so
seven
can
differentiate
between
two
types
of
applications,
the
one
it
has
and
the
one
it
can
support.
B
You
took
the
words
out
of
my
mouth,
so
the
question
becomes:
how
much
of
an
effort
is
that
and
how
confident
are
we
about
that?
We
should
be
pretty
confident
about
the
ability
to
determine
whether
or
not
a
given
application
is
operable
at
the
moment
that
someone
requests
the
list
of
applications.
We
should
be
able
to
invoke
the
same,
dag
or
the
same.
A
Actually
now
now
machine
server
has
dryer
and
built
into
it,
so
you
can
try
it
in
your
pattern.
It
will.
It
won't
do
anything
in
your
infrastructure.
It
will
just
check
if
that
pattern
will
actually
go
through.
So
probably
we
can't
just
use
that
to
create
out
stuff
that
this
pattern
is
not
going
to
go
through.
B
Yeah
a
little
bit
of
it
yeah
that
sounds
pretty
good.
There's
there's
a
bit
that
concerns
me
that
it
it's
just
more
refactoring
for
us
and
whereas
users
don't
really
care,
I
mean,
which
is
to
say
like
yeah.
We
just
keep
we're
building
a
better
internal
system,
ultimately
like
yeah.
This
does
have
a
direct
user
experience.
It
is
nice,
but
what
I
mean
to
say
is
and
it'll
be
it'll
be
a
little
bit
of
effort
and
it's
just
refactoring
the
refactoring
being
to
stop
shipping
sample
apps
in
patterns
and
to
start
doing
it
centrally.
B
Hold
on
to
that
thought,
there's
a
consideration
a
little
bit
later.
That
I
think
will
has
a
ramifica
has
a
an
effect
on
on
where
we're
loading
patterns
for
applications
from
so
so
for
now.
Okay,
good!
So
give
this
a
helpful
refresher.
This
is
you
know
the
the
content.
That's
there
in
the
local
provider.
It's
the
files
are
bundled
into
the
image
the
container
image
when
the
server
boots
it
runs.
It
does
a
boot.
B
You
know
an
initialization
process
to
source
the
files
source,
the
content,
so
so
the
actual
storage
of
the
files
and
getting
them
into
a
place.
That's
available!
That's
one
consideration
and
that's
separate
from
the
routine
of
automating
the
import.
B
So
bear
that
in
mind.
Now
the
nice
thing
about
building
that
content
into
the
container
image
for
the
local
provider
that
helps
with
air
gap
deployments,
because
that
content
is
just
present
and
available.
B
For
the
remote
provider
that
we'll
talk
about
that
in
a
minute,
we
do
want
to
be
concerned
with
versioning
the
content.
Ultimately,
if
people
make
changes
to
a
pattern
and
they
want
to
keep
an
older
version
of
it
or
an
older
version
of
their
filter,
eventually
facilitate
for
that.
B
Okay,
so
that's
the
state
of
the
local
provider
content,
that's
seated
in
the
local
provider
today,
if
we
go
over
to
the
other
dock
for
the
remote
provider
and
if
we
skip
over
the
sequence
diagram
for
the
moment,
there's
a
couple
of
considerations:
the
remote
provider
is
deployed
separately.
B
B
That's
not
the
only
way
to
notify,
and
so
when
we
talk
about
potentially
moving
applications
around
moving
where
they
sit
around.
B
B
The
provider
does
need
ideally
determines
whether
or
not
content
is
novel.
We
don't
want
to
have
a
bunch
of
duplicative
listings
of
the
same
filters
like
10
times
over
rather
as
content
is
imported,
whether
it's
seed,
content
or
otherwise.
B
B
To
figure
out,
if
it's
the
same
piece
of
content
and
it's
the
same
version,
it
would
use
the
location
if
it
finds
a
matching
location
of
a
pre-existing
record,
then
it
would
look
to
that
file's
git
sha.
If
it's
the
same
git
shop,
then
it's
this.
It's
a
do,
duplicate
piece
of
content.
Don't
don't
import
it
don't
do
anything
doesn't
need
to.
It
already
has
that
file
if
it's
the
same
location
but
there's
a
new
git
shop,
then
it's
the
same.
It's
just
a
new
version
of
the
the
existing
piece
of
content.
B
A
So
because
we
are
relying
on
git
sha,
that
means
that
we
would
be
only
importing
from
github
or
any
remote
repository.
B
B
So
hashing,
instead
of
doing
it
using
the
git
shot,
might
be
a
better
determinant
of
whether
or
not
this
is
the
same
file
or
as
a
different.
B
You
know
different
file,
a
new
version
of
I'm
sorry
whether
or
not
this
is
the
same
file
or
a
different
version
of
the
same
file,
because
yeah
even
then
like
this
isn't
foolproof.
It's
like
well,
if
a
user
imports
a
piece
of
content
from
their
documents,
folder
and
then
just
moves
that
piece
of
content
to
their
desktop
and
imports
from
there.
It's
like.
Oh
that
looks
like
a
new
file,
because
it's.
E
B
New
location,
a
new
local
path,
location,
and
so
it
will
be
treated
as
such
and
and
I
think
that
that's
reasonable
generally.
B
B
So
this
is
a
little
bit
of
a
brain
tease
some
some
of
these
questions
so
good
to
introduce
on
the
call.
Maybe
we
wouldn't
make
it
to
the
end
part
of
what.
A
Yeah,
actually
so
it's
just
one
thing
that
is
is
about
it's
a
content
that
we
are
going
to
import.
We
also
had
plans
to
enforce
pattern
id,
so
we
can
use
so
just
like
npm
registry
or
git
tags.
If
this
doesn't
changes,
then
it's
not,
and
if
you
change
this,
then
we
consider
it
as
an
update.
If
you
don't,
then
we
don't
consider
it
as
an
it
has
an
update
and
we
refuse
to
basically
update
that
thing.
So
probably
this
is
something
that
we
can
use
without
going
down.
F
B
So
one
other
area
of
concern
for
measuring
cloud
is
ownership
and
access
in
the
local
provider.
It's
just
assumed
that
everyone
has.
You
know
the
user
has
access
to
everything
in
measuring
cloud,
there'll,
be
ownership
and
access
concerns,
and
so
that's
probably
good
for
us
to
review
that
that
proposal
isn't
written
up
yet
so
probably
good
to
review
later.
B
But
I,
but
I
think
this
is
a
good,
a
healthy
review,
there's
a
good
step
forward,
a
little
bit
different
than
what
was
proposed
previously
this
the
current
proposal,
I
think,
comes
with
some
caveats,
so
one
it's
kind
of
tied
to
github
at
the
moment
like
git,
which
you
know
it's
probably
not.
It's
probably
not
good,
two,
it's
kind
of
tied.
It's
also
it's
tied
to
that
for
both
versioning
and
also
for
notification
of
when
there's
a
new
piece
of
content
and
so
now
granted.
B
We
are
just
talking
about
seed
content,
so
we
should
clarify
that
when
we
say
well,
a
user
might
import
a
new
piece
of
content.
It's
like,
yes,
is
that
of
a
concern
in
this
discussion.
Well
yeah.
It
is
because,
to
the
extent
that
you
use
the
same
routines
for
importing
speed,
content
versus
content
later
on,
you'd
want
to
use
the
same
routines
or
portions
of
the
same
routines
and
so
yeah.
B
B
So
this
is
this
is
good,
so
I
I
think
that,
with
this
discussion
I
know
that
there's
three
or
more
of
you
on
the
call
who
will
have
comments
and
things
to
iterate
on
to
help
advance
the
thought
ashish.
I
would
like
to
see
what
it
would
take
to
do
that
invoke.
That
dry
run
to
basically
augment
the
behavior
of
the
read,
like
the
end
point
for
reading
an
application
for
reading
a
fo,
a
pattern.
B
Need
would
need
to
be
updated
to
include
the
dry
run,
a
dry
run
assessment
so
that
when
we
go
to
display
that
content
in
the
ui
a
flag
can
be
set
to.
Let
people
know
that
this
is
available
for
this
is
available
in
your
system.
But
it's
operationally
dysfunctional
or
it's
available
in
your
system,
and
you
can
go
ahead
and
deploy
it.
A
One
more
thing
probably
we
can
consider
is
that,
because
dry
running
is
very
cheap,
it's
it
takes
few
milliseconds
very
few.
So,
just
when
stuff
comes
under
the
ui
hit
the
and
also
we
ensure
that
at
ma
hit
max,
you
would
be
able
to
access
only
25
items.
So
that's
also
one
thing,
so
you
can
just
quickly
hit
the
end
point
25
times,
maybe
and
gray
out,
just
right
there,
so
it
won't
actually
take
up.
A
B
Yeah
yeah
the
thing
about
it
is
yep
I
mean
I
don't
know
why
you
would
what
the
justification
for
doing
that
versus
doing
it
back
in
where
you
don't
make
all
those
calls
and
all
you're
doing
is
annotating
whether
or
not
it's
available
or
not.
B
A
Because
we
raised
with
thousands
of
confidence,
so
basically
it
would
be
even
based.
So
if
there
are
thousands
of
confidence
every
time
something
new
gets
registered,
we
are
anyhow
running.
Try
run
to
see
if
now
the
not
that
particular
file
is
valid
or
not,
so
it
would
be
far
more
calls
as
compared
to
doing
it
only
when
the
user
actually
needs
it
so
sort
of
doing
it
in
a
lazy
way,
because
actually
the
confidence
rates
are
way
too
many.
B
Yeah,
well,
no,
what
I
mean
is
like
when,
when
someone
does
a
read
to
pull
up
the,
they
do
a
read
on
the
end
point
to
pull
up
25
records
of.
B
Seems
yeah
and
that's
a
good
ux
improvement
all
around.
Irrespective
of
the
question
about
where
applications
are
sourced
from.
C
E
A
It's
more
than
exciting
and
then,
if
you
want
to
talk
about,
wasn't
filtered
scattered.
B
And
that
question
was
for
alan,
so
alan,
if
you're
on
your
topic
is
up.
A
Let's
move
on
to
the
next
item,
so
ireland
fixes
his
audio
issue.
I
think
probably
that's
the
issue
so
navindu.
I
think
you
are
up.
G
Thank
you.
So
this
topic
is
on
updating
filters
ui
to
support
a
binary
plus
configuration
apply.
G
So
I
guess
me
and
discussed
about
this
a
bit
and
one
of
the
fixes
for
this
was
made
in
the
missouri
provider
and
the
pr
is
linked
there
and
yeah,
and
we
just
wanted
to
point
out
the
areas
that
we
need
to
work
on.
So
from
a
high
level,
we
need
to
add
support
for
persisting,
filter
configuration
and
as
like,
with
the
discussion
with
utkarsh,
as
utkers
mentions
in
that
particular
pr,
we
can
handle
the
filter
configuration
with
the
wasn't
binary
itself
so
yep.
G
That
is
one
one
thing
that
we
we
have
decided
and-
and
we
also
have
an
endpoint
in
measuring
current
measuring
server.
Currently
that
serves
the
filter
file.
So
one
of
the
another
issue
here
is
that
this
file
like,
if,
if
we
are
behind
a
provider,
then
it
will
be
behind
a
layer
of
authentication.
So
we
need
to
make
sure
that
the
the
on
the
on
onway
vm
can
actually
pull
these
awesome
files
that
is
stored
in
measuring.
G
So
that
is
a
concern
and
guess,
like
we
have
to
decide.
We
have
to
look
into
how
we
can
handle
it
yep,
so
I
just
wanted
to
address
these
concerns.
As
we
go
on
to
add
configuration
for
washing
filters
in
measuring
and
utkar
anything
else.
You
would
like
to
add
yeah.
A
Just
I
think
we
are
already
good
with
so
actually
in
video
today
fixed.
We
had
some
issue
with
uploading.
Actually
it
was
working,
but
we
had
some
internal
issues
with
uploading
binaries
and
having
to
actually
today
fix
it
fix
it
in
measure
cloud.
So
now
that's
done.
We
I
and
lee
were
on
call
and
we
discussed
about
how
we
can
actually
go
about
persisting
quantum
files
along
with
horizon
boundaries,
and
I
think
we
sort
of
concluded
that
just
right
now,
what
we
do
is
we
actually
persist.
A
Just
wasn't
binaries
in
our
cloud
or
in
any
provider.
Alongside
that,
we
can
actually
start
persisting
config
files
as
well,
for
that
particular
binary,
and
this
will
act
as
a
default.
This
will
act
as
default
values
for
that
particular
filter,
which
would
be
overrideable,
probably
in
the
ui.
This
is
one
of
the
thing
that
we
actually
discussed
earlier.
The
thing
that
namindo
was
talking
about
the
authorization
issue
with
the
odyssey
issue
that
we
would
actually
face
right
now.
A
We
have
right
now,
if
you
are
uploading,
your
content
to
a
provider,
it's
behind
an
authorization
wall,
so
that
only
the
uploader
can
actually
access
it.
We
also
have
concept
for
infinite
tokens,
infinite
lifetime
tokens,
but
they
are
sort
of
restricted.
Only
only
certain
accounts
can
actually
create
them
or
destroy
them.
A
So
this
is
a
concern
that
we
have
to
probably
deal
with
in
the
future,
because
what
we
need
actually
is
the
ability
to
is
the
ability
to
create
endpoints
which
are
accessible
for
the
user,
but
this
end
endpoint
should
be,
would
be
actually
accessed
on
behalf
of
user
by
on
vm
and
it
actually,
if
it's
just
your
sd,
is
the
one
which
is
actually
going
to
make
the
call
onward
passes
drawn
to
istio.
So,
basically,
we
need
a
construct
which
allows
to
do
that.
A
This
is
of
concern
that
we
have
to
deal
with,
so
that's
actually
pretty
much
it.
We,
as
I
think
we
also
talked
about
a
little
bit
earlier
right
now.
We
don't
have
a
specification
as
it's
written.
This
is
something
that
we
are
still
considering.
B
Yeah
yeah,
if
you
would
go,
go
back
to
the
the
having
a
separate
file
for
config,
speak
a
bit
more
as
a
refresher
of
my
memory
and
then
how
we,
what
what
you
think
the
ux
would
be
like
yeah
someone
goes
to
either.
Do
it
from
your
ctl,
maybe
from
the
ui.
A
Okay,
actually,
okay,
so
just
for
a
refresher.
Actually,
what
we
discussed
was
about
the
providers
not
exactly
the
flying,
but
we
sort
of
also
talked
about
how
the
probably
the
ux
could
be
like
it
was
that
that
the
default
config,
the
config
file,
the
filter
file
along
with
version,
will
be
stored
on
provider
in
terms
of
a
ui.
What
we
can
do
is
the
edit
button
that
you
were
actually
talking
about.
A
We
talked
about
on
the
call,
also
that,
instead
of
right
now,
if,
if
anyone
remembers
in
the
call,
we
demoed
it
a
previous
week,
it
was
allowing
you
to
edit
by
the
binary,
which,
probably
you
don't
want
to
create
it.
You
want
to
edit
the
file
and
that's
what
you'd
be
able
to
edit.
This
is
the
file
which
is
actually
attached
to
the
wasm
binary
and
saved
alongside
that
particular
binary
in
the
provider.
A
G
Yeah,
yes,
I
guess
so
yeah
or
or
like
in
the
configuration
file
like
we
actually
point
to
the
the
url
of
the
awesome
binary
that
is
stored
in
measuring
server.
B
A
Actually,
local
reference
is
also
something
that
we
I
mean
that
this
is
something
also
we
have
to
discuss,
and
probably
that's
what
navindi
was
also
preaching
to,
and
that
is
what
we
want
is
that
if
you
have,
if
you
are
dealing
with
mystery
as
content
manager,
then
what
you
should
be
able
to
do
is
just
refer
a
unique
identifier
of
your
of
your
content
and
which
you
would
be
able
to
figure
it
out.
I
think
that's
what.
B
If
you're,
referring
to
that,
particular
that,
if
you're
referring
to
that
particular
content
in
this
case,
the
filter
that
you
would
be
you'd
specify
its
id
in
your
query
string
and
if
your
and
measuring
server
would
determine
whether
or
not
you're
a
measure,
ui
user
or
a
mastery
ctl
user,
and
respond
to
you
accordingly,
with
a
local
reference
versus
something
separate.
B
Maybe,
although
we'll
probably
get
ourselves
into
like
that,
would
work
for
the
ui
kind
of
right
now.
Only
because
it's
bundled
into
mesherie
server.
It's
not
just
because
it's
bundled
in
like
you
could
also
base
it
on
authentication
or
authorization
of
whether
or
not
the
user
is
also
passing
along
a
job.
So
for
message.
B
Ctl
and
measure
ui
like
using
a
jot
based
determination
of
that
or
a
token-based
determination
of
that
would
probably
work,
and
there
would
be
some
nice
intelligence
there,
although
sometimes
people
are
going
to
want
to
like
retrieve
that
public-facing
url
anyway,
for
whatever
reason
so
yeah
we're,
probably
like
like
the
thing
is,
is
like
the.
B
This
doing
that
also
negates,
and
currently
we
don't
support
it,
but
it
also
negates
the
ability
to
import
a
filter,
but
really
just
import
the
record
of
it,
not
the
actual
binary,
so
that
the
record
of
it
can
be
there.
Even
though
it's
pointing
to
a
remotely
persisted
filter
right
now,
that's
not
something
that
we
support,
and
maybe
it's
not
something
that
we
would
never
support.
B
But
so
so
I
don't
know
being
clever.
There
may
not
help
us
like
adding
another
attribute
called
public
url
while
simpler.
B
C
Yeah
so
ux
for
filters,
ui
handling
the
smp,
let's
configure
it.
So
I
have
one
work
on
this
item.
Yet
I'm
actually
working
on
test
and
upload
deletion
like
card
operation
for
patterns
with
cypress,
probably
second
one.
B
So
where
say
it
again,
I
don't
understand.
C
C
So
mario
is
also
there
like
yeah,
so
probably
we
are
doing
it
together,
so
I
just
I
just
had
no
knowledge
about
cyprus.
That's
why
I
was
learning
and
testing
up
things
so.
B
C
So
it's
it's
still
it's
according
my
local
system.
I
know
yeah
but
hoping
to
open
it
by
tomorrow.
So
it's
it's
not
for
watsonville!
That's!
Actually
it's
for
patterns
is
what
I'm
working
on
right
now,
like
so
yeah,
so
on
a
window
added
like
any
of
the
configuration
pattern,
filters
or
applications
can
be
tested.
So
I
just
started
with
patterns,
since
most
of
the
things
are
like
yeah
having
good
functionality
like
all
the
buttons.
Are,
you
know
as
expected,
so
for
that
reason.
B
Mario
is
this:
have
you
given
much
thought
on
in
this
area?
I
know
it
hasn't
been
long
since
we
last
spoke
about
it,
but
does
what
abi
is
saying
ring
a
bell.
H
Yes,
yes
sure
so
currently
recently
I
finished
during
the
my
local
environment,
so
I'm
taking
a
look
specifically
at
the
configuring.
You
know
this
there's
a
guide
for
for
this
functionality,
so
I'm
just
going
over
it
to
see
you
get
more
familiar
with.
What's
the
expected
condition,
oh,
we
have
a
lot
of
file
and
uploads
fine
right.
So
I
think
it's
it's
pretty
straightforward.
I
don't
see
a
lot
of
difference
between
like,
at
least
on
the
test
perspective,
adding
a
pattern
versus
adding
a
filter
versus
adding.
H
I'm
I'm
going
to
do
some
actual.
You
know
using
the
ui
both
manually
and
with
cypress
and
to
inspect.
H
You
know
if
there's
specific
requests
you
know,
and
what
I
see
about
the
issue
is
that
we're
expected
to
do
integration
tests
so
just
to
clarify
this
means
that
the
test
would
we
would
make
cypress
intercept
request
to
the
back-end
and
we
would
we
we
need
to
mark
or
or
not,
only
intercept
to
listen
to
them,
but
also
to
supply
like
a
specific
payload.
You
know,
like
that's
part
of
the
integration.
H
Like
testing
we
do
at
this
level,
there
are
endurance,
but
at
least
in
the
issue
I
don't
see
this
is
included.
Is
this
correct?
Like
I
mean.
B
Yeah,
I
think,
for
the
as
a
good
starting
point
yeah.
I
think
for
the
moment
that,
like
if,
if
the
integration
test
that's
being
performed
is
to
upload
a
file,
then
yep,
then
then
you're
about
right
that
that
it
would
be
just
testing
the
ui.
I
mean
be
testing
the
ui
and
the
measuring
server,
but
that
it
is
possible
for
people
yeah,
yeah
yeah,
it's
it's
possible
for
users
to
use
the
cli
meshery
ctl
to
also
import
a
content,
a
filter
or
a
pattern.
B
But
but
in
terms
of
cyprus,
by
the
way
does
cyprus,
like
I'm,
assuming
that's,
not
a
great
fit
for
cyprus
as
a
tool.
F
Is
that
right
in
what.
H
F
H
Like
if
you
like
well
not
by
default
of
course,
there's
a
certain
task,
we
can,
we
can
invoke
specific
code
that
will
will
run
in
a
node
environment.
H
So
we
would
need
to
configure
that,
of
course,
it's
it's
part
of
like
cyprus,
functionality
either,
there's
something
that
we
need
to
configure
like
before
running
tests
or
or
we
need
to
invoke
like
an
os
level
piece
of
code,
maybe
some
something
we
need
to
trigger,
and
it's
not
like
from
the
ui.
There
are
ways
of
doing
that:
they're,
not
straightforward,
because
you
know
the
tools
are
different
and
cypress
exposes
different
ways
of
doing
that.
H
So
it
would
be
good
to
do
that
if
we
would
want
to
test
a
combination
of
cli
and
ui.
You
know
like
okay,
let's
say
a
user,
I'm
just
giving
an
example
over
here.
A
thin
air
user
uses
cli
of
this
specific
pattern,
and
then
you
know,
maybe
he
configures
it
in
a
certain
way
and
and
then
right
after
that
or
she
goes
to
the
ui-
and
you
know,
does
something
something
else
right
with
that
data.
H
So
maybe
those
kind
of
scenarios
would
be
like
good
to
pursue
once
we
cover
like
basic
functionality
right.
B
Nice
yeah,
that
makes
total
sense
yeah.
I
I
think
part
of
when
I
was
asking
that
question.
I
was
not
ex
not
expanding
my
mind
to
to
really
think
about.
You
know
in
scenario:
yeah,
yeah
and
and
the
fact
that,
like
the
end-to-end
integration
tests
are
being
invoked
inside
of
a
github,
workflow
and
so
yeah
to
your
point.
B
If
the
the
the
high
level
description
of
a
test
might
be,
you
know,
verify
import
of
a
filter
of
a
of
a
filter
like
of
a
piece
of
content
and
that
and
that
that
that
workflow,
the
github
workflow
might
be
called
that,
but
internal
to
it,
it
might
have
two
different
jobs
using
two
different
clients,
one
client
being
cli
based
the
other
client
being
ui
based
and
so
to
your
point
like
over
time.
B
While
we're
focused
on
the
measure
ui
as
our
as
the
client
in
context
of
cyprus
and
and
we
want
to
start
there
and
be
successful
there
and
have
you
know,
write
any
number
of
you
know:
integration
tests
that
as
we
come
back
to
integration,
we've
done
a
lot
of
unit
testing
with
measuring
ctl.
B
But
as
we
come
back
to
integration,
testing,
yeah
it'll
be
it'll,
be
an
interesting
reflection
like
hey.
Do
we
just?
Would
we
go
and
augment
the
existing
workflow
for
the
integration
test
with
the
ui
client
and
add
the
cli
client
as
like
a
second
parallel
job?
Or
would
we
you
know
split,
you
know,
have
two
separate
workflows
that
are
really
testing
the
same
feature
but
from
two
different
types
of
clients
like
yeah.
That's,
that's
great.
B
H
Yeah
I'd
like
to
pursue
that
once
we
cover
the
basics
and
I'd
like
to
add
something
else.
So
when
we
do
cypress
test
it's.
If,
if
we
are,
let's
say
talking
about
me,
let's
say
we're,
I'm
I'm
in
a
team
and
we're
developing
a
specific
set
of
functionality.
H
You
know
as
a
tester
when
we
have
the
technical,
let's
say
we're
doing
this
white
box
testing.
We
know
like
what's
being
being
developed
as
it
is
developed.
You
know
we
do
early
testing,
we
go
over
sorry,
my
daughter.
We
go
over
the
the
design
we
go
over.
You
know
the
pull,
requests
and
said
cetera.
H
We
try
to
test.
You
know
we
script
our
test
in
a
way
that
we're
very
well
aware
of
what
we're
testing
like
what
piece
of
integration
part
we're
testing-
and
this
part
this
time
around
like
this
is
another
circumstance
where
something's
already
developed.
You
know
we
we
come
in
and
as
testers.
H
So,
even
though
we're
going
to
do
integration
tests,
what
I
do
usually
is
that
so
I
start
the
script
I
may
I
I
add
the
first
step
to
so
that
the
test
navigate
to
cypress
and
then
so
so,
cyprus,
I'm
not
sure
any
everyone's
aware.
You
know
it
has
like
this,
like
ui
as
a
test
test
runner.
So
it's
very
very
interesting
because
that
it
allows
you
to
inspect
and
to
go
over
the
the
what's
happening
inside
the
console
and
if
there's.
H
Ran
just
go,
get
going
the
network
tab
in
the
browser
and
then
so
so
I
would
start
looking
at
what's
happening
at
the
in
the
browser
and
then
start
a
adding
this
intercept
command
so
that
we
can.
Of
course
the
upload
of
the
file
needs
to
be
like
a
real
file,
but
or
else
we
there
are
also
some
some
strategies.
H
H
You
know
he's
learning
cyprus,
so
I'll
share
I'll
share
with
you
like
those
links.
So
there's
some
recipes
and
it's
just
like
going
over
a
catalog.
Seeing
if
there's
a
specific
recipe
for
your
use
case,
you
know
you're
trying
to
do
an
upload
you're
trying
to
do
some
specific
user
actions
and
I'll
take
a
look
to
the
let's
say:
the
the
drawbacks
of
each
different
approach.
H
But
but
we
could
definitely
use
like
an
in-memory
file
and
just
pass
like
this
a
reference.
But
you
know
everything
all
of
this.
You
know.
Let
me
just
take
a
look,
because
everything
depends
on
the
implementation
of
how
the
the
ui,
how
how
is
the
front
end
uploading?
Oh
yeah,
yeah,
okay,
so
I
no,
I
don't
know
who's
sharing
the
screen.
H
Oh
yeah,
that's
abby,
shake
yeah
cool,
so
he's
sharing
the
the
test,
runner,
okay,
cool
yep.
So
so
the
idea
is
that
I
need
to
take
a
look
as
to
how
how
is
the
front
end
supporting
the
upload
and
then
all
based
on
on
the
implementation.
I'll
take
a
look
as
to
how
we
can
make
cyprus
a
either
do
an
actual
upload
or
or
at
least
like
use
a
blog
in
memory
and
then
just
pass
it
to
the
application.
H
You
know,
but
you
know
I'm
barely
taking
a
look
at
the
functionality,
so
sorry
for
not
being
able
to
to
show
any
code
yet,
but
I'll
I'll
do
my
best
this
week
to
get
some
progress
and
try
to
find
a
strategy.
We
can
reuse
across
a
different
test
for
this
for
this
functional
area.
B
It
comes
with
a
caveat
of
like
well
like
if
you
had
a
if
there
was
a
continuation
of
that
integration
test
that
needed
an
actual
file,
then
maybe
you'd
have
a
challenge,
but
but
it's
just
like,
I
think,
as
you
share
that
aloud,
I'm
really
good
for
really
good
for
everyone
to
be
aware
of
yeah
of
its
capabilities.
Also
yeah.
B
B
No
yeah,
no
and
then
yeah
to
your
point.
I
think
you
were
alluding
to
potential
reuse
in
the
future
as
well
over.
You
know
like,
like
hey
here's.
A
lot
of
the
code
yeah.
H
B
F
H
Add
that
thanks
sorry
for
interrupting,
I
like
to
add
that
a
well
I
I
was
honestly.
I
was
a
selenium
webdriver
tester
with
c
sharps
in
the
past,
and
I
switched
over
to
cypress.
For
me,
it
was
a
very
I
don't
know.
I
thought
it
was
very
risky
to
you
know,
mark
things
off
and
you
know
use
certain
stuff
in
in
test
code.
H
You
know,
because
that's
not
like
a
common
to
do,
but
I
really
like
the
division
and
how
the
cypress
team,
you
know
the
the
creators
of
the
tools
they
share.
That
you
know,
even
though
you
know,
if
you
know
your
application,
it's
very
it's
very
safe
to
use
like
let's
say,
test
version,
test
version,
dependencies
or
components
or
data
in
in
your
environment.
Right
because
you
need
to
have
control
of
your
of
your
desk.
You
know
else.
It's
very
complicated.
F
H
Start
working
with
this
tool,
you
know
what
I
like
is
that
it
helps
you
be
more
conscious
of
of
how
your
application
works.
You
know,
how
is
it
exposed
in
a
certain
set
of
functionality
and
well
yeah?
So
that's
that's
what
I
wanted
to
share
and
well
yeah
I'll
I'll,
let
you
guys
know
any
blockers
or
issues
or
questions
that
I
have
and
I'll
try
to
to
collaborate
with
abhishek
as
best
as
I
can
just
I'm
sure
he
had.
H
Even
though
he's
a
nearly
cyprus,
I'm
sure
he
has
a
lot
of
value
to
add
to
the
to
this
task.
So
thanks
a
lot.
A
So,
let's
move
on
to
the
next
item,
which
is
from
me:
it
is
about
defining
relationship
between
application,
pattern
and
filter.
This
is
something
I
think
we
talked
about
last
week,
also
not
knowing
detail
and
probably
today,
also
not
in
much
detail.
I
quickly
created
this
looks
ugly,
that's
because
I
created
in
last
five
minutes.
So
this
is
just
a
broad
overview
of
what
the
relationship
actually
looks
like
so
pattern
is,
as
we
were
talking
about
it's
a
very
broad
term.
A
It's
about
best
practices,
enforcing
best
practices,
letting
you
know
about
best
practices
along
with,
because
it's
a
very
generic
construct.
It
lets
you
do
everything
within
with
the
infrastructure
and
when
we
say
everything,
it's
actually
everything
you
can.
You
can
configure
your
service
machines,
you
can
configure
your
cluster,
you
can
create
a
source.
You
can
basically
anything
that
you
can.
Probably
imagine
that's
right
now,
supported
with
buttons
except
exception
is
odd
c,
like
setting
up
something
like
spire
or
something.
A
That's
that's,
probably
something
we
would
take
up
later.
So
one
of
the
construct
that
patents
supports
is-
and
when
I
say
patent
supports,
that's
most
like
the
file.
The
way
patterns
are
structured,
the
pattern
file
that
we
have
they
are
capable
of
representing
filters.
What
filters
are
filters
are
basically
wasn't
binary,
wasn't
binary
along
with
a
config
file.
A
This
config
file
is
a
file
yaml,
as
everything
is
in
kubernetes
world,
where
you
can
actually
talk
about
not
talk
about,
you
can
actually
specify
how
your
volume
file
is
supposed
to
configure
on
the
onboard
data
plane.
Where
should
it
be
dropped
or
what
should
be
its
position
in
filter
chain
and
what
should
be
the
other
details
like
where?
Should
it
be
fetched
from
what
the
should
look
like
in
those
kind
of
details
is
something
that
this
config
file
is
going
to
capture.
A
This
config
file
is
again
a
pattern
file,
not
and
when
I
say
a
clean
pattern
file,
it's
about
a
yamaha
file
which
is
capable
of
representing
almost
anything
that
you
want
to
perform
on
your
cluster.
The
second
concept
is
application.
That
is
also
a
sort
of
comes
under
patents.
It's
another
course
construct.
What
it
is
is
basically
it's
a
it's
a
construct
which
lets
you
handle
your
workloads
in
a
cluster.
This
workload
could
be
a
kubernetes
manifest
if
you
have
kubernetes
manifest,
or,
of
course
you
can
do
quite
apply.
A
What
you
can
do
is
you
can
convert
into
patterns?
Well?
Why
would
you
want
to
convert
into
pattern
file
because
you
can
import
into
mystery
whatever
you
want
to
import
in
mission,
because
we
have
a
extension
mesh
map,
you
can
actually
visualize
whatever
you
had
in
a
manifest
in
your
infrastructure,
and
you
can
actually
design
it
further
from
there
graphically.
A
Basically
with
a
nice
user
interface,
I
don't
have
mesh
map
up
or
I
would
have
showed
you.
The
second
thing
is
rollouts.
That's
also
something
that
we
support
today
and
the
support
is
sort
of
limited
we
definitely
want
to.
We
would
be
actually
extending
the
support,
but
what
you
can
do
is
just
using
the
same
application
construct
you
can
do
candid,
roll
outs
or
candy
routes
is
something
that
we
sort
of
support.
A
You
can
also
do
blue
green
deployments
or
those
kind
of
things
which
is
also
sort
of
a
subset
of
application
and
this
dot
dot
dot
which,
like
my
poor,
designing
skills.
Actually,
that
basically
means
others,
but
we
or
we
can
also
support
other
other
methods
of
handling
your
workloads.
A
So
basically,
that's
what
mostly
patents
is
it's
a
huge
construct
which
allows
you
to
represent
anything
in
a
yaml
file,
anything
that
you
want
to
perform
on
your
cluster
on
your
infrastructure,
along
with
enforcement
of
best
practices,
how
the
best
practices
are
enforced
is
basically,
why
are
actually
right
now?
Why
are
official
patents
that
actually
we
talked
a
lot
about
today?
Seating
patterns,
seating
applications,
sealing
filters,
those
are
official
things
they
actually
enforce
the
best
practice.
A
So
let's
say
we
have
a
filter
for
rate
limiting
we
we
are
going
to
provide.
We
are
going
to
see
it
for
you,
you
can
actually
drop
it
in
your
data
plane.
You
can
use
that,
and-
and
probably
trust
is
that
that
is
going
to
work
just
right,
and
it
is
basically
it
is
the
best
configuration.
Probably
you
can
ask
for,
or
you
can
actually
tweak
it.
We
also
provide
tweaking
the
the
rate
limiting
or
the
rest
of
those
filters
that
we
have.
A
So
this
is
basically
the
overview
of
what
patents
is.
I
hope
it
made
sense
if
it
didn't.
You
can
ask
questions.
C
Okay
yeah,
so
there
is
any
application
that
is
like
available
and
you
just
impose
a
pattern
file
onto
it
to
perform.
You
know
to
make
it
best
or
to
make
this
that
those
performance
like.
A
So,
right
now,
right
now,
actually
so
right
now.
This
is
one
thing
that
is,
if
you
are
the
capability
to
convert,
transpose
kubernetes
into
mystery
applications.
That
was
added
very
recently,
but
that's
not
the
place
where
we
actually
right
now,
at
least
in
forcing
best
practices.
But
what
you
can
actually
do
is
is,
if
you
use
a
type
cooldown
application.
If
you
have
seen
that
construct
in
measuring,
let
me
try
to
pull
up.
A
Patents
yeah,
so
if
you
have
seen
that
application
construct
that
we
have
that
actually
already
enforces
best
practices,
so
let's
say
this
one
here:
what
we
are
trying
to
do
is
actually
deploy
our
application
called
details.
This
is
its
image
and
it
looks
sort
of
like
you
are
trying
to
deploy
a
pod,
but
it's
not
exactly
a
pod.
It's
not
even
a
deployment.
It's
not
replica!
I
said
it
creates
multiple
stuff.
It
will
actually
first
check
if
you
have
a
proper
shootout
engine
available
in
your
in
your
infrastructure
or
not.
A
If
it's
not
there,
it's
going
to
basically
pull
it
up
for
you
and
once
it
it,
it
is
up
and
running
it's
going
to
it's
going
to
create
a
road
out
for
you
and
then
replicas.
It
then
board
and
then
basically,
it's
going
to
set
up
stuff
for
you.
At
the
same
time,
it's
also
going
to
ensure
that
you,
when
you
say
that
okay,
I
want
to
access
this
on
1980.
A
It
should
be
accessible
to
you
on
1980
unless,
until
like
you
have
very
weird
networking
things
set
up
in
your
future
and
cannot
figure
out
that
how
to
get
it
up
for
you.
So,
basically,
if
you
are
using
this
construct,
you
are
pretty
much
using
the
best
practices.
While
the
recent
feature
that
we
added,
I
should
say
I
added
because
I'm
going
to
say
that
it
could
be
buggy.
So
the
recent
feature
that
I
added
it
what
it
lets
you
do
is
you
can
actually
say
that.
A
A
So
right
now
there
are
no
best
practices
that
we
are
doing
basically
implementing
there,
that's
one
of
the
caveat,
and
probably
that
will
also
sort
of
improve
later
on,
but
you
can
be
assured
that
if
you're
using
this
constructor,
we
are
doing
stuff
in
best
way
possible.
Yeah.
H
I
have
a
question
in
this
conversation.
First
of
all,
I
think
this
is
great
yeah,
a
great
job,
hey.
I
just
want
to
know
when
you
say
enforce.
Do
you
mean
that,
like
would
measuring
undo,
let's
say,
there's
something
already
deployed
in
a
kubernetes
environment,
and
then
we
run
like
a
pattern.
H
We
didn't
do
with
modify
existing
resources
or
workloads
like
it.
Does
it
enforce
it
actually
like
in
that
meaning
of
the
word.
A
It
enable
best
practice
yeah,
actually
it
could
be
a
it
could
be
that
enables
best
practices
is
more
appropriate,
although
yeah
it
could
be
any
yeah.
We
also
sort
of
enforce.
That
is
some
things
are
which
we
are
sort
of
opinionated
about,
like
I,
I
shouldn't
say
b,
because
it's
something
that
I
coded
up.
So
I
was
supinated
about
when
I
was
coding.
So
let's
say
when
you're
doing
application,
we,
you
are
actually
deploying
it
rollout.
A
Some
things
happen
in
a
way
that
are
actually
which
are
actually
something
that
I
thought
would
be
the
best
way
to
get
the
stuff
up
and
running.
So
let's
say
you,
let's
say
you
are
trying
to
deploy
your
application
and
mission
figures
out
that
this
thing
already
exists.
What
it's
going
to
do
it's
going
to
it's
going
to
gradually
lower
its
count,
it's
going
to
increase
its
count,
and
it's
going
to
annotate
that
okay,
I'm
the
manager
from
now
on,
I'm
going
to
manage
its
field.
A
So
this
is
something
that
sort
of
of
enforcement,
but
in,
but
that's
only
the
case
with
application,
not
with
most
of
the
construct
that
comes
with
patents.
So
yeah
most
mostly
it's
about
enabling
best
practices.
H
Oh
and
well,
I
think
you're
kind
of
right
when
you
say
enforce,
because
if,
if
a
user
decides
to
adopt
measuring
like
as
it's
like
tool
as
to
how
to
deploy
and
configure
his
or
her
workloads,
of
course
in
in
that
sense,
it
would
enforce
best
practices
like
best
known
practices
like
as
you
see
opinionated,
but
they're,
they
would
be
enforced
because
there's
it
wouldn't
allow
other
way
of
doing
it
right.
H
It's
like
this
framework
that
allows
you
to
use
something
that
someone
else
like,
or
a
group
of
people
predefined
as
a
best
practice
right.
H
Oh
it's
a
great
yeah,
but
I
I
they
didn't
like
it
was
just
like.
Sometimes
I
had
and
something
else
when
you
say
application
in
this
diagram
k,
kubernetes
k8
s
like
is,
is
the
file?
Is
that
file
actually
encapsulating
a
kubernetes
environment
or
like
everything
else,
makes
sense?
But
when
I
see
kate
in
the
box,
I'm
I'm
thinking
like
okay,
that
it's
this
is
containing
like
a
kubernetes,
oh
manifest:
okay,
okay,
that's
better
cool.
C
Okay,
so
one
confusion
from
my
side,
so
I
am
seeing
like
a
service
mesh
pattern
repo
and
there
are
simple
patterns
that
we
have.
So
if
I
see
it
so
there
is,
is
like
booking
for
pattern
or
histo
filter
pattern.
So
I'm
just
I'm
just
currently
sticking
with
the
booking
for
pattern
since
yeah
so
booking
for
pattern,
booking
phase
application
right,
so
it
should
should
it
only
apply
to
applications
following
the
similar.
C
You
know
a
pattern
like
what
should
I
say
if
you
understand
it
so,
following
the
similarity
like,
if
I
have
my
application
and
it
is
somewhere
similar
with
the
way
I
perform
networking
inside
it
inside
my
applications
to
the
booking
for
applications,
so
only
in
that
case
will
it
be
helpful
or
it
is
kind
of
imposing
something
like
very
general,
that
will
help
like
in
every
application.
A
Okay,
actually
so
book
info
is
a
application
which
is
made
up
of
multiple
services,
so
so
what
right?
Now?
What
at
least
let's
talk
about
right
now
so
right
now
the
application
construct
which
I
have
been
also
told
to
rename
to
rollout.
So
probably
it
should
be
renamed
to
rollout,
because
it
creates
a
lot
of
confusion
so
right
now
the
application
construct
that
we
have
the
practices
that
it
enforces.
It
only
enforces
it
on
a
single
console.
So
right
now
this
is
that
related
here.
A
This
is
relevant
portion.
This
is
the
so
this
is
the
unit
on
which
the
practices,
the
things
would
be
actually
enforced.
If
you
want
to
do
anything
other
than
that,
let's
say
so.
If
you
would
see
this
pattern,
this
is
a
completely
function
pattern.
It
will
actually
set
up
everything
your
infrastructure,
mostly
correctly,
if
you
have
the
required
things
running
on
your
system.
A
Actually,
if
you
don't,
then
it
will
also
let
you
know
that
you
don't
have
this
thing
running,
so
we
cannot
get
this
button
up.
So,
let's
say:
if
you
have
everything
running
it's
hdr
is
running
in
you
have
every
crd
in
your
system.
If
you
apply
this
pattern,
it's
almost
guaranteed
that
you
will
actually
have
your
application
available
to
you
on
the
endpoint
that
you
actually
chose.
That
doesn't
mean
that
we
impose
best
practices
everywhere,
er
at
least
right
now
we
infuse
best
practices
on
those
small
units.
This
is
a
unit
details.
A
We
impose
some
best
practices
here.
This
is
a
unit.
This
is
not
the
place
where
we
actually
enforced
any
practice.
This
is
because
you
actually
explicitly
chose
that.
Okay,
I
know
what
I'm
doing
I
want
to
configure
my
so
this
is
also
something
patterns.
Are
pattern
file
that
lets
you
do.
That
is,
if
you
know
that
you
know
better
about
something,
then
you
can
go
ahead
and
configure
that
particular
construct.
So
here
you
are
saying
that.
A
Okay,
I
want
a
virtual
service
and
I
want
to
configure
it
my
way,
so
you
actually
especially
choose
that
virtual
service.seo
I'm
going
to
create
a
virtual
service
for
it
now
or
there
are
actually
examples
where
also
opting
out
from
creating
yeah.
So
this
is
an
example
where
you
are
actually
opting
out
from
one
of
those
practice
that
actually
measuring
forces
for
you.
A
So
if
you
are
saying
that
okay,
I
want
reviews
hyphen
one
v,
one,
this
service-
I
want
it
to
be
up,
but
you
are
also
saying
that
okay,
I
want
to
go
into
the
advanced
section.
I
want
to
opt
out
from
creating
services,
don't
measure
it
don't
enforce
that
thing.
I
am
going
to
do
it
on
my
by
myself
and
there
is
something
basic
basically
now
this
is
a
unit
where
we
are
enforcing
lesser
practices.
A
We
are
just
basically
because
you
asked
us
to
and
then
you
can
actually
go
ahead
and
create
service,
and
probably
you
may
opt
out
from
creating
service
like
completely
so
I
hope
that's
making
sense.
Actually
we
are
right
now
reinforcing
best
practices
on
units,
not
on
the
entire
thing.
That's
the
state
right
now.
Actually.
C
Okay,
so
those
things
will
be
automatically
be
already
done
with
machine
learning
by
default.
C
Okay
and
and
this
this
whole
repositories
are
doing
that
thing
like
service
mesh
patterns.
What
is
the
like?
Any
external?
Oh,
I.
A
Let's
assume
we
don't,
we
are
12
minutes
after
so,
let's
conclude
the
meeting.
If,
unless
someone
has
okay,
we
are
good
to
conclude
so
bye,
guys,
let's
meet
on
wednesday,
we
have
our
division
meeting
on
wednesday,
so
good,
okay,.