►
From YouTube: Meshery Development Meeting (August 26th, 2020)
Description
Excellent presentation of new @hashicorp Consul adapter enhancements by @michaelgfeller and of Buf by @_devkalra. Welcome @NikitaPande3!
A
B
B
B
B
D
Thank
you,
so
my
pc
was
behaving
strangely
all
day.
So
if
I
somebody
vanished
and
something
happened,
maybe
yes,
I
thought
about
talking
a
little
bit
about
the
work
I've
been
doing.
I
joined
the
layer
five
messaging
not
so
long
ago,
and
I
was
when
I
was
looking
around
for
some
issues
I
could
work
with.
I
saw
the
measuring
console
adapter
and,
as
I'm
working
with
console
connect
right
now
in
my
day
job.
I
thought
that
would
be
a
good
way
to
export
some
synergies
between
this
work
here
and
my
day.
D
B
D
F
A
D
B
D
D
But
then
I
went
back
to
working
on
number
two
update
console
adapter,
here's
the
latest
version
of
console
just
to
get
familiar
with
the
console,
measuring
console
adapter
and
to
have
something
which
probably
is
a
bit
quicker
to
be
able
to
finish
than
starting
refactoring
and
including
helm.
But
of
course,
that's
still
an
open
issue
and
something
we
should
be
working
with.
G
G
D
D
D
D
D
But
then
stuff
didn't
really
work.
So
I
didn't
really
understand
a
how
this
was
possible
and
b
wait
why
it's
worked
halfway.
So
that's
why
I
was
then
using
set
to
just
replace
the
namespace
in
the
generated
file
with
a
namespace
variable,
and
the
namespace
variable
is
the
only
namespace
that
is
merged
into
the
template
in
the
measuring
console
adapter.
So
that
worked
in
the
end.
D
A
D
D
And
then
you
deploy
either
the
service
mesh
or
the
sample
application.
Then
this
is
going
to
be
deployed
in
this
namespace
right,
nice,
nice,
okay.
So
so
I
could
write
test1
and
then
it
looked
like
console
actually
was
deployed
into
the
test1
namespace,
but
the,
but
it
wouldn't
work
so
console
wouldn't
work,
because
the
namespace
in
the
manifest
was
still
console.
That
was
really
weird
but
anyway.
D
If
I
then
replacing
as
I've
shown
here,
the
generated
namespace
console
in
in
the
in
this
new
file
and
replacing
this
merge
variable
and
then
then
it
worked
and
then
everything
yes
worked
actually
now
well
at
least
the
first
part.
There
was
a
lot
of
actually
there
was
a
lot
of
familiarizing
and
finding
out
and
people.
D
What
happened?
Okay
so
successfully?
I
can
now-
and
I
can
show
you
that
this
works,
but
I
don't
dare
to
do
it
now.
I
did
it
before
the
meeting.
You
never
know
what
can
go
wrong
and
I
can.
I
can
now
show
you
the
console
user
face,
hopefully
which
is
running
on
my
pc
right
now,
and
you
see
down
here
if
you
can
see
it
that
the
version
of
console
running
here
now
as
deployed
by
measuring,
is
182,
which
is
the
latest
like
a
couple
of
days
ago.
D
You
have
notes
that
are
part
of
the
console
data
center
right
now
we
just
have
one
node
here
on
my
pc.
Then
you
also
in
console.
You
have
key
value
store,
you
have
access
control
lists
and
you
have
intentions.
I
can
show
them
later
in
a
couple
of
minutes
what
I
have
done
here.
I
have
been
using
a
application,
an
image
which
is
developed
and
maintained
by
nick
jackson.
It's
called
fake
surface
and
it's
really
great
to
sort
of
create
service,
topologies
and
call
chain
topologies.
D
D
E
D
A
Now
I
think,
there's
a
few
persons
that
have
just
happened
that
I
think
that's
the
first
time.
I've
heard
a
user
say
you
know
no
that
wasn't
supported,
but
I
just
went
ahead
and
used
the
custom
yaml
option
anyway.
It's
like
that's
fantastic.
I
just
that
feature
has
been
there
for
like
a
year,
and
I
haven't
heard
that
much
feed
so
that
that's
great
also
I'll,
say
well
one.
A
You
mentioned
nick
jackson
and
there
are
some
of
us
in
the
community
that
are
on
the
call
now
that
know
nick
and
some
that
don't,
but
so
nick
for
those
that
don't
know
him
he's
in
the
slack
he
works
at
hashicorp,
which
is
the
which
is
the
corporate.
The
company
behind
console
the
console
service
mesh,
the
the
pink
one
that.
A
So
one
to
nick
nixon,
very
much
so
a
friend
of
enemy
and
and
I'll
tell
you
more
about
some
of
the
things
that
he
does
with
us.
But
one
thing
we're
looking
at
doing
with
him
is
exactly
what
he
was
showing,
which
is
the
fake
service.
That's
there
in
between
the
learn
layer
file
sample
app
that
we
have
that
we
use
for
smi
conformance
testing,
there's
a
different
small
sample
app
that
was
developed
here.
A
A
D
I
think
the
advantage
of
using
fake
services
that
you
don't
have
to
think
about
what
kind
of
application
you
have
and
how
this
is
supposed
to
behave
and
the
ui,
which
is
sort
of
included
included
in
fake
service,
also
shows
very
nicely
how
they
are
connected.
You
see
here
that
I
have
the
api.
Aaa
service
is
actually
used
by
two
other
services
now,
just
quickly,
maybe
go
back
to
the
management
console,
and
you
see
here
that
you
have
all
the
services
on
the
node.
D
D
Now
I
can
start
and
in
practice
you
have
to
do
that.
You
have
to
start
adding
allowing
say
from
the
web,
which
is
the
front
end
to
the
next
one,
which
is
this
one
and
say
this
is
an
allow
I
haven't
practiced.
So
this
is
going
to
be
interesting
to
see
what
happens
and
you
see
it's
calling
on,
but
because
the
error
return,
it
returns,
narrowed
and
everything
is
red
is
still
red.
D
D
And
I'll
see
what
happens
here
now
you
see
the
a
chain
if
you
like
is
going
fine,
but
the
call
to
b,
if
you
remember
from
b4,
is
not
going
fine.
So
using
a
setup
like
this,
you
can
sort
of
like
play
and
start
understanding
how
your
service
mesh
works
and
have
both
visual
feedback.
But
you
also
get
json
response,
which
you
can
then
use
in
automat
automated
tests,
for
instance.
D
A
D
D
So
I
have
been
working
with
just
fixing
the
two
sample
apps
that
are
included
http
bing
and
the
book
info
they
have
using
old
versions
of
the
deployment
manifests,
so
I'm
ready
and
just
waiting
for
this
bull
request
to
be
approved
so
that
I
can
test
them
as
well
and
from
then
on.
There
are
lots
of
interesting
issues
like
helm,
support,
automated
testing
stuff
like
this
and
refactoring
as
described
in
oh.
This
was
the
wrong
one
here:
the
measuring
adapter
dock.
D
D
A
Michael,
this
is
a
heck
of
a
first
demo.
This
is
I'm
just
I'm
tickled
with
that
the
stuff
you're
showing
it
I
haven't
the
last
time
I
fell
on
oh
yeah,
no
last
time
that
I've
seen
yesterday
deploying
also
it
was
it
was.
You
know
one
top
five
right,
like
you
just
progressed,
I
don't
know
like
a
year
and
a
half
worth
of
releases.
A
A
A
A
A
I'm
very
pleased
to
I'm
glad
that
you
are
that.
That
makes
me
happy
that
you
are
I,
but
so
I
have
to
take
a
moment
because
for
those
that
have
been
on
these
calls
before
or
if
you
go
back
and
watch
the
embarrassing
moments
from
many
other
recorded
calls,
you'll
know
that
my
american
tongue
is,
you
know,
only
so
only
has
so
much
dexterity
when
it
comes
to
pronunciation,
apparently,
and
so,
but
now
that
shri
is
hoping
it's
called.
B
E
Today
is
my
first
call
and
yeah
I'm
new
to
service
mesh,
and
I'm
means
I'm
nikita.
I
think
you
would
have
known
already
so
yeah,
so
I
am
in
the
phase
of
learning
of
service
mesh
and
I
am
very
much
interested
in
getting
in
depth
of
this
particular
project
because
it
looks
suitable
for
many.
Many
new
cases
like
performance
was
one
of
the
good
use
case
of
measuring,
which
I
couldn't
get
in
any
other
project.
I
I
B
I
B
B
C
C
C
Okay,
the
protocol
protocol
buffers
whatever
you're
saying
so
it's
basically
a
new
way
of
working
with
protocol
buffers
and
the
goal
of
buff
is
to
basically
make
it
a
lot
easier
to
use
protocol
buffers
so
that
whenever
someone
will
be
comparing
that
but
to
use
json
or
portable
buffer
or
whatever,
then
the
like,
you
can
say
the
best
choice
or
a
very
good
choice
will
be
the
protocol
buffer
yeah.
So
so
before
that.
So
why
is
this
tool
here?
So
let's
talk
about
some
problems
that
is
with
protocol.
C
So
first
of
all
protocol
is
not
as
old
as
widely
adopted
as
json.
Okay,
the
another.
It
is
actually
not
a
problem,
it
is
just
yeah.
It
will
take
some
time
to
get
adopted
and
another
some
things
is
the
api
structure.
So
actually
right
now,
as
it
is
not
as
much
or
adopted,
there
are
no
standards
that
we
that
our
organization
can
enforce
on
apis
like
api
structure
or
something
like
that.
C
So
what
can
happen
is
there
can
be
inconsistencies
between
the
apis
like
apis
games,
api
structure
or
some
or
something
like
that?
It's
basically
based
on
the
design.
This
is
a
design
decision
that
someone
will
take
some
design.
Decisions
like
yeah
api
should
be
all
in
camel
case
or
something
something
like
that
other
than
that
there
is
this
backward
compatibility.
C
Okay,
so
right
now
off
is
there
is
no
stable
release
for
buff.
It
is
right
now
in
beta
and
right
now,
what
it
has
is
it's.
Basically,
it
provides
us
with
some
cli
tools
and
some
product
plugins.
So
in
that
cli
tool,
what
we
have
is
we
have
a
lender
that
will
basically
enforce
api
design
choices
and
api
structure
and
a
breaking
change
detector,
some
functionalities
that
it
provides
us
like
in.
C
If,
if
you
have
used,
if
someone
has
used
the
prototype
compiler,
so
what
it
does
is
you
have
to
specify
every
single
file
yeah
this
file
is
there
this
file
is
there
and
although
all
those
things,
but
unless
you
don't
have
to
specify
anything,
it
will
just
search.
You
have
to
specify
the
root
directory
and
it
will
recursively
search
for
profiles
in
that.
C
So
there
are
a
lot
of
lenders
and
breaking
checkers,
because
the
thing
is
some
lenders
and
some
breaking
checkers
will
work
for
some
organization
and
some
will
work
for
some
another
organization.
So
organization
can
choose
among
these
lenders
and
making
checks
that
yeah.
We
want
to
go
with
these
laters
and
these
breaking
checkers,
and
that
is
another
feature
that
I
found
like
interesting
is
so
basically
what
buff
does
is
it
has
its
own
internal
compiler
and
it's
like
four
times
faster
than
the
proto,
the
standard
defector
compiler
for
photographs.
C
It's
like
four
times
faster,
and
it's
really
interesting
another
thing.
So
I
in
what
we
have
now
I
discussed
that
we
have
the
above
cli
client
and
another
thing
is
both
plugins,
so
we
can
just
use
those
plugins
with
the
proto
product
compiler
and
instead
of
using
buff
as
a
standalone
tool,
we
can
just
use
plugins
with
the
product
to
basically
lint
and
check
if
there
is
some
breaking
change
or
something
and
in
phase
one
so
there
are.
C
This
is
about
the
roadmap
that
what
they
are
building
and
where
they
are
now
so
in
phase
one.
They
are
trying
to
solve
this
api
structure
and
backward
compatibility,
compatibility
issue
and
yeah.
I
just
as
I
have
mentioned
before,
they
are
trying
to
solve
this
api
structure
enforcement
by
using
linters
and
some
plugins
related
to
the
breaking
chains,
so
they
are
trying
and
by
that
they
are
trying
to
do
this
backward
compatibility
thing.
Okay
in
in
phase
two.
C
This
is
really
interesting
about
this
tool,
so
I
think
some
of
you
may
have
worked
with
docker.
So
what
it
does
is
you
specify
a
docker
file?
You
can
build
a
docker
image
and
you
can
push
that
docker
image
to
a
docker
rejection
registry,
maybe
docker
hub
registry
or
some
private
registry
right
so
now
other
can
pull
those
docker
images
from
those
registries
and
they
don't
need
access
to
the
particular
user
right
that
who
push
those
things.
So
this
is
really
interesting.
C
So
what
it's
trying
to
do
is
it
will
do
in
the
future
right
now,
it's
in
the
beta
version,
and
it's
just
trying
to
provide
us
with
the
api
ap
structure
and
a
back
compatibility
backward
compatibility
thing
in
the
in
future.
They
are
planning
to
do
to
provide
us
with
this
buff
schema
registry.
So
what
what?
What
problem
will
this
solve?
Is
there
was
this
problem
with
stop
distribution?
So,
okay,
we
generated
a
profile.
Now
we
have
to
share
it
with
our
clients.
C
We
implement
the
server
for
the
apis
right,
but
we
have
to
share
it
with
our
clients
too.
So
that
was
the
issue
like.
If
you
update
something,
then
how
are
you
going
to
like
distribute
it
to
your
clients
who
are
already
using
these
protofiles?
It
can
break
it
can
break
things
right.
So
that's
why
they
are
trying
to
build
this
buff
schema
history.
So
what
we
will
do
is
we
will
just
use
this
buff
tool.
C
We
can
create
images
out
of
the
proto
files
and
we
can
push
those
images
to
the
the
schema
registry
and
someone
who
is
using
these
apis
this
protobufs
and
then
just
can
pull
these
images
from
the
buff
schema,
usually
itself,
okay,
yeah.
So
I
have
prepared
a
little
demo
for
this
thing,
so,
let's
go
to
visual
studio,
it
should
be
visible.
Should
I
increase
the
size
of
this
thing
like
zoom
in.
C
Yeah,
okay,
so
the
images
are
right:
yeah,
okay,
so
images
is
basically
what
product
does
is
it
basically
creates
file?
Descriptor
sets
right.
The
protocompiler
basically
generates
file.
Descriptor
sets
from
the
protofiles
these
file.
Descriptor
sets.
This
is
nothing,
but
it
will
just
contain
the
information
about
the
protofiles
like
messages,
services
and
all
those
things
and
using
this
file
descriptor
thing
the
go,
plugins,
sorry,
no,
the
go
plugins.
The
plugins,
like
protocheck
protocol,
will
generate
code
based
on
this
file,
descriptor
thing,
so
what
buff
has
done?
Is
it
basically
extends
this
file?
C
Descriptor
set,
they
have
add,
is
added
some
of
their
fills
like
some
metadata,
so
that
they
can
work
on
that
thing
now.
The
interesting
thing
about
that
is
basically
the
image
is
file.
Descriptor
set
and
file.
Descriptor
set
is
image.
So
if
we
want
to
use
the
buff
image
with
the
protocol,
that
is
the
protocol
compiler
the
standard
protocol,
we
can
use
that
what
product
will
do.
It
will
just
ignore
these
extra
fields,
and
if
you
want
to
use
file
descriptor
sets
with
this
buff
compiler
the
buff
internal
compiler.
C
We
can
use
that
too
it.
Basically,
it
will
just
not
use
those
fists
that
was
there.
The
concept
on
which
this
thing
is
based
on
is
that
the
grp,
so
not
the
hdr
physio
the
protobuf.
It's
basically
provides
us
with
this
thing
that
is
forward
and
backward
compatibility.
It's
not
related
to
the
issue
that
I
was
talking
about
it's
something
related
to
like.
If
you
add
some
fields,
then
it
is
not
going
to
break
your
api.
I
will
just
show
them
in
the
demo
too,
so
it
you
can
grasp
it
a
little
better
and
file.
C
C
C
So,
okay,
how
buff
works
is
basically
we
have
to
define
a
buff.cml
file
in
the
root
of
the
directory,
this
buff.tml
file,
and
it
will
just
look
for
configuration
in
those
cml
files.
I
will
just
go
over
this
file
that
what
things
are
there
and
what
it
is
doing
and
all
that
so
buff
will
look
for
configuration
in
this
file
like
what
lentil
to
use
what
breaking
checkers
to
use
and
which
directory
so
this
root
here.
This
root
is
basically
telling
us
buff.
C
Okay,
you
have
to
check
all
those
photo
files
in
this
in
this
directory.
That
is
the
current
directory.
Basically-
and
these
are
the
linters-
so
basic
is
like
a
group
of
lenders
and
in
this
later
there
are
other
lenders,
and
we
are
just
removing
these
lenders
from
that
basic
group
and
we
are
using
another
lender.
C
C
This
is
the
protoc
proto
compiler
that
how
we
are
how
we
use
this.
We
we
have
to
tell
it
that
this
is
the
director
in
which
you
have
to
look
for
the
file
and
we
have
to
specify
the
file
greater
good
protocol
or
some,
and
then
this
goes
out
that
you
have
to
generate
the
code
for
golang
and
the
directory
in
which
you
have
to
basically
generate
that
code.
So
I
think
it
should
be
generated,
yeah,
greater
dot,
pb.com.
C
So
this
was
just
a
proto
command.
I
just
wanted
to
go
over
this
and
and
based
on
this,
we
can
let's
go
to
the
buff
compiler
now,
so
the
buff,
what
it
provides
is,
as
I
talk
about
the
buff,
provides
us
with
automatic
file
discovery.
So
we
can
just
do
this.
Ls
files
yeah
only
greater
dot
photo,
is
present
now.
But
if
I
just
create
a
new
folder,
say.
C
Yeah,
if
I
move
this
glitter.
and
that's
that
thing
that
will
work
too
so
after
this.
So
let's
talk
about
the
lane
checking
thing,
so
what
it
will
do
is
buff
check
link.
If
you
just
do
this
thing,
it
will
check
the
link
if
it
will
check
this
proto
file.
That
is
there
in
this
directory
and
all
the
protocols
that
are
there
in
the
sub
directories.
It
will
equal
of
them
recursively.
C
Let
me
show
this
yeah
here,
so
we
use
this
lower
snake
case
link
and
if
you
see
the
messages
here,
that
is
name
welcome
message.
Our
note
in
a
lower
snake
is
that
this
height
is
showing
us
the
error
about
those
links,
and
it
would
basically,
we
can
check,
lint
and
enforce
that
yeah
right.
There's
some
issue
here
and
we
can
change
that.
So
this
is
this
was
about
the
length
after
this.
C
C
So,
let's
just
create
an
image.
By
using
this
buff
image,
build
output
is
the
file
image
door
pin
it
will
just
create
a
file
and
yeah.
Here.
Is
this
file
image
yep?
Okay?
So
now
what
we
can
do
is
we
can
do
some
change
in
this
created.file
say
I
change
this
to
n32
now.
This
will
essentially
break
the
apis
like
initially,
the
api
was
getting
a
string
input
now
they're
getting
this
n32.
So
this
this
will
break
the
code.
C
So,
let's
just
check
yeah
there
is
this
error
message
and
what
is
it
saying
is
hello,
request,
change,
type
from
string
to
m32
field,
one
or
message,
so
why
is
this
here
field
one?
So,
basically
how
protobuf
works
is
on
the
wire
level.
It
basically
do
not
use
this
thing.
It
don't
use
this
names
name
or
something
welcome
message.
It
use
this
number
one
two
three
or
something
that
is
mentioned
here
on
the
wire
level.
So
that
is
why
it
basically
is.
C
I
think
it's
showing
the
one
thing
here,
because
the
name
has
changed
from
string
to
entertainment,
so
I
just
send
it
back
and
let's
see
if
there
is
a
breaking
chair
now,
no
there
is
no
waiting
chain
now.
So
that
is
how
this
making
change
thing
work.
I
want
to
also
mention
this
one
thing,
so
how
buff
is
checking?
Is
it
it
is
basically
collecting
all
these
protofiles?
It
is
compiling
them
like
dynamically
note,
basically
compiling
and
storing
somewhere
and
then
based
on
that
compiled
thing.
It
is
checking
yeah.
C
There
is
some
breaking
change
or
something
okay
yeah.
So
the
the
thing
that
I
talked
about
file
descriptor
is
image
images
file
descriptor,
but
with
some
extra
metadata
files
right.
So
what
buff
over
such
is,
we
can
use
protocol
file
descriptors
with
buff,
as
we
just
use
image
here
like
in
this
command.
Buff
check
breaking
minus
against
input
image
document.
So
let's
just
create
the
file
descriptor
for
using
the
protocompiler,
and
we
can
you
create
that
with.
A
C
C
Okay,
okay,
I
I
I
will
take
a
note
about
that
and
we'll
see
that
how
this
thing
is
working,
so,
let's
just
create
a
file
descriptor
for
this
thing
using
the
proto.
That
is
the
standard
compiler
right.
So
there
is
this
file
descriptor.ben
file
that
is
just
created
that
we
have
just
created.
Now
we
can
just
pass
it
to
the
buff
instead
of
passing
the
image
origin,
so
the
command
initially
was
this
image.then
now,
instead
of
using
image,
but
then
we
will
just
use
this.
C
C
If
you
have,
you
had
already
set
up
some
plugins
to
some
thing
in
your
repo,
then
you
can
just
use
this
link
checkup
lint
check.
These
are
the
plugins
that
bob
had
built.
You
can
just
use
this
link
with
the
pro
took
standard
compiler
and
it
will
work
and
yeah
one
other
thing.
I
was
curious
like
okay,
so
I
know
how
to
build
images
out
of
this
thing,
but
at
the
end
I
am
not
going
to
work
with
images
right.
C
I
am
going
to
work
with
some
kind
of
code,
so
it
provides
us
with
this
internal
compiler.
That
is
protocol,
and
we
can
just
use
this
proto
same
as
we
are
using
this
proto
standard
compiler.
Instead
of
just
using
protocol,
we
will
just
use
buff
space
protocol
and
it
will
work.
Similarly,
let's
just
do
this.
C
B
E
C
Yeah
yeah.
Actually
I
talked
about
right,
so
there
were
some
issues
like
stop
distribution
and
all
this
it
is
trying
to
solve
those
issues,
but
other
than
that.
I,
what
I
think
is
until
and
unless
the
browser
starts
to
support
this
grpc
people
will
most
probably
be
using
rest
for
a
long
time.
The
reason
is
the
grpc
only
work
with
http
2,
and
so
it
might
not
work
with
every
browser,
and
that
is,
I
think,
one
of
the
reason
that
people
are
not
shifting
to
using
protobuf
and
it
is
solving
a
lot
of
issues
and.
C
People
are
slowly
but
yeah.
A
lot
of
them
are
starting
to
adopt
this
thing.
These
three
pieces
protocol
thing
and
buff
is
trying
to
help
them
adopting
that
by
making
it
easier
to
solve
some
issues
like
like,
say,
distributing
the
protofiles
distributing
these
images
and
enforcing
some
standards
about
the
api
structures,
and
all
that
that
was
the
main
issue
that
it
is
trying
to
solve.
E
C
Okay,
so
sorry,
so
that
was
a
mistake
on
my
part,
so
http
2
is
only
for
grpc.
I
was
kind
of
mixing
things
and
it
is
not
about
protocol
office.
Just
like
a
protocol
in
which
you
it
basically
tells
us
how
we
are
going
to
sterilize
things
and
send
it
from
one
place
to
another.
That's
it.
That
is
what
election
protocol.
B
E
E
Yeah
yeah
yeah,
so
yeah,
so
by
default.
When
I
open
the
ui,
you
know
so
the
this
problem
was
by
default.
I
am
getting
sorry.
This
is
related
to
cli.
So
by
default
I
am
getting
list
of
all
meshes
which
measures
supporting,
but
there
should
be
an
option
to
a
user
wherein
user
can
provide
like.
I
only
want
to
get
info
about
console
and,
let's
say
puma.
I
don't
want
other
meshes.
So
that
was
my
point.
Like
user
should
be
given
a
option
to
provide
the
mesh
name
list
of
mesh
names.
K
A
Once
you
know,
measuring
is
great
to
help
you
figure
out
what
service
meshes
adopt
and
then
after
you've
chosen
one.
Maybe
you
don't
really
care
to
have
those
other
adapters
hanging
out
if
they're
not
they're,
not
valuable
to
you,
and
so
maybe
you
want
to
turn
them
and
I'm
trying
to
rack
my
brain.
My
whole
truck
had
well
delivered
the
ability
to
provide
mastery
cpl
a
config
file,
and
I
don't
remember
I'm
pretty
sure,
like.