►
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Intro: Operator Framework BoF - Diane Mueller & Sebastian Pahl, Red Hat
An Operator is a method of packaging, deploying and managing a Kubernetes application. A Kubernetes application is an application that is both deployed on Kubernetes and managed using the Kubernetes APIs and kubectl tooling. To be able to make the most of Kubernetes, you need a set of cohesive APIs to extend in order to service and manage your applications that run on Kubernetes. You can think of Operators as the runtime that manages this type of application on Kubernetes. http://coreos.com/operators The Operator Framework is an open source toolkit to manage Kubernetes native applications, called Operators, in an effective, automated, and scalable way. https://github.com/operator-framework
To Learn More: https://sched.co/Grbh
A
Thank
you
very
much
for
coming.
I'm
Sebastian
I'm,
a
director
of
engineering
in
the
openshift
group
at
Red,
Hat's
Diane,
already
told
you
who
she
is.
She
works
on
community
development
at
Red,
Hat's
and
we're
here
to
talk
to
you
about
a
group
of
projects
that
we've
created
initially
at
Red
Hat
and
before
that,
even
at
core
OS
called
the
operator
framework
and
I'll
go
through
a
lot
of
details
and
also
a
demo
later
in
the
talk.
A
A
Pull
Postgres
darker,
pull
Redis
darker,
run,
Postgres
doc,
run
Redis
and
then
you're
good
you're
off.
You
can
start
coding
you
you
don't
have
to
do
anything
anymore.
This
is
a
gigantic
booster
for
a
huge
amount
of
people
who
would
be
even
intimidated
to
just
install
and
to
try.
That
is
something
that's
amazing,
but
it
hasn't
completely
translated
that
promise
hasn't
completely
translated
one-to-one
to
the
production
environments.
Soon,
as
you
cross
the
barrier
from
development
to
production,
everything
changes,
you
need
a
whole
platform,
especially
with
containers
like
kubernetes
to
even
start
running
your
containers
correctly.
A
You
can
do
it
differently,
but,
like
every
single
scenario,
has
its
own
drawbacks
and
good
sides.
Kubernetes
does
something
very
amazing:
it
abstracts
a
lot
of
this
complexity
that
you
have
and
gives
you
generic
features
like
deployments.
Stateful
sets
if
your
application
with
let's
say
your
database,
that
has
a
volume
attached
to
its
dies.
The
machine
on
which
the
pod
is
scheduled
on
dies.
Kubernetes
will
reschedule
your
pod
somewhere
else
and
remount
the
volume
somewhere
else,
and
so
your
application
will
continue
to
work.
A
That's
these
generic
features
that
kubernetes
gives
you
allow
to
the
to
develop
a
variety
of
an
applications
and
again
get
a
lot
of
simplicity
to
get
these
development
patterns.
The
problem
is
that
most
complex
applications,
most
applications
with
state's
most
distributed
applications
require
way
more
custom,
logic
and
strategies
to
be
run
in
production,
and
most
of
these
strategies
are
domain-specific
they're
different
for
each
software
scaling.
Redis
is
not
the
same
as
scaling
Postgres,
which
is
not
the
same
as
scaling
Cassandra.
Each
of
them
are
different.
Each
of
them
have
different
failure
scenarios.
A
Each
of
them
can
need
to
be
upgraded
in
different
manners.
Each
of
them
need
to
be
monitored
in
different
manners,
all
the
above
and
that
domain-specific
knowledge
is
all
in
the
heads
of
either
operations,
people
or
the
experts
that
built
the
software
or
consult
for
the
software,
but
that's
it
like
other
than
that.
If
you
want
to
set
it
up
and
run
it,
you
have
to
learn.
So
one
thing
that
we
want
to
do
is
fulfill.
A
That
promise
make
it
just
as
easy
to
run
software
and
production
as
it
is
to
run
it
as
a
development
environment,
on
your
laptop
and
in
a
way
where
people
yeah
they
have
to
know
the
platform
underneath,
if
you're
using
kubernetes.
Let's
not,
let's
not
kid
ourselves,
you're
not
going
to
get
away
with
not
knowing
how
it
works,
but
at
the
very
least
you're
not
gonna
have
to
know
all
the
details,
all
the
hard,
complex
minutiae
that
can
be
there.
A
You
have
to
you,
can
focus
on
your
own
higher
level,
abstractions
higher
level
domain
specific
code
and
that's
what
happened
with
the
operator
pattern.
It's
a
pattern
that
was
coined
by
core
OS,
I,
think
2016,
and
the
idea
was
to
say:
let's
leverage,
this
platform
that
gives
us
this
generic
toolset.
That
gives
us
an
extendable
API
today
with
C
RDS,
there's
nothing
easier
than
to
extend
the
kubernetes
api
key
for
an
expert.
If
you're
not
an
expert,
it's
not
easy
and
then
that's
the
fun
part.
And
then
you
run
it.
A
On
top
you'll
run
that
application
that
you
build
on
top
of
kubernetes
in
containers.
You
don't
install
it
on
the
side,
you
don't
provide
it
a
special
different
way
of
matt
getting
managed.
You
make
sure
that
it's
all
at
the
same
place
than
your
other
applications
with
run,
and
then
you
write
the
code
that
is
domain-specific
to
your
lap.
A
So,
for
example,
if
you're
writing
a
post,
Chris
operator,
you're
going
to
write
code
to
make
sure
that
you
can
automatically
upgrade
from
one
version
to
another
handle
a
complex
failure
scenario,
complex
failure
scenario
where
a
master
goes
down
and
a
slight
needs
to
be
promoted
to
become
a
Postgres
master.
You
need
to
handle
things
like.
How
do
I
scale
an
application
up
and
down?
A
All
of
this
code
can
be
written
inside
of
that
operator,
leveraging
the
kubernetes
api
s
and
being
also
exposed
behind
thanks
to
CR
DS,
a
kubernetes
like
API
and
I'm,
going
to
show
examples
of
this
in
a
bit
just
to
make
sure
that
work
a
bit
more
clear
and
all
of
that.
So
that's
basically
it
if
you're
building
a
controller
on
top
of
kubernetes
that
drives
a
specific
application
and
make
sure
it
exposes
that
application.
A
Just
like
a
cloud
service
and
by
clouds
earth
I
mean
something
like
RDS
when
you
go
to,
for
example,
Amazon
and
you're,
requesting
for
a
Postgres
database
or
my
sequel
database
from
RDS,
you
just
do
an
API
call
and
you
get
a
database
back.
You
barely
have
to
worry
about
upgrades
and
all
that
cycle
that's
doable
inside
of
these
cloud
providers.
Operators.
That
pattern
is
the
goal
to
bring
this
to
any
kubernetes
cluster.
A
Whether
you
were
on
different
cloud
providers
in
your
own
datacenter
wherever
and
that's
the
goal
is
that
developers
still
have
to
do
all
the
complexity
than
I'm
currently
talking
about.
We
don't
get,
there's
no
way
around
it,
but
at
the
very
least
we
can
create
generic
codes
to
help
them
do
that
and
deal
with
that
complexity,
but
once
we
get
to
the
user,
the
person
that
actually
wants
to
deploy
a
database,
they
don't
have
to
know
that
complexity.
A
They
only
now
have
to
know
a
little
bit
of
kubernetes
api,
that's
it
and
they
already
know
that,
because
they're
using
the
kubernetes
platform
operators
have
since
that
kind
of
exploded.
Quite
a
lot
of
a
lot
of
people
want
to
build
operators
a
lot
of
people,
a
lot
of
is
v's
a
lot
of
open-source
developers
and
even
internally
at
companies
like
this
is
not
just
for
open-source
software.
Even
if
that's
a
preferred
way.
This
is
for
closed
and
open
source
software.
The
goal
is
people
don't
want
to
have
a
human
in
the
loop
again
emore.
A
So
that's
what
all
these
projects
are,
building,
whether
it's
on
Postgres
or
for
Prometheus
or
for
a
couch
base
or
geget
racing
as
another
one.
That's
not.you
know
that
map
we
made
a
list.
This
awesome
operator's
repository.
That's
our
current
way
of
exposing
the
operators
that
exists
to
the
world.
We're
gonna
talk
about
better
ways
very
soon
and
my
demos,
but
that's
a
great
place
to
go.
If
you
want
to
see
what's
out
there
right
now,
the
quality
of
these
operators
is
varies
from
operator
to
operator,
of
course.
A
A
So
what's
the
operator
framework
well
I
talked
to
you
about
the
complexity
that
it
is
to
build
such
an
operator
you're
not
going
to
get
around
having
to
understand.
If
you're
gonna
build
an
operator,
you're
gonna
have
to
understand
kubernetes
you're,
going
to
have
to
understand
how
to
write
a
kubernetes
controller.
How
to
talk
to
the
kubernetes
api,
how
to
generate
all
the
code
that
you
need
to
even
just
get
started,
and
then,
beyond
that
you're
going
to
want
to
manage
all
your
operators
you're
going
to
want
to
measure
all
that.
A
How
do
you
do
that?
How
do
you
package
your
operators?
How
do
you
distribute
them?
What
we
did
is
a
specific
set
of
tools
which
are
different
projects
to
try
to
help
answer
these
questions
in
a
complete,
open
source
usual
manner,
where
we
invite
the
community
to
participate.
The
first
piece
that
I
would
like
to
highlight
is
the
operator
as
decay.
That's
where
you
usually
start.
If
you
want
to
write
an
operator,
the
operator
SDK
will
help
you
do
a
couple
of
things
like
building
your
operator
and
by
building
I
mean
generating
and
scaffolding.
A
The
code
that's
needed
to
generate
a
kubernetes
controller
and
talk
with
your
kubernetes
api.
It
will
give
you
abstractions
to
eat
more
easily
talk
to
the
kubernetes
api.
It
will
give
you
tools
to
make
sure
that
you
can
deploy
metrics
or
TLS,
or
that
you
are
testing
your
operator
the
right
way
so
that
you
can
focus
on
the
business
logic
and
the
business
logic
in
an
operator
is
quite
simple.
Think
about
one
loop
in
which
you
are
and
you
look
at
the
state
of
the
world.
A
I'm
Postgres,
if
I'm
a
let's
say,
Postgres
container,
I'm
going
to
want
to
have
a
master
running,
so
my
loop
is
going
to
be
running
constantly
and
checking
is
a
master
currently
running.
If
the
master
is
not
running,
the
loop
will
start
it
that's
the
way
you
think
about
it.
If,
if,
if
you
need
to
scale
it
out,
the
loop
will
look
and
decide
how
many
masters
do
I
have
Oh.
Only
one
well
looks
like
we
need
Ivan
and
how
many
read-only
replicas
do.
A
I
have
oh
only
two,
but
the
I'm
being
asked
to
do
three
and
in
your
loop
you
basically
reconcile
that's
where
you're
explained
hey.
This
is
I
need
three
and
you
you,
you
bump
the
version,
and
you
do
all
the
logic
that
you
need
to
get
to
three.
I
will
go
more
into
detail
about
these
pieces
tomorrow
in
the
deep
dive
in
the
deep
dive
talk
where
we
will
be
building
an
operator
or,
as
today,
it's
more
about
showing
off
how
to
use
operators.
A
So
that's
what
the
sdk
gives
you.
It's
not
the
only
way
to
build
an
operator.
It's
just
a
way
that
we
provide
you
so
that
code
doesn't
get
written
twice.
A
lot
of
code
like,
for
example,
testing
testing
is
another
important
thing.
If
you
want
to
fulfill
the
promise
of
automatically
upgrading
automatically
testing
automatically
verifying
that
everything
is
running,
then
you
need
to
have
automated
tests
built
in
your
tool
kits
and
from
the
get-go.
Once
you
have
an
operator,
let's
say
again,
Postgres
or
Redis,
you
need
to
run
it.
A
You
can
just
start
it
as
a
normal
kubernetes
application.
All
these
projects
are
not
interlocked
tightly,
so
you
can
just
take
your
operator,
run
it
as
a
simple
container,
as
you
usually
do,
but
once
you
start
having
a
lot
of
container
operators,
things
get
complicated
because
in
the
end
and
operators
just
another
app,
just
like
the
rest
and
you're
going
to
have
to
manage
them,
you're
going
to
need
an
operator
for
operators.
A
We
didn't
like
that
name
that
much
so
we
came
up
with
operator
lifecycle
manager,
whether
that
describes
it
better
or
not,
we'll
see,
but
for
now
suffice
to
say
that
this
is
the
project.
That's
there
to
install
update,
manage
all
your
operators
and
that's
the
thing
that
I'm
going
to
be
demoing
in
a
bit
because
you'll
see
that
a
lot
goes
into
that
and
it's
a
operator,
lifecycle
manager.
It
handles
everything
from
dependencies
from
from
an
operator
to
another
to
making
sure
that
an
operator
doesn't
die
when
it
gets
uninstalled.
A
Things
like
this
operator
metering
is
one
other
piece
of
the
puzzle
that
one
comes
after
I
would
say:
there's
a
whole
talk
about
it's
a
bit
later
in
the
conference
on
Thursday,
but
the
idea
is
that
once
you
have
all
these
operators
installed
and
running
you're
going
to
want
to
measure
them
you're
going
to
want
to
know
how
much
precisely
how
much
they
cost
like
as
in
AWS
dollars
per
operator,
or
even
to
go
more
detailed.
If
you
code
the
logic,
how
much
does
this
table
and
my
database
currently
costs?
A
All
of
this
can
be
aggregated
and
then
reported
on,
and
you
can
then
create
different
reports
to
do
show
back
charge
back
all
these
different
things.
I
will
not
be
demoing
metering
this
time,
but
there's
a
whole
session
that
demos
plenty
of
it.
So
you
should
go
all
right.
Let's
do
the
demo,
because
that's
definitely
the
way
I
prefer
showing
things
all
right.
So
what
you
see
here
is
an
open
shift.
Cluster
latest
version
like
this
is
kubernetes
underneath
and
on
top.
A
What's
the
page
that
I
have
opened
right
now
is
one
of
the
pages
of
the
operator
lifecycle
manager.
So
before
I
go
there,
one
thing
that
I
haven't
talked
about,
but
I'm
previewing
and
we
will
have
more
and
more
details.
Coming
is
what
we
call
the
marketplace.
We
want
a
way
of
having
people
not
just
show
off
their
operators
in
a
simple
repo
like
awesome
operators,
but
we
want
a
way
to
be
able
to
actually
use
operators
straightaway
and
in
any
openshift
cluster
or
cluster
that
has
kubernetes
marketplace
installed.
A
The
idea
here
is
that
the
this
this
page,
that
I'm
currently
showing
is
for
the
administrator
of
a
cluster,
the
administrator
of
a
cluster,
decides
what
operators
a
user
is
allowed
to
use
in
their
cluster
at
all.
Just
like
you
would
do
with
permissions
in
AWS
or
in
this
case,
since
it
comes
from
the
outside
source,
a
admin
will
need
to
decide
what
versions
of
operators
can
run
and
also
in
what
namespaces
certain
operators
can
run.
A
This
is
what
this
provides
once
you're
in
you
are
inside
of
what
we
call
the
operator
lifecycle
manager,
and
you
can
see
that
here.
I
already
have
one
operator,
that's
deployed
called
HCD,
but
let's
deploy
one
another
one
first
to
show
how
it
looks
like
so
the
prince.
The
the
way
that
works
to
use
operator
lifecycle
manager
is
that
first,
you
need
to
deploy
the
operator,
because
you
want
to
provide
a
certain
service
to
the
cluster
and
CD
is
already
deployed
here.
A
So
I'm
able
to
deploy
new
at
City
instances
and
we're
gonna
do
this
in
a
bit.
Prometheus
operator
is
not
installed
if
I
want
Prometheus
instances
I'm
going
to
have
to
install
that.
So
what
you
do
is
you
create
a
subscription.
A
subscription
is
saying:
I
want
to
follow
this
part
version
of
the
prometheus
operator
in
our
case
we're
in
the
preview
Channel
and
we
are
starting
with
a
specific
subscription.
So
once
I
create
this,
what
happens
is
that
the
operator
starts
getting
installed,
so
you
can
see
here
that
it's
installing
its
already
installed.
A
That
goes
quite
quickly.
You
can
see
in
the.
If
you
want
to
see
what
happens,
you
can
see
it
in
the
install
plans.
You
can
see
that
this
is
completes.
This
is
OLM
deploying
and
installing
the
Prometheus
operator,
once
we
go
now
to
cluster
service
version,
we
can
see
that
are
still
waiting,
because
there's
some
pods
still
deploying
in
a
minute
or
so
it'll
be
all
done
and
enabled
just
like
at
CD.
So
in
the
meantime,
while
we
wait
for
the
install,
let's
have
a
look
at
that
CD.
A
So
the
fonts,
of
course,
like
this
or
more
more,
doesn't
look
as
well
afterwards.
Alright,
it
still
looks
okay,
alright,
the
the
idea
here
is
that
I
can
now
deploy
new
instances
of
at
CD.
Currently,
I
don't
have
any
running,
so,
let's
create
a
new
instance.
I
want
a
cluster.
So
this
is
what
your
end
user
does
not
the
developer,
but
the
person
inside
that
sits
inside
of
the
kubernetes
cluster
and
decides
that
he
needs
a
new
kubernetes
in
us
CD
instance.
A
So,
in
this
case,
I
want
a
size
of
three
I
want
to
deploy
to
the
default
namespace,
because
you
could
choose
that.
I
want.
Let's
choose
example
as
a
name
and
then
which
is
already
here
and
then
the
version
so
once
I
create
this,
you
can
see
that
there's
an
X
EE
cluster,
that's
currently
being
deployed,
and
this
is
where
it
gets
interesting.
So
it's
a
currently
the
size.
This
is
a
panel
that
is
specialized
for
that
operator.
There's
no
special
code.
That's
written
for
that
UI.
A
All
that
UI
does
is
get
this
from
the
status.
That's
coming
back
from
each
of
the
operators,
so
you
can,
for
example,
see
that
right
now
only
one
member
of
the
Etsy
D
cluster
is
currently
active,
despites,
probably
already
having
three
pods
up
the
other
still
needed
a
little
bit
more
time
to
form
a
quorum
and
we're
back.
Three
members
are
up,
so
this
here
directly
shows
me
that
my
cluster
now
has
three
member
is
ready
to
serve
if
I
want
to
increase.
I
can
do
other
things.
A
Size
is
a
very
generic
parameter,
since
it's
that
generic
I
can
actually
go
and
create
a
generic
form
for
it's
like
this
one,
and
so
in
this
case
we're
gonna
just
bring
our
XD
cluster
from
three
members
to
five
just
to
show
it.
You
can
always
see
that
this
is
pure
kubernetes.
So
all
the
you
don't
need
to
go
through
these
UIs.
Everything
is
available
through
cube
cuddle.
It's
all
written
back
to
the
object
as
like.
A
You
can
see
that
the
object
currently
has
updated
itself
since
we're
now
at
five,
so
it
will
update
basically
the
members
down
here
up
there
we
go.
We
have
four
members
now
it'll,
probably
update
one
more
time.
It
will
be
at
five
members
and
then
that's
it.
That's
how
easy
it
is.
Let's
see,
how
are
we
at
five
members?
Yet
not
yet,
let's
wait.
Five,
oh,
look!
Sweet!
It's
coming.
A
A
A
So,
let's
see
Prometheus,
this
is
coming
up
great,
so
Prometheus
coming
up
and
we're
going
to
have
just
like
before
that
thing
is
ready.
It
has
two
pods
running.
It
has
an
example
rule,
and
the
cool
thing
here
is
that
for
Prometheus
Prometheus
has
more
than
just
like
launching
a
single
prometheus
instance.
What
you
can
actually
do
like
you
can
see
the
Prometheus
instance
running
here
right
now,
but
it
won't
have
anything
it's
not
populated.
Now.
The
cool
thing
is
that
you
can
use
the
kubernetes
api
to
create
a
service.
A
A
Okay,
all
right!
So
in
this
case
a
cluster
monitor
is
another
one
of
these
custom
resources
in
which
we
say
we
want
to
watch
slash
metrics
of
the
port
called
clients
from
servers
that
met
from
any
application
that
matched
the
label
at
CD
and
is
in
a
yet
C
cluster
called
example.
So
now
I
create
this
and
I've
also
said
in
there.
If
we
want
to
have
a
quick
look
again,
that
we
want
to
scrape
the
metrics
every
10
seconds,
since
this
is
a
talk
we
want
to
be
fast
or
there
we
go.
A
A
Let's
see
if
it's
there
nope
still
not
let's
reload,
oh
there,
they
are
well.
So
here
are
all
our
metrics,
so
there
it
is
the
sed
metrics
are
coming
in.
Let's
see
something
interesting,
let's
see
the
leader
changes
seen
in
total
have
I
ever
changed
leaders.
So
this
is
not
as
interesting
because
this
is
currently
just
a
counter.
Let's
fix
this
real
quickly,
so
well
great
CD,
and
then
here
let's
say
that
we
want
to
select
her
serve
this
equal
example,
and
then
we
want
to
do
this
one
minute
there
we
go
so
now.
A
Well,
we
haven't
had
leader
changes,
it's
been
fine,
we've
only
increased
the
size
of
the
quorum
so
right
now,
leader
changes
are
at
zero,
let's
kill
and
at
city
node
and
we'll
do
two
demos
at
once
and
yes,
now
I'm
going
to
increase
the
phones.
Here
you
go
so
I'm
gonna
kill
the
sed
leader
and
while
it's
dies,
we're
gonna
go
see
what's
happening
so,
first
of
all,
obviously
the
operator
is
gonna,
do
its
job
and
the
operator
is
gonna,
bring
it
back
up.
A
I
think
that's
the
most
important
thing
currently
for
members,
because
the
leader
died.
This
is
going
to
come
back
by
itself
as
soon
as
it's
back
we're
gonna,
go,
see
the
graphs
and
check
how
it's
going
there
we
go
spiked,
but
not
not
enough.
Yet
there
we
go
so
in
this
case
the
main
demo
is
that
is
that
we
killed
it
and
it's
coming
back
there.
We
go
we're
back
at
five
members.
A
So
if
that
happened
during
the
nights,
I
wouldn't
get
paged
I
think
that's
pretty
cool
because
I
don't
like
getting
paged
and
we
can
see
in
the
graphs
that
it's
spiked
here.
Why?
Well
because
it's
swapped
the
leader
changed!
So
that's
it!
So
that's
an
example,
and
this
service
monitor
the
interesting
thing
there
is
I
currently
typed
it
by
hand,
that's
not
so
cool.
A
So
one
of
the
things
that
the
tools
like
the
SDK
can
do
for
you
is
generate
those
automatically
if
I
know
that
I'm
going
to
get
monitored,
I
might
as
well
generate
it
automatically
for
the
user
so
that
when
I
deploy
my
new
operator,
anything
that
I
deploy
that
Albert
it
gets
monitored.
Another
thing
that
that
that's
the
lifecycle
manager
does
for
you
is
it
takes
all
of
this
and
it
creates
dependencies
between
operators,
so
you
can
create
complex
applications
that
depend
on
let's
say
like
a
web
app.
A
This
is
the
web
application
that
depends
on
Postgres.
That
depends
on
Redis.
The
operators
will
get
installed
thanks
to
the
chain
of
dependencies.
This
is
quite
powerful
in
the
end.
So
that's
another
thing
that
I
love
to
demo
someday,
but
right
now,
I
wanted
to
show
off
the
service,
monitor
all
right.
That
was
the
demo.
Now,
how
do?
How
does
one
get
started
with
the
operator
framework?
Well,
first
of
all,
there's
the
github
page.
The
get
up
organization
operator
framework
you
go
there,
there's
a
getting
started
guide
that
I've
linked
to
the
line.
A
Every
single
project
in
there
has
its
own
getting
started,
guide
that
you
can
use
and
play
with
they're
all
as
I
said
they're
loosely
coupled
not
tightly
coupled,
so
you
can
use
them
all
independently.
You
don't
need
the
operators
DK
to
use
the
lifecycle
manager
or
to
use
mirroring.
You
also
don't
need
the
lifecycle
manager
to
use
operators
DK
you're
free
to
build
your
operators
in
Java.
If
that's
what
you
want,
it's
not
a
problem.
The,
but
the
getting
started,
guides
kind
of
shows
everything
coming
together,
one
after
the
other
and
it's
pretty
cool.
A
There's
an
open
shift
sig.
So
we
meet
every
month
we
get
together.
We
show
off
operators
that
we've
built
new
tools,
discuss
problems,
brainstorm
solutions,
that's
a
fun
meeting
to
attend
it's
all
remote,
so
anyone
in
the
world
can
attend
once
a
month.
The
link
is
right
there
as
well,
and
then
there's
a
kubernetes
operators
channel
and
slack
to
talk
all
things.
Operators,
it's
quite
active
people,
respond
there
all
the
time.
This
is
not
just
for
the
kubernetes
for
the
operator
framework.
A
A
There's
lots
of
more
sessions
about
operators
tomorrow,
there's
a
deep
dive,
so
it's
me
again
and
we're
gonna
be
building
an
operator,
so
we're
gonna
go
through
how
to
use,
go
and
also
ansible
so
go
when
you
want
to
code
ansible
when
you
don't
want
a
code
to
build
an
operator
and
to
actually
do
de
to
operations
with
ansible.
The
other
thing
is
and
we're
gonna
build
it
into
and
publish
it
and
deploy
it
in
the
same
cluster.
A
That
I've
just
showed
you
and
then
we're
gonna
deploy
multiple
instance
of
it
and
see
what
we
want
to
do
and
then
Thursday
there's
a
keynote
by
Rob,
which
is
about
operators
and
the
states
of
operators
yeah.
You
should
attend
that
and
then
what
I
mentioned
earlier,
the
metering
talk.
It
goes
way
more
into
detail
about
metering.
A
I
mean
I
didn't
go
into
detail
at
all,
so
it's
super
fun
and
it
shows
you
quite
a
lot
of
interesting
things
about
how
to
think
about
your
organization
about
data
and
reorganization,
operational
data,
it's
cool
and
then
there's
a
workshop
for
those.
Some
of
you
might
be
going
it's
sold
out,
but
go
knock
on
the
door
who
knows
and
it's
on
Friday
morning
all
morning.
So
that's
it.
Thank
you
very
much
questions
and
thank
you
for
much.
A
B
C
A
So
we
actually
just
like
the
operators:
DK
works
with
helm
as
well.
You
can
take
a
helm
chart,
it's
currently
a
separate
project,
we're
currently
integrating
it,
but
you
can
take
a
helm,
Tarts
and
I'm.
Currently
talking
a
helm
v2
when
you
go
and
helm,
be
three
there's
a
lot
of
brainstorming
that
needs
to
happen,
but
in
the
in
in
helm,
v2
lands,
you
take
the
helm
charts
and
you
can
generate
an
operator
from
it
and
then
you
have
an
operator
running
and
you
don't
need
tiller.
A
C
A
I,
don't
have
an
answer
to
ask
helm
to
see
that
what
I
do
know
is
that
what
we're
putting
a
lot
of
emphasis
on
is
making
sure
that
operators
track
the
resource,
annotate
their
resources,
to
make
sure
that
you
know
that
everything
that's
created
by
an
operator
belongs
to
it
and
they
can
also
clean
it
up
easily
like
that
would
be
my
answer.
Okay,
thank
you
sure.
D
A
D
E
So
at
lyft
we
have
been
using
a
lot
of
the
operator
SDK
and
we've
followed
it
for
the
last
six
months.
Oh,
we
should
be
open
sourcing,
some
of
our
operators
soon
awesome,
but
recently
we
have
seen
some
development
in
controller
run
time
and
then
a
couple
other
projects
from
I
think
Google.
How
does
how
is
this
ecosystem
gonna
develop
or
continue
to
develop,
and
how
is
the
relationship
between
controller
runtime
and
operator
SDK?
Specifically,
that's.
A
A
great
question
so
operators
DK
uses
controller
runtime.
It
started
out
doing
its
own
implementation,
but
there's
not
much
point
in
having
various
implementations
on
that
of
that
what
I
call
lower
level
library.
So
we
use
the
same
controller,
runtime
library
and
try
to
differentiate
by
what
we're
building
on
top.
That's
it
and
then
yeah
any
there's
a
lot
of
different
ways
of
building
operators.
You
can
use
client
go
directly
as
well
like
it
goes.
Yeah.
E
E
A
F
A
F
A
G
D
A
So,
where
I'm
going
with
this
is
yeah,
you
can
write
in
with
the
client
go,
but
the
whole
goal
of
the
SDK
is
to
have
common
code
that
we
share
between
all
the
operators.
So
if
somebody
finds
a
bug
somewhere,
it
gets
fixed
and
it's
fixed
for
everyone,
and
not
just
for
a
few
people,
and
mainly
also
not
to
rewrite
there's
a
lot
of
common
code
that
gets
written
beyond
your
basic
interaction
with
like
interacting
with
kubernetes
is
just
one
little
aspect
of
an
operator
right.
A
You
have
all
the
arrests
that
you
want
to
be
doing
tools
to
help
testing
tools
to
have
versioning
packaging,
distributing
it's
to
simplify
these
things
too
right
and
also
libraries
to
not
have
to
rewrite
how
to
handle
TLS
again
how
to
handle
metrics,
like
I,
said,
generating
your
service
monitors
automatically.
These
are
the
things
that
we're
putting
in
the
SDK,
because
we
want
higher-level
tools
again,
you
might
need
it.
You
might
not
so.
I
H
A
The
user
of
the
operator
doesn't
have
to
do
anything
because
the
user
of
the
operators
just
a
consumer
and
can
use
OLM
to
make
sure
to
step
through
stable
and
good
Asians
of
the
operator.
As
the
implementer
of
an
operator,
there
I
have
to
use
tools
to
upgrade
my
libraries,
my
functions
in
the
operators,
decay
we're
going
to
help
we're
gonna
put
stuff
to
help
migrate
from
one
version
to
another
or
even
automatically
migrate
from
a
version
to
another
right.
H
A
H
A
A
great
question
I
should
have
mentioned
this
a
bit.
Our
goal
with
the
OLM
operator,
lifecycle,
manager
and
even
sdk,
is
to
help
with
that
to
not
depend
on
other
people's
other
versions.
But
more
to
do
automatic
probing
of
api's
is
API.
X
present,
yes,
I
can
run
here.
Is
it
not
present?
I
can't
run
here.
That's
what
we
want
to
do
with
operator
lifecycle
manager
and
when
you
describe
what
kind
of
API
is
your
operator
uses?
A
A
I
Yeah
I
just
had
a
question
about
this
versus
kind
of
the
meta
controller.
I'm
kind
of
reading
this
as
like
this
is
the
matter
controller
is
fine,
but
it
doesn't
perform
nearly
at
the
same
level.
Right
like
I'm,
okay,
GUP,
right
SDK
is
something
where
I
would
use
that
to
build
a
more
efficient
go
controller,
but.
I
A
One
thing
we're
gonna
make
sure
that
we
have
good
defaults,
that
these
defaults
work
and,
if
and
that,
that's
our
primary
focus
and
so
make
it
sure
that
it's
as
easy
as
a
docker
pool
or
docker
run
for
to
use
an
operator
and
also
later
to
develop
an
operator
right.
Like
that's,
the
goal,
I
think
we're
I.