►
Description
Notes: https://github.com/vmware-tanzu/tgik/tree/master/episodes/105/README.md
- 00:00:00 - We lcome to TGIK!
- 00:03:26 - Week in Review
- 00:16:35 - Start dapr exploration
Come hang out with Joe Beda as he does a bit of hands on hacking of Kubernetes and related topics. Some of this will be Joe talking about the things he knows. Some of this will be Joe exploring something new with the audience. Come join the fun, ask questions, comment, and participate in the live chat!
This week we'll be looking at dapr (https://dapr.io). This is "an event-driven, portable runtime for building microservices on cloud and edge." Joe will be installing it and checking out how it works.
A
A
For
those
who
are
not
familiar.
Tti
kubernetes
is
a
YA
weekly,
ish
thing
where
me,
or
one
of
my
compatriots
start
streaming
plays
around
with.
You
know,
talks
about
what's
happening.
The
kubernetes
ecosystem
starts
playing
with
some
new
technology
and
we
explore
it
together.
I
think
we
tend
to
go
long,
because
this
is
all
unfiltered
a
lot
of
times,
I'm
learning
stuff
for
the
first
time
and
yeah,
and
so
that's
that's
generally.
A
What
we
do
I'd
like
to
start
out
by
saying
hello
to
everybody
who's
joining
me
when
we
first
did
this
I
hadn't
realized
that
this
is
like
the
worst
time.
You
know
to
actually
hold
one
of
these
things,
because
so
many
other
folks
around
the
world,
it's
Friday
night
or
Saturday
morning
or
the
middle
of
the
night.
Or
what
have
you?
But
thank
you
everybody
for
joining
me
regardless,
and
so
you
know
it's
I'm.
A
He
also
this
Jorge
Castro
who's
big
in
the
kubernetes
community
also
I
also
helped
to
pull
together
a
bunch
of
the
links
that
we're
gonna
be
going
over
for
the
for
the
news
of
the
week.
So
thank
you
for
that.
Jorge
Tim
from
San
Francisco
Martin
from
the
Netherlands
proof
Adar
from
Seattle
good,
to
see
you
Ian
from
Cardiff,
Evan
compatriot
from
Bellevue
Evan.
Do
you
want
to
do
one
of
these
ones?
We
can
rope
you
into
it.
A
Nuno
from
Portugal
yatin
from
Ashford
Virginia
Philippe
from
hair
mm
check,
BAM
chick
from
India,
where
Tessa
from
Tehran
Wow
good
to
see
you
Derrick
from
Tim
San
Mateo
Amman
from
Bellevue
Sun
tush
from
Philly
Scottie
from
Pensacola
Dublin
Tegh,
a
good
to
see
you
Paul
from
Brits,
pin
another
yarn
from
from
Bellevue
another
person
from
Bellevue
Gregor
from
Switzerland
Jo
from
London
and
Chen
from
Ken
Moroso,
a
lot
of
folks
from
around
the
Seattle
area.
Hopefully
folks
that
are
working
on
dapper,
which
we
great
because
I'm
gonna
need
all
the
help
I
can
get.
A
A
One
of
the
maintainer
Xand
also
sent
me
some
of
the
pointers
of
where
we're
gonna
start
here.
So
let's
go
through
sort
of
our
news
of
the
week
to
begin
with.
Now,
one
of
the
things
that
we
do
here
is
we
crowdsource
notes,
and
so,
if
there's
any
notes
or
links
or
stuff
that
you
want
to
share,
feel
free
to
edit
this
document
here
you
can
get
to
this.
A
Let's
see
it's
George.
Can
you
put
the
link
in
there
to
the
to
the
hack
MD,
and
then
we
copy
and
paste
this
into
a
repo
link
to
that
repo
from
the
description
of
the
video,
so
that
this
stuff
all
kind
of
ties
together?
So
if
you're
watching
this
after
the
fact,
you
can
definitely
see
it
there,
alright
so
stuff,
that's
going
on
so
kubernetes
1.18
is
percolating
along.
We
have
a
code
freeze
on
March
5th,
we're
on
alpha
5,
and
we
have
this
amazing.
Oh,
this
is
not
the
the
full
change
like
we.
A
A
So
another
thing
that's
going
on
here
is:
let's
see
we
have
okay,
so
this
is
fascinating.
So
this
dates
back
honestly
to
the
first
integrations
of
kubernetes
with
docker,
is
that
we
wanted
to
have
this
idea
of
a
pod.
A
pod
was
a
whole
bunch
of
santosh
good
to
see
you
yeah.
If
you've
worked,
I
worked
with
eks,
you
can
definitely
adapt
and
learn
this
stuff
I
try
and
keep
stuff
clear,
kubernetes,
so
yeah.
So
when
he
was
early
on
when
we
were
integrating
with
docker,
we
had.
A
The
idea
of
the
pod
pod
is
a
set
of
containers
that
operate
in
a
shared
context.
Those
containers
are
equal,
or
at
least
they
were
now.
We
have
init
containers
and
we
have
official
support
for
sidecars
coming.
So
all
sorts
of
good
things
coming
that
way,
but
docker
didn't
understand
what
a
pod
was,
and
so
we
needed
a
thing
that
would
sort
of
bring
up
a
bunch
of
context
for
a
pod
but
wouldn't
actually
predicate
on
any
single
thing,
and
so
we
created
this
container
image.
A
That
does
nothing
like
come
up
and
pause
and
it's
called
the
pause
container
and
it's
been
stuck
at
version
3.1
for
a
long
time,
and
apparently
we
just
upgraded
this
to
the
next
version
and
we're
scared,
because
this
is
going
to
be
and
so
I
don't
know
what
the
exact
changes
are
in
3.2.
That
motivates
this,
since
we
changed
the
build.
So
so
something
happened
and
we
have
a
new
version
here,
and
this
is
going
to
be
quite
the
effort
to
get
everybody
upgrade
to
the
latest
and
greatest
version.
A
I
think
we
should
understand
and
I
don't
understand
all
the
all
the
implications
of
what
it
means
to
keep
burning
the
old
version
on
accident.
So
that's
something
that
I
think
we
should
probably,
as
we
push
this
out,
understand
what's
going
on
there,
but
this
is
little
types
of
things
where
it's
like
you
know
it
should
be
easy,
let's
just
rev
it
now.
It's
never
quite
that
easy.
Never
quite
that
easy.
Let's
see
another
week,
another
pile
of
point
releases.
A
So
this
is
just
a
bunch
of
back
ports
to
the
versions
that
we're
supporting
17,
16
and
15,
and
then
you
can
actually
go
through
and
and
click
through
here
and
see
the
individual
things
that
got
cherry
picked.
You
know,
there's,
like
you
know,
relatively
minor
stuff,
is
what
it
looks
like,
so
nothing,
nothing
earth-shattering.
It
looks
like
and
let's
see,
and
then
we
have
oh.
This
is
really
interesting.
There's
a
cap
on
starting
to
create
a
so
Kappa
Cooper,
nee,
kubernetes
enhancement
proposal
to
start
creating
a.
A
I
think
that
that
makes
sense,
as
we've
moved
more
of
the
exciting
stuff
out
of
core,
and
so
this
is
a
great
effort
to
actually
pull
together
all
of
the
ins
and
outs
and
implications
of
actually
doing
an
LTS
version
and
how
that
works
so
definitely
check
this
out.
If
you're
interested,
ok
well,
it
says
that
the
paws
3.2
is
built
with
the
correct
architecture
metadata
okay.
So
this
means
that
you
can
pause.
A
Eventually,
we
can
pause
on
all
sorts
of
architectures,
not
just
x86
all
right,
so
that's
kubernetes
project
itself,
other
stuff
happening
around
sort
of
the
kubernetes
cloud
native
ecosystem
is
Juergen.
Did
this
did
a
look
at
captain
I
haven't
looked
at.
This
looks
really
interesting.
This
is
a
continuous
delivery
framework
for
kubernetes,
and
so
you
know
understandings
sort
of
like-
and
this
is
this-
is
one
of
those
things
where
these
things
all
blur.
A
This
was
like
a
great
blog
post
on
this
and
it's
all
event-driven
I'd
love
to
start
taking
a
look
at
one
of
these
things
and,
from
the
point
of
view
of
like
level
said
versus
edge,
triggered
right,
something
that
actually
borrows
a
bunch
of
kubernetes
ideas,
but
looks
at
it
through
the
lens
of
deployment
not
tied
to
a
single
cluster,
so
that
I
think
would
be
super
interesting.
This
is
great,
so
this
is
a
post
that
somebody
posted
to
kubernetes.
A
This
is
super
scary,
was
mucking
around
with
some
stuff
accidentally
deleted
everything
all
the
pods
on
a
production
cluster
and
two
and
a
half
minutes.
Let
later
everything
was
back
up
and
running,
which
is
really
really
crazy,
so
I
think
it
just
goes
to
show
that
you
know
the
self-healing
aspects
of
kubernetes.
A
You
know
it's
coming
into
play
earth
if
they
deleted
all
their
deployments.
They
might
have
had
a
worse
time
unless
they
were.
You
know
essentially
following
a
get
up
source
of
truth
model
and
they
actually
were
able
to
redeploy
from
a
known
good
state
or
if
they
were
using
something
like
Valero,
that
would
have
saved
their
bacon
very
cool.
Here's
somebody
writing
an
article
talking
about.
A
So
this
is
a
LJ
Miranda
here
talking
about
how,
when
they
were
learning
kubernetes
things
really
clicked
when
they
started
thinking
about
deployments
and
and
services
versus
focusing
on
things
like
pods
and
nodes,
and
for
me
this
is
really
fascinating,
because
I'm
I'm,
what
I
like
to
call
a
depth-first
engineer,
I,
want
to
understand
things,
super
SuperDuper,
deeply
and
then
sort
of
build
up
layer
by
layer.
There
that's
just
sort
of
my
way
of
learning
things,
but
there's
a
lot
of
other
folks
that
are
much
more
task.
A
A
So,
let's
see
Larry
from
Johannesburg
good
to
see
you
and
then
Steve
good
to
see
you
Steve
Steve
is
one
of
the
maintainer
Zonk
on
tour
and
there's
some
good
discussions
going
on
in
the
chat
there,
all
right
so
other
stuff,
Apache
flink,
which
I've
never
used,
has
native
kubernetes
support,
which
looks
really
cool
it's
in
beta.
If
link
is
a
sort
of
data
processing
framework
that
runs
on
all
sorts
of
different
clusters.
Jonathan
Simmons
has
an
article
of
this
is
on
the
Mineo
blog.
Why
you
can't
container
I
use
the
storage
appliance?
A
It's
really
I
think
you
know
talking
about
the
move
from
these
appliances.
That
sort
of
operate
on
the
network
is
like
a
box
to
things
that
are
more
API
driven,
more
scalable
and
that's
what
you
need
to
be
to
be
more
cloud
native,
so
some
interesting
sort
of
perspectives
coming
from
sort
of
the
storage
space
going
on
there,
and
then
this
is
really
cool
too.
Is
that
the
H,
a
proxy
folks
I
consent
to
cookies?
A
Let's
go
essentially
went
through
rolling
updates,
but
then
showed
how
you
can
do
a
Bluegreen
deployment
by
essentially
redirecting
ingress,
which
is
really
cool.
I,
don't
think
they
took
it
far
enough
to
start
thinking
about
like
well
how
you
know,
how
can
we
use
controllers
or
other
systems
to
actually
help
manipulate
that
ingress,
which
seems
pretty
cool,
and
so
there's
there's
a
set
of
systems,
things
like
flux
that
can
actually
help
with
some
of
that
so
pretty
cool
and
then
update
from
George
on
our
100th
episode,
which
was
I
guess
five
weeks
ago.
A
A
Alright,
let's
get
going
so
let
what
the
heck
is
dapper,
so
I
think
this
is
really
fascinating
because
we're
starting
to
see
a
class
of
projects
which
are
building
on
top
of
kubernetes,
which
are
much
more
curated
in
term
of
how
your
application
code
interacts
with
a
runtime
and
those
runtimes
are
being
delivered
as
a
set
of
sidecars
that
run
next
to
your
workload
and
I.
Think
dapper
is
a
great
example
of
this.
A
You
know,
do
I
have
a
compatible
library,
that's
in
an
actor
this
other
library
across
languages
and
stuff,
like
that,
all
that
runtime
stuff
runs
as
a
sidecar
for
you
and
so
another
similar
system
that
we're
not
going
to
go
deep
in
today
from
the
akka
folks,
and
so
akka
is
a
Java
framework
for
doing
a
bunch
of
streaming
stuff.
Is
this
thing
called
Cloud
State,
which
is
another
sort
of
entry?
A
A
Well,
you
mean
this
thing
here,
so
I
think
George
further
up
should
have
yeah
it's
a
TJ,
io
/
notes.
If
you
want
to
help
out
there.
So
if
you
go
there,
that'll
take
you
to
the
to
the
to
the
hack
MD.
If
you
want
to
actually
see
what's
happening
there,
all
right,
so
so
yeah
I'm
not
going
to
go
into
into
cloud
state,
but
it's
interesting
that
we're
starting
to
see
a
class
of
systems
like
this.
That
I
think
are
really
really
interesting
and
then
birth.
A
Upon
saying
what
is
the
Google
OSS
equivalent
to
dapper
I,
don't
think
that
it
exists.
I
think
Google's
been
putting
a
lot
of
effort
into
systems
like
key
native
in
sto.
Sto
provides
some
of
the
security
aspects
that
I
think
we're
seeing
with
with
dapper
and
I
want
to
dig
into
that
a
little
bit.
I've
just
got
a
hint
of
it.
Reading
the
docs
and
then
there's
K
native,
but
K
native,
is
more
of
a
serverless
tool.
It's
not
a
it's,
not
sort
of
an
opinionated
sort
of
architecture.
A
Thing
like
something
like
dapper
or
clouds
day,
I
think
one
of
the
interesting
things
and
I.
You
know
I
know
talking
to
the
cloud
native
to
the
K
native
folks.
There
is
some
talk
about
K
native
supporting
having
more
than
one
container
as
part
of
your
runtimes
and
K
native,
and
that
might
be
an
interesting
way
to
start
slipping
in
more
opinionated
sort
of
helper
runtimes
with
something
like
K
native.
So
that's
something
that
I
think
is
going
to
be
really
interesting.
A
I,
think
one
of
my
fears
when
we
look
at
these
systems
is
that
they
create
silos
and
there's
a
lack
of
interoperability
with
other
systems
running
on
top
of
kubernetes.
That
may
not
be
part
of
dapper
that
you
want
to
communicate
to.
So
that's
something
that
I'm
going
to
be
keeping
an
eye
out
for
as
I
actually
look
through
this
stuff
yeah.
A
So
let's
go
to
the
homepage
and
we'll
see
what
it
says:
an
event-driven,
portable
runtime
for
building
micro
services
on
clouded
edge,
I
mean
you
know,
that's
kind
of
generic,
so
I,
don't
even
know
what
that
means.
Building
blocks
open,
API,
No
Limits,
so
that
means
any
any
programming,
language
cloud
or
edge
and
it's
open
source.
So
that's
all
good
stuff
too.
A
A
The
runtimes
being
pinned
to
the
language.
Doing
event-driven
and
state
handling
are
difficult
at
scale
and
then
many
runtimes
only
target
specific
infrastructure
platforms.
When
limited
code,
portability
o'clock
cross
cloud
and
edge,
that's
what
I'm
a
little
less
sure
about
I
got
to
be
honest.
I,
don't
think
this
is
a.
This
is
something
that
we've
seen
Microsoft
do
in
a
couple
of
different
places.
We
see
this
with
with
gap
or
we
see
it
with
om
it's.
A
A
All
right
so
select
your
OS
starts
with
window,
so
that's
cute,
okay,
I
can
do
a
double
you
get
here
and
then
do
dapper
net,
but
I'm
not
going
to
do
that.
We're
gonna
actually
go
to
the
docs
here.
We're
gonna
go
to
github
we're
gonna
start
looking
at
this
there's
an
overview
here
that
I
think
goes
into
some
more
depth
about
what
exactly
that
we're
talking
about
here.
So
this
is
this
is
the
docs
that
I
want
here,
okay,
so
service
invocation.
So
how
do
you
do?
Services
service
calls
retries
remote.
A
So
this
is
a
lot
of
that
sort
of
the
some
stuff
that
shows
up
oftentimes
in
service
mesh
types
of
things.
How
do
you
create
resiliency
at
the
sort
of
service
to
service
layer?
State
management?
This
you
know
is
about
how
do
you
actually
manage
state
in
a
distributed
way
without
having
to
go
crazy
and
and
write
a
lot
of
bugs?
A
So
it's
like
understanding
a
set
of
patterns
and
how
states
interact
with
those
patterns
and
so
I'm
gonna
be
interested
in
looking
at
that
and
I
think
that's
the
type
of
thing
to
sort
of
compare
and
contrast
with
something
like
cloud
state,
because
that
really
is
cloud
states
focus
publish/subscribe
messaging
between
services,
so
interacting
with
queues
things
like
Kafka
oftentimes-
and
this
is
very
confusing
folks.
We'll
talk
about
this
as
being
reactive
programming,
where
you're
actually
talking
about
queues
and
your
message
passing
between
different
actors
and
they're.
A
Reacting
to
those
messages
that
reactive
programming
model
is
different
from
reactive,
the
UI
thing
from
Facebook
for
browsers.
It's
very
confusing.
It
confuses
me
also
event-driven
resource
bindings
resource
bindings
with
triggers
builds
further,
so
I'm
not
sure
what
this
means.
But,
oh
so
this
is
actually
being
able
to
send
and
receive
events
from
external
resources,
such
as
databases,
queues
file
systems,
etc,
distributed
using
the
w3c
trace
contact
standard
I,
wonder
how
that
applies
to
the
open.
Telemetry
stuff
and
then
actors
pattern
pattern.
A
First,
a
file
stays
alive
just
to
make
concurrency
simple
with
method
and
state
encapsulation.
So
this
is
part
of
that
sort
of
you
know,
message
passing
stuff,
and
so
the
idea
is
at
any
application
code.
Htv
GRP
see
there's
this
runtime
here.
So
your
application
code,
the
bulk
of
the
functionality,
comes
from
a
sidecar
not
from
your
application
code,
and
then
this
can
run
a
bunch
across
a
whole
bunch
of
different
infrastructure.
I
think
it's
cool
that
they
put
AWS
and
GCP
on
there,
I
guess
via
kubernetes.
A
You
can
get
support
there,
but
I'm
guessing
there's
no
sort
of
native
support
going
on
for
for
any
of
these.
Yet
so
yeah
I
mean
I'd
love
to
know
like
right
now
it
looks
like
there's
a
local
development
experience
and
then
there's
an
experience
on
top
of
kubernetes
I
wouldn't
be
surprised.
If
asher
has
some
plans
for
this
being
natively,
supportive
I
think
it's
going
to
be
interesting
to
see
over
time.
A
If
there's
some
push-pull
about
like
hey,
we
can't
add
feature
X,
because
if
we
add
feature
X,
it
won't
be
available
on
the
issuer
version.
That
sort
of
push
pull
is
definitely
something
that
we've
seen
in
the
K
native
world,
so
yeah.
So
all
of
that
stuff
that
goodness
comes
in
a
sidecar
and
then
your
application
runs,
and
that
runs
in
a
pod.
So
this
is
a
great
example
of
where
that
pod
concept
really
comes
into
play
for
doing
some
really
interesting
stuff.
A
And
then
here
we
can
say
run
it
on
local
or
I
can
run
it
on
kubernetes
suite.
And
so
let's
see
that
what
we're
gonna
see
is
that
there's
a
sidecar
injector,
which
probably
is
a
mutating
admission
controller
webhook
there's
the
operator
provides
services,
provide
first-class
integration
to
launch
tapper
as
a
sidecar
in
the
same
pot,
so
I
wonder
what
the
operator
does
it's
different
from
the
injector
and
then
there's
sentry,
which
is
a
certificate
Thor
store
for
doing
so.
A
A
This
is
a
place
where
the
way
that
TLS
certificates
are
handed
out,
the
way
that
Communications
is
actually
validated
will
probably
only
work
with
dapper
Dapper
and,
if
you're
talking
to
stuff
outside
of
dapper
your
you
really
miss
out
on
this
stuff,
and
so
this
is
exactly
why
we
created
spiffy
and
so
I
would
love
to
see
something
like
dapper
really
take
advantage
of
spiffy
so
that
we
don't
actually
create
sort
of
this
dapper
world
with
secure
communication.
And
then,
when
you
go
outside
of
it,
you
can't
do
it.
That's
you
know
really
looking
at.
A
How
do
we
actually
create
interoperability?
There
would
be
really
really
good.
I
mean
this
is
good
stuff.
Don't
get
me
okay,
so
it
looks
like
the
controllers
for
config
updates.
Okay
to
the
side,
cars
yeah
I
mean
this
is
good
stuff,
I,
think
doing
em
TLS
doing
a
hosted,
CA
doing
rotation.
That's
all
great
I
think
that
there's
a
you
know
huge
opportunity
to
create
this
identity
control
plane.
That
is
wider
than
one
single
runtime,
and
so
that's
something
that
I
think
I'd
love
to
understand.
A
There's
a
self-hosted
thing
where
you
can
have
the
century
talked
to
some
other
thing:
oh
no!
This
is
kubernetes,
so
it
stores
in
a
kubernetes
secret
yeah.
So
that's
something
that
I
think
I'd
like
to
look
at
and
I
think
that
that
I
think
you
know
hints
that's.
Maybe
one
of
the
downsides
of
these
systems,
where
these
things
are
sort
of
they're,
isolated
environments.
So
Chen
is
asking.
A
Does
this
mean
the
dapper
cannot
work
with
a
service
mesh
I,
don't
know,
that's
a
good
question:
what
happens
when
you're
running
dapper
on
top
of
something
like
sto?
Do
you
get
like
mm
TLS
right
where
you
have
dapper
doing
stuff
in
the
abyss?
Do
doing
it
because
it's
happening
at
different
levels?
What
happens
when
you're
running
both
side
cars
at
the
same
time?
A
Okay,
so
you'd
have
to
turn
the
MT
LS
off
in
that
case
and
then
you're
relying
on
that.
But
one
of
the
problems
with
sto
specifically,
is
that
it
does
Mt
LS,
but
the
identity
of
who
your
who's,
calling
you,
when
you're,
actually
getting
our
PC
call
that
identity
doesn't
get
passed
on
to
the
application,
and
so
that
means
that
you
get
less
application
context.
In
that
case
there
at
least
last
I
checked
it
didn't
get
passed
on
in
a
trusted
way.
So
that's
something
that's
interesting
too,
all
right.
A
So
that
is
the
overview
and
and
the
the
the
operator
propagates
configuration
updates
to
adapt
or
sidecars.
This
is
really
interesting.
I
think
that
there's
room-
and
this
is
one
of
the
things
that
exists
in
the
spring
community-
to
actually
think
about
configuration,
versioning
propagation
as
a
first-class
system
that
actually
gets
extracted
and
separated
from
a
bunch
of
these
other
things
both
for
applications
and
for
infrastructure
type
of
stuff.
A
I
know
that
Google,
when
I
was
there
had
some
really
interesting
systems
for
being
able
to
propagate
a
configuration
changes,
but
also
viewing
those
configuration
changes
as
similar
to
a
code
rollout
where
you
want
to
have
C
ICD,
you
want
to
do
Canaries,
you
want
to
look
for
signals,
or
sometimes
you
want
to
try
and
push
things
as
fast
as
possible.
Configure
configuration
versioning
rollout
system
would
be
really
really
cool
to
see.
Somebody
build
all
right
cool
that
isn't
sort
of
tied
to
one
of
these
things.
Okay,
so
let's
get
into
the
details
here.
A
A
A
B
A
A
B
A
Look
at
this:
what
are
we
doing
here?
Okay,
this
is
a
system
info
verify
supported,
checked
whether
we
got
the
check
HTTP
request.
Cli
get
latest
release
okay,
so
this
is
getting
the
latest
release.
One
of
the
things
is
that
the
damper
team
released
something
I
believe
about
three
or
four
hours
ago.
This
is
here,
I've
got
four
and
I.
Think
I
was
giving
advice
to
try
and
do
0.3.
So,
let's
see
if
we
can
actually
make
sure
that
we
install
0.3
just
so
that
we're
not
super
bleeding
edge
here.
A
A
A
Run
is
room
where
it's
the
installed
er
I,
don't
I
want
to
install
it
locally.
Okay,
so
we're
gonna
we're
not
going
to
use
the
install
script.
We're
gonna
hack
around
that
okay
I'm
on
says:
I
should
try
the
latest
release.
Okay,
okay,
we
recommend
0.4,
all
right,
I'll
do
0.4
all
right,
I,
don't
wanna
I,
don't
want
to
get
y'all.
You
know,
github,
calm,
dapper,
yeah,
I,
just
wish
I
mean
if
homebrew
or
so,
let's
see
so
we
have
dapper
dapper
tarrant
Lee.
Only
one
person
is
here:
everybody
else's
private
they're.
A
A
Repos
releases
getting
the
rightest
latest
release
and
then
what's
the
release.
Url
oh
I,
see
okay
releases
and
then
requests
CLI
which
which,
which
artifact
is
the
CLI
that
dapper
D
or
is
that
I'm
sorry
I'm
a
little
confused
here.
Give
me
a
second
all
funk.
Oh
there's
a
CLI
repo,
that's
different
from
dapper.
That
makes
sense.
Okay,
there's
dapper
our
CL
ID
CLI.
There
we
go
10
releases.
Oh,
not
only
do
I
want
4.0
I
want
4.1,
okay,
cool,
so
here's
the
assets-
and
here
we
can
get
a
copy
link,
address
curl.
A
A
Cli
version
runtime
version
sweet,
ok,
so
we
got
that
up
and
running
and
I
think
that
dead
shell
script,
that's
essentially
what
it
did.
Oh
look,
hey,
there's
the
thing
for
not
using
the
shell
script.
I
should
have
just
followed
those
instructions,
I'm
an
idiot,
sorry
about
it,
alright,
and
so
now
we're
gonna
do
a
dapper
in
it.
So
this
is
really
interesting
is
that
this
will
actually
install
it
into
your
cluster
I'm.
A
Very
unsure
about
these
things
because,
like
this
is
gonna,
do
a
lot
of
stuff
in
my
cluster
I,
don't
know
what
it's
gonna
do
I
like
to
do
sort
of
like
examine
the
yeah
mole
stuff.
Like
that,
you
know.
As
we
look
at
things
like
scene,
you
have
in
different
ways
to
install
stuff,
oh
dapper,
and
it
will
install
it
locally
on
the
machine.
Okay,
I!
A
A
That'll
actually
sit
in
the
middle
and
sort
of
like,
probably
because,
like
my
favorite
tool
for
this
is-
and
you
know,
I've
talked
about
this
before-
is
that
there's
cap,
and
so
a
cap
is
a
it's
this
way
it's
it
provides
you
a
way
to
install
stuff,
and
it
gives
you
a
UI
that
looks
like
you
know,
a
terraform
UI,
where
it's
like,
here's
all
the
stuff
I'm
about
to
do.
Here's
the
namespaces
I'm
going
to
be
impacting,
and
so
having
that
diff
and
having
the
ways
to
be
able
to
filter
it.
A
As
you
go
makes
me
feel
a
lot
more
confident
about
what
the
heck's
going
on
here.
But
let's
so
I
have
a
kind
cluster
with
with
one
node
dapper
knit
kubernetes,
let's
see
what's
going
on,
deploying
the
dapper
operator,
alright!
Well
that
wasn't
hard
alright
and
then
so
it's
installed
so
I
do
Cube
control
cube,
get
pods!
A
So
so,
if
I
launch
oktin
here,
let's
see
what
we
got
going
on
here,
so
we
got
so.
These
things
are
running
in
my
default
namespace,
which
is
really
interesting
and
so
with
the
operator
century
and
the
injector,
and
what
did
it
do
with
respect
to?
So,
let's
look
at
the
operator,
which
I
assume
was
the
first
thing
here.
This
thing.
A
Does
it
have
a
service
account?
Okay,
so
this
is
the
da
period
operator
service
account
so
okay,
so
it
created
this
thing
here
and
that's
the
service
account
and
so
okay.
This
is
a
you
need
to
send
this
to
the
octant
team.
It
would
be
cool
if
I
could
actually
from
the
service
account
be
able
to
back
propagate
which
roles
and
role
bindings
are
actually
being
used
there.
So,
okay,
so
I,
don't
see
any
roles
or
role
bindings.
A
Cluster
role
bindings,
okay,
there
we
go
okay,
so
this
is
something
that
I
think
is
a
little
bit
weird.
Is
that
it's
installing
it
into
the
default
namespace?
But
then
it's
giving
it
essentially
cluster
admin
and
secret
reader
yeah.
So
this
thing
I
mean
it's
running
as
root
on
your
cluster,
which
is
okay,
but
I.
A
Think
you
know,
I
also
think
it's
really
interesting
to
see
systems
like
this
to
be
able
to
run
in
sort
of
a
local
mode
where
hey
I'm
only
running
this
thing,
where
it's
operating
within
a
single,
namespace
and
I,
definitely
think
that
you
know
when
you're
installing
stuff.
You
know
like
this,
that
you
understand
that
this
is
something
that
actually
is
hitting
your
entire
cluster
and
it's
threading
itself
through.
So
that's
something
something
to
keep
in
mind
there.
A
Cool
all
right,
very
cool,
okay,
so
we
are
so
so
we
have
stuff
up
and
running
and
it
installed
the
let's
see
so
we
have
deployments
here.
We
have
the
placement
century
and
the
sidecar
injector.
What
is
placement
ooh,
I,
wonder
what
that
does?
Okay,
well
we'll
play
with
it,
we'll
actually
see
where
we
get
with
this
okay,
so
we're
up
and
running.
Oh
here's
using
helmets,
the
advanced
things.
So
you
can
add
the
helm,
repo.
You
can
go
and
do
a
helm,
install
and
and
and
Bob's
your
uncle.
A
Gotta
love
using
go
templates
with
with
oh
okay.
Let's
see
so
that's
okay!
So
we're
up
and
running
now,
which
is
great
and
then
and
then
there's
a
set
of
samples
that
we
can
go
through
and
we
have
a
sample
version
and
we
can
fix
the
links
because
I
think
that
the
getting
started
in
the
samples
that
I
was
pointing
to
here
were
the
0.31.
So
we
definitely
want
to
be
looking
at
the
0.41.
A
A
We're
nokton
in
the
background
git
clone
samples,
okay,
cool
all
right.
So
let's
look
at
hello
world.
Let's
see
so
this
thing
is
all
running
locally.
We
didn't
set
up
the
local
stuff,
so
we're
gonna
skip
this
and
we're
gonna
actually
go
to
hello.
Kubernetes,
one
versus
hello.
We're
gonna
jump
right
into
it,
yeah.
So
there
we
go
okay.
So
we
have
a
pod
that
has
the
operator
and
then
the
operator
is.
A
So
I
wonder,
is
it
really
an
operator,
because
is
it
the
one
that
actually
launches
the
pods
I?
Don't
know,
let's
actually
figure
it
out
figure
it
out,
so
we
got
it
set
up
there.
We
need
to
create
and
configure
a
state
store.
Okay,
so
let's
go
through
and
do
okay
do
I
do
I
have?
Is
this
helm
to
or
helm
three
and
I
don't
even
have
helm
installed
because
I
rebate
my
machine
a
little
while
ago,
let's
go
through
and
do.
A
A
There
we
go
see
deleted
formulas,
Python,
2,
there's
a
bunch
of
updates
holy
moly
I
got
to
get
my
act
together.
All
right.
Let's
see
how
ok
sweet
ok,
so
we
can
do
helm,
install
Redis
failed
to
download
right
us.
Oh
he'll,
reach,
Oh
update,
no
repositories
found
ok.
What
did
I
do
wrong
there?
Docks
roadmap.
A
A
A
A
You
forgot,
no
I
did
port
forward
it's
running.
Let's
see
we're
support
forward,
it's
running
up
here
and
it's
running
in
the
background,
so
we're
port
14,
that's
an
error
from
the
port
forward,
because
the
things
not
running,
let's
see
so
we
have
pods,
we
have
Redis,
we
have
the
Redis
master
zero.
These
things
are,
oh,
you
know
what
the
problem
is.
Is
it's
a
yet
Redis.
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
B
A
A
A
A
Sweet,
alright,
no
password,
alright!
Thank
you!
So
much!
Okay,
that's
awesome!
That
gets
us
up
and
running
here
and
we
all
learned
a
lot
and
sorry
I
didn't
sort
of
chase
that
one
to
ground,
but
I
think
you
know
at
this
point
where
I
don't
want
to
get
a
to
when
I
lost
my
place
on
the
on
the
samples,
but
well
we're
gonna
samples
for
hello,
kubernetes,
okay,
that
was
harder
than
it
should
have
been.
A
Had
the
keys
to
the
registry
mo
file
on
the
deployed
directory?
Okay,
so
let's
look
at
sample
CD
all
right.
We
have
a
deployed
directory
here,
so
a
samples,
hello,
kubernetes,
deploy
rightist
IMO.
Okay,
you're
right
as
host
here
is
gonna,
be
a
rightist
master
right
and
then
the
password
we're
gonna
set
that
to
a
string.
A
You
know,
I
cope
quote
these
things
cuz,
you
know,
yeah
mo
state
store,
okay,
okay,
so
this
is
a
dapper
Ciardi
called
component
and
it
is
called
it's
okay,
so
it's
called
state
store
its
type
state,
dot,
Redis,
okay!
So
there's
this
generic
config
here
for
with
dapper,
where
it
just
has
component
config
and
then
it's
just
key
value
pairs
with
a
type
on
it.
Okay,
it's
kind
of
like
a
config
map
by
another
name:
okay
and
I,
wonder
I,
wonder
how
it
differs
from
config
naps,
okay
and
then
we
apply
that
okay,
deploy
cube.
A
A
We
need
to
find
out
okay
and
then
there's
a
configuration
and
the
configuration.
Let's
see,
HP
pipeline
TLS
Wow
clock
skew
tracing
okay.
So
that's
a
configuration
for
everything:
okay,
cool
okay!
So
let's
go
back
to
our
tutorial
and
this
will
deploy
our
okay
so
and
then
we're
gonna
deploy
the
node
die
animal.
So,
let's
see
what's
going
on
here
when
we
do
that.
A
Well,
what
is
in
no
DML
at
this
point?
Okay,
so
this
is
a
kubernetes
service
called
node
app
that
is
just
going
to
node
and
it's
a
deployment.
The
deployment
has
some
annotations
around
dapper
and
then
it's
just
a
simple
container.
Okay,
so
this
is
serverless
in
the
it
doesn't
handle
sort
of
source
to
code.
That's
still
left
as
an
exercise
to
the
reader
to
have
their
own
thing.
It's
really
a
runtime
that
way.
So
this
wouldn't
isn't
really
what
you'd
call
server
list,
but
I
think
we
could
probably
definitely
like.
A
Let's
see
yeah,
we
can
definitely
go
through
and
you
know
this
might
work
with
the
server
list
type
of
framework,
but
it
just
seems
that
you
have
okay
and
then
we
only
have
one
replica
here
so
I
wonder
if
that
server
list,
but
not
dr.
luyt,
it
depends
on
your
definition
of
server
list
right,
node,
okay,
so
this
thing
will
actually
create
the
deployment
we're
not
doing
anything
fancy
there.
But
what
should
have
happened
here
and
let
we're
gonna
look
at
the
pod.
A
Is
then,
when
we
look
at
the
pod
for
know
tab,
it
actually
has
a
dapper
Dapper
d,
let's
see
and
so
and
stuff
that
we
have
passed
in
here
is
some
trust
anchors
for
sentry.
These
things
should
be
delivered
dynamically
I
wonder
if
that's
supported,
okay
and
then
a
bunch
of
args
saying
we
wanted.
We
do
want
to
enable
them
TLS
and
then,
let's
see
we're
getting
the
the
service
account
token
and
then
I
wonder:
does
this
actually
have.
A
Alright,
so
here's
the
command
a
Purdy
trust
anchors,
those
are
environment
variables.
Does
this
have
any
special
permissions
as
the
question
I,
don't
think
so.
I
think
you
should
be
able
to
do
all
sorts
of
fun
stuff
without
that,
ok
cool,
so
that's
up
and
running.
This
will
deploy
our
nodejs
app
to
kubernetes,
adapt
or
control
plane
will
automatically
inject
the
dapper
sidecar
into
our
pad.
If
you
look
at
node,
I
am
well.
You
see
how
a
dapper
is
enabled
for
that
deployment.
A
So
you
say:
hey
I
want
to
opt-in
and
then
and
then
this
assigns
a
unique
ID
for
the
dapper
application,
so
it
can
be
sent
messages
to
in
front
and
communicated
with
by
other
dapper
apps
I'm
wondering
sort
of
like
ok.
So,
ok,
ok,
you
all
see
the
container
which
we're
deploying
this
one
provision
is
an
external
IP.
We
wait
until
the
IP
is
visible.
Okay,
that
probably
won't
work.
A
A
A
A
A
Accesses
once
you
have
an
external
play,
you
can
save
it.
You
can
all
export
a
very
okay.
So
we
got
that
thing.
You
didn't
say
to
hit
it
with
this.
Next
look
at
our
Python
app
Python
app
with
kubernetes
sample.
Is
this
the
kubernetes
sample
the
quick
glance,
a
bass,
bass,
basic
Python,
app
to
post
Jason
messages
to
localhost
35,000,
which
is
the
default
listening
port
for
damper?
Okay?
So
you
explicitly
invoked
with
damper.
A
So
it's
not
like
a
service
mesh
where
it
tries
to,
like
you
know,
do
all
sorts
of
network
magic
to
inject
grab
stuff.
We
invoke
the
node.js
applications
new
order,
entry
point
by
invoking
posting
to
blah
okay,
so
this
is
v1
invoke
node
app.
This
is
the
name
of
the
app
that
we're
doing
and
then
method
new
order,
and
so
this
is
essentially
a
sort
of
RPC
bus
that
dapper
and
allows
for,
and
so
we're
going
to
go
through
and
we're
going
to
do
that.
Oh.
A
Before
this
one
has
an
ID
of
Python
and
DAPA
Rio
is
enabled,
but
it
doesn't
have
the
port
here,
which
means
that
gapper
also
does
some
stuff
with
that
port
I'm,
not
sure.
Okay,
now
we
can
actually
go
through
and
we
can
observe
messages
coming
in
cool,
ok,
successfully,
persisted
state.
So
now,
if
we
do
the
Redis
CLI
Eli
localhost,
okay,
so
what
is
the
OH.
A
A
A
How
do
I,
how
do
I
list
all
the
keys
in
Redis,
okay,
okay,
yeah?
Let's
do
that?
Let's
see
what
happens
yeah,
it's
star
nil,
so
we
don't
have
anything.
Okay,
Oh
keys,
I,
keep
Xing
Keys
star;
okay,
so
we
have
Oh
fascinating.
So
it
has
its
own
sort
of
key
space
schema,
so
I
can
do
get
node
app,
so
magic
is
okay
operation
to
get
okay.
So
what
is
the
type
tell
me
what
the
type
is
all
right?
A
But
okay,
so
it's
storing
stuff
into
Rattus
and
let's
see,
and
so
what
is
the
node
app
doing
so
we,
okay
yeah
curl.
We
can
also
curl
node
app
order.
Curl
localhost:8080
order,
okay,
we're
on
117.
At
this
point
sweet
we
can
clean
up.
Okay,
I
want
to
see
the
code
for
the
note
app
where's
the
code.
Well,
that's
the
Python
app!
So
let's
look
see
what
the
note
app
is
doing
so
I
some
work,
morphic
fetch
I,
have
no
idea.
This
is
the
the
world
that
we're
in
alright.
A
A
The
fact
that
it
did
the
note
app
pipe
pipe
order.
It
says
that,
like
you,
can
have
multiple
things
in
dapper
all
backed
by
the
same
reticence,
tense
and
it'll,
actually
provide
name
spacing
along
with
a
generic
API,
because
I
assume
you
could
actually
swap
out
from
Redis
to
other
types
of
key
value
stores
instead
of
Redis.
A
A
A
State
store
name
so
when
we
write
new
order,
we're
actually
putting
together
this
thing
here
we're
doing
a
post.
Oh
you
know
what
I
bet
you.
It
is
I
bet
you,
it
is
I
bet
you
that's
a
version
number
of
this
thing
hi
and
it
started
at
zero,
whereas
the
order
ID
probably
started
at
one
something
like
that.
Okay,
so
that's
interesting!
That's
interesting!.
A
So
I
yeah
I
bet
you
there's
some
sort
of
versioning
type
of
thing
going
on
there
for
doing
some
sort
of
conflict
rebel
road.
Okay,
so
now
we
can
do
a
distributed
calculator.
Let's
see
if
we
can
go
ahead
and
do
this
right,
so
we're
gonna
do
a
go:
MUX
application,
a
Python,
flask
application,
node
Express
and
a
dotnet
core
application
for
subtraction
and
then
and
then
there's
gonna
be
state
management
on
one
of
these
things.
Okay,
this
is
kind
of
crazy
sounds
like
fun.
A
Okay,
so
now
we're
we
want
the
Redis
I
don't
know.
Does
it
actually
I
was
assuming
that
I
would
have
me
like
recreate
the
Redis
here
yeah,
because
here
there's
there's
another
Renison,
so
I'll
just
go
ahead
and
redo
that,
because
I
just
want
to
make
sure
that
I'm
I'm
not
like
accidentally
infecting
one
thing
so
do
we
have
deploy
here,
read
STM,
okay!
A
If,
because
like
the
last
thing,
I
did
was
actually
the
state
store
can
I
actually
like
sort
of
like
put
the
states
who
are
in
their
late
I,
wonder
if
that's
something
that
it
actually
is
good
at
okay,
each
service
ending
and
a
progressive
render
your
service
is
right
beside
cards.
Well,
the
calculator
front-end
service
represents
the
external
load
balancer
for
these
things.
Okay,
but
we're
not
doing
the
external
load.
Balancer
thing
we're
gonna,
actually
sort
of
kill
this
port
forward,
and
we
instead,
we
want
this
thing
to
be:
what
is
a
calculator
front
and.
A
A
A
Boom
check
that
out
alright,
so
now
I
do
80
times:
30,
2400,
okay,
that's
magic!
How
hard
could
that
be?
Okay?
So,
let's
dig
into
what's
actually
going
on
here:
okay,
open
your
browser,
console
windows
and
see
the
logs
produce,
as
we
use
calculator
know
that
each
time
we
click
a
button,
we
see
logs
that
indicate
state
persistence,
okay,
so
well!
This
is
a
reactor
app.
We
are
f12,
so
I
don't
have
enough
12
on
this
keyboard,
because
this
keyboard
is
very
hipster,
so
developer
tools.
A
A
A
I
have
to
restart
the
pods
okay
see
now.
This
is
actually
an
interesting
thing.
I
think
there
is
this
aspect
of
sort
of
cloud
native
systems
where,
in
my
mind,
you
don't
want
this
stuff
to
be
order
dependent
right,
because
then
you
have
to
orchestrate
how
you
actually
roll
this
stuff
out.
Something
like
cube,
control
applied,
doesn't
know
the
dependencies
that
we
talked
about
here.
There
might
be
some
ways
to
actually
talk
about
and
express
those
dependencies
in
the
ammo,
but
that's
yet
another
thing
to
actually
hook
up.
A
A
All
right
there
we
go
unexpected
end
of
Jason
input
because,
okay,
there
we
go
plus
two
equals
alright
cool.
Here's
the
state
eight
times
six.
So
it's
interesting
that
we're
actually
seeing
the
states
come
back
here.
I
assume
that
is
this
actually
is
is
the
is
this
coming
from
all
the
way
from
the
client
and
is
the
client
saving
that
state
I,
wonder
how
that
works.
A
A
A
A
Okay
and
then
get
state
just
goes
ahead
and
gets
the
state
persists
forward.
State
persisted
a
poor
okay,
so
so
these
things
are
essentially
the
clients
driving
it
all
in
the
the
server
is
just
being
a
proxy
for
the
thing
we're
serving
client
build
and
listening
on
the
port,
okay,
cool,
and
so
what
we
do,
then,
is
that
whenever
we
do
like
a
multiply,
we
take
whatever
the
client
gives
us
and
we
multiply.
Ab
method
multiply.
A
So
this
is
essentially
a
a
method
dispatch
where
dapper
is
actually
doing
the
essentially
point-to-point
messaging
stuff:
okay,
cool,
okay:
the
this
sample
demonstrates
that
we
used
a
pert
is
a
programming
model
first,
implying
that
a
development
of
distributed
sits
in
the
sampled,
a
person,
abling
polyglot
service
discovery
and
simplified
state
management.
Each
service
in
the
sample
is
written
in
a
different
programming
language
service
invocation,
yeah,
okay.
So
this
is
what
we
were
looking
at.
Okay,
so
essentially
what
it
does
is.
It
creates
a
URL
space
for
essentially
doing
RPC
between
services.
A
We're
talking
to
localhost,
and
you
just
trust,
dapper,
to
be
able
to
sort
of
maintain
that
okay,
so
it's
both
point-to-point
communication
here,
it's
also
state
storage
and
routing,
okay,
yeah
and
then
transient
fault
hand,
handling
and
all
that
stuff
is
happening
under
the
covers.
So
this
is
a
lot
of
the
stuff
that
at
least
the
non
state
stuff.
The
point-to-point
stuff
was
a
lot
of
stuff
that
you'll
see
in
a
system
like
finagle
and
then
there's
also
pub
sub
and
event
bindings
for
similar
things,
which
is
really
kind
of
clever.
A
It's
I
mean
it
feels
a
lot
like
at
least
the
point-to-point
stuff
feels
a
lot
like
of
what
you
get
out
of
a
service
mesh
without
all
the
sort
of
working
shenanigans
that
go
on
under
the
covers
there.
It's
essentially
saying
the
application
itself
has
to
buy
into
doing
these
things
and
there's
no
reason
these
applications
can't
call
stuff
outside
of
the
dapper
world.
I.
Think
the
only
question
in
my
mind
is
you
know
when
we
look
at
the
set
of
services
that
we
have
here
and
we
have
something
like.
A
Like
big,
not
the
front
end
but
like,
let's
say
that
we
have
the:
why
is
this
not
moving?
Oh,
oh
I
think
it's
just
cutting
my
windows
too
small.
That's
kind
of
an
octet
bug.
Okay,
but
let's
say
the
divide
up
here,
so
the
divide
app
actually
has
a
dotted
a
per
service
for
talking
dapper
to
that
thing
and
HTTP,
and
this
thing
and
one
of
the
things
I'm
wondering
is
that
is
this
protocol
documented
to
the
point
where
folks
can
call
in
to
dapper
without
going
through
the
front
end?
A
Could
I
write
something
that
could
talk
dapper
directly
or
do
I?
You
know,
or
are
all
those
protocols
essentially
still
mutable
and
sort
of
like
specific
to
dapper,
right
and
so
I?
Think
one
of
the
things
that
I'm
thinking
about
is
like
is
there
a
way
that
we
can
think
about
dapper
being
not
just
a
runtime
but
also
a
protocol
for
how
I
can
actually
talk
to
workloads
in
a
more
sort
of
in
this
higher
level
way.
A
A
A
A
Oh,
oh
I,
don't
want
to
do
that.
That
would
have
been
a
mistake
because
it
turns
out
that
now
the
type
here
is
pub/sub
and
it's
a
message,
bus
and
we
had.
We
can
have
that
in
addition
to
the
state,
so
we're
actually
reusing
the
Redis
host
for
that.
If
I
had
copy
and
paste
I
would
have
actually
really
broken
stuff.
I
do
want
to
copy
and
paste
this,
though
so
I
don't
get
it
wrong.
A
Okay,
so
that's
actually,
okay,
so
that
here
we're
actually
seeing
how
this
component
is
a
more
sort
of
generic
thing
with
a
type
associated
with
it.
Yeah
a
name
is
different
and
the
type
is
different
there.
Okay,
we're
not
broken,
but
it
yeah.
Okay,
so
we're
not
broken,
but
it
would
have
a
it
would
have
worked
either
because
I
wouldn't
have
had
a
message.
Okay,
now
and
then
we're
gonna
make
them
we're
not
gonna
make
the
same
mistake
again:
we're
gonna
do
cute
control,
apply
Jeff,
Redis,
no
wait.
B
A
Run
locally
running
kubernetes
debri
is
applicable
message
bus
all
right.
This
has
like
it
right
a
slave,
zero
and
one
I.
Don't
really
need
that
I.
They
should
be
fine
with
my
like
HECO
Rama,
Redis,
okay
and
then
this
thing
says-
and
this
is
wrong-
because
that
won't
work
with
the
it'll
things
may
happen
out
of
order
because
we're
super
fast,
but
we
already
did
the
Redis
tune
by
Jeff,
so
we
should
be
ready
to
go
there.
So
we
have
blah
blah
blah
react,
form
we're
gonna,
look
at
that
service
again
and
we're
not
gonna.
A
Okay,
cool,
okay,
I
haven't
seen
what
happens
if
you
change
the
name
of
the
pub
sub
greta's
type
on
the
component?
Does
it
break
then?
My
guess
is
that
that
well
I
mean
this
is
a
question
it's
like.
If
you
have
multiple
state
stores,
how
do
you
choose
which
state
store
to
use?
Is
that
something
that
is
a
all
up
config
of
of
dapper?
Or
is
it
something
that's
on
an
application
by
application
basis
and
there's
an
idea
of
like
a
default
state
store?
Oh,
the
state
store.
A
Has
the
state
store
name
in
the
API
path?
Oh
so,
when
I
actually
hit
these
api's,
let's
actually
sort
of
look
at
that.
So
here
our
state
store
is
called
state
store,
gotcha,
okay
and
then,
when
I
look
at
say
the
node
or
here
the
only
thing
that
does
it
is
the
is
a
server
dot.
J
US
state
store
name
is
state
store?
Okay,
okay!
That's
that's
nice
I
like
that.
Okay,
so
now.
A
Okay
and
then
use
the
sample,
react
form
logs,
okay,
great
and
submit
different
message
types,
so
we
can
go
through
and
reload.
This
message:
type
a
B
and
C,
oh
they're,
setting
message
to
submit
okay
and
then
like
yeah.
It's
so
Evans
wondering
if
that's
true
for
message
bus
also.
My
guess
is
yes,
because
I
think,
if
we
look
at
the
server
here,
publishing
dapper
Earl
is
well
know,
publish.
A
A
Well,
that's
a
good
question.
The
the
app
scope
doesn't
have
a
neat
kubernetes
namespace
in
it,
and
so
that's
something
that's
interesting
too.
I
would
expect
yeah,
because
that
then
you're
gonna
have
the
problems
like
ingress,
where
it's
like,
hey.
If
I'm
running
in
a
multi-tenant
world
I
could
actually
go
through
and
and
really
node
subscriber,
so
I
don't
see
it
show
up
in
the
logs.
We
make
good
control
get
pods.
Let
me
make
sure
I'm
doing
the
right
thing.
A
A
A
A
A
A
But
okay,
so,
but
you
can
subscribe
and
the
fact
that
okay,
so
yeah
a
couple
of
feedback
based
on
what
Evan
said.
Is
that,
like
the
fact
that
I,
like
that,
the
state's
doors
are
segmented
I?
Don't
like
the
fact
that
the
that
you
don't
have
multiple
message?
Queues
and
I?
Don't
like
the
fact
that
the
the
application
names
are
global
across
all
these
things?
A
Okay
switch
to
another
yeah,
I'm
gonna
run
out
of
time.
So
doing
something
like
Nats
would
be
would
be
interesting
too
for
sure
yeah,
the
committee's
kasparek,
so
ancient
so,
but
yeah,
one
of
the
one
of
the
things
that
that
I
think-
and
this
is
this-
is
something
that
I
definitely
look
at
when
I
look
at
these
things.
A
There
are
definitely
places
where
this
works,
with
kubernetes
I,
like
the
fact
that,
like
Redis
tsk
I
mean
that
that
that
dapper
uses
kubernetes
services
to
talk
between
things
I
like
the
fact
that
it
we're
using
CR
DS
for
configuration,
I,
think
you
know
these
things
are
simple
enough.
We
could
probably
get
away
with
config
Maps
here.
These
things
really
aren't
operators
in
terms
of
like
managing
CRTs
with
with
spec
and
status
right.
It's
not
like
a
controller
pattern
like
that.
A
It
really
is
about
the
injection
and
providing
a
MeetMe
point
things
I
really
don't
like
is
that
this
totally
ignores
the
kubernetes
name,
space
model
right,
and
so
there
are
no
protections
for
hey
I'm.
You
know
running
something
in
one
namespace
and
I
want
and
something
in
another
namespace
dapper,
installs
globally,
and
then
all
of
a
sudden
you
have
this
space
and
like
and
I
haven't
I'm,
not
sure
and
I
haven't
seen.
Are
there?
Is
there
support
with
dapper
for
actually
having
any
sort
of
identity
and
Ackles
to
actually
say
well?
A
Only
this
namespace
can
actually
use
this
application
name,
and
this
thing's
allowed
to
actually
see
this
data
or
talk
to
this
data.
Or
you
know
this
state
store
is
only
available
in
this
type
of
thing,
so
that's
sort
of
like
yeah
well
globally,
with
respect
to
the
cluster
right
and
I,
think
you
know,
and
that
also
actually
actually
begs
the
point.
Also
so
you
say
you
don't
do
cross
namespace
communications.
A
Okay,
that
means
that,
in
terms
of
the
yeah
I
know,
we
could
test
I'm
gonna
run
I'm
running
out
of
time.
Evan
I
mean
cuz
like
in
my
mind,
it's
like
it's
like,
if
I'm
doing
micro
services,
there's
different
sort
of
schools
of
thought,
I.
Think
a
lot
of
folks
want
to
have
your
end
up
with
this
web
of
services,
some
things
in
some
namespace
some
things
in
another
and
actually
even
having
these
things
cross
cluster,
so
understanding
sort
of
what
is
the
tenancy
model?
How
does
it
relate
to
namespaces
and
multiple
clusters?
A
That's
super
interesting.
Clearly
that
has
knock-on
effects
with
respect
to
the
way
that
certificates
are
managed
and
you
secure
communications,
because
if
you
start
doing
cross
cluster
across
domain
type
of
thing,
you
have
to
start
worrying
about
providing
unique
names
and
stuff
like
that.
Okay,
so
you
can
create
a
state
store
for
apps
from
several
namespaces
or
you
can
deploy
them
in
the
same
pod
or
per
namespace
okay,
so
the
so
the
state
stores
are
global,
that
namespace
is
global,
but
yet
the
names
of
the
applications
as
per
kubernetes
namespace.
A
So
you
can
see
some
of
my
confusion
here,
so
understanding
the
tenancy
model
and
where
things
are
namespace,
if
specific
versus
not
would
be,
would
be
really
interesting
to
me
that
and
the
ability
to
actually
talk
about
okay.
What
is
this
as
a
system
and
then
what
are
the
individual
protocols
so
that,
like
I,
think
you
know,
can
people
actually
without
using
dapper
the
system
start
in
ur
fact
interfacing
with
dapper
workloads,
you
know
and
dapper
services
at
a
higher
level.
I
think
that
would
be
really
interesting
to
me.
A
Also
you
know
and
and
and
I
think
and
when
I
look
at
these
things.
That
starts
to
provide
ways
for
these
things,
not
to
just
be
sort
of
this
bubble
of
a
closed
system,
but
also
to
be
things
that
can
interface
with
other
systems
in
really
interesting
ways,
and
it
also
starts
to
provide
the
capability
for
say
you
have
a
monolith,
you're
breaking
it
down.
A
So
if
we've
gotten
that
to
work
bindings,
these
are
ways.
Okay,
so
this
is
really
interesting,
where
you're
both
talking
to
two
Kafka
I,
assume
that
starts
to
look
a
little
bit
like
dependency
injection,
maybe
or
no.
This
is
bindings
for
events.
Okay,
this
is
the
other
thing
that
I
think
is
interesting.
A
Foo
really
is,
is
implemented
by
foo
version
23,
and
we
have
food
version
24
over
here
and
then
you
can
actually
do
a
traffic
split
based
on
that
service
mapping
and
so
thinking
about
the
target
namespace
for
us
either
an
event
binding
or
whether
you're
talking
about
targeting
to
micro
services
being
something
that
comes
out
of
a
virtual
namespace.
That
is
different
from
what
the
app
identifies
itself
as
I
think
is
also
an
interesting
thing
and
something
that's
worth
looking
at.
That's
something
like
something
that
looking
at
something
like
finagle
for
some
ideas.
A
A
Love
that
it
uses
a
Google
account
is
an
example.
Considering
that
you
know
y'all
work
for
Microsoft,
that's
hilarious,
so
we
have
an
app
container.
So
what
is
this
doing?
So?
This
is
actually
IP
of
your
ingress,
so
we're
doing
ingress
here.
I
don't
have
time
to
actually
go
through
this,
but
we
have
an
oauth2
middleware
now
does
this?
Is
this
middleware
actually
implemented
by
a
by
dapper.
A
A
So
you
can
change
components.
Some
of
them
are
middleware.
Okay.
So
now
are
these
things
actually
separate
pods
or
are
these
things
components
that
are
all
built
into
DAP
or
D?
I?
Guess
that's
the
question
and
I
guess
what
I
can
do
is
I
can
look
at
the
deployment
here,
o
auth.
This
is
middleware
okay.
So
this
is
a
component
gotcha
and
this
is
a
set
of
capabilities
that
are
built
into
DAP
or
D
and
you
activate
them
gotcha.
Okay.
This
is
different
from
something
like
thinking
about
this
as
being
an
extensibility
mechanism.
A
A
Yeah,
okay
something's
worth
looking
at
okay,
so
the
middleware
stuff
is
super
interesting,
also
in
terms
of
being
able
to
actually
sit
in
here.
Okay,
it
is
jeopardy.
Okay,
so
you'd
have
to
build
your
own
version
of
dapper
D
with
the
middleware
that
you
want
to
be
able
to
actually
make
this
stuff
work.
Okay,
cool
all
right.
So
that
is
super
interesting.
What
are
I
guess?
My
last
question
here
is:
when
we
start
looking,
so
we
did
pub/sub.
We
did.
We
looked
at
event
binding,
so
we
looked
at
some
of
the
middle.
A
A
A
Okay,
dapper
has
cloud
state
integration
released
yesterday.
So
that's
really
interesting,
okay,
because
I
think
so
it's
a
little
bit
of
a
different
sort
of
take
on
it,
because
cloud
state
is
really
about
in
my
for
my
understanding,
I
haven't
played
with
it
is
really
about
more
advanced
patterns
for
actually
dealing
with
distributed.
Data
patterns
where
it
looks
like
dapper
is
really
about
providing
a
more
instrument
and
runtime
for
communication.
A
That
is,
that
the
sort
of
application
involved
level
versus
being
involved
at
the
sort
of
networking
level
with
with
service
messages
which
is
actually
really
cool.
Okay,
you
can
save
cloud
states
er
DTS
using
dapper,
so
you
have
an
in-memory
replicated
database
with
the
aberrant,
Cloud
State,
very
cool,
yeah,
okay,
very
cool
stuff,
okay,
I've
gone
over,
so
it's
just
like
an
hour
and
forty
minutes.
A
Thank
you,
you're
on
so
much
for
joining
in
answering
my
stupid
questions.
Thank
you
for
everybody
else.
For
sticking
with
me.
Through
this,
you
know
a
little
bit
of
a
little
bit
of
a
dust-up
there
with
getting
ready,
sup
and
running
I
apologize
for
that,
but
I
think
we
all
learned
something
like
don't
run
four-year-old
Redis,
and
so
with
that
I'm
going
to
wrap
it
up.