►
From YouTube: Operator Framework SIG 2020 03 17 Full Meeting Recording
Description
Operator Framework SIG 2020 03 17 Full Meeting Recording
B
C
I've
got
a
quick
updates,
so
things
have
been
progressing
well,
a
little.
The
three
things:
I
wanna
talk
about
some
new
website
work
that
we're
working
on
the
CN,
CF
donation
status
and
then
some
updates
to
the
capability
model.
So
I'll
start
with
the
first
one,
so
we're
purchasing
domain
names
and
we'll
have
we're
planning
websites
for
each
of
the
community
projects,
so
the
SDK,
OLM
and
operator
hub,
you
know
already-
has
its
own
website
but
filling
out
some
more
information
about
that,
as
well
as
an
overall
wrapper
project
or
homepage.
C
That
has
information
about
things
like
just
what
is
an
operator?
What
do
we
think
the
definition
of
an
operator
is?
Why
are
these
important?
Who
are
the
types
of
people
that
are
using
operators
that
are
making
operators
all
that
type
of
stuff,
so
those
are
underway?
We're
hoping
to
get
that
done?
Hopefully,
it
doesn't
really
matter
before
the
CN
CF
donation,
but
it's
just
like
then
we'll
have
a
web
presence
when
we,
you
know
unveil
this
to
the
world
and
all
that
kind
of
stuff.
So
I
wanted
to
show
up
a
really
quick
this.
B
C
Is
a
really
quick
in
progress
kind
of
dev
site
for
this,
but
you
can
see
operator
framework.
This
is
like
kind
of
the
main
landing
page.
What's
in
it,
you
know
all
the
different
steps
that
you
do
to
build
an
operator.
What
is
an
operator
things
like
that
and
then
we're
gonna
keep
working
on
these.
What
and
why
pages,
which
are
you
know?
What
does
an
operator,
how
do
I
start
building
one
who's,
building
them,
etc?.
E
C
C
Alright,
the
next
update
was
around
the
CN
CF
donation,
so
there's
been
progress,
as
always.
I
feel
like
I,
have
the
same
update
here,
but
the
main
point
of
contention
was
around.
If
you
haven't
heard
that
there
was
a
project
proposed
and
kind
of,
not
necessarily
following
the
guidelines
at
the
CN
CF
for
a
CN
CF
wide
hub.
C
If
it
as
long
as
it
makes
sense-
and
you
know
we
don't
lose
some
of
the
things
that
are
important
to
us,
like
you
know,
we
do
human
curation
for
operator
hub
as
part
of
a
holistic
process,
with
some
automation
as
well.
We
think
that's
important
because
operators
they
float
through
our
capability
model,
it's
really
important,
that
they
adhere
to
those
guidelines
and
that
the
the
grading
that
they
have
is
actually
accurate
and
said.
We
would
love
to
be
fully
automated,
but
then
you
know
there
is
a
human
in
loop
right
now.
D
Yeah,
they
convinced
read
the
other
project
to
be
open,
because
it
was
really
bad
form
that
that
other
project
would
quote
unquote
behind
closed
doors
or
whatever
you
want
to
call
it.
I
commented
other
people's
commented
that
they
just
that.
You
know
that
come
on
now
with
the
CNC
F,
that's
not
how
we
do
things
yeah,
so
they
kind
of
acknowledge
yeah.
C
So
it's
open
now,
and
one
of
the
main
things
that
was
talked
about
was
just
the
fact
that
it
was
at
hub
at
CNC,
F
dot.
Io
was
just
like
look
like.
It
was
more
of
a
vote
of
confidence
or
like
signal
that
this
thing
was
more
mature
than
it
was
whatever
so
we're
they're
gonna
move
that
off
to
another
test
domain
and
so
we're
making
all
the
right
tweaks
and
the
code
is
now
public
and
the
the
charter.
Whatever
you
want
to
call.
C
D
C
All
right
so
I've
mentioned
a
few
times
about
this
update
to
the
capability
model
and
I
know.
Daniel
was
the
one
that
worked
through
a
lot
of
that
and
so
I'm
gonna
hand
it
over
to
him
to
walk
you
through
that.
A
bunch
of
great
updates
I,
don't
think
nothing
meaningfully
changes
with
the
capability
model
itself.
So
don't
don't
be
worried,
but
there's
just
a
bunch
of
added
additional
info
to
help
folks
think
about
it
over
to
you,
Daniel
I,.
G
For
that,
so
we
have
heard
multiple
times
that
this
particular
topic
of
the
capability
models
needs
more
meat
to
the
bone.
In
terms
of
what
does
it
actually
mean
to
be
level,
three,
four
and
five
right,
so
we've
taken
a
stab
at
that
based
on
some
documents
that
were
internally
grown
and
have
gathered
over
time.
So
it's
here
in
the
dogs
section
of
the
operator
SDK,
and
you
have
the
operator
capabilities
document
here.
So
essentially,
what
we've
done
is
we've
described.
What
we
think
is
the
criteria
for
each
level.
G
G
What
are
examples
for
operators
and
their
features
at
this
stage,
and
what
are
some
guiding
questions
for
you
as
a
operator
developer,
of
course,
to
be
asking
yourself?
What
could
my
is
my
operator
level
1?
What
does
it
need
to
do?
In
addition?
What
it's
doing
today
in
order
to
become
level
3
or
4
and
5
right
so
I
won't
go
through
all
of
this
here,
but
we
really
wanted
to
point
out
that
this
is
something
that
is
obviously
open
to
collaboration
right.
G
That's
why
it's
on
github,
so
we're
looking
forward
to
your
PRS
and
issues
on
this
there's,
also
a
mock-up
of
how
this
will
look
like
on
the
framework
side.
So
this
will
also
be
consumable
and
a
nice
visual
form
on
operator
framework
tile,
and
this
is
really
not
you
know,
set
in
stone
or
us
making
the
rules.
This
is
really
about
creating
some
aspirations
right.
G
What
you
operator
should
ideally
be
capable
of
right,
and
we
see
a
lot
of
operators
out
there
that
there
are
basically
just
you
know,
deploying
some
of
the
resources
and
then
they're
kind
of
done
right,
and
we
specifically
call
this
out
to
be
level
1
and
there's
a
reason.
Why
there's
you
know
no,
no
for
other
levels,
and
you
should
be
gradually
reaching
and
growing
to
reach
those
just
to
give
you
opportunities
right.
G
G
You
had
the
idea
of
Winston's
adding
the
ability
to
omit
service
events,
as
you
know
another
for
another
five
that
could
be
really
interesting
in
order
to
make
you
operate
a
more
useful
in
an
environment
where
K
native
is
available,
so
your
operator
would
basically
trigger
K
native
Facebook
notes
as
well,
based
on
event
that
it
emits.
So
these
are
a
couple
of
ideas.
They're
looking
for
more
of
those
so
feel
free
to
raise
PRS
against
this
discussed
is
in
issue
section
challenges
on
this,
but
keep
in
mind.
C
Yeah
and
I
think
one
of
the
things
that
we've
heard
pretty
loud
and
clear
is
that
the
capabilities
were
they
were
intentionally
supposed
to
be
vague
because,
like
not,
everything
applies
to
your
application
or
whatever.
But
hopefully
this
is
still
is
less
vague,
but
still,
as
is
agnostic
to
applications
as
it
was
intended
to
be
so
you'll
see
a
bunch
of
sample
questions
here
and
obviously
transform
that
in
your
mind
to
you
know
something
that
applies
to
you,
but
hopefully
this
flushes
it
out
a
little
bit
more
and
like
Daniel,
said
we'd
love
your
feedback.
H
You
have
a
question:
if
that's
okay
take
a
second
yeah
I
love.
This
I've
been
thinking
all
along
these
lines
for
some
time,
but
this
level
seem
to
be
my
op
and
say
myopic,
but
they
seem
to
be
isolated,
maybe
to
an
operator
and
I
realize
this
is
about
operators,
but
I
almost
feel
like
there's
a
level
maturity
that
goes
outside
of
operators.
H
C
E
H
C
G
Quickly
wanted
to
provide
the
additional
pointer
to
the
best
practice
document
that
we
also
have
and
the
same
github
work,
but
in
a
different
repository
or
the
community
operators.
Actually,
so
we
had
us
on
a
block
up
last
week
as
well.
So
that's
where
we
gather
just
kind
of
you
know
general
best
practice
level,
information
about
development,
best
practices
as
well
as
runtime
behavioral,
best
practices.
So
maybe
some
of
that
ends
up
being
there.
I
just
want
to
quickly
highlight
that
this
exists
as
well
and
could
also
be
a
potentially
subject
to
contributions.
C
F
Hello,
my
name
is
David
ager
and
I've
been
seeing
a
lot
of
questions
about,
like
writing.
Idiomatic
reconcile
functions
and
I
was
wondering
if
that
was
something
you
guys
have
considered
like.
What
reconcile
functions
are
supposed
to
look
like
I
haven't
seen
anything
to
point
people
to
and
it
it
seemed
it's
a
hard
question
that
I,
like
answer
off
off
the
cuff.
F
Don't
know
yeah
the
specific
questions.
I've
seen
have
been
specific
to
go
base
operators
and
do
builder
based
projects
and
those
kinds
of
things,
but
it
it
just
opened
up
the
question
for
me
like
what
would
the
recommendation
be
for
an
idiot
like
what
would
that
even
look
like
I
seem
like
a
hard
question
to
answer
because
is
pretty
dependent
on
what
you're
doing
but
figure
that
should
ask
this.
I
I
Things
that
you
shouldn't
do
because
I'm
wondering
if
things
that
you
should
do
is
or
that
you
could
do
that
would
be
fine,
is
too
large
of
a
space
but
stuff
that
we
know
can
cause.
Problems
seems
like
a
space
that
we
have
some
knowledge
of
today,
I'm
wondering
if
maybe
that
helps
narrow
down
what
we
tell
people
like
not
to
do
like
these
are
things
that
would
go
poorly.
I
F
The
I
think
I've
seen
it
a
handful
of
times
in
the
past
week
or
so,
and
it's
been
pretty
open-ended,
I'm
new
to
writing
operators
and
I
want
to
write
it
idiomatically.
What
does
that
look
like,
but
I
do
think
you
are
right
that
thing
trying
to
answer
that
question
might
be
more
difficult
than
just
saying:
here's,
the
pretty
short
list
of
things
you
shouldn't
do.
C
H
I
think
some
of
the
struggle
might
be
that
the
advice
you
would
give
is
already
based
on
certain
assumptions.
Right
like
you
should
never
pull.
The
api
rapidly
poll
would
be
a
bad
idea,
which
means
you're
going
to
move
towards
probably
a
caching
mechanism
and
watch
and
then
based
on
that
there's
approaches
of
how
you
would
use
those
things
that
are
somewhat
idiomatic
within
that
space.
I
We
probably
start
with
the
assumption
that
people
are
using
control
or
runtime
at
least
right,
and
that
the
caching
mechanism
should
be
an
obvious
thing
to
do
with
the
cache
and
how
you
watch
and
everything
else
should
be
encapsulated
in
the
library
functions
that
we've
written.
Do
you
think
that's
not
a
safe
assumption,
I
think
it's.
J
Think
if
you
use
that
as
the
assumption
and
you
document
the
best
practices
based
on
that
assumption,
that
at
least
gives
people
a
place
to
go,
look
to
see
like
well,
what
is
controller
runtime
doing
and
what
are
the
best
practices
that
you
get
based
on
that
assumption,
and
so
people
that
you
know
are
writing
a
Python
operator,
for
instance,
can
at
least
go
and
look
at
controller
runtime
and
be
like
okay.
I
need
a
cash
I
need
here's,
how
they've
structured
their
reconciler
interface
all
of
that
kind
of
stuff.
J
Like
people
will
say
you
know,
I'm
getting
a
request
in
to
my
reconciler,
but
I
really
want
to
get
every
single
event
and
we
always
have
to
go
back
and
say.
Well,
no,
you
don't
really
want
to
see
every
single
a
bit
and
here's.
Why
and
we
link
them
over
to
the
controller
runtime
documentation
FAQ
about
why
doing
like
a
bit
based
diff
like
people
are
like
I
want
to
get
a
diff
between
what
my
CR
used
to
look
like
and
what
it
looks
like
now,
so
that
I
can
know
what
to
change
or
well.
J
No,
you
don't
really
want
to
do
because
you
might
see
you
might
not
get
every
single
event
or
you
events
might
be
coalesced
and
that
kind
of
stuff,
so
so
I
think
the
one
thing
I
would
say
is
you're.
Just
looking
at
current
state
new
see
our
state
and
applying
the
new.
You
always
want
to
make
your
cluster
state
and
look
like
what
your
CR
said.
It
should
look
like
every
single
time
you
reconcile.
H
Yeah
and
I
I
love
it
and
then
and
then
but
then,
as
you
get
into
the
more
of
the
details,
you
start
getting
into.
What's
the
difference
between
a
revision
versus
a
generation
and
what
are
you
paying
attention
to
and
how
do
you
yeah?
Why
is
one
worth
watching
versus
another,
so
I
but
I
love,
I,
love
the
assumption
of
control
of
runtime
as
its
the
guiding
function.
K
I
think
where
I've
seen
some
people
struggle
is
yeah
as
Joe
is
describing
you're,
basically
creating
a
state
machine
and
implementing
it
there's
different
ways.
You
can
structure
that
and
some
are
a
better
fit
for
certain
goals
and
certain
workloads
that
you're
managing
than
others
are
more
natural
to
certain
programming
patterns
or
not,
and
there's
a
lot
of
different
choices
you
can
make
there
I
think
it
would
be
interesting
to
see
some
examples.
I
like
that
idea
of
examples,
and
maybe
even
back
to
the
meeting
idea.
K
H
Think
to
that
point
there
were
some
examples
for
a
cute
builder
that
grew
out
of
date
fairly
quickly,
so
there's
historical
stuff
to
look
at,
but
it
doesn't
fully
functional
now
that
there's
probably
room
for
a
bunch
of
examples
out
there
that
are
that
are
topical.
You
know
my
microphone,
a
particular
interest
of
a
controller
that
we
really
burn
yeah
yesterday.
L
Kay
we
have
the
samples
there
pretty
simple
record
the
projects
there
are
very
small.
We
could
definitely
prove
then
like
put
to
the
test.
Is
we
have
a
proposal
for
the
HT
to
show
how
to
tell
change
or
to
start
which
is
common
questions
as
well?
Ng
we
have
the
getting
started.
We
made
a
blog
post,
it's
a
try
to
clarify
G
period
as
well,
which
II
sometimes
I
have
the
feeling
that
the
users
I
don't
know
if
they
don't
find
the
getting
started.
L
Do
you
know
because
he
the
questions,
the
common
questions,
like
a
death
Cheeseman?
How
are
you
wash
a
resource?
You
know
the
get
started.
Is
there
Hellsing
example?
But
he
probably
the
person
didn't
follow
that
so
because
these
didn't
get,
you
know
how
the
things
works,
so
I,
don't
know.
How
we
can
address
is
how
we
can
make
it
easier
for
then
check
the
basic
stuff
information.
I,
don't
know
if
it
just
makes
sense.
J
J
Another
aspect
of
it
is
that,
like
the
samples
that
you're
talking
about
Camila
are
extremely
simple
so
like
even
if
people
do
find
that
and
do
kind
of
start
to
model
their
operator
based
on
those
samples
that
very
quickly,
if
you're,
writing
any
any
sort
of
complex
operator,
you're
very
quickly,
getting
to
the
point
where
there's
some
complexities
that
you're
dealing
with
in
your
operator
that
just
don't
exist
in
in
the
samples
operators.
So
it's
always
it's
always
kind
of
difficult.
It's
like
okay!
J
Would
we
even
be
getting
by
making
a
complex
sample
so
I
think
the
the
ideas
of
like
having
community
operator
developers
showcasing
their
reconcile
methods
as
Michael
was
kind
of
suggesting
I?
Think
I.
Think
that's
a
great
idea,
like
I
think,
is
the
more
we
can
get
the
community
involved
in
showcasing
the
way
that
they've
solved
the
problem,
and
maybe
we
can
start
adding
links
in
in
the
doc
site.
J
L
And
I
think
if
we
make
it
a
single
stroke,
complex
you'll
be
hard
to
follow
how
we
started,
which
is
the
biggest
in
communicating
my
point
of
review,
but
it
what
about?
We
move
the
getting
started
for
a
is
cheeky
helpful
as
well,
for
example,
because
it
I
think
it
who
started
with
fidelity
starts
by
the
quick
starting
to
reach
me.
Anything
don't
have
the
full
information,
you
know,
and
you
may
be
making
hard
the
things
the
docs
will
will
probably
address
just
better
as
well.
I
agree
to
I.
G
Think
to
plant
CK
documentation
is
to
definitely
have
that
getting
started
guide.
Part
of
the
QuickStart
section
that
we
plan
to
have
so
like
the
talks
will
be
structured
very
similar
between
SDK
and
or
them,
and
you
will
have
an
introduction
section
with
click
start
and
then
you
will
have
a
section
about
you
know
general
concepts
and
topics,
and
then
there
will
be
a
how-to
section
that
describes
very
particularly
use
cases
of
how
to
go
from
A
to
B
the
very
prescriptive
manner,
so
I
think
the
getting
started
guide
would
really
fit
well.
I
I
So
once
you
write
the
QuickStart
and
you
create
you
know
now,
my
memcache
is
is
deploying
three
pods
like
look
what's
next
like
what's
I
know
my
problem,
but
I
don't
know
how
to
go
from
this
place
where
we're
deploying
a
thing
to
where
I
need
to
manage
my.
My
my
application
and
I
think
the
problem
gets
into
like
how
do
I
write
that
reconcile
loop
in
such
a
way
that,
like
will
be.
I
Not
about
doing
a
quick
story,
yeah
no
good
I
would
just
want
I.
Think
we're
I
think
we're
dialing
in
Don
to
a
prop
like
we're,
trying
to
find
a
solution
to
a
prop
to
a
different
problem
and
I.
Don't
know
if
the
solution
that
we're
working
on
actually
solves
the
larger.
How
do
what's
my
next
step
after
I
start
writing
an
operator
like
how
do
I
make
this
good?
Then
people
will
not
think
this.
I
This
is
bad
I
think
it's
probably
mostly
what
people
are
asking
and
I
think
the
best,
and
that's
where
I
think
like
the
negative
case
is
probably
our
best
that
right
now,
because
I
don't
think
we
I
don't
know
if
writing
down
a
exhaustive
list
of
everything
that
is
that
you
can
do.
That
would
be
good,
is
going
to
be
possible,
I
think
it'd
be
better
to
say
like
make
sure
you
don't
do
this,
make
sure
you
don't
do
that,
make
sure
that
you
are
outputting.
I
You
know
certain
information
in
a
certain
format
like
I
think
the
conditions
is
probably
something
that
we
can
be
affirmative
about,
like
you
should
be
using
conditions.
They
should
look
like
this.
This
is
the
format
for
the
conditions.
Here's
the
and
you
know
we
soon
will
help.
We
have
a
library
for
doing
conditions
work.
You
should
be
using
the
libraries
for
conditions,
those
sorts
of
things
I
think
are
what
people
are
looking
for
and
I
don't
know
if
the
Quick
Start
Guide
being
moved
around
is
going
to
necessarily
help
folks.
J
E
J
Out
level,
one
now:
how
do
I
go
from
level
one
up
to
level
two,
three
four
or
five,
and
that's
the
piece
that
we
don't
really
have
any
documentation
about,
and
it's
hard
to
write
that
documentation.
So
maybe
that's
what
we
they.
We
can
try
to
figure
out
how
we
can
get
more
docs
about
how
to
go
from
level
1
to
level
2
and
beyond,
and
maybe
it's
simpler
from
that
standpoint
to
say,
like
okay,
getting
started
guide
covers
level
one.
J
If
you
want
to
go
to
level
two
like
here's,
some,
you
know:
here's
some
operators
that
are
level
two
that
exists
in
the
community.
Maybe
we
do
it
that
way,
or
maybe
we
have
a
doc
that
says
and
here's
the
extra
things
that
you
can
do
and
here's
how
you
might
do
something
in
your
reconcile
function.
That
would
make
your
operator
level
two
and
so
on
and
so
forth
up
through
the
different
levels.
I
So
you
know,
I
was
just
gonna.
Ask
the
dagger,
like
that's
that's
more
or
less.
What
he's
seeing
people
ask
for
is
like
okay,
now
that
I
got
my
initial
thing
like
what
do
I
do.
Next
is
really
what
they're
asking
when
they
say
how
do
I
run
the
idiomatic
operator
or
if
he
thinks
that,
there's
something
more
to
it
than
that
I.
F
Get
the
feeling
that
they
would
I
it
would
be
nice
to
be
able
to
say
answering
that
question
is
hard.
Here
is
a
you
know:
here's
a
link,
I
can
give
you
that
gives
you
resources
to.
Like
start
answering
that
question
for
yourself,
you
know,
links
to
other
reconcile
functions
from
other
operators,
that
we
are
good
examples
like
even
having
a
list
of
things
not
to
do
I
think
are
all
I
think
there's
all
sound
good,
but
having
that
link
that
you
can
share
and
say,
oh
you
want
to
know
more
about
writing
operators.
H
It's
potentially,
this
might
be
the
reason
why
I
don't
see
an
operator
unless
you're
level
3,
because
if
you're
level
1
you
don't
even
need
to
reconcile
anything
you're,
just
installing
something
one
can
assume
so
I.
Don't
even
understand
that
to
me
it
doesn't
make
any
sense
but
I
wonder
I
love
the
the
conversation
as
a
whole
I
wonder
if
there's
a
need
for
a
list
of
have
you
considered,
you
know
in
particular
around
reconciliation.
H
Have
you
considered
these
things,
and
so
just
a
list
of
links
that
go
off?
Have
you
considered
x,
+
y
+
Z,
and
because
you
won't
be
able
to
capture
them
all
I
can
fleetly
agree
with
that
comment
that
was
made
well,
there's
a
lot
of
assumptions
that
go
into
them,
but
have
you
do
you
have
a
need
to
listen
or
watch
other
objects?
Do
you
have
you
know
we
could
go
through
a
list
of
those
things
right?
C
J
J
And
maybe
we
need
to
find
a
way
that
we
can
highlight
those
things
from
there's
a
new
website
that
we're
adding
in
or
Doc's
somewhere
whatever
it
is
to
make
it
easier
for
people
to.
Basically,
as
Xavier
was
saying,
like
here's,
the
link
that
has
all
the
links
to
different
blogs.
You
know
the
FAQ
that
have
you
considered
page.
They
would
just
kind
of
throw
stuff
there
and
have
people
be
able
to
go
through
that
and
find
things
on
their
own.
G
She
look
at
the
agenda.
There
is
an
issue
in
the
SDK
repository
about
a
proposal
to
extend
the
SDKs
scaffolding
coverage
to
writing
queue,
control,
plugins
or
CLI
interfaces
for
your
operator
in
general.
That
interact
with
that
operator
using
kind
go
so
I
was
just
looking
to
bring
this
up
with
you
and
maybe
get
some
feedback
on.
G
H
H
C
H
J
J
So
it
could
be
like
like
it
could
be
that
if
you
have
your
v1
API
for
your
operator,
like
that's,
not
gonna
change
really
at
all.
In
that
case,
like
maybe
it
is
okay
to
have
a
separate
CLI
project.
That's
outside
of
the
operator
project
and
all
you
have
to
do
is
vendor
the
client
set
for
the
v1
API
and
off
you
go
with
client
go,
but
you
know
it's
six
of
one
half
a
dozen
of
the
other.
In
my
mind,
yeah.
H
J
Let's
put
this
way,
I,
don't
see
any
reason:
why
not
to
put
it
in
your
project
directly
right,
I
guess
the
only
case
would
be
like
if
you've
got
maybe
like
four
or
five
operators
that
all
have
some
interactions
with
each
other,
and
you
want
to
have
like
a
single
CLI
that
kind
of
ties
them
all
together.
Then
of
course
you're.
Probably
you
probably
have
a
separate
project
at
that
point,
but
that
seems
like
a
pretty
far
out
use
case,
potentially
yeah.
C
E
C
G
C
E
A
So
a
Pantheon
word
we
built
an
operator
so
we're
building
a
system
that
uses
kubernetes
and
our
internal
orchestration
platform
together
on
the
same
nodes
using
container
optimized
OS
from
Google,
and
we
built
a
machine
operator
that
provisions
gke
nodes
outside
of
the
node
pool,
and
then
it
does
a
lot
of
things
registers
it
with
our
Orchestrator
manages
these
nodes
kind
of
overall
machine
management
in
this
mixed
workload.
So
our
internal
worker
traitor
orchestrate
system,
D
containers
on
the
same
nodes
as
docker
images
are
running
for
our
services
that
service
those
customer
containers.
A
So
we've
built
a
machine
operator
that
has
a
machine
at
the
machine
class,
CRD
and
I.
Don't
think
we're
going
to
open
source
this
so
specific
to
what
we're
doing.
But
it's
interesting
from
the
perspective
that
we're
managing
G
cloud
objects
and
kind
of
the
way
service
broker
would
doing
all
kinds
of
extra
injection
of
things
and
cos
is
read-only.
So
there's
a
lot
of
extra
work
there
that
the
operator
does
to
do
overlay
mounts
on
the
boxes
through
executing
remote.
A
C
That's
a--that's
a
more
interesting
I'm,
curious,
I'm,
curious
issues,
tracking
statuses
and
linking
together
different
actions
and
like
between
things
that
are
happening
on
cloud
api's
and
things
are
happening
on
your
box
and
then
your
source
of
truth
CI
system.
How
do
you
kind
of
weave
all
that
together
so.
A
We
have
the
operator
integrated
with
the
G
cloud
API
and
the
cuvette
api,
and
then
we
actually
had
to
do
some
modifications
to
our
code
because
it
needs
to
be
able
to
access
more
than
one
kubernetes
cluster
at
a
time
watching
things
on
multiple
cloud
clusters
so
which
is
interesting
in
itself.
The
synchronization
happens
when
we
create
the
box
and
it
gets
created
in
G
cloud
and
then
things
happen.
A
We
constantly
check
in
a
polling
fashion
on
the
state
through
the
G
cloud
API,
because
it's
not
event-driven
like
the
kubernetes
api
is
right,
so
there's
definitely
some
polling
that
goes
on
there,
but
also
coop,
because
these
are
being
registered
to
a
gke
masker,
we're
able
to
use
the
nodes,
api
or
COO
with
the
operator.
So
the
operators
watching
the
nodes,
API
looking
for
things
that
are
not
ready
and
if
we're
not
ready,
then
we
investigate
further.
K
K
D
K
Interesting
it,
as
you
can
imagine,
there's
a
lot
of
problems.
You
have
to
solve
and
you're
trying
to
make
that
sort
of
API
quagga
Bowl,
where
you
have
different
providers,
all
sort
of
implementing
the
same
guys,
but
they've
been
wrestling
with
that
for
like
a
year
and
a
half
now
and
I've
come
up
with
some
pretty
good
stuff.
So
I'll
drop
Lincoln
chat
in
just
a
mine,
wonderful.
A
A
K
A
But
I'd
love
to
see
what
you
have.
You
know
we
already
have
code
Ian,
it's
interesting.
Hopefully,
if
it
happens
at
all
systems,
go
in
Berlin
this
year,
we'll
be
presenting
on
system
D
and
kubernetes
mixed
workloads
on
single
container
optimized,
OS
VMs,
hoping
that
that
conference
continues
scheduled
at
this
time.
It's
unknown.
G
A
A
So
what
we
have
is
we
have
a
GAE
cluster
called
our
provision
cluster.
It
has
one
instance
of
the
operator
prompt
reduction,
gke
cluster
with
these
mixed
nodes
and
that
lives
in
isolation.
So
our
secrets
are
isolated
in
a
different
project
and
cloud
in
a
different
cluster
than
these
nodes
are
being
registered
to
and
we're
reaching
across
to
get
to
the
gke
clusters.
There
are
control
clusters.
A
G
A
With
right,
so
it
was
there's
a
lot
of
complexity
in
the
code
there
I
always
felt
like
it
would
be
interesting
if
we
could
have
n
COO
clients
for
one
operator
monitor
things
and
like
one
operator
that
could
manipulate
and
resources
on
of
multiple
other
cluster,
which
has
been
somewhat
difficult
right
to
do
with
the
current
operator.
Sdk.
G
It's
a
good
and
valid
pattern
to
have
the
same
operator
installed
multiple
times
in
the
same
cluster
or
not,
and
it
sounds
like
your
use
case
would
actually
advocate
for
that
to
be
possible,
because
there's
no
other
convenient
way
to
give
it
some
sort
of
free
configuration.
That
goes
with
every
request.
Very.
A
We
have
an
instance
of
the
operator,
so
we
actually
have
each
instance
of
the
operator
manages
one
control
cluster
from
the
provision
cluster
with
n
control
clusters
and
operators,
and
then
they
still
need
the
two
sets
of
credentials
because
the
node
CRD
gets
added
to
the
provision
cluster.
So
we
have
to
monitor
for
those,
but
then
we
have
to
add
the
node
and
register
it
to
the
the
control
cluster
which
we
have
to
wait
for
it
to
have
the
ready
state
and
monitor
its
state
in
that
cluster.
A
So
we're
actually
watching
resources
in
two
different
clusters
for
each
instance
of
this
operator
and
we're
running
many
instances
of
it,
one
for
each
control
cluster.
So
it's
become
quite
complex.
Unfortunately,
we
were
shooting
for
simplicity,
of
course,
in
the
beginning
and
I'm
gonna
hit
some
roadblocks
after
we
had
already
committed
and.
E
K
A
A
K
C
Throw
out
that
if
your
talk
does
get
cancelled
or
move
to
virtual
or
something
with
the
conference
we'd
love
to
have
you
have
a
few
minutes
here
to
chat
that
if
you
want
to
lift
the
same
presentation
you
put
together
for
that,
you
want
to
use
for
this
or
something
like
that.
That
would
be
awesome.
Yeah.
C
C
A
C
You
and
your
fine
mount
craziness
and
really
just
bringing
me
back
to
my
container
Linux
days
from
core
OS,
where
we
did
a
bunch
of
really
cool
stuff
and
send
linking
between
user
and
and
other
locations
that
were
not
read
only
so
you
could
blow
away
the
send
links
itself.
It
was
very
cool
yeah,
there's.
A
A
Bind
mounts
for
that
and
then
there's
use
run,
see
with
system
D
for
OCI
compliance
for
OCIO,
specs
and
and
and
there's
new
ones
there
with
how
we're
buying
mounting
and
do
our
customer.
We
like
booth
password
D
so
that
they
look
like
the
only
user
inside
their
container
a
lot
of
custom
work.
There,
though
I
know
that's
off
topic
for
this
call,
but
yeah.
That's.