►
From YouTube: SIG Cluster Lifecycle - Cluster Addons 20190611
A
B
We're
talking
about
yes,
wonderful,
so
leave
feel
free
to
chime
in
wherever
I
misrepresent
it
or
whatever
the
there
are
two
open
PRS.
We
I
think
today,
we've
been
encouraging
people
to
submit
ideas
or
proposals
for
Froman
proposals
for
how
the
item
operators
or
how
management
should
actually
work.
We
have
to
PRS
that
are
up
there.
They,
as
we've
discussed
in
previous
weeks,
they're,
actually
not
really
that
different,
both
of
them
use
operators,
one
of
them,
uses
the
operator
SDK.
One
of
them
uses
coop
builder,
both
of
them
build
on
the
underlying
controller
runtime
library.
B
B
We
know
we
have
a
lot
of
things
like
in
these
doc
that
we
want
to
talk
about
and
discuss
and
prototype,
and
so
we
feel
like
some
code
would
be.
You
could
way
forwards,
and
this
does
not
preclude
anyone
that
has
a
genius
idea
from
proposing
aid
yet
another.
We
are
just
a
way
to
sort
of
move
forwards
and
start.
B
C
Yeah
we
we
had
some
discussion
on
quite
a
few
interesting
points
once
we
were
beyond
like
okay,
let's
merge
the
operator
thing
and
let's
submit
some
patches
to
just
get
in
the
right
place
which,
by
the
way,
I
think
Jeff
was
it
that
had
the
patch
for
coop
CTL
or
like
kind
of
customized
style
patch
support.
We
talked
a
lot
about
how
we
can
get
some
of
these
higher
order
needs
for
add-on
management
like
beyond
what
we
have,
which
is
just
applying
llamó
files
to
the
cluster.
C
C
But
then
you
know
use
whatever
code
to
modify
those
declare.
Those
declarations
from
the
customized
packages,
such
as
in
the
case
that
you
would
need
to
do
record
EMS
and
then
the
other
thing
we
mentioned
was
an
idea
that
a
lot
of
people
independently
came
up
with
and
one
that
I
think
we're
all
really
starting
to
like,
which
is
that
building
into
our
the
pattern
that
justin
has
been
working
on,
and
this
is
applicable
to
anybody's
pocs
as
well,
is
just
having
an
early
exit
convergence
for
the
operators
that
are
responsible
for
installing
things.
C
It
gives
us
a
binary,
that's
not
just
going
to
like
need
to
sit
around
for
forever,
but
also
can
be
applied
for
low
resource
use
cases
like
arm
clusters
and
things
where
you
don't
want.
You
know
something
eating
up:
CPU
cycles,
you
know
checking
on
what
it
installed
and
you're
only
concerned
about
enforcing
that
a
cluster
lifecycle,
so
that
in
the
add-on
management
document
is
called
the
ad-hoc
runtime
use
case,
and
we
many
people
have
commented
that
it's
possible
to
retrofit,
that
behavior
onto
existing
operators
to
where
they
could
timeout.
C
C
C
Well,
I
mean
I
think
that
it
would
be
a
more
a
in
line
with
the
same
deployment
pattern
like
it's.
It's
a
more
similar
abstraction
to
just
use
a
job
with
the
early
exits,
like
that's
very
similar
to
using
a
deployment,
it's
actually
deploying
the
operator
and
then
the
client
side
code
could
then
determine
hey
this
job
exited
properly
within
the
necessary
period
like.
Let
me
just
clean
up
the
are
back
temporary
for
it.
Okay,
so
the
service
account
would
be
temporary,
pulled
out.
C
D
The
perspective
of
assessing
a
concern,
but
it's
it's
I
think,
is
a
separate,
separate
matter
on
the
you
know
eath
yeah
anyway,
but,
like
broadly,
it
sounds
like
a
good
idea
to
to
keep
going
forward.
It's
just
that
doesn't
just
mean
I'm,
not
entirely
convinced
it
has
to
to
run
as
a
job
inside
the
cluster
at
all.
It
seems
like
a
a
an
unnecessary
layer,
current
direction,
but
I
think.
B
She's
fighting
to
me
is
that
we
we
think
that
the
same
like
basic
code
pattern,
can
be
like
sliced
in
different
ways.
So,
like
some
people,
my
bias
is
I
want
to
run
it
continuously
because
I
want
to
say
this
monitoring
I
think
the
least,
as
I
was
two
months
run
to
this
job
and
I.
Think
you're
saying
you
want
to
run
it
outside
the
cluster
and
I
I
think
that
we
might
build.
You
have
the
same
like
core
body
of
code.
That
actually,
you
know,
is
wrapped
in
different
yeah.
D
Yes,
yeah
I
absolutely
agree
on
that
part.
It's
just
did
I
eat
yeah
of
it.
Would
you
Shella
to
that
binary?
One,
no
I
mean
it
could
be
anything
really
I
mean
personally
from
akia's
control
perspective
I
mean
they.
Don't
particularly
carry
this
stage,
so
it
could
be
to
be
anything
really.
It's
it's
not
of
a
particular
concern
as
such
right
but
like
we
can
discuss
separately
anyway
for
specifics
of
media's
control.
I.
D
Think
I
think
we
shouldn't
have
to
worry
about
the
fact
of
whether
the
consumer
should
whether
whether
the
consumer
needs
to
shell
out
a
call
as
a
library
vendor
a
role
or
whatever
I,
don't
think
it
needs
to
be
discussed
at
this
stage.
It
seems
like
implementation
detail
that
that
is
less
turbulent
overall
architecture.
D
D
D
Think
I
mean
he'd,
probably
be
fine
for
his
control
project.
You
know
it's
yeah,
I,
think
I.
Think
it's
important
at
this
stage
to
make
progress
towards
towards
the
towards
something
that
satisfies
broad
use,
cases
and
particular
details
of
how
it's
being
consumed
downstream
is
a
either
set
for
each
other
cool.
D
Contextual
part
time
is
important
that
they
should
be
able
to
to
run
as
a
theme
that
just
does
a
job
and
goes
away
and
doesn't
sit
around,
doesn't
doesn't
have
our
back
implications
and
all
those
things
to
itself.
So
we
don't
end
up
with
a
Taylor
problem,
which
you
know
the
hell.
People
haven't
quite
solved
yet
yet
as
in
maybe
they
did.
C
I've
been
really
emphasizing
on
all
of
the
needs
like
having
operators
that
install
things
doesn't
solve
the
problem
of
needing
to
install
and
configure
the
operators
writing
on
installing,
unlike
the
packaging
portion
and
the
mechanisms
by
which
the
installers
like
Covidien
Copsey,
kiss
cuddle,
coop
spray
like
how
they
get
those
things
into
the
cluster
in
a
configured
and
versioned
way.
I.
C
Think
if
you
solve
that
problem,
then
people
can
decide
whether
or
not
their
thing
needs
an
operator,
because
there
are
certainly
like
I
could
I
could
see
us
distributing
we've
met
in
a
way
where
we
were
only
using
customized
and
overlays
I.
Don't
I,
don't
think
that
that
needs
an
operator
component
in
there
necessarily,
but
we
should
try
it
right.
We
should
see
what,
like
there
may
be,
some
cluster
specific
things
since
networking
component,
where
it
needs
subnets
or
something
but
yeah
or
like
DNS,
introspection
or
whatever.
But
it.
D
C
C
That's
it
kind
of
becomes
tricky
right,
because
no,
you
have
to
use
a
special
teacher
yeah
that
is
dedicated
to
to
certain
the
use
cases,
so
it
might
be
easier
right
to
like
have
an
operator
or
it
might
be
possible
to
use
with
just
customize
and
that's
kind
of
what
I
was
highlighting.
Is
that
like,
when
you
were
talking
about
having
that
extra
piece
of
software
that
has
extra
privileges
that
needs
to
run
somewhere?
C
So,
with
regards
to
the
early
exit
discussion,
we
is
having
that
software
not
running
all
the
time
as
an
option
and
also
just
not
even
meeting
it
and
still
being
able
to
benefit
from
the
packaging
was
built
in
mind
and
the
tooling
and
the
libraries
around
that
that
exposed
those
component
configs
to
the
user
of
the
Installer
I
think
we
can
get
to
a
healthy
place
where
this
like.
We
actually
have
an
ecosystem
and
recommendations
that
we
can
point
people
to
Justin.
Are
you
following
with
what
I'm
saying.
B
B
And
one
of
the
things
I
guess
is
like,
but
I
feel
like.
Eventually,
we
want
we've
specifically,
for
example,
to
have
a
CRD
that
does
fit,
is
versioned
and
describes
its
configuration,
and
today
an
operator
would
be
the
thing
that
translates
that
to
to
we've,
maybe
in
a
future
world
we've
got
it
self
consume
the
CRD,
yeah
and
I.
D
C
Am
also
I
think
that
CR
DS
in
specificity
are
a
trade
off
like
reducing
the
reducing
the
complexity
of
an
application
into
something.
That's
specific,
for
it
is,
can
be
a
very
helpful
abstraction
yeah,
not
like
the
other
objects
that
are
necessary
to
run.
The
thing
are
not
in
respectable,
but
like
sometimes
just
as
like
somebody
who
operates
a
cluster.
You
just
like
just
show
me
the
secrets
right,
so
it
does
complicate
our
back
so.
B
Well,
I,
guess
the
challenge
is
what
happens
win
enough
when
administer?
He
goes
and
makes
a
different
sort
of
change
behind
the
scenes,
and
how
do
you
reconcile
sort
of
the
two
intents
which
is
I
guess
so
a
continuously
operating
running
operator
is
a
way
to
effectively
say
once
you
make
a
change,
it
effectively
gets
immediately
reverted
or
or
we
have
a
web
hook
that
prevents
that
change
entirely.
B
C
C
C
B
C
B
I
think
it's
certainly
technically
possible
right
to
run
that
validation
and
I.
Imagine
that
yeah.
It
would
be
great
if
we
can
do
that
one
day,
but
it
is
also
a
fairly
niche
niche.
It's
a
because
I'm
sure
everyone
well
I'm
sure
I
will
do
it
many
times,
but
it
is.
It
is
not
the
end
of
the
world
so
like
half
garbage
in
garbage
out
type
semantics,
yeah.
C
C
C
So
we
do
have
phases
right
now
that
like
kind
of
just
are
concerned
with
those
bits
and
so
I
think
those
would
naturally
change
up,
and
we
would
start
with
an
alpha
alpha
phase
set,
doesn't
sound
like
there's
too
much
concern
there,
but
later
with
garbage
in
garbage
out
like
or
if
you
want
to
add
or
remove
an
add-on.
C
That's
a
that's!
Definitely
something
where,
like
I
want
to
run
the
tool
again
and
like
have
it
do
the
packaging
again
and
have
it
like
implicate
them
into
the
cluster
again
and
like
to
diffs
and
stuff.
So
the
could
CTL
apply.
Shell
out
makes
a
lot
of
sense
there,
but
just
making
sure
that
it's
executable
for
the
user
over
and
over
again,
it's
gonna
be
something
that
like
as
soon
as
there
is
garbage
like
people
are
gonna
run
that
thing
10
times.
C
C
Okay,
cool
over
30
minutes
and
we've
talked
about
plenty
and
I.
Don't
have
much
dad
here.
I
think
that
we
would
like
to
get
some
POCs
working
and
then,
with
kind
of
a
medium
term
goal
to
also
have
implementable
kept
just
for
some
of
these
finer
details
that
might
just
be
a
patch
to
the
existing
one,
but
we're
currently
in
provisional
I
think
on
the
Hat
on
skep.
So
we
should
probably
go
through
that
process.
C
Think,
like
the
verbage
is
literally
the
approvers
say
it's
good,
which
I
mean
as
far
as
the
cap
goes,
and
with
regard
to
what
we're
talking
about.
We
have
like
way
more
concrete
details
now,
so
we
should
write
those
down,
so
people
can
criticize
them
in
a
different
forum.
That's
I!
Guess
not!
This
call
and
yeah
I
mean
it
from
what
we've
kind
of
chatted
about
and
described,
and
a
lot
of
the
issues
and
trade-offs
that
we've
discussed
like
this
packaging
solution
using
these
operators
with
these
encouragement.
C
You
know
with
regard
to
coop
Gilder
and
this
pattern
that
that
all
sounds
like
very
concrete,
implementable
details
so
and
then
there's
like
other
states
as
well
like
you
can
like
reject
and
deprecated
caps
and
stuff
so
again,
just
saying
aloud
and
on
a
recording
that
us
going
to
an
implementable,
kept
and
making
these
decisions
and
doesn't
prevent
anybody
from
proposing
other
stuff.
Please
we'd
like
to
hear
your
ideas.
A
B
Think
that's
the
long
term
go
I'm
a
little
bit
wary
of
saying
like
this
is
a
known
good
way
until
we've.
But
this
is
the
way
I
think
Weaver.
As
far
as
I
interpret
the
call,
we
have
agreed
that
we
are
going
to
explore
that
option
and
we
are
going
to
try
to
prove
that
as
a
known
good
way
and
addresses
like
the
different
wrappings
around
that
code,
like
a
job,
a
low
running
operator
and
a
external
one
of
the
three
that
we've
seen
and
I.
C
A
C
A
C
My
are
merged
justin's
could
builder
operator.
I
submit
some
of
the
differences
to
that
operator
to
clean
up
any
bugs
and
style
things
get
patched
support
into.
It,
build
a
proof
of
concept
for
using
coop
CTL
with
customize
and
some
configuration
to
install
add-ons.
So
that's
one,
that's
a
bigger
task
and
then
describe
the
approach
in
an
implementable
kept
that
can
then
be
reviewed
and
hopefully
approved
by
whoever's
on
the
approve.
Your
list.
B
A
Yeah
the
question
about
complete
next
steps
and
well,
we
helped
because
in
the
first
call
we
had
around
5060
people
and
I
think
it,
and
they
all
seem
to
have
like
a
use
case
for
this.
So
I
guess
we
shout
to
them
and
saying
like
okay.
This
is
that
we
already
agreed
on
here's
a
bunch
of
things.
Do
you
want
to
get
involved
and
give
us
your
feedback?
I?
Think
that
would
you
know
speed
up
the
process,
maybe
a
little
bit,
and
it
wouldn't
be
just
you
know,
Lee,
just
if.
C
Somebody
is
interested
in
doing
like
some
OCI
packaging
stuff
with
customize.
That
could
be
a
huge
area
of
help.
I
think
that,
like
that's
kind
of
a
a
major
missing
point
of
that
implementation,
is
that
there
is
no
standard
packaging
around
customized
at
the
moment
beyond
get,
and
it
has
a
lot
of
useful
and
flexible
features
that
I
would
argue
we
should
keep
around,
but
I
think
a
lot
of
people
working
in
an
enterprise
scenario
like
would
scoff
using
it
for
packaging
because
they
want.
C
You
know,
cryptographic,
verification
and
like
of
like
this,
the
source
of
things
the
provenance
of
there
is
that
the
fancy
word
that
people
use
artifact,
provenance
and
yeah,
and
then
there's
like
some
cluster
bundle
working
there
as
well,
that
we
chatted
it
out,
like
potentially
being
able
to
package
up
a
some
customized
inside
of
a
cluster
bundle.
C
B
E
Was
just
gonna
add
one
thing:
this
is
kind
of
unrelated,
but
since
you
guys
were
looking
at
a
queue
builder
versus
operator,
SDK,
so
I'm
the
operator
rest
of
Kaylee,
so
I
think
I
mentioned
this
last
time.
But
I
can't
remember.
We
started
conversation
with
the
acute
builder
maintainer
and
controller
runtime
to
figure
out
how
we
might
want
to
go
about
down
streaming
queue
builder
into
operator
SDK.
So
we're
gonna,
there's
another
conversation
tomorrow
at
the
Q
builder
community
meeting,
so
I
just
wanted
to.
E
C
You
can
wrap
all
that
stuff
in
and
then
the
community
can
get
the
benefits
of
operator
SDK
for
like
operators,
and
they
basically
look
the
same.
But
then
you
can
get
like
the
metric
stuff.
You
can
get
any
of
the
like
specific
benefits.
There,
then
even
the
tooling
and
UX.
That
sounds
really
wonderful.
Yeah.
E
The
big
thing
we're
going
for
is
really
you
know
a
lot
of
the
upstream
work
that
that
we
haven't
had
time
to
work
on
or
or
basically
also
include
and
develop
in
parallel,
it's
much
easier
just
to
be
able
to
leverage.
What's
already
been
done,
so
that's
kind
of
the
idea
that
we
had
so
we'll
be
able
to
contribute
more
upstream
and
then
we'll
be
able
to
work
more
on
some
of
our
value-added
features
like
the
metrics
and
the
danceable
and
helm
operators,
and
some
of
the
OLM
integrations
that
kind
of
thing.
E
C
That
sounds
really
great.
Do
you
know
when
that
meeting
is
it's
I'll.
E
E
C
If
nobody
else
has
anything
that
they
want
to
bring
up,
I
mean
we've
pretty
much
run
to
the
end
of
our
agenda
and
we're
not
just
kind
of
discussing
different
ideas.
It
sounds
like
we've
kind
of
shared
a
rough
plan
of
some
concrete
steps
that
are
necessary
next
and
yeah.
We'll
keep
working
on
some
things
did
we
do
we
want
to
talk
about
a
timeline
for
the
installation
POC?
When
would
people
like
to
see
that
who
wants
to
work
on
it?
B
C
C
B
B
C
I
that
was
created
rather
recently
right,
because
I
didn't
see
that
in
the
add-ons
repo.
Until
recently,
it's
a
beginning
of
the
year.
C
B
Like
a
lot
of
particularly
on
one
cloud,
which
is
not
the
one
I
work
for,
there
are
a
lot
of
DNS
issues
reported
and
the
fix
that
most
people
have
come
up
with.
There
are
a
lot
of
people
doing
a
lot
of
like
investigations
into
a
bunch
of
things
at
kernel
versions
and
always,
and
that
contract
issues
all
these
sort
of
things,
but
essentially
the
one
solution
that
seems
to
fix
everyone's
issues
is
to
run
some
form
of
local
agent,
and
so
that
was
what,
from
today,.
C
Yeah
I
also
recall
somebody
did
a
talk
about
like
using
TCP
versus
UDP
that
there's
probably
some
of
that
in
there
yeah.
B
It
turns
out
it's
like
four
or
five
different
things
that
or
it
seems
like
it's
four
or
five
different
things.
There's
kernel
issues,
there's
contract
issues,
there's
TCP
versus
UDP,
there's
the
behavior
of
the
clouds
when
it
comes
to
UDP
versus
TCP,
there's
DNS
retries,
all
these
things
sort
of
compound,
and
it's
just
like
oh
yeah,
you
could
just
like
just
run
the
local
agent
and
this.