►
Description
Topics covered:
Brief overview of the ansible-operator and helm-operator - Rob Szumski
The switch to controller runtime & the merge of ansible - Haseeb Tariq
Mongodb Operator Update - Rodrigo Valin
Test Framework - Haseeb Tariq
Meeting Notes: https://hackmd.io/s/BJqrGRZY7
A
And
welcome
everybody
to
this
must
be
the
third
or
the
fourth
cig
meeting
or
the
operator
framework
sake.
Today
we
have
a
sort
of
impromptu
schedule,
our
agenda
and
I'm,
going
to
let
Rob
give
us
a
brief
overview
of
the
ansible
operator
and
helm
operator
just
to
level
the
playing
field
and
talk
about
those
two
things:
I'm
going
to
talk
a
little
quickly
remind
everybody.
If
you're
on
this
group,
you've
probably
got
the
announcement,
but
if
you
didn't
the
there's,
there's
a
Google
Group
and
please
sign
up
for
that.
A
That's
how
we
get
done
down
announcements.
So
please
do
that
and
that's
where
all
the
conversations
are
really
happening
these
days
and
also
I
have
one
request
from
everybody
tests.
My
survey
on
the
operator
framework
I'm
trying
to
create
a
survey
to
send
out
to
people
who
are
interested
in
the
operator
framework
and
I,
wouldn't
really
love
you
all
to
especially
nan
Red
Hatters,
unless
you're
actually
working
on
a
specific
operator.
A
Just
just
fill
the
form
out,
and
let
me
know
what
else
I
should
be
asking
before:
I
put
it
up
on
the
landing
page
or
our
community.
To
do
that,
it's
one
of
the
ways
that
I'm
trying
to
figure
out
what
other
content
we
need
to
create
and
share
with
folks
or
asked
be
created
and
keep
it
yeah.
So
without
any
further
ado
Rob,
you
want
to
start
the
conversation
around
tangible
operator
and
helm
operator.
B
Helm
operator
are
getting
merge
into
the
SDK,
and
so
we
can
talk
through
some
of
the
specifics
for
that.
But
if
you
are
first
joining
us
in
the
last
meeting,
we've
had
some
demos
of
these
two
different
types
operators
and
where
we're
going
with
this
is
we
want
to
have
one
tool
that
knows
how
to
create
a
number
of
different
types
of
operators
based
on
technology
that
they're
worth
and
so
the
to
do
so.
B
We
have
to
go
Lange
today,
and
that
is
you
know,
very
well
supported
and
pretty
mature
and
looking
along
with
the
great
and
we're
incubating
I'll
use
that
word
two
different
other
ones.
We
have
ansible
operator
which
works
like
you
see
in
this
diagram
up
right.
Basically,
it's
designed
for
you
to
take
existing
labels
that
you've
already
made
investment.
C
B
You
want
to
use
from
another
is
V
and
map
those
to
kubernetes
defense.
So
when
the
operator
is
instantiated
where
it's
scaled
or
things
to
be
filled
over,
you
can
run
different
play
books
to
do
those
activities
and
the
way
that
this
works
is
used
to
get
into
your
container.
It's
version
does
an
immutable
artifact.
Just
like
you
do
you
know
your
application
code
for
a
container
I
mean
you
can
run
that
operator
on
your
cluster
and
then
I'm
Stan.
B
She
ate
a
number
of
objects
here,
we're
looking
at
a
tomcat
operator,
so
you've
got
here.
There's
on
cap
objects.
You
can
think
those
across
a
number
of
different
name.
What
we
want
to
do
to
generate
this
whole
thing
that
you
see
on
the
right
is
figure
out
the
plan
to
merge
that
into
the
existing
tool
in
for
golang
such
that
when
you
say
operator
s
to
Kate
new,
that
you
then
can
choose
from
a
type
and
that
can
be
an
ansible
operator.
B
It
could
be
hello
operator
to
click
down
second
or
the
regular
dollar
writer,
and
then,
if
we
want
to
branch
out
to
new
things
further
down
the
line,
you
can
do
that
via
the
same
thing,
so
I'm
going
to
switch
to
the
helm
operator,
which
looks
very
similar
in
the
diagram
to
the
right
except
we're.
Instead
of
taking
an
existing
playbook,
you
are
looking
at
a
start.
B
If
you
are
an
organization
that
has
investment
in
charts
and
you
want
to
operate
those
before
automated
in
manageable
way,
you
can
put
those
in
the
container
and
same
type
of
workflow.
Just
like
would
adding
your
business
logic
to
a
cool
thing
about
the
helm
and
ansible
operators
is
that
you
can
do
them
basically
by
writing
no
code.
B
If
you
have
those
assets,
you
don't
have
to
write
any
of
the
glue
logic
just
like
you
would
not
have
to
do
with
the
golang
operator,
but
in
a
go
case
you
know,
you're
gonna
have
to
write
business
logic
go
here.
You
don't
forget
that.
So
that's
just
like
the
level
setting
of
the
kind
of
the
direction
that
we're
going
support
these
new
types
of
operators
and
then
see
was
going
to
talk
a
little
bit
more
about
how
we're
gonna
start.
B
D
D
Just
going
off
on
what
pension
about
the
Anselm
operator
so
that
exists
separately
right
now,
I
think
I
just
can
load
meetings
ago.
But
we
we
apparently
trying
to
do
is
basically
get
all
of
the
core
packages
of
the
ansible
operator
into
the
SDK.
And
so
what
we
want
to
do
is
basically
have
the
SDK
is
support,
generating
an
ansible
type
project.
D
So
there's
a
proposal
on
the
operators,
a
repo
I
think
it
was
an
English
last
week,
but
it
should
be
under
the
talks
proposal
and
simple
operator,
and
the
proposal
is
basically
to
have
the
f-ck
support
generating
pure
and
simple
type
project,
which
you
basically
use.
The
base
image
of
the
ansible
operator
and
this
way
developers
will
just
so
middle
with
ansible,
can
light
up.
D
So
they
can
write
a
more
traditional
operator
in
that
sense.
So
I
just
wanted
to
kind
of
highlight
this
and
point
this
out.
It's
still
a
work
in
progress,
I
think
we've
got
most
of
the
packages
that
you
can
fill
it
in
and
you
should
be
worth
starting
work
on
modifying
the
operator.
Sdk
is
CLI
to
actually
support,
generating
and
an
spirit,
I
project.
D
So
this
we
also
call
that
in
the
repo
right
now-
and
we
haven't-
you-
don't
have
a
proposal
around
the
helm
operator
right
now
we're
trying
to
get
it
finished
after
work
on
the
ends
of
the
operator
bridge.
But
I
would
imagine
if
you
actually
be
quite
similar
people
with
the
answer
would
operator.
So
we
still
need
to
get
a
proposal
out
for
that.
So
if
we
have
that
out,
I
think
we
can
party
I
have
no
question
about
that.
Once
you
have
a
proposal
so
yeah
this
is.
D
B
A
E
E
D
I
know
what
we'll
do
and
discussing
another
upcoming
change
that
tool,
and
hopefully,
in
the
next
couple
of
weeks,
maybe
three
weeks,
but
essentially
what
we're
trying
to
do
is
we're
going
to
be
replacing
I
would
say
pretty
much
all
the
major
api's
of
the
operator
SDK
with
the
controller
runtime
api's.
So
for
those
of
you
who
haven't
seen
this
particular
issue
which
basically
likes
to
work
around
this
effort.
D
D
D
D
D
D
So
yeah,
if
your
application
has
a
profile
resource,
calling
the
database
object
and
then
there's
a
secondary,
so
it's
like,
like
the
database,
backup
object
if
something
changes
with
regards
to
that
or
even
any
resource
that
you
create
under
your
database
or
if
it's
a
part
or
service
of
something
else
that
changes
on
both
anything
changes
in
the
vessel.
You'd
ideally
want
to
riku
at
the
reconciliation
due
for
their
primary
resource.
D
You
can
still
do
the
same
thing
where
you
have
one
controller
within
your
operate.
That
would
end
all
experiments.
All
you
all.
You
could
define
multiple
controllers
each,
each
of
which
could
handle
different
resources
independently
of
each
other,
but
you
can
get
more
into
the
specifics
of
that
ones.
D
This
huge
changes
in
the
CLI
that
will
happens
that
will
actually,
that
you
add
multiple
controllers
and
that
you
add
multiple
custom
resource
types
in
your
project.
So
there's
some
changes.
You
can
see
that
and
probably
happen
around
that,
but
this
is
easy
for
people
to
kind
of
stay
up
to
date
and
kind
of
keep
track
of
the
changes
are
that
will
be
probably
coming
in
in
two
to
three
weeks,
so
the
planning
and
I
guess
like
the
timeline
for
this
is
once
we
have
the
controller
on
time.
D
In
factoring
branch,
working
I
would
say
you
have
all
the
tests
in
place
and
we
have
only
the
documentation
up
to
I
guess
like
speed.
What
we'll
do
probably
like
more
formal
proposal
on
the
repo,
so
people
have
a
chance
to
actually
discuss
any
sort
of
high-level
changes
to
the
CLI
or
how
the
project
layout
was
all
if
there
are
any
changes
to
the
workflow
before
we
actually
go
ahead
and
merge
the
changes
into
the
master.
In
fact,
the
release
for
this
change.
This
will
be.
D
This
would
be
quite
a
big
change.
So
obviously,
since
we
have
a
personality
as
its
it's
a
it's,
a
breaking
change,
we'll
try
to
see
how
much
of
this
you
can
minimize
on
outside
in
the
SDK
probably
provide
some
utilities
or
see
if
we
can
have
existing
projects.
Take
the
second
situation,
ports
on
the
existing
handles
and
move
that
over
to
how
to
control
the
runtime.
D
Comes
over
directly,
like
all
of
that
on
the
reconciliation
code
that
you
would
have
for
your
operator
would
essentially
state
extreme
unit
interval
changes
the
way
you
currently
basically
get
an
event
object
in
your
handle,
and
you
just
use
that
Isis.
The
interface
changes
just
a
little
bit
where
now
you
have
access
to
the
cash
and
you
can
actually
just
look
at
the
object.
D
That's
in
the
cash
that's
in
the
data
state,
so
it's
just
a
small
interface
change
around
how
the
reconciliation
for
next
fall,
but
by
and
large,
most
fridges
port
over
to
control
the
runtime
based
project
so
yeah.
Those
changes
should
be
upcoming.
I,
like
seeing
the
next
couple
of
weeks,
I
meet
everybody
else
up
to
date
on
that,
as
you
make
more
progress
on
that,
but
yeah
I'm.
So
they
might
be
a
lot
on
this.
You
can
only
follow
up
on
the
issue.
If
you
have
something
like
now,
I
can
answer
it
that
again.
B
D
Yeah
after
this
for
Michael
and
Denise
I
think
our
ad
is
from
the
we
probably
won't
have
any
other
sort
of
like
major
changes
to
the
API
fee
on
this
coach.
The
controller
in
time
has
other
diseases
beyond
the
SDK,
and
it's
already
pretty
stabilized
in
terms
of
Audi
a2,
which
increases
the
controller
on
time.
I
think
that
should
be
mostly
nice
and
what
we
have
at
all
so
yeah.
A
D
A
D
Be
a
very
good
point
so
for
people
who
are
interested
in
seeing
what
control
and
time-based
project
looks
like
we
should
have
leading
the
operators.
Decay,
samples
repo
with
some
sample
of
it-
is
to
actually
give
some
examples
of
that.
But,
as
Sean
mentioned,
we
have
to
answer
with
operators
which
actually
uses
the
controller
in
time
already.
So
you
can
see
all
that's
an
example
of
a
project
that
uses
the
controller
on
and
so
there's
a
few
sort
of
changes
in
terms
of
the
project
layout.
D
A
A
F
Hello,
guys
I,
don't
have
any
anything
to
share
with
you
any
slides
for
anything.
I
was
not
prepared
for
it,
but
I.
If
I,
if
I
I
can
like
give
you
an
update
on
the
operator.
The
MongoDB
operator
is
that
within
the
next
few
weeks,
we
will
start
investigating
about
like
basing
our
operator
in
the
operators
decay,
because
what
we
built
so
far,
it's
basically
not
based
on
anything
right.
It's
based
on
the
communities
API
is
but
no
SDK
in
our
in
our
code.
F
What's
where
so
that's
what
we're
going
to
be
start
doing
the
next
week?
Actually,
so
we
aren't
right
on
version,
0.38
think
we're
going
to
be
version
point
four
will
app
to
be
will
have
will
be
related
to
the
integration
of
the
operators,
DK
and
think
I
think
we
are
still
far
apart
from
GA
at
least
eight
or
ten
or
ten
months.
I
wanted
to
ask
you
like,
even
though
all
the
changes
that
you're
doing
on
the
operator
SDK
now?
D
So
the
next
release
that
we'll
do
is
probably
that's
what
we're
going
to
be
more
of
a
check
point
before
we
actually
go
ahead
and
make
all
of
the
Beijing
changes
with
regard
suit.
Controller
runtime
over
they'll
just
be
like
I,
think
I,
actually,
probably
a
minor
other
faculties.
So
there
shouldn't
be
too
many
changes
in
that,
but
yeah,
like
I,
said
with
the
lease
after
that,
from
the
thing
to
still
a
weeks
with
all
the
changes
to
coming
into
the
controller
on
time.
D
So
the
there
should
be
some
changes
to
the
CLI
of
the
operator
SDK
and
how
you
scaffold
a
new
project
and
then
how
you
can
add
controllers
and
it
and
define
new
API
definitions
in
your
project
and
vine.
Large,
the
layout
of
the
project
should
still
be
the
same
it.
The
only
thing
that
changes
is
exactly
where
you
define
you
in
reconciliation
code.
D
So
currently,
if
you
use
the
SDK,
it
scaffolds
the
project
for
you
when,
basically
you
go
and
package
stuff
handle,
and
you
know
there's
a
little,
will
you
basically
get
events
and
that's
where
you
start
writing.
You
know,
like
answer
logic
in
this
case,
it
still
pretty
much
the
same
thing.
Well,
it
feels
couple
the
new
project
which
controls
the
runtime.
D
D
I
would
actually
you
could
you
could
start
taking
the
look
at
that,
but
probably
I
would
suggest
you
like
hold
off.
If
you
haven't
already
started
using
the
SDK.
In
that
way,
you
can
kind
of
have
a
fresh
start
of
continuing
and
import
it
rather
than
factoring
after
we
change
everything
on
our
line,
so
yeah
I
would
suggest
probably.
E
F
Okay,
perfect
thanks
for
that,
so
I
think
that's
our
status,
we're
just
going
through
the
ID
there!
The
work
you
necessarily
do
to
build
our
operator
and
all
of
the
operators
decay,
so
not
going
to
be
until
a
few
until
a
month
after
you,
you
do
that.
You
have
this
new
release
that
we
can
have
something
the
bar
more
robust
based
on
this.
So
that's
it.
Thank.
A
F
D
A
D
Yes,
so
I
don't
know
if
you
have
to
be
mentioned
this
any
of
the
previous
six,
but
we
have
that
framework
package
in
the
operator,
SDK
that
you
can
currently
used
to
actually
that,
basically,
you
have
a
lets.
You
write
your
end-to-end
tests
for
your
operator
that
is
generated
using
the
FTA,
and
so
currently,
what
that
person
would
like
to
do
is
basically
you
import
the
operator
SDKs
test
framework
package.
D
You
have
a
starting
point
where
you
can
write
your
end-to-end
tests.
What
that
gives?
You
is
basically
some
utilities
around
setting
up
global
resources
or
resources
for
your
tests
in
your
namespace,
and
then
you
have
a
CLI
command,
I
think
it's
operators
DK,
and
then
you
give
the
location
of
your
cache
files.
D
That
done
so
stressed
on
the
first
row
that
you
can
point
it
to
by
giving
it
a
good
tooth
ache,
and
so
those
are
on
the
tests
locally
on
your
machine,
and
so
the
test
done
locally
on
your
machine,
and
it
basically
gives
you
that's
like
the
to
pinpoint
it
to
a
cluster.
The
next
thing
that
we
are
looking
at
with
the
test
framework
is
actually
far
to
think
of
the
end-to-end
tests
that
you
would
have
for
your
fit
within
the
operator
image.
D
So
this
way,
if
you
basically
build
your
operator,
will
make
you
can
fight
with
your
end-to-end
test
along
with
that
and
then
just
using
that
image,
you
can
son
an
operator
in
the
vessel
and
actually
test
it
out
at
the
same
time.
So
that's
20
years
ago,
working
partners,
we
have
a
PLL
go
back
and
once
that's
done,
we
should
have
in
world
talks
around
that.
That's
from
something
else.
We
go
demo
in
the
next.
Take.
B
One
thing
I'd
like
to
I've,
been
noodling
on
and
need
to
put
it
for
Ozel
down
for
is
having
the
default
set
of
tests
that
run
for
all
operators.
Once
we
have
the
test
framework
in
place,
and
this
would
be
just
checking
it
like
you're
writing
a
status
out
after
the
CR
is
created
with
the
you
know,
whatever
the
operator
is
doing
or
whatever
the
current
status
is
just
so
that
folks,
end-users
can
be
able
to
know
that
oh
it's
running
successfully
or
it's
still
creating
or
it's
an
error
state
or
whatever,
like
yeah.
D
That's
that
such
a
good
idea,
it's
I,
think
we
just
need
to
kind
of
narrow
down.
What
is
some
then,
instead
of
liabilities
like
all
of
these
things
like
yeah,
if
you're,
that
image
status,
the
dash
cam
would
put
other
default
test
for
that
if
any
code
I
started
when
they
fit
operator
actually,
does
that
a
lot
and
it
would
be
a
participant
I
think
you
have
to
formulate
some
partners
on
that
first.
B
A
A
The
only
other
thing
that
I
had
to
ask,
or
just
is
we
were
thinking
about
hosting
an
operator
framework,
hands-on
workshop
II
type
thing
at
KU
con
in
Seattle
in
December
and
if
you're
interested
in
participating
in
that
are
taking
that
workshop.
If
you
can
reach
out
to
us-
and
let
us
know
be
interested
in
that,
Tony
Campbell
is
working
on
the
content
for
that
he's
on
the
on
the
hook
for
it.
So
hopefully
we'll
get
that
off
the
ground.
A
So
look
for
an
announcement
around
that
and
if
you
have
an
operator
that
you're
working
on-
and
you
like
a
little
air
time
at
one
of
these
to
talk
about
it
or
to
get
some
hands-on
feedback
from
some
folks.
Please
speak
up
on
the
mailing
list
and
we'll
yeah
we'll
give
you
that
sometime
and
get
some
eyeballs
on
it
for
you
as
well
speaking,.
A
B
Yeah,
that's
it
just
excited
to
see
the
work
on
some
of
these
operators,
and
so
I
would
encourage
you've
got
work
in
progress
that
you
want
to
show
off
or
you're
tackling
a
figure,
leeteuk
problem,
and
you
want
some
brainstorming.
This
meeting
is
great
place
to
do
that.
The
mailing
list
is
a
great
place
to
do
that
and
got
happy
all
part
of
the
group.
A
All
right
we'll
be
doing
this
again
on
October
19th,
the
third
Friday
of
the
month,
so
I'm
email,
the
list
or
email,
Rob
or
I
or
and
we'll
put
you
on
the
agenda
or
just
add
yourself
into
the
hack
MD
agenda
and
I'll
make
sure
that
it
gets
there
next
time
and
I
will
upload
the
recording
of
this.
So
those
of
us
who
don't
take
notes
like
myself,
can
watch
it
again
and
call
all
the
insight
thanks.