►
From YouTube: Securing Your Services with Authentication, Authorization, and RBAC in gRPC - Luis Pabón, Portworx
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Securing Your Services with Authentication, Authorization, and RBAC in gRPC - Luis Pabón, Portworx
gRPC makes it extremely simple to write complex, business-critical services, in a vast number of programming languages. Its simplicity and adaptability has made it simple for developers to adopt by easily generating code from structures and messages defined as protocol buffers. Writing a secure service based on gRPC, on the other hand, takes a little more effort. In this talk, we will be going through a model of how to secure a gRPC service using JWT based tokens to authenticate user access by relying on interceptors. We will also discuss models of how to provide role-based access control to authorize user access.
https://sched.co/Uad3
A
What
everyone
thank
you
very
much
for
coming.
My
name
is
Luis
Paulin
and
I
work
at
Port
works
today,
we'll
be
talking
about
securing
your
gr
PC
applications.
Okay,
a
little
bit
about
me.
First
I
say
my
name
is
Louise
already
I'm
a
CNC
I've
taken
technical
lead,
I'm,
also
been
participating
in
kubernetes
since
I
think
1.4
I,
remember,
going
to
Q
Khan
in
London
and
I
was
much
much
smaller.
Spite
of
the
size
of
just
this
side.
A
Right
I'm
also
been
participating
CSI
since
its
inception
and
before
the
working
at
port
works,
I
worked
at
core
OS
and
I
read
storage,
and
actually
that
picture
you
see
right
there,
that's
from
big
hero
6.
My
sister
sent
me
that
picture
and
she
said
I
think
you're
in
the
movie,
and
so
that
kind
of
looks
like
me
a
little
bit
probably
a
few
years
ago,
when
I
had
more
hair,
though
so
anyways,
alright,
so
a
little
bit
of
history
before
we
go
ahead
and
talk
about
authentication
authorization.
A
A
So
what
we
did
first,
we
created
G
RPC
SDK
and
that
worked
well
and
then,
after
that
they
said
well,
we
want
to
also
have
certain
applications
have
certain
rights,
and
we
also
want
certain
users
to
be
able
to
access
certain
volumes
and
not
others,
so
that
started
creating
what
we're
going
to
talk
about
here.
So
this
talk
is
specifically
on
our
experience
on
how
we
were
able
to
achieve
this
through
authentication
authorization
in
G
RPC.
A
Anybody
know
what
this
is
sneakers,
that's
right.
Yes,
that
movie
came
out
about
ninety-two,
I,
think
and
you
can
see
how
important
security
was.
Even
then
they
made
a
movie
about
it's
actually
pretty
fun
movies
but
watch
it,
but
in
this
movie
the
way
that
authentication
was
done
was
by
the
voice
of
the
person.
They
had
to
say
these
words,
and
then
they
will
have
a
voice
recognition
system
and
it
will
allow
them
to
go
in
the
point
of
the
movie
is
that
they
record
the
person
with
an
audio
tape,
a
very
analog
audio
tape.
A
They
record
every
single
word
that
the
person
said
to
put
them
all
together
and
then
playback
and
then
can
get
in
stable
to
achieve
that.
So
security
is
very
important
even
for
a
long
time
now.
So
when
we
started
this
project,
we
said
okay,
we
understand
that
we
need
password
management.
We
understand,
we
need
a
method
for
us
to
determine
who
the
user
is.
Okay.
So
what
we
started
going
into,
we
started
going
into
the
libraries
and
go
seed
started,
checking
out
other
projects
that
we
had
security
models,
so
I
looked
at
bcrypt
and
I.
A
Look,
how
be
correct
is
able
to
store
passwords
and
may
be
able
to
manage
passwords,
and
so
on
so
I
called
a
friend
of
mine
Cole.
His
name
is
Erik
Chang.
He
is
a
friend
of
mine
from
Korres.
He
now
works
at
Google.
He
used
to
be
a
cig
off
lead,
so
I
said
I
have
this
idea
for
authentication
and
authorization?
What
do
you
think
it
uses?
Bcrypt
it
uses
passwords,
and
all
this
is
pretty
nice.
You
log
in
saves
your
passwords
or
something
that
you
know
where
he
said.
A
No,
no,
no
don't
do
that.
You
do
not
want
to
do
password
management.
You
don't
ever
want
to
think
about
doing
password
management
strike.
That,
from
your
mind,
okay,
the
only
thing
you
should
be
doing
is
verifying
a
token.
That's
the
only
thing,
and
this
is
the
way
he
said
you
should
do
it
like
kubernetes,
that's
what
they
do
right.
Something
else
creates
tokens
you
get
your
token
to
kubernetes
for
an
API
call
in
combination.
Can
then
verify
you
should
do
exactly
the
same
thing.
A
Okay
and
actually
I
want
to
thank
Eric,
because
we
have
brought
this
model
over
to
some
of
our
customers
and
they
have
a
huge
audit
sheet
of
things
to
how
you
do
password
management
things
like
that,
and
the
really
nice
thing
about
it
is
that
most
of
them
we
say
does
not
apply,
does
not
apply,
does
not
apply.
Why?
Because
I'm
do
password
management.
All
we
do
is
verification
of
tokens.
How
long
do
you
hold?
The
password
does
not
apply
where
the
astoria
password
does
not
apply
right.
A
Okay.
So
how
do
we
actually
get
to
do
this
verification
of
tokens
in
G
RPC?
We
chose
two
models:
I
mean
that's
really
one
model
using
the
g-o-p,
kouddous
JSON
web
token.
I
hope
most.
Everybody
knows
what
JSON
web
token
is
very
good
okay.
So
then,
what
we
need
to
do
is
also
make
sure
that
applications
can
generate
tokens
for
G
RPC.
We
call
that
a
trusted
issuer.
So
let's
talk
about
gwt's
first
for
those
who
are
new
to
this,
it's
just
a
bunch.
A
It's
a
large
string,
okay,
a
token:
it's
just
a
large
string
divided
into
three
parts
and
that's
what
adjacent
we're
talking
is.
The
three
parts
are.
The
header
describes
the
token
itself.
The
claims,
the
most
important
part
describes
the
user
groups
roles
whatever
you
want,
it's
just
a
whole
bunch
of
JSON
blob.
You
can
put
whatever
you
want
in
there
and
then
there
is
a
signature.
A
The
signature
is
the
contract
between
the
token
issuer
and
the
word
friar
the
contract,
where
you
need
a
certain
method
to
go
ahead
and
verify
that
the
token
is
correct
and
it
hasn't
been
tampered
with.
So
once
your
token
gets
out
put
into
some
large
blob
of
text,
it
is
immutable.
Okay,
all
right,
so
we
understand
now,
where
the
token
is
it's
just
three
parts
of
string,
somebody,
it
has
the
claims,
it
has
a
signature.
A
Well,
how
do
you
generate
the
token
there's?
Actually
a
couple
of
models
that
we
actually
use
for
our
implementation?
One
is
that
you
can
use
the
normal
JW
te
libraries
for
many
languages
to
go
ahead
and
generate
a
token
as
long
as
you
share
the
they're.
Both
the
verifier
and
the
generator
of
tokens
have
to
have
a
method
to
to
determine
either
one
is
to
do
a
shared
secret
right.
We
have
one
secret
to
generate
the
signature,
and
then
you
have
a
secret
in
the
verifier
that
make
sure
that
that
signature
is
correct.
A
You
can
also
do
a
public
key
private
key
model
where
you
had
the
private
key
being
able
to
generate
tokens,
and
you
have
the
public
key
to
be
able
to
verify
and
then
there's
another.
That's
again,
that's
up
to
you,
the
in
in
our
model.
It
will
talk
to
our
customers.
We
let
them
have
the
freedom
to
be
able
to
generate
all
these
tokens
in
any
way
they
want
python
script
or
whatever,
but
then
there's
another
model
called
Open
ID,
Connect,
Oh
IDC
oo.
A
I
DC
is
a
standard
that
allows
your
system
to
connect
to
two
out
of
which
help
can
manage
thousands
of
users.
So
I'll
go
into
all
I
see
in
a
second.
But
let's
talk
about
how
generating
the
token
works,
so
here's
just
a
little
bit
of
pseudocode
and
you
can
see
from
here
that
in
the
claims
again
the
JSON
map,
you
can
store
things
like
the
sub.
The
sub,
according
to
the
standard,
is
a
unique
identifier
for
your
user.
A
A
Okay,
then
there's
more
information
about
the
color
like
the
email
name
and
tongue
sometime
and
then
there's
expiration
date
and
the
issue
that
time
for
this,
which
is
a
little
Sukkot,
and
now,
as
I'm
gonna
start
showing
a
lot
of
go
line
code
just
get
ready
and
I.
Don't
want
you
to
start
like
reading
through
it
right
now.
A
Every
one
of
these
has
a
link
at
the
bottom,
and
you
can
click
on
that
link
and
actually
shows
you
our
open
source
code
that
we
actually
use
in
Port
works
to
do
this,
so
you
can
see
real
examples,
so
open
ID
connect
again
it's
a
service.
You
can
use
this
service
to
be
able
to
connect
between
your
G
RPC
service
and
something
like
Active,
Directory
or
LDAP.
For
example,
one
of
the
ones
that
we
tried
and
works
really
well
is
Key
Club
by
Red,
Hat
and
Dex
by
core
OS,
for
example.
A
In
key
cloak,
you
can
map
different
sections
of
an
LDAP
like
roles
and
groups
to
what
port,
which
is
looking
for.
Ok,
you
can
also
have
users.
Kylo
can
have
its
own
therapies
for
users.
If
you
have
just
maybe
a
few
hundred,
but
if
you
have
thousands
of
users-
and
you
want
to
track
them,
you
can
you
can
connect
it
to
an
LDAP
system.
Then
there's
also
service
on
the
cloud
like
Octonauts,
zero
and
then
another
o
or
there
are
IDC
compliant
systems
in
Google
and
AWS
and
Azure,
and
others
like
that.
A
So
alright,
so
we
understand
kind
of
the
big
picture
of
Santa
keishon.
How
does
it
actually
work
implemented
in
going
so
if
you've
done
JWT
tokens
in
rest
is
a
lot
like
that
for
the
client,
where
the
token
goes
into
the
metadata
of
the
call
in
a
rest
call,
it
goes
into
the
headers,
which
again
is
the
metadata
of
the
call
and
in
goal-line
there
is
a
sorry
in
G.
A
A
So
it's
pretty
simple:
it's
not
much
to
do
in
the
in
a
client.
If
you
don't
want
to
do
this,
for
example,
for
each
one
of
your
calls,
you
can
start
the
token
in
the
context
every
single
time
and
go
long.
You
can
also
do
something.
It's
called
interceptors
and
interceptors.
Allow
you
to
catch
your
calls
going
out
and
then
insert
the
context
every
time.
Now,
let's
talk
about
the
service
side,
that
was
a
client.
It's
pretty
simple!
It's
done!
A
The
server
side
is
a
little
more
complicated,
and
this
is
really
one
of
the
reasons
why
I
wanted
to
do
this.
Talk.
There's
very
little
information
about
this
out
on
the
internet
and
I
wanted
to
kind
of
just
put
it
all
together
like
a
little
compiled
program
and
then
send
it
out
to
you.
So
the
way
it
works
is
that
we're
going
to
use
technology
called
interceptors
which
you've
used
OpenStack,
Swift
or
Python
whiskey
server.
You
have
these
filters
that
doing
a
pipeline
and
they
pass
environment
to
each
other.
A
If
you
write,
if
you
written
Windows
device
drivers,
they
have
the
stack
you
can
send
from
one
to
the
next
and
the
next
and
so
on
and
stack
so
in
the
same
ways
how
Interceptor
works.
So
here's
a
very
simple
interceptor
for
the
server
side
if
every
interceptor
has
that
same
function
are
a
set
of
arguments.
A
In
this
example,
we
take
the
context
and
we
insert
into
it
some
value
some
key
value,
and
then
what
we
do
here
also
is
in
this
example.
This
is
specifically
for
going.
We
are
also
past
the
actual
G
RPC
function
as
being
accessed
in
the
function
in
folder,
full
method,
and
when
this
value
here
we
get
to
print
it
out,
and
then
we
go
ahead
and
call
the
next
handler
with
the
new
context
that
we
have
adjusted.
A
So
the
next
handler
now
has
that
some
key
some
data
information
in
the
context,
so
it's
just
a
generic
interceptor.
Now,
let's
now
start
focusing
on
our
authentication
interceptor,
so
G
RPC
has
these
golden
libraries,
our
helper
libraries,
to
be
able
for
you
to
do
authentication
of
JWT
tokens.
The
way
you
set
it
up
is
that
when
you
set
up
an
AG,
RPC
server,
you
have
to
do
the
following
to
be
able
to
stack
all
your
inter
scepters
in
order.
So
in
that
order
is
how
the
server
is.
A
Gonna
call
your
interceptors,
so
you
want
your
authentication
most
likely
to
be
first.
So
that
way,
you
can
authenticate
the
call
and
then
set
up
the
context
for
the
next
calls.
In
this
example,
here
we
just
have
the
simple
interceptor,
just
as
like
a
logger,
and
then
we
have
this
wrapper
around
the
our
off
call,
which
is
here.
A
This
is
a
helper
function
that
comes
with
going
in
the
gr
PC
a
library
and
this
helper
function
gets
automatically
just
the
context
and
from
it
we
get
call
another
helper
function
to
extract
out
the
token
out
of
the
call
out
of
the
metadata.
Once
we
extract
the
token
out
of
the
metadata,
we
just
call
some
verify
token
function.
Whatever
you
have
for
your
system,
there
is
a
lot
of
goaling
libraries
to
be
able
to
do
this.
A
We
use
the
adjacent
with
T
going
libraries
to
do
this,
so
this
is
how
you
implement
it
in
your
way.
Alright,
so
here's
the
library
that
we
use
is
JWT
go
and
we
again
I
have
lots
of
examples.
Once
you
use,
you
see
these
slides.
These
lights
are
on
my
golang
on
my
github
repo
actually,
and
then
we
also
have
a
very
a
way
of
verification
with
already
seen.
How
is
it
that
we
set
it
up?
A
A
This
part
was
a
little
bit
more
complicated
because
in
authentication
we
had
a
lot
of
helper
functions
being
able
to
from
the
growing
library
function
for
G
RPC
to
help
us
with
this,
but
for
our
back
we
had
to
kind
of
come
up
with
something
and
again,
this
is
how
we
implemented
the
the
methods.
It's
an
example.
You
may
look
at
this
and
adjust
it
to
your
models,
but
I
just
wanted
to
give
you
a
start
on
the
way
we
did
it.
A
So
we
have
an
art
back
model
for
our
our
open
stores,
SDK,
which
is
a
gr
PC,
SDK
and
everybody
here
hopefully
understands
the
kubernetes
model
right.
The
kubernetes
are
back.
Model
is
based
on
verbs
like
get
list
patch,
right
and
so
on,
but
we
needed
to
do
something
like
this
for
gr
PC,
but
gr
PC
doesn't
have
the
same
verbs
right.
Those
are
those
are
HTTP
verbs.
A
So
what
we
did
was
we
wanted
to
look
kind
of
like
kubernetes,
and
we
wanted
to
make
it
simple
for
our
users
to
be
able
to
do
this.
So
what
we
did
was
we.
We
looked
at
this
strings
that
the
functions
are
called
and
we
say
okay.
This
is
what
I
would
like
it
to
be
like
right.
I
want
a
role,
a
key,
the
name
of
the
role,
there's
these
rules
and
then
inside
it
has
two
sections
or
a
an
array
of
these
two
sections
and
they
are
services
and
api's
right.
A
So
in
this
example,
in
this
one
role
that
I
have
here,
there's
a
service
that
is
allowed
for
this
one
color
called
route
guide,
an
in
route
guide,
the
only
API
that's
allowed
is
get
feature.
So,
according
to
this
rule,
list
features
is
not
allowed.
So
if
somebody
was
in
this
role
and
tried
to
call
this
features,
it
will
be
the
knight,
so,
let's
figure
out
how
we
actually
do
that
in
golang.
A
So
the
way
it
works,
it's
all
based
on
the
Interceptor
passing
in
the
info
dot,
full
method
that
has
the
entire
path
for
your
G
RPC
call.
All
you
have
to
do
is
kind
of
clean
off
all
the
the
slashes
and
the
things
inside
like
open
source
API
that
comes
from
the
generation
of
the
of
the
go
long
files
from
the
protocol.
Buffers
justtake,
remove
that
and
you're
left
with
the
service
and
the
api.
A
And
now
with
that
information,
you
can
go
ahead
and
verify
that
the
color
is
allowed
to
do
make
that
call
or
not
all
right.
Here's,
for
example,
a
more
specific
example:
how
to
do
this
and
go
line
and
make
a
roll,
but
again
it's
the
same
style
as
you
can
see
here
we
have
a
different
set
of
function.
We
have
a
roll,
and
we
have
two
API
calls
this
one's
specific.
A
What
the
storage
SDK,
where
we
have
two
services,
so
we're
saying,
and
you
can
call
the
volume
service
and
the
cluster
service
and
the
api's
star,
meaning
what
all
the
functions
in
those
two
services?
Okay.
So
when
somebody
use
it
uses
this
role,
they're
only
allowed
to
make
those
calls
if
they
try
to
make
another
call
like
a
node
or
something
like
that
they
will
not
be
allowed
to
all
right.
So
how
do
we
do
this
in
go
long
again?
How
do
we
actually
implement
it?
A
Okay,
so
the
Authenticator
interceptor
was
called
first.
It
makes
sure
that
the
token
was
okay.
It
put
extracted
information
of
the
token
saved
at
all.
In
the
context
now
the
next
call
comes
in
extracts,
information
out
of
the
context
again,
I
see.
Oh,
this
is
Louise
right
he's
trying
to
make
this
call
and
then
it
goes
ahead
and
calls
the
verify
for
Louise,
and
it
says
to
make
sure
that
this
call
is
a
loud
or
not
okay
and
that's
how
we
do
our
back
support
in
Ag
RPC.
Now,
here's
another
really
cool
thing.
A
I
was
doing
debugging
for,
for
this
called,
isn't
interceptor
specifically
and
I
created
something
I
didn't
even
mean
to
create
right,
I,
wasn't
even
planning
on
doing
this.
I
created
an
auto
log,
I
didn't
even
plan
on
doing
that.
It
just
happened
right
I
was
tracking.
Every
single
call
that
came
through
every
user
and
I
was
logging.
It
right.
I
was
logging,
you
feel
successful
as
long
if
it's
not
successful.
Now
we
have
methods
to
track
each
one
of
these
right.
A
A
Okay,
so
that's
authentication,
that's
authorization,
but
some
of
our
customers
also
said.
Will
we
liked
your
PC
that's
great,
but
we
still
want
to
use
rest
said
okay,
so
what
do
we
do?
We
use
there's
a
service
out
there
that
is
called
a
GRS
PC
gateway,
and
this
is
really
nice
because
and
I
highly
encourage
you
to
stop
running
rest
services
and
start
writing.
G
RPC
versus
services,
with
the
G
RPC
gateway.
Also
what
the
way
works
is
on
your
G
RPC
service.
A
You
define
the
path
okay
and
then
what
happens
is
that
when
you
deploy
your
application,
your
service,
you
start
up
a
rest
service,
that's
generated
for
you
by
the
G,
RPC
gateway.
You
start
this
gateway.
It
takes
in
the
rest,
call
automatically
changes
it
to
a
G,
RPC
call
and
it
calls
your
function
you
didn't
have
to
do.
You
need
to
write
a
single
line
of
code
to
be
able
to
support
rest.
Okay,
the
really
nice
thing
about
it,
too,
is
that
eight
supports
authentication.
A
A
There
we
go
all
right,
so
all
right
so
on
this
system,
I
have,
let's
make
sure
I
have
the
Internet.
Anybody
can
see
that
okay
I
could
make
it
bigger,
so
I
have
four
nodes
and
are
running
one.
Fifteen,
five,
okay,
actually
I,
didn't
show
you
this
slide
here.
Let
me
talk
about
this
life
first
and
I'll
show
you
the
demo.
So
what
we
wanted
to
do
in
this
demo
is
some
of
our
customers.
They
wanted
a
simple
way:
they
don't
want
to
use
or
IDC.
A
They
just
wanted
to
secure
the
communication
between
kubernetes
and
our
storage
system.
They
wanted
to
make
sure
that
that
kubernetes
doesn't
have
the
entire
our
back.
They
want
a
specific
article
kubernetes
and
they
wanted
administration
tokens
to
be
run
only
on
the
command
line.
So
that
means
is
that
the
customer
is
leveraging.
The
kubernetes
authentication
model
for
other
users
wants
to
get
authenticated
to
actually
create
a
volume.
They
go
ahead
and
use
a
storage
class,
and
then
the
kubernetes
can
send
the
command
to
to
our
storage
system
and
that
gets
authenticated.
A
So
we
only
trust
kubernetes
in
this
model.
Okay,
what
we
do
is
our
secrets
that
we
use
to
generate
tokens
are
stored
in
kubernetes
itself,
and
the
tokens
that
are
generated
are
also
stored
in
kubernetes
itself.
Ok
and
I'll
show
you
what
that
means.
So
the
very
first
thing
is
I'll
show
you
is
the
secrets.
So
KN
is
my
alias
for
cube
system,
Q
Caudill
and
the
cube
system
that
has
too
much
to
type
I
just
add
care.
So
if
you
want
to
check
you
say
capacities,
that's
all
the
queue
proxy
and
things
like
that.
A
A
A
Here's
the
administrator,
llamo
I,
said
the
name
this,
the
subject:
the
email,
the
roles
and
the
group
group
star
specific
to
port
works,
meaning
you
are
can
use
any
any
volume.
Any
resource
doesn't
matter
okay.
So
this
is
the
admin,
the
storage
admin.
If
I
do
this
for
kubernetes,
then
we
look
at
the
information
that
we
have
here
for
kubernetes
and
so
on.
So
I
have
a
little
refresh.
Keys,
okay
and
we're
gonna
just
run
this
one
line
here
for
the
often
just
to
show
you
run
this
first,
so
we're
gonna
get
the
secret.
A
That's
on
the
on
kubernetes
itself,
I
gonna
say
echo
secret.
It's
not
recorded
right,
that's
good!
So
that's
the
secret,
that's
being
used
to
generate
tokens
and
we're
gonna
generate
it
a
token
just
for
fun.
Gonna
give
it
a
seven
day
token,
and
that's
a
token
right
there.
That's
how
it
looks
like
okay,
if
you
wanna
see
what
it's
inside
a
token
we
can
go
to
here.
A
Let
me
just
get
out
of
this
and
go
to
JWT
the
IO
and
paste
it
here
and
then
you
can
verify
that
your
token
information
is
correct.
See
here's
the
admin
is
on
role,
system,
admin
and
so
on.
This
is
a
good
way
to
verify.
What's
inside
your
token,
all
right,
let's
go
back
here,
alright,
so
the
next
thing
that
this
little
program
does
is
that
it
inserted
the
tokens
in
different
namespaces.
A
Now,
when
I
show
you,
the
cpsc
I,
have
a
storage
class,
and
is
this
how
it
works
the
stores
class
we
first,
this
stores
class,
specifically
we
first
with
specific
token
and
the
token
is
the
kubernetes
user
token
right.
So
that
way,
anyone
that
uses
the
stores
class
uses
that
token
so
every
so.
So
that's
fine!
Now
what
if
we
wanted
to
have
two
tenants
separately
now
we're
not
gonna
discuss?
A
How
do
you
do
that
networking
and
things
like
that?
We're
just
talking
about
the
storage
system
and
how
you
do
different
volumes
for
each
so
what
I
did
here
is
I
have
two
namespaces
one
called
tenant
one
and
one
called
ten
and
two
and
then
I
go
ahead
and
create
a
secret
in
each
and
each
one
of
those
has
a
token
for
each
one
of
those
tenants.
Okay.
A
So
when
I
look
now
at
the
source
class
for
the
tenants
you
can
see-
and
again
this
is
all
based
on
CSI.
You
can
see
now
that
the
namespace
is
the
namespace
of
the
PVC,
that's
very
important.
So
what
happens
is
that
if
I'm
calling
from
tenant
one,
then
I
request
a
PVC
with
this
storage
class,
it's
going
to
go
to
my
namespace
and
look
for
the
token
that
defines
me
as
tenant.
A
A
That
is
very
important,
because
what
happens
is
that
if
at
any
point
in
time
any
other
tenants
because
malicious
and
tries
to
get
the
accident
data
of
another
a
tenant,
it
will
not
be
possible
because
the
API
will
protect
them
all
right.
So
you
have
protection
from
kubernetes
at
your
level
visa
namespaces,
and
then
you
got
protection
now
from
the
storage
system
itself.
A
So
a
couple
of
last
things:
now
we
have
just
a
few
minutes
left.
How
is
it
that
we
generate
documentation?
There
is
some
really
cool
programs
out
there
like
there
are
generators,
just
like
you
have
protocol
buffer
generators
for
different
languages.
They
just
output
in
that
language
is
one
for
markdown,
so
you
can
actually
go
through
your
entire
protocol
buffers
file
and
generate
all
the
documentation,
and,
lastly,
is
I-
recommend
you
guys
do
this.
If
you
have
protocol
buffers
files
is
that
you
version
them,
we
have
a
link
here.
A
How
is
it
that
we
go
ahead
and
do
that
in
our
system,
but
that
makes
it
that
the
file
itself
is
versioned,
and
then
you
can
use
that
information
at
an
important
time,
for
example,
for
the
client
to
request
the
version
information
for
the
from
the
server.
That
way,
you
can
check
for
any
situations.
What
they're
not
matching,
alright,
that's
all
I
have
again
the
slides
are
right
there
on
my
github
and
I
have
just
about
five
minutes
for
questions.
If
not,
we
can
I'll
be
out
in
the
back.