►
Description
Squash: A Debugger for Kubernetes Apps - Idit Levine, solo.io
Squash is a tool for debugging distributed applications.
Most cloud native applications written today follow the microservice architecture. These applications are distributed by nature, and therefore hard to debug.
Microservice engineers debug their applications by printing values of select variables into log files. This leaves them with the daunting task of sorting through reams of log data, which at best provide a partial view of the state of application. This approach is cumbersome, time consuming and works better with "easy" bugs.
Many advanced tools to debug monolitic applications exist in the market, and provide users with powerful ways to dissect their programs and to interact with them on the fly. However, these tools cannot be used directly for debugging applications that follow the microservice architecture pattern.
Squash is designed to bring the strength of modern debuggers and the convenience of their IDEs to microservices developers. Squash uses popular, powerful and mature debuggers (gdb, dlv, java debugging) and integrates them seamlessly with Kubernetes. This allows devs to use the debugger of their choice, and the IDEs that support it, to develop microservices on any platform.
About Idit Levine
Founder, solo.io
Idit Levine is a leader and innovator in the Cloud open source community, and the founder of solo.io. Until recently, Idit was CTO for cloud management division at EMC and a member of its global CTO office, where she had focused on Management and Orchestration (M&O) over the entire stack and on microservices, cloud native apps, cluster management and Platform as a Service.
Idit’s fascination with the cloud sprouted when she joined DynamicOps (vRealize, now part of VMware) as one of its first employees. She subsequently took part in developing the new-generation public cloud of Verizon Terremark, and served as an acting CTO at Intigua, a startup company that focuses on container and management technology.
Join us for KubeCon + CloudNativeCon in Barcelona May 20 - 23, Shanghai June 24 - 26, and San Diego November 18 - 21! Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy and all of the other CNCF-hosted projects.
A
Hi
everybody,
and
thanks
for
coming
here
so
we'll
talk
today
about
their
project
called
squash.
It's
an
open-source
project
and
we
kind
of
like
try
to
understand
what
is
the
motivation
of
creating
and
what
gap
is
kind
of
like
covering
the
ecosystem
and
I
was
going
to
integrate
with
everything
that
we're
doing
today,
so
quick
water.
What
myself
so
my
name
is
Edith
levine
and
I'm
the
founder
of
a
company
called
salah.
It's
a
startup
company
and
these
specifically
project
weeds
were
done
by
me
and
by
my
employee
Caldwell.
A
A
Ok,
so
what
is
the
problem
with
that
to
try
to
solve?
So
you
all
know
about
it,
and
it
will
go
very
fast
because
I
know
that
you
guys
know
all
of
this,
but
basically
divided
my
first
micro
service
application.
It's
another
problem
today
and
it's
really
really
simple.
Why?
Because
way
on
the
bed
back
on
the
day
we
had
want
to
lay
the
complication.
A
If
you
wanted
to
actually
debug
it
and
understand
the
stage
of
the
application
you
needed
to
just
attach
a
debugger,
and
basically
you
got
a
picture
and
an
image
of
all
what
happening
in
the
memory
right.
You
basically
saw
the
state
of
the
application
can
see
they
even
stuck.
You
can
actually
see
everything
that
happening
and
the
story
understand
what
this
application
is
doing.
But
that's
not
the
case
right
now,
because
we
really
really
wanted
to
be
more
scalable.
We
needed
to
actually
kick
this
monolithic
application
and
cut
it
to
have
very
little
small
pieces.
A
So
now
it's
a
little
bit
problem,
because
now
all
these
little
pieces
actually
has
their
own
kind
of
like
image
of
memory.
But
the
question
is
I
would
kind
of
like
understand,
what's
happening
in
all
the
application
itself,
and
you
know
here
it's
an
example
with
a
few
container,
but
actually
the
real
applications
that
were
running
today
and
production
will
look
more
like
this
right.
The
Netflix
of
the
word
and
Twitter
running
like
over
500
container,
so
it's
kind
of
like
very
complicated
to
tell
story
to
understand
the
story.
A
This
is
a
tree
that
was
fitted
back
then,
but
I
really
like
it
so
I
just
saw
that
it'll
be
amusing,
but
basically
sandwich.
Just
move
is
a
monolithic
application
for
micro
services
and
now,
every
time
that
he
has
an
outrage
is
basically
a
murder
mystery
as
any
considers
a
lot
of
people
simplified
with
this
problem,
because
it
was
treated
a
lot
and
we
liked
a
lot
okay.
A
So
now
I'm
not
going
to
talk
about
of
interesting
because
you
learn,
you
have
learned
so
much
about
it
on
the
last
two
days,
but
I
will
mention
it
and
mainly
what
I
will
focus
is
what
it
really
is
and
what
it's
not-
and
this
is
where
I'm
going
to
put
the
false
what
it's
not
going
to
do
for
you
and
where
I
see
the
gap,
so
will
quick
again.
You
know
that
I'm
going
to
go
very
very
quickly.
The
idea
is
that
it's
a
transactional
logging
you're
taking
the
ID.
A
You
send
it
to
all
the
pieces
of
your
own
transaction
application,
you're
getting
a
peak.
You
know
you
big,
you
can
actually
get
picture
of
something
like
that
right.
So
now
you
have
tracing
and
span.
You
basically
understand
the
application,
look
who
is
calling
who
and
what
they
do
it.
Okay,
so
that's!
Basically
what
open
tracing
is
I'm
not
going
to
talk
about
that
again.
This
is
for
people
who
doesn't
know
this
stuff,
but
we
talk
so
much
about
open
tracing
in
this
conference.
A
That
I
felt
that
you
probably
most
of
you,
understand
what
it's
doing
and
it's
in
the
foundation
and
I'm
not
going
to
show
you
a
demo,
because
you
probably
see
but
I
will
focus
on
this
and
what
it's
really
easy,
what
it's
trying
to
solve?
What
is
this
purpose
and
not
what
we
be
using
to
be
because
we
kind
of
like
abusing
with
what
it
really
is.
So
what
it
is?
It's
a
logging
right.
This
is
what
it
is.
It's
basically
you
log
in
your
application
and
logging.
A
It's
basically
main
training,
that's
what
we
doing
right,
it's
a
really
good
one,
but
what
it's
doing
it's
logging,
what
you're
not
logged!
You
don't
know
right.
You
can
kind
of
extra
sit
and
people
in
Hoover,
for
instance,
URI
is
doing
it
that
basically
you're
taking
it.
It
was
login
that
you
collect
and
kind
of
like
freedom
as
a
metrics
to
different
tools,
metrics
tool.
But
again
this
is
not
what
it's
for
right.
It's
basically
it's!
Okay!
Now
you
are
getting
a
compare.
A
It's
in
code,
its
conception,
a
login,
which
means
that
you
actually
know
the
context
of
the
logging.
So
you
can
actually
see
it
much
better
and
see
how
it
view
and
understand.
Where
is
call
who
and
so
on,
but
again
Dean
is
saying
that
it's
logging
now
you
can
understand
the
critical
path
analysis
a
little
bit.
A
If
you
see
what's
going
on
who
is
calling
Hilary,
you
kind
of
I
get
a
picture
of
where
could
he
have
a
problem
latency
and
then
you
can
analyze
it
right
so
because
you
do
see
the
topology
right,
but
here's
what
it's
not
and
here's.
What,
for
my
opinion,
is
weakness
of
the
solution,
so
open
tracing
is
not
a
runtime
debugger.
Basically,
you
send
me
Golding
furnish
him
somewhere,
it's
aggregating
the
log,
it's
massage
it
and
you
will
see
it
ten
minutes
after
right.
A
A
So
if
the
poet
you
have
a
problem
that
you
didn't
think
about,
or
you
don't
know
what
is
they
permitted
they're
doing
your
problem?
You
will
not
see
their
and
what
you
will
need
to
do
is
actually
go
to
the
application
print.
It
again
send
it
to
your
to
your
to
your
aid
to
product
it
to
to
the
system
again
push
it
again,
and
then
you
will
need
again
to
basically
ma
wait.
A
10
minutes
until
you're
getting
the
logs
the
like
the
next
thing
is
that
as
I
said
it's
basically,
you
can
change
horrible
in
in
run
time,
because
it's
not
a
run
time
debugger.
So
basically,
you
can
only
see
that
after
10
minutes-
and
you
know,
there
is
a
very
good
presentation
that
you
saw
this
week
about
open
tracing
for
Ben
and
and
a
from
like
step
and
from
people
like
Yuri.
A
A
All
we
did
is
basically
dealt
a
lot
with
operated
system
and
unique
kernel
and
I
was
doing
a
lot
of
core
application
and
my
best
friend
was
the
debugger.
Basically,
we
took
a
uni
Karen
or
from
foreign
we
put
it
on
Raspberry,
Pi,
guess
what
black
screen
you
can't
give
any
bug
it.
So
gdb
was
our
best
friend
right,
so
we
used
a
lot
of
debugger
and
then,
when
I
was
in
my
previous
company
and
I
was
working
with
my
nan,
my
new
engineers,
who
basically
born
in
the
cloud-
and
we
worked
on
some
application.
A
A
Flowered
and
I
felt
that
this
is
something
that
we
can
help
and
the
reason
it's
disappeared.
It's
for
that
for
not
used
right
now,
because
it's
complicated
right.
You
need
to
pipe
a
lot
of
stuff,
so
we
decided
to
do
the
piping
for
it.
That's
basically
what
we
did.
So
what
is
squad
squad
is
basically
orchestration
for
debugger.
So
what
it's
doing?
It's
basically
seamlessly
integrate
with
your
infrastructure
and
when
I'm
saying
infrastructure
actually
mean
platforms
and,
for
instance,
cubanelle
is
seamlessly,
which
means
that
it's
not
changing
the
platform.
A
This
really
really
key
stuff
that
we,
but
you
know
we
really
really
insist
of
not
changing
the
code
and
basically
that
way
it
can
use
with
the
open,
shipped
or
any
other
destroy
that
exists
in
the
market,
because
we
are
not
changing
the
kubernetes
code
itself
and
on
the
other
side
we
basically
piping
it
all
the
way
to
the
idea,
because
in
the
end
of
the
day,
this
is
what
we're
doing.
We
call
it
writing
code
in
the
want
to
debug
it.
A
That's
how
we
will
be
they
like,
so
what
you
getting
with
squash,
because
it's
basically
leveraging
the
regular
debugger.
We
are
not
writing
our
own
debugger,
we're
leveraging
all
the
debugger
that
exists
there.
So
what
we're
getting
from
it
is
like
debugging
course,
multiple
multi
micro
services
right.
You
basically
can
jump
between
micro
services
and
I.
We
showed
a
mock
soon,
it's
you
can
debug
container,
you
can
debug
pod,
you
can
you
can
debug
a
service,
you
can
set
a
broad
breakpoint.
A
You
can
step
into
a
baby,
your
code
and
the
last
thing
and
very
important
is
you
can
actually
modify
a
variable
on
one
time
and
see
how
it
will
affect
your
application.
So,
let's
see
demo
will
quick
that
way.
I
think
you
will
understand
what
I'm
talking
about
one
sec
environment.
Don't
worry
about
it.
It's
just
setting
up
my
environment,
which
one
even
AWS,
hopefully
the
network
will
not
kill
me.
A
Okay,
so
this
is
the
micro
services
application
that
I
wrote
really
really
simple
one.
Basically,
what
it's
doing
is
getting
to
parameter
and
freed
the
results
right
and
you
can
add
ed
of
subscribe,
so
I
just
put
whatever
value
we
want
here
doesn't
really
matter
and
we
will
calculate
and
we
see
that
it's
not
really
working
right.
55
plus
33
is
not
22,
so
we
have
a
buggy
right.
So
what
we
can
do
so
if
I
were
using
open
tracing
or
any
I,
don't
log
in
so
I
will
need
to
log.
A
I
will
need
to
change
that
in
my
application.
Push
it
again.
My
kubernetes
environment
and
I
need
to
wait
until
it's
actually
the
log
and
so
on,
but
maybe
I
don't
have
to
do
that.
Maybe
all
I
need
to
do
is
basically
go
to
this
application
in
the
ID
and
say
that
this
application
is
actually
building
from
two
microservices
I.
Don't
know
if
you
can
see
it,
but
it's
not
really
interesting.
It's
a
go
application.
The
first
services
is
basically
a
UI
right.
A
It's
basically
trying
to
write
the
UI
and
it's
getting
the
value
that
is
getting
and
it's
sending
it
to
the
second
domain
core
services.
Again,
everything
it
go
and
basically
it's
either
add
or
surprise,
really
really
simple
application.
So
what
I
will
do
next
are
basically
going
to
use
the
command
pilot
I,
don't
know
if
you're
familiar
with
Visual
Studio
code,
but
I
think
that
I
like
the
most
is
that
everything
you
can
reach
from
their
command
palette.
A
So
we
wrote
a
squash
extension
and
that's
giving
you
more
functionality,
so
extension
in
visual
studio
can
just
it
really
easily
from
the
marketplace.
You
install
and
you
have
all
this
capability.
So
what
we're
going
to
do
now,
we're
basically
going
to
run
debug
container
because
that's
what
we
want
to
do.
What
happened
is
that
the
idea
went
and
basically
talked
to
my
coop
coop
coop
coop
CTL,
basically
brought
me
on
the
product
running
that
I
can
see
right.
A
So
it's
kind
of
like
secure
only
what
I
can
see
and
because
it
service
one
I
will
choose
the
one
that
the
service
one.
Now
we
will
tell
you
present
me:
the
container
in
this
pod
I
would
choose
the
one
that
I
have,
and
you
asked
me
which
debugger
do
you
want
me
to
attach
and
I
will
say
the
only
because
it's
go
and
you
will
say
that
in
a
second,
it's
basically
attached
right.
So
now,
let's
do
exactly
the
same
thing
for
the
other
services.
A
So
if
I
container
now
we'll
choose
the
pod
to
service
to,
we
will
attach
to
the
container
and
we
will
choose
again
deal
really
because
it's
a
go
application
so
in
a
second
that
one
will
be
attached
again,
so
not
basically
attachment
waiting.
So
what
I
should
do
is
just
go
and
calculate
it
again.
What
will
happen?
A
But
look
what
I
did
here,
I
actually
did
a
mistake
is
added
equal,
true
and
I
put
minus
right,
and
this
is
only
a
simple
demo
to
show
what
we
can
do
right.
But
what,
if
I,
don't
need
to
kind
of
like
change
it
and
then
push
it
again?
What
if
I
can
just
leverage
the
fact
that
I
can
change
this
value
and
see
if
it
will
solve
me
the
problem
so
we're
coming
and
I
will
do,
is
edit
equal,
false.
A
That
should
change
that
and
I
will
step,
and
you
will
see
that
the
value
change
to
false
and
then
I'm
just
going
to
move
next
to
a
jump
here,
because
I
put
a
breakpoint
do
that
and
basically
what
I'm
going
to
go
to
the
idea.
You
see
that
now
it's
fix
the
problem
so
now
I
know
how
to
fix
it,
I,
don't
fixing
it
pushing
it
and
one
set
right.
So
that's
basically
a
very
simple
example
of
what
this
question
doing.
A
Okay,
so
so,
basically
it's
really
simple
right
now,
a
detective
is
really
simple.
There's
three
components:
the
first
one
is
the
server
this
discourse
server.
Basically,
the
only
thing
that
it's
doing
this
basically
orchestrate
like
on
the
client
what
it's
doing
is
getting
a
request
from
the
extension
or
to
an
API
and
basically
what
it's
doing
to
figure
out
based
off
what
you've
got
which
Nadi
need
to
talk
to,
and
then
it's
going
and
said
it.
A
The
request
to
the
Clyde,
that's
really
simple:
the
squash
plan
is
basically-
and
this
is
a
server
running
on
kubernetes.
So
basically
we
have
a
yahoo.
Just
it's
calling
it.
It's
really
simple.
It's
like,
if
you
can,
you
know,
flexed
up
and
down
and
so
on.
Then
there
is
the
squash
client.
So
what
is
the
squash
client?
So
basically
it's
a
we
use
it
as
a
daemon
set
to
make
sure
that
it's
always
up,
and
basically
it's
a
docker
container
wrap.
Basically
the
debugger,
so
I
was
really
need
a
little
bit
more.
A
So
that's
why
I'm
going
fast
to
kind
of
like
get
you
the
full
overview
and
then
the
last
thing
is
that
the
UI
is
basically
the
idea
right.
We
didn't
want
to
invent
the
will.
We
just
use
the
regular
ID
and
we
just
studio
card
in
that
example,
so
again
what's
happening
in
the
flow
in
terms
of
technically,
when
the
extension
is
that,
even
when
you
know
when
you're
actually
calling
the
command
of
the
extension,
what
happened?
It's
going
to
coop
CTL
and
basically
represent
the
use
of
the
pod.
A
When
it's
used
the
presenter
the
container,
and
then
he
basically
represent
the
debugger
that
we
support.
Then
it's
basically
sending
it
to
the
server
the
squad
server
rendering
too
much.
But
it's
basically
need
to
figure
out
rich
client
doctors
or
which
the
container
where
they
look
at
the
container
located.
Okay,
then
in
the
nodes
and
basically
send
it
the
request
and
then
basically
is
waiting.
It
is
the
ID
ID
in
that
case,
just
waiting
for
the
debug
session.
A
It's
basically
waiting
to
tell
the
client
of
the
ID
debugger
to
work
to
it
right
and
that's
it
and
then
it's
coming.
The
quest
as
I
said,
to
squad
to
squad
server
musquash
service,
doing
this
basically
sending
it
to
the
relevant
client
and
then
is
reigning
himself.
Writing
it
wait
for
for
the
debug
to
happen
to
the
actually
that
attachment
happening,
and
then
the
debug
client.
The
only
thing
that
it's
basically
doing
is
so
there
is
some
trick
here
and
we
were
drilling
into
him,
because
there
was
some
challenge
and
that
we
needed
to
solve.
A
But
basically,
what
you
need
to
know
is
we
have
some
issue
and
I
will
drill
into
it,
but
II
need
to
kind
of
write,
translate
they
the
basically
PID
of
the
of
the
container
to
the
PID
of
the
ORS,
the
namespace,
so
so
I
will
really
into
our
we
did
it.
I
will
find
a
solution.
What
we
did
with
this
and
and
the
after
we
does
and
it
actually
know
what
is
the
process
that
you
need
to
attach
to
what
we
actually
doing
we
just
basically
there
is
the
squad.
A
Client
just
initiate
an
instance
of
the
debug,
has
a
server
and
attach
it
to
the
container
and
again,
I
will
drill
into
it,
because
there
is
some
cool
stuff
here
and
then
it's
return
the
session
from
the
port,
basically
going
all
the
way
pop
you
get
it
to
the
IDE.
Now
then
it
connected
it
and
basically
letting
the
nate-
a
debugger
to
work.
So
it's
only
doing
the
piping
it's
connecting
and
I
said
now.
A
You
own
yourself
do
whatever
and
that's
why
we
love
rich
and
we're
not
writing
our
own
debugger
we're
leveraging
all
the
debugger
that
exists.
So
one
second,
but
here
as
I
said
we're
doing
some
tricks.
So
I
want
to
kind
of
like
focus
on
this,
and
because
we
are
egg,
we
want
to
get
a
feedback
and
be
it's
kind
of
fun
and
interesting.
So
what
do
we
need
to
do?
So?
This
is
how
it's
actually
do
not
look
right.
You
have
the
squash
client,
you
have
cream
and
you
have
container
that
run.
A
The
container
PID
is
usually
in
a
different
name
space,
and
we
need
to
kind
of
translate
it
to
the
Earth's
name
space
in
order
to
attach
it
so
the
way
we
did
and
one
of
the
things
that
was
important
to
us,
the
most
is
that
we
don't
want
to
do
it
only
for
docker
container,
because
that's
kind
of
easy
they
can
factory
nuts,
but
we
want
to
be
working
with
any
container
runtime
interface.
Implementation
that
exists.
So
here
is
how
we
did
it.
A
It
is
basically
squash,
bang
is
going
to
Cree
and
when
it's
going
to
this
is
basically
running
an
exact
sync
requests
and
what
he's
saying
is
LS
right,
proc
self,
which
is
basically
me
namespace,
show
me
all
the
namespace
that
I'm
running,
which
is
basically
the
LS
command
and
now
you're
getting
this
list
of
the
namespace,
and
you
basically
can
say
that
I
don't
know
if
you're
familiar
what
a
persistent,
but
basically
there
is
the
unique
identity
in
the
operating
system
is
basically
what's
called
inode.
So
what
we're
getting
here
is
basically
a
unique.
A
This
is
the
ion,
so
we
get
an
M
and
unique
a
I
not
basically
of
their
namespace.
So
now
we
kind
of
like
the
PID
namespace,
so
we
kind
of
like
to
know
where
it
is
once
we
getting
that
we
basically
and
now
we're
not
using
the
PID
actually,
because
the
PID
could
actually
also
be
in
the
last
level,
so
we're
actually
using
specifically
the
the
mount
names
case.
But
this
is
ditto
doesn't
matter.
We
just
needed
to
find
something
that
identified
specifically
and
then
we
could
be.
A
We
returned
into
the
squash
blind
and
then
the
squash
Brian,
who
is
running
on
the
earth,
basically
looking
for
this
I,
not
on
the
list,
so
you
can
see
the
quad.
It's
really
really
simple,
but
basically
what
it's
doing
is
basically
go
over
all
the
profit
running,
finding
that
I
know.
Finally,
the
relevant
I,
not
returning
the
PID
and
now
basically,
we
have
the
PID
of
the
earth,
so
we
can
just
go
and
attach
that.
A
So
so
that's
that
there
is
one
limitation
that
we
have
right
now
with
the
solution
which
the
thing
is
that
if
your
container
is
non
running
LS
we
kind
of
like
having
shipped
right,
but
we
still
kind
of
like
there
is
a
way
to
even
tweak
that
you
can
actually
inject
LS
and
so,
but
we
need
to
think
about
that.
So
we
will
love
your
feedback,
okay
and-
and
the
last
thing
is
that
basically,
the
squash
client,
the
way
it's
actually
working
is
this
is
a
docker
file
off.
A
Are
we
actually
building
it,
and
what
you
can
see
is
that
basically
we
installed
the
gdb
and
the
deal
be
in
that
case
and
basically,
what
we're
doing
after
it
we
just
initiate.
Instead,
he
ate
the
the
storage
buffer
and
in
attach
it.
So
that's
really
really
simple
and
the
beauty
of
what
it's
giving
you
is
that
what
I
show
you
in
your
application?
A
You
had
two
micro
services
that
are
reading
it
go,
but
actually
what
you
can
do
is
actually
have
a
micro
service
reading
in
go,
for
instance,
and
another
one
reading
in
in
in
in
Java,
and
you
can
do
but
the
Java
debugger
here
and
and
they
squash
debugger
to
the
other
one.
They
call
debugger
to
the
other
one
and
actually
bug
that
right.
A
We
did
cross
class
and
that
was
kind
of
like
what
you
know
in
the
end
of
the
day
in
beginning
we
did
it
not
a
lot
of
paper,
so
we
needed
to
choose
to
kind
of
like
create
an
MVP
before
the
community
actually
telling
us
if
they
liked
it
or
not.
So
what
we
did
we?
Basically,
it
was
really
really
hard
right.
The
MVPs
Minimum
Viable
Product,
so
we
chose
kuben.
It
is
at
the
platform
because
it's
no
brainer,
which
is
the
idea
of
the
Visual
Studio
code.
A
A
They
asked
us
to
add
support
from
our
turns
or
a
guy
from
Verizon
want
to
take
the
heat
and
doing
that
and
they
wanted
to
add
support
for
school
swarm,
and
actually
they
also
want
a
more
debugger
like,
for
instance,
say
a
Python
if
you're
running
in
production
and
then
and
also
more
ID,
like
a
IntelliJ,
for
instance,
was
a
lot
of
requests.
So
the
vision
is
kind
of
like
doing
it.
That
way,
right
I
mean
we
want
that
to
be
kind
of
like
the
debugger
for
everything,
and
it
should
be
whatever
using
it.
A
And
in
order
to
do
that,
we
created
in
from
the
beginning
the
flat
for
the
interface
will
be
clean.
So,
in
order
to
add,
for
instance,
a
platform
for
any
a
the
platform,
the
only
thing
you
really
need
to
do
basically
in
this
interface
here
is
everything
that
is
a
platform
specific.
So
one
thing
that
you
need
to
do
is,
and
we
talked
about
it
to
create
the
container
locator.
You
need
to
kind
of
like
you're,
getting
the
request
and
you
need
to
understand
whether
the
container
is
actually
located.
A
That
would
be
a
specific
kubernetes
call
right
and
then
in
decline,
the
same
thing
we
need
to
translate
the
get
PID
we
talked
about
it.
So
again
we
using
the
Cree
Cree
not
exists
in
every
platform.
Actually
kubernetes.
There
is
almost
the
only
platform
that
I
know
at
least
that
you
can
run
an
exact
on
the
container
itself.
So
that's
not
the
trick
that
we
did
right
now
will
not
work
for
something
like
Mara,
and
the
last
thing
is
that
we
wanted
to
save
the
states
if
something
happened
to
our
server
in
the
middle.
A
So
what
we
did?
We
created
an
interface
for
that
because
in
kubernetes
born
to
leverage
something
like
third-party
and
so
on,
and
we
we
cannot
I
didn't
in
the
rest.
So
basically
right
now,
it's
in
memory
the
same
difference,
but
you
can
implement
in
it
and
the
debugger.
It's
exactly
the
same
thing
that
what
the
debugger
is
doing
is
attach
the
touch
and
forth
right,
really
simple.
So
to
add
the
new
debugger.
It's
really
really
good
and
the
idea.
A
So
we
did
it
for
Visual
Studio
code,
but
we
can
do
it
for
the
rest,
it's
doable
and,
in
the
end
of
the
day,
it's
an
open
source
project
that
we
wanted
to
come
to
it.
But
the
question
is:
how
kind
of
what
kind
of
speaker
will
be?
It
will
be
in
coop,
current
and
I'm
going
to
talk
about
service
match.
I
think
that's
would
be
the
only
session
that
we're
not
there.
A
So,
let's
talk
about
service
measurement
sake,
so
service
wait
for
my
opinion,
it's
great
because
you're
giving
us
the
visibility
that
we
talked
about.
You
basically
now
own
the
network
and
I'm
not
going
to
tell
you
about
what
it
is
so
I'm
good.
You
know,
you
know
what
is
service
meant
because
you
heard
so
much
about
it
in
the
last
two
days
and
you
know
that
the
top
plane
is
envoy
could
be
enjoy,
and
you
know
that
the
control
panel
can
be
sto.
A
So
that's
not
what
interesting,
but
what
interesting
is
how
you
can
take
open,
tracing,
squash
and
service,
mention
kind
of
like
we
had
one
one
solution
that
will
fit
over
close
all
the
gap.
So
what
we
did
here,
it's
really
simple,
the
basically
create
that
you
can
make
in
a
basically
you
can
debug
a
service,
and
this
is
the
beauty
of
it:
a
service
and
not
a
container
on
the
infrastructure,
so
you're
going
today
to
the
idea.
You
basically
now
will
tell
me
which
service
you
want.
A
You
will
tell
me
which
image
in
the
service
you
want
to
debug
and
that's
it
and
run
real
world.
We
wrote
basically
an
annual
plugin.
So
what
does
it
mean
and
then
from
plug-in
I?
Don't
know
if
you
know,
but
you
can
extend
it
easily
and
basically
get
the
ability
that
every
time
it
like
it,
we
extend
somebody
we
plug
in
and
basically
I
will
show
the
plugin
in
a
second.
But
what
we're
doing
is
that
way
if
a
request
coming
with
the
aid
of
squash,
what
the
envy
is
doing?
A
He
basically
during
this
question,
said
debug
me,
and
then
it
Squatch
got
the
request
from
the
IDE
it
kind
of
like
Comanche
to
ear
it's
doing
what
the
magic
and
it's
attached
it
to
the
debug
and
the
beauty
of
it
is
again
is,
for
my
opinion,
destroying
a
thing,
and
this
is
basically
saying
something.
So
this
is
the
envelope
in
its
open
source.
You
can
go
and
look
at
it,
but
basically
what
it's
doing.
A
It's
really
simple
is
using
the
environment
variable
to
take
the
port
name
space
they
did,
and
the
pot
name
and
basically
creating
a
quest
to
set
to
squash
and
then
is
basically
waiting
for
those
myths
and
the
beauty
again
for
my
build
what's
stronger
here
is
that
now
you
can
actually
debug
it
in
production
without
supposing
the
cluster
we
not
basically
stopping
the
cluster,
because
the
cluster
will
continue
running
with
all
the
other
requests.
Only
they
request
that
you
ask
is
basically
going
to
be
stuff.
A
So
that's
that
I
mean
there
is
limitation
right
now
to
give
a
two-pilot
and
envoy's.
Basically
the
fact
that,
as
a
plug-in,
if
you're
adding
a
new
plug-
and
you
need
to
recompile
it-
which
basically
now
become
a
new,
enjoy
and
and
and
and
the
other
thing
with
pilot-
is
that
you
need
to
basically
configure
pilot
to
use
the
plugin
and
right
now,
the
way
they
did.
A
B
A
A
So
now,
basically,
that's
me,
so
what
I
did
right
now
is:
I
basically
blown
the
application
that
van
and
Lightspeed
is
doing
with
the
donut
salon
and
basically,
what
you
can
see
the
code
here
in
a
second
you'll,
see
it
open
and
it's
already
in
service
smash.
So
it's
kind
of
like
connect.
You
will
see
it
connected
also
to
java.
A
A
The
fact
that,
on
the
beginning,
when
we
did
it,
we
said
well,
but
that's
not.
This
will
never
work
in
production
when
we
only
basically
attaching
to
the
container
because
then
you're
stopping
it
and
it
just
doesn't
make
any
sense.
So
what
we
try
to
do
we
try
to
do
kind
of
like
a
lot
of
interesting
stuff,
basically
watch
all
the
services
attach
them
all
to
the
client
and
when
there
is
a
panic,
we
return
it
that
was
kind
of
like
a
hack.
A
Then
we
try
to
do
a
lot
of
other
stuff
like,
for
instance,
you
want
to
make
sure
that
you
that
the
debugger
attached
and
and
you
be
able
to
kind
of
like
debug
it
from
the
first
line,
so
we
basically
put
our
own
service
and
then
did
exact
and
change
it
to
the
regular
one
after
it's
attached.
So
there
was
a
lot
of
magical
that
been
done,
but
with
service,
which
we
don't
need
to
do
that.
It's
really
clean
because
service
when
she's
stopping
the
request.
A
A
Yeah,
so
we
can
do
it
even
better
for
my
opinion,
so
so
so,
for
instance,
one
thing
that
we
know
is
that
the
service
Manville,
basically
as
the
ability
to
reach
rife
in
it,
which
mean
that
he
actually
has
the
request.
So
what
we
can
do
if
we're
getting
a
response
for
500,
for
instance,
which
is
an
internal
server,
what
we
can
do
is
actually
send
the
same
request
again,
but
now
with
the
data
of
squatchin
kind
of
like
debug
it
so
that's
kind
of
like
more
automatically.
A
We
should
integrate
it
better
with
the
get
up
in
that
way,
because
what
we
want
is
basically
that
it
will
open
for
the
user
itself,
but
for
that
we
need
to
find
basically
the
commit
ID.
So
there
is
an
idea
to
do
that.
Maybe
with
attribute
and
concur
Bonelli's,
maybe
web
browser
ID
can
help
here,
because
then
you
basically
not
need
to
run
anything
on
your
machine
because
you're
going
to
spin
up
everything
for
you,
I
need
to
integrate
it
better,
with
open
tracing
for,
for
instance,
with
the
way
I
envisioned.
That
is
service.
A
Mention
up
addressing
giving
you
the
latency
between
the
services,
but
now
we
need
to
zoom
in
and
see
why
it's
actually
happening
there.
So
you
see
a
legacy
between
two
services
and
what
I
would
likely
to
be
able
it's
kind
of
like
the
zoom
on
top
of
an
on-demand
figure
out,
what's
happening
there
and
that's
what
we
have
that's
what
I
have.
B
A
A
It's
only
its
statement
set
on
the
note
yeah,
so
you
do
yeah.
So
basically
we
don't
need
yourself.
So
the
question
was:
if,
because
we
have
the
climbs
in
the
server,
we
don't
need
to
have
it
in
any
way
every
container
and
that's
or
not.
We
basically
do.
We
did
some
magic
there
with
the
namespace,
so
we
only
need
it
as
a
daemon
set
under
not
itself.
That's
the
one
instance
of
it
and
that's
it.
Yeah.
A
So
like
what
I
ever
in
the
idea
is
something
that
I
took
from
the
get
up
and
running,
but
I'm
actually
debugging
it
on
AWS,
so
that
cluster
itself
in
the
content
running
on
AWS
right
now
on
kubernetes
in
a
double?
Yes.
Yes,
yes,
yes,
so
basically
you're
on
debugging
its
life.
It's
a
running
cluster!
Yes,.
A
So
that's
why
I
said
we
using
a
diamond
set,
it's
basically
a
yama
that
we're
giving
you
and
we
use
it
and
basically
I
mean
I,
can
show
you
it's
really
simple.
We
can
it's
basically
two
Yaman
that
install
one
is
this
discourse
the
score
server
itself
as
a
service
and
then
you're,
basically
getting
a
yama
and
it's
giving
you
it's
putting
you
the
day
myself.
B
A
Basically,
just
using
the
coop
CTR
that
way,
I'm
leveraging
their
security.
I'm
going
on
to
telling
me
give
me
all
the
power
that
I
can
see
that
I'm
allowed
to
see
right
because
I'm,
good
CTR
and
then
it's
bringing
me
back
so
I'm
just
leveraging
the
Cooke
City
and
you
can
see
the
extension
is
open-source
as
well.
So
you
basically
can
just
go
and
locate
it,
but
it's
like
so
dead
suitable.