►
From YouTube: Operator Framework SIG 2020-02-18 Full Meeting Recording
Description
Operator Framework SIG 2020-02-18 Full Meeting Recording
more SIG information here:
https://github.com/operator-framework/community/projects/2
A
C
A
D
In
short,
we
merged
it.
Every
107,
I'm
Jared
Dillon
I'm,
one
of
the
chairs
for
over
on
DT
IQ
for
the
project.
So
we
we
got
everything
merged
in
and
I.
Think
there's
you
know
it's
all
set
up.
You
can
go
look
at
the
PR.
That's
also
now
in
master
governance,
not
indeed,
if
you're
curious
about
how
that
process
will
work.
E
This
is
Rob,
I
think
what
we're
waiting
for
is
to
get
on
the
TOC
agenda
and
I
think
we
need
to
bump
this
with
whoever
compiles
that
agenda.
I
think
we're
in
agreement
from
the
sig
that
you
know
we
should
have
the
opportunity
we've
already
talked
to
them
once
so.
I
think
it
was
more
of
like
they've
elected
some
new
members,
and
so
we
just
need
to
figure
out
which
of
those
folks
need
to
hear
more
information
which
are,
you
know,
overlap
with
the
presentation.
Where
did
that's
an
action
item
after
this
meeting
for
sure.
A
A
A
So,
if
you're
interested
in
that
hit
me
up
after
and
I'll
set
you
up
with
the
right
people,
also
at
Q,
Khan
EU,
there's
an
operator
con
event
which
is
put
on
by
a
separate
company,
I
think
it's
woodsy
and
it
would
be
really
good
for
us
to
go
out
there
and
support
them,
and
if
we
could
get
an
operator,
SDK
talked
that
would
be
especially
good
again
hit
me
up
afterwards
and
I'll
set
you
up
with
the
right
people.
If
you're
interested
in
doing
that.
A
F
F
Do
you
see
operator
today,
oh
and
creating
the
operator
package
awesome?
So
yes,
this
is
not
release
it,
but
no
one
of
two
stages
very
soon.
So
it's
in
that
operator
after
I
hope
you
kept.
You
try
this
out.
That's
perfectly
reachable.
So
before
on
the
side,
we
had
the
ability
to
basically
support
to
package
the
operator
right
with
the
UI.
So
the
idea
is
you
give
us
your
convenience,
manifest
making
out
the
operator
and
we
basically
scaffold
our
bundle.
That
is
that's
possible
so
and
the
rest
of
the
bundle.
F
You
would
be
basically
able
to
complete
with
a
graphical
editor,
which
has
all
sorts
of
linting
rules
and
validation
rules
and
semantic
checking
enabled
so
a
little
bit
better
than
you
know,
editing
all
this
yeah
more
in
your
your
text,
editor
and
then
only
see
you
fail.
Then
you
try
to
actually
build
a
catalog,
so
this
editor
is
based
on
the
package
level
or
the
D
bundle
of
the
right.
So
that's
a
one
version
of
your
operator
now.
F
The
package
is
basically
this
structure
right
and
then
you
will
be
able
to
say,
go
upload
this
and
then
you
could
give
this
a
location
in
a
github
repository
doesn't
have
to
be,
ours
can
be
any,
and
then
you
could
say
upload,
and
hopefully
this
works,
and
it
will
basically
import
all
those
files
right
and
we'll
try
to
make
sense
out
of
that.
So
you
see
it
actually
parses
that
and
tries
to
see.
Is
this
belonging
to
an
operator
package?
F
This
is
something
we
understand
as
part
of
the
structure
that
we
have,
and
you
can
also
see
what's
inside
those
for
us
here.
So
this
is
a
fairly
simple
operator:
that's
created
of
ham
chart
only
as
soon
as
CRD
and
the
cluster
service
version
and
the
effect
definition,
which
basically
the
name
of
the
operator
and
the
different
police
channels
right
and
then
you
click
create,
and
then
you
get
a
graphical
representation
at
the
package
level
right.
So
you
see
here
this
thing.
F
This
package
has
exactly
one
release
channel,
which
is
called
stable
and
it
has
Rio
curvy
operator
versions
in
it
like
to
11
to
1
11
to
1,
1
and
209,
and
you
see
also
the
update
path
that
is
built
between
those
versions,
as
it
is
described
in
the
individual
series
pointing
back
to
each
other.
So
you
could
use
this
just
to
visualize
that
you
did
the
right
thing
and
definitely
update
5,
but
you
can
also
actually
add
a
new.
F
That
operators
should
you
have
just
released
a
new
version.
Let's
say
this
is
2
1
12.
Oh,
it's
actually
asking
me
for
their
name,
so
yeah,
let's
confirm
once
that
is
the
field.
And
then
you
have
a
new
version
and
you
can
actually
make
that
the
default
version
right
now.
So
the
newest
one
and
you
can
start
editing
the
update
path
and
select.
This
replaces,
for
instance,
to
111
right.
So
you
can.
You
can
update
it,
oops
representation
of
that
and
then,
as
usual,
you
can
go
into
each
version
and.
F
So
I
can't
do
this
right
now,
because
this-
and
there
are
some
errors
in
here
which
I
would
need
to
fix,
but
once
I
fix
these
errors,
I
can
actually
download
the
zip
file,
and
this
is
exactly
what
you
are
contributing
as
a
chart
to
us
right
and
from
that
we
build
the
catalog
that
is
known
as
the
community
catalog,
so
hopefully
I'm
helping
you
create
vetted
stuff
faster
and
with
less
back-and-forth.
In
terms
of.
Why
is
this
airing
out
what
am
I
missing
here?
What
do
I
need
to
enter
them.
B
Super
cool
I'm,
assuming
that
the
import
from
a
github
demo
that
you
did
it's
expecting
the
versions
to
be
immutable,
and
so
that's
just
a
question
there,
but
the
follow-on
to
that
is
what
happens
when
additional
versions
are
added
in
underneath
that
tree?
Is
it
possible
to
refresh
that
as
opposed
to
import
it?
Does
it
know
how
to
manage
those
details?
I.
F
Don't
think
it
is
able
to
refresh
that
as
of
today,
so
I
think
it's
actually
a
good
question.
I
am
NOT,
one
of
isn't
sure
what
would
happen
if
I
just
do
this
again
and
let's
say
I
would
have
added
something
here.
Maybe
this
is
an
additive
operation
after
all,
and
I
can
just
do
this
over
and
over
again
and
get
this
refreshed.
B
F
Yeah
yeah
I
think
and
in
doubt
you
would
just
start
from
scratch
to
be
importing
it
completely.
So
you
would
say
you
have
clear
all
sword
in
your
package
and
then
it
would.
You
know,
do
this
one
more
time.
First,
when
we
haven't
been
particularly
tested
that
go,
maybe
maybe
this
is
worth
testing
calm.
F
A
F
I,
don't
think
that
something
in
particular-
and
this
was
something
we
wanted
to
do
for
a
long
time
and
EPR
was-
was-
was
open
for
a
long
time
as
well.
It's
eventually
also
needed
for
our
acceptance
and
the
scenes
yeah
and
that
we
have
a
common
in
smuggle
and
yeah.
It's
nothing
out
of
the
ordinary.
It's
almost
the
same
as
the
okd
working
group,
which
is
an
established
upstream
community.
So
should
shouldn't
have
any
surprises
in
there,
but
yeah
I
guess:
you've
shown
the
location
right,
awesome,
yeah,
yeah,
so
yeah.
A
E
Yeah
I
don't
have
too
much
to
talk
about
here.
Just
the
each
project
is
kind
of
continuing
to
move
on
the
main
thing
that
we're,
as
we
mentioned,
was
the
CN
CF
donation
is
the
kind
of
the
main
thing
holding
up.
Some
of
the
work
is
regarding
where's,
like
operator
hub,
gonna,
be
hosted
long
term
and
like
all
that
kind
of
stuff,
that's
kind
of
blocking
work
on
on
that
property,
and
so
we're
just
trying
to
wait
on
that.
E
Events
are
taking
place
before
then
I'm,
not
sure
if
we're
giving
any
actual
coop
contacts
this
year,
but
there's
every
year,
there's
been
more
and
more
operator
talks
and
there's
has
been
growing
from
folks
outside
of
core
OS
and
Red
Hat
and
other
folks
involved.
So
it's
really
great
to
see.
I
don't
have
Dana.
If
you
have
anything
else
to
add
to
that,
but
I
think
it's
just
cruising
forward
per
normal.
F
A
G
Guess
I
can
just
quickly
talk
about
where
we
are
with
the
cupola
integration.
So
for
those
who
don't
know
the
SDK
team
and
the
queue
builder
team
are
or
is
the
both?
The
communities
are
working
on
a
joint
effort
to
implement
a
plug-in
system
or
queue
builder,
which
allows
other
projects
to
use
queue.
G
So
if
anybody
is
curious
about
what
that
looks
like
there
are
two
pr's
or
one
PR,
that's
currently
open
one
that
was
merged
in
queue
builder,
just
search
for
plugins
in
the
pull
requests
search
window,
and
you
can
take
a
look
at
that
yeah.
So
that's
that's!
Basically
all
that's
been
going
on
with
yeah
the
cooler
and
operator
SDK
integration
other
than
that
have
any
other
updates
together.
F
F
So,
as
I've
shown
you
so
far,
we
have
essentially
like
this
on
disk
format.
This
nested
directory
based
approach,
where
you
have
your
package
definition
that
in
each
subfolder
version
with
all
the
files
and
that
make
up
the
operator
from
a
metadata
perspective.
So
specifically,
all
this
is
series
and
the
cluster
service
version
right,
and
that
needs
is
some
house
it
somewhere
to
be
reachable
for
or
whatever,
in
order
to
fill
that
catalog
right.
That
graphically
view
that
PC
and
off
road
after
I/o,
but
also
inside
and
gravity
consoles,
like
the
option
console.
F
F
Repository
so
this
is
not
fully
released
yet
we're
still
working
on
this,
but
the
basic
approaches
already
outlined
here,
where
you
have
a
very
similar
approach
on
disk
right.
Oh
yeah,
a
folder
of
the
name
of
your
operator
and
subdirectory
called
manifests,
which
is
where
all
the
usual
metadata
goes
and
annotations
yamo,
and
for
that
we
were
actually
able
to
do
a
non-executable
container
image.
So
the
Takaful
for
this
could,
let's
see
where's
the
example
for
that
he
ended
up.
Commentation
nope.
F
Here
in
the
bundle
design,
so
this
this
is
only
offering
registry
and
repository
of
framework
work,
and
you
see
we
have
on
this
structure
here
and
we
are
able
to
basically
say:
we've
built
all
of
this
into
a
docker
our
into
a
container
image,
and
that
constitutes
a
an
operator
bundle
of
rights
or
something
that
we
had
no
term
or
no
container
for
and
the
past
is
not
becoming
something
that
you
can
move
around
and,
more
importantly,
store
on
any
container
image
registry.
That
is,
that
is
out
there
and
is
current.
F
So
what
does
we
give?
Us
is
two
things
so
it
when
able
us
to
use
a
standard
back-end
to
host
costume
catalogs
and
by
the
way,
also
our
own
catalogs,
like
the
one
that
is
brent,
offering
half
that
I/o
or
the
ones
that
redheaded
shipping
for
worship
and
also
enables
everyone
who's
capable
of
running
a
container
registry
to
host
their
own
catalogs
as
well.
Now
we
had
a
solution
for
this
before,
but
it
was
not
quite
capable,
and
it
was
also
not
not
something
that
we
had
a
good
UX
around.
F
So
what
we
are
doing
now
is
we
allow
you
to
build
these
bundles,
and
that
is
one
bundle
for
opera
version.
You
can
store
them
on
a
container
registry
and
then,
in
order
for
something
like
the
offered
lifecycle
manager
to
make
sense
out
of
that
and
create
a
catalog,
that's
the
concept
of
an
index
image.
F
So
you
can
really
draw
the
analogies
between
rpms
and
yum
repositories
here,
so
the
bundle
is
kind
of
the
RPM
right
that
contains
all
the
things
that
they
want
install
and
then
there
is
some
sort
of
index
that
makes
that
indexes
many
collections
of
these
rpms
and
allows
them
to
be
viewed
in
a
package
manager.
That's
novotna
orleans
doing
at
this
point
right.
It
has
the
notion
of
index
images
that
can
be
built
on
the
fly
from
collection
of
those
bundles
and
the
index.
Image
is
again
another
container
image
and
dannis
word.
F
So
this
OPM
binary
has
several
sub
commands
in
order
to
do
that,
and
essentially
it
is
able
to
use
an
existing
index
and
incrementally
add
bundles
as
they
come
in,
which
meant
itself
obviously
very
well
to
do
this
in
a
CD
pipeline
right.
So
we've
sort
of
release
this
as
in
a
first
drop.
It's
not
like
product
has
yet
and
completely
integrated,
but
it
is
out
there
and
it's
something
you're
going
to
transition
towards
to
just
to
allow
everyone
to
run
their
own
catalog
and
curate
their
own
catalogs
host
Edmund
and
the
internal
container
registry.
F
E
I'm
super
excited
about
this
because
I
think
there's
two
use
cases
are
really
awesome.
One
is
like
doing
local
devic
and
testing
upgrades
and
all
that
stuff
on
a
cluster.
That's
on
your
laptop
or
something
like
that
makes
it
really
easy
to
do
that.
And
then,
if
you
are
an
organization,
that's
building
a
bunch
of
custom
operators,
you
can
you
know
curate
those
and
ship
them
out
to
a
bunch
of
clusters
without
having
them
be
public
and
beyond
operator
hub.
If
that's
not
what
you
want.
C
F
H
C
F
Yeah
yeah,
so
that
that's
definitely
the
plan.
So
the
catalog
is,
you
know,
just
an
indexed
collection
of
this,
but
we
will
also
have
the
ability-
and
you
can
see
this
in
the
designs
on
the
OLM
repository
already
to
just
take
a
bundle
and
and
install
directly
from
that.
So
I
mean
this-
will
only
work
if
your
bundle
doesn't
have
any
dependencies
and
there's
everything
it
needs
basically.
C
F
Yes,
but
the
team
actually
also
implemented
this
in
the
current
API
set.
So
we
have
this
concept
of
a
install
plan
right.
That
basically,
is
the
or
drives
the
installation
of
an
operator
on
cluster,
and
that
fee
understands
operators
that
come
from
today,
spec
and
implementation,
but
it
also
understands
how
to
actually
work
with
with
a
bundle
right.
So
in
fact,
the
the
new
object
that
you're
talking
about
will
be
introduced
in
parallel
with
the
existing
API
set.
F
I
C
I
F
So
on
the
community
side
will
obviously
need
to
get
the
community
pipeline
up
to
speed
with
this
new
format
and
creating
these
index
images.
So
this
might
take
some
time
and
technically
it
could
take
even
longer
than
than
four
or
five
but
yeah.
Obviously
our
goal
is
to
have
that
up
to
snuff.
That's
the
stuff
is
that's
ready
to
go
in.
H
J
J
You
know
contributed
to
operate
your
I/o
and
the
the
idea
there
was
to
allow
other
operators
to
have
the
ability
of
having
cross
resource
references
so
rather
than
having
everything
be
hardwired
in
URI
amell's.
What
we
wanted
to
do
is
to
be
able
to
specify
pointers
to
other
resources
and
have
the
facilities
of
resort
resolving
those
references
dynamically.
J
So
after
you
deploy
an
object
that
has
a
pointer
at
that
point,
the
the
pointer
can
be
resolved
and
the
comp
Elisabeth
operator
at
the
heart
of
it
had
something
that
we
call
composable
SDK
and
what
we've
done
is
to
do
a
PR
on
operator
SDK,
so
that
these
utilities
can
be
available
to
anybody.
That's
building
an
operator
so
that
they
can
give
the
you
know
the
ability
of
having
pointers
in
their
animals
instead
of
hardwiring
every
value,
so
the
composable
SDK,
and
so
we've
had
actually
a
lot
of
discussion
on
that.
J
Pr
people
have
been
very
receptive
to
it
and
I'm
just
gonna
summarize.
What
is
is
that
it
would
be
contributing.
So,
first
of
all,
on
the
type
side
you
have
the
ability
of
having
an
object
graph.
So
when
you're
defining
your
schema
for
the
for
URI
ammos,
you
can
have
an
object
graph.
Let's
say
where
the
value
should
come
from.
So
we
say,
get
value
from
and
get
value
from.
Here
is
a
composable
get
value
from
type
that
will
specify
the
kind
api
version
name,
etc.
Of
the
the
object
that
one
is
pointing
to.
J
We
also
have
format
transformers
so
that,
if
you're
pointing
to
an
object,
that's
of
the
slightly
different
type
that
does
kind
of
data
that
you
need.
You
can
actually
pipe
these
format,
transport
formers
together
to
get
the
right
format
for
your
data
and
the
composable
sdk
actually
provides
a
series
of
format
transformers
as
well,
and
then
what
we
have
is
for
the
reconciler
inside
your
controller.
There
is
a
reason,
object,
interface
that
has
a
resolved
object
that
is
actually
implemented
by
these
drugs.
That
has
a
resolved
object
function
so
inside
the
reconciler.
J
Once
you
have
used
this
type
of
reference
in
your
in
your
in
your
schema,
you
can
then
call
a
resolved
object
function
to
get
the
value
frog
for
that
particular
reference.
And
so
the
way
this
works
in
your
reconciler
is
that
when
it's
presented
with
an
object
that
has
a
pointer
or
several
pointers,
it's
going
to
try
to
resolve
the
entire
object.
J
If
he
gets
a
resolution
for
the
entire
object,
then
it
will
move
forward
with
whatever
it
is
that
it
needs
to
do
and
if
at
any
point
there
is
some
kind
of
error
that
occurs
during
the
resolution,
because
maybe
the
point
the
object,
that's
pointed
to
doesn't
exist
or
the
data
within
it
doesn't
exist.
Then
the
resolution
returns
an
error,
and
at
that
point
your
reconciler
would
have
to
figure
out
what
to
do,
and
so
we
also
provide
a
series
of
functions
so
that
you
can
figure
out
what
is
the
nature
of
the
error?
J
That's
coming
out
from
the
object
resolution
and
be
able
to
deal
with
it
accordingly.
So
if
people
want
to
learn
more,
we
have
a
tutorial
here
that
goes
into
detail
about
how
to
take
the
memcached
operator
and
replace
the
size
here
field
inside
of
it,
with
a
pointer
to
to
some
other
object
like
a
config
map
that
would
have
that
information,
and
then
it
shows
you
how
you
would
modify
that
memcached
operators
so
that
you
use
the
composable
sdk
in
order
to
get
this
this
ref
to
be
dynamically
configured.
Okay,
that's
it.
D
J
So
the
operator
itself
is
is
something
that
actually
wraps
all
their
operators,
so
it
has
a
template.
So
when
you
look
at
the
operator,
the
way
that
works
is
that
it
has
a
template
that
it
then
drops
other.
You
know
yeah
memos
from
other
objects.
You
can
wrap
any
other
object,
and
so,
if
that
object,
hadn't
been,
you
know,
designed
in
such
a
way
that
it
has
pointers.
J
The
composable
operator
makes
it
so
that
you
can
take
any
kind
of
any
field
of
this
thing
and
turn
it
into
a
pointer
and
then
what
the
reconciler
for
composable
does
is
that
it
takes
the
template,
tries
to
resolve
it,
and
then
you
know
then
creates
the
underlying
object.
So
if
it's
made
for
for
people
who
haven't
you
know,
don't
have
like
the
facility
for
having
pointers
designed
into
their
operators,
it
makes
it
possible
for
you
to
have
pointers
in
in
such
cases
as
well,
so
it
can
physically
wrap
any
any
object
out
there.
J
E
J
So
the
composable
operator
does
is
that
at
every
reconcile
cycle
it
actually
really
resolves
the
object,
and
if
that
object
has
happened,
has
changed
is
an
issues
and
update
to
the
underlying
object
that
we
created
before
so
it's
truly
being
sort
of
dynamically
updated
and
in
same
thing
like
if
I
went
back
to
for
the
composable
sdk.
If
I
go
back
to
this
to
this
memcached
example,
so
so
here
we
have
an
example,
we
will
replace
the
size
with
a
pointer
to
a
config
map.
J
F
J
F
A
A
All
right,
then,
the
lot
the
next
one's
mine
basically
I,
think
that
we
need
another
venue
for
communication.
We
need
some
developer
mailing
lists
or
operator
SDK
and
for
OLM
that
way.
The
discussions
that
we're
having
you
know
just
in
person
like
in
in
little
meetings,
we
could
make
it
a
little
bit
more
open
and
more
inviting
for
everyone
to
contribute
to
so
I've
got
two
suggestions
here:
operator
framework,
SDK,
dev
upward
or
framework
OLM
dev,
and
if
there's
a
general
agreement,
I'll
go
ahead
and
pull
the
trigger
make
that
happen
before
the
next
meeting.
A
E
A
Alright,
some
plus
ones
in
the
chat
all
right
I'll
do
that.
We
have
similar
thing
for
slack
I.
Think
that
there's
a
fair
amount
of
communication
that
happens
in
Red,
Hat,
internal
slack
and
I
think
that
we
should
be
moving
that
over
into
a
public
channel,
though
here's
some
gestures
for
what
those
channels
should
be
this
one
I'm
gonna,
let
it
sit
for
a
little
bit,
because
I
would
like
these
choices
to
be
a
little
bit.
Careful.
So
I'll
just
leave
this
as
an
item
for
next
next
meeting.
A
Alright,
very
good.
Well,
that
is
all
the
stuff
that
we've
got
for
today.
I
discovered
this
morning
that
you
need
github
permissions
to
add
agenda
items.
So
if
you
have
an
item
for
next
meeting,
feel
free
to
you
know:
Mahoney
I'm
Austin
at
redhead,
calm
and
I
will
add
it
for
you.
Unless
we
can
come
up
with
a
better
solution,
right
and
I
will
be
posting.
The
link
to
this
recording
in
the
notes
and
I
hope
everyone
has
a
good
month,
see
you
next
time.