►
From YouTube: Operators Everywhere - Jason Dobies and Josh Woods(Red Hat) | OpenShift Commons Gathering KubeCon NA
Description
Operators Everywhere
Jason Dobies and Josh Woods(Red Hat)
OpenShift Commons Gathering KubeCon NA
November 17 2020
Join Red Hat's Josh Wood and Jason Dobies, co-authors of the Kubernetes Operators book (O'Reilly, 2020), for a surveillance flight over the Operator development landscape. Your co-pilots will direct your attention out of the cabin windows to identify the biggest news and latest features in the Operator Framework for building and distributing Operators. Get a quick backgrounder on the purpose and adoption of Kubernetes Operators, and what it means that the Operator Framework became a CNCF incubating project this summer. Gaze at the new features and upstreamward standardization resulting from the Operator SDK's adoption of Kubebuilder's extensions and project layouts, and learn about the alternative ways to build Operators in a variety of languages that have sprung up around the community.
466764 Operators Everywhere
A
Hi,
I'm
josh
wood,
a
developer
advocate
for
openshift
at
red
hat
and
I'm
joined
by
my
colleague,
jason
dobies
and
sometimes
co-author.
We're
going
to
tell
you
about
all
the
exciting
updates
that
have
happened
over
the
course
of
2020
that
have
seen
new
adoption,
new
features,
new
frameworks
and
new
initiatives
for
operators
and
the
tools
that
we
use
to
support
and
construct
them.
A
So
we'll
dig
into
a
little
bit
about
what
operators
are
and
make
sure
we're
all
on
the
same
page
and
then
we'll
take
a
look
at
things
like
our
recent
induction
into
incubation
at
the
cncf,
with
the
frameworks
and
tools
that
we
use
to
build
operators
and
some
of
the
new
features
that
that's
brought
into
the
sdk
and
the
olm
before
we
get
too
deeply
into
that.
Let's
take
a
look
at
what
operators
are
and
why
you
care
about
them
in
the
first
place.
A
I
usually
like
to
start
talking
about
this
at
a
really
high
level,
because
the
pattern
that
operators
enable-
and
it
lets
us
let
us
do
advanced
automations
on
the
kubernetes
platform
and
they're
really
distinct
in
terms
of
what
we
want
to
accomplish,
with
them
from
the
implementations
and
the
techniques
that
we
use
to
accomplish
those
things.
So
what
I
always
say
is
we
care
about
operators
and
operators
are
important
because
any
application
on
any
system
or
platform
has
to
be
installed,
configured
managed
and
upgraded
over
time.
A
We
see
this
with
web
browsers
and
automatic
updates
so
that
we
get
the
latest
security
patches,
we're
very
used
to
it,
with
app
stores
and
the
applications
that
run
on
our
mobile
phones
and
certainly
our
operating
system
package
managers
have
delivered
automatic
updating
facilities
and
maintain
our
applications
configurations
through
new
versions
of
that
software.
Those
those
same
things
are
desirable
for
the
applications
that
we
deploy
at
scale
on
kubernetes
or
on
openshift
clusters.
A
So
with
that
idea.
Any
of
those
functions
from
installation
to
patching
for
security
to
applying
upgrades
for
features
into
keeping
software
running
any
of
those
processes
that
aren't
automated
are
slowing
you
down.
In
fact,
that's
what
brought
a
lot
of
us
to
kubernetes
in
the
first
place,
the
idea
of
how
easy
kubernetes
makes
it
to
automate
the
lifecycle
management
of
simple
stateless
applications.
A
If
you
imagine
a
web
server,
all
it
does
is
listen
for
requests
over
http
and
then
return
file
system
content.
In
response
to
the
file
named
in
that
request
to
some
http
client,
it
doesn't
record
state
about
the
session.
It
doesn't
store
data
or
read
and
write
new
data
in
a
user's
record
or
in
some
persistent
underlying
database.
A
It's
in
fact
completely
stateless.
Any
other
web
server
can
replace
it
if
that
piece
of
software
falls
over
it's
very
easy
for
ourselves
or
for
kubernetes
to
automatically
start
running
a
new
copy.
If
we
want
to
scale
from
one
copy
to
three
or
five
copies
to
handle
increased
an
increased
number
of
users
coming
to
our
website
or
our
service,
that's
also
really
easy
for
kubernetes
to
do.
In
fact,
we
can
scale
a
fungible,
simple,
stateless,
app
like
this
up
and
down
just
by
adding
new
copies
new
replicas.
We
can
say
something
like
coop
cuddle
scale.
A
It's
still
pretty
easy
to
move
to
the
next
stage
to
the
kind
of
persistent
or
clustered
apps
that
generally
lie
at
the
bottom
of
an
application
stack.
Stateless
design
is
great.
Managing
stateless
applications
on
kubernetes
is
easy
and
cool,
but
somewhere
down
the
line.
Most
real
world
applications
have
to
store
persistent
data,
maintain
a
sense
of
state
and
many
of
those
applications.
A
If
you
think
about
databases
and
file
system
clusters,
even
have
their
own
notion
of
what
it
means
to
be
a
member
of
a
cluster
to
join
a
cluster,
a
database
might
need
authentication
assets
or
to
know
about
who
the
read,
leaders
and
or
write
leaders
and
read.
Followers
are
in
a
cluster
of
nodes
comprising
comprising
a
database
server
cluster,
so
deploying
a
database
on
kubernetes
is
not
really
any
more
difficult
than
deploying
our
stateless
web
server.
A
This
takes
detailed
knowledge,
the
internal
state
of
the
application,
and
we
have
to
connect
that
new,
that
new
pod
we
bring
up
to
replace
a
failed
member
in
our
cluster
needs
to
know
about
how
to
join
the
cluster.
As
I
mentioned
before,
there's
a
question
of.
Do
I
need
authentication
assets
to
become
a
cluster
member.
Do
I
need
to
know
what
my
position
in
the
cluster
is,
and
I
need
to
know
api
and
networking
endpoints
so
that
I
can
begin
communicating
with
the
remaining
cluster
members.
Now,
that's
usually
up
to
a
human
operator.
A
We
call
them
dbas
a
lot
of
times.
If
we're
talking
about
a
cluster
of
file
system
servers,
we
might
call
them
a
systems
administrator
or
even
an
ops
team,
but
somewhere
rather
than
automating.
These
processes
for
complex
stateful,
apps,
there's,
usually
human
knowledge
required
of
that
application's
internal
state.
A
So
you
can
think
of
of
operators
as
software
site,
reliability,
engineers
that
manage
the
whole
life
cycle
of
complex
stateful
applications
on
kubernetes
clusters.
So,
while
kubernetes
is
excellent
at
scaling,
your
stateless
web
server
up
and
down,
perhaps
even
automatically
in
response
to
increasing
or
decreasing
demand
at
given
times
kubernetes
operators
teach
a
particular
cluster
about
managing
the
whole
life
cycle
of
a
particular
application,
and
in
fact
that
that
coupling
is
so
tight
that
we
often
refer
to
the
software
that
an
operator
manages
as
that
operator's
operand.
A
So
you
can
think
of
this
combination
of
a
custom
controller
with
a
set
of
custom
resources
that
it
watches,
reacts
to
watch
events
and
takes
actions
to
reconcile
in
the
real
world
running
on
the
cluster.
As
this,
the
simplest
definition
of
what
a
kubernetes
operator
is
now
pictorially.
It
looks
a
little
bit
like
this
illustration
of
our
usual
process.
Inside
of
the
kubernetes
control
plane.
We
have
this
idea
of
a
reconciliation
loop
that
runs
in
response
to
changes
that
the
controller
is
notified
of
by
watch
events
instead
of
the.
A
A
Now,
because
that's
a
pattern
rather
than
a
particular
product
or
a
specific
technology.
It
makes
sense
for
us
to
to
develop
both
the
pattern
and
the
tools
and
distribution
frameworks
we've
built
in
an
open
way,
and
so
the
first
bit
of
really
cool
news
about
operators
that
we
can
talk
about
happening
in
the
latter.
Half
of
2020
is
the
donation
by
red
hat
of
the
operator
framework
to
the
cloud
native
computing
foundation.
A
The
way
we
use
operators,
for
example,
inside
of
red
hat's,
open
shift,
kubernetes
distribution
as
as
our
way
of
extending
adding
features
to
and
building
atop
the
kubernetes
core
of
openshift
to
provide
the
day.
Two
enterprise
features
that
that
product
is
all
about,
so
the
cncf
as
a
neutral
foundation
to
to
oversee
the
governance
of
these
of
these
kinds
of
projects
is
a
really
good
place
for
community
oriented
development.
A
Like
the
kind
we've
tried
to
do
on
the
two
main
components
of
the
operator
framework,
that
is,
the
operator
sdk
for
building
operators
and
the
operator
lifecycle
manager,
which
is
sort
of
an
operator
for
operators
that
manages
discovery,
distribution
and
continuing
updates
to
the
operators
that
are
running
on
a
cluster.
While
those
operators
in
turn
manage
their
operands
the
applications
that
they
manage
and
manage
and
keep
up
to
date
over
their
entire
lifecycle.
A
This
underlines
the
design
in
kubernetes
itself,
where
the
api
has.
These
modular
extension
points
that
you
can
create
in
the
form
of
custom
resource
definitions
and
then
use
and
manage
those
custom
resources,
and
those
are
the
benefits
we
see
from
joining
that
community,
which
makes
it
clear
that
other
developers
in
the
community
who
are
working
on
operators
can
be
involved
in
the
management
and
the
the
the
future
planning
of
features
and
fixes
in
both
parts
of
the
framework.
A
The
sdk
and
the
olm,
and
my
good
friend,
jason
dobies,
also
from
red
hat,
is
about
to
give
us
the
details
of
that
that
donated
version
of
the
operator
framework,
especially
focusing
on
the
sdk,
but
with
some
notes
about
the
the
operator
lifecycle
manager
as
well
so
without
too
much
further
ado.
I'd
like
to
turn
it
over
to
jason.
Take
it
away.
Jay.
B
Thank
you
josh
for
that
completely
spontaneous
and
unscripted
transition,
so
he
introduced
the
sdk
and
olm
the
cncf
incubation
and
so
forth.
Let's
talk
a
little
bit
more
about
the
sdk
itself,
so
some
quick
background,
the
sdk
is
exactly
what
you
would
expect
out
of
an
sdk.
It
is
generates
project
scaffolding.
It
generates
a
fair
amount
of
code
for
you
and
really
sets
you
up
at
the
point
of
hey
here's
the
basis
for
an.
B
Now
it's
time
to
implement
your
business
logic
and
then
it
has
some
build
utilities
for
you.
If
you've
done
those
pieces,
you've
tied
in
you've
tested
as
necessary
now
we
can
actually
build
this
operator
and
ship
it
and
make
it
usable.
So
this
is
a
very
high
level
overview
of
what
the
sdk
does.
But
again,
if
you
know
what
an
sdk
is
in
general,
you
have
a
pretty
good
idea
of
what
to
expect
from
it.
B
Now
the
operator
sdk
itself
and
again
we're
talking
about
this
particular
cncf
project,
which
is
one
avenue
for
writing
operators
or
for
facilitating
writing
operators
more
easily
supports
three
different
ways
of
assembling
your
operators
going
from
right
to
left.
Actually,
the
full
programmatic
way
supported
in
the
operator
sdks
using
the
go
programming
language,
not
a
surprise
there.
B
The
sdk
also
has
the
ability
to
generate
scaffolding
code
that
will
run
an
ansible,
playbook
or
a
helm
chart
for
you.
So
if
you
already
invested
in
those
infrastructures
in
your
enhanceable
shop
or
you're,
very
heavily
invested
in
helm,
you
don't
necessarily
have
go
developers.
You
can
absolutely
still
use
the
sdk
and
the
benefits
there.
There's
a
lot
more
than
I
want
to
cover
in
this
talk,
but
everything
in
terms
of
the
delivery
through
life
operation
operators,
life
cycle
manager
to
the
interface
using
custom
resource
definitions.
B
B
B
Right
now,
because
she
would
know
better
than
me
if
comments
are
still
around
and
openshift
too,
but
I
imagine
we
have
a
fair
amount
of
new
users
in
the
past
couple
years.
Openshift
2
was
our
own
attempt
at
a
similar
type
of
concept,
and
those
of
you
who
were
around
back
then
will
remember
things
like
cartridges
and
the
other
terms
eluding
me
right
now,
but
we
had
these
concepts
and
looked
around
the
industry
and
said
you
know
what
this
seems.
B
Now
I
mentioned
that
because
those
of
you
who
may
have
used
the
sdk
in
this
pre
1.x
version,
it's
going
to
look
a
little
bit
different.
Now
again,
we
started
out
with
this
custom
idea.
We
knew
we
had
something
we
wanted
to
solve.
Let's
play
with
some
code,
let's
see
what
sticks
and
get
these
ideas
out.
B
There
and
as
things
started
to
mature
for
1.0
or
or
I
should
say
in
the
road
to
1.0,
we
looked
around
the
industry
and
once
again
realized
that
we
don't
need
to
be
competing
with
a
lot
of
these
upstream
projects.
We
could
easily
be
contributing
to
and
really
leveraging
for,
the
benefit
of
both
the
upstream
product
as
well
as
ours.
So
a
lot
of
one.x
has
been
revamped
to
use
q
builder
in
particular,
but
we
also
have
some
integration
with
customize
and
cuddle
and
probably
a
few
other
projects.
B
That
begin
with
k
that
I
haven't
actually
listed
here.
I
know
I
don't
have
time
to
make
this
reference,
but
I
come
from
a
java
background
and
everything
began
with
j
and
20
years
into
my
career.
Now,
I'm
seeing
everything
begin
with
k
and
it's
just
a
really
bizarre
parallel
point.
Being
one.x
is
going
to
look
a
little
bit
different
because
we've
done
this
rebase
on
top
of
q
builder
and
again
that's
for
a
number
of
reasons
that
we
don't
want
to
put
up
the
perception
of
competing
with
these
other
projects.
B
B
One
of
those
contributions
came
in
the
form
of
a
cli
framework
where
you
can
do
plug-ins
to
the
cube
builder
and
we
worked
with
the
upstream
and
we
got
those
that
functionality
landed
and
as
such,
the
sdk1.x
has
been
rebased
to
now
use
plugins
into
cube
builder.
So
if
you
have
an
existing
q
builder
project
or
if
you're
just
getting
started
and
you're
worried
about,
oh,
am
I
buying
into
a
particular
type
of
project
structure,
or
am
I
locking
myself
out
of
something
in
the
future
you're
not.
This
is
compatible
with
everything.
B
Q
builder
is
going
to
do
so.
The
project
structure
is
going
to
look
a
little
bit
different
than
in
the
xero.x
days,
but
it's
more
consistent
with
what
other
projects
in
the
industry
are
doing.
You'll
see
at
that
bottom
that
list
of
commands
a
lot
of
them
use
make
now,
which
is
again.
I've
been
in
this
industry
long
enough
to
kind
of
laugh
at.
Oh,
my
god,
meg
is
back.
So
you'll
see
some
of
the
workflows
may
have
changed,
but
all
the
functionality
is
still
there.
B
We
really
just
kind
of
gutted
a
lot
of
the
pieces
that
we
were
duplicating
or
we
could
better
contribute
to
upstream.
So
the
project
scaffolding,
a
lot
of
that
came
from
qbuilder.
A
lot
of
these
generation
pieces
that
you're,
seeing
in
terms
of
the
crds
and
the
other
files
we
use
for
olm,
are
based
on
top
of
customize
the
operator.
So
the
other
thing
that
we've
added
into
the
sdk
is
generation
for
a
lot
of
the
pieces
necessary
for
olm.
I
remember
from
what
josh
said
operator.
Lifecycle
manager
olm
is
effectively
yum.
B
B
It
is
pretty
verbose
and
it
did
take
quite
a
bit
of
manual
effort
to
get
created.
Now.
All
of
that
is
going
to
be
handled
by
the
operator
sdk
for
you
so
being
able
to
run
a
few
commands
point
it
at
your
operator
and
say
hey.
I
want
you
to
generate
me
the
pieces
I'm
going
to
need
for
olm
and
it's
not
just
that
because
as
the
sdk
evolves
so
did
olm
and
their
new
packaging
format
is
this
notion
of
an
operator
bundle.
B
This
bundle
is
itself
shipped
as
a
container
image
and
in
the
future,
that's
going
to
use
the
artifact
spec,
but
for
now
it's
simply
a
container
image,
and
that
contains
the
metadata
pieces
around
your
operator
and
that's
what
olm
uses
you
can
then
organize
those
metadata,
bundles
or
those
operator,
bundles
of
metadata
into
catalogs
and
make
those
available
to
your
cluster.
So
now
you
have
a
lot
better
organization
and
versioning
in
terms
of
subscriptions
coming
in
and
new
versions
of
operators
being
released
available
to
your
cluster,
but
bringing
this
back
to
the
sdk.
B
This
stuff
is
now
built
into
the
sdk
there's.
Also,
this
new
side
tool
called
opm.
That's
used
for
manipulating
these
bundle
images
in
these
catalogs.
So
that
way
you
can
much
more
easily
work
with.
I
have
this
set
of
operators,
and
I
want
to
organize
my
alpha
channel
my
beta
channel
and
my
stable
channel.
For
instance,
testing
is
a
good
thing.
The
sdk
is
obviously
going
to
help
with
that.
So
we've
integrated
with
this
project
called
cuddle.
B
I
might
have
it
written
down
what
it
stands
for,
but
whatever
the
case,
the
it's
kubernetes
testing
tool.
I
think
it
is
there's
a
lot
of
weird
capitals
in
there
point
being
this
tool
is
again
an
upstream
project
that
we've
pulled
into
the
sdk,
and
it
works
very
much
on
this.
Here's.
What
my
cluster
should
look
like
after
the
operator
runs
here
is
what
I
expect
it
to
look
like.
So
if
that
means
we
have
a
bunch
of
pods.
A
B
Or
some
services
and
all
these
extra
pieces,
this
cuddle
project,
we
reuse
all
of
their
formats
to
say,
hey
verify
these
states.
For
me,
it's
also
something
called
scorecard
and
you
can
see
the
link
at
the
bottom
there
and
that's
much
more
custom,
customized
testing
for
your
particular
operator
and
its
logic.
Now,
one
of
the
cooler
things
is
that
this
data
is
now
packaged
inside
of
this
operator.
Bundle
and
remember
this
is
a
separate
image
that
is
metadata
describing
your
operator.
B
B
B
It's
how
you
use
particular
constructs
inside
of
kubernetes
to
accomplish
something
and
just
saying
that
out
loud
you
can
realize
that
doesn't
mean
you're
necessarily
tied
to
a
language,
so
in
the
spirit
of
operators
everywhere
I
wanted
to
showcase
a
few
of
the
other
types
of
projects
and
frameworks
out
there,
and
I
myself
am
a
python
guy.
You
can
see
the
link
at
the
bottom
here,
the
speaker
who
sergey
apologies.
B
His
last
name
eludes
me
right
now
spoke
at
a
definition
event
a
couple
of
months
ago
about
the
the
kopf
framework
and
it's
the
kubernetes
operator's
python
framework
include
a
little
snippet
there.
I'm
obviously
not
expecting
anyone
to
copy
it
down.
But
if
you
do
know,
python
you'll
see
this,
and
this
feels
very
pythonic,
very
annotation
based
very
decorator
based
and
then.
A
B
Leave
this
up
for
another
half
a
second,
while
people
take
screenshots
or
pictures
but
definitely
watch
his
talk,
it
was
a
really
cool
introduction
to
it
and,
like
I
said,
I'm
more
on
the
python
side
of
things.
So
I'm
really
happy
to
see
this
gaining.
Some
traction
java
is
and
will
remain
for
the
foreseeable
future,
a
very
popular
language.
So
no
surprise
we
do
have
a
java
operator
sdk
up
in
the
community.
It
uses
your
again
your
typical
java
constructs
here.
B
So
your
basic
java
pojos
that
you're
already
working
with
and
then
we
have
ways
of
generating
your
controllers
now
you'll
notice
here
the
interface
looks
a
little
different
and
this
is
way
too
technical
to
go
down
in
this
talk.
But
this
takes
this
framework
takes
a
vastly
different
approach
than
the
operator.
Ck
does
that's
not
saying
it's
necessarily
better
or
worse,
but
if
you've
done
anywhere
with
operators.
So
far,
you
may
notice
this
delete
resource
and
creator
update
that
feels
a
little
different,
which
is
very
cool.
B
B
B
I
was
messing
around
with
something
and
I
decided
to
see
if
I
could
make
an
operator
function
in
bash,
because
again
it
is
purely
a
paradigm.
It
is
a
way
of
doing
things
on
top
of
kubernetes.
I
I
looked
at
the
code
and
I
thought
better
than
dumping
a
giant
shell
script
on
the
slide.
So
we
will
just
leave
that
as
react,
redacted,
but
you
can
see
the
the
repo
is
up
there
and
all
joking
aside
about
being
bashed.
B
B
A
Hey
jason,
that's
that's
funny
the
batch
thing
just
because
one
it
reflects
probably
some
of
the
very
earliest
mockups
and
models
of
the
operator
idea
years
and
years
ago,
and
two
because
early
on
in
containers,
we
used
to
joke
a
lot
about
re-implementing
docker
with
just
bash
scripts.
That's
what
that
made
me!
Think
of
while
you
were
while
you
were
telling
us
about
the
bash
framework
for
for
kubernetes
operators,.
B
A
The
operator
hubs
now
at
operatorhub.io
you'll
find
a
list
of
of
operators
ready
to
run
on
your
kubernetes
clusters,
or
your
openshift
clusters
that
have
olm
management
and
olm
itself
being
open
source
is
an
out
of
the
box
component
that
we
ship
with
every
single
openshift
kubernetes
distribution,
but
is
also
easily
available
with
instructions
available
at
operatorhub.io
for
adding
the
olm
to
your
vanilla
or
other
service
providers
or
other
distributions
that
that
are
running
your
kubernetes
clusters.
So
the
things
we're
talking
about
are
not
openshift
specific,
but
they
bring
this
sort
of
graphical
discovery.
A
User
experience
to
operators
that
that
we
think
is
one
of
the
big
reasons
why
people
are
adopting
and
building
them
for
the
apps
that
they
distribute
or
adopting
them
to
make
it
easier
to
build
those
apps,
because
it
makes
it
easier
for
their
developers
to
run
a
corporate,
approved,
stack
of
databases
and
middleware
or
one
way
or
another.
The
underlying
foundation
apps
that
that
are
key
can
be
consumed
along
with
a
built-in
automatic
lifecycle
manager
in
the
form
of
that
operator.
That
runs
that
application.
A
So
if
you
look
at
operatorhub.io
or
operatorhub
within
an
openshift
cluster,
you'll
find
a
way
that
for
for
for
administrators,
to
make
it
easy
for
users
on
those
clusters
to
self-service
to
to
get
these
operators
install
them
on
the
clusters
and
make
instances
of
the
applications
they
manage.
Whether
that
is
a
cluster
of
database
servers
file
servers
a
cluster
of
of
etcds
providing
raft
quorum
for
for
your
distributed
computing
project
that
runs
atop
ncd.
A
B
So
let
me
jump
in
while
you
took
that
quick
break
in
terms
of
integrated
vanilla,
kubernetes
like
it
is
straight
up
built
into
mini
cube.
If
you
look
at
the
mini
cubes
add-ons,
there
is
one
for
olm
and
just
installing
that
is
going
to
wire
up
a
source
directly
to
operator
hub.io,
so
it
is
as
simple
as
the
mini
cube
add-ons
and
then
you
just
start
creating
subscriptions
to
get
those
operators
deployed.
So
just
to
reiterate
this
message
that
this
is
not
an
open
shift,
specific
concept.
A
A
So
it
is
an
important
thing
to
bring
back
up
so
with
much
appreciation
for
the
half
hour
or
so
of
your
time
that
that
we've
already
taken
up
and
with
hopes
that
all
of
that
information
has
been
useful,
it'll
encourage
you
to
run
out
and
get
involved
in
operators,
whether
you
start
using
them
today
or
building
them
for
your
apps.
We
do
have
some
resources
that
you'll
find
in
these
slides
after
our
session.
I've
pointed
in
particular
to
operator
hub.io
as
a
distribution
point
for
operators.
A
If
you're
looking
for
how
to
build
operators
and
more
about
the
concepts
and
the
documentation
behind
the
operator
framework,
the
sdk
and
the
olm,
you
want
to
look
to
operator
framework
dot
io
that
first
link
on
the
slide,
and
obviously
we
can
never
resist
one
shameless
plug
for
our
book
with
o'reilly
jay's
even
got
a
copy
to
hold
up.
If.
A
If
you
ever
get
to
see
us
in
person
again,
we'll
be
have
so
happy
to
sign
a
copy
of
this
book
for
you
folks.
But
in
the
meantime,
if
you
follow
that
bottom
link
that
bitly
link
there,
that
is
a
pointer
to
a
an
addition.
An
electronic
edition
of
our
kubernetes
operator's
book
available
for
free
with
compliments
of
red
hat
and
open
shift.
A
There's
also
a
few
places,
we
would
point
you
to
get
in
touch
with
the
community
since
you're
at
a
community
event
like
commons.
In
the
first
place.
This
is
probably
going
to
be
important
and
part
of
what
you
want
to
know
about
how
to
find
operator
framework
mailing
lists
how
to
find
the
github
repos
that
contain
the
operator
framework
and
olm
source
code
and
how
to
join
the
common
special
interest
group
that
addresses
these.