►
From YouTube: Decoupling observability from the application using Dapr
Description
This talk/demo will show how Dapr decouples observability (i.e. distributed tracing, metrics, logging & health) from the application development. There’s no need to reference libraries or implement custom instrumentation code. Dapr allows the developer to focus on building business logic instead of observability plumbing. We will see how easy it is to move the app to a different monitoring platform using Dapr.
A
I
just
want
to
introduce
myself,
I'm
vivek
the
bit
of
different
set
of
roles
I
have
played.
Currently
I
am
a
senior
cloud
advocate
in
cloud
and
ai
engineering
team
of
microsoft,
and
this
is
my
digital
coordinate.
You
can
connect
with
me
in
any
of
these
coordinates
and
we
can
have
a
deep,
deeper
discussion
on
today's
topic
as
well
or
any
other
topic
as
well.
A
So
I
had
no
answers
at
that
time.
You
know
I
had.
I
said
you
know
it's
going
to
take
time
to
build
it
and
you
have
to
go
back
and
instrument
it.
We
can't
do
anything
about
it.
You'll
have
to
spend
some
time,
but
today
I
can
confidently
answer
that
you
know
you
can
use
a
distributed.
Application
runtime,
which
is
dappers
in
solving
those
problems,
and
I've
been
talking
about
observability
observability
can
be
you
know,
divided
into
four
border
categories.
A
Tracing
metrics
logging
and
health
tracing
is
about
understanding
the
traffic
between
services,
the
performance
and
performance
bottleneck
between
services
when
they
interact
for
a
specific
business,
transaction
and
metrics
is
about
resource.
Consumptions
and
logging
is
about
understanding
the
errors
and
warnings
available
within
either
code.
Getting
some
insights
on
that,
and
then
there
is
health
endpoints.
A
I'll
have
to
install
the
modules
specific
to
zipkin
and-
and
you
can
see
there
are
a
couple
of
you
know,
a
couple
of
things
where
has
been
called
out
from
a
zipkin
perspective
in
the
code
itself,
and-
and
if
I
have
you
know,
that
is
one
part
of
the
problem.
So
if
you
have
25
30
services,
40
services
as
a
developer,
you
need
to
make
sure
you
have
to
code
it
and
the
moment
you
code,
there
is
a
bug
right.
So
that's
that's
the
implementation.
A
You
know
overhead
right
and
and
if
you
have
to
move
away
into
a
different
tool
like
eager,
which
is
also
a
tracing
tool,
you
still
have
to
implement
it
in
a
different
way
and
this
both
the
implementation
are
different,
even
though
both
of
them
are
for
python.
Both
of
them
are
using
flask.
The
implementations
are
different
and
as
a
developer,
you
need
to
understand
how
to
instrument
this,
and
how
does
you
know
dapper
solve
this
problem?
Simple
it.
It
provides
you
a
container,
a
site
from
a
sidecar
architecture
perspective.
A
A
There
is
collector
open,
telemetry
collector
available,
and
once
you
have
collected
into
open
telemetry,
you
can
use
it
with
any
of
these
different
set
of
different
set
of
tools
which
is
out
there.
I
could
use
egger
prometheus
and
zipkins
and
her
things
so
so
it's
basically
you're
not
instrumenting
the
code.
All
you're
doing
is
you're,
enabling
the
in
a
pod
or
you're,
adding
a
new
container
to
the
part,
which
is
which
is
the
dapper
and
and
capturing
all
the
information
through
that.
A
There
is
a
site
car
for
the
service,
a
which
is,
you
know,
set
up
by
the
dapper,
and
then
there
is
a
collector.
So
each
time
there
is
an
interaction
happening,
there's
information
has
been
collected
and
from
the
collector
I
can
use
it
with
any
of
the
any
of
the
tools
and
it
could
be
for
health.
It
could
be
for
logging,
it
could
be
for
metrics,
it
could
be
for
tracing.
A
So
both
you
know,
sidecast,
for
service
b
and
service,
a
is
pushing
the
information
to
the
collector
and
from
through
collectors,
I'm
able
to
capture
all
the
information
and
and
note
that
it
provides
out-of-the-box
support
for
various
set
of
tools.
So
you
need
not
go
back
to
service
a
and
service
b
and
instrument.
These,
like
the
way
I
showed
you
right,
zipkins
and
eggers.
I
could.
I
could
use
service
a
with
you
know.
With
this
zipkin
or
probably
service
b
is
set
up
with
aegis.
A
It
could
be
a
different
set
of
all
together
different
set
of
companies
as
well
right,
so
service,
a's
and
service
being
could
be.
You
know
different
orgs
within
the
company
and
they
are
talking
to
each
other
for
different
services,
and
maybe
they
might
be
using
different
observability.
You
know
back
ends
right,
so
that's
that's
the
use
case
and
we
will
see
how
to
develop
that.
A
Let's
not
worry
too
much
about
what
it
provides,
and
on
top
of
that
you
know
basically
instrumenting
instrumentation,
how
it
is
easy,
and
you
know
how
you
can
configure
sample
rates
and
other
things
or
from
a
metrics
perspective,
how
you
can
set
up
all
of
these
things,
I'm
going
to
focus
on
tracing
and
we're
going
to
see
a
demo
of
that
and
how
to
set
this
up
all
right.
So
let
me
go
back
and
see
whether
my
kubernetes
cluster
is
up.
A
Yes,
cluster
is
up
so
I'll
go
to
the
cluster,
and
this
is
my
cluster,
which
is
on
azure
azure,
and
it
is
azure
communities
service.
What
we
need
to
do
now
is
to
make
sure
that
I
have
access
to
the
cluster,
so
so,
basically
I'll
just
say
connect.
So
what
is
there?
This
is
the
credentials
which
I
need
to
provide
so
and
let's
just
take
this
up
and
say:
dapper
demo,
already
resources
set
right.
This
os
is
stepper
test
perfect.
A
So
so
I'm
just
trying
to
make
sure
that
I
am
in
the
context
and-
and
I
know
the
community's
context
is
set
on
my
system,
so
I've
set
the
context,
so
we
can
also
test
check.
It
is
set
or
not
config
get
context,
and
when
you
do
that,
you'll
get
this
information
and
you
can
see
there
is
one
context.
It
has
been
set
right,
so
cool,
so
we
are
good
to
go,
and
all
I
have
is
a
cluster
now
and
I
have
you
know
a
demo
app
which
is
out
there.
A
A
It's
an
azure
voting
app
and
it's
a
backend
backend
is
radius
and
nothing
different
and
it
is
sitting
on
a
service.
You
know
there
is
access
to
it.
It's
kind
of
a
access
to
this
specific
back
end
and
then
there
is
a
word
front
front
end
which
is
having
a
load
balancer
attached
to
it,
and
there
is
a
front
end,
which
is
a
simple
code
which
is
out
there.
So
I'm
going
to
use
that
code,
and
this
is
already
a
pre-build
image
which
is
there
and
you
can
just
reuse
it.
A
A
This
is
the
app
so
azure
ort
initial
in
in
it.
So
it's
basically,
there
is
no
wrapper
installed
on
top
of
it.
I
have
not
done
the
instrumentation
of
any
tracing
on
the
on
the
app
so
right
now.
All
I
have
is
a
cluster
and
and
with
the
cluster
I
have
ins,
you
know
created
an
app
and
we
will
see
what
this
app
is.
A
Basically
doing
so,
let's
see
say
if
I
have
to
check
that's
up
the
link,
I'm
going
to
copy
me
and
come
back
here,
and
this
is
not
the
app.
This
is
the
one
old
one
so,
and
this
is
yet
to
come
up.
So
while
it
is
coming
up,
we
will
do
a
couple
of
things:
okay,
while
it
is
coming
up,
the
app
is
coming
up.
What
we
will
do
is
we
will
install.
We
will
install
a
dapper
that
installation
of
dapper
cli
is
very
simple.
A
You
can
just
go
and
look
for
it.
You
can
just
go
and
brew,
install
and
dapper,
and
you
will
get
you
know,
installation
done
and
once
you
have
installed
wrapper
you
just
you
know,
check
for
the
installation
and
you
can
see
there
is
a
bunch
of
things
from
a
cli
perspective,
so
you
have
the
distributed
application,
runtime,
cli
up
and
running
for
you.
So
all
you
need
to
do
is
now
make
sure
that
you
initialize
this
with
kubernetes.
A
So
you
have
to
run
this
run
this
specific
command
when
the
context
is
set
for
your
kubernetes
cluster.
So
it's
not
like
you
just
go
out
there
and
just
run
this
command
and
it
will
get
started.
You
just
want
to
make
sure
that
it's
it's
it's
part
of
the
class.
You
know
the
context
is
set.
So
once
you
have
the
context
set,
it
is
deploying
a
control
plane.
So
so
it's
basically
deploying
that
control
plane
onto
your
cluster.
A
A
So
we
are
ready
with
this,
and
all
we
need
to
do
is,
you
know,
run
configuration.
So
what
is
configuration
is
app
configuration.
So
this
is
the
configurations.
So
couple
of
configurations
you
need
to
do
this
is
a
configuration
we
need
to
run
to
enable
zipkin.
So
here
is
the
end
point
and
zipkin
endpoint,
and
I'm
going
to
talk
about
how
you
can
change
this
endpoint
to
a
edgar
and
it
gets
converted
into
an
eager
dashboard.
But
we
are
going
to
anyways,
see
that
but
simple
to
remember.
We.
A
I
just
want
to
make
sure
that
this
component
is
enabled
so
I'm
enabling,
on
the
dapper
I'm
going
to
use
this
control
plane.
You
know
the
operator
which
has
been
installed
and
we're
going
to
you
name
it
app.config
and
there
is
sampling
rate.
So
all
the
request
will
be
captured
at
this
specific
endpoint.
All
the
requests
which
is
going
through
the
app
will
be
captured
as
part
of
the
tracing.
So
that's
what
sampling
rate
one
means
right.
A
Configurations.
Hyphen
k,
which
is
communities,
did
I
miss
configurations?
Okay,
it's
s
so,
basically,
once
let's
run
it
again,
just
for
making
sure
okay,
once
you
run
this
command,
the
configurations,
so
you
can
see
here.
App
config
is
is,
is
ready
and
tracing
is
enabled
and
metrics
is
enabled
so
by
default,
metrics
is
enabled
whenever
you
have
depos
right
so
by
default
it
is
enabled
when
you
run
app
config
configurations.
You
know
yaml
file,
so
you
can
also
disable
it.
A
So
all
we
need
to
do
is
basically
go
back
and
what
else
we
need
to
do
so
we
just
need
to
go
and
code.
So
now
we
need.
We
have
this
code.
We
haven't
enabled
anything
specifically
in
the
code
in
the
ammo
of
specifically
the
the
configurations
right.
So
there
is
nothing
changed,
so
what
we
will
do
is
we're
going
to
go
here.
A
A
So
what
I'm
going
to
do
now
is
adding
annotations
and
you
can
see
I'm
enabling
with
app
config
that's
what
we
did
from
a
deeper
perspective,
so
here
it
initializes
a
a
new
container
and
added
it.
On
top
of
it's
like
a
side
car
attached
to
the
container
which
is
going
to
run
similarly,
I'm
going
to
do
it
for
the
front
end
as
well.
So
there
is
addition
we
go
here
into
in
it
and
we're
going
to
add
same
set
of
things
for
this
one
as
well,
so
I'm
saving
it.
A
A
A
A
So
what
we'll
do
next
is
we
have
the
hot
in
it
and
before
I
go
and
run
the
old
init
file,
I
will
just
make
sure
that
everything
is
up.
So
we
have
the
cluster
on
cluster.
We
did
install
the
dapper
control
plane
and
then
we
we
had
obviously
deployed
an
app.
It's
it's
ready
and
we
have
you
know.
Basically
a
couple
of
things
enabled
all
right,
so
we
have
zipkins
and
we
have
set
up
the
zipkin.
A
A
A
You
just
need
to
hit
iphone
k
and
you
will
see
the
dashboard.
Let
me
bring
the
dashboard
here
this
couple
of
things,
which
is
happening
right
now.
We
can
see
here.
These
two
have
been
enabled
from
our
dapper
application
perspective
in
the
dashboard,
and
if
I
go
here,
you
can
see
a
couple
of
things
metadata,
the
app
id
port
and
other
things
and
configurations
it
is
bringing
in
and
logs,
and
you
can
also
see
you
know
the
logs,
which
is
there
for
specifically
for
this
specific
thing.
A
So
this
is
also
a
telemetry
data
and
yeah.
So
for
back
as
well,
you
can
see
the
same
set
of
things
is
available
for
that
as
well.
So
you
can
also
see
that
for
for
front
end
and
the
back
end
right.
So
this
is
the
control
plane
and
you
can
see
this
in
the
service
as
well
in
azure
community
service.
You
can
see
here.
I
did.
I
hope
I
did
show
you,
but
this
is
world
bank
rapper
and
you
can
see
here.
A
There
are
two
different
services
getting
enabled
here
for
these
two
different
services.
We
got
two
different
containers
as
well,
so
now
I
hope
it
will
capture
the
data.
So
I
am
running
this
app
and
this
app
is
up.
I'm
calling
again
resetting
it
running
couple
of
things.
Hopefully
thinking
there
is
that's
how
it
is
so
now
you
have
enable
tracing.
Now
you
can
see
there
is
trace
available.
I
didn't
do
anything
on
the
code.
A
I
didn't
imp,
you
know
install
any
of
those
pb
install
zipkin,
flask,
zipkin
or
something-
and
I
didn't
do
any
of
those
things
or
for
edgar
I'll
show
you
for
ager
as
well,
but
I
didn't
do
anything
it's
just
zip.
Can
I
have
I'm
just
having
these
set
of
tracing,
which
is
happening
and
you
can
see
you
know.
I
can
see
the
trays.
A
I
can
see
everything
coming
in
and
also
the
time
it's
taking
for
executing
couple
of
things
right,
so
I
can
always
go
back
and
see
a
couple
of
things
right,
so
so
data
is
available
already.
So
all
I
need
to
do
is
you
know
it's
all
set
all
I
need
to
do
for
changing
this
specific
thing
is:
let's
go
here,
you
know,
install
eager
and
get
that
egger
up
and
running
like
how
we
got
zipkin
and
just
go
to
tracing
and
I'll.
Show
you
a
code.
A
A
I'll
just
wrap
it,
so
you
can
see
here
change
the
end
point
to
this.
Instead
of
this
and
give
a
different
name
and
just
execute
it.
So
once
you
execute
once
you
apply
this
yaml
and
obviously
you
have
to
make
sure
that
you
change
the
name.
If
you
have
changed
the
name,
just
change
the
name,
that's
it
you'll
move
to
egr
as
well
dashboard
as
well.
So
that's
how
simple
it
is
to
instrument
your
code
and
that's
how
simple
it
is
to
get
things
done.