►
From YouTube: Kubernetes SIG Service Catalog 20170713
Description
Design meeting:
- What is the best way to make additional integrations beyond the basic OSB integrations?
B
Welcome
everybody
to
the
July
13
2017
meeting
of
uber
96
Service
Catalog
we're
going
to
be
continuing
to
discuss
some
different
design
issues
for
things
that
we
think
are
required
or
may
be
required
to
elevate
catalog
to
beta.
So
first
up
is
Michael.
Kiba
from
Google
is
going
to
do
a
demo
for
us
go
ahead
and
Michael.
You
have
the
floor.
C
Sorry
spill
getting
used
to
this:
okay,
yeah,
okay,
so
yeah
this.
This
is
sort
of
a
continuation
of
where
we
left
off
from
yesterday,
because
we
were
talking
about
how
how
we
sort
of
wanted
to
separate
the
concept
of
pod
presets
from
a
from
the
actual
credential
sort
of
storing
and
consumption
story,
and
maybe
give
that
a
bit
more
customized
ability
on
the
users
side
to
be
able
to
maybe
consume
services
in
their
application.
C
The
way
they
want
to
so
I
was
doing
some
prototyping
just
around
this
concept,
and
so
maybe
to
recap
some
of
the
possible
ways
people
would
want
to
consume
credentials.
We
had
discussed
about
like
vcap
services,
where
they
store
everything
in
one
environment.
Variable
then
there's
of
course,
pod
presets
and
then
there's
custom
solutions
based
off
of
maybe
what
the
the
people
are
currently
running.
C
Whatever
their
enterprise
environment
is,
and
something
I
also
wanted
to
bring
up,
was
that
maybe
it's
not
just
the
actual
credential
storing
for
the
application
use
that
we
should
maybe
make
a
bit
more
dynamic,
but
there's
also
other
sorts
of
environment
configuration
that
we
may
want
to
allow
to
do
on
binding
creation.
So
some
of
the
examples
we
have
thought
were
like
if
you're
familiar
with
Sto
having
an
sto
proxy,
come
up
on
a
binding
creation
that
fronts
that
that
binding
or
maybe
doing
something
like
an
egress
proxy
or
a
firewall
rule
for
the
cluster.
C
B
C
C
So
what
I'm
thinking
is
that
maybe
the
the
secret
aspect
is
just
one
component
of
how
the
binding
is
configured
in
the
environment
and
then
maybe
having
that
entire
sort
of
portion
after
the
the
credentials
come
back
from
the
broker
as
a
hook.
Point
for
other
logic
that
can
take
place
that
you
that
people
can
build
their
own
custom
solutions.
There
yeah.
B
Yeah,
and
so
my
version
of
that
is
that
the
binding
resource
is
just
about
the
open,
serviceworker
binding,
it
dumps
credentials
into
a
secret.
If
you
want
another
integration,
you
build
another
integration
and
have
the
resource
for
that
represent
that
integration
be
watching
the
binding
and
start
working
when
the
binding
becomes
ready.
Is
that
basically,
what
you
had
in
mind
so.
C
Mines
my
thoughts-
this
is
just
a
sort
of
spit
ball
proposal,
okay,
that
I
did
or
that
I
made
this
little
demo
off
of
okay.
The
thought
is
that
maybe
the
secret
aspect
itself
is
also
more
of
a
customizability
extension
point,
and
so
let
me
maybe
just
go
through
the
demo
and
this
gels
at
all
with
anybody.
This
is
a
first
cut
and
so
yeah
I
just
wanted
to
see
if
this
is
something
we'd
be
interested
in
and
if
it
yeah
sparks
any
interesting
discussion.
C
C
What
we
don't
have
is
the
binding
yet
so
I'm
going
to
create
the
binding
next,
and
so
what
I
want
to
show.
First
is
a
little
bit
of
the
architectural
changes
that
I
made.
So
this
is
in
the
kubernetes
api
server
I'm
going
to
get
the
pods
for
the
catalog,
and
so
now
what
we
see
is
there's
the
API
server
and
the
controller
manager
as
we're
used
to,
but
I've
also
created.
This
other
thing
called
so
here,
just
as
native
UPC,
that's
sort
of
an
old
ish
name.
C
We
were
kind
of
thinking,
but
it's
because,
like
Oh
user
provided
service
like
it's
kind
of
user
provided
client,
but
anyway,
this
is
just
a
a
sort
of
plugin
that
you
would
be
able
to
create.
So
the
idea
here
is
that
the
controller
manager
handles
everything
up
until
the
the
very
up
until
when
the
credentials
are
passed
back
from
the
broker
and
then
what
you
could
do
is
create
your
own
plugin
that
handles
that
next
step.
C
A
My
college
totally
sure
I
understand,
but
still
you
described
there,
it
sound
like
you're,
saying
that
after
the
binding
is
created,
the
concert
after
the
binding.
No,
so
the
binding
is
created
by
the
user,
the
controller
talks
to
the
service
broker
gets
the
credentials,
sticks
it
into
a
secret.
Then
you
optionally,
starts
calling
plugins
to
do.
Customized
work
is
that
right.
C
So
everything
there
was
right,
except
for
in
this
case
I,
had
included
the
aspect
of
secret
creation
in
the
job
of
the
plug-in.
That's
yeah!
That's
totally
just
my
decision
there,
but
us
I've
opened
the
plug-in
here,
and
so
what
we
see
is
that
it
is
the
same
old
here
we
have
like
inject
secret,
where
it's
creating
the
secret
and
then,
if
you're
familiar
with
the
the
controllers
binding
code,
and
then
it
creates
the
pod
preset
here.
So
it's
just
a
refactoring
there,
but
the
interesting
part
oops
can't
scroll,
okay,
yeah.
C
C
A
Only
trying
to
subdue
the
reason
for
you're
doing
something
you
said
the
the
action
of
putting
the
credentials
into
a
secret
is
done
as
a
plug-in
I
assume,
because
you
wanted
the
flexibility
to
say
in
some
environment
they
may
not
even
want
to
store
these
as
secrets
at
all.
They
know
I'm,
just
like
a
goody
custom
with.
Is
that
right?
Yes,.
C
So
now
what
I've
created.
So
the
only
change
here
is
that,
instead
of
just
having
this
alpha
pod
preset
template
as
a
aspect
of
the
spec,
it's
been
pushed
up.
One
level
into
this
concept
called
consumption
parameters,
and
so
the
consumption
parameters
here
are
everything
the
plug-in
needs
to
know
in
order
to
do
its
job
so
I,
since
this
plug-in
in
this
case,
is
creating
a
secret
and
the
pod
preset
I
just
gave
it
the
secret
name,
namespace
and
then
the
pod
preset
template.
A
C
A
A
Or
do
you
see
this
if
we
actually
did
adopt
this
type
of
approach
of
also
sort
of
having
sort
of
a
default
definition
that
says
yeah
I'm
not
going
to
force
every
single
binding
creator
or
every
single
application
developer
to
add
that
into
every
single
binding
expect,
rather
we're
going
to
default,
one
that
you
can
override
or
something
like
that.
Yeah.
C
B
The
the
probably
the
first
one
is
that
if
you
use
this
pattern,
you
expose
yourself
to
a
couple
of
different
risks
and
inconveniences.
The
first
one
is
that
if
this
plug-in
that
you
call
goes
down
and
I'm,
not
sure
how
you
configure
the
plugins
for
the
record,
but
if
a
plug-in
that
you
call
goes
down,
you
don't
have
anywhere
to
put
the
secret
mm-hmm.
You
do
not
have
anywhere
to
put
the
results
buying
operation,
Oh,
you,
you
don't
have
a
place
to
persist
it
I.
B
We
do
not
want
to
add
like
persistence,
cashes
in
kubernetes
controllers,
we
don't
basically
don't
have
a
precedent
for
that
and
that's
not
a
place.
I
want
to
go.
The
second
one
is
that
I,
the
lifecycle
of
the
binding
is
now
tied
to
some
arbitrary
criteria
that
are
themselves
like
by
they
are
necessarily
undefined
because
it's
a
plug-in
mechanism.
So
let
me
describe
an
alternative
to
this.
I.
Do
think
it's
the
right
approach
and
is,
by
the
way
cool
demo.
I
can
appreciate
the
work
it's
good
to
prototype
on
these
things,
so
I.
B
The
the
pattern
that
I
have
in
mine
is
like
is
very
similar
in
terms
of
what
it
tries
to
accomplish.
It's
just
a
slightly
different
factoring
so
say,
for
example,
that
in
by
the
way,
I
I
look
at
secret
right
now,
as
like
the
place
to
persist,
the
the
bind
result.
B
If
you
want
to
integrate
with
a
pod
preset,
I
think
there
should
be,
as
I
was
describing
yesterday
a
preset
binding
resource
and
you
create
the
binding
in
the
pod
preset
binding.
At
the
same
time,
the
pod
preset
binding
references,
the
binding
that
you
created
and
the
controller
that
backs
the
pod
preset
binding
me,
the
pod,
preset
that
you
want
to
create,
along
with
the
lifecycle
of
the
binding.
B
So
when
the
binding
becomes
ready,
then
the
pod
preset
controller
can
be
watching
bindings
and
say:
hey
that
one's
ready
now
I'm
going
to
I'm
going
to
create
the
pod
preset
when
the
binding
I
get
deleted.
The
and
actually
the
the
this
resource
could
conceivably
create
or
add
an
initial
error.
I'm
sorry
a
finalizar
to
the
binding
via
the
initializer
mechanism,
which
is
basically
a
remote
admission
controller
so
like.
But
let
me
just
talk
through
this
again.
Really
quick,
you
create
the
binding.
B
The
initializer
for
your
other
resource
adds
a
finalizar
to
the
binding
when
the
binding
becomes
ready.
The
piped
reset
binding
controller
makes
the
pot
preset
when
the
binding
gets
deleted.
The
the
pod
preset
binding
controller,
clears
the
finalizer
and
deletes
the
pod
preset
and
then
once
the
all,
the
other
finalizes
are
cleared,
the
catalog
controller
can
can
actually
delete
the
secret
and
do
the
unbind
and
I
I
would
characterize
the
advantages
of
this
approach,
as
you
can
build,
as
many
integrations
as
you
want,
they
can
have
dependencies
between
them.
B
So,
for
example,
say
that
you
want
to
make
a
another
integration.
As
I
know,
a
lot
of
people
want
for
gif
do
where
you
do
X
or
Y
activity
related
to
Sto.
You
can
make
an
FeO
binding
and
point
it
at
the
the
binding
resource
and
have
it
do
its
work
and
manage
the
SEO
rules
on
the
same
life
cycle
as
the
binding
Mike
again.
B
So
I'm
all
about
having
people
build
other
pluggable,
behaviors
I
think
the
right
factoring
is
not
a
plug-in
mechanism
to
binding
its
other
resources
that
reference,
the
binding
that
can
hook
into
the
lifecycle
and
I.
Don't
think,
there's
anything
about
what
I
saw
here.
That
would
prevent
us
from
factoring
what
you
showed
that
way.
I
think
probably
the
salient
point,
like
the
biggest
difference
to
me
in
terms
of
like
fundamentals,
that
change
about
the
situation
is
that
in
your
pattern,
you
might
not
actually
create
a
secret?
C
It
was,
it
was
mostly
a
coincidental
effect.
It's
a
thought
that
creating
a
secret
is
itself
sort
of
a
environment
configuration
aspect
too,
after
we've
gotten
the
credentials
back
from
the
binding,
so
it'll
like.
If
we're
not
concerned
about
the
the
sort
of
Oh,
what
do
we
do
if
things
are?
If
we're
ignoring
the
idea
of
that,
we
might
have
to
persist.
Information
anyway
should
plugins
go
down,
then
it
would
itself
be
just
another
pluggable
feature
is
my
thoughts.
Yeah.
B
And
if,
if
we
had
a
place
where
we
could
put
the
payload,
that
would
stand
up
to
an
API
review,
scrutiny,
I
think
I
might
be
more
open
to
this
approach,
but
I
think
I
would
still
have
a
reservation
about
complicating
in
kind
of
invisible
ways:
the
behavior
the
blinding
resource.
My
experience
has
has
definitely
given
me
a
lot
of
data
points
that,
like
the
simpler
things,
are
and
the
less
entanglements
they
have
the
easier
that
they
become.
B
The
reason
about
I
do
think
that
we
have
the
primitives
that
we
would
need
to
hook
into
the
to
hook
into
the
binding
lifecycle
from
other
resources.
I,
don't
know
what
your
thoughts
are
about,
that.
What.
C
Could
I,
let
me
maybe
say
a
couple
of
things
as
to
what
I
thought
were
sort
of
pros
to
this
approach,
and
then
maybe
we
can
ask-
or
we
can
talk
about
how
these
would
be
handled
in
an
alternative
case
or
in
the
sort
of
proposal
that
you've
designed
sure,
because
the
idea
of
first
first
I
think
a
nice
one
is
in
the
case
where
you
are
not
needing
to
intimately
hook
into
the
kubernetes
sort
of
API
in
the
code,
because
this
is
a
more
it's
just.
C
It's
just
a
HTTP
like
post
endpoint
with
a
JSON
payload.
So
that
allows
you
to
have
flexibility
in
how
you
implement
the
actual
plugin.
So
I
actually
had
some
more
of
the
demo
where
I
did
I
had
two
plugins
running
together
and
it's
a
console
plugin
for
service
discovery,
where
the
application
uses
the
console
DNS
as
opposed
to
kubernetes
dns,
to
resolve
where
the
service
endpoints
are
and
then
a
volt
plug
in
for
for
the
secret
store.
C
And
so
what
was
interesting
was
that
the
console
plugin
it
was
in
Python
and
then
the
vault
one
was
in
go
and
the
idea
would
be
that
you
could
then.
Another
aspect
is
that
the
plugins
are
an
ordered
chain
that
allows
you
to
do
something
like
you
can
have
the
fur
plug
in
in
your
chain
be
the
like
the
sto
plug
in
and
what
that
would
do
is
it
would.
It
gets
the
credentials
back
from
the
broker.
It
says:
okay,
let
me
create
a
sto
proxy
and
then
for
the
rest
of
the
chain.
C
I
will
substitute.
I
will
keep
a
record
of
what
the
actual
end
point
was,
but
let
me
substitute
it
in
with
a
with
the
proxies
endpoint
and
so
the
rest
of
the
plugins.
If
you
had
secret
store
after
that,
it
would
store
a
reference
to
the
sto
proxy
and
not
the
actual
service
endpoint.
So
you're
able
to
do
some
complex
sort
of
manipulations
of
the
what
at
the
very
end,
the
app
is
going
to
actually
read
by
chaining
these
plugins
together.
So.
B
I
I
do
not
think
that
there
is
any
reason
that
either
of
the
things
that
you
have
said
it
mean
that
we
have
to
add
this
to
binding.
You
can
make
another
resource,
that's
like
the
plug-in
binding
that
has
the
same
semantics
as
you've
shown
here,
but
that
doesn't
entangle
the
actual
binding
resource
in
the
binding
controller.
Does
that
get
you
to
what
you
want?
Well.
C
B
And
I
think
that's
a
small
price
to
pay
for
the
binding
resource
being
only
the
open,
serviceworker
binding,
and
you
could
do
that
work
once
in
a
plugin,
binding
type,
a
resource
and
the
controller
to
backs
it,
and
then
that
thing
could
delegate
out
to
the
plugin
mechanism
that
you
want
to
use.
So
the
other
thing
is
that
we
don't
have
a
precedent
for
this
type
of
extensibility
in
any
kubernetes
api
resource
and
I
can
I
would
bet
you
$1
that
this
is
not
something
that
would
pass
API
rate.
Okay,
that's
another
consideration.
B
D
B
D
D
Think
I'm
sure.
If
you
watched
the
demo,
I
did
with
B
Smith
I'll
put
on
a
sitting
on
top
of
a
lock
so
essentially
actually
like
the
use
case
is
similar
to
what
you
described
and
the
way
we
solve.
It
is
the
way
that
Paul
describes,
so
we
make
a
new
resource
on
top
of
winding
and
like
we
can
do
ordered
like
we
can
build
the
dependency
graph
and
whatever
else,
and
in
this
generic
way.
We
can
like
to
solve
any
use
case.
D
C
D
But
you
can
wrap
it
just
like
pull
digital
data
like
you
need
books,
binding
and
4%
4%
to
be
able
to
inject
the
credentials
into
the
port,
but
you
can
create
a
separate
resource
called
4%
binding
and
you
create
it
once
and
it
will
manage
both
objects
for
you.
So
you
can
create
only
one
object,
and
this
will
wait.
A
Isn't
it
possible
for
someone
have
to
create
a
new
resource
anyway?
You're
gonna
have
to
create
a
controller,
so
it
is
technically
possible
for
someone
to
write
a
specialized
controller
that
watches
bindings
and
then
creates
these
additional
resources
as
the
bindings
are
created
and
manipulated
right,
yeah.
B
That's
that's
exactly
what
I'm
referring
to
and,
like
honestly,
there's
really
nothing
from
stopping
somebody
to
wrapping
the
entire
resource,
although
I
would
suggest
that
would
not
be
a
fantastic
idea,
wrap
all
of
binding
and
add
additional
fields
to
it.
So
if
you
wanted
to,
you
could
just
create
one
resource,
but
I
I
will
be
honest.
Perfectly
honest
I.
B
Don't
think
that
creating
two
resources
instead
of
one
is
a
problem
provided
that
they
can
work
together
and
as
far
as
they
that
the
dependent
resource
of
the
two
can
hook
into
the
resources
lifecycle
that
has
a
dependency
on
and
I,
also
just
to
bring
this
conversation
back
to
Ada.
B
The
the
decision
plane
that
I
have
for
beta
is
that
I
want
I
think
it
would
be
in
our
best
interest
to
ensure
that
we're
concentrating
on
things
that
make
the
open,
serviceworker
API
integration
rock-solid
and
that
and
then
also
make
the
kubernetes
api
surface
really
really
good
in
terms
of
like
knobs
for
Brooker
type
settings
should
be
on
the
broker.
B
Instead
of
like
configuration
parameters
to
the
controller
stuff
like
that,
and
I
I
do
not
see
that
we
need
a
plug-in
type
mechanism
to
get
there,
I
I
wouldn't
I'll
not
make
the
same
mistake.
That
I
did
yesterday
and
say
the
word.
Never,
but
I
don't
think
it's
necessary
for
beta
and
I
think
there
are
ways
to
accomplish
like
exactly
what
you
want
to
do.
They
don't
involve
a
scope,
change
to
the
binding
resource
like
and
one
more
thing
in
my
brain
is
there
have.
B
There
has
been
some
work
done
in
another
incubator,
repoed
to
make
the
overhead
of
creating
a
new
API
server
itself
much
much
lower
I.
Don't
have
the
URL
in
front
of
me,
but
there
is
work
on
going
to
make
it
so
that
you
should
just
be
able
to
stamp
out
a
new
API
server
and
add
your
go
types
to
it
and
just
start
running
so
that
it's
like
something
that
you
can
get
to
in
an
afternoon
instead
of
something
that
takes
a
month
and
I.
B
C
B
So,
by
the
way,
we're
going
to
put
a
link
to
the
API
server
builder
in
the
chat,
and
just
so
everybody
knows
and
that's
what
it's
called
if
you're
watching
on
the
internet,
it's
cuber,
Nettie's,
incubator,
api
server,
builder
I,
fill
with
rock
who's
been
involved
with
the
sig
in
the
past
has
has
been
working
on
that
along
with
a
couple
other
people
I
think.
B
A
So
so
Mike
a
couple
questions
for
you,
I,
totally
sure
I
understand
just
from
a
straight
functional
perspective.
Are
there
aspects
to
your
proposal
that
cannot
be
done
through
the
mechanism
that
that
Paula
nail,
where
talk
about
of
creating
additional
resources
just
from
straight
functional
aspect,
just
one.
C
Think
of,
though
yeah
I
guess
the
one
aspect
is
or
it's
the
same
con
that
Paul
was
saying
is
that
the
mechanism
like
the
binding
creation,
is
tied
to
this
other
chain
of
plugins.
But
one
thing
that
gives
you
is
that
the
binding
or
I
should
say
that
the
the
I'm
not
familiar
with
the
finalize
errs
that
you
are
talking
about.
But
if
you
have
the
plugins
B
criteria
for
whether
the
binding
States
it's
in
a
ready
condition
as
opposed
to
having
I
guess
this
asynchronous
controller
watching
it's
like.
C
Oh
the
bindings
ready,
but
it's
not
really
ready
for
consumption
until
I
do
the
work
that
I
need
to
do,
but
I
guess
you
would
get
around
that
by
having
two
separate
secret.
So
you'd
have
one
that
the
that
is
just
a
store
of
raw
information
passed
back
from
the
broker
and
then
you
would
have
the
other
that
the
I
guess
consumer
would
actually
use,
and
they
would
wait
for
that
other
secret.
Or
can
you
close.
B
By
maybe
so
yeah,
that's
a
very
good
point.
Less
I
think
the
the
issue
we're
talking
about
is,
if
you
build
other
API
resources
to
characterize
your
other
integrations.
B
You
got
to
know
that
these
other
resources
that
you
may
take
in
to
represent
the
other
integrations
I've
also
become
right.
So
there
is.
That
is
one
of
the
trade.
Oh
well.
Let
me
say
there
is
definitely
a
trade-off
between
having
one
place,
to
look
and
being
able
to
reason
easily
about
the
system
and
two
to
have
to
look
at
other
resources
to
see
if
they're
ready.
B
My
my
great
fear
would
be
that
it
with
a
plug-in
type
mechanism
to
the
blinding
resource
that
it
might
become
really
impossible
to
figure
out
the
state
that
the
system
is
actually
in,
because
you
wouldn't
have
a
resource
that
you
could
look
at
about
seeing
what
state
these
other
integrations
are
in
so,
for
example,
say
that
I
say
that
you
have
a
plug-in
mechanism
to
the
binding
resource
and
you
you
do.
B
Assuming
that,
like
the
mechanism,
we're
communicating
from
plug-in
back
to
the
binding
would
allow
you
to
set
a
condition
on
the
status.
Now
you've
got
any
number
of
things
that
might
manifest
themselves
in
the
status
for
that
resource
and
different
authors
are
going
to
implement
them
at
much
different
levels
of
quality
and
I.
B
They
might
use
overloaded
terminology
that
makes
it
hard
to
figure
out
it's
kind
of
anybody's
guess
what
will
happen,
and
that's
that's
one
of
the
reasons
that
generic
plug-in
type
mechanisms
are
something
I've
found
to
be
very
difficult
to
support.
They
take
a
lot
of
care
and
I
think
that
they're
they're,
also
like
extremely
seductive
as
programmers
like
it's
easy
to
to
look
at
a
plug-in
type
mechanism
and
say:
oh,
this
is
going
to
this
is
going
to
make
things
easier
for
me.
B
They
tend
to
be
like
many
other
things,
be
it
first
really
really
hard
once
people
start
using
them
in
ways
that
you
don't
think
about,
and
one
of
the
like
I
am
I
am
all
for
people
building
other
integrations.
I
know.
A
lot
of
people
are
really
interested
in
SEO.
As
an
example,
I
think
it
will
be
in
our
best
interest
if
the
behaviors
of
individual
resources
are
really
clearly
defined
and
I
and
easy
to
reason
about
and
have
behaviors
and
implementation
quality
that
is
equal
with
a
well
behaved.
A
Paul
a
couple
things
first
I
like
to
call
time
on
this
discussion
because
we're
almost
at
45
minutes
now
and
Michael,
it
seems
like
you've,
got
a
lot
of
good
feedback
and
I
think
it's
now
sort
of
balls
in
your
court
to
decide
what
to
do
with
that
feedback,
whether
to
rework
the
idea
or
to
say
nope,
gonna
drop
it,
but
either
way.
I
think
we
should.
If
you
do
want
to
continue
the
discussion.
We
probably
should
set
up
another
call
to
discuss
that.
That
sounds
fair
yeah.
A
The
other
question
is
well
I,
just
for
the
notes
purposes.
I
wanted
to
get
a
crisper
answer
to
Michael's
question,
because
I
think
it
was
a
very
important
one
which
efficient
was
that
with
the
last
one,
the
ass,
which
is,
if
you
do
this
other
resource
model
that
people
are
advocating
as
opposed
to
the
plug-in
model.
How
does
someone
know
when
those
other
resources
are
done
with
their
job
right
had
of
the
client
know?
A
That
system
is
ready,
because
without
the
without
those
other
resources,
they
may
say:
oh,
the
secrets
they're
there
for
the
by
native
strawberryk
and
ready,
but
the
other
resources
may
not
have
been
created
and
then
their
job
yet,
and
what
I
think
I
heard
you
say
is
short
answer.
Is
there
is
no
good
mechanism
right
now
if
it
lets
the
person
whoa
those
other
mechanisms
about
those
other
resources,
yeah.
B
Let
me
let
me
give
a
very
clear
answer
to
that.
So,
if
I
build
another
resource
that
integrates
on
top
abiding,
that
resource
has
to
have
its
own
status
section
and
has
to
have
its
own
ready
condition
so
that
I
can
know
that
that
one
is
ready
to
and
if
I,
if
I
create,
if
I
as
the
user,
then
go
and
create
a
binding
and
pod
preset,
binding
or
prod
you
later
binding
I've
got
to
know
that,
like
cool
open
service
broker
bindings
ready.
B
B
A
Whole
Rob,
you
later,
okay,
got
it
all
right.
Okay,
all
right.
So
what
I'd
like
to
do
is
move
on
now.
I
in
the
notes.
I
specifically
said:
I
did
not
want
to
talk
about
specific
next
steps
for
the
pipe
reset
split
thing,
because
we
promised
people
would
give
them
a
couple
of
days
to
think
about
it.
So
I
figured
we'd
wait
until
at
least
Monday
on
a
regular
call
before
we
actually
start
talking
about
concrete
puzzles
for
what
to
do
next
or
people.
Okay
with
that,
okay.
A
So
the
next
problem
that
I
put
on
the
agenda
is
I,
thought
might
be.
Something
we
could
tackle
today
is
issue
one
zero,
zero,
eight
and
you
get
the
link
pasted
into
the
chat
on
this
is
one
the
opened
it
so
Derrick
open
this
one.
Basically,
it's
about
main
collisions
between
our
resources
and
our
communities,
I
believe
the
one
that
first
popped
up
with
finding
as
the
problem.
B
B
So
I
in
general,
by
the
way
for
the
record
when
we
chose
the
names
for
these,
we
decided
as
a
group
that
I
don't
think
anybody
thought
they
were
like
amazing
names.
But
we
didn't
want
to
spend
time
like
shedding
on
names
before
things
were
a
little
bit
more
developed,
and
basically,
everybody
had
talked
to
about.
The
naming
of
these
resources
has
said
that
they're
terrible
I,
think
instance
and
binding
certainly
should
be
renamed
and
by
the
way,
just
for
the
record.
B
B
Yeah,
so
the
binding
resource
is
a
very
simple
resource
that
the
scheduler
uses
to
assign
a
pod
to
a
particular
node.
So
the
binding
resource
has
like
the
name
of
the
pod
and
the
node
that
it
should
be
on,
and
the
API
server
like
mutates
a
pod
when
a
binding
is
created.
Now,
if,
if
we
were
building
this
system
today,
there
would
just
be
a
binding
sub
resource
on
pod,
and
if
we
ever
have
a
b2
pod
API,
probably
there
will
not
be
a
distinct
binding
resource.
F
B
B
F
B
And
what
you
can
do
is
you
can
actually
use
the
fully
qualified
name
to
address
the
resource
and
then
it
works,
but
yeah
I
think
that
we
should
consider
renaming
it
and
the
feedback
that
I've
gotten
about
instance.
Is
that
no
one
knows
what
an
instance
is
so
I
think
now
we're
in
the
enviable
position
of
having
something
mature
enough,
where
it's
probably
right
and
good
to
think
about
what
the?
What
the
best
means
that
we
can
come
up
with
our
for
I
definitely
think
this
stuff
must
have
four
beta.
So.
A
So
there's
a
proposal
in
the
issue
that
I
put
in
there
to
prefix
all
of
our
stuff,
with
the
word
service
nail
suggested,
perhaps
Service,
Catalog
and
technically
I
person
allocated
either
one.
My
only
concern
was
I
thought.
Service
Catalog
might
make
things
kind
of
verbose,
but
at
least
is
very
clear.
Yeah.
A
Me
just
finish
my
thought,
sure
sorry
I
thought
you
were
done.
No,
what
I
would
like
to
suggest,
though,
is
we
come
up
with
a
constant
they
with
a
prefix
and
use
it
on
all
of
our
resources,
not
just
some
of
them,
because
I
think
consistency
is
very
important
here.
So
I
was
wondering
we
can
least
get
agreement
that
we
will
prefix
all
our
resources
with
the
same
thing
and
then
we
can
bike
shed
on
the
right
prefix.
B
Not
sure
that
we
necessarily
need
a
prefix,
it
might
wind
up
depending
on
the
prefix
in
might
stutter
and
resource
names.
I,
definitely
think
that
we
should,
on
a
case,
resource
by
resource
basis.
Ask
ourselves
what
the
best
name
for
all
these
resources
is
since
and
I
think
that
we
have
issues
are
scoped
to
be
like
rename
binding
rename
instance.
B
A
So
Paul
I
didn't
follow
what
you
said
there
you
seemed
like
you
were.
You
were
not
necessarily
in
favor
of
using
the
same
prefix
for
all
of
our
resources.
Yes,
because
it's
because
of
some
potential
conflict
key.
Can
you
look
at
the
proposal
that
I
put
in
there?
I
gave
a
very
concrete
list
of
what
changes
and
what
doesn't
change
based
on
the
proposal.
Just
using
the
word
service
I'd
like
to
understand
where
you
see
a
potential
problem
with
that
yeah.
B
B
A
A
C
B
C
A
So
the
list
here
seems
fairly
straightforward
to
me,
like
I,
said
I.
Think
the
only
problem
with
just
the
word
service
is:
if
someone
else
decides
hey
they,
like
the
word
service
too,
so
that
point
maybe
service
color
will
be
better,
but
otherwise
I
did
I,
didn't
see
anything
obvious
in
here.
That
was
going
to
be
like
a
name
conflict
just
by
the
single
name
itself.
Well,.
D
D
D
A
C
E
Somebody
is
there
a
I'm
wondering
if
this
is
going
to
be
a
more
general
problem
in
kubernetes.
Like
is,
it
seems,
like
a
you
know,
it's
the
it's.
The
name
spacing
problem
right.
We
have
very
succinct
names
that
are
namespace
somehow
and
and
other
people
who
are
incubators
or
whatnot
will
have
this
exact
same
problem.
It's
like
this.
Is
there
something
we
can
push
there,
that
that
will
help
us
do
this
or
because
I'm
looking
at
this
list,
I
like
service
I,
think
I.
E
B
B
A
Think
it
might
be
beneficial
to
try
to
focus
on
a
consistent
prefix,
because
I
think
I
heard
enough.
People
say
that
they'd,
like
the
consistency
factor
so
rather
than
looking
at
each
one
individually.
If
we
can
brainstorm
around
possible
prefixes,
there
have
been
quite
a
few
there
than
listed
in
the
chat,
SVC
cat
OSB
api,
those
kind
of
things
they
just
see.
If
there's
one
that
jumps
out
of
people
as
a
potential
for
a
way
forward,
we.
B
B
There's
an
actual
github
team
that
can
help
us
make
these
naming
decisions
just
just
to
call
it
out
that,
like
we
can
decide
all
we
want
and
then
our
decision
will
mean
nothing
if
API
review
doesn't
like
I
understand.
A
But
I
think
I'm
hearing
enough
people
say
they
want
us
to
leave,
try
if
we
can
to
come
up
with
a
consistent,
prefix
and
understand.
We
understand
that
they
may
get
shot
down,
get
get
shot
down
later,
but
look
I
think
it's
be
beneficial
to
make
forward
progress
here
to
just
even
come
up
with
a
strong,
a
proposal
for
what
that
prefix
a
day.
A
F
A
F
A
A
F
The
problem
yeah,
we
need
to
do
that,
but
the
problem
is
that
we're
colliding
with
the
the
core
resource
and
us
making
a
bunch
of
names
that
don't
happen
to
collide
right
now
is
not
a
permanent
solution.
But
if
we're
worried
about
this
binding,
specifically
thing,
let's
just
prefix
everything
right
now
get
it
out
of
the
way
and
yeah
get
the
API
meeting
as
soon
as
possible.
F
E
B
Well,
there
is
namespacing,
like
the
the
api
group
is
part
of
the
fully
qualified
name
like
the
resource
by
the
way,
I
have
a
hard
stop
like
right
now,
so
maybe
we
can
continue
this
conversation
on
slack
short,
okay.
That
sounds
like
alright.
Well,
thanks
thanks
for
joining
everybody,
this
was
another
good
one.
Everybody
have
a
good
afternoon
or
morning
and
I
will
talk
to
you
all
on
the
Internet
bye,
bye
I
was
waiting,
but
I
was
off-camera.
Bye.