►
Description
Kubernetes Data Protection WG - Bi-Weekly Meeting - 31 May 2023
Meeting Notes/Agenda: -
Find out more about the Data Protection WG here: https://github.com/kubernetes/community/tree/master/wg-data-protection
Moderator: Xing Yang (VMware)
A
A
A
Let
me
make
you
the
co-host.
B
Sure
should
we
directly
jump
into
the
demo
or
Call
of
Duty
like
to
summarize
the
things
we
discussed
in.
C
Yeah
again,
we
kind
of
went
over
this
I
think
last
time.
If
we
go
straight
to
fit
page
slide
three,
so
the
feedback
we
got
from
the
last
time
we
ran
something
was,
you
know,
try
to
use
a
validating
web
hook
instead
of
a
mutating
web
hook.
That
was
from
Ben
and
turns
out.
We
can
so
you
know
we
made
that
change
and,
of
course,
the
previous
thing
which
the
previous
feedback
we
had
not
addressed,
which
was
getting
the
Prototype
ready
end
to
end.
So
we've
got
that
ready
over
here.
C
So
in
so
this
presentation
right,
we
are
going
to
go
through
the
going
to
go
through
the
prototype
and
I
think
the
details
of
the
Prototype
of
what
what
we're
trying
to
demonstrate
the
Prototype,
I
think
and
slide
26
or
something
we
will
jump
back
and
forth
to
these
figures.
You
know
in
context
as
we
go
through
things
I
think
mostly
everyone
has
seen,
have
seen
these
figures
and
the
slide
link
is
in
the
agenda.
C
So
you
can
see
all
this
stuff,
but
in
the
Prototype,
what
we're
going
to
try
to
do
is
we're
trying
to
we're
going
to
demonstrate
the
practicality
of
this
design
with
the
you
know,
with
the
emphasis
on
these
points,
security
right,
because
the
most
important
thing
is
to
make
sure
this
thing
is
secure
and
support
for
multiple
CSI
drivers.
That's
one
of
the
one
of
the
feedback
items
we
had
got
earlier.
C
We
will
demonstrate
the
direct
use
of
grpc
by
the
backup
client,
which
bypasses
the
API
kubernetes
API
Service
server,
and
you
know,
because
of
that
and
because
of
the
two
different
domains
kubernetes
domain
and
the
SP
domain,
we'll
demonstrate
the
bridging
and
the
proxy
of
this
external
side
car
and
clearly
identify
what
part
is
to
be
provided
by
the
storage
provider
and
what
part
will
be
from
the
community
contribution.
C
I
think
that's
about
it.
At
the
end
you
know,
Prasad
has
put
together
everything
in
a
single
repo.
I,
don't
know
I,
don't
think
a
link
is
over
there
in
the
figure,
but
we
can
add
the
link
anywhere
oh
yeah,
yeah,
but
yeah.
So
so
I
think
we
just
go
ahead
and
start
with
that.
Prasad
and.
B
I'll
also
post
the
link
so
yeah.
If
you
want
to
have
a
look
at
the
deployment,
camels
or
source
code,
you
will
find
everything
in
the
in
the
single
airport,
yeah.
C
So
just
a
brief
thing
on
the
on
the
on
prasad's
repo
he's
put
everything
into
one
Super
Repo,
but
it
actually
contains
sub
projects
within
it.
He's
based
this
stuff
on
the
on
the
host
path,
CSI
driver
because
I
think
a
lot
of
testing
is
done
and
that
development
was
previously
done
in
that.
But
it's
not
that
we're
actually
using
that
CSA
drivers
just
giving
us
the
framework
to
demonstrate
stuff
go
ahead.
B
Cool
text
card
for
summarizing
I
believe
everyone
is
aware
of
this
diagram.
You
have
been
discussing
these
I,
don't
know
since
humans,
so
yeah
we
will
I'll.
Try
to
in
this
demo.
I'll
will
be
jumping
on
this
diagram
to
explain
the
workflow,
so
yeah
I
I'll.
If
you
want
to
have
a
look,
you
can
take
a
look
at
the
source
code
and
deployment
channels.
Everything
is
in
this
report.
Let
me
share
another
screen
that
you
can
view
my
terminal.
B
B
Cool
so
I'll
first
talk
about
the
deployment,
so
we
have
maybe
how
we'll
be
talking
about
these
three
namespaces.
First
20
CSS
snapshot
session
manager,
which
has
the
controller
deployed.
B
It's
just
a
snapshot
session
manager,
controller
deployed
which
manages
the
CRS
in
which
life
cycle
it
also
have
has
the
book
Handler
due
to
perform
all
the
validations
another
name
space
is
CSI
driver
where
we
have
deployed
this
data
travel,
as
well
as
the
external
structure,
Station
Service,
which
acts
as
a
you
know
proxy
to
and
which
also
has
a
sidecar
that
service
sidecar,
which
has
the
service
provider
implementation
of
the
CBT
RPC.
B
Basically-
and
there
is
a
CBT
client
where
we'll
be
just
having
a
sample,
client
called
Running,
which
will
be,
you
know,
trying
to
call
this
apis
to
get
the
actual
change
block,
metadata
cool
and
now
we
have
say
the
default
instance
for
this
demo.
So
we
have
a
PVC
created
in
the
default
instance,
and
there
are
a
couple
of
snapshots.
Kg
stands
for
Capital
git.
If
your.
If
you
are
confused
with
someone.
B
Okay-
and
there
are
a
couple
of
snapshots
which
are
taken
on
on
this
on
this
CSI
PVC
right,
so
you
will
be
using
these
two
snapshots
in
the
apis
to
to
we'll
be
comparing
these
two
snapshots,
basically
to
get
the
change
block
metadata
between
two
okay.
B
Service,
which
is
the
which
is
a
container
running
inside
the
external
snapshot
station
service,
so
external
snapshot
session
service
has
two
containers.
One
is
the
the
station
service
which
acts
as
a
proxy
just
describe
this
part
so
that
that
will
be
cleared.
B
So
we
want
to
look
into
the
Cs
that
are
called
okay,
so
see.
I
set
our
Port,
as
I
already
said,
has
a
CSL
driver
deployed.
We
are
using
host
path,
CSI
driver
for
this
demo.
It
also
has
a
container.
It
also
has
a
deployment
of
the
snapshot.
Station
Service,
which
has
two
containers,
as
you
can
see
so
there
is.
B
There-
is
a
external
snapshot.
Station
Service,
which
acts
as
a
proxy
distributions
for
the
which
is
which,
which
isn't
for
the
request
from
client
and
forwards
it
to
the
the
service
provided,
implementation
of
and
the
CBT
service
right
and
this
service
call.
This
service
communicates
with
the
site
car
over
the
Unix
web,
socket
that
we
have
already
discussed
in
in
the
the
overall.
B
The
workflow
I
think
we
already
discussed
in
in
the
flowchart
on
the
PPT,
so
I'll
yeah
I'll,
just
print
I'll
print,
the
log
Southeast
service,
so
that
once
we
once
the
client
request
for
the
change
document,
editor
we'll
see.
What's
what's
happening,
you
know
under
all
the
services.
B
Okay,
I
wanted
to
show
this
in
parallel,
but
I
guess
due
to
the
screen
size.
I
cannot
do
that.
Now
we,
we
also
have
a
sample
client
running
in
CBT
CBT
client
namespace.
So
this
pod
has
all
the
this.
This
part
as
a
service
account,
which
has
all
the
required
permissions.
The
permissions
to
create
the
snapshot
session,
access.
B
Snap
search
station
access,
CR
and
as
well
as
to
you,
know,
to
get
the
to
get
the
value
snapshot
as
well
as
PVCs,
so
that
it
can
this
down
this
down
those
okay,
so
I'll
first
run
the
and
I'll
first
run
the
sample,
GRTC
client,
so
that
will
get.
We
will
see
how
how
this
client
gets
the
actual
change
of
metadata.
Then
we'll
jump
into
the
code
to
see
what
steps
the
client
has
to
perform
to
get
the
actual
channel
right.
C
Let's
start
if
I
can
insert
a
word
so
just
to
clarify
there
are
a
number
of
namespaces
involved
here.
You
know
most
of
the
time
vendors
actually
deploy
all
the
CSI
drivers,
everything
in
a
single
namespace
Cube
system,
but
that's
their
choice.
We
have
chosen
to
have
each
and
each
actor
in
its
own
namespace
to
demonstrate
part
of
the
security
model,
okay
and,
in
this
particular
case,
the
actor
which
is
showing
up
here.
Cbt
client.
This
represents
the
backup
software
which
runs
in
its
own
namespace.
Also,
so
just
keep
that
in
mind.
B
Yeah,
so
this
is
a
sample
client
Port
running
in
the
CBT
client,
namespace
and
I
have
copied
a
binary
called
grpc
plan
which,
which
has
which
in
which
we
have
implemented
the
workflow
or
of
creating
snapshots
in
xscr,
get
the
status,
get
the
selection
parameters
from
the
CR
and
then
use
those
parameters
to
call
the
actual
JRP
standpoint
to
get
the
actual
change
block
header
data
we'll
jump
into
the
code
in
in
a
bit,
but
first
I
just
we
can
just
run
this
command.
B
So
this
binary
text
based
snapshot
and
Target
snapshot
as
a
parameters.
These
are
the
followed
snapshot.
Names
in
in
the
snapshots
are
created
in
the
department
space,
but
the
client
is
running
in
the
CBT
client
distance,
so
yeah.
So
once
we
run
these
cool,
what
just
happened
is
the
first.
It
created
the
snapshot
session,
access
CR
and
it
in
the
default
namespace.
Obviously
iterated
it
towards
it
to
be
ready
once
it's
ready.
B
It
gets
all
the
station
parameters,
including
the
sales
certificate,
the
token,
as
well
as
the
station
URL,
to
to
get
the
change
box
from
in
The
Next
Step
once
it
creates
all
the
same
parameter.
It
calls
the
Jr.
It
makes
the
jrtc
call
on
the
endpoint
to
get
the
actual
General
operator,
and
this
is
the
sample.
B
B
You
know
showed
at
the
beginning
of
this
demo,
the
the
information
like
for,
for
which
driver
we
have
this
certificates
and
searching
URL
configured
that
we
that
we
store
in
the
resource
name
CSI.
If
you
have
short
station
data
data
resource
so
in
in
the
CSI
driver,
name,
space
yeah,
if
you
could
get
this
resource.
Oh
sorry,
it's
not
data
service,
yeah!
B
Sorry
for
the
confusion,
so
this
resource
holds
the
the
information
of
information
like
the
address
and
certificate
or
or
that
that
the
controller
reads
for
specific
driver.
So,
in
in
case
of
you
have
multiple
drivers
and-
and
there
will
be
obviously
different,
endpoints
service
endpoints,
where
the
service
will
be
running
and
to
get
the
information
of
of
a
sales
certificate
as
well
as
address
for
specific
driver.
B
We
have
to
register
register
this
information
using
the
CSS
natural
Station
Service
resource,
so
I,
just
as
you
can
see,
the
level
here
is
or
liability
resource
parts
and
here
from
here.
Actually
the
snapshot
station,
Access,
Controller
or
snapshot
session
manager,
controller
reach
the
information
and
send
populates
the
status
and
sends
it
back
back
to
the
client.
B
B
These
are
the
logs
from
the
station
manager
service
running
in
the
CSS
snapshot
session
manager,
namespace,
which,
which
has
a
controller
running
to
manage
the
snapshot
session
access
here,
as
well
as
it
has
the
web
hook,
Handler
for
the
same
Okay.
So
if
I
can
okay,
so,
as
you
can
see
through
the
logs,
when
you
create
the
when
a
client
runs
when
we
run
the
client,
it.
B
Yeah,
so
you
can
see
the
waybook
Handler
got
the
request
for
creation
of
this
resource,
it's
a
snapshot
session
access
resource
and
we
are
also
logging
up
logging,
the
user
info,
the
user.
As
you
can
see,
the
user
information
the
user
has
provided
the
service
account
in
CBT
client
namespace.
B
The
service
account
name
is
the
snapshot
session
client
CSS
station
plant
and
the
the
web
Handler
uses
these
user
information
to
to
perform
the
validation
checks,
whether
if
whether
the
you
know
the
user
is
a
user
is
allowed
to
access
the
wireless
capture
resource.
We
also
check
if
the
user
is
allowed
to
access
the
persistent
volume
plane.
B
The
service,
the
service
account
associative
associated
with
the
CBT
client
is
all
the
permissions
we
have
already
added
using
cluster
role
and
cluster
and
binding
we'll
discuss
about
all
the
other
configuration
in
the
end
once
the
all
the
validations
are
passed.
The
next
thing
it
does
is
so
first
thing
it
initializes
the
status
sets
it
to
trending
State,
then,
as
a
part
of
handling.
This
event,
right
first,
is
search,
is
searches
for
the
CSS
snapshot.
B
Station
Service
object
for
the
worst
Parts
is
a
theater
sciot
driver
because
the
snapshots
are
created
using
this
driver,
so
the
controller
will
will
search
for
all
the
namespaces
and
figure
out
which
snapshot
session
service
object
holds
the
information
for
for
this
specific
driver,
so
once
it
counts
the
once
it
finds
the
the
specific
CSS
website
session
service
object.
It
figures
out
the
Cs
certificate
information
xcl
certificate,
as
well
as
address
from
that
CR.
B
The
next
thing
it
does
is:
it
creates
another
resource
called
CSS
snapshot
session
data.
Now
this
results
okay
before
before
creating
this,
so
it
generates
the
token.
Then
it
creates
this
resource
and
the
resource
populates.
B
B
B
Sorry,
we
reset
the
resource
status
to
ready
and
yeah.
So
that's
done
the
job
of
this.
The
CR
controller
or
I
would
say
the
standardization
manager
is
done
here
so
yeah.
To
summarize
it
it
searches
for.
B
Then
it
creates
a
generous
token
populates,
the
station
populates,
the
Snapchat
station
data
CR,
along
with
the
snapshot
entries
and
then
and
and
yeah
to
do
specify
the
token.
What
token
is
it's
generated
for
and
yeah
it
sets
the
session
parameter
into
the
status
and
returns
there.
The
next
thing,
client
does
is
using
the
session
parameters
it.
It
calls
the
oops.
B
Yeah
so
once
it
goes
to
the
system
parameters,
it
called
the
grp
standpoint
on
the
address.
So,
if
you
look
at
you
know
the
logs
from
external
session
service
right
okay,
so
it
got
the
request,
along
with
the
session
token,
as
well
as
the
other
parameters
are
based
snapshot
and
Target
snapshot.
B
Now,
one
thing
to
notice
here
the
the
parameters,
the
arguments,
the
sorry,
the
request
parameters
here
are
names
of
in
the
base
base
Webster,
we
have
mentioned
the
name
of
volume,
snapshot
right.
B
So
next
thing
the
snapshot
session
service
does.
Is
it
validates
the
token
against
the
parameters,
so
it
takes
if
the
to
open
we
have
passed
is
valid
for
the
arguments,
the
snapshot,
arguments
or
basic
abstract,
as
well
as
targets
captured,
and
it
does
it
by
fetching
out
again
the
CSS
snap
session
data
resource
which
holds
the
you
know
entries
for
snapshot
or
which
the
token
was
generated.
D
B
Searches
for
the
resource.
For
this
specific
token,
it
got
in
the
request
parameters
once
it
found
once
it
finds
the
the
required
snapshot
station
data
resource
next
thing.
It
does
it
validates
and
translate
the
volume
snapshot
names
to
ID,
so
it
obviously
it
takes
if
the
resource
the
volume
snapshot
data
resource
has
the
entries
for
the
snapshot
it
got
in
the
it
occurred
in
the
first
request.
B
The
next
thing
it
does
is
it
finds
out
the
snapshot
IDs
or
we
can
say,
snapshot
handle
for
the
Polish
app
short
names
passed
in
the
in
the
request
parameters
and
these
entries
it
figures
out
from
the
CSS
snapshot
session,
get
output.
You
can
quickly
check
the
content
of
it
as
a
so
to
just
make
things
clear.
B
Since
our
driver
name
stress,
if
you
look
at
the
specs
of
it,
the
token
will
be
the
name
of
this
resource
will
be
the
whatever
token
we
have
generated,
and
it
also
holds
the
information
like
snapshot,
names
for
which
we
have
generated
this
token,
as
well
as
IDs
of
you
know,
snapshot
as
well
as
volume,
okay,
so
using
the
same
resource
dates
and
snapshot
system
service
of
validates
in
the
token
yeah.
B
The
next
thing
it
does
is
it
calls
the
service
provider
GRTC
endpoint
over
the
local
Unix
socket,
but
when
it
does
that
yeah,
so
there's
a
third
terminal
here,
I
know
it
could
be
confusing,
seeing
multiple
multiple
terminals
on
the
same
screen
but
yeah
you
can.
You
know
differentiate
by
looking
at
this
name
which
which
service
these
logs
are
for.
So
these
are
the
logs
for
the
SP
implementation
of
the
CBT
service.
I
would
say
so.
B
This
external
snapshot
station
service
calls
the
service
providers
JRP
standpoint
to
get
the
actual
change
block
metadata.
This
call
happens
over
the
Unix
websocket
local
local
Unix
sets
of
it
cool.
So
if
you
look
at
the
request
diameter
here,
the
snapshot
IDs
based
snapshot
and
Target
snapshot
here
it
got
ID,
not
the
volume,
substant
names
right,
so
This
Server
basically
calculates
the
changeometer
data
extreme.
B
The
response
to
the
external
snapshot-
Station
Service
external
snapshot,
Professional
Service,
receives
the
data
from
the
CSL
driver,
it
stream
it
to
the
back
to
the
client.
So
this
is
acting
as
a
proxy
between
the
client
and
the
actual
service
provide
St
implementation
of
CBT
service.
One
thing
again,
I
missed
to
say
when
client
calls
the
end
point.
B
It
also
provides
okay.
We
can
directly
jump
into
the
client
call
or
sorry
client
code
to
see.
You
know
how
the
grpc
call
is
made.
This
happens
over
secured
this.
The
call
from
client
to
snapshot
session
service.
B
It
is
a
secured
One
secured
by
the
certificate,
but
the
call
from
external
snapshot:
Station
Service
to
the
service
providers,
CBT
implementation
that
happens
over
the
Unix
okay.
So
you
know
at
the
inter
diagram
you
can
you
you
can
you
can
see
the
you
know,
different
security
domains
that
we
are
using
here
and
any
questions
so
far.
B
I
can
quickly
browse
through
the
client
code.
You
know
so
that
you
can
understand
how
the
client
workflow
look
like
to
get
the
actual
to
get
the
CBT
data
for
specific
snapshots
all
right.
The
sample
client
codes
you
can
see
in
the.
B
Snapshot
session
service
itself,
these
are
in
the
command.
I
have
added
simple
sample,
client
code.
So
if
you
look
at
the
client
code,
all
right,
we
were
taking
the
base
and
Target
snapshot
and
this
case
as
the
argument.
So
first
thing
it
does.
Is
it
setups
the
session
in
setting
setting
up
the
station
first
thing
it
does?
B
It
creates
the
it
creates
the
snapshot
session
access
CR
to
to
generate
decision,
and
if
you
look
at
the
let's
look
at
the
spec
of
the
resource,
so
in
this
space
we
passed
the
this
job
snapshots
so
right
now
it's
just
two
based
on
target
snapshot.
We
can,
we
can
pass
so
since
it
is
released.
We
can
pass
any
number
of
snapshots
here.
B
So
once
the
session
was
this
session
at
snapshot
session,
access
CR
is
generated.
The
next
thing
we
do
is
we
wait
for
it
to
be
ready.
So
once
the
status
session
state
is
ready,
we
go
to
the
next
step.
That
means
the
station
session
is
created.
Now
we
use
that
session
to
get
the
actual
change
block
metadata.
B
Okay.
So,
in
the
next
step,
what
we
do
is
we
we,
we
initialize
the
grpc
client
we
use
CS3,
so
the
certificate
we
got
it
from
the
station
parameter
in
the
status
of
this
CR
status
of
the
session
xscr
as
well
as
we
also
get
the
session
URL
right
and
the
station
token.
So
all
these
station
parameters,
we
use
the
to
call
the
grpc
to
make
the
grpc
call
on
the
session
URL.
So
this
request
this
grpc
call
we
are.
B
Yeah,
so
we
wait
for
the
next
thing.
Once
you
make
the
GRTC
call,
we
wait
for
all
the
streaming
data
to
yeah.
We
will
get
this
team,
the
the
retail
end
of
the
redirected
uis,
and
we
are
just
printing,
the
whatever
data
we
have
got
yeah
any
questions
so
far.
C
E
I
had
a
quick
question:
Prasad,
could
you
identify
in
this
workflow
I?
Think
you
you
have
it
on
your
slide,
but
might
be
helpful
just
to
talk
about
it
from
a
quote
perspective
as
well.
Could
you
identify
what
are
the
pieces
that
would
need
to
be
implemented
by
the
backup
provider
and
what
are
the
pieces
that
would
need
to
be
implemented
by
the
storage
provider.
B
Yeah
yeah
yeah
I'll
come
to
that
once
I
explained
on
briefly
about
the
the
you
know,
the
other
services
implementation.
C
He
did
just
show
you
what
the
backup
client
would
do
that
code
is
applying
code.
So
now
he
can
show
us
the
he'll,
get
to
I,
guess
the
proxy
and
then
the
SP
got
it
got
it.
Okay,.
B
So
retro
we
just
saw
how
the
client
would
use
this.
The
next
thing
I'll
quickly,
you
know,
go
through
the
other
services
to
to
show
you
what
what
is
happening
behind
the
scenes
right.
So
once
you
create
this
CR
and
the
snapshot
access
snapshots
to.
B
Oh
okay,
okay,
yeah,
cool
I
think
I
have
already
explained
this
tapes
as
well,
so
we
we
discovered
the
service.
We
discovered
the
required
information
from
the
snapshot
session
service
object
for
the
driver,
so
we
create
the
snapshot
system,
data
with
the
information
and
we
set
the
status
and
we
written
here
nothing.
You
know
rock
itself
all
right,
so
we'll
jump
to
the
next
service,
which
is.
B
Okay,
the
next
component
is
the
external
snapshot
session
Service,
which
is
running
as
a
site
called
to
those
service
provided
implementation
of
CBT
CBT
service,
so
yeah,
this
acts
as
a
proxy,
as
we
already
discussed.
B
If
you
go
through
the
source
code-
and
these
are
the
Proto
Proto
files,
basically
for
the
snapshot
metadata
service,
it
has
the
git
built
RPC,
which
takes
the
best
app
short
Target
snapshot,
volume,
IDs
session
token
and
other
parameters,
and
it
Returns
the
Delta
response,
which,
which
has
the
block
meta
metadata
yeah.
B
B
Quickly
going
to
the
code
here,
yeah
first
thing
is
it:
it
does
it
loads
the
certificate
we
have
to
when
we
deploy
this
side
card,
we
generate
self-cent
certificate,
we
use
clients
so
review
server,
certificate
and
key
to
to
run
this
service
and
the
respective
CS
certificate.
We
we
add
certificate
in
the
states,
CSS
snapshot
session
date,
CSS
snapshot,
Station
Service
object,
along
with
the
address
of
address
of
the
service,
which
is
pointing
to
the
pointing
to
this
service.
B
Basically,
okay,
so
we
will
load
this
certificate
and
key.
We
will
start
the
server
which,
which
will
be
related
to
the
captured
metadata
server,
which
implements
the.
B
Gate
Delta
get
data
RPC
right
so
in
in
the
Handler
of
this
service.
B
First
thing
we
do,
is
we
initialize
the
grpc
client?
So
this
is
CSI
grpc
client
and
we
to
initialize
it
we
so
we
use
since
the
CSI
endpoint
or
the
service
provider
implementation
of
CBT
service.
It
listens
on
the
local
Unix
socket.
We
use
Unix
protocol
as
and
this
socket
CSI
socket
to
initialize
the
CSI
grpc
client.
B
We
convert
the
patterns
or
I
would
say
we
validate
and
convert
the
parents,
so
we
we
find
the
snapshot
session
data
object,
which
which
has
information
of
token,
as
well
as
the
snapshot
for
which
we
alternative
token.
We
validate
the
parameters
and
we
we
find
the
respective
snapshot
IDs
from
from
the
same
so
once
we
got
the
IDS
or
the
base,
as
well
as
Target
snapshot.
B
We
we
make
the
we
call
the
we
make
the
grpc
call
on
the
CSI
client
okay,
so
we
yeah
with
the
new
parameters
that
we
have
constructed.
We
make
that
your
PC
call
on
the
CSI,
client
and
yeah.
We
we
read
from
the
stream
once
we
read
from
this
CSI
client
stream.
We
forward
it
to
the
CBT
client
screen.
B
You
know
yeah,
so
we
have
two
streams
here.
One
is
CSS
stream
from
which
we
are
reading
the
contents
sent
by
the
CSI
driver
and,
at
the
same
time
we
are
forwarding
the
same
response
to
the
CBT
client.
So
we
are
doing
kind
of
browsing
here
right.
B
So
once
we
are
done
with
reading
all
the
responses,
we
we
close,
the
close
the
strip
and
yeah.
This
is
how
you
know
the
external
snapshot
system
service
will
act
such
a
proxy
between
plant
and
solid
stored
implementation.
B
The
next
thing
I
would
I
would
go
through.
Is
the
Cs
the
service
provider,
implementation
of
the
CBT
service
right,
so
the
protofile
we
we
have
already
gone
through
the
service
provided
implementation.
It
is
expected
to
implement
the
same
service
right
and
implement
the
same
RPC.
B
The
difference
here
is
the
arguments
or
the
parameters
or
the
request
parameters
that
we
see
here.
The
proxy
service
will
get
actual
names
for
based
on
certain
Target
snapshot,
but
the
with
the
service
provider
implementation
of
this
RPC.
They
would
expect
the
IDS
of
the
snapshot
and
the
proxy
service
is
responsible
for
converting
the
names
to
the
IDS.
Okay,
so
yeah.
C
These
are
the
snapshot,
handle
fields
in
the
kubernetes
objects.
Okay,.
B
Yeah,
yeah,
okay,
so
service
implementation
would
implement
the
same
service
same
RPC,
but
with
different
parameters.
B
So,
for
the
sake
of
this
prototype,
I'm,
not
using
the
you
know
all
the
CSI
Flags
here,
I'm
just
running
it
as
a
simple
jrpc
service,
so
yeah
this
service
distance
on
Unix
protocol
on
the
socket
and
it
implements
the
created
Delta
RTC.
Here
we
are
generating
right
now
we
are
generating
some.
You
know,
fake
data
and
returning
it
foreign.
C
So
just
a
note
on
the
data
I
mean
again
forget
the
fake
part,
so
this
is
the
place
where
the
SP
would
utilize.
Whatever
you
know,
this
is
running
in
the
namespace
of
the
CSI
driver,
so
it
has
access
to
whatever
config
maps
and
secrets
that
the
CSI
driver
has
established
to
get
credentials.
Okay,
so
all
that
is
up
to
the
vendor
and
it'll
use
all
that
data
and
the
IDS
here
to
make
its
backend
call.
C
So
when
it's
serving
the
data,
no
just
a
couple
of
points
which
we
haven't
brought
out
before,
because
this
is
all
grpc
level
is
that
the
protocol
right
allows
us
to
put
multiple
multiple
blocks
into
a
single
response.
So
you
notice
Prasad
this
stuff
two
blocks
into
each
response.
I
mean
the
control
is
part
of
the
input.
It
has
a
max
size,
Etc
right.
So
there's
quite
a
lot
of
flexibility
here
and
how
you
want
to
return.
The
data
just
want
to
point
that
out.
B
Cool
yeah,
now
that
we
have
discussed
about
you,
know
mainly
three
services.
B
The
sales
search
snapshot
session
manager,
which
has
controller
implemented
as
well
as
Facebook
Handler.
Then
there
is
an
external
snapshot
session
Service,
which
acts
as
a
proxy
and
perform
the
token
verification
right
and
the
client
communicates
with
the
service
using
the
it's
secured
by
TLS,
let's
go
and
then
the
proxy
service
calls.
B
These
two
services
are
running
as
sidecars
to
each
other
and
the
the
manager
service
is
running
in
independent
namespace,
so
to
it
to
answer
money's
question
the
manager
Service,
as
well
as
the
station
service,
those
will
be
implemented
or
maintained
by
community
and
the
actual
change
block
calculation
logic.
B
We
call
it
service
provider,
implementation
of
this
CBT
RPC
that
only
service
will
be
maintained
by
the
vendors
because
yeah,
the
Gen,
the
manager
and
the
proxy
service
implemented,
and
we
just
saw
or
the
logic
we
have
there.
It's
generic,
it's
not
specific
to
any
vendor.
So
you
can.
You
know
we
can
as
comparing
that
with
the
other
CSI
features
we
have
like
Snapchats
and
all
right.
B
B
So
the
server
the
CBD
service,
which
is
which
will
be
running
as
a
sidecar
along
with
the
proxy
service
or
will
be
implemented
by
and
maintained
by
the
vendor.
It's
it's,
it
has
the
vendor.
Specific
implementation,
I
would
say
yeah.
So,
comparing
that,
with
this
figure
right,
this
is
the
manager,
service
manager,
manager,
service
training
in
some
namespace,
and
this
is
the
Pod
Excel
service
service,
external
snapshot,
Section
3
spot,
which
has
this
proxy
Service
as
well
as
service
provider,
implementation
of
CBT
running
as
a
sidecast
to
each
other.
B
D
F
B
F
So,
if
that's
the
case,
how
the
controller
discover
the
endpoint
mdca
certificate
for
each
SP,
like?
Will
the
user
be
expected
to
reconfigure
the
controller
like
if
they
add
a
new
or
SP
or
like
that
gets
changed
or
whatever?
No.
C
C
C
F
B
Yeah,
so
that's.
C
Oh,
this
is
okay,
this
is
the
Cs,
the
kubernetes
implementation.
It's
not
the
CSI
spec
itself,
the
kubernetes
implementation
for
the
spec,
so
the
label
would
be
there.
So
we
can
find
the
object
fast,
because
this
is
going
to
be
in
multiple
namespaces.
So
kubernetes
gives
us
label
searching
right,
so
we
can
use
the
label
search
to
find
it.
C
The
odd
the
object,
it's
a
good
question-
doesn't
have
to
be
namespace
you're
right,
but
regardless
I
mean
oh
yeah,
so
the
reason
we
put
it
namespace
is
just
in
case.
Someone
was
concerned
about
exposing
this
information
to
anyone
else.
Now
the
CSR
is
public,
not
a
problem.
The
address
is
also
kind
of
public,
but
maybe
you
don't
want
to
show
it.
That's
all:
hey
yeah,
there's,
no
real
reason
to
put
it
there.
G
C
E
One
other
question
about
this:
I
think
I
know
the
answer
to
it.
I
just
would
like
to
confirm
it.
The
fact
that
the
ca
cert
itself
is
visible
is
not
a
problem
right
right,
so
I
mean
I'm
just
trying
to
understand
if
somebody
can
take
the
actual,
see
a
certain
contents
and
and
somehow
use
that
to
to
either
fake
a
session
or
do
something
malicious
with
it.
Yes,.
C
They
probably
yes,
if
it's
public,
if
this
is
easily
accessible,
clearly
I
mean
and
we're
not
saying
it's
not
accessible
right,
that's
true,
especially
if
vendors
install
the
CSI
driver,
saying
Cube
system,
because
almost
everybody
has
access
to
cube
system,
at
least
to
view
objects.
No,
but
of
course
this
is
protected
differently
right.
It's
got
its
own.
C
It's
got
its
own
rbac
rules,
but
again
that
doesn't
necessarily
make
it
the
make
the
session
yeah
more
vulnerable
because
you
still
have
to
get
access
to
the
session
data
objects
and
those
are
namespaced
in
the
TSA
driver
and
again
constrained
by
our
back
to
be
readable
by
the
CSI
drivers.
Service
account.
E
E
E
So
from
that
point
of
view,
great
work,
one
quick
question
that
I
had
was
I'm
sure
you
guys
have
thought
of
this
already,
but
given
all
the
different
components
that
are
there
in
this
system,
how
do
we
handle,
like
you
know,
situations
like
something
coming
up
sooner,
instead
of
later
than
expected,
or
if
a
component
goes
down?
How
do
we
ensure
that
you
know
the
system
overall
system
can
detect
that
that
has
happened
and
and
relay?
Are
there
any
initialization
dependencies
that
we
need
to
worry
about?
E
D
C
A
lot
of
it
would
depend
on
how
we
how
the
implementation
works.
I
mean
you
know
if
you've
played
with
CA
with
Unix
domain
sockets.
Sometimes
you
know,
there's
always
a
hang
up
between
listening
and
you
just
have
to
restart
the
entire
container.
But
that's
why
you
wrap
that
pair
of
the
of
the
sidecar
and
the
SP
service
together
in
in
a
you
know,
with
a
high
level
workload
which
can
just
restart
that
piece.
C
Now,
if
you
restart
you'll,
break
ongoing
Services,
that's
the
issue
right
on
weighing
sessions,
but
otherwise
that
you
can
recover.
Based
on
on
that,
so
no,
we
haven't
looked
into
all
the
failure
scenarios,
and
you
know
that's
something.
This
is
just
the
design
part
we've
just
been
going
through.
You
know,
let's
get
something
we
can
agree
on.
Yeah.
E
Yeah
no
completely
understand
I
I
I
wasn't
I,
wasn't
suggesting
that
we
should
have
solved
it
by
this
by
this
time.
I'm
just
saying
that
those
are
things
that
we
would
need
to
kind
of
Harden
and
get
get
right
before
this
can
become
ready.
Absolutely.
C
A
Sorry
can't
check
it's
already
on
the
top
of
the
hour,
so
I
think
we're
done
to
another
meeting.
So
I
did
add
one
thing
I
said
Thank
You
Prasad
for
for
the
presentation,
car
yeah
great
work
so
I
did
add
like
there
was
a
CSA
Community
sync
up,
June
21st.
Do
you
guys
want
to
present
there.
A
This
is,
this
is
for
the
CSS
that
changes,
because
you
will
need
to
go
through
that
as
well.
Okay,
yeah
and
also
another
question
is
I.
Think
I
asked
on
the
on
the
slide
as
well.
Have
you
guys
decided
do
you
want
to
go
to
in
1.28
or
what
not?
So
we
need
to
make
that
decision,
because.
D
A
Yeah,
let's,
let's
do
the
the
you
know
the
CSI
Community
Center
meeting?
That's
fine
yeah
with
that's
just
a
Target
design
for
this,
for
this
really
stand,
but
let's
try
to
be
there
for
the
CSS
income
meeting
for
the
CSA
Community
Committee
on
June
21st.