►
Description
Idit Levine is the founder and CEO of solo.io, a Boston-based company that develops tools to help the enterprise adopt and make the most of innovative cloud technologies. Idit is an enthusiastic active member of the open-source community. Among the open-source projects coming from solo are Gloo, the function gateway, which melds monolithic, microservices, and serverless apps; Squash, a platform for debugging microservices applications; and UniK, an orchestration tool for microVMs and unikernels. Recently Idit shared with the community her vision of the multi-mesh, an architecture pattern in which users will use multiple and different service meshes on the multi-cloud. To make this vision a reality, Solo announced SuperGloo, an open-source service mesh orchestration platform.
- Captured Live on Ustream at http://www.ustream.tv/channel/craftconf with the Ustream Mobile App
A
Thanks
hi
guys
thank
you
so
much
for
coming
Blackstock.
So,
let's
let's
go
for
it.
So
first
of
a
few
words
on
us,
so
I'm
indeed
I'm
the
founder
of
solo.
We
have
an
amazing,
open
source
project.
Everything
that
I
will
talk
about
it
today
is
open
source.
So
please
go
check
it
out.
I
think
that
you
will
benefit
from
it.
So
let's
try
to
talk
about
the
problem
that
we're
trying
to
solve
why
we
event
here.
So
this
is
three
different
ecosystem.
A
The
way
I
see
it
today
there
is
a
lot
of
the
people
actually
still
using
a
monolithic.
That's
what
they're
going
to
use
they're
going
to
use
different
tooling.
For
that,
then
there's
some
people
that
already
move
to
micro
services
and
all
the
architecture
is
micro
services
and
there
is
a
service
ecosystem.
They
are
treat
different
different
ecosystem.
Actually,
there's
not
a
lot
in
common
between
them.
They,
if
you
will
use
in
one
of
their
forests
and
some
monitoring
tool,
most
likely
in
the
monolithic.
You
will
use
something
like
a
PM.
A
Then,
if
you're
going
to
move
to
micro
services,
you
need
the
way
way
more
skill.
So
we'll
move
to
something
like
primitives
and
if
you're
going
to
be
several
less
you're,
probably
going
to
run
on
the
cloud
most
likely,
because
in
my
opinion,
this
is
where
it's
making
more
sense.
Then,
when
you
lose
the
cloud
provider
monitoring,
so
there's
quite
a
lot
of
different
ecosystem
different
coin
tolling.
And
what
we're
going
to
do
right
now
is.
We
will
try
to
see
how
we
can
actually
merge
them
together
and
not
by
actually
services
but
actually
tools.
A
So
look
at
this,
so
first
of
all
I,
just
kind
of
like
look
at
the
touring
that
you
will
use
if
you
use
something
like
monitoring
monolithic
application.
So
much
like
this
will
be
one
big
binary.
It's
going
to
use
something
like
an
evil
chef,
puppet
and
so
on
to
actually
manage
that
you're
going
to
use
something
like
Splunk,
for
instance,
to
actually
collect
the
log
and
the
architecture
itself
will
be
service-oriented
architecture.
A
But
if
you're
going
to
move
to
micro
services,
you're
most
likely
going
to
use
kubernetes,
distro
or
anything
of
that
like
the
darker
DCOs
for
messes
and
so
on,
you're
going
to
use
a
different
as
I
said,
metrics
or
monitoring
tool,
because
this
scale
now
in
this
distributed
it's
way
way
higher.
So
you
will
need
somehow
to
use
something
that
capable
of
scaling
so
much.
A
If
you
go
into
several
s,
I'm
a
big
believer
so
service
need
to
live
in
cloud
its
way,
it's
make
way
more
sense
when
it's
on
rent-
and
the
reason
is,
if
you
think
about
why
it
even
exists.
Aw
I
did
it
exactly.
For
that
reason,
right
I
mean
they
have
all
those
services
in
the
cloud
and
they
need
something
to
glue
them
together
and
therefore
they
decided
to
do
those
function.
If
you're
running
complement,
you
don't
have
all
those
services
hook
up
the
way
I
WS
did
it
make
way
way
less
sense.
A
So
if
you
will
run
on
cloud-
and
this
example
is
AWS
just
because
lambda
is
probably
the
oldest,
you
will
use
something
like
cloud
watch
to
actually
look
at
the
morning
during
something
like
x-ray,
which
is
basically
transactional
logging
and
it's
all
about
event-driven
right
I
put
something
in
s3:
bang.
It
spin
up
the
function,
so
that's
great,
but
the
question
is
now
I
have
all
these
technology?
Maybe
I
have
something
running
already
in
my
infrastructure.
Maybe
I
want
to
move
to
micro
services.
A
Maybe
I
have
some
functionality
in
this
application
that
actually
make
more
sense
to
do
in
service.
But
if
I
will
do
this,
the
question
is:
how
do
I
managing
it,
am
I
going
to
go
to
three
different
monitoring
tool
to
actually
figure
out?
What's
going
on,
that,
doesn't
really
make
sense.
So
what
I
try
to
do
is
to
figure
out
how
we
can
actually
merge
those
environments
and
the
way
I
see.
A
This
is
that,
if
you're
trying
to
do
this
exercise,
the
best
way
to
do
is
to
find
what
is
the
smallest
unit
of
computer
actually
share
between
those
environment,
and
in
my
opinion,
this
is
function
right.
If
you
think
about
it,
what
is
the
service
service
is
basically
an
API
call
that
calling
a
piece
of
code.
That's
not
that
different
than
microservices
is
just
going
to
be
more
function
in
the
same
binary
and
then
that's
not
different.
The
monolithic
application
again,
an
API
called
the
core
of
code.
A
It
just
means
that
you
will
have
more
function
in
this
binder,
so
what?
If
somehow
I
will
manage
to
actually
break
my
application
to
function
and
when
I'm
saying
break
I'm,
not
really
mean
break
I
mean
discover
them
all
and
then
basically
be
able
to
route
to
them.
Then
I
can
do
something
like
that
and
that's
what
I'm
calling
a
hybrid
application.
This
is
the
ability
to
actually
create
an
application
that
consists
from
different
type
of
architecture.
A
A
B
A
So
I
have
a
monolithic
application.
This
is
the
Lord
for
spring
application
right.
Everybody
know
it's
that
it's
pretty
obvious.
It's
actually
not
something
that
we
wrote
if
you're
looking
at
this,
it's
actually
written
by
the
people
tile
guys
and
they
wrote
a
very
simple
monolithic
application.
So
we
just
took
that
code.
You
know,
and
it's
complicated
as
you
can
imagine,
wanna
let
the
complication
all
the
code
is
here
and
so
on,
and
it's
working
right.
A
If
I'm
going
to
the
browser
and
I'm
actually
looking,
you
can
see
that
I
can
easily
browse
and
see
everything
that
exists
there
and
it's
working
fantastic,
but
here's
the
thing
I
have
a
new
engineering.
My
team
I
really
really
really
want
to
add
a
new
column
here.
What
does
it
mean
that
this
guy
need
to
do
so?
The
first
thing
that
you
need:
you
need
to
actually
learn
the
code
itself
after
along
the
code.
You
need
to
actually
add
the
functionality.
Then
you
need
to
test
it.
A
Then
you
need
to
regression
test
it
to
see
that
it
didn't
break
anything
and
only
then
I
need
to
redeploy
monolithic
application.
That's
quite
a
lot
to
add
a
new
column,
so
here's
what
we're
going
to
do
instead
of
it
so
I,
run
a
very
small
go
microservices
application
here.
Basically,
the
only
thing
that
is
doing
is
going
directly
to
the
database.
Getting
all
the
information
that
I
need,
render
an
HTML
and
serve
it.
It's
pretty
pretty
simple
reading
and
go.
But
again,
this
is
all
the
fat.
This
is
all
it's
doing
right.
A
B
A
Everything
that
I'm
showing
in
the
UI
it's
basically
translate
eventually
to
a
CL,
C
or
DS
in
kubernetes.
In
that
case,
which
means
that
you
can
use
it
with
Yama
file,
you
can
use
it
from
CLI.
You
can
use
it
also
from
the
UI.
So
when
I'm
clicking
on
this
we're
already
taking
advantage
of
the
platform
that
I'm
running
on-
and
in
that
case
it's
open
shift
from
a
reddit,
so
I'm
just
going
to
log
in
with
their
credential
and
I'm
already
seeing
what
I
can
see.
Can
you
see
that?
Well,
it's
big
enough
won't.
A
Okay,
okay,
cool,
so
basically
what
you
can
see
that
glue
already
just
by
installing
glue,
we
have
a
very
interesting
discovery
system
that
already
discovered
a
lot
of
stuff
low
running
on
my
infrastructure.
So
let's
see
what
we
have
here.
So
the
first
thing
that
you
see
there
is
a
lot
of
lambda
function.
It's
basically
discovered
some
lambda
function
that
running.
We
can
go
to
it
and
see
that
it's
running
going
east
y1
right
in
the
US.
We
can
see
that
there
is
other
function
that
we
discover,
like
basically,
a
swagger
open,
API
function.
A
That
running
on
cubanelle
is
this
is
what
you
can
see
here
right,
it's
running
on
Campinas
as
a
service,
but
you
discover
even
the
spec
of
the
open
API
calls.
We
can
see
some
of
GOP
see
so
it's
discovered
some
geography
function,
they're
running
on
kubernetes
and
it
discovered
quite
a
lot
of
services
that
running
on
kubernetes.
So
now,
if
we
will
go
quick
and
we'll
do
the
pet
clinic,
which
is
the
application
that
we
just
ran,
you
will
discover
that
I
have
these
things,
which
is
basically
the
monolithic
application
lifting
shift.
I.
Have
this?
A
That's
basically
is
the
database,
and
then
there
is
the
go
micro
service
that
I
just
wrote.
Now
we
can
go
to
the
route
and
can
see
that
I
basically
defined
an
application
called
default
and
in
default
I
have
one
route
everything
going
to
the
monolithic
application
right.
So
now
we'll
do
something
pretty
simple.
The
only
thing
that
I'm
going
to
do
is
I
will
come
here,
go
to
the
pet
clinic
again
and
what
I'm
going
to
do
is
I'm
going
to
add.
A
They
grow
micro
services
to
the
default
application,
and
here
I
will
say
every
time
that
in
the
browser
someone
going
to
slash
vet
as
a
prefix
go
to
disco
micro
services
and
that's
all
I
needed
to
do
so
now
we're
going
to
the
route.
You
will
see
that
now
I
have
to
route,
but
the
thing
is
that
slash
met
is
also
slash,
which
means
that
slash
will
take
everything.
So
what
I
need
to
do
is
to
sort
it
and
sorting
it's
pretty
simple,
just
move
it
up.
A
So
now
it's
first
going
to
look
for
search
vet
and
we
go
to
the
go
micro
services.
Otherwise,
if
I
go
to
the
monolithic
application,
so
now,
let's
see
how
it
works,
it's
pretty
simple!
So
this
is
a
java
application
and
when
I'm
clicking
here
this
is
a
go
micro
service.
You
see
this
is
already
update.
So
now,
basically
we
merge
those
two
environment
together,
but
there
is
another
thing
that
not
working
here,
and
this
is
the
contact
every
time
that
I'm
clicking
on
the
contact.
It's
not
working.
A
So
what
we
can
do
pretty
really
simple
is
we're
just
going
to
try
to
before
the
fun
to
run
along
the
hair.
So
every
time
that
someone
will
click
on
this,
it
will
run
a
lambda
and
I
can
edit
from
here
from
this
UI
right,
just
find
it
and
edit
like
we
did
before,
but
just
track
of
it.
We
will
go
to
the
route
and
we
will
edit
from
this
page
we're
going
to
say
to
the
default
application
every
time
that
someone
now
going
to
slash
contact
I
want
to
go
to
l.
A
A
So
what
we
did
we
extended
and
voi,
which
is
the
proxy,
and
we
will
talk
about
it
in
a
second
to
actually
support
transformations,
so
you
can
choose
source
for
whatever
protocol
you
want
to
whatever
one
you
want
so
again,
what
we're
going
to
do
we're
just
going
to
put
it
on
top
of
the
slash
and
now
when
we're
going
here.
This
is
a
Java
monolithic
application.
Every
time
that
I'm
clicking
here,
I'm
going
to
go
micro-services
and
while
clicking
on
top
contact.
A
This
is
an
OG
s,
pin
up
in
AWS
every
time
that
I'm
doing
it.
So
basically,
this
is
an
Android
application.
This
is
an
ability
to
take
now
why
it's
important
it's
important,
because
if
you
really
want
to
migrate
your
application
or
atom,
you
need
to
do
the
one
that
is
right
for
the
architecture,
not
not
using
something,
because
then
how
am
I
going
to
monitor
it.
So
what
guru
is
also
doing?
It's
basically
collecting
all
the
data
from
all
those
monitoring
and
bring
it
to
one
place.
A
B
A
Okay,
okay,
so
if
you
think
just
about
what
you
just
saw,
so
what
you
saw
right
now
is
a
product
that
is
in
time
of
way
the
technology
is
the
edge
of
the
edge
that
exists.
It's
it's
built
on
top
of
every
open
source
that
that
it's
reading
here,
sorry
based
on
top
of
envoi,
which
Android
is
the
proxy
that
lyft
wrote
actually
to
exactly
do
this
use
case
to
make
it
between
the
monolithic
to
Microsoft
and
glue
in
environment.
A
A
So
the
technical
people
here
we
are
basically
watching
storage,
it'll,
see
our
IDs
in
kubernetes
or
something
else,
and
once
something
changed,
we
basically
immediately
detected
sending
it
to
a
plugin
system
that
know
how
to
translate
it
in
that
case
and
for
proxy
and
then
just
aggregate
it
back
and
position
it.
That
means
that
if
there
is
new
feature
in
Android,
we
immediately
can
you
can
can
get
them,
and
if
we
want
to
write
something
we
can
go
very
fast.
A
That
means
that
we
can
always
be
on
the
edge
of
the
edge
and
there's
a
lot
of
interesting
technology,
other
technology
that
we
did
here
like,
for
instance,
the
heat
of
integration.
So
you
saw
a
quick
when
I
change,
something
in
the
in
the
UI.
It's
immediately
changed
on
the
on
the
network,
which
is
kind
of
like
dangerous.
A
What,
if
I
messed
it
up
so
for
that
you
need
some
way
to
actually
protect
yourself
and
the
way
to
do
it
is
basically
the
UI
or
the
CLI
eventually
translate
to
a
Yama
file
that
is
being
checked
in
to
get
on
your
on
your
on
your
on
your
advance
and
so
on.
So
we
talked
about
the
discovery
system,
so
the
discovery
system
is
one
thing.
A
Well,
we
discover
them
all,
because
if
we
do
know
the
signature
of
the
function,
it's
giving
us
an
ability
to
be
more
interesting,
more
protective,
for
instance,
in
terms
of
security.
If
we
know
what
we
should
expect,
we
can
actually
not
not
move
it
on
if
it's
not
a
good
idea.
The
other
thing
is
that
also
it's
going
to
help
us
help
you
with
with
or
help
you
with
with
the
transition.
A
The
other
thing
is
that
we
discovering
all
the
service
several
s
function
that
exists
out
there.
So
this
is
the
example
of
what
we're
supporting,
but
the
interesting.
In
my
opinion,
the
most
is
the
Kennedy
one
so
Kennedy
when
they
actually
got
out.
It's
coming
from
Google
when
they
got
out
they
basically
baked
a
was
depending
on
service
Maskull
sto,
coming
also
from
Google
that
it's
a
big
monster
and
but
they
didn't
need
all
of
this
in
order
to
support
that.
A
So
they
basically
look
for
a
different
ingress
that
ko
API
that
can
help
them
and
they
choose
glue
or
glue,
is
by
default
running
in
K
native.
But
as
I
said,
architecture
is
really
interesting
that
way
that
it
can
extend
if
our
purpose
is
actually
gluing
environment.
So
we
need
to
make
sure
that
we
can
run
everywhere.
We
can
persist
our
storage
anywhere
and
we
can
actually
also
watch
the
secret
show
which
really,
what
we're
doing
here
with
the
security
and
the
secret
that
it's
very
interesting.
You
saw
me
running
along
the
function
right
now.
A
What
you
didn't
notice
is
that
in
Mike,
because
I
did
not
show
you
that
in
my
client,
I
actually
didn't
put
any
secret
or
API
key,
and
the
reason
is
because
glue
is
watching
the
something
like
vault
or
kubernetes
security,
and
every
time
that
there
is
a
rotation
glue
is
detecting
it's
sending
it
to
enjoy.
So
then,
when
the
request
but
is
coming
on,
the
request
is
coming.
A
It's
basically
piggyback
that
creating
an
action
with
AWS
just
make
sure
that
it's
work,
which
means
that
something
rotate
you
don't
need
to
worry
about
that
which
I
think
is
very
comfortable.
So
that's
what
we
just
did
right.
We,
basically,
if
you
think
about
it,
we
do
the
environment
that
would
be
basically
glue
the
client
because
the
backend
is
still
totally
distributed
and
there's
no
relationship
between
the
backend
like,
as
you
can
see
here,
there
is
a
function
class
and
a
funk
multiplication.
A
There
is
no
connection
between
them
when
we
thought
about,
we
said,
can
we
create
any
connection
when
and
we
saw
that
we
can
now
what
we
did?
We
thought
about
graph
QL,
think
about
what
graph
QL
actually
is
doing
today.
Kraft
is
doing
some
collected,
what
it's
doing,
it's,
basically,
the
ability
to
actually
go
to
one
function,
collect
the
data,
then
send
it
to
a
different
function,
collect
the
data
in
a
French
and
represent
the
answer.
So
it's
basically
doing
a
flow
of
function.
A
If
you
think
about
it
right
what
everybody
trying
to
do
with
and
how
do
they
call
it
walk
lambda
for
something
there
are
my
right,
but
basically
that's
exactly
what
they're
trying
to
do,
but
graphically
are
giving
you
to
do
that
with
a
very
simple
language
of
query
language.
So
what
we
did
we
basically
said:
Android
by
far
is
the
best
and
a
proxy
that
exists
to
the
end
of
mark.
Yet
what
we
built
here,
it's
very
interesting
because
we
are
rounding
on
the
level
of
the
function,
not
like
other
oast.
A
So
what
if
we
can
actually
build
a
graph
to
on
top
of
envoi
when
the
resolver,
which
is
basically
explain
which
function
to
call
with,
we
can
actually
always
pointed
it
to
enjoy,
and
because
envoi
is
all
about
configuration,
we
can
actually
change
it
and
define
it
without
changing
anything
in
the
application
itself.
So
we
show
you
what
I
mean
and
again
everything
is
open
source.
We
calling
it
scoop,
it's
open
stores,
go,
try
them
I,
think
it's
pretty
cool,
so
they're
gonna
be
really
a
small
example.
A
I
have
this
application
that
I
will
make
it,
but
it's
basically
just
a
company,
and
there
is
two
division
there.
One
of
the
first
one
is
Human
Resources
HR,
and
this
is
all
the
people
that
working
and
if
they
are
good
or
not
right,
it's
basically
what
is
the
pro
formas
valuation,
then
there's
the
engineering
and
the
engineering.
Basically,
it's
a
different
division
and
I
can
go
and
look
to
see.
What
is
the
project
that's
running
right
now
in
the
company.
When
is
the
deadline?
You
know
what
is
the
budget
and
so
on?
A
I
can
also
see
that
there
is
a
finance
division
and
the
finance
division
is
basically
holding
all
the
salary
that
exists
in
the
market.
But
what
you
don't
see
is
that
it's
basically
three
different
type
of
application:
the
first
one
it's
basically
the
finance,
it's
basically
a
lambda
that
going
to
a
back-end
service
and
bring
me
all
the
function,
the
second
one,
it's
basically
the
engineering
and
the
engineering
is
basically
a
swagger
open.
I
click,
open,
API
application,
that's
running
on
kubernetes,
the
third
one.
A
A
So
now
what
we
can
do
is
this:
we
can
easily
come
to
glue
and
basically
define
a
new
query
language,
a
new
API,
that's
basically
what
I'm
doing
a
new
API
that
I
wanted
to
support
and
tell
them
right
and
basically
said
this
is
the
new
API
that
I
want
to
support.
The
second
thing
that
once
once
you
do
this
immediately
its
defined:
what
is
the
resolver?
A
What
is
the
float
that
you
need
to
know
how
to
get,
because
it
doesn't
know
right
you
need
to
tell,
and
what
you
can
see
is
that
you
can
easily
go
here,
define
that
you
need
to
get
the
first
name
and
just
basically
from
the
list
of
everything
that
was
discovered
already
just
choose
which
function
you
want
to
call,
and
you
can
see
that
here
in
this
application
that
I
show
you
before
there
is
a
kubernetes
service.
This
is
how
we
define
it.
A
There
is
a
lambda
service
and
so
on,
and
you
can
just
see
how
you
can
glue
them
together
if
you're
going
to
it.
Another
thing
that
you're
getting
will
read
glow
is
basically
if
its
scope
is
basically
a
graph
QL
flag
run.
So
this
is
your
ability
to
actually
come
and
say:
oh
I,
wonder
what
the
query
should
be
and
it's
not
it's
autocomplete.
So
now
what
you
can
do
is
just
click
on
this
and
it's
going
and
basically
doing
exactly
head
right.
A
It's
basically
the
flow
went
to
one
function
and
give
me
the
information
went
to
the
other
service
gave
me
the
information,
because
we
build
on
an
invoice
and
we
added
we
added
a
lot
of
functionality.
It's
all
cash
and
even
secured,
is
embedded
in
this
side,
which
I
think
it's
really
cool,
and
you
know
here.
I
did
the
same
thing
just
with
reports
right,
so
you
can
get
the
information.
B
A
Everybody
that's
working
there.
Performance
is
good,
but
they
got
less
than
70
K,
for
instance,
right.
So
that's
kind
of
like
the
ability
to
bring
everything
together
so
now.
Hopefully
this
would
be
more
interesting.
We
will
talk
about
ok,
so
we
have
this
application
altogether
right.
The
only
question
is
how
to
debug
them.
How
do
you
actually
unify
the
toolings,
which
I
think
now
it's
the
biggest
problem
that
exists
in
the
market?
Okay,
so
this
is
the
tooling
the
way
I
see
it
today
right.
This
is
what
at
least
when
we
run
monolithic.
A
This
is
what
we
needed
to
do
to
have.
We
had
the
metrics,
where
someone
to
take
care
of
the
logging,
something
to
take
care
of
debugging,
something
taking
care
of
the
architecture,
development
and
testing
deployment
and
testing.
So
if
you're
looking
at
this,
for
example
in
metrics,
you
have
a
PM,
4,
monolithic,
primitives
for
micro
services,
the
most
famous
one
and
cloud
watch
for
lambda,
but
think
about
what
we
just
did
with
glue
we're
basically
in
working
every
function
that
exists
in
the
market
in
the
Oracle
system.
A
Even
if
it's
a
lambda
one,
which
means
that
we
can
go.
And
then
we
have
the
idea
to
suck
the
information
from
everywhere
and
bring
it
to
you
to
one
place,
for
instance
primitives.
But
it
can
be
everything
if
you're
thinking
on
the
logging.
It's
actually
very
more
interesting
because
you
know
you
can
use
blank
when
you
have
a
monolithic
application.
But
when
you
started
to
actually
using
instances
and
replication,
there
is
a
lot
more
of
service
instances,
and
you
don't
know
where
the
log
arse
and
usually
you're
getting
a
lot
of
other
flocks.
A
But
you
don't
know
how
to
correlate
between
them.
That's
what
open,
tracing
and
open
consensus
is
doing
for
you,
they
giving
a
transaction
ID
on
the
beginning
of
the
request
and
then
the
following
up:
they're
only
taking
the
errors.
So
you
need
to
block
that.
But
eventually
you're
getting
what's
called
a
span,
which
is
an
ability
to
actually
to
see
oh
micro-service,
a
called,
be
call
see
that
called
e,
and
here
is
all
the
logs
that
I'm
collected.
That's
very
interesting,
but
again
it's
in
London.
A
You
know
lambda,
you
have
something
called
x-ray,
that
AWS
is
providing
you,
but
because
we
actually
the
one
that
is
working
everything
we
can
actually
make
sure
that
the
code
you
know
to
bring
all
this
information
and
create
a
span
that
this
could
be.
Those
logs
is
from
analytic.
Those
log
is
for
micro
services
and
does
logout
former
servicemen
several
s.
So
basically
you
connect
all
of
them
together
now
debug
and
debugging.
This
is
where
I'm
very
passionate
about
I
mean.
A
If
you
see
every
time
that
we
had
something
in
monolithic,
we
managed
to
create
the
tooling
in
x-ray
monolithically
created
during
in
micro-services
or
service.
But
what
we
didn't
do
is
we
never
solve
this
problem
of
debugging
and
debugging
is
amazing.
I
mean
there
is
no
better
feeling
than
just
take
you,
no
wonder
its
application,
attach
the
debugger
and
understand
what
everything
that
happening
in
the
moment
on
the
same
point,
but
what
we
doing
with
Microsoft
server
less
its
troubleshooting.
A
We
are
not
bugging
anymore
and
that's
why
we
created
a
tool
called
squash
and
I
will
show
you
there.
Second
kotecha
is
the
same
thing.
There
is
a
soil
heat
texture,
there
is
micro
services
and
they
revenge
driven.
But
who
said
that
event-driven
cannot
be
also
for
micro
services,
so
that
is
or
something
that
we
did,
that
giving
you
the
ability
to
basically
use
something
like
Nats
of
Kafka
to
actually
spin
up
an
event,
and
then
we
should
fix
the
development
and
the
testing.
A
So
we
shared
one
second,
the
debugging
I'm
again
I'm
a
big
big
fan
of
debugging,
so
I
will
show
you
why
kind
of,
like
I,
feel
that
this
is
a
strong
problem
and
I
will
show
you
always
solve
it.
So
the
first
one
is:
why
do
we
have
a
problem?
So
again
we
have
a
problem
because
before
we
had
one
big
binary,
when
we
have
this
big
one,
big
binder,
it
was
pretty
simple
because
all
the
state,
what
is
the
side?
A
So
if
we
actually
going
to
attach
the
debugger,
we
will
see
everything
that
happening
in
the
memory.
On
that
point,
and
that's
great,
but
that's
not
the
case
anymore
right,
we
decided
to
go
distributed
when
we're
going,
distribute
it
never
mind
if
it's
several
s
or
microservices,
we
basically
just
took
the
state
of
the
application
and
spread
it
all
around.
So
now
that
the
stake
is
not
in
one
place,
so
you
can
just
attach
the
bugger.
A
You
don't
know
what's
going
on
on
the
others
and
that's
very
problematic,
it's
also
problematic
to
know
where
to
attach
the
debugger
there.
It's
a
really
really
big
problem
now.
I
saw
example
of
micro
services.
This
is
actually
how
people
actually
run
it
micro
service
today
in
production
right,
there
is
like
my
fan
replies.
So
that's
a.
B
A
Of
micro
services,
so
how
are
you
going
to
manage
something
like
that,
and
this
is
a
tweet
that
someone
tweet
not
long
time
ago
and
I'm
really
really
like
it,
because
I
think
it's
really
true
right,
you're
moving
and
then
good
luck.
So
so
the
question
is:
how
can
you
actually
fix
it?
So
I
will
show
you
what
we
did.
It
would
take
a
second
because
I
need
to
spinning
it
up,
but
basically
this
is
what
we
thought
that
we
should
do
so.
I
will
start
the
demo.
A
A
A
Be
given
another
second,
if
it's
not
going
to
work
I'm
going
to
just
kill
it
myself.
So
it's
all
these
things
like
all
this.
The
buggers
are
already
working
and
exist,
and
the
question
is:
what
can
I
do
in
order
to
actually
orchestrated
them
to
simply
work
in
environment
of
micro,
service
and
service,
and
that's
exactly
what
we
did
and
I
will
tell
you.
We
almost
there
last
series,
all
your
choice,
not
I'm,
just
going
to
kill
it.
B
A
Starting
awesome,
so,
okay,
so
so
so
that's
basically
what
we
try
to
do
here.
Basically,
what
we
did
we
orchestration
of
debugger.
We
just
basically
want
to
make
sure
that
it
would
be
really
really
simple
for
you
to
do
back.
You
micro-services.
There
is
a
little
timer
right
now,
just
to
make
sure
that
everything
is
connecting
there
and
then
I
will
show
you
the
demo.
So
what
we're
going
to
show
here
is
that
it's
basically
a
very
simple
application.
A
It's
called
it's
a
calculator
that
basically,
what
it
can
do
is
just
add
or
subtract
a
to
numbers.
It's
pretty
pretty
simple
here
you
go,
it
started
and
I
will
try
to
run
it
and
choose
to
number.
It
doesn't
really
matter
which
one
and
I'm
going
to
calculate
it,
and
we
discover
that
it's
not
working,
that's
pretty
annoying.
So
what
people
usually
doing
when
something
like
vacationing
with
Microsoft
and
service
is
not
working,
they
start
to
troubleshoot
lobs,
or
maybe
they
using
some
open
tracing
fine,
a
capability.
A
So
then
they
need
to
wait
and
it
may
be
to
the
log
and
then
wait
for
10
minutes
until
the
log
will
come
and
order
again
to
troubleshoot.
That's
not
debugging.
So
what
we
did
instead
is
this.
So
let's
understand
what
is
this
micro
service
application?
So
basically
it's
pretty
simple:
I
have
a
go
micro
services
that
basically
just
serving
the
HTML.
That's
what
you
can
see
here,
it's
pretty
simple!
A
It's
serving
the
HTML
of
this
page
is
taking
the
to
Palmiter
and
when
you
get
them
in
moving
them
to
a
Java
micro
services
that
running
here.
So
it's
this
one,
it's
just
a
very
simple
Java
micro
services
that
either
add
them
or
subtract
them
and
then
return
the
result.
So
it's
over
complicated
calculator.
Now
this
is
running
that
go
micro
service
is
running
on
on
Visual
Studio
code.
A
Just
to
show
you
the
weekend
to
do
any
idea
that
you
could
want
and
the
Java
one
is
running
on
the
IntelliJ
just
again
to
show
you
the
weekend.
So
here
is
our
I
feel
that
we
should
debug
our
micro
services
and
service
application.
Basically,
we
created
an
extension
called
squash
when
I'm
actually
going
and
asked
squash.
I
can
choose
squash
debug
container.
What's
happening
immediately,
is
squash
growing
and
basically
represent
me
all
them.
I
cross
all
the
pots
that
running
in
my
cluster.
This
is
service.
A
One,
so
I
will
choose
the
first
one
Danny
said:
look
in
this
body
of
one
micro
services:
do
you
want
debug?
It
I
will
say
yes
and
then
it
was
so
which
debugger
do
you
feel
like
attached
to
it,
and
this
is
reading.
It
goes.
I
will
go
with
the
DL
VD
body,
so
that's
it.
So
now
that's
running
in
East!
So
fully
the
network
will
play
nicely
with
us,
but
that's
it.
I
attach
the
debugger.
Now
will
do
exactly
exactly
the
same
thing.
A
In
IntelliJ
we
will
write
squash
debug
container,
we're
going
to
choose
service
to
Java,
because
this
is
Java
and
then
we're
going
to
choose
the
container
that
running
there
and
we
attach
the
Java
debugger.
So
we
attach
the
coding
bag
to
deal
v2
the
go
code.
We
attach
the
Java
debugger
to
the
Java
code,
and
now
the
only
thing
that
I
need
to
do
is
just
basically
click
the
button
and
that's
it
I'm
debugging
it
so
I
can
actually
easily
step
into.
A
And
you
see
here-
and
hopefully
it's
big
enough
for
you
guys,
you
can
see
the
numbers,
you
can
see
that
we
said
201
or
1234
80
89.
Now
what
will
happen
when
I
will
click
next,
so
jump
to
the
other
microservices
right,
because
I
put
a
breakpoint
and
again
I
can
see
that
everything
is
working
I'm
going
to
step
into
him
again
it's
in
u.s.
East.
So
it's
a
little
bit
slow,
but
you
will
see
in
a
second
that
I
can
actually
jump,
and
what
you
can
see
is
that
it's
true,
it's
good
right.
A
A
And
not
pass,
but
this
is
simple.
This
is
a
regular
debugger
right.
This
is
the
Java
debugger.
Let's
just
change
it
to
online
on
one
time,
just
going.
Oh
sorry,
I'm
just
going
to
go
to
the
easy
edit
I'm
going
to
change
it
to
false
in
the
memory
right,
so
nothing
really
changes
just
in
memory
and
then
what
I
will
do
next?
What
will
happen?
It
will
jump
to
the
other
micro-services
because
I
put
a
breakpoint
and
then,
when
I
will
click
this
Bank.
It's
fix
the
problem
so
now,
I
know
what
to
do.
A
I
don't
need
logs
I,
don't
need
anything.
I
saw
what
happened,
and
you
see
it
was
very
simple.
So
this
is
how
I
think
that
we
should
debug
it
now.
Imagine
you
jumping
between
monolithic
to
micro,
server,
to
server
less
I
think
this
is
where
it
would
be
interesting.
We're
working
right
now
with
the
K
native
team
to
actually
edit
server,
2k
native
and-
and
there
is
a
lot
more
that
we
can
do
on
this
space,
but
I
feel
that
this
is
the
white
people
need
to.
A
A
Okay,
so
now
we
saw
to
debug
it,
we
explain
a
little
bit
why
today,
just
you
will
know
it's
again:
it's
open
source
so
go
ahead
fun.
So
basically
squash
has
two
type
of
running
the
first
one.
Is
that
if
you
run
it
look
locally,
you
don't
care
you
are
on
the
cluster.
We
can
do
whatever
you
want.
That's
the
default
mode.
The
other
mode
is
that
if
you're
running
with
your
teammate,
you
don't
want
other
people
to
attach
to
your
application.
A
So
we
need
to
verify
that
you
allowed
to
say
that
and
I
will
explain
in
a
second.
Are
we
doing
and
what
is
interesting
about
what
we're
doing
here.
So
the
simple
one,
even
though
I
what
securement
think
it's
pretty
simple,
you
have
a
container
in
name
space
in
that
case
is
name
space.
A
what
we're
doing
is
there
is
a
name
spits
it.
Basically,
it's
a
command
line
that
it's
automatically
already
we
using
it
from
the
extension
name.
Space
squash
is
just
going
to
put
the
debugger
and
going
to
attach
to
the
microservices.
A
That's
really
really
simple,
but
it's
not
that
simple,
because
the
question
is:
if
both
of
them
are
running
in
different
name
space
and
different
container,
what
is
the
PID
that
I
need
to
actually
attach
in
the
name
space
of
the
host?
Because
that's
what
problem
and
that's
the
really
magical
go
in
in
squash?
What
we
did
here,
which
I
feel
very,
very
nice-
it's
been
able
to
find
the
PID
of
this
application
on
the
namespace
of
all
the
Earth's
in
the
operator
system.
A
What
we're
doing
here
is
this
we're
basically
using
the
you
know
we're
going
to,
in
that
case,
in
kubernetes
to
something
called
Cree,
which
is
the
container
runtime
interface
and
we're
basically
running
a
command
to
understand.
What
is
the
unique
identifier
of
this,
and
this
is
how
to
do
this.
This
is
like
an
operate.
The
system
flat
low
level,
but
basically
that
way
we're
getting
the
PID
and
then
the
only
thing
we're
doing
is
basically
attached
to
the
PID
that
we
discover.
So
that's
pretty
simple
again.
A
The
beautiful
is
that
what
you
ask
what's
special
about
squash?
Is
we
doing
all
the
piping
for
you?
You
don't
need
to
worry
about
it
right.
We
just
figure
it
out.
We
are
touching
everything
boom.
It's
running,
debug
it
now
secure
mode.
So,
first
of
all,
I
need
to
know
that
you
cannot
so
that
you
can
debug
this
micro
services
and
to
all
of
it
in
order
to
do
this,
I
need
to
make
sure
that
you
have
actually
a
permission
to
this
namespace.
So
when,
first
of
all,
you
need
to
run
squash
as
a
service.
A
That's
the
way
we're
actually
making
sure
that
it's
here,
which
is
very
simple,
small
micro
services
and
then,
when
you
actually
want
to
debug
some
things,
we
writing
them
intense
to
the
namespace
that
the
application
running
it.
If
it's
exceeded
its
mean
that
you
have
permission.
If
it's
not
succeed,
we
know
that
you
cannot
debug
it
you're
immediately.
Getting
an
error.
You
don't
have
permission,
but
if
we
did
succeed,
squash
is
actually
looking
to
see
if
this
year
it
is
added
and
then
same
thing
just
create
the
container
of
the
debugger.
A
Attach
it
and
you
have
it
secure
okay.
So
this
is
great
the
question
that
we
have
right
now.
Can
you
debug
it
in?
Can
you
use
squash
for
production,
and
you
knows
that
it's
not
a
good
idea.
You
don't
want
to
attach
to
your
application
running
in
production,
something
like
DL
DL,
vo
gdb.
Is
you
really
do
not
want
to
do
that?
So
what
you
need
to
make
sure
is
that
you
know
how
what
and
also
it
will
pause
your
request
right.
A
So
again,
not
a
good
idea,
but
to
be
fair,
we
all
care
about
production
right.
So
the
question
is
what
we
can
do
with
this.
So
I
want
to
show
you
something
that
I'm
really
passionate
about
it
and
we're
working
on
it
with
lift
actually
because
lift
asked
for
it.
So
explain
you
what's
going
on,
so
it's
pretty
simple.
Let's
say
that
I
have
a
request
coming
to
my
cluster.
It's
going
to
all
those
micro
services.
Maybe
from
these
micro
services,
is
going
to
die,
debase
or
s3,
and
it's
getting
out
there.
A
Is
this
technology
called
service
mesh
that
actually,
my
employee
is
talking
about
it
right
now
in
the
other
tent
and
unfortunately,
because
it
should
have
probably
see
that?
Maybe
that's
where
everybody
so
basically
service
mesh
is
the
ability
to
say
well.
That's
too
complicated,
like
you
know,
that's
interesting,
but
every
time
that
you
actually
want
to
do
something
like
security
like
observability
to
your
cluster
like
make
sure
that
this
to
microservice
can
reach
to
each
other.
A
What
you
need
to
do
is
actually
you
need
to
make
it
inside
your
application
code
and
that's
never
healthy
right.
I
mean
that
means
that
if
I
have
a
new
library
for
logging
I
need
to,
then
you
know
deploying
your
micro
services,
which
is
again
it's
not
a
good
tip
at
decouple.
You
don't
want
to
do
that.
A
So
people
came
in
with
this
technology
that
came
called
service
mesh,
which
is
basically
the
ability
to
put
to
abstract
this
law
and
by
the
way
after
you
doing
it,
you
need
to
give
it
to
something
like
open
tracing
that
basically
body
throwing
is
running
this
proxy
that
we
running
it's
called
invoice
the
the
proxy
that
we're
running
glue
on
and
basically
just
putting
next
to
every
application.
Every
microservices
this
site
called
this
proxy
and
basically
tricking
the
IP
table
to
talk
only
to
this
proxy.
A
So,
basically,
every
traffic
in
and
out
from
this
micro
services
or
monolithic
application
or
anything,
is
going
through
this
proxy.
Now,
what
is
40
proxy
is
basically
done
right.
It
can
tell
to
do
everything,
but
you
need
to
tell
me
what
to
do
and
for
that
there
is
something
called
control
plan
that
need
to
manage
those
proxy.
If
you
think
about
this
is
exactly
what
we're
doing
with
glue
right.
We
abstract
the
network,
that's
why
we
can
do
a
lot
of
stuff,
because
we
own
the
request
but
can
append
stuff.
A
So,
if
we're
doing
this,
that
means
that
before
that,
when
these
things
happen,
when
you're
actually
getting
a
request
to
go
first
to
the
proxy,
the
proxy
can
propagate
it
to
the
cloud
you
know
to
you
know
they
logging
somewhere,
you
can
tell
him
that's
not
allowed
to
talk
to
these
micro
services.
You
can
tell
them
going
round
to
this.
You
can
own
all
these
technology,
so
that's
something
very
popular
that
to
the
next
year.
This
is
this
is
like
the
most
the
most
interesting
stuff
happening
in
this
ecosystem.
A
The
problem
with
that
is
that
you
didn't
solve
the
problem
of
so
yeah.
Now
you
can
actually
make
the
proxy
not
modifier
application,
take
the
logs
and
put
them
somewhere.
This
is
great.
It's
given
observer
ability.
The
problem
with
that
is
that
there
is
a
lot
of
logs.
If
you're,
actually
putting
everything
there,
you
will
kill
your
network.
So
the
question
you
know
they
hover.
It
will
be
huge.
So
what
people
doing
and
open
tracing
there
is
two
cons.
Oh
sorry,
open
tracing
is
there's
two
contacts
conference.
A
One
of
them
is
you're
only
taking
the
others,
which
means
that
you,
as
a
developer
responsible
to
put
the
data
in
the
other
and
the
second
thing,
because
again,
then
there
is
not
so
much
data,
and
the
second
thing
is
that
you
have
to
sample
sample
is
the
most
important
out
in
open
tracing.
You
can't
collect
everything
you
will
kill
the
network,
so
this
is
great,
but
the
question
that
I
asked
when
I
try
to
figure
out
how
to
debug
something
in
production
is,
do
I
really
care
about
everything
that
is
good.
Something
is
good.
A
A
Now,
if
the
request
is
good
I'm,
just
tossing
it,
it's
not
even
going
out
of
the
network,
but
if
something
is
going
to
bed,
then
when
I
care
about
this
and
then
what
I'm
going
to
do
is
I'm
going
to
save
it,
but
awfully
there
is
not
so
many
bugs.
So
you
will
choose
on.
You
will
use
only
what
is
really
relevant
now
think
about
it.
A
The
proxy
is
actually
also
piping
it
to
the
database
and
to
and
to
s3,
and
also
bring
it
to
the
application,
which
means
that
you
basically
got
a
snapshot
on
everything
that
went
to
your
application
and
go
out
from
your
application,
which
means
everything
that
you
got
from
the
database.
It's
like
a
snapshot
on
your
environment
with
service
much.
We
can
also
actually
see
the
latency
between
them
so
now
and
they
recalling
a
globe
by
the
way,
isn't
also
going
to
be
an
open
source
project.
A
So
if
right
now
actually
recorded
this,
it's
as
simple
for
me
to
just
spin
up
the
same
environment,
there
inject
the
curl,
do
curls
and
basically
inject
everything
that
happened
in
production
and
attach
squash
and
now
I
can
actually
debug
a
basically
replay
every
port
production
problem
that
I
have
without
actually
interfering
whatsoever.
The
production,
environment
and
I
think
this
is,
you
know,
will
be
very
useful,
believe
there's
a
different
use
case,
but
lyft
is
doing.
A
You
know
if
lyft
is
a
like
uber
and
what
happening
if
you
calling
a
my
lift,
is
not
here
usually
what
they
have
like
a
support
team
that
have
that's.
Well,
then
they
want
to
record
everything
that
related
to
you
that
we
will
be
able
to
understand
what
the
problem.
So
this
is
basically
a
really
use
amazing
use
case.
A
In
my
opinion,
this
is
it
like
the
feed
below
forgetting
about
it
is
really
big,
so
I
mean
I
can
show
you
a
quick
demo
if
we
have
time,
but
we
don't
have
a
lot
of
time,
but
we
all
we
can
defer.
That
may
be
ready
for
it,
but
there
is
basically
I
wanted
to
show
you
what
I
just
described.
So
you
believe
me
that
its
work
so
I'm
just
going
to
summarize,
because
we
out
of
time
basically
this
is
what
I
show
you
right
now.
I
show
you
tools,
those
tool
is
all
open
source.
A
You
can
all
use
it.
First
one
is
glue,
which
is
basically,
in
my
opinion,
the
best
API
that
exists
out
there.
I
did
I
couldn't
talk
too
much
about
the
technology
there,
but
it's
really
special,
the
second
one
and
again
it's
treating
function
as
the
first
entity,
which
means
that
it
will
play
very
nicely
with
server
less
it's
going
to
just
basically
glue
the
environment
and
help
you
migrate,
the
serpent
one,
it's
cool:
this
is
the
graph
PL
again
open
source
just
go
check
it
out
and
then
the
last
one
is
squash.
A
This
is
the
debugger
we
talked.
So
this
is
what
we
have
I
said.
I
didn't
have
time
to
talk
about
everything,
but
we
have.
But
actually,
if
you
are
interested,
you
can
go
and
check
it
out,
but
basically
we
have
super
glue,
which
is
basically
the
best
way
to
start
with
service
mesh
today.
Basically,
what
it's
doing
it's
coming
with
an
opinion
API
that
it's
very
simple
and
let
you
consume
whatever
meshes.
A
So
this
is
what
I
show
you
today
and
the
last
one
is
going
to
announce
a
service
mesh
hub,
because
we
believe
that
service
mesh
is
the
future
for
several
s
for
micro
services,
for
everything
that
happening
today,
because
the
right
way
to
actually
build
your
application
is
to
abstract
the
operation
from
it
and
you
should
come
and
see
it,
but
going
to
be
basically
very
great.
So
that's
all
I
have
and
thank
you
so
much.
B
B
C
A
Definitely
it
so
the
way
we
build
everything
that
we
build
in
our
in
our
glue
is
basically
interface.
That
way
that
it
would
be
very
easier
to
you
to
do
it
by
yourself
if
you
want
to
use
it
from
the
open
source
or
ask
us,
and
we
will
do
that
for
you,
it's
a
very
clear
interface
and
very
simple
to
do
so.
We
can
support
anything
you
want
and
that's
the
beauty.
That's.
A
Definitely
and
more
than
this
I
will
say
so
you
will
see
another
announcement
coming
out
for
us,
so
there
is
a
product
called
a
flogger
from
we
work
and
we
work
together
to
actually
integrate
it
with
glue
and
to
integrate
it
with
superglue,
which
is
our
for
service
match,
and
you
can
do
a/b
testing
and
it's
really
actually
beautiful.
So
it's
watching
your
primitives,
you
don't
need
to
do
the
traffic
shifting
yourself.
It's
just
basically
giving
me
threshold
and
it
can
do
that
manually.
It's
a
parade
all
right
and.
A
So
anyways
and
where's
the
future
I
mean
in
HD
poxy
is
solid
people
running
it
in
production.
I
think
that
in
envoi
there
is
like
you
know
we
needed
to
choose
when
we
build
glue
and
the
reason
with
what
we
choose.
You
know
we
started
from
scratch,
so
we
actually
could
have
choose
whatever
we
want.
The
reason
we
choose
Android
is
because
two
reasons.
First
of
all,
that's
the
best
use
case
that
was
built
for
that
for
me
creation
and
that
what
we
wanted
to
glue
those
environment.
A
The
second
reason
is
because
the
way
Andrew
is
built,
there's
a
few
things.
First
of
all,
there
is
ability
to
extend,
extend
it
for
real
and
that's
really
good.
There
is
a
main
I
wrote,
a
big
actually
blog,
that
I
would
love
you
to
read
basically
I'll
and
what
is
working
and
it's
basically
showing
that
the
way
the
flow
is
working
is
that
when
a
request
is
coming,
then
it's
going
through
a
filter
system
and
you
can
just
roll
it
bright
filters
and
make
you
do
whatever
you
want.
A
Basically,
now
it's
also
really
really
performant
and
also
because
Google
choose
it
as
stos
proxy
for
service
smash,
there's
a
huge
community
around
it.
So
I
mean
we
are
the
top
contributor
together
with
Google.
Together,
we
live
together
with
Apple,
even
Amazon
everybody
using
it
right
now,
so
that
will
be
the
future
they're
going
to
also
it's
part
of
the
CN
CF
they're,
going
to
put
to
create
it
right
now,
another
layer
for
API,
so
I'm,
a
big
fan
I
have
no
doubt
that
that's
will
be
the
winner,
so
HP
box
reports.