►
Description
Debugging Cloud Foundry Apps: Via Service Mesh, Open Tracing - Idit Levine, Solo.io
The mainstreaming of containerization and microservices is raising a critical question by both developers and operators: how do we debug all this?
Debugging microservices applications is a difficult task. The state of the application is spread across multiple microservices, and it is hard to get a holistic view of the state of the application. Currently debugging of microservices is assisted by openTracing, which helps in tracing of a transaction or workflow for post-mortem analysis, and linkerd and itsio which monitor the network to identify latency problems. These tools however, do not allow to monitor and interfere with the application during run time.
In this talk, we will describe and demonstrate common debugging techniques and we will introduce Squash, a new tool and methodology.
About Idit Levine
Idit Levine is the founder and CEO of solo.io, where she is aiming to streamline the cloud stack.
Prior to founding solo.io, Idit was the CTO of the cloud management division at EMC and a member of its global CTO Office.
At EMC, Idit lead, designed and implemented project UniK, an open source platform for automating unikernels compilation and deployment and project layer-x, an open source framework for cross-cluster scheduling . At solo, Idit recently released Squash, an open source platform for debugging microservices applications.
A
We
have
tons
of
content
to
cover,
so
we
will
start
quick
and
hopefully,
we'll
manage
to
do
it
all
so
we're
going
to
talk
about
a
little
bit
more
than
what
we
said
that
we're
going
to
talk
about
it,
but
it's
also
going
to
cover
everything
that
we
talked
about
like
service
smashing
and
arbitration.
But
let's
start
before
for
this.
So
when
you
look-
and
you
probably
all
aware
of
this
announcement
last
year-
and
this
is
great
right
now-
cloud
founder
is
working
with
kubernetes.
This
is
fantastic
and
this
is
the
natural
direction
direction.
A
So
you
kind
of
looking
like
this
right
now
you
have
boss
right
is
actually
managing
it,
and
then
you
have
kubernetes
and
Cloud
Foundry,
that
managed
by
by
a
Bosch,
but
the
most
customer
actually
also
have
monolithic
application
and
actually
there's
also
several
services
much.
That
is
really
interesting
in
this
world
and
it's
kind
of
feel
that
all
of
this
should
be
managed
by
something,
because
otherwise
you
need
to
go
to
a
lot
of
different
type
of
interfaces
for
the
user.
A
So
there
is
something
is
missing
here
and
the
first
thing
that
we
really
decided
that
we're
going
to
do
is
basically
to
glue
this
environment
together
and
I
would
explain
why
it's
important,
because
I
feel
that
this
is
the
nature
way
of.
Where
did
all
the
application
is
going
and
therefore
we
need
to
know
how
to
manage
them
and
and
and
debug
them
and
so
on.
So
let
me
just
kind
of
like
do
lean
to
understand
what
I
mean,
and
this
was
really
really
high
level
with
what
should
be
so.
A
Basically,
today
in
the
ecosystem,
as
I
said,
there
is
true
three
groups,
one
of
them.
You
know
people
was
doing
monolithic,
that's
mainly
the
enterprise,
it's
managed
by
something
like
puppet
or
chef
or
ansible
they're,
using
their
own
tool
for
logging
and
debugging
and
they're,
usually
running
architecture
like
SOA,
and
then
there
is
the
micro
service.
A
Then
you're
going
to
use
the
provided
tools,
because
you
have
no
choice
right,
something
like
x-ray
and
cloud
watch
if
you're
using
sir
a
lambda
specifically,
and
that
would
be
an
event-driven
architecture.
So
you
have
all
of
this
yeah
it's
a
lot
of
choices,
but
the
real
question
is:
how
do
you
mean
great
between
them?
I,
you
debug!
These
things.
Are
you
dealing
with
this?
A
So
if
you
will
look
into
it,
you
will
see
that
basically
service
is
functions
and
we
can
look
at
micro-services
monolithic
as
an
and
I'm
talking
only
the
expose
API
as
a
functions,
and
if
we
will
do
something
like
this
and
we
actually
be
able
to
discover
all
this
echo
system
and
then
also
route
to
it,
we
can
do
something
like
that
and
then
we
can
actually
be
great
or
mixed
application.
That's
running
in
different
place,
so,
okay,
so
again,
I'm
starting
with
solving
this
problem.
A
We
kind
of
I
going
to
glue
it,
and
then
we
will
talk
about
how
we're
going
to
use
open,
tracing
and
service
mesh
and
so
on
to
kind
of
like
get
the
observability
and
so
on.
So
what
do
we
need
to
do
in
order
to
do
that?
The
first
thing
we
need
to
do
is
to
break,
but
it's
not
really
break
right,
because
we
can't
really
break
what
we
can
do
is
actually
discover
them
and
router
them
all
those
function.
A
Then
we
need
to
basically
be
able
to
assemble
them,
to
what
I
call
I
would
up
and
then
the
last
thing
that
we
need
to
do
is
make
sure
that
we
can
actually
debug
them
and
so
on,
and
this
is
exactly
what
we
build.
It's
called
glue
is
build
on
invoice.
That's
why
it's
really
really
close
to
service
mesh
because,
like
you
know,
STR
is
also
build
on
and
voi,
and
what
it's
doing
is
we're.
Basically,
we
extend
an
invoice
to
route
on
the
function
level.
So
a
we
discover
all
those
functions.
A
A
You
will
extend
it
to
a
micro
service
or
maybe
to
service,
and
it's
all
going
to
look
like
one
big
application
and,
of
course
we
don't
care
where
it's
running
right,
because
the
beauty
of
it
is
that
it's
all
layer
7,
because
anybody
give
us
this
abstraction.
So
again,
when
we
did,
is
we
basically
extend
the
envoi?
We
build
glue
to
manage
that.
It's
really
really
extensible.
A
You
can
give
you
that,
in
their
level
of
the
function
and
and
also
if
it's
going
to
AWS,
we
wrote
filters
that
in
Android
that
basically
already
giving
you
all
the
signature
and
everything
and
making
you
easily
router
so
I
want
to
show
you
them
I
think
that
will
be
the
most
easy
way
to
understand,
and
this
is
only
one
use
case,
because
actually
we
build
it
very
flexible.
So
it's
showing
us
over
okay,
so.
A
A
Now
you
see
that
nice
yeah,
perfect
okay,
so
I
just
SSH
to
a
machine
alright
and
this
machine
is
actually
running
Cloud
Foundry.
So
we
just
show
you
that
I'm
not
lying.
Sorry,
that's
s!
Okay!
Now,
let's
do
see
if
oops,
so
you
see
are
running
it
and
right
now,
guru.
Is
there
we're
not
doing
anything
we
will
do
next
is
I
will
show
you
and
again
it's
more
like
that.
You
will
see
this
is
Alexa
and
what
we
did
is.
A
A
A
A
So
now
it
will
go
to
a
zero.
So
if
I
will
do
it
do
exactly
the
same
demo,
this
way
so
yeah
and
the
summer
I
said
what
I
did
is.
First
of
all,
when
we
putting
an
upstream
we're
going
a
discovering
all
the
function,
that's
what
we
did
the
beginning.
We
did
it
with
Google,
discover
the
function
and
created
route
to
wait
so
I
like
so
basic.
We
call
this
route,
and
now
we
didn't
change
anything.
The
only
thing
we
will
change
is
the
route
it
will
go
to
a
double.
A
B
A
A
B
A
A
Right
so
basically
I'ma
great
it.
It's
really
really
simple:
we
have
a
lot
of
demos,
so
we're
going
to
go
next
and
glue
is
an
open-source
project,
so
we
can
go
and
look
at
it,
but
basically
again
there,
it
is
immigration
use
case
and
I
will
show
you
and
more
demos
in
the
in
the
next.
So
now,
let's
talk
about
what
you
came
up,
which
is
the
debuggable
and
observability
pot,
so.
A
Does
better
yeah,
okay,
so
let's
first
understand
the
problem
right
so
way
way.
On
the
back
days,
we
had
one
erotic
application
if
I
wanted
to
debug
the
monolithic
application
and
touch
debugger.
That
was
really
really
simple.
Once
I
did,
that
I
actually
saw
all
the
stage
of
the
application
can
see.
There
are
oh
boy,
we
see
the
memory.
I
can
actually
have
a
full
picture
of
everything
that
running
there.
The
problem
with
microservices
is
that
now
I
took
it
the
same
one
binary
and
actually
spread
them
to
a
lot
of
different
ones.
A
So
now
the
state
is
all
spread
all
around
and
it's
really
hard
to
kind
of
like
follow
what
its
belong
to
to
what
so.
This
is
definitely
complicated
right
now,
when
you're
running
some
micro
server.
Definitely
it's
more
complicated
when
you
actually
run
it
cross-platform
like
kubernetes
and
Cloud
Foundry,
but
even
if
we
take
it
to
another
level.
This
is
our
really
your
application.
Look
right,
your
application,
look
like
500,
450
micro
services
and
do
understand.
What's
going
on
on
the
full
application
to
understand
the
full
picture,
it's
really
really
hard.
A
This
is
just
a
funny
joke
that
someone
to
be
read
and
I
found
it
very,
very
larious,
but
this
is
true.
This
is
what
people
are
actually
going
through.
So
what
is
that
solution?
What
can
we
do?
How
can
we
actually
debug?
So
the
first
thing
that
we
can
do
is
use
open
tracing.
So
let's
understand
what
it's
opened
erasing.
So
what
open
tracing
is
is
basically
a
transactional
logging.
A
What
it's
mean
is
that
when
someone,
when
a
request,
coming
open
tracing,
giving
it
ID
and
then
what
it's
doing,
it's
basically
what
the
context
just
propagated
down
to
all
the
RIC,
the
micro
service.
You
use
this
request
and
then,
when
it's
getting
it
back,
is
looking
at
the
setup.
Okay,
now
I
can
actually
aggregate
it
all
there.
It
is,
and
I
can
get
a
story
that
looks
something
like
this
right,
so
this
is
basically
how
it
looks
right
you
get
have
experice,
that's
what
calls
fence
and
basically
in
Sprint's
you
have
a
function.
A
You
know
micro-services
a
that
run,
call
mycosis,
be
that
called
C,
D
and
E,
and
now
you
have
the
full
picture
of
how
your
stuff
is
working.
They,
the
open
tracing
itself,
is
basically
a
standard
right.
I
mean
it's
only
an
API
and
that's
Austin
right
now
by
the
cloud
CNCs,
and
there
is
a
lot
a
lot
of
product
like
geography
from
uber
and
a
lot
of
other
that
actually
implemented
there
actually
UI
and
and
thing
itself
so
I
think
that
again,
if
you
have
time
I
think
we
have
time
yeah,
we
have
time.
A
If
done,
maybe
we
will
see
them
so
I
mean
this
demo
is
basically
I'm
just
going
to
if
you
want
and
we
can
skip
it.
If
you
want
these
basic,
they
are
going
to
teach
you
what
is
open
tracing
just
showing
you
why
we
needed
and
so
on
awfully
it
will
be
useful.
If
not,
we
can
go
to
the
other
demos.
So
yes,
again,
where
is
this
dressing?
One.
A
Okay,
so
what
I'm
spinning
right
now
is
a
very,
very
simple:
this
is
Jagger
right.
This
is
one.
This
is
a
we've
been
creating
in
uber
and
basically
it's
a
very
good
open
tracing
implementation
tool.
It's
also
asked
by
the
CNC
F.
So
this
is
the
UI
and
it's
very,
very
simple,
and
when
I'm
running
with
this
is
basically
it's
an
application.
That
also
wrote
is
basically
right
on
demand.
Okay,
so
your
quest
and
oh
and
over,
and
basically
it's
going
and
doing
what
it's
doing
so.
A
The
first
thing
that
we're
going
to
do
we're
just
going
to
request
one
okay,
that's
all
we're
going
to
do
quest
1
and
now
that
was
very
simple
right.
We
got
a
ride,
but
let's
go
one
second
to
the
CLI
to
see
the
lock
so
look
at
this
all
I
did
is
click
one
thing
and
I
want
to
show
you
how
much
logs
I
got
for
this.
This
is
only
for
one
thing
right:
they
didn't
click
just
know
like
it's
very
simple.
As
that
you
can
see.
A
There's
a
lot
a
lot
of
flock
for
this
specific
now,
if
we
will
go
to
Jagger,
we'll
see
what
you
gave
us
all
right,
so
the
first
thing
that
we
can
see
is
that
if
we
go
into
the
juggler
UI
we're
going
to
the
dependency,
is
that
immediately?
You
realize
that
without
me
needed
to
do
anything,
he
basically
realized
that
I
have
1/10
that
call
route
that
call
customer
that
called
driver
call
this,
and
all
of
this
he
understand
by
just
me
clicking
one
button.
A
A
Yeah
four
and
five
tres,
so
you
find
a
dress
right.
We
click
one
time
and
you
can
see
that
and
we
can
actually
go
and
see
what's
going
on
there.
So
this
is
what
we
got
right.
We
just
click
one
button,
and
this
is
what
happened.
You
can
see
the
request.
You
can
see
what
happened,
who
called
who
hi
it's
happening,
and
this
is
only
for
one.
Click.
A
I
just
want
you
to
understand
what
happened
when
I
clicked
one
time
and
you
can
see
a
lot
of
stuff
like,
for
instance,
I
can
come
here
and
see
actually
logs
from
going
to
the
logs,
but
they
are
all
in
the
transactional
level.
You
can
actually
see
what
happening
and
understand
and
because
it's
pretty
the
context
you
can
even
see
more
than
this.
So
that's
that.
But
you
know
this
is
kind
of
like
boring.
A
Let's
go
and
do
a
lot
and
let's
see
what
happened
when
I'm
clicking
and
a
lot
of
time,
and
what
you
can
see
is
when
I'm
clicking
the
let
can
see
going
up,
okay
and
so
let's
go
try.
Let's
take
the
one
that
is
actually
the
most
time
and
let's
go
back
here
and
try
to
look
for
this.
One
I
think
it's
Drive,
hopefully.
A
A
So
they
can
see,
we
got
all
of
this,
and
if
we
can
go
right
now
to
one
of
them,
we
can
see
that
we
can
see
what's
the
problem.
Actually,
what
we
can
see
is
that
we
have
a
problem
with
letting
see.
First
of
all,
we
can
see
some
arrows
and
the
second
thing,
if
we
are
actually
going
to
look
and
see
we
can
see
that
there
is
a
lot
of
let's
key
one
of
the
arrows,
for
instance,
and
you
can
see
that
the
problem
is
that
there
is
actually
it's
waiting.
A
A
It
again
will
totally
change
the
spam,
but
the
idea
with
what
open
tracing
is
giving
you
is
the
ability
to
actually
see
problems
in
the
you
know,
latency
and
so
on,
and
let
you
actually
analyze
it
and
so
on
now,
I
don't
have
time
so
I
mean
if
you
want
I
will
do
the
demo
offline,
but
basically
there
it
is
that
that's
what
it's
giving
you
and
we'll
talk
right
now
about
what
is
giving
you.
What
is
not
giving
you.
A
And
then
we'll
continue
back
okay,
so
we
talked
about
so
what?
What?
Actually
it's
giving
you
giving
you
logging
right.
This
is
actually,
if
you're
thinking
about
it,
that's
the
equivalent
for
logging
that
exists
in
monolithic
application.
It's
just
a
transactional
one,
because
that
way
it
can
give
you.
You
know
a
view
of.
What's
going
on,
it's
giving
you
metrics
an
alert,
because,
theoretically
we
can
pipe
it
back
to
Prometheus,
it's
giving
you
a
context,
propagation
and
that's
what
I
were
talking.
A
We
can
go
actually
and
drive
it
as
much
as
we
want
down
it's
giving
you
a
critical
path.
Analysis
right,
because
you
can
see
that
something
is
not
working
and
you
can
actually
go
and
and
debug
it
and
it's
giving
you
a
topology
right.
We
can
actually
see
how
the
system
look.
So
that's
great,
but
there
is
a
lot
of
stuff,
it's
not
giving
you
and
we
need
to
look
at
it
and
understand
the
first
thing
that
it's
not
giving
you
it's
not
giving
you
runtime,
debugger,
usually
I.
A
As
you
see
I
print
a
lot
of
stuff
I
mean
when
I
show
you
the
demo.
You
saw
a
lot
of
logs.
The
reason
it's
happening
is
because
I
wanted
to
show
you
what
you
can
get
from
it,
but
actually
think
about
the
network
throughput.
You
can't
blog
everything
if
you
kill
the
networks.
So
what
you
need
to
actually
do
is
not
log
a
lot
and
therefore
you
can
and
then
you
need
to
basically
simple
it.
You
can
basically
collect
every
log,
so
you
then
you
take
it.
A
I,
don't
know
once
a
minute
and
what
happening
in
this
is
that
eventually
you're
not
getting
the
old
picture
right?
It's
not.
You
know
you're
getting
some
of
it
and
you're
not
getting
a
runtime
debugger.
There
is
also
you
need
to
rub
the
code
somehow
right,
because
it's
a
library
in
the
end
of
the
day,
there's
no
allistic
view,
because
you
only
see
what
you
print.
If
you
didn't
print
it,
you
can't
see
it
right.
It's
not
it's
very
simple!
A
Now
the
process
of
let's
say
that
I
didn't
print
it
and
now
I
want
to
print
it.
It's
mean.
You
know
the
regular
one
at
the
print
go
push
it
a
built
again
and
push
it
to
kubernetes.
Wait
a
minutes
until
you
getting
the
logs
and
so
on,
and
you
can
change
any
variable
on
runtime,
because
it's
not
a
debugger
and
also
it's
giving
quite
a
lot
of
over
them.
Then
throughput
of
the
network,
and
we
need
to
be
realized
that
you
have
to
sample
it.
A
You
can
see
all
the
logs
all
the
time
and
that's
what
bring
us
to
build
an
order
to
Acco
squash
and
what
is
squash
so
I
mean
I
will
explain
what
it
is,
but
I
think
that
the
best
way
just
to
show
it,
because
it's
damn
simple.
So,
as
I
said,
if
you're
working
today
on
the
monolithic
you
have
the
ability
to
something
like
Splunk
or
any
other
to
see
the
logs,
that's
the
equivalent
of
open
tracing.
But
if
you're
looking
at
a
regular,
the
debugger
there
is
no
equivalent
in
the
micro-services
world.
A
A
Okay,
so
this
is
a
very
simple
application,
so
she
show
the
case
of
what
we're
doing
it's
a
very
stupid,
a
vacation
you're
putting
to
power
metal
doesn't
really
matter
which
and
then
you're
grading
calculator,
and
what
you
can
see
downstairs
is
that
it's
not
really
working
right,
76
likes
32,
it's
not
equal
44.
So
what
do
you
do
need
to
debug
it?
How
do
you
do
that?
So,
let's
you
probably
know
usually
you're
going.
A
You
writing
some
logs
you're,
putting
the
variable
you're
trying
to
understand
what
is
not
working
if
using
open
tracing,
you
maybe
add
logs
and
then
10
minutes
after
you
getting
them,
but
what
we
start
is
that
it
actually
should
be
much
much
simpler.
So,
let's
understand
why
this
application
is
doing
actually
this
application.
It's
really
really
simple
this
one.
This
is
actually
a
go
micro
services.
A
That
basically,
is
served
me
the
UI,
so
it's
basically
an
HTML
wrap
inside
a
glow
ago
and
then
is
taking
this
formatter
and
he
sent
it
to
the
next
micro
services
written
in
Java.
That's
what
you
see
here
and
this
micro
service
is
very
simple-
is
getting
the
to
value
and
either
end
very,
very
simple
and
bring
it
back
so
again,
just
notice
this
is
go
application
and
this
is
Visual
Studio
card
ID.
This
is
java
application
and
this
is
IntelliJ.
A
So
what
we
did?
We
basically
create
an
extension
when
I
clicking
this
one
I
hope
you
can
see
that
basically,
what
I
did
is
I
created
an
extension
for
squash
and
what
you
can
see.
I
hope
you
can
see
that
it's
basically
squash
debug
container
and
we
will
choose
this
and
what
happened
here.
It
went
to
kubernetes
and
brought
me
all
the
pod
that
exists
in
my
system.
Only
the
one
I
can
see,
of
course.
A
A
So
this
is
running
on
AWS
right
now
and
in
a
second
touch
it
and
can
debug
it
now
we
will
do
the
same
thing
exactly
on
the
other,
just
to
show
you
that
you
can
do
it
also
in
the
other
one.
So
this
is
IntelliJ
again
squash
debug
container.
Now
we
will
go
to
the
second
microservices,
which
is
service
to
Java.
Here
is
there
the
darker
quote
the
ears
the
container
and
we
will
choose
Java
and
that's
it
it
a
child
it
attached.
A
So
now,
the
only
thing
that
we
really
need
to
do
is
go
back
to
my
application
and
click
and
what
will
happen
I'm
like
debugging
it.
So
what
you
can
see
I
have
all
the
parameter
here.
I
can
step
into
it
and
do
everything
right
now.
What
will
happen
if
I
will
continue
here?
It
will
jump
to
the
other
micro-services
right
because
I
put
a
breakpoint
there
as
well.
So
basically
we
took
the
Java
debugger
attached
to
it.
A
We
took
the
scapegoat
debugger
attached
to
it
and
we
basically
orchestrated
all
right
and
then
what
will
happen
here
is
you
can
see.
I
mean
I'm
going
to
click.
Some
parts
next
and
you
can
see
that
what
I
that
we're
getting
the
right
bottom
line-
I,
don't
know
if
you
can
see
it,
but
this
is
76.
This
is
32
like
we
wrote,
and
this
is
true
but
look
what
I
did
here:
I
introduce
a
by
a
bug,
specifically
right.
A
What
I
did
is
if
it's
true
I
did
because
I
wanted
to
show
you
the
point,
but
this
is
a
debugger.
So
the
only
thing
that
I
can
do
is
just
go
and
change
the
value
to
see
if
it
will
fix
the
problem
on
one
time
so
I
change
it
to
false
I'm
going
to
do
next,
it
will
jump
to
the
other
microservices
and
then
I
will
click
it
again
and
we'll
go
to
the
application
to
see
that
this
is
fix.
A
A
Oka
staying
in
the
debugger
and
giving
him
the
dead,
it's
also
open
source
really
recommend
to
go
and
check
it
out
and
I
said.
The
idea
with
squash
is
that
and
I
we
shared
a
letter.
Is
that
it
not
only
a
micro
service
debugger?
Basically,
we
can
work
with
any
environment,
including
monolithic.
So,
theoretically,
if
you
have
an
application
that
is
part
of
its
monolithic
part
of
it
micro
service,
part
of
his
service,
you
can
actually
jump
between
it,
like
it's
one,
big
application,
which
I
found
very
useful.
A
Okay,
so
now
service
smash,
so
I,
don't
know
if
you
know
buddy
service
Messer
will
start
just
to
explain
daddy,
but
the
idea
with
service
mesh
is
to
abstract
the
network.
So
right
now
before
that,
if
two
micro
service
needed
to
talk
I
needed
to
put
some
folder
that
we
know
directly
out
to
go
to
these
micro
services,
the
problem
is
that
if,
after
it
I
want
to
change
something,
I
need
to
go
and
change
the
code,
which
is
really
not
useful.
A
Today
is:
maybe
it's
not
allowed
for
those
micro
service
to
talk
and
that's
where,
for
instance,
a
mixer
is
coming
into
picture
in
this.
It's
growing
every
call
to
basically
interrupt
and
ready
me
immediately
decided
if
it's
actually
supposed
to
go
and
it's
okay
to
do
it
or
not.
So
that's,
basically,
what
is
service
machines
doing
is
very
simple
side
car
next
to
every
cube
next
to
any
container
and
so
on.
So
I'll
show
you,
where
I
think
that
it
will
play
a
lot
and
then
I
will
show
you
okay.
A
So
the
solution
that
I
see
that
is
best
is
I
do
believe
that
service
mesh
is
really
really
important.
It's
giving
you
observer
ability,
which
is
really
really
important.
It's
giving
you
security!
That's
the
to
use
case
that
people
are
preaching
and
I
really
really
agree
that
it's
really
useful.
What
we
did
is
we
basically
also
add
in
option,
which
is
we
wrote,
a
filter
for
an
for
squash
to
envoi.
So
now,
theoretically,
think
about
like
this
I
ever
mesh
right
with
a
lot.
A
A
Basically,
what
we're
doing
is
a
shadowing
the
request
and
attach
a
debugger
to
the
request,
but
they're
all
the
rest
is
continue
running,
so
basically
not
posing
the
service
on
on
the
cluster.
So
what
I
will
do
is
the
last
demo
and
I
know
I'm
killing
you
and
going
fast,
but
really
trying
to
show
you
a
lot.
A
A
Okay,
so
the
only
thing
I
will
do
is
right
now
online
demo.
So
what
we
will
do
right
now
is
the
service
manager
plus
everything
together
plus
they
did
the
squash
together.
Everything
working
another
one
solution,
and
it
will
take
a
second
because
spinning
up
the
environment,
any
questions
for
the
meantime
No
okay,
so
in
a
second
it
will
happen
and
then
hopefully,
okay.
A
Okay,
so
I
will
tell
you
what
we're
going
to
do
right
now.
We
start
by
basically
taking
a
very
simple
application
that
I
guess
most
of
you
know,
which
is
the
monolithic
application,
a
pet
store,
we'll
take
it
and
we're
basically
going
to
transport
it
to
do
micro
services
and
service
and
then
debug
it
all
that's
the
purpose,
not
full.
It
will
be
ready
in
a
sec.
The
network
will
play
with
us.
Okay,
so
I
can
show
you
already
that
this
is
the
code
of
the
monolithic
application.
It's
a
regular!
You
go
it's
starting.
A
This
is
the
application
that
I
guess.
Everybody
knows
right.
There's
no!
A
lot
of
surprise
here
here
is
the
code
of
the
application.
It's
a
regular
spring
application
pet
store
right.
Ok,
so
now
what
happened
is
that,
as
you
can
see,
it's
all
working
and
when
I'm
coming
here,
I
really
want
to
modify
it?
What
I
want
to
do
is
add
another
column
for
location
and
I.
Have
a
new
engineer
in
my
team
and
I
really
really
want
him
to
go
and
actually
had
it,
but
he
doesn't
know
this.
A
So
we
need
to
learn
that
and
then
after
we
need
to
modify
it,
then
you
need
to
test
it
then
in
either
regression
test
it.
Then
you
need
to
redeploy.
That's
a
lot
a
lot
of
stuff,
but
most
of
the
thing
what
this
page
is
doing
is
only
basically
showing
right.
It's
only
representing.
So
what
we
can
do
is
I
wrote
here,
a
micro
services
in
go
very
simple
one.
That's
always
going
is
basically
going
directly
to
the
database
and
showing
the
data
that
I
want.
A
So
why
did
you
see
what
I'm
doing
a
second
okay?
So,
as
I
said,
with
gluey
I
already
see
the
environment
and
I?
Don't
know
if
you
see,
if
you
know
you
see
it
big
enough,
so
I
will
tell
you
what
I'm
saying
and
saying
blue
CTL.
Please
create
a
route
that
every
time
that
someone
going
to
slash
red
dot,
html'
I,
want
you
to
go
to
the
go
micro
service,
that
I
wrote
and
that's
it.
That's
all.
I
did
right
and
that's
what
will
come
here.
This
is
basically
still
Java.
A
This
is
still
Java,
but
if
I'm
going
here,
it's
already
the
micro
servicing
go
so
basically
this
is
what
I
call
I
boot
up
right.
So
basically
you
so
quick!
It
is
by
the
way
it's
because
we're
using
the
v2
API
of
envoi
really
really
quick
right.
So
now
this
is
an
I
build
up
already,
but
look
at
this
here
we
actually
have
arrow
in
the
contact
again,
I
can
go
and
ask
my
ninja
need
to
fix
it
or
I
can
do
something
simpler.
A
A
A
Contact
us
now,
notice,
I
didn't
put
any
password
and
security
any
ID,
and
the
reason
is
because
we're
already
taking
care
of
it
is
listen
to
all
the
secret
and
every
time
that
something
changing
the
secret
or
in
the
upstream
or
in
the
configuration
file
humidity,
taking
it,
sending
it
to
an
API
to
plugins
that
generate
the
language
and
basically,
then
n
we're
getting
it
so
again,
very
simple!
That's
all
I
did
now.
I
will
do
the
same
thing
just
for
this,
so
this
is
so
many
date.
A
A
Is
called
contact
tree
so
funny
the
sec,
you
know
go
so
again,
the
same
thing
exactly
and
the
only
thing
I'm
saying
now
run
this
function,
and
it's
done
and
now
when
I
will
go,
you
will
discover
that
it's
not
going
to
work
and
I
will
show
you
why.
So
this
is
a
Java.
This
is
a
go
microservices,
but
when
I'm
coming
here,
this
is
a
J's
and
apparently
lambda
doesn't
know
to
return.
A
Something
else
is
in
JSON,
which
is
a
problem
for
us,
so
you
can
either
use
the
API
gateway
of
AWS
and
pay
the
money
and
they
will
transfer
it
for
you.
Actually,
there's
no,
our
API
here
where
they're,
giving
it
for
free
or
you
can
just
use
glue
and
what
we're
going
to
do
right
now.
I
just
apply
the
transformation
filter
that
again
it's
open-source.
You
can
go
and
look
at
this.
A
A
It's
a
go
micro
services
when
I'm
clicking
here
actually
running
no
GS
lambda,
and
it's
all
look
to
the
user
like
it's
one
application,
that's
what
I
call
I've
it
up
and
we
can
actually
feel
the
information
and
I
can
sure
that's
actually
going
to
s3,
but
I'm!
Guess
you
better
and
it's
worse
and
I
can
go
to
show
you
if
you
really
want,
but
the
idea
that
the
beautiful
of
all
of
this
is
now
you
can
actually
attach
the
debugger
of
each
of
them
and
actually
the
bucket.
So
what
we're
going
to
do?
A
And
now
what
I
will
show
you
in
a
second?
It
will
connect
that
if
I'm
coming
back
to
my
application,
I
put
a
breakpoint
somewhere
here
when
I'm
adding
a
visit.
So
when
I'm
clicking
this
one
and
I
was
clicking
adding
a
visit.
This
is
my
monolithic
application,
bin-debug,
let's
release
it
and
now,
when
I'm
coming
here
and
I'm
clicking
my
micro-services.
A
Basically
it's
my
goal:
ocation
debug!
So
that's
the
idea
and
I
think
that
it's
really
really
powerful
help
you
to
move
in
your
free
time.
So
again,
instead
of
taking
all
your
monolithic
application
rewrite,
it
will
take
you
a
lot
of
time
and
you're,
not
getting
new
feature.
Just
extend
the
feature,
basically
extend
it
with
wherever
you
want
micro
service
to
serve
allies
and
then
on
your
free
time.
Do
that
while
you
actually
do
gradually
moving,
hopefully
it's
helpful,
all
of
them
is
open
source
and
I.
Will
love
love,
love
to
get
feedback?
A
A
The
squash
one
of
the
glue
it's
depend,
so
if
it
squash
wondering
what
you
ask
is
about
debugging,
what
we're
doing
is
basically,
we
use
we
leveraging
the
technology
like
kubernetes
and
cloud
foundry
and
they
already
filter
what
you
can
and
cannot
do
right.
So,
if
you
are
not
supposed
to
see
this
board,
you
will
not
be
able
to
debug
it
if
we're
talking
about
debugging
and
I
hope
that
that's
what
you
talk
about.
A
A
B
A
I
said:
if
you
cannot
get
there,
you
can
see
that
you
can
debug.
It
will
be
also
doing
it.
I
said
with
these
filters,
is
that
once
we
getting
the
arrow
you
wanted
to
send
we
just
creating
a
shadow
request,
that's
basically
not
affecting
the
cluster.
It's
like
imagine
that
we're
doing
a
snapshot
there.
Okay,
so
it's
not
influence
your
environment
environment
continue
running,
but
what
we're
doing
is
basically
forking
it
and
then
letting
you
debug
this,
but
we're
basically
giving
you
a
snapshot
of
the
environment,
so
you
can
see
it
all
to
debug.