►
From YouTube: What's New in Operator Framework?
Description
Don’t miss out! Join us at our upcoming hybrid event: KubeCon + CloudNativeCon North America 2022 from October 24-28 in Detroit (and online!). Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
What's New in Operator Framework? - Jonathan Berkhahn, IBM; Varsha Prasad, Jesus Rodriguez & Austin Macdonald, Red Hat
This session covers recently added features in Operator Framework, particularly the Operator SDK CLI. We'll walk through scaffolding a Java operator using the newly-added Quarkus plugin, discuss how to add custom login to a Helm operator with the Hybrid-Helm feature, or how to best test your operator.
A
A
So
what
is
operator
framework?
It's
an
open
source
toolkit
to
help
you
create
and
manage
your
operators.
There's
two
key
projects
operator
sdk,
which
is
the
cli.
It's
an
extensible
toolkit
that
can
scaffold
out
your
projects
and
help
you
create
bundles
to
integrate
with
olm
olm
operator.
Lifecycle
manager
will
help
you.
It
helps
you
get
your
install,
manage
and
upgrade
your
operators.
So
basically
it
takes
away
a
lot
of
the
hard
work
and
just
kind
of
lets
it
run
and
manage
it
for
you.
A
So
what
are
java
operators
they're
effectively,
operators
that
you
write
in
java,
simple
as
that,
so
they
we've
currently
have
go
and
ansible
and
helm
support.
So
now
we
can
actually
help
you
create
your
operator
scaffold
it
out.
In
native
java
we
were
able
to
do
this.
There
is
a
new
plugin
java
operators,
plugin,
which
integrates
with
sdk,
that
does
the
scaffolding
of
it,
and
then
there
is
a
java
operator,
sdk
project
that
was
started
by
another
group
that
is
effectively
a
controller
runtime
library
like
except
written
in
java.
A
A
bunch
of
java
developers,
everyone
says
it's
the
popular
enterprise
language,
so
we
wanted
to
kind
of
target
there.
We
have
a
mantra
of
meeting
the
developers
of
where
they
are
so,
instead
of
forcing
folks
to
learn,
go
and
write
the
operator,
let's
get
to
them,
where
they
feel
more
comfortable.
That's
how
we
got
ansible.
So
a
lot
of
folks
were
hey.
I
need
to
get
operators
written,
I
need
to
deploy
my
stuff
and
they
already
had
play
books
and
things
and
ansible.
A
So
we
kind
of
we
went
there
and
then
helm,
charts,
hey
I've
already
got
a
helm
chart
and
I
have
to
do
an
operator.
Can
I
get
started
so
we
did
a
helm
operator.
This
is
the
same
thing.
There's
been
a
lot
of
chatter
of
folks
wanting
to
be
able
to
write
their
operators
in
java,
so
this
was
kind
of
a
likely
good
candidate
and
good
path
to
go
down.
A
So
phase
two
plugins,
so
phase
two
is
in
cube
builder
it'll,
soon
be
into
sdk
when
we
bring
in
the
next
release
of
qbuilder.
So
what
is
a
plug-in
wikipedia
says
it's
a
software
component
that
adds
a
specific
feature
to
an
existing
computer
program.
That's
exactly
what
the
plugins
have
been
doing
with
operator
sdk.
A
So
we
have
three
main
methods
in
it:
create
api
and
create
api.
I
mean
web
hook,
so
these
plugins
allow
us
to
extend
those
features.
So
when
you
do
in
it-
and
you
give
us
the
plugin
of
go
ansible,
helm
and
now
java,
we
can
create
the
specific
plugins
that
you
need.
The
specific
operator
project
that
you
need.
A
So
phase
two:
what
about
the
other
phases
so
phase?
One
is
when
we
introduced
the
plug-in
architecture
to
operator
sdk.
So
this
again
allowed
us
to
go
beyond,
go
and
add
specific
languages
and
extend
the
features
to
it
right
now.
The
phase
one
plug-ins
are
all
go
based,
so
they
have
to
be
compiled
into
the
sdk.
A
A
A
So
what
is
phase
two
phase?
Two
allows
for
out-of-tree
plug-ins,
so
they
will
no
longer
have
to
be
compiled
into
the
operator
sdk.
They
don't
have.
They
can
be
have
their
own
release
cycle,
they
can
be
written
in
any
language.
We
basically
have
a
simple
input.
We
give
you
a
there's,
a
universe
that
we
pass
in.
Everything
is
done
right
now
through
standard
in
and
standard
out,
and
we
can
call
your
external
plugins.
We
have
discovery,
so
we
know
to
find
and
where
your
plugin
is,
and
we
can
run
that
in
the
current
implementation.
A
A
B
Oop,
hello,
is
this
thing
on
okay?
So
let's
do
some
more
show
of
hands
who
here
has
worked
on
an
application
that
was
deployed
to
kubernetes
via
a
helm,
chart
okay.
So,
unsurprisingly,
most
of
you
are
pretty
familiar
with
helm
charts.
Who
here
has
tried
to
make
a
helm
operator
based
on
those
charts?
B
B
B
Now
today,
when
you
build
a
helm
operator,
you
get
everything
baked
into
an
image
that
we
control
and
it
just
sort
of
you
know
you
get
the
image
you
can't
really
control.
What's
going
on,
so
the
hybrid
helm
operator,
rather
than
having
everything
be
pre-baked
into
an
image,
we
make
it's
more
similar
to
the
golang,
where
it's
gonna
spool
out
a
bunch
of
scaffolding
on
your
machine
and
you
can
go
in
and
edit
the
various
pieces
of
it.
B
It's
a
separate
repository
from
sdk
for
the
moment
that
contains
all
these
helpful
helper
functions
and
we're
gonna
go
ahead
and
do
a
demo
of
it
right
now.
Now
I've
been
having
this
I've
been
fighting
with
this
all
yesterday,
because
the
conference
internet
is
awful,
but
hopefully
my
cluster
is
still
up,
and
this
should
work.
B
B
Okay,
so
we're
gonna
go
ahead
and
knit
a
hybrid
home
operator
we're
going
to
use
the
bitnami
wordpress
chart
sort
of
the
hello
world
of
helm.
It's
a
non-trivial
example
stands
up
a
wordpress
instance,
that's
backed
by
I
think
by
the
default
configuration
it's
a
mariadb
instance
and,
of
course
this
would
take
forever
to
run.
B
Oh
no,
there
it
goes
okay.
So
if
you're
familiar
with
what
the
go
operator
looks
like
this,
should
look
pretty
similar,
we've
scaffold
it
out
the
basic
framework.
We
have
a
main.go
which
is
going
to
run
the
controller
manager
and
it's
going
to
have
a
reconciler,
that's
configured
with
the
helm,
chart
and
some
pretty
basic
defaults
and
then
we're
going
to
go
ahead
and
add
the
type
based
on
the
wordpress
chart.
B
B
B
B
Okay,
so
I'm
spooling
up
the
controller
here.
This
is
what
was
built
out
of
that
main.go.
So
if
we
wanted
to,
if
you're
familiar
with
how
the
controller
manager
and
the
controller
tools
and
controller
runtime
libraries
work,
that's
the
same
as
the
one
that
runs
in
the
go
operator
and
provided
your
handy
with
a
little
bit
of
go,
you
can
go
in
there
and
make
it
do
whatever
you
want.
Now
it's.
B
B
B
Let's
go
ahead
and
make
it
do
something
fancy
so
like.
I
said
this
is
the
go
code,
if
you're
all
familiar
with
how
controller,
runtime
or
controller
manager
works.
This
is
the
same
thing.
We're
going
to
go
in
and
use
one
of
those
helper
functions.
I
was
talking
about
so
like
I
said
we
have
a
helper
function
that
lets
you
set.
B
B
I
know
this
is
fairly
simplistic.
I'm
just
doing
you
know
basic
string
to
string,
but
because
this
is
happening
in
go
code,
you
could
do
you
know,
get
as
fancy
as
you
want
here
and
have
override
files
based
on
what's
going
on
in
the
cluster.
You
know
even
spin
up
go
controller
tools,
reconciliation,
loop
and
do
whatever
you
want
in
that.
B
B
B
B
B
So
even
if
you're,
not
the
handiest
with
writing
your
own
custom
reconciliation
loop
and
go,
if
you
know
assuming
you've,
already
got
this
thing,
packaged
as
a
helm,
chart
you've
probably
used
some
of
these
abstractions
and
you
can
just
go
ahead
and
add
them
to
your
operator.
With
these
helper
functions.
B
Has
a
different
name,
even
though
that
wasn't
what
I
declared
in
the
cubiaml,
so
I
used
my
override,
so
that's
just
a
short
demo
for
hybrid
helm,
let's
go
ahead
and
keep
going
so
that's
sort
of
what
we
we
have
everything
we
just
mentioned
with.
I
guess
the
exception
of
phase
two,
but
like
the
java
operator,
hybrid
helm,
that's
all
in
the
release.
You
can
go
download
that
and
use
it
right
now
today.
B
Now
we're
gonna
briefly
cover
some
of
the
stuff
we're
working
on
coming
in
the
future,
so
for
operator
sdk
right
now,
we're
working
on
external
bundle
validation.
So
what
is
a
bundle?
A
bundle
if
you've
ever
used
olm
a
bundle
is
the
artifact
you
produce
that
encapsulates
a
specific
version
of
your
operator
to
then
be
consumed
and
deployed
by
olm.
B
Currently,
when
you
generate
a
bundle,
it
runs
a
suite
of
validations
against
it,
but
those
validations
are
entirely
opaque
because
they're
compiled
into
the
sdk
they
happen,
whether
you
want
them
to
or
not-
and
you
can't
add
additional
validations
for
that.
So
we're
breaking
that
out.
We're
going
to
allow
arbitrary
validators
to
be
our
validators
to
be
called
from
arbitrary
binaries.
B
B
So
this
is
what
phase
two
was
talking
about,
so
like
jesus
mentioned
currently
today,
even
like
the
java
operator
is
written
and
go,
which
is
kind
of
weird
we're,
hoping
that
this
will
allow
the
community,
like
I'm
aware
of
there's
the
job
operator,
there's
also
a
python
framework
out
there.
But
this
will
allow
the
community
to
say
if
they
want
a
rust
operator
framework
or
python
or
whatever
arbitrary
language.
You
want
that
they'll
be
able
to
go
and
write
that
and
they
won't
be
dependent
on
us
as
a
bottleneck.
B
You've
got
to
extricate
itself
from
the
database,
so
this
is
being
replaced
with
just
a
sort
of
a
file
based
catalog.
That's
what
it's
called
where
this
stuff
is
just
going
to
be
stored
in
plain
text
yaml,
which
hopefully
should
be
a
lot
easier
for
a
human
to
use,
especially
because
we're
all
familiar
with
cutting
yaml
up
and
down
to
use
kubernetes
itself
and
then
also
coming
down.
The
pike
is
ruck
pack,
so
that's
the
name.
They
came
up
with
it,
but
basically
what
it
is.
B
It's
olm
2.0,
so
they're
going
to
be
doing
a
major
version
bump
of
olm,
so
the
api
is
going
to
be
entirely
different.
It's
going
to
be
based
more
around
the
concept
of
the
bundle,
so
right
now
today,
when
you
need
your
operator
to
be
usable
with
olm,
you
make
this
thing
called
a
bundle,
but
it's
it's
a
collection
of
artifacts
and
doesn't
really
have
any
one-to-one
correspondence
with
like
actual
kubernetes
resources
that
get
created
by
olm.
B
Eventually,
we're
going
to
have
support
for
generic
bundles,
so
rather
right
now
today,
where
we
have
our
own
one
specific
bundle,
format
that
we
create-
and
you
have
to
you
know,
use
that
we're
hoping
to
have
support
for
generic
bundles,
so
a
bundle
can
be
backed
by
multiple
different
kinds
of
resources.
We
could
stick
with
the
bundle
type
that
we
have
today
or
you
could
like
have
a
bundle,
that's
backed
by
a
helm,
chart
and
that's
how
your
operator
is
packaged.
B
So
hopefully
this
will
be
helpful
if
you
don't
actually
care
about
that.
You
just
want
to
keep
using
olm
when
the
upgrade
happens.
All
the
commands
you
use
with
operator
sdk
to
generate
use
bundles
today
should
still
work.
Everything
should
happen
behind
the
scenes,
so
individual
users
and
authors
won't
have
to
worry
about
it.
B
C
D
Hi
so
last
week
I
wrote
my
first
java
operator
with
the
quarkx
sdk.
It
was
really
great
fun.
The
part
I
was
struggling
a
bit
with
was
the
status
implementation,
so
there
are
really
good
examples,
etc.
But
I
I
was
having
a
bit
of
a
hard
time
on
how
to
streamline
that.
So
I
think
there's
the
other
go
project
cube
builder,
where
you
have
the
more
or
less
a
defined
standard,
saying,
status,
changes
like
last
transition
message,
etc.
Are
there
any
plans
on
standardizing
this
part
as
well?
A
The
the
java
s
java
operator,
sdk
library,
does
they
are.
They
are
attending
the
q
builder
and
controller
runtime
meetings
as
well,
and
so
what
they're
trying
to
do
is
it's
not
going
to
be
completely
feature
parity,
but
there
are
common
things
that
happen
on
the
go
and
control
the
runtime
side
that
they
try
to
implement
on
their
side
that
come
up
so
as
far
as
a
concrete
plan
of
yes,
it
will
be
the
same.
I
can't
say
that
for
sure,
but
they
are
aware.
A
So
I'm
sure,
what's
going
to
happen,
is
they'll
look
at
it
and
then
try
to
get
it
as
close
as
possible
to
that
one.
The
java
meeting
is
every
thursday
at
11
a.m.
Eastern,
which
I
think
is
5
00
p.m,
central
european
time.
So,
if
you
ever
have
a
concern
you're
more
than
welcome
to
join
that
meeting
and
and
and
bring
it
up-
and
we
can
always
have
a
conversation
about
it
as
well.
D
A
With
with
corcus
their,
we
haven't
done
full
like
performance
numbers
on
it,
from
what
we've
seen
with
quarkus
like
startup
time,
it's
a
just
a
little
hair,
a
hair
slower
than
starting
native
go
but
quark
is
in
native
mode
is
way
faster
than
starting
a
jvm
operator.
So
that's
one
of
the
reasons
we
targeted
quarkus
first
is
to
allow
that
to
get
you
there
faster.
A
C
C
What
is
it
so?
I've
used
the
original
helm
operator
where
it
did
just
take
the
helm,
charts
and
it
did
generate
code
and
you
couldn't
get
at
the
code.
So
is
this
extension
or
this
new
hybrid
code
and
ability
for
if
people
have
the
hand
chart
and
then
they
want
to
come
on
and
add
extra
stuff
to
control
afterwards,
did
you
find
that
people
were
limited
when
they
had
the
original
one.
A
Yes,
one
of
one
of
the
primary
reasons
for
doing
the
hybrid
helm
was
a
lot
of
folks
would
start
with
the
helm
operator
and
then
realize
that
they
wanted
to
do
more
and
they
would
often
abandon
it
and
go
to
create
a
go
operator
and
so
that
they
could
have
more
control.
So
one
of
the
reasons
we
did
the
helm,
the
hybrid
helm
is
to
by
default
it
generates.
It
looks
just
like
the
old
helm
one,
but
because
you
have
access
to
the
main.go
and
actual
reconciliation
loop
and
there's
also
a
library
in
there.