►
Description
Join us for Kubernetes Forums 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
Smooth Operator - A Rough Guide to Kubernetes Operators - Olive Power, VMware
Kubernetes Operators are key to the automation of complex containerised applications. They facilitate the encoding of post deployment configuration information into Kubernetes primitives. This means operational tasks like installation and configuration (day 1), update, reconfiguration and failover (day 2), can exist as software inside Kubernetes, with integration into the Kubernetes API. This integration makes these applications Kubernetes-native. In this talk we will discuss the genesis and evolution of Kubernetes Operators. In addition, we will discuss their use in some common complex applications being orchestrated by Kubernetes today. Finally, we will touch on the process of building an Operator and how that process pathway looks. Kubernetes Operators take the rough edges off a complex application, enabling smooth automation!
A
Okay,
I
think
we're
ready
to
start
hello.
My
name
is
olive
power.
I
currently
work
at
VMware,
so
happy
to
be
here
in
Sydney.
It's
only
my
second
time
here,
I'm
from
Ireland
originally
so
I
feel
a
little
bit
far
from
home.
But
it's
a
beautiful
city
and
everybody's
made
me
feel
very
welcome
thanks
very
much
for
that.
Okay,
just
a
little
quick
introduction
about
me
before
we
go
into
this,
the
talk
itself,
I
came
to
VMware
with
the
hep
T
or
acquisition
and
hep-c
o
was
founded
by
to
the
original
founders
of
kubernetes.
A
So
we
were
a
very
open
source,
driven
kubernetes
type
company
that
VMware
acquired
for
its
sort
of
strategic
focus
and
concentration
into
the
kubernetes
world.
So
I've
been
with
VMware
for
about
five
months
and
as
I
say
before
that
we've
helped
you
before
hep
T
I
was
at
Red
Hat
sort
of
working
on
their
kubernetes
offerings,
as
well,
mainly
in
those
sectors
and
I
just
wanted
to
point
out
that
I'm,
currently
an
instructor
for
the
cube
Academy
and
just
in
case
you
didn't
know
we're
running
some
of
those
sessions
tomorrow.
A
So
it's
like
free,
sorry,
not
free,
but
I'm.
Sorry
training
for
in
kubernetes
we're
going
to
be
doing
some
introductory
mod
modules
there.
So
if
you
want
to
check
it
out,
there's
one
in
the
morning
one
in
the
afternoon,
so
if
you've
got
some
free
time
tomorrow,
come
down
and
I'm
also
part
of
the
the
crew
that
we've
sort
of
launched
a
new
podcast
within
VMware
as
well,
not
necessarily
more
a
branded
thing.
Just
a
few
of
us.
A
A
How
would
you
go
about
starting
on
your
journey
of
building
your
operators
and
then,
after
this
session,
I'd
like
to
give
you
some
sort
of
resources
that
I
find
really
useful
and
in
a
kind
of
a
what
next
section
so
things
that
you
can
look
up
and
read
about
in
your
own
time?
So
I
hope
it's
hope.
It's
going
to
be
useful
session,
but
just
a
little
bit
of
background
first,
because
I'm
going
to
kind
of
talk
about
these
objects.
So
obviously
kubernetes
is
a
platform
for
managing
containerized
applications.
A
So
we
should
kind
of
maybe
all
know
that
point
now
and
all
the
information
about
the
platform
is
stored
in
a
key
store
database
called
its
CD.
So
all
the
information
in
and
around
kubernetes
is
stored
in
this
database
and
any
change
you
make
to
kubernetes
will
be
stored
in
that
database
and
any
information
you
want
a
tree
retrieve
about
your
system
will
be
retrieved
from
that
database
and
the
the
data
is
retrieved
from
that
database
through
kubernetes
api
server.
A
So
all
interaction
with
kubernetes
is
through
API,
so
it's
API
driven
model
and
it's
always
API.
First
and
there's
a
various
ways
that
you
can
interact
with
the
API,
but
most
people
are
familiar
with
using
the
command
line.
Interface
and
I
come
out
line
interface.
We
all
know
and
love
as
cubes
ETL,
so
we
keep
CTL.
A
So
it's
always
striving
to
maintain
the
system,
as
you
have
declared
it.
So
it's
a
declarative
system
always
maintaining
desired
state.
Now,
if
I
talk
about
desired
state
in
a
human
body,
so
I'm
kind
of
an
X
I
back
to
my
background,
just
for
a
little
bit
desired
state.
You
know
it's
a
concept
that
is
not
like.
A
You
know
unique
to
kubernetes,
or
indeed
any
other
sort
of
that
architectural
systems
like
that,
it's
quite
a
common,
it's
quite
a
common
philosophy
or
a
common
way
of
working,
and
if
we
look
at
the
human
body,
for
example,
in
like
a
really
really
really
over
simplistic
view
of
this.
So
if
the
body
gets
cold,
if
the
outside
temperatures
are
cold
and
they're
acting
on
the
body,
then
the
brain
recognizes
that
the
body
temperature
is
dropping
away
from
what
its
desired
state
should
be.
A
And
so
it
implements
some
action
to
try
and
remediate
that
so
it
implements,
in
this
case
lots
of
different
things,
but
I've
just
shown
he
producing
mechanisms
like
shivering.
So
from
a
kinetic
energy
point
of
view,
that
would
generate
heat
in
the
body
and
it
will
start
to
raise
the
body
temperature
back
up.
So
there's
this
kind
of
like
analyzing,
the
state
of
the
world
taken
remediate,
remediating
action
when
it's
not
as
required
and
then
checking
it
again,
and
it's
continuously
doing
that.
A
A
The
system
will
check
it
periodically
to
make
sure
that
at
that
state
is
maintained
and
it
will
fix
it
if
it's
not
and
all
the
fixes
will
be
implemented
through
interaction
with
the
API
to
make
sure
that
the
system
is
as
per
desired.
So
as
I
say,
we
call
this
a
reconciliation
loop
and
the
elements
would
think
kubernetes
that
implement
this
loop
and
do
most
of
that
work
associated
with
that
remediation
is
implemented
through
controllers.
A
So
I
put
it
sort
of
my
own
definition.
There
is
a
software
loop
that
monitors
resources
of
interest.
So
in
our
previous
example,
it
was
our
number
of
pods.
We
wanted
to
run
X
number
of
pods.
That's
our
resource
of
interest,
so
there'll
be
a
specific
controller
that
will
maintain
my
number
of
pods
in
this
case
replication
replica
set
controller
that
will
monitor
my
resource
of
interest,
my
pods
and
compared
the
desired
state
to
the
actual
state
and
take
remediating
action.
So
out
of
the
box.
Kubernetes
has
a
lot
of
resources
of
interest.
A
I
keep
talking
about
pods,
but
there's
a
whole
load
of
other
resources
in
there
that
come
out
of
the
box
and
so
they'll
be
relevant
controllers
for
those
making
sure
that
how
you've
declared
your
nodes,
for
example,
or
how
you've
declared
your
deployments,
there
will
be
controllers
to
make
sure
that
they're
maintained,
as
per
your
definition
or
as
per
your
desired
state.
So
there's
lots
of
out-of-the-box
resources,
but
of
course
kubernetes
is
extensible.
You
can
add
your
own
resources
that
you
want
control,
because
not
there
is
never
any
products,
kubernetes
included.
A
A
So,
if
I
add
a
new
resource
called
olive
and
there's
some
various
attributes
associated
with
all
of
like
color
or
location,
I
can
extend
kubernetes
to
understand
those
objects
and
those
resources
and
those
attributes
and
I
can
declare
what
they
should
look
like
write
some
logic
for
kubernetes
to
understand,
and
it
can
sure
that
all
of
is
in
a
desire
state
and
so
because
you've
extended
the
API.
You
can
now
query
those
objects,
just
like
you
can
do.
A
A
Just
to
show
that
the
attributes
and
the
resources
that
you
can
bring
to
kubernetes
can
be
anything
and
use
the
operator
or
the
person
who
wants
to
implement
this
new
automation
will
understand
what
those
objects
are
and
you
will
define
them
to
kubernetes,
so
that
kind
of
brings
us
on
to
the
what
part
of
the
agenda.
So
operators
are
actually
a
class
of
controller
and
they're
the
ones
that
implement
and
manage
custom
resources.
So
I.
Also,
if
you
have
out-of-the-box
controllers,
to
manage
your
out-of-the-box
resources,
operators
are
what
manages
your
custom
resources.
A
A
So
we've
talked
about
the
reconciliation
loop
and
that
there's
some
logic
has
to
be
implemented
for
you
to
tell
kubernetes,
okay
watch
this
resource,
it's
a
new
custom
resource
I've,
just
told
you
about
and
I've
added
you
to
the
API
so
now
you're
aware
of
it,
but
you
need
to
tell
kubernetes
various
attributes,
C
or
DS
customers
or
definitions.
So
the
kubernetes
understands
if
something
changes
to
those
attributes
or
kubernetes
understands
which
attributes
it
needs
to
watch
and
and
understand.
A
If
there's
changes
to
those
attributes,
what
does
it
need
to
do
and
what
does
it
need
to
do
is
cold?
You
know
you
can't
get
away
from
like
you
know,
implementing
your
automation
as
cold,
so
you
have
to
tell
kubernetes
okay,
so
this
attribute
has
changed.
Maybe
the
color
in
all
of
dark
color
has
changed
from
red
to
blue.
What
do
you
want
me
to
do
about
that?
What
do
you
want
me
to
do
when
that
situation
happens
in
the
case
of
the
out-of-the-box
stuff
with
pods?
A
Basically,
so
you
have
to
tell
kubernetes,
within
your
operator,
cold
what
action
you
wanted
to
take
when
that
happens,
and
so
it's
kind
of
you're
kind
of
packaging
up
your
code
in
a
format
that
kubernetes
ins
understands
and
being
kubernetes
been
your
platform
you're
optimally
packaging,
your
code
for
the
platform,
it's
going
to
run
on
and
lots
of
vendors
or
software
companies
have
done
this
already
they've
packaged
up
their
code
to
install
and
manage
and
operate
their
applications
on
kubernetes.
So
there's
quite
a
few
examples
there.
A
The
cache
add
that
instance
to
a
cluster
resource
manager
or
something
those
type
of
steps
that
you
would
have
to
do
if
you
were
implementing
databases
kind
of
normally,
while
cockroach
DB
and
all
the
other
ones
that
you
see
in
this
page,
they've
implemented
that
logic
into
an
operator
so
that
it
knows
if
another
instance
of
the
database
is
added.
Kubernetes
is
going
to
spin
out
the
logic
through
an
operator
to
make
sure
that
cockroach
DB
is
functioning
as
desired.
A
So
I,
don't
you
to
have
a
look
at
the
operator
hub
de
IO,
so
if
you're
thinking
about
packaging
up
some
application
to
run
on
kubernetes,
it
might
be
done
already
for
you
and
there's
lots
of
other
sources
as
well.
There's
Oh
some
operators
in
the
wild,
and
then
this
actually
is
a
gray
page.
So
the
folk
at
cubed
x
have
made
a
consolidated
list
of
all
the
operators
out
there.
A
A
A
Can
you
not
see
that
okay,
okay,
if
you
scroll
down
they've,
actually
group
the
operators
in
terms
of
function
as
well,
so
you
see
auto-scaling
there
and
we've
actually
scrolls
through
the
page
you'll
see
security,
you'll,
see
databases,
so
they've
grouped
them
nicely
in
kind
of
function.
They're
doing
so,
you
can
just
grab
that
code
and
have
a
look
at
it
and
just
see
how
do
they,
how
they've,
written
and
coded
their
operators
and
just
to
go
back
to
the?
Why
so?
Why
are?
A
Why
are
people
writing
operators
and
I've
kind
of
just
briefly
mentioned
it
before,
but
we're
basically
extending
kubernetes
to
manage
the
resources?
Your
custom
resources
the
same
way
that
it
manages
its
inbuilt
resources,
so
you're
trying
to
make
a
homogeneous
system
and
all
the
automation
our
kubernetes
is
running,
is
kind
of
native
and
in
a
familiar
language?
If
you
like
to
kubernetes,
we
can
always
keep
our
automation
outside.
A
We
can
always
have
some
manual
steps
to
happen
when,
for
example,
your
cost-
you
know
like
we
talked
about
databases
before,
if
there's
a
new
instance
or
a
new
instance
of
a
database
part
is
running.
Do
you
have
to
do
something
manually
to
make
sure
that
works?
You
can
always
do
it
manually
or
coded
in
a
script
outside
of
the
cluster,
but
the
goal
of
operators
and
kind
of
the
beauty
of
them.
A
If
you
like,
is
that
you're
bringing
that
automation
into
your
kubernetes
platform
so
that
everything
is
contained
in
there
and
you
don't
have
different
bits
of
automation,
perhaps
operated
by
different
teams,
you're
kind
of
bringing
it
all
in
together,
so
everybody's
kind
of
speaking,
a
common
language
and
then
also
with
the
operators,
especially
with
all
the
examples
that
I've
showed
you
on
the
previous
pages,
it's
kind
of
making
it
now
easier
to
deploy
these
complex
applications.
There's
a
lot
of
talk
when
I
speak.
Customers
is
like
you
know.
A
How
easy
is
it
to
package
up
this?
A
piece
of
software
for
kubernetes
or
and
should
I
be
running
my
database
as
a
container
codifying
the
the
operational
knowledge
into
an
operator
just
allows
you,
the
ability,
as
I
said,
to
have
everything
running
on
the
same
platform,
but
you're
now
thinking
perhaps
how
that
database
application,
or
indeed
your
automation,
who
you're
trying
to
put
into
an
operator
you're
rethinking,
perhaps
how
that
should
work
and
you're,
perhaps
optimizing
it
for
kubernetes
kubernetes
might
do
a
lot
of
this
stuff
already
for
you.
A
Okay,
so
so,
if
you
wanted
to
start
thinking
about
how
to
write
up
operators
or
delving
a
little
bit
more
deeper
into
them,
then
I
just
there's
a
few
simple
statements
there.
Most
of
them
are
written
in
gold
and
the
reason
for
that
is
because
kubernetes
is
written
in
gold.
So
again,
when
you're
trying
to
run
applications
on
a
platform,
you
design
them
and
write
them
in
the
language,
that's
native
to
the
platform,
and
so
it'll
run
more
optimally.
So
most
operators
are
written
and
go.
A
A
First
of
all,
you
want
to
create
a
new
project
and
I'll
show
you
some
of
the
tools
in
a
minute,
but
the
first
step
is
to
create
a
new
project.
Then,
obviously
you
have
to
define
the
resource
API,
so
you're,
basically
defining
your
custom
resource
and
your
custom
resource
definitions,
and
then
you
have
to
tell
kubernetes
in
its
some
sort
of
logic.
What
attributes
do
I
need
to
watch
which
are
the
ones
that
you
want
era
of
interest
to
you,
because
member
I'm
watching
something
and
if
it
changes
I,
want
something
to
happen.
A
So
you
tell
kubernetes
which
resources
and
which
resource
attributes
you
want
to
watch
and
then,
of
course,
you
have
to
write
the
reconciling
logic.
If
something
goes
from
red
to
blue
what
you
want,
what
what
do
you
want
kubernetes
to
do,
and
how
do
you
want
it
to
fix
it
or
what
you
want
it
to
run
when
that
happens?
So
that's
the
logic
again,
that's
kind
of
the
main
be
written
ago,
but
can
be
another
language
and
then,
of
course
you
build
the
operator.
A
So
if
you
have
like
a
hundred
controllers,
they
probably
all
80%
kind
of
have
that
reconciliation
kind
of
loop,
so
there's
a
lot
of
what
we
call
kind
of
boilerplate
code.
So
a
lot
of
these
tools,
kind
of
pre
write
that
code
for
you
and
then
you
just
need
to
insert
your
own
specific
operator
logic
into
that
boilerplate
code.
A
So
they
were
leader
there.
It
had
this
definition
about
codifying
operational
knowledge
into
into
kubernetes
operational
knowledge
of
an
application
and
coding
that
into
code.
So
it's
worthwhile
to
kind
of
see
the
history
of
operators
to
have
a
look
at
that
link.
Then
I've
also
the
put
up
the
link
for
their
or
some
operators
again,
open-source
kind
of
free
resource
for
you
to
have
a
look
at
some
operators
that
have
been
written
already
for
two
reasons.
A
First
of
all,
if
you're
thinking
about
writing
an
operator,
it
might
be
written
already
right
for
a
particular
particular
application.
Excuse
me
Kafka
or
some
of
the
aqua
sex
stuff
or
again,
the
couchdb
stuff.
I
talked
about
earlier
to
have
a
quick
look
and
see
if
the
thing
you're
thinking
about
writing
as
an
operator
see
if
it's
been
written
already
and
the
second
reason
to
kind
of
look
at
these
examples
is
kind
of
again
to
help.
A
So
in
summary,
I
just
wanted
to
say
what
we've
done
with
already
so
we've
we've
kind
of
defined
what
controllers
are
and
they're
all
the
time
trying
to
move
current
state
of
what
the
world
is
to
the
desired
state.
Again,
the
kind
of
sole
operation
way
of
working
that
kubernetes
has
and
operators
are
controllers
for
your
custom
resources
and
they're
codifying
operational
knowledge.
You
might
have
your
application
into
into
a
format,
that's
understandable
by
kubernetes
and
managed
by
kubernetes
and
as
I
showed
you
lots
of
software.
A
So
I
just
wanted
a
point:
it's
not
even
on
okay,
yeah
queue
builder
is
a
really
good
tool
for
trying
to
a
resource,
for
you
know,
building
that
boilerplate
code.
So
you
can
take
what
queue
builder
has
and
go
through
the
steps,
and
it
kind
of
shows
you
on
the
screen
kind
of
steps
that
it
goes
through
to
build
a
code.
So
that's
an
excellent
resource
and
I
just
wanted
to
point
out
one
other
resource.
A
Top
of
the
page,
the
TDI
K
T
GI
k
is,
thank
god,
its
kubernetes
and
it's
a
live
youtube
feed
run
every
friday
from
the
it
started
off
with
folk
at
hip.
T,
oh,
but
there's
lots
of
contributors
who
contribute
to
it.
So
it's
a
kind
of
an
hour,
hands-on
job
ADA.
Does
it
a
lot
Chris
Nova
and
they
spend
an
hour
on
Friday,
just
literally
taking
a
something
that's
of
interest
in
the
open-source
community
and
just
you
know,
line
by
line
just
going
through
the
code.
A
So
there's
been
three
kind
of
episodes
in
and
around
Q
builder
and
controllers
and
operators,
and
that
episode
40,
the
first
one.
It's
it's
really
useful
for
going
through
right,
step-by-step,
let's
go
through
Q
builder
and
let's
go
through
step
by
step.
How
we
use
that
to
build
me
an
operator,
and
it's
it's
it's.
You
know
as
I
say
it's
hands-on
so
that
it's
like
the
person
who
does
it
it's
generally
looking
at
that
project
for
the
first
time
as
well.
A
So
you
kind
of
get
a
feel
that
you
know
when
you're
kind
of
in
it
together
we're
going
to
look
at
this
project
today
and
we're
going
to
figure
out
how
it
works
and
then
there's
two
others
on
minecraft
building
a
controller
for
Minecraft
and
then
another
one
building
in
controller.
So
there
was
like
number
seven.
A
First,
then
40,
then
83
but
I'd
encourage
you
to
have
another
TGI,
okay,
not
just
for
the
Q
builder
stuff,
but
there's
like
there's
98
episodes
now
so
there's
like
pretty
much
everything
to
do
with
kubernetes
in
the
ecosystem,
there's
probably
being
an
episode
of
that.
So
have
a
look
at
that.
So
there's
no
more
question
any
questions.
A
A
It
depends
what
you
wanted
to
do,
what
kind
of
access
that
controller
or
the
operator
running
in
a
pod
might
need
to
the
outside
or
whether
you're
prepared
to
grant
that
automatically
or
whether
you
implement
some
sort
of
manual
process,
but
because
it's
because
it's
your
code
at
the
end
of
the
day
you're,
it's
your
system
that
you're
trying
to
get
kubernetes
to
manage
it's
your
application.
Then
those
kind
of
decisions
are
yours.
A
Most
of
the
stuff
I've
seen
is
implemented
in
cluster,
but
there's
generally
some
sort
of
write
out
so
like
I've
seen
one
where
every
time
like
a
team
provisioned
something
in
a
namespace,
then
there
was
a
write
out
to
it
and
eternals
like
internal
but
external,
to
the
cluster
CMDB.
That
kept
a
record
of
that.
So
they
could
kind
of
use
that
information
to
kind
of
understand
who's.
Doing
what
externally,
like
in
their
service.
A
Now
type
externals
CMDB
system
that
they
had
so
those
kind
of
things
like
so
you
can
get
kubernetes
to
watch
and
then
one
of
the
things
the
actions
of
a
change
in
the
thing
it's
watching
hope
you
didn't
write
something
out
to
keep
a
track
of
it
or
indeed
raise
a
ticket
like
ServiceNow
to
get
up
seen
that
done
as
well
before
some
people
still
want
to
have
that
ticket
based
system
and
something
happens
automatically
then
create
a
ticketing
service.
Now
any
more
questions,
excellent.
A
Now
so
the
question
was
like
hew
builder
or
operator
framework:
no,
not
really
I,
just
I
looked
at
operator
framework
first
because
it
had
the
answerable
bits
in
and
then,
as
my
kind
of
go
knowledge
got
a
bit
better.
I
was
kind
of
looking
at
the
go
elements
and
then
sort
of
internally.
With
my
team
there
was
a
lot
more
folks,
looking
at
queue
builder,
so
I
just
looked
at
that,
but
it
kind
of
like
anything,
there's.