►
From YouTube: Intro: Linkerd - William Morgan, Buoyant
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Intro: Linkerd - William Morgan, Buoyant
In this session, William Morgan will provide an introduction to Linkerd, the CNCF's service mesh project. Linkerd features blazing fast performance, an ultralight footprint, a Kubernetes-native design, and open governance. You'll learn what it does, why it's useful, differences with other service meshes, and finish with a brief Q&A.
https://sched.co/UaiT
A
So
I'm
gonna
go
ahead
and
get
started.
I
know
we
still
have
a
couple
folks,
trickling
in
but
there's
a
lot
of
stuff
I
want
to
cover
and
we
have
35
minutes
to
do
it.
I
want
to
leave
a
bunch
of
quiet
time
for
questions
at
the
end.
So,
let's
see
you
know,
maybe
if
I
can
get
through
the
kind
of
slide
portion
in
15
minutes,
then
we'll
have
ten
minutes
for
a
demo
in
ten
minutes
for
Q&A.
A
A
Culminating
in
me
creating
this
service
mesh,
yes
by
myself,
you
know
from
from
pure
genius
inspiration
yeah!
Thank
you.
Thanks
I
am
linker.
D
ya
know,
so
the
reality
is
linker.
D
is
a
community
project.
It's
a
CNC
F
project.
There
are
many
many
people
who
have
spent
a
lot
of
blood,
sweat
and
tears
on
on
linker,
D
and
I
am
ostensibly
a
maintainer
of
Lincoln
II,
but
I'm.
Really
it
these
days,
I'm
mostly
the
maintainer
of
the
readme
and
I.
Don't
do
a
whole
lot
of
coding.
I.
A
Do
a
whole
lot
of
talks
like
these.
So
thank
you
again
for
for
for
coming
here
and
I'll
try
and
make
it
worth
your
while.
So
what
is
linker
D?
It
is
a
service.
Mesh
I'm
gonna
spend
a
tiny
bit
of
time
going
over
what
a
service
mesh
is.
It's
an
open
source,
linker
DS,
an
open
source
project.
It's
a
CNC
F
project.
Hopefully
you
saw
the
keynote
update
this
morning
with
Bryan
Liles.
All
sorts
of
activity
going
on.
A
We
have
a
very,
very
healthy
community,
been
in
production
for
over
three
years,
a
lot
of
friendly
folks
on
the
slack
Channel.
Lots
of
github
stars,
of
course,
very,
very
important
and
a
ton
of
contributors,
and
so
you
know
I
by
being
in
this
room.
What
I
want
to
invest
in
you,
the
power
to
to
link
or
D.
You
are
already
members
of
the
link
or
D
community,
so
you're
already
a
part
and
all
sorts
of
fancy
production
adopters,
which
is
so
important.
Okay,
so
you
know
linker
D
is
a
service
mesh.
A
What
is
a
service
mesh
do
and
typically
I'd
like
to
break
this
down
into
three
general
categories
right.
One
category
is
around
observability:
okay,
one
categories
around
reliability
and
one
categories
around
security.
So
on
the
observability
side
well,
link
your
D
can
do
is
give
you
well
there's
a
lot
of
stuff,
but
one
of
the
things
we
can
do
is
we
can
give
you
what
we
call
golden
metrics,
which
are
things
like
the
success
rate
and
the
latency
distribution
and
the
request
volume
of
the
traffic
going
to
and
from
a
service.
A
We
can
draw
a
service
topology
for
you.
We
can
do
distributed
tracing,
there's
a
bunch
of
other
fun
stuff.
We
can
do
and
I'll
show
a
little
bit
of
that
in
the
demo.
At
the
end,
you
can
also
there's
a
bunch
of
cool
reliability,
features
that
it
gives
you
primarily
oriented
around
kind
of
synchronous,
HTTP
calls
so
things
like
retries
and
timeouts,
and
load
balancing
and
circuit
breaking
or
all
the
things
that
linker
D
can
do.
And
then
this
set
of
security
features.
A
A
We
care
about
identity
on
both
sides,
so
both
that
gives
us
both
encryption
and
identity,
and
you
know
most
important
for
us-
is
we
we
do
all
this
in
a
package
that
is
focused
on
operational
simplicity,
which
means
that
when
you
add
a
service
mesh
to
kubernetes,
we
don't
want
to
make
it
any
harder
than
it
really
needs
to
be
right.
You've
already
gone
through
the
exercise
of
adopting
kubernetes
and
its
massive
api
surface
area.
A
We
don't
want,
then,
the
service
mesh
to
be
like
an
additional
700
things
that
you
have
to
worry
about,
so
a
big
focus
on
linker
DS.
How
do
we
provide
these
features
for
you
in
a
way
that
is
as
easy
as
possible
as
simple
as
possible,
and
especially
from
the
operational
aspect,
the
least
burdensome
possible
you
can
see
a
couple
of
screenshots
of
our
fancy.
Dashboard
also
show
that
as
part
of
the
demo.
A
Ok,
so
that's
that's
like
the.
What
but
I
think
what's
more
interesting
is
the.
Why
should
I
care
and
actually
just
wrote
a
very,
very
long
form
version
of
this
slide
at
service
mesh
IO?
It's
like
a
15-page
like
mesh
efest?
Oh
so,
if
you
are
bored,
yeah
I
just
came
up
with
that
term.
So
if
you
are
bored
or
you
have
a
long
flight
home
or
whatever
feel
free
to
check
out
surface
mesh
dot
IO,
but
so
so,
why
should
I
care
right?
A
So
the
reason
why
linker
D
is
interesting
and
the
reason
why
any
service
mesh
is
interesting
is
I.
Think,
there's
a
couple
aspects:
there's
there's
a
who
there's
a
what
there's
a.
Why
and
there's
like?
What's
the
magic
element
right
and
the
who,
for
the
service
mission
is
primarily
what
we
call
this
platform
owners,
which
are
the
sres,
the
architects,
the
folks
who
are
building
the
internal
platform
for
their
organization?
That's
the
immediate
target
audience
for
linker
D.
A
Now
the
service
owners,
who
are
you,
know
the
developers
who
are
building
code
on
top
of
this
platform.
They
also
get
a
lot
of
value
out
of
this,
but
they're
kind
of
a
secondary
audience.
Okay,
and
how
do
we
make
this?
The
platform
owners
happy?
Well,
we
give
them
those
primitives
right
and
we
give
them
in
a
way.
A
That's
the
goal
right
and
seeing
through
that
lens
I
like
to
say
that
linker
D
doesn't
solve
technical
problem
so
much
as
it
solves
socio
technical
problems,
it
decouples
of
platform
owners
from
the
developers
so
rather
than
you
relying
on
the
developers
to
implement
TLS
and
for
every
team
to
use
TLS
in
the
exact
same
way
you
can
solve
it
at
the
platform
level
right
same
thing
with
reliability,
features
same
thing
with
the
observability
features.
It's
not
a
complete
solution
in
any
of
these
domains.
A
Right,
there's
a
lot
more
to
observer
ability
than
just
looking
at
service
success
rates.
It's
a
lot
more
to
reliability
than
like
you
know,
retries
on
HTTP
gets
and
there's
certainly
a
lot
more
to
security
than
just
adding
a
bunch
of
encryption
everywhere,
but
it
gives
you
the
link.
Ferdie
gives
you
this
platform
centric
slice
of
those
features
that
make
sense
so
far.
A
Okay,
so
I
talked
a
little
bit
about
this
there's
there's
a
bit
of
history
and
linker
D
that
I'm,
mostly
not
going
to
go,
go
into
and
I'm
gonna
talk
about
like
a
modern
version
of
linker
D,
which
is
the
2x
branch.
2.6
is
the
most
recent
version.
2.7
is
will
be
released
later
this
year
and
so
on.
Alright-
and
here
we
have
some
very
explicit
design
goals,
which
is
we
want
linker
D
to
do
the
least
amount
of
things
possible
right.
So
every
feature
you
add
is
like
a
cost
right.
A
It
expands
the
surface
area
explained
it
expands
the
operational
complexity,
so
we're
trying
to
do
less,
not
more
right
and
we
have
got
a
we've
got
a
couple
design
principles.
So
the
first
is
we
want
to
just
work,
which
means,
if
you
have
a
functioning
kubernetes
application,
you
install
linker
D
on
top
of
it,
your
application
should
continue
to
work.
A
That's
right!
Yes,
it's
genius
right!
It
turns
out,
it's
actually
really
hard
to
do
so.
We've
got
all
sorts
of
fancy,
protocol,
detection
and,
and
things
like
that,
ultralight.
Of
course,
we
want
to
reduce
as
much
as
possible
the
computational
burden
right,
which
means
not
just
the
CPU
consumption
and
the
memory
consumption,
but
especially
the
latency,
because
that's
actually
what's
gonna
end
up
being
user
facing
in
a
very
direct
way
and
then,
most
importantly,
simplicity
right.
A
Here
actually
has
a
couple:
more
I
have
a
slide
with
a
couple
more
links
to
talks,
the
rest
of
Kubb
cons
and
iego,
but
one
of
them
you
want
to
get
you
know
if
you
want
to
graduate
from
intro
level
2
like
deep
dive
level.
My
colleague
and
the
real
creator
of
linker
D
Oliver
Gould,
is
giving
a
link
or
D
deep
dive
later
in
those
comments.
A
Ok,
so
this
is
what
linker
D
looks
like
from
the
architectural
perspective:
I'm
not
going
to
go
into
too
many
of
the
details
here,
but
you
can
see
that
it's
roughly
divided
into
a
control,
plane,
data
plane
and
the
control
plane
has
like
all
sorts
of
bits
and
things
that
do
things
and
the
data
plane
actually
looks
very
simple
here
right.
But
when
you
deploy
this
thing,
the
control
plane,
you
know
you
have
between
1
and
3
kind
of
replicas,
the
data
plane
you
may
have
hundreds
or
thousands
or
tens
of
thousands
of
replicas.
A
So
this
is
just
the
conceptual
diagram
and
in
here
every
blue
box
is
like
a
kubernetes
pod
boundary
and
so
in
the
data
plane
section
you
can
see
that
the
way
this
works
as
with
not
all
but
many
service
meshes
is,
we
add
a
little
proxy
called
linker
D
proxy
here
and
it
gets
jammed
right
next
to.
In
fact,
it
could
stand
in
the
same
pod
as
your
service,
your
application
instance,
and
we
do
some
wiring
so
that
all
TCP
traffic
automatically
goes
to
and
from
that
proxy
and
there's
all
sorts
of
reasons.
A
There's
there's
there's
upsides
and
there's
downsides
to
this
approach.
Obviously
you
know
there's
like
we're,
adding
proxies
I've
ever
in
fact
we're
heading
to
proxies
to
every
hop
all
right,
because
when
a
talks
to
B
it
goes
through
its
proxy
and
then
through
the
destination
proxy.
So
there
is
an
impact
to
doing
that.
A
Okay,
how
fast
slash
small
is
it
we
did
some
benchmark
well,
a
company
called
kinfolk
did
some
benchmarks.
You
can
read
their
blog
post
about
it,
it's
I
guess
the
TLDR
is
that
it's
fast
and
but
it's
a
lot
worse
than
not
having
a
service
mesh.
So
if
you
really
want
to
be
fast,
don't
Lee
and
the
service
mesh
at
all,
but
it's
also
a
lot
faster
than
Sto
when
we
do
Q&A.
A
A
Okay
and
we
are
more
or
less
on
track
for
time
if
I
can
stay
focused
here,
okay,
so
roadmap
as
of
2.6,
which
was
announced
last
month
or
released
last
month,
we've
got
all
sorts
of
crazy
features
distributed
tracing
is
in
there
lots
of
caveats
about
distributed
tracing,
but
we
support
it.
Traffic
shifting
is
in
there,
so
you
can
shift
like
a
percentage
of
traffic
from
one
service
to
another
as
part
of
like
a
Bluegreen
deploy
or
something
like
that.
A
Great
telemetry
I'll
show
that
off
and
retry
as
time-outs
proxy
auto
injection,
which
means
you're,
not
all
the
all
the
injection
stuff,
where
we
add
that
proxy
into
the
container
of
the
application
instance,
it's
all
done
on
the
server
side,
so
you're
not
doing
anything
at
deploy
time
that
even
looks
special
you're.
Just
like
deploying
your
stuff
as
usual,
a
mutual
tell
us
on
by
default
for
all
HTTP
communication
raizy
the
moment
all
linker
D
and
you
add
the
data
plane
to
your
service.
All
HTTP
communication
is
automatically
pls.
You
don't
get
a
choice.
A
Well,
you
can
turn
it
off,
but
it's
on
by
default.
I
think
that's
really
important,
because
security
here
D
works
best
when
it
is
free
right,
then
the
harder
you
make
it
right,
the
less
inclined
people
are
to
do
it
and
more
configuration
that's
involved.
While
you
leave
that
thing
for
later
right,
but
when
I
use
my
web
browser
and
I'm
connecting
to
Reddit
and
looking
at
cat
pictures
or
whatever
I
get
the
green,
lock
icon,
you
know
and
I
haven't
done
any
work
on
my
side.
A
A
So
I
want
to
give
you
that's
clearly
like
a
security
theme
here
we
want
to
give
you
really
good
introspection
into
what
is
T
less
than
what
it's
not
because
sometimes
it's
not
clear
rotating
certs
in
the
control
plane,
all
sorts,
other
fancy
stuff
and
then
getting
into
next
year
policy.
So
right
now,
linkers!
Yes,
every
time
you
want
to
make
a
connection,
sometimes
we
might
want
to
say
no
you're
not
allowed
to
make
that
connection.
That's
policy
enforcing
TLS
or
not
allowing
non
TLS
connections
to
happen.
A
A
Briefly
I'll
briefly,
I
will
just
say:
there's
a
lot
of
linker
D
content
at
coop
con
this
year,
which
is
very
exciting
for
us
all.
The
stuff
on
Tuesday
you've
basically
already
missed,
because
the
only
other
linker
D
thing
that
hasn't
happened
is
happening
right
now,
which
is
Rita
and
I.
Think
talking
about
OPA
gatekeeper,
which
is
a
really
cool
project,
but
everything
gets
recorded.
A
So
you
can
always
watch
these
things
afterwards
and
then,
tomorrow,
Anna
and
reach
are
going
to
be
talking
about
some
really
cool
stuff
that
they
did
with
linker
D
at
pay
base.
If
you're
into
functions
as
a
service,
half
Alex
and
Charles
talking
about
open,
faz
and
then
Oliver
like
I
mentioned,
will
be
doing
a
deep
dive
and
then
finally,
Brian
Redman
from
Microsoft
on
Thursday
will
be
talking
about
super
charging.
A
Your
micro
services,
CI
CD,
there's
a
lot
content
and
all
these
things,
what
I'm
gonna
try
and
do
now
give
you
a
very
brief
demo
of
linker
D
and
then,
if
I
can
wrap
that
up
in
time
and
if
the
demo
gods
are
with
me,
we'll
have
a
bunch
of
time
for
Q&A
making
sense
to
everyone.
So
far,
all
of
these
slides
are
actually
while
they're
on
schedule,
but
there's
also
a
linker
D
they're
derived
from
this
linker
D
meetup
deck
public
meetup
deck.
A
A
A
There
are
some
thing:
I'm
gonna
do
is
I'm
going
to
apply
so
before
I
do
any
service
myself,
I'm
gonna
apply
this
manifest
and
I've
been
using
this
manifest
for
like
three
years
so
I
know
this
application
pretty
well
okay,
so
it
creates
this
namespace
emoji
photo
and
it's
got
a
bunch
of
services
that
are
running
in
there
and
then,
if
I
go
to
my
handy-dandy
kubernetes
dashboard.
Hopefully
we
will
see.
Oh.
A
A
Okay,
there
we
go
all
right,
so
you
know,
I
can
go
to
this.
Emoji
photo
named
face.
Clearly,
there's
some
stuff
running
here
and
in
fact,
I
can
even
go
and
I
can
see
what
this
I'm
app
is.
So
if
I
go
to
a
local
host,
you
can
see
this
app
for
voting
for
your
favorite
emoji.
So
you
know
we'll
vote
I,
like
the
smiley
ghost
guy,
all
right.
Okay,
cool
I
actually
have
a
bot.
That's
going
in
here,
that's
generating
traffic.
So
it's
also
voting.
This
is
like
man
vs.
A
machine
and
then
the
bug
the
app
has
a
bug
in
it
right.
So
for
the
sake
of
this
demo,
every
time
you
click
on
the
doughnut
thing,
it
returns
a
500
or
404
okay.
So
the
reason
why
I
like
to
start
with
this
app
is
because
you
look
at
the
kubernetes
dashboard
as
far
as
its
concerned:
everything's
healthy,
all
right
and
so
we're
in
this
state
now,
which
is
not
uncommon.
Where
we
have
an
application.
A
We
know
the
applications
broken,
but
as
far
as
kubernetes
is
concerned,
like
everything's
fine
pods
are
green
if
everything's
running
nodes
are
up
okay,
so
this
is
like
this
is
a
good
intro
to
the
surface
mission.
So
what
I'm
gonna
do
is
I'm
going
to
install
linker,
D,
okay,
so
I've
got
a
little
CL
CL
I
link,
D
version,
great
and
I'm
gonna
install
it
and
the
way
install
works
is
just
emits
a
manifest.
That's
other
ways
of
doing
this.
A
A
Lightning
fast,
and
then
we
have
this
little
command
called
linker
D
check,
which
is
this
gonna,
validate
that
everything's,
okay
with
linker
D,
okay-
and
it's
detected
that
you
know
this
thing
is
not
ready,
so
it's
waiting
for
it
doctor
for
mac
is
frantically
struggling
under
the
load.
And
what
what's
interesting
here
is
you
can
see
that
it
is
waiting
for
linker
D
proxy
for
that
container
in
this
pod
and
well
now
moved
on
to
the
next
one
that
was
not
called
so
he
was
looking.
It
was
looking
for
a
data
plane
proxy.
A
You
can
use
the
exact
same
tools
that
we
give
you
to
inspect
your
application
and
to
understand
the
state
of
your
application
to
understand
the
state
of
linker,
D
I.
Think
that's
really
important,
because
a
service
mesh
is
really
confusing,
especially
the
first
time,
and
if
you
are
the
poor
fool
who
introduces
a
service
mesh
into
your
ecosystem,
then
the
moment
that
anything
breaks
you
or
the
first
person
who
gets
blamed
because
you
just
introduced
this
garbage
technology.
A
So
I
want
to
give
you
that's
what
they
would
say
and
then
I'm
going
to
give
you
the
tools
to
understand
and
to
show
and
to
inspect
exactly
what's
happening
on
the
linker
decides
that
you
can
defend
this
beautiful
piece
of
technology
from
naysayers,
okay,
so
the
linker
D
check
says
everything's,
okay
and
then
let's
just
spin
up
the
dashboard,
so
that
wasn't
too
bad
installing
a
service
mesh
and
60
seconds,
even
on
a
slow
computer.
Okay.
So
here's
the
linker
D
dashboard.
A
It
looks
kind
of
similar
to
the
to
the
kubernetes
dashboard
similar,
but
different,
and
you
can
see
it's
got.
We've
got
a
whole
bunch
of
namespaces
here
and
the
linker
D
namespace
is
the
only
one
that's
getting
metrics
right
now.
That's
because
all
I've
done
this
installed
the
control
plane
which,
as
I
mentioned,
has
a
data
plane
in
it.
The
other
names
faces
have
not
been
meshed,
so
there's
no
data
plane
in
there.
A
A
Okay,
so
now
you
know,
emoji
Votto
is
still
running
here.
Right,
I
haven't
done
anything
with
this
application
and
it's
still
got
the
same
problem.
So
what
I'm
going
to
do
next
is
I'm
going
to
add
the
data
plane
into
emoji
code.
Oh
and
there's
a
variety
of
ways
of
doing
this,
but
for
ease
of
use,
I'm
going
to
use
this
inject
command
and
let
me
see,
do
I
actually
have
okay.
So
what
I'm
gonna
do
is
I'm
actually
going
to
show
you
the
difference.
I'm
gonna
show
you
what
link
ready
inject?
A
Does
it's
just
a
text
transform
command
so
what
it's
gonna
do
really.
Is
it
just
gonna?
Add
this
annotation,
that's
a
sling
to
D
IO
inject
enabled
it's
gonna.
Add
that
to
every
deployment
in
this
manifest,
you
can
also
add
this
at
the
namespace
right
and
that's
the
only
changes
of
making
other
than
apparently
you're
ordering
a
line
from
here
to
there.
That's
the
only
change
right
and
once
the
link
once
linker
D
sees
that
annotation.
Then
it's
going
to
know
when
you
deploy
this
thing,
I'm
going
to
inject
the
data
plane,
prods
pods!
A
A
And
scant
moments
is
yeah
we
can
see,
so
we
can
see
that
well
all
right,
it
happened
so
fast.
We
could
barely
see
it.
No,
there
we
go
so
we
can
see
that
something
has
gone
tragically
wrong.
No,
we
can
see
that
everything
was
meshed,
so
one
out
of
one
pods
for
each
of
these
deployments
has
been
meshed
and
now
we're
starting
to
see
metrics
come
through
the
system.
Alright,
so
we've
added
without
emoji
Votto
having
to
be
changed
or
without
you
having
to
do
anything
or
write
any
code.
A
We've
added
the
proxy
next
to
every
deployment
and
traffic
is
going
through
those
things
and
we're
getting
metrics
out
of
them
by
the
way
we've
also
encrypted
everything.
So
emoji
Votto
was
fully
secure
and
while
not
fully-
but
you
know
it's
encrypted
at
least
our
emojis
encrypted
our
emojis,
which
is
important
and
we're
reporting
all
these
metrics
we're
aggregating
them
and
we're
displaying
this
dashboard.
A
You
might
have
noticed
a
little
graph,
wanna
logo
here,
so
we
can
even
see
we
pre
generate
these
graph
wanna
dashboards
per
service
and
there's
there's
all
the
ones
that
are
included
on
the
box.
So
you
can
see
how
success
rate
you
know
for
these
things.
It's
actually
not
that
great.
Ok,
this
making
sense
so
far
great
I'm
gonna
show
off
one
last
thing
and
then
we'll
do
we'll
do
Q&A.
A
So
you
may
have
noticed
that
no
success
rate,
it's
actually
not
that
great,
alright
cuz
cuz
of
that
bug,
alright,
and
so
now
we
have
some
actual
numbers
around
that.
Okay,
so
we
can
actually
start
with
this
web
deployment
here
and
the
way
to
read
this
is
web
is
in
the
middle
and
all
the
sources
of
traffic
for
web
or
on
the
left
and
all
of
the
destinations
for
traffic
around
the
right.
We're
drawing
this
picture
automatically
just
from
metrics
data.
A
So
we
can
see
that
here's,
my
bot,
that's
sending
you
know,
looks
like
closer
to
two
requests
per
second
to
web,
and
so
web
has
a
paltry
96
percent
success
rate.
It's
dropping
alright,
but
we
can
see
that
it
in
turn
calls
these
two
services
and
it's
actually,
this
voting
service.
That
seems
to
really
be
failing.
Okay,
let's
click
on
that
thing.
Let's
see
that
voting
has
only
one
client
which
is
web
has
no
dependency,
so
it's
just
a
standalone
service.
Here
we
scroll
down
a
bit.
A
What
we're
seeing
here
is
a
sample
of
the
live
calls
that
are
happening
through
the
system.
These
are
g,
RPC
calls
linker
to
use
fully
G
RPC
ready,
and
we
can
see
actually
that
if
we
sort
these
things
my
success
rate,
one
of
these
calls
has
failed.
Everything
else
has
been
a
hundred
percent.
One
of
these
calls
has
failed.
Okay,
there's
three.
Now
three
occurrences
of
this
failed
okay,
so
we
can
watch
us
a
little
bit
longer,
but
basically
this
call
is
a
culprit.
A
Oh
kubernetes
thinks
it's
running
so
everything's.
Fine
here
is
the
exact
success
rate.
Oh
here's,
the
service,
that's
failing!
Oh
here's!
The
call
on
that
service.
That's
failing!
It's
all
done
without
modifying
the
application,
so
that's
just
a
very,
very
small
sample
of
the
sort
of
stuff
you
can
do
with
linker
D
I
hope
that
made
sense
to
you
and
I'm
going
to
pause
it
as
luck,
it's
a
lot
more
to
demo,
but
I'm
just
going
to
pause
here
since
we
have
about
eight
minutes.
Left
I
would
love
to
take
questions.
A
A
We've
got
a
formal
security
audit
where
they
were
blown
away
by
how
incredible
linker
D
was
and
we're
a
collection
of
friendly
folks.
Okay,
now
before
I
call
the
first
person
I
want
you
to
remember
what
I
said:
hey
this
guy's,
giving
me
the
nod
all
right.
How
does
linker
D
compare
to
sto?
Oh,
that's
a
great
question:
yeah
yeah,
so
I
always
get
asked
that
question.
It's
like
the
first
first
question:
yeah
I,
don't
want
to
speak
too
much
for
the
sto
project,
but
I
think
the
goals
of
the
two
projects
are
similar
right.
A
We
there's
a
set
of
features
around
reliability
and
security
and
and
observability.
There
are
some
differences
in
opinion,
and
you
know
but
I
think
the
biggest
in
the
scope
of
that.
That
feature
said,
but
I
think
the
biggest
difference
is
the
focus
right.
So
the
focus
for
us
is
on
minimizing
operational
cost
as
much
as
possible.
Even
if
that
means
we
have
to
be
slower
to
add
features,
I
think
the
focus
for
this
it's
quite
different
and
then,
but
you
should
take
both
of
these
projects
and
you
should
compare
them.
A
A
Yeah,
so
that's
this
right,
so
that's
a
good
question:
I,
don't
have
a
great
way
of
showing
you
a
breakdown
of
the
status
codes.
What
I
can
tell
you
is
that
that
404
was
a
translation
by
the
web
front-end
of
AG,
RPC
error
and
G
RPC.
Has
this
weird
status
thing
where
everything
is
a
200,
but
you
have
a
G
RPC
status,
that's
like
unknown
or
okay
or
something
else.
So
that's
why
you
saw
a
404
and
on
the
on
the
website,
but
you're,
seeing
you're
just
seeing
this
like
not
successful
thing
over
here.
A
That
makes
sense.
Actually
let
me
see
if
I
can
like
sorry.
Let
me
try
one
thing
here:
cuz
I
think
we
might
actually
break
this
down.
I
just
lost
a
call,
stateless
services.
All
right.
Let
me
wait
for
this
thing
to
come
up
and
then
we'll
do
one
more
investigation,
because
I
think
there
is
a
way
of
showing
you
the
status
the
status
code
hold
on
for
one
second,
because
I
want
to
do
this
side
of
the
room
okay
way
over
there.
Yes,
you.
A
Yeah
yeah,
that's
a
really
good
question,
so
the
question
was:
how
does
linker
D
deal
with
the
fact
that
some
of
the
stuff
kind
of
naturally
gets
into
developer
concerns,
so
circuit
braking
was
one
example,
even
potentially
things
like
retry
policies,
you
know
our
developer
specific,
so
they're.
What
we've
tried
to
do
is
design
the
linker
D
API
is
in
a
way
that
at
a
minimum,
the
the
way
that
they
attach
is
to
the
the
core
objects
that
each
role
would
be
fault,
that's
a
little
complex.
A
So,
for
example,
for
for
retries
and
timeouts,
we
had
this
idea
of
a
service
profile
right
in
a
service
profile
attaches
to
an
individual
service
right,
so
it's
kind
of
in
the
developers,
area
of
expertise
and
it
configures
exactly
how
retries
and
time
us
work
just
for
that
service
right
and
you
could
potentially
do
that
else.
You
know
in
700
different
ways.
The
way
we've
chosen
to
do
to
try
and
attach
it
to
the
domain
object
as
much
as
possible.
So
it's
not
a
complete
solution.
A
It's
not
a
perfect
solution
and
I
think
this
is
still
an
area
that
the
world
is
figuring
out,
because
obviously
there
are
these
two
teams
at
least
two
teams.
Often
you
know,
there's
a
security
team
and
you
know,
and
other
teams
involved-
and
they
each
have
different
things-
that
they're
interested
in
and
different
things
that
they're
able
to
control,
but
yeah
I
think
that's
that's
the
first
step
for
us,
I
hope
that
makes
sense.
A
A
We
rely
on
you
sending
stuff
up
with
ingress
if
you
set
things
up
correctly
and
you
like
propagate
some
headers
or
forward
some
headers
or
something
we
can
give
basically
answer
the
easy
version
of
that
question,
which
is
we
can
give
you
metrics
once
you
start
getting
into
things
like
identity
and
stuff
and
Multi
cluster
things
and
like
can
you
preserve
identity
across
calls?
That's
where
things
get
a
lot
more
complicated,
but
the
easy.
A
The
easy
version
is
yes,
great
question:
okay,
I'm
bouncing
back
to
the
side
of
the
room:
yes,
yeah,
linker
D
identity,
any
integration
with
spiffy
great
question
no
I'd
like
to
at
some
point,
but
right
now
we
try
and
do
the
simplest
thing
possible,
which
is
we
we
just
take
the
kubernetes
service
account
and
that
is
your
identity.
Yeah,
once
once
we
get
into
like
Multi
cluster
mesh
expansion
stuff
than
things
like
spiffy
become
a
lot
more
relevant
yeah
great
question.
A
Yeah,
so
the
question
was
basically:
how
does
link
or
do
you
integrate
with
open
tricks?
How
well
does
it
integrate
with
open
tracing,
and
the
answer
is
great
great
integration
distributed
tracing
is
complicated.
There's
a
long
blog
post.
We
wrote
about
this.
What
the
service
mesh
can
do
is
actually
quite
minimal
right.
You're.
Still,
you
still
end
up
doing
most
of
the
work.
What
the
service
mesh
can
do
is
in
the
proxies
we
can
emit
a
distributed.
Tracing
span
right
when
traffic
goes
through.
A
It
goes
through
the
proxy,
but
we
need
you
to
propagate
headers
in
the
application
to
do
that,
because
otherwise
we
can't
tie
incoming
requests
and
outgoing
requests
in
the
presence
of
concurrency.
So
we
do
support
open
tracing,
but
the
reality
is
link
reduce
porting,
open
tracing
is
like
5%
of
the
work
you're
gonna
have
to
get
to
actually
get
to
the
point
where
you
see
a
distributed.
Tracing
dashboard
yeah
go
ahead.
A
Yeah,
so
in
this
tea,
oh
there's,
a
mixer
mixers
have
adapters.
Adapters
can
connect
to
various
things
and
linker
D,
there's
not
really
an
equivalent
that
yet
yet
we
want
to
get
there.
I
want
to
do
it
in
a
way
that
it's
not
the
way
that
mixer
does
it
because
I
think
that's
responsible
for
some
of
the
performance
issues
in
sto,
but
we
want
to
get
to
that
point
and
I
would
love
a
pull
request
with
them.
Even
an
issue
with
a
very
specific
set
of
criteria.