►
Description
Ask Your Proxy, It Knows Everything - Blake Mizerany, Backplane
Proxies have long been layered into distributed systems but rarely do we lean on them to do more than route, and balance load. In this talk we will go over how to use proxies to replace Service Discovery, control Release Managment and Traffic Shaping, and streamline Employee on-boarding/off-boarding. You'll talk away never looking at your proxies/load-balancers the same.
About Blake Mizerany
Founder / CTO, Backplane
Sinatra, Heroku, Doozer, Etcd, Backplane
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
My
name
is
Blake
Missouri
nee
I
have
worked
at
a
number
of
companies
you
may
have
heard
of,
but
my
current
company
that
I
founded
it's
called
back
plain
or
we're.
Building
a
globally
distributed
fleet
of
smart
proxies
to
do
a
lot
of
what
we're
talking
about
today,
but
formally
before
that
I
was
at
Heroku
and
I
was
also
at
core
OS,
where
I
worked
on
@cd
and
when
I
was
there
I
kind
of
felt
like
Martin
yan?
How
many
of
you
know
Martin
yen,
yeah,
ok,
no,
ok,
so
Martin
yan
is
a
chinese-american
chef.
A
He
had
this.
Had
this
really
awesome
show
on
PBS
back
in
the
80s
called
again
can
cook,
and
this
was
during
a
time
when
everyone
was
talking
about
French
cuisine
and
maybe
burgers
and
fries
or
grilling
or
whatever,
and
then
here's
this
guy
on
PBS
with
nothing
but
a
walk
in
a
cleaver
making
some
really
amazing
dishes
and
just
blowing
people's
minds,
and
in
doing
so
he
also
taught
a
lot
about
cooking
with
just
a
few
simple
tools
versus
having
an
entire
array
or
a
kitchen
stocked.
A
A
This
is,
for
you
know,
just
like
brute
force
everything,
but
he
was
able
to
take
this
thing
and
use
it
as
if
it
were
like
it
weighed
nothing,
and
it
was
just
a
really
amazing
art
form
to
watch
him
mince
garlic
with
just
a
quick
slap
of
the
wrist
and
like
just
crank
through
things
or
julienne,
bell,
peppers
and
so
forth.
I
highly
recommend
watching
some
of
the
older
videos
on
YouTube.
This
guy
is
hilarious
and
he's.
It
definitely
has
a
very
comedic
kind
of
bit
about
him,
but
I
love
cooking
by
the
way.
A
So,
that's
probably
why
I
know
him
most,
but
anyway,
yeah
I
kind
of
like
to
when
I'm
I've
been
you
know,
doing
I,
guess
cloud
native
for
like
10
years
now,
since
you
know
early
at
Heroku
how
many
of
you
have
ever
used,
Heroku
or
okay
great.
So
you
are
all
cloud
native
long
before
so
anyway,
so
yeah.
So
some
of
the
interesting
problems
that
I
worked
on
and
I
spent.
Almost
all
my
time,
working
on
were
load,
balancing
and
proxying
service
discovery.
A
A
My
way
through
or
I
want
to
talk
you
through
a
little
app,
a
very
simple
app
and
we're
gonna
kind
of
go
through
the
evolution
of
a
distributed
app
and
then
look
at
how
some
tools
that
we
kind
of
almost
I
would
say.
Neglect
could
actually
make
things
a
whole
lot
easier
and
help
us
simplify
our
applications
as
well.
A
So
let's
build
a
to-do
list.
I've
chose
it
to
do
list
because
it's
something
everybody
can
relate
to
has
worked
with
and
is
constantly
aggravated
with
on
all
the
like
everything
that
is
out
there
and
available
today.
So,
let's
go
through
and
build
a
very
basic
one
and
then
we'll
see
how
complicated
and
how
quickly
it
can
become
complicated.
A
So
this
is
our
to-do
list.
We
have
one
list,
that's
our
shopping
list,
there
are
items
and
there
are
checkboxes
and
with
these
checkboxes
we
can
check
things
off.
This
is
the
most
basic
to-do
list.
We
could
possibly
build
how
many
of
you
have
built
one
of
these.
Maybe
it
was
like
a
fun
project
when
you
first,
you
know
like
something
to
like
kind
of
dip,
your
toes
into
some
new
technology
or
languages.
You
can
build
a
to
list
and
then,
let's
add
a
new
feature.
A
Another
feature
might
be
that
we
can
have
multiple
to-do
lists.
That
seems
reasonable
and,
like
a
really
great
feature
to
have
there's
my
life,
isn't
just
one
long
list
of
things
do
I
like
to
categorize
them.
So
how
might
we
build
that
I
think
and
to
get
started?
It
might
look
something
like
this.
How
many
of
you
would
probably
just
default
to
this?
You
have
your
HTTP
server
and
you
have
a
database
super
basic
super
easy.
This
is
the
right
way
to
start.
A
This
is
a
sequel
database
by
the
way
we're
not
going
or
anything
yet
okay,
and
so
our
our
call
graph
our.
If
we
were
to
look
at
this
as
like
a
distributed
system,
our
our
time
line
would
probably
look
like
this.
If
we
were
to
implement
the
marking
or
the
completion
of
an
item,
we
would
have
mark
done.
A
We'd
probably
pass
in
something,
like
you
know,
some
some
basic
information,
but
mostly
the
list
name
that
we
want
to
check
them,
hide
them
off
and
what
item
in
the
list
it
was,
but
this
is
a
little
too
simple,
so
I'm
already
losing
people,
it's
a
to-do,
app
I
know
all
right.
Just
follow
me,
we'll
just
bear
with
me.
This
gets
a
little.
This
gets
fun.
So
let's
build
an
enterprise
ready,
to-do
list.
A
Okay,
how
many
of
you
have
been
to
enterprise
ready,
dot
IO
if
you're
working
on
anything
or
anything
or
selling
anything
to
enterprises?
You
should
you
need
to
read
that
site?
It's
absolutely
great,
but
one
of
the
first
things
you're
gonna
need
to
do
is
build
users
and
organizations
right
like
no
one,
no
enterprise
or
any
a
company
is
likely
to
use
your
product
without
this.
So
what
might
that
look
like?
Well,
we
can
still
keep
our
database
and
we
can
still
keep
the
simplicity
of
our
architecture,
but
we're
gonna
need
some
new
tables
right.
A
We're
gonna
need
users,
organizations
and,
and
most
likely
will
need
roles
as
well,
because
we're
gonna
want
to
build
some
kind
of
role
system
into
this.
This
app,
and
so
let's
look
at
our
caller
our
timeline
again.
So
our
timeline
starts
to
look
like
this.
First,
we
need
to
go,
get
the
role
whenever
we
want
to
mark
something
done
well,
we
need
to
make
sure
that
someone
can
actually
mark
it
done.
Do
they
exist
in
the
organization
that
that
list
is
in?
Can
they
do
they
have
the
privileges
to
mark
something
done?
A
Can
they
do
any
of
these
things,
and
once
the
once
we've
figured
all
that
out,
then
we
can
mark.
The
item
is
done
right.
So
that's
two
separate
calls.
That's
two
calls
to
the
database
to
do
one
simple
thing
to
mark
it
in
the
database,
but
let's
go
a
little
bit
further:
let's
build
an
enterprise
ready
social
to-do
list,
and
what
does
that
look
like
that
looks
like
this?
People
can
watch
you
creating
lists
and
checking
off
items
and
being
proud
and
being
productive
right.
I
I
can
follow
a
list.
I
can
follow
a
person.
A
A
list
can
follow
a
person.
If
maybe
I
don't
know,
we
could
have
audit
logs.
We
can
have
all
sorts
of
other
interesting
features
to
it,
right,
we're
building
a
sauna
now,
and
so
now
our
architecture
might
look
like
this.
Any
of
you
have
tried
to
create
any
kind
of
social
graph
or
any
kind
of
graph.
For
that
matter.
Anything
goes
beyond
just
basic
inside
of
a
sequel
database.
A
All
knows
to
what
knows
all
too
well
there
like
it
gets
a
little
complicated
and
performance
can
have
a
bit
of
an
impact
at
scale,
and
we
tend
to
scale
right.
So,
in
order
to
do
this,
we're
probably
going
to
want
something
like
a
graph
database,
so
this
graph
database
is
going
to
model
the
relations
that
we
have
between
lists
and
users
and
likes
and
followers
and
etc,
etc,
etc.
A
Right,
but
we'll
still
keep
all
of
our
canonical
information
inside
the
the
transactional
database,
so
that
we
have
a
source
of
truth
and
can
rebuild
that
graph.
If
we
had
to
so
now,
our
our
system
starts
to
look
like
this.
We
have
to
get
the
rolls
right.
We
still
have
to
get
rolls.
We
still
have
to
determine
whether
or
not
this
person
can
write
to
this
list.
I
eat
check
something
off.
A
We
need
to
then
write
the
mark
to
the
database,
and
then
we
need
to
notify
everybody
on
our
graph
in
our
immediate
following
list
of
what
just
happens
right,
we
need
to
get
allow
them
to
see
that,
like
I
am
being
productive,
I
have
done
something
so
there's
a
problem
with
this.
Well,
actually
before
that,
let's
add
one
more
feature:
let's
add
feature
flags
right.
So
now
we
have
someone
who's
like
well,
you
know
I'd
really
like
to
be
able
to
like
bring
on
five
or
six
users
to
try
this
new
beta
feature
out.
A
You
know
within
the
organization
so
now
we're
gonna
add
yet
another
table.
We're
gonna,
add
flags.
So
we
have
feature
flags
now
right
and
these
feature
flags
they're,
pretty
basic.
It's
like
on
or
off
it's
some
kind
of
key
value.
Pair
right
I
mean
people
model
it
differently,
but
it's
all
basically
the
same
concept
and
then
we
have
to
do
billing.
We
can't
plan
on
you
know
charging
people
for
this
right
right,
okay,
guys
it's
the
after
lunch
slump
here.
A
So
so
we
have
to
do
billing
and
in
order
to
add
billing,
let's
let's
oversimplify
billing
and
say
it's
one
table
and-
and
so
now
you
can
kind
of
start
to
get
this.
This
idea
and
you're
starting
to
understand
where
I
might
be
going
here-
and
that
is
this-
is
becoming
a
little
complex.
We
were
building
a
to-do
app
right,
like
we
weren't
trying
to
build
like
this
whole,
like
social
system,
in
fact
we're
reinventing
the
wheel
and
nearly
every
one
of
these
things.
So
there's
another
problem
with
this.
A
If
you
look
at
this
a
we
have
to
keep
data
synced
between
the
transactional
database
and
the
graph,
because
the
transactional
database
is
our
source
of
truth.
So
we
need
to
make
sure
that
it's
constantly
in
sync
with
our
graph,
our
graph
databases
and
sync
with
that.
So
that's
gonna,
require
some
other
mechanisms
as
well.
I'll
leave
that
as
an
exercise
for
you
all
to
take
home
later,
but
there's
one
big
key
thing
here
and
that
is
in
our
tracker
transactional
database.
Look
at
that.
75%
of
our
database
is
not
really
value.
Add
right.
A
It
is
not
something
that
we're
having
to
like.
We
want
to
really
be
in
the
business
of
dealing
with,
so
even
so,
we
might
reach
out
to
third-party
services
or
whatever,
and
that's
one
great
way
to
start.
But
if
you
want
to
own
some
of
it,
then
you're
gonna
have
to
find
another
way
and
in
fact
this
also
causes
another
problem.
The
other
problem
is,
is
that
as
we
grow
the
application,
we
start
to
have
other
micro
service
if
we
start
a
micro
services
architecture
right,
so
maybe
we
have
our
site.
A
Our
marketing
site
has
you
know
some
knowledge
and
intimate
knowledge
of
our
users
and
organizations
and
who's
build
one
etc,
and
also
the
the
API
the
API
most
definitely
has
almost
all
more
information
than
any
of
these
other
apps
and
the
admin
panel
that
like
allows
us
as
administrators
and
operators
of
this
to-do
list.
This
allows
us
to
be
able
to
manage
our
users
and
manage
things
and
the
dashboard.
A
Of
course,
we
all
have
dashboards
and
that
thing
needs
to
start
slurping
data
out
of
this
database,
and
so
all
of
these
services
start
to
get
very
familiar
with
this
database.
Almost
too
familiar.
They
start
to
get
very
tangled
and
the
disentanglement
cost
becomes
more
and
more
an
exponentially,
more
expensive.
So
what
we
can
do
and
then,
oh
sorry,
to
make
matters
worse.
Each
one
of
these
is
written
in
a
different
language.
A
A
You're,
not
all
writing
the
like
grid,
the
one,
perfect
language
you
want
to
use
right,
like
your
there's
many
different
languages,
and
so
this
means
that,
in
order
to
to
do
the
things
that
you
want
with
organizations
and
roles
and
access
management,
you
wind
up
having
client
libraries
written
in
many
several
different
languages.
There's
many
different
versions
of
them
out
there
within
the
organization
and
things
start
to
get
really
hairy.
A
A
So
there's
one
thing
that
we
can
use
that
can
help
us
move
away
from
all
of
this
and
help
us
remove
the
intimacy
that
all
these
applications
have
to
have
and
the
headache
of
having
to
upgrade
several
different
libraries
across
several
different
languages
across
the
organization,
and
this
is
our
proxy,
so
how
many
of
you
use
a
proxy
from
more
than
just
the
basic
stuff
right.
So
the
great
thing
about
proxies
is
that
they
speak
Universal
wire
protocols
like
they're,
completely
language
agnostic.
A
A
What
sed
says
is
not
the
actual
case
of
what's
actually
going
on
in
your
system
and
in
production
things
are
flapping,
moving
around
dying,
coming
up
like
taking
more
load
than
others,
etc,
and
so
your
proxy
it
does
more
than
load
balancing.
It
can
do
more
than
load
balancing
your
proxy
can
do
more
than
TLS
termination,
and
your
proxy
can
definitely
do
more
than
just
doing
some
quick
header
rewrites
for
you
to
you
know
service
those
old
blog
post
URLs,
because
you
moved
from
one
blog
to
the
other
last
year.
A
Right,
your
proxy
can
make
macro
decisions,
it
has
all
of
this
information,
and
so
why
don't
we
allow
our
proxies
to
make
more
decisions
for
us
that
are
more
mundane
and
more
time-consuming
for
us
to
do.
Then
we
do.
Why
do
we
always
keep
trying
to
do
this
in
the
applications,
and
the
other
thing
that
it
can
do
is
add
context
to
your
requests
for
you
as
well,
and
so
I'll
get
into
this
in
a
second
I
like
to
call
this
enrichment.
This
is
like
request
enrichment
right.
A
So,
as
a
request
comes
in
there's
some
some
amount
of
information
associated
with
it,
and
if
there
is
information
that
it
does
that
the
proxy
does
not
have
it
can
do
the
same
things,
we
would
normally
do
in
our
application
code
to
get
more
context
around
what's
happening
such
as
authentication,
but
how
many
of
you,
what
there's
a
really
famous
request
in
Richmond?
It's
it's
something
that
all
of
you
use
and
are
all
of
you're,
pretty
familiar
with
I!
Think
and
can
anyone
name
and
it's
a
header
holy?
A
Yes,
yeah
yeah,
it's
x-forwarded-for
right,
like
that's
a
request
in
Richmond,
it's
a
giving
you
some
context
around.
What's
going
on
and
like
so
when
you
get
that
request,
you
can
make
a
slightly
more
intelligent
decision
if
you
need
to
make
a
decision
based
on
where
the
actual
original
reading
IP
was
some
load
balancers,
including
backplane
plug,
can
give
you
country
code.
They
can
give
you
the
city
code
and
those
that
are
smart
enough
to
actually
do
authentication
on
your
behalf
and
more
of
a
zero
trust.
Networking
beyond
Corp
style
and
an
identity.
A
Aware
style
can
give
you
the
provider.
That
was
authenticated.
They
can
do
the
authentication
for
you
and
also
tell
you
who
they
authenticate
or
who
they
are
authenticated
it
with.
They
can
give
you
the
identity
of
the
of
who
was
authenticated
and
what
it
gets
even
more
attractive
is
when
you
say
that,
well
what
if
I
want
attributes
that
I
specify
about
a
specific
identity?
So
maybe
there's
this
header
called
aw
attributes
and
it's
just
a
set
of
strings
just
tags,
just
just
just
arbitrary
things
that
our
user
defines
or
are
also
provider
to
find.
A
This
can
get
begin
to
get
interesting.
So
if
we
go
back
to
our
to-do
list,
what
if
we
injected
strings
for,
say,
Blake
it
back
Lane
do,
and
it
may
mean
to
say
I'm
allowed
to
mark
things
off
of
the
shopping
list,
so
our
string
might
look
kind
of
like
this
kind
of
follow
this
format
right.
So
here's
just
I
invented
this
for
the
slide
presentation.
This
is
to
do
:,
org
list
action
like
this
is
our
format
right.
How
many
of
you
have
ever
worked
with?
I
am
roles
in
AWS
right
like
yeah.
A
That's
that's
the
same
thing
right
like
that's
his
exactly
how
that
we're,
how
this
works,
there's
an
access
proxy
that
deals
with
these
things,
so
our
code
can
then
look
like
this.
This
is
go
so
or
pseudo
go
so
here
we
can
just
do
a
quick
branch
statement
when
we
receive
a
request.
We
can
already
have
contextual
information
about
that
request.
A
We
can
know
who
was
identified
and
we
don't
have
any
of
you
can
grep
our
entire
code
base
and
there
is
zero
oo,
auth
or
Oh
IDC
anywhere
in
that
code,
like
all
that
nuance,
the
thing
all
having
to
upgrade,
you
know
the
the
ruby
gems
or
the
packages,
the
libraries
of
the
maven
packages
or
whatever,
like
that's.
That's
all
the
thing
in
the
past.
I'm
not
worrying
about
that
anymore,
because
my
proxy
is
able
to
do
it
and
tell
me
what
it
is
I
should
be
doing,
and
so
I
can
just
trust
the
proxy.
A
So
let's
go
back
to
this
this
timeline
again
for
our
to
do
that.
Remember
we
had
get
roles.
We
need
to
get
the
roles
for
the
user
that
we
were
that
we
were
authenticating
ourselves.
We
had
to
go
and
create.
We
had
to
check
to
see
whether
they
could
right.
So
that's
another
database
call.
We
had
to
then
mark
it,
as
you
know,
mark
it
as
okay
and
then
also
update
our
graph.
So
these
things
are
all
step
by
step
in
a
very
linear
fashion.
We're
not
getting
a
lot
of
like
this.
A
Isn't
this
isn't
as
ideal
as
we
would
like
it
to
be,
but
what's
great
now
is
that
we
have
attributes
coming
from
our
proxy
that
we
told
the
proxy
about
earlier.
We
said:
hey
that
Blakey
black-bean
do
is
totally
okay.
It's
it's
fine
Graham
to
mark
things
as
as
done
on
the
shopping
list
under
the
organization,
backplane,
etc.
A
So
now
our
clan,
our
timeline
looks
more
like
this,
we're
less
complicated
right,
so
we've
eliminated
the
need
to
make
any
calls
to
the
database
like
we're
being
told
what
to
do.
We're
told
what
is
what
we
don't
have
to
ask
anymore,
but
what
also
this
this
also
allows
us
is
to
add
some
parallelism.
Now
too,
we
don't
have
to
do
the
atomic
check
first
to
make
sure
that
the
person
is
capable
of
doing
what
it
is.
They
say
they
can
do
we're
we're
not
having
to
ask
anyone
first
and
make
expensive
Network
calls.
A
Instead,
we're
told-
and
so
now
that
we're
being
told
we
can
eliminate
the
need
to
go
to
that
round
trip,
and
also
we
know
that
it's
totally
okay,
that
both
of
the
graph
and
the
transactional
database
are
capable,
and
it
is
okay
to
make
that
right
to
both.
So
we
don't
have
to
wait
so
now
we
can
do
something
like
this.
We
can
just
go
ahead
and
do
both
of
those
at
the
exact
same
time,
we
don't
have
to
wait
for
permission,
we've
already
been
given
permission
and
we
can
trust
our
proxy.
A
We
still
need
that
to
identify
all
the
relationships
between
you
know:
who's
watching
what
and
etc,
but
we
can
eliminate
the
complexity
of
users
and
roles
and
access
and
feature
flags
and
etc,
and
all
this
like
all
this,
can
be
pushed
up
into
the
proxy.
So
to
answer
your
question
this
slide,
so
now
our
proxy
doesn't
need
an
API.
A
Now,
though,
so
what,
if
your
proxy
had
an
API
that
you
could
post
to,
and
you
could
just
treat
it
as
this
kind
of
you
know,
black
box
service
that
you
could
say:
hey
just
update
this
user
and
then
all
the
sudden
from
then
on
out,
like
whenever
you
start
to
getting
requests
about
from
a
user.
This
new
context,
these
tags,
these
labels,
that
you've
identified
for
them
are
automatically
merged
in
and
enriched
within
the
proxy
and
then
sent
to
all
of
your
services.
A
You
can
do
it
without
having
to
update
all
of
your
services
and
all
of
your
applications.
No
one
has
to
deal
with
anymore.
These
are
arbitrary
strings
that
you
defined,
not
some
data
layer
that
everyone
has
to
completely
re
rewrite
all
of
their
their
code.
To
talk
talk
with
that
data
layer.
Does
that
answer
your
question?
A
A
We
can
now
logically
shard
our
database
if
we
wanted
to
scale
out
instead
of
logically
shot
like
if
you
want
a
logically
shard
based
on
lists
in
the
current
version
with
the
previous
one,
all
the
users
and
lists
would
have
to
be
duplicated
or
some
other
new
database
would
have
to
come
online
for
everyone
to
understand,
to
be
able
to
go,
get
all
those
permissions
and
roles
and
interesting
information
before
they
can
write
to
the
list
database,
which
is
being
shorted
out.
But
now
you
don't
have
to
worry
about
that.
A
So
it
would
look
like
this,
and
so
now
we
don't
those
complicated
inter
joins
that
we
had
and
all
that
intimacy,
that
we
had
inside
of
our
sequel
queries
and
on
inside
of
our
client.
Libraries
is
all
gone
now
and
that
frees
us
to
to
be
able
to
do
other
things
and
had
more
performance
and
scale
to
our
system.
A
What
this
also
gives
us
is
central
control.
This
gives
us
the
ability
to
control
who
and
what
can
see
what
from
a
specific
API
that
looks
like
this,
you
have
a
plain
API
and
that
plain
API
is
like
the
all-knowing
it
is.
It
is
the
central
source
of
truth
now
for
anything
that
you
are
telling
it
about
and
asking
it
to
enrich
your
requests
with
and
there's
one
more
thing.
So
there's
a
few
other
things
a
proxy
can
do
for
you,
I
mean
there's,
so
many
I
don't
have
time
for
it.
A
But
if
you
have
a
smart
proxy
that
has
this
feature
built
into
it
like
it
can
take
care
of
all
this
for
you
and
if
it
has
an
API
and
you
can
in
real
time
while
it's
running
tell
it
different
weights
for
different
versions
of
your
service
and
different
builds
of
your
service.
You
can
have
multiple
builds
running
simultaneously.
You
can
ship
one
one
percent
of
it.
A
You
know
the
request
to
this
cluster
and
99
over
to
this
or
some
variation
thereof,
and
you
can
test
out
new
and
interesting
features
without
having
to
you
know,
do
a
full
up
fold
down
where
you
just
redeploy
the
whole
world
all
at
once,
and
if
you
have
a
global
fleet
of
them,
then
you
get
other
interesting
aspects.
You
get
you
get
cloud
agnostic,
/,
Multi,
multi
cloud
failover.
A
You
can
now
run
in
multiple
different
environments
and
have
all
of
your
configuration
and
interests
and
information
being
enriched
at
the
edge
and
then
once
it
gets
down
into
the
cloud
provider.
The
proxy
doesn't
know
what
cloud
you're
at
it
doesn't
care,
and
when
you
receive
that
information,
you
don't
need
to
care
where
you
exist,
either
you're
able
to
just
operate
so
you're
having
less
dependency
on
the
cloud
cloud,
less
less
dependency
on
cloud,
specific
features
or
cloud
specific
services,
and
and
relying
more
on
on
your
proxy
to
give
you
the
information
you're
looking
for.
A
So
it
would
look
like
this
right,
so
hopefully,
I've
convinced
you
that
proxies
can
do
a
whole
lot
more
than
what
we've
previously
relied
on
them
to
do
like
load,
balancing
and
TLS
management
right.
It's
kind
of
that
thing
that
a
lot
of
people
set
up
and
they're
kind
of
like
I'll
just
provision.
This
thing
over
here
or
I'll,
set
up
in
genetics
or
I'll.
Just
do
this
and
then
it
kind
of
just
eventually
turns
into
this
big
lump
of
mess.
How
many
of
you
have
had
like
at
least
6,000
lines
of
an
engine?
A
A
So
enclosing
trust
your
proxies
start,
relying
on
them
more
start,
pushing
more
information
to
them
and
make
that
information
and
how
it
came
to
that
information
more
transparent
towards
the
services
that
are
running
within
your
organization.
Developers
are
much
happier,
they
move
master
and
they
can.
You
can
offload
all
this
Monday
and
work
like
feature
flagging
and
billing,
and,
and-
and
you
know,
I
am
roles
a
back
our
back
systems.
It's
it's!
It's
a
pleasure
like
once.
A
You
can,
you
can
do
all
sorts
of
new,
interesting
performance
tuning
to
your
app
when
it
doesn't
when
it
isn't
concerned,
with
all
of
these
things
that
are
75%
of
your
app
right,
I
like
the
flags
and
everything.
So
with
that,
thank
you
and
we're
hiring.
So
please,
if
you're
interested
in
back
playing
and
would
like
to
work
with
us,
I
would
like
to
talk
to
you.
So
thank
you
that
was
it.
A
Yeah
sure
so
in
that
you
want,
like
you're
gonna,
want
mutual
other
than
a
mutual
authentication
with
your
proxy.
You
want
to
know
that
when
you
talk
to
that,
when
you
receive
that
request,
you
want
to
be
able
to
know
that
you're
getting
it
from
a
reputable
source.
Yes,
so
there
are
concerns
in
that,
like
it
backplane
we
do
a
reverse
dial
like
and
then
we
you
have
a
token
that
goes
out
to
the
edge,
and
then
it
does
a
dozen
mutual
off
that
way.
A
A
A
It's
just
a
string
so
just
say
like
to
do,
has
blue
background
instead
of
green
background
and
then
check
that
check
that
check
for
that
that
tag
when
it
comes
in
it's
a
much
nicer
model
than
like
having
some
SDK
that
goes
out
to
a
database
and
like
it's
constantly
keeping
an
LRU
cache
or
something
like
that
and
like
hitting
the
database
constantly.
Instead,
the
proxy
keeps
the
cache,
and
then
you
can
just
thread
that
all
the
way
through,
which
is
really
nice.