►
From YouTube: OpenShift Commons Briefing #126: Operator Framework
Description
The Operator Framework is an open source project that provides developer and runtime Kubernetes tools, enabling you to accelerate the development of an Operator. The Operator Framework includes:
Operator SDK: Enables developers to build Operators based on their expertise without requiring knowledge of Kubernetes API complexities.
Operator Lifecycle Management: Oversees installation, updates, and management of the lifecycle of all of the Operators (and their associated services) running across a Kubernetes cluster.
Operator Metering (joining in the coming months): Enables usage reporting for Operators that provide specialized services.
We believe that the new Operator Framework represents the next big step for Kubernetes by using a baseline of leading practices to help lower the application development barrier on Kubernetes. The project delivers a software development kit (SDK) and the ability to manage app installs and updates by using the lifecycle management mechanism while enabling administrators to exercise Operator capabilities on any Kubernetes cluster.
In this session, Rob Szumski (Red Hat) will give a deep dive into the Operatior Framework and we will have live Q/A afterwards.
A
Hello
and
welcome
to
yet
another
open
ship
Commons
briefing.
This
time
we
have
Rob's
own
ski
from
the
OpenShift
team,
formerly
from
the
core
OS
team.
Who
is
going
to
talk
about
the
over
operator
framework
that
we've
just
recently
opened
sourced
and
give
us
an
overview
of
the
whole
thing.
I'm
gonna,
let
Rob
introduce
himself
and
it's
topic.
The
format
for
this
is
we
have
a
chat.
You
can
talk,
talk
amongst
yourself
via
the
chat
during
his
presentation
and
then
afterwards,
we'll
have
some
live
Q&A.
So
please,
let's
let
Rob
get
started
here.
Alright,.
C
A
B
B
Look
at
some
real
world
examples
of
operators
is
exist
today
and
then
how
you
can
use
the
operator
framework
to
make
one
for
yourself
and
then
kind
of
wrap
it
up
with
the
touch
on
security
and
why
operators
are
key
to
that
and
then
we'll
have
a
live,
Q&A
and
I
believe
we
have
Mike
from
Couchbase
on
the
line.
He
has
some
experience
using
the
SSA.
So
if
we
have
questions
about
real-world
uses
of
that,
he
can
field
a
few
questions
there.
So
with
that,
let's
get
started
so
as
I
mentioned.
B
What
we're
going
to
talk
about
today
is
the
operator
framework.
This
is
an
open-source
framework,
that's
available
and
you'll
get
hub
or
called
operator
framework
and
we're
going
to
talk
through
what
that
means
in
a
little
bit.
But
first,
let's
talk
about
just
what
is
an
operator.
What
is
this
concept
and
an
operator
is
just
a
method
of
packaging
and
deploying
and
managing
a
kubernetes
application
on
the
right
here.
You
can
see
that
say
you
want
to
deploy
an
SPD
clusters
is
a
distributed
database.
So
there's
a
lot
of
coordination
needs
to
happen.
B
B
On
top
of
your
kubernetes
cluster
same
things,
work
Prometheus
same
thing
needs
to
be
versioned.
It
has
a
number
of
distributed
components
that
all
need
to
talk
to
each
other.
This
configuration
they're
scaling
and
the
operator
allows
you
to
encapsulate
all
that
knowledge.
This
is
something
that,
if
you
were
going
to
just
deploy
and
say
a
distributed
database
or
a
big
spark
cluster
or
whatever
it
is
manually,
you
would
be
following
some
sort
of
run
books.
You
might
have
a
script.
B
You
might
just
have
knowledge
in
your
head
about
what
to
do,
which
components
to
bring
up
first
and
the
operator
encapsulate
all
of
that
into
a
method
where
you
can
package
and
deploy
that,
and
so
you
can
give
somebody
a
single
artifact
that
says
hey.
This
is
how
you
can
deploy
Couchbase
cluster
for
me,
this
cluster
density
cluster
and
then
quickly
get
that
up
and
running
in
your
super
next
cluster.
B
Because
you
can
use
all
the
kubernetes
tooling
to
install,
manage
and
deploy
operators
onto
your
cluster
and
the
crazy
thing
about
this
is
that
it
allows
you
to
plug
in
a
new
type
of
object
into
kubernetes.
So
say,
you've
got
your
application
and
you
want
to
provide
that
application
out
to
other
users
of
the
cluster.
Kubernetes.
B
So,
if
you're
running
OpenShift
across
bare
metal
on
all
the
different
cloud
providers,
this
operator
is
going
to
work
the
exact
same,
and
so,
if
you
want
to
deploy
an
application
modeled
with
an
operator
on
any
of
those
clusters.
As
long
as
you
have
the
correct
permissions,
it's
going
to
go
through
these
five.
B
C
C
B
Then
there's
this
magical
piece
of
software
in
the
middle,
the
operator
that
is
going
to
parse
that
and
then
turn
it
into
a
number
of
kubernetes
objects.
If
you
think
about
any
sort
of
distributed
system,
you're
not
just
going
to
have
you
know
application
pods
running,
but
you
know
you're
going
to
need
to
maybe
set
up
a
pod
autoscaler,
there's
going
to
be
configuration,
values
that
need
to
be
set.
C
B
And
what
does
look
like
is
there
is
a
loop
running,
refrigerant
kind
of
is
amudha
loop,
observe
orient
analyze
an
act,
and
this
is
the
main
logic
treat
of
an
operator
and
where
this
is
important
in
modern
distributed
systems.
Is
that
this
is
a
declarative
state,
just
like
any
other
object
inside
into
burning.
So
if
you
have
a
deployment,
for
example,
you
set
the
desired
state
that
I
want
five
replicas
and.
C
B
System
will
analyze
that
and
say:
there's
only
three
running
I
need
to
start
two
more,
that
same
method
is
used
to
represent
the
higher
level
configuration
options
for
an
operator,
so,
for
example,
in
an
SUV
or
Prometheus
cluster,
you
would
say:
I
want
3
replicas
of
this
make
it
happen
or
I
want
to
upgrade
from
version
X
to
version
y,
make
it
happen,
and
the
operator
has
all
the
knowledge
for
what
to
do
to
actually
make
that
and
as
I
mentioned
before.
The
important
thing
is.
This
is
a
native
extension
point
for
kubernetes.
B
So
this
will
work
against
any
kubernetes
cluster,
and
this
is
how
the
kubernetes
cluster
is
going
to
be
able
to
plug
in
and
have
the
new
object
types
and
what
this
means
is
you're
not
having
to
support
kubernetes
to
add
new
functionality.
This
has
been
architected
into
kubernetes
for
the
beginning,
and
so
that's
really
important
to
you
know,
stay
on
that
upstream
path
and
have
a
nice
story
for
working
across
all
the
different
simonetti
providers
at
core
OS
we've
used
operator
functionality
since
it
was
introduced
to
enable
over-the-air
updates
of
components
of
a
cluster.
B
We've
done.
Some
crazy
things
like
even
update,
kubernetes
itself
with
an
operator,
and
so
we
think
this
is
a
huge
win
for
security
and
automation
and
we're
going
to
touch
on
that
in
a
second.
So,
let's
look
at
a
really
easy
example
of
a
an
operator
and
that
left-hand
side
that
we
talked
about
earlier
is
the
declarative.
Manifest
is
actually
a
custom
resource
definition
in
kubernetes,
and
this
is
how
you
can
add
some
resources.
This
is
what
an
SVD
cluster
CRD
looks
like,
and
you
can
see
at
the
top.
B
That
looks
like
any
other
kubernetes
gamal
cloud
that
you
might
be
used
to,
but
for
the
kind
is
now
our
custom
resource,
PMDD
cluster,
and
it
can
have
all
the
common
kubernetes
metadata
name
annotation,
all
that
stuff
here.
We've
got
a
name
of
example,
and
the
spec
is
where
the
magic
comes
in,
and
the
spec
in
a
physical
thing
is
the
custom
thing
that
is
used
to
drive
that
object
type.
So
in
a
deployment
you
modeled
the
number
of
replicas
your
rollout
strategies.
Here
we
have
a
completely
custom
name
for
FPD.
B
We
have
the
size
of
the
cluster.
We
also
have
the
version
of
the
cluster
so
notice
that
you're
not
putting
in
the
complete
image
strings
for
where
the
scanner
is
being
stored
on
a
registry,
the
operator
has
all
that
logic
built
in,
and
so
that's
a
pretty
simple
example.
So
if
we
submitted
this
to
accrue
Bernette
Buster
inside
of
a
namespace,
we
would
get
an
STD
cluster.
That
would
have
three
pods
running
version
3.2.40.
B
But
let's
look
at
a
little
bit
more
of
a
complicated
example,
and
this
is
kind
of
a
fake
one.
That
goes
a
little
bit
further
and
shows
you
how
smart
one
of
these
operators
needs,
and
what
this
is
looking
at
is
an
object
for
a
magical
compliant
date.
So
these
days
in
the
we've
got
gdpr
and
all
kinds
of
data
locality
concerns,
and
let's
imagine
that
we
have
a
piece
of
software
that
is
knowledgeable
about
this,
and
it's
knowledgeable
even
native
about
multiple
clusters
and
geographies.
So
here
we're
going
to
instantiate
a
new
compliant
database.
B
It's
got
a
name,
as
example:
DB
it's
replicated
database.
So
it's
got
a
replication
factor
we're
going
to
dial
that
up
to.
Yes,
we
want
to
auto
scale
it
so
as
more
data
get
suggested,
we
might
need
to
run
more
replicas,
and
so
the
operator
knows
how
to
say
those:
yes,
we
want
to
back
it
up
hourly
and
there's
a
magic
part.
Here
is
the
geography
now.
B
B
So
if
your
German
cluster
went
away,
it
could
move
it
to
Belgium
and
still
be
within
that
geographic
restriction.
But
maybe
your
preference
suited
speed
is
not
actually
honored,
and
so
this
shows
the
scale
of
what
you
can
accomplish
with
an
operator.
You
can
think
about
modeling
any
sort
of
application.
This
way
and
the
high
level
primitives
that
you
get
to
expose
they're
completely
custom
to
you
in
the
CMO
now
remember
we
talked
about
being
cube
native
is
really
important,
and
this
is
a
blessed
extension.
B
This
makes
the
best
ecosystem,
so
if
you're
thinking
oh
I,
already
have
methods
for
deploying
my
software
or
why
do
I
want
to
tackle
this?
Why
do
I
want
to
build
an
operator
because
you're
get
access
to
the
entire
to
burn
any
ecosystem
of
users?
If
you
are
cube
native
and
if
you
happen
to
be
building
an
operator
for
either
an
open
source
project
or
commercial
software
bean
cube
native
is
a
really
great
way
for
sales
enablement.
Because
now
you
can
sell
to
the
entire
kubernetes
user
base
and.
B
So
let's
look
at
some
operators
that
are
available
today.
The
top
three
are
ones
that
we've
worked
on
at
COEX
and
will
continue
to
work
on
at
Red
Hat.
These
are
at
the
V
Prometheus
involved
and
then
the
bottom
row
is
just
a
sample
of
a
number
of
operators
that
are
out
in
the
wild
today.
These
are
built
either
by
companies
or
different
open-source
communities
around
these
projects.
C
B
List
of
them
on
this
repo,
most
awesome
operators
in
the
operator
framework
course
and
what
you'll
notice
about
these
is.
They
all
have
something
to
do
with
some
sort
of
stapled
data
and
that's
not
by
accident.
It's
not
to
say
that
you
can't
use
an
operator
for
anything
stateless,
it's
very
great
for
that.
B
And
that's
great,
you
know
that's
step
lunch
of
recovering
from
a
failure,
but
you
actually
need
to
do
something
a
little
bit
more
complicated.
You
might
need
to
rebalance
data
in
terms
of
Couchbase.
This
is
required
to
get
your
replication
back
up
and
have
highly
available
cluster
and
something
needs
to
check
out
off.
There's
no
built-in
primitive
to
kubernetes.
To
do
that,
so
you
can
build
that
into
the
operator,
so
the
operator
will
notice
that
one
of
your
POSIX
failed,
you
know,
generate
and
do
one
attach
the
storage
and
then
kick
off
that
rebalance
operation.
B
And
if
you
go
to
something
like
cassandra
for
example,
and
you
wanted
to
scale
out
that
cluster,
you
could
be
used
as
pod
autoscaler,
for
example,
and
an
operator
can
configure
it
set
up
all
that
and
then
you
might
change
some
of
the
replication
mechanisms
or
configuration
into
Sandra
and
it
would
automatically
go
and
reconfigure
your
ring
and
all
that
good
stuff,
and
this
is
where
you
can
see
that
you
start
modeling.
These
higher-level
applications
with
a
really
simple
CRD,
but
it
has
really
complex
actions
on
the
backend
and
we
see
folks
running
stapl.
B
Workloads
on
kubernetes
are
most
successful
in
this
fashion.
So
if
you
wanted
to
model
your
custom,
application,
for
example,
is
another
great
way
to
use
this
inside
of
an
enterprise.
If
you
think
about
all
the
things
that
the
knowledge
that
your
team
has
and
how
they
display
their
software,
you
can
model
that
inside
of
an
operator,
so
you
can
think
about.
If
you
want
to
have
a
MOOC
version
of
your
software
between
different
staging
production
environments.
That's
now
modeled
as
a
C
or
D,
and
the
operator
does
all
the
heavy
lifting
flip.
A
B
All
three
hundred
forty
four
of
these
instances
could
live
in
their
own
namespaces
that
those
teams
manage
the
are
back
and
the
permissions
on
those
namespaces.
These
objects.
All
you
know,
natively
into
the
kubernetes
ecosystem.
You
can
use
to
cuddle
to
describe
their
state
in
their
status,
use
to
cuddle
edit
to
change
configuration
about
them,
and
this
is
the
power
of
using
an
operator
they're.
B
So
the
reason
that
we
built
the
operator
framework
is
because
the
together
with
the
community
you've
learned
how
to
make
operators
in
the
best
way
possible
and
avoid
common
pitfalls
that
you
have
and
the
SDK
encapsulates
all
of
that
knowledge,
because
there's
no
need
for
everybody
to
reinvent
the
wheel.
You
know
we've
had
you
know
three
four
years
now
of
experience,
thinking
about
the
problem
and
then
shipping
and
updating
operators,
and
we
want
to
help
everybody
get
started
quickly.
B
So
that's
where
the
operator
framework
and
I
want
to
describe
the
different
components
of
it,
because
each
of
them
is
important
in
their
own
right.
So
the
two
parts
that
we
have
today
are
the
operator
at
decay.
This
is
the
build
side
of
things.
How
do
I
build
an
operator
start
modeling
my
application
logic
and
then
the
lifecycle
manager?
This
is
how
how
do
I,
instantiate
operators
and
different
namespaces
model
their
permissions
correctly
and
then
get
my
applications
that
are
installed
by
the
operator
running
on
clusters.
B
We
have
a
number
of
other
components
that
we'd
like
to
add
over
time.
These
are
things
like
helping
you
do
metering
for
the
operators
running
on
your
cluster.
This
is
tracking
things
like
resource
usage
and
the
number
of
operations
that
they're
doing
so,
if
you
are
running
300
of
them
that
you
can
start
getting
aggregate
statistics
of
what's
going
on
as
well
as
helping
folks
do
things
like
license
enforcement
and
just
look
at
the
number
of
objects
that
are
being
managed
by
the
operators.
B
So
the
first
thing
is:
we
need
to
build
an
operator.
So,
let's
talk
about
how
you
offer
an
operator
with
the
SDK,
this
is
the
rough
workflow.
The
foundation
that
we
start
with.
On
the
left
hand,
side
is
some
of
the
code
generation
that
the
operator
XK
does
on
the
command
line
tool
that
will
instantiate
a
brand
new
operator
for
you,
and
this
is
going
to
set
up
all
the
primitives
that
you
need
to
communicate
with
the
kubernetes
api
and
that
doesn't
sound
that
crazy.
B
As
kubernetes
events
come
in
four
configurations
change,
this
pod
showed
up.
This
node
showed
up
whatever
it
is
anything
that
you
can
see
in
the
kubernetes
event
stream.
You
can
process
with
your
operator
and
then
take
the
appropriate
action
now.
Just
coding
that
logic
isn't
all
that
you
need
to
do
you
actually
need
to
have.
You
know
reasonable
certainty
that
local
testing
is
going
to
work
for
that,
so
you
can
think
about,
like
you
know,
mocking
out
the
kubernetes
api.
B
So
oh
and
this
event
happens-
or
this
scaling
event
happens,
does
my
operator
do
the
correct
thing
and
then
also
testing
that
against
a
live
cluster,
we've
got
some
tools
that
are
built
in
to
help
you
run
automation
against
a
live
cluster
and
you
can
hook
this
up
to
your
CI
TD
workflows.
This
is
the
help.
You
really
feel
really
good
about
your
operator,
because
you
know
these
staple
databases
are
really
important.
B
For
example,
if
that
was
the
operator
that
you
were
building-
and
you
want
to
have
a
lot
of
confidence
that
it's
going
to
handle
those
failures
in
the
correct
way
now,
once
you're
happy
with
the
version
of
your
operator,
you've
got
the
logic
encoded
in
it.
You
need
to
publish
it
and
we've
got
a
publishing
workflow
and
what
pops
out
of
the
other
side
of
that
are
two
things.
B
There's
an
operator
manifest
and
this
some
information
about
the
custom
objects
that
your
operator
is
going
to
be
watching
some
of
the
permissions
that
it
needs,
because
the
SDK
knows
what
kind
of
commands
that
you're
taking
in
cubed
any
of
that
you're
trying
to
spawn
pods
or
edit
secrets
or
whatever
it
is.
So
we've
got
some
our
back
that
gets
generated
for
you.
B
Then
you've
got
the
container
image
itself,
and
so
the
SDK
will
build
that
image
and
then
you
can
publish
it
on
any
registry
like
we
prefer
to
a
I/o,
and
so
those
are
what
your
end
users
need
to
run.
Your
operator
on
the
cluster
as
I
need
this
manifest
and
they
may
be
image
now.
I
talked
about
this
event.
Loop
and
I
wanted
to
talk
through
that
for
a
second,
because
it's
really
important.
B
This
is
where
you're
bringing
your
application
knowledge,
because
you
are
the
expert
in
whatever
you're,
building
you're,
building
a
commercial
piece
of
software
or,
if
you're
part
of
an
open-source
community
and
you're
building,
something
like
spark.
For
example,
you're
the
expert
in
spark
and
the
SDK
is
going
to
help
you
kind
of
hook.
B
It
up
hook
that
up
to
your
day,
and
so
in
that
Gouda
loop
that
we
talked
about
earlier,
the
operator
is
observing
things
from
two
different
sources:
one
is
the
kubernetes
event
stream,
like
I,
talked
about
and
you'll
get
that
for
free
with
the
operator
and
chain,
as
well
as
watching
for
human
changes
to
the
custom
resource
definition.
This
is
the
configuration
of
your.
B
So
if
you're
going
to
change
replicas
from
three
to
five,
the
SDK
will
observe
that
and
then
it
needs
to
analyze
what
happened?
Look
at
the
current
state
of
the
cluster
and
figure
out
what
to
do
and
that
last
stage
the
act
is
when
then
new,
kubernetes,
primitives
or
tweaks
to
your
cluster
are
going
to
happen
and
that's
you
know,
scaling
the
pods
generating
secrets
changing
some
sigmax,
whatever
it
means.
B
And
just
summing
this
up,
so
the
goals
for
this
are
to
maximize
the
opportunity
that
you
have
so
you
drizzle.
This
is
cube.
Natives.
You
have
the
entire
tube
ecosystem
to
work
with
to
distribute
your
operator,
but
you
also
have
all
the
kubernetes
primitives
to
work
with.
So
if
you've
ever
deployed
a
piece
of
software
on
trams,
somebody
data
center,
for
example,
you
don't
have
things
like
Auto
scalars,
you
might
have
access
to
a
hardware
load
balancer,
but
you
don't
have
it
all
in
all
the
primitives,
like
you
do
in
super
Nettie's.
C
B
So
they
make
it
as
easy
as
possible
for
an
infrastructure
admin
to
start
running
an
operator
and
as
part
of
this,
there
are
a
few
decisions
that
you
need
to
make
and
the
beauty
of
this
is
they
are
yours
to
make.
So
you
own
the
code,
that's
produced
by
the
operator.
So
if
you
want
to
make
it
open
source,
if
you
part
of
an
open
source
communities,
you
can
do
that
if
you're
making
a
commercial
product-
and
you
want
to
keep
some
of
its
closed
source.
B
B
What
an
individual
admin
or
operations
would
have
to
happen
on
an
actual
cluster,
and
so
what
you
would
do
is
you
take
this
operator
manifest
and
that's
our
declarative
state
with
some
of
our
roles
and
about
our
object,
and
you
would
register
that
with
a
clutter
catalog
now
this
is
a
concept
in
the
lifecycle
manager.
That's
really
important,
because
the.
B
Is
not
just
instantiated,
you
know
one
of
these
across
the
cluster.
This
is
you
know,
with
an
eye
towards
a
shared
set
of
infrastructure,
that
a
number
of
different
engineering
teams
are
using.
We
see
that
as
a
really
popular
pattern,
for
you
know
having
you
know,
1030
300,000
namespaces
on
the
cluster
and
they
can
all
have
different
versions
of
the
operator
and
an
admin
can
even
choose.
You
know
with
the
RDoc
primitives
in
kubernetes,
whether
certain
namespaces
can
instantiate
that.
B
So,
if
you
think
about
maybe
running
like
actually
Cork
bulbs,
for
example,
in
a
kubernetes
namespace,
a
bulb
is
a
really
important
thing.
If
you're
storing
secrets-
and
you
want
to
make
sure
that
the
teams
that
are
going
to
be
running
that
application
understand
how
it
works,
they
understand
the
failure
mode.
The
operator
is
going
to
help
them
through
all
that,
but
it's
important
to
understand
what
you're
getting
into,
and
so
you
might
not
want
all
your
namespaces
have
access
to
that.
So
the
lifecycle
manager
helps
you
with
that
access
control.
B
B
It
out
to
all
the
consumers
of
that
on
the
cluster
and
the
lifecycle
manager
helps
you
come
out
with
strategies
for
how
operators
are
updated
and
an
important
part
inside
of
the
SDK
is
that
operators
are
always
forwards
compatible.
This
is
so
that
they
can,
you
know,
have
a
live,
rolling
update
happen,
and
then
the
new
version
of
the
operator
will
start
managing
the
old
running
instances.
This
is
all
deposit,
config,
Maps
and
everything
that
it
manages
on
the
cluster.
B
So
if
you
need
to
prime
a
cache
or
you
need
to
deploy
one
bit
of
the
application
before
another
different
tier,
the
operator
can
do
all
that
logic
and
the
lifecycle
manager
helps
roll
that
out
to
all
the
namespaces
that
are
running
and
all
of
it.
You
can
hear
me
talk
about
there's
all
this
automation
in
place
in
an
operator,
and
we
really
believe
that
that
key
to
security
these
days,
especially
running
infrastructure
like
kubernetes,
it's
fast
moving,
you
know
the
cluster
highly
dynamic
and
the
more
automation
you
can
build
into
it.
B
The
better
you're
going
to
have
for
end-user
experience,
as
well
as
security
and
having
to
burn
I,
didn't
see
that
source
of
truth
for
the
desired
state
of
your
cluster
and
that
things
like
access
control,
as
well
as
different
versions
that
are
running
across
the
cluster
and
with
a
lifecycle
manager.
That's
very
easy
to
find
if
I
have
a
my
sequel
operator,
which
versions
of
my
sequel
are
being
run.
If
there's
a
new
CBE
in
one
of
those,
the
operator
knows
how
to
upgrade
them,
and
you
can
make
sure
that
that
happens.
B
So
this
automation
is
key
to
running
your
cluster
now
in
openshift.
We're
very
excited
to
be
combining
the
best
of
both
worlds
from
the
core
OS
product
tectonic
with
openshift,
and
this
is
a
really
brief
look
at
what
the
architecture
looks
like
you
can
do
this
operator
lifecycle
manager
in
the
middle
there
is
running
and
that's
going
to
be
initiating
a
number
of
operators
across
the
cluster
to
manage.
Some
of
these
services,
like
I,
was
talking
about
with
FTD
and
Prometheus.
C
B
Well,
as
some
of
the
built-in
objects
and
services
that
come
with
a
cluster
like
the
registry
and
logging
stack
and
builds
and
image
streams,
all
the
things
that
you
know
and
love
and
openshift,
but
there's
also
all
this
stuff
beneath
that.
That
is
actually
the
clusters
control
plane
itself
and
we
see
automation,
teaches
security
at
every
layer
of
the
stack.
And
so
we
actually
internally
have
operators
that
run
across
this
entire
stack.
That.
A
B
All
of
this,
so
the
console
that
run
an
open
ship,
for
example,
is
managed
by
an
operator.
The
different
monitoring
stacks
kubernetes
itself
all
are
operating,
and
this
is
really
important.
You
know
security
doesn't
end
with
your
applications.
It
matters
of
the
infrastructure
layer
as
well
and
even
down
to
the
Linux
host
layer,
and
so
we're
excited
to
continue
our
usage
of
operators
internally.
B
See
that
flourish
at
the
higher
end
of
the
stack
for
folks
running
these
complex
distributed
system
in
a
really
safe
way.
That's
really
manageable
at
you
know
high
scale,
just
like
we
heard
from
Ticketmaster
with
their
300
comedians,
and
we
think
this
is
going
to
give
you
the
best
developers
experience
for
running
those
applications,
as
well
as
the
best
infrastructure
owner
experience
for
managing
the
cluster
and
the
lifecycle
of
all
these
operators.
B
That's
all
I
wanted
to
cover
with
the
slides,
but
we'll
start
with
a
QA,
but
I
wanted
to
point
out
all
the
links
for
the
operator
framework.
This
is
an
Oregon
github,
as
I
mentioned,
there's
the
SDK
and
a
lifecycle
manager,
as
well
as
some
other
tools
in
there,
as
well
as
our
list
of
Awesome
operators.
This
is
a
list
of
all
the
operators
that
we
know
about
in
the
wild
and
some
of
which,
a
lot
of
which
are
open
sources.
B
If
you
want
to
take
a
look
at
how
some
of
those
are
built,
either
with
or
without
the
SDK,
that's
a
great
resource
as
well
as
in
the
github
work.
We
have
a
full
getting
started
guide
which
takes
you
full
in
the
end
of
everything.
We've
talked
about
so
doing
code
generation
with
the
SDK,
making
a
very
simple
sample
operator
running
that
on
a
cluster
with
the
lifecycle,
manager
and
that'll,
show
you
kind
of
how
you
would
start
from
code
and
then
get
to
end
user
running
on
the
question.
A
Awesome
thanks
so
much
Rob
for
doing
that
and
and
I
know
you
mentioned
Ticketmaster
before
using
the
operators
for
Prometheus
I'm,
wondering
there's
a
bunch
in
the
awesome
operators
and
I
love
the
name
with
that
repo
group
and
I
think
we
have
one
of
the
folks
who's
done
that
Mike
from
Couchbase
on
on
the
line
as
well
too
with
us
today
and
I'm
wondering
if
I
could
talk
a
little
bit
about
his
experience.
You
know
the
difficulties
and
all
unmute
you
now
or
the
ease
of
creating
an
operator
and
talk
a
little
bit
about
that.
A
C
So
when
we
started
reading
the
operator
we
actually
did
so
before
the
operator
SDK,
and
so
one
of
the
things
that's
really
tough
when
you
get
started,
is
just
getting
all
of
the
I
call
it
boilerplate
code
in
place
that
talks
to
kubernetes,
and
so
one
of
the
things
that's
really
nice
about
the
operator.
Sdk
that
Rob
talked
a
little
bit
is
that
it
actually
generates
a
lot
of
that
boilerplate
code
for
you
and
so
we're
talking
about
hundreds
of
lines.
C
You
know
we
had
to
do
a
bunch
of
research
into
figuring
out
exactly
how
the
code
works
right
at
ourselves,
and
it
probably
took
us
three
to
four
weeks
just
to
do
that
and
with
the
operator
SDK.
We
one
of
the
things
that
I
think
is
one
of
the
key
features
is
that
you
can
just
generate
all
that
code,
and
so,
instead
of
taking
three
to
four
weeks
to
learn
everything
and
write
it,
you
just
run
one
single
command
everything's
there.
C
The
project
is
set
up
the
way
that
it's
supposed
to
be
set
up,
and
you
literally
just
have
to
add
in
a
function
that
basically
says:
here's
where
I'm
going
to
put
all
my
code
that
actually,
in
our
case
managers,
Couchbase
and
so
that
I
think,
is
really
really
helpful.
It
really
allows
you
to
focus
on
the
stuff
that
you
know,
which
is
the
application
that
you're
writing
your
operator
for,
and
then
you
guys
just
decide
from
that.
You
know.
A
C
Right
right
now
we're
currently
in
our
beta
releases,
so
we
have
probably
15
or
20
customers
who
are
who
are
kind
of
testing
it
out
running
it
in
their
dev
environments
and
preparing
to
go
into
production.
So
for
us,
we're
planning
on
having
our
1.0
ga
release
sometime
towards
the
end
of
the
summer,
and
so
we
already
have
I
think
five
or
ten
customers
lined
up
who
are
just
waiting
to
go
into
production
and
we've
seen
a
lot
of
interest
around
operators.
Just
in
general.
C
A
A
We
have
a
cig
that
that
talks
a
lot
about
that
and
if
that's,
where
that's
coming
from
I
notice,
that
two
of
the
folks
working
on
the
tensorflow
one
were
two
of
the
key
members
of
the
open
shift
machine
learning
sake,
and
they
hadn't
mentioned
it
on
the
sig.
So
I'm
gonna
make
them
talk
about
it
there,
but
is
that's
what
driving
some
of
the
demand
as
well?
As
you
know,
these
really
highly
scaling
workloads,
yeah.
C
I
mean
I
think
anything
any
application
that
is
complex
to
manage
it.
Doesn't
it
doesn't
fit
as
well
into
kind
of
the
kubernetes
framework.
So
kubernetes
is
basically
has
this
model.
In
my
view,
where
it's
you
know
we're
gonna
create
pods.
We
have
you
know
we
have
controllers
that,
allow
you
to
bring
up
pods,
scale,
pods
and
so
forth,
but
really
when
it
comes
to
a
lot
of
the
more
complex
tasks
they
don't
really
handle.
That
and
I
think
that's
that's
the
right
model
you
stateful
sets
and
deployments.
C
They
really
will
handle
97%
of
people's
use
cases,
but
there
are
a
lot
of
applications
out
there
with
with
heavy.
You
know,
management
where
you
you
can't
just
bringing
up
a
bunch
of
pods.
It
doesn't
really
work
right,
so
in
couch
bases
situation.
If
you
want
to
create
a
four
node
cluster
and
you
create
a
stateful
set,
it'll
bring
up
four
quads
with
Couchbase,
but
the
pods
won't
know
about
each
other.
They
won't
cluster
themselves
together,
and
so,
when
you
start
having
to
do
things
like
that,
I
think
operators
are
really
powerful.
A
So
there's
there's
still
a
lot
of
Education
to
go
on
out
there
in
operate
land.
It's
pretty
it's
a
fairly
new
framework
and
I
think
it's
going
to
be
a
very
hot
topic,
and
so
we're
going
to
try
and
set
up
an
operator
framework
sig
coming
up
soon,
and
so
look
for
that
as
well
will
be
announcement
around
that
and
we'll
probably
like
try
and
get
you
and
some
of
the
other
folks
created
operators
to
to
share
your
your
experiences
there.
So
hopefully
we'll
get
that
spun
up
in
the
next
day
or
so
Rob.
B
Yeah
just
check
out
the
getting
started
guide.
That's
really
the
best
overview
kind
of
how
the
whole
thing
work.
We've
got
a
public
mailing
list.
It's
a
Google
group.
We
love
folks
to
join
on
there
and
share
best
practices,
we're
also
very
active
on
github.
So
we've
got
a
lot
more
in
store
for
the
framework.
A
Right
well,
thank
you
very
much,
both
Mike
and
Rob,
for
your
your
your
time
today,
and
we
look
forward
to
lots
more
awesome
operators
populating
that
on
that
repo
and
talking
about
them
more
so
they'll
we'll
definitely
have
some
follow-ups
as
the
framework
of
alls
and
we'll
get
more
information
out
there
on
blog
that
openshift
com
shortly
with
this
YouTube
video
embedded
in
these
links
and
others.
So,
thanks
again
guys
and
we'll
talk
to
you
all
very
very
soon,
thanks
for
having.