►
Description
Updates and Best-Practices in Kubebuilder and Controller-Tools - Varsha Prasad Narsing, Bryce Palmer & Rashmi Gottipati, Red Hat; Tony Jin, Boston University; Camila Macedo, Replicated
If you have ever developed an Operator or controller you may have heard of the Kubebuilder and controller-tools projects. During this talk, we will cover some of the new features in recent releases of both Kubebuilder and controller-tools that aid in accelerating the development of Operators while adhering to best practices. A brief summary of the features we will be covering for Kubebuilder is creating/consuming external plugins, a new default scaffold layout, and two new built-in plugins. For controller-tools, we will cover how controller-tools can be leveraged to create custom generators.
A
Hello,
my
name
is
Camila
macedo,
but
that
is
not
important
at
all.
What
matters
is
the
context
prepared
by
us
to
share
with
you.
I
will
be
kicking
start
on
this
journey.
However,
if
you
want
to
know
more
about
us,
please
see
the
hair
forensic
Link
at
the
bottom.
You
can
check
out
our
profiles
on
the
kobecon
page
following
the
talks
that
we'll
cover
here.
It
is
only
to
let
you
know
what
it
is.
A
presentation
is
about
to
begin
with.
A
So
we
can
speak
about
good
practice
and
common
suggestions
waving
after
that
we
will
share
the
Kobe
Builder
updates.
Think
we
will
let
you
know
about
your
personal
plugins
and
how
they
can
help.
You
accelerate
the
development
of
your
Solutions.
We
also
is
speaking
here
about
the
Kobe
Builder
plugin
ecosystem.
Then
we
will
tell
you
more
about
controller
chain
and
controller
tools.
By
less,
we
will
say
how
you
can
interact
with
and
to
be
part
of
the
community.
Your
help
is
more
than
welcome.
We
are
willing
to
see
you
around.
A
A
It's
design
architecture
is
based
on
plugins
that
allows
users
be
able
to
choose
if
they
want
opt-in
or
not
for
specific
features,
helpers
and
sometimes
Integrations
I
will
not
do
a
spoiler
here
to
better
covered
into
stock.
That's
it
for
now.
I
just
would
like
to
share.
This
is
also
possible
using
could
be
built
as
a
library
and
then
take
advantage
of
its
features
and
implementations.
For
example,
imagine
if
you'd
like
to
create
a
tool
to
provide
specific
scaffolds
or
to
do
customizations
and
Integrations
on
top
of
your
watch
is
done.
A
Operator
we
added
here
a
PC
of
information
from
the
kubernetes
documentation.
Uk
news
could
be
Builder
to
build
a
solution
that
you
not
follow.
This
principle,
however,
could
be
Builder
is
designed
to
help
you
watch
if
it
is
gone.
Kubernetes
is
very
nice
and
very
cool,
but
we
need
to
make
our
Solutions
work
on
it.
As
you
know,
it's
not
English
task
and
definitely
there's
more
than
a
way
to
skin
a
cat.
A
A
A
A
Let's
return
to
our
deployment
example
to
help
us
to
illustrate
this
idea,
so
we
have
the
deployments
and
we
have
the
pods
defining
the
deployments.
Everything
is
running
and
finally,
on
the
cluster.
If
we
go
there
and
delete
the
pods,
what
happens?
Do
you
remember
that,
then,
in
this
case
the
body
will
be
recreated
without
our
intervention.
A
A
So
if
someone
or
another
solution
or
our
solution
to
self
it
creates,
deletes
or
updates
resource
on
the
host
that
matters
for
us
research
that
we
are
watching
for,
then
we
can
go
there
oops
we
need
reconcile.
We
need
to
be
looking
for
to
ensure
that
you
are
on
the
host,
as
we
want
to
be
now
that
we
are
all
in
the
same
page
about
opportunity
does
and
its
motivations.
We
can
share
that.
Jacobi
Builder
is
developed
on
the
top
of
controlling
time
and
controller
tools.
A
The
projects
built
with
Kobe
Builder
results
in
a
bond
that
runs
the
manager
into
PG
is
responsible
for
managing
the
controllers.
Controlling
time
is
the
leak
that
provides
abstractions,
meaning
to
help
us
to
manage
the
cheese
controllers
and
watch
the
resource
in
the
controller
tools
which
is
used
to
generate
Edge
code.
You
see
that
better
after
install
about
best
practice,
it's
very
common
people
ask
where
they
can
find
the
good
practices
where
I
can
find
the
cheese
information.
So
shall
we
try
to
do
a
small
overview
here?
A
A
A
Thus
it
is
why
the
to
ensure
that
we
understand
its
structure
and
that
it's
API
conventions
put
yourself
in
the
position
of
existing
a
dreaming.
Who
is
the
person
who
you
consume
and
to
use
our
solution?
This
person
knows
kubernetes,
so
ensuring
our
resolution
works
in
the
same
way,
you
make
their
life
much
easier.
A
Definitely
it
provides
a
much
better
user
experience,
let's
think
about
FM
designer
solution
to
run
onto
the
environments.
Why
not
think
is
this
problem
that
you
need
to
so
we
sort
out
by
kubernetes.
If
you
saw
how
kubernetes
does
it,
then?
Why
not
this
in
the
same
way,
for
example,
it
is
an
excellent
idea
to
track
the
stats
of
our
reconciliation
so
that
it's
possible
to
troubleshoot
and
to
know
if
something
goes
wrong
and
to
the
reason,
if
you
win,
it
is
possible.
A
How
does
kubernetes
API
do
each
of
a
resource
of
the
kind
deployment?
Do
it
not
check
these
thoughts
conditions
of
a
deployment
when
something
goes
wrong
in
this
way?
Let's
not
try
to
hang
to
the
hill.
We
can
do
it
the
same
way.
On
top
of
that,
see
that
we
can
use
kubernetes
leaves
into
implementations
to
achieve
our
goals
in
the
spend.
Our
efforts
in
what
we
need
to
sort
out
in
this
light
see
that,
as
a
tip,
we
are
sharing
the
project
API
Machinery,
which
provides
a
helper
to
work
with
stats
conditioners.
A
If
you
are
looking,
for
example,
by
looking
at
a
discount
for
Generation
by
the
deploying
image
plugin,
which
will
speak
a
little
bit
more
as
part
of
our
updates,
you
can
find
them.
The
next
tip
is
try
to
avoid
Your
Design
solution,
where
the
semi-controller
has
the
purpose
of
being
responsible
for
reconciling
and
to
manage
more
than
one
principal
kind.
A
For
example,
suppose
we
have
our
operator
projects
that
your
manages
our
resolution
and
our
resolution
has
more
than
one
component.
We
have
the
front
and
the
back
so
in
this
case
it
might
be
better.
We
have
a
custom
resource
definition
for
the
front
and
another
for
the
back
as
its
respective
controllers.
A
Furthermore,
this
might
hurt
Concepts
such
as
single
responsibility
by
Health
Concepts,
like
it
is
it's
much
bringing
the
expected
bite
side
effects
such
as
increase
the
difficult
of
growing
reusing
or
keeping
maintaining
our
solution
buy
less.
We
are
sharing
here,
a
link
from
the
opening
that
has
the
key
documentation
where
you
can
find
a
very
helpful
information
about
this
stock.
A
A
A
As
you
can
see
on
the
screen.
We
need
to
inform
the
image
that
should
be
deployed
on
the
cluster
to
generate
the
code.
It
will
end
up
as
a
deployment
with
a
pod
running
a
container
using
this
image,
so
by
running
both
commands
one
to
create
the
project
in
another
trisk
approach,
the
API
and
the
controller
to
manage
this
image.
We
mainly
have
a
whole
solution,
implemented
with
testis.
Raising
events
into
using
status
conditioners.
T
solution
can
be
used
up
added.
A
A
Also,
you
can
check
a
making
file
with
tags
to
help
you
develop
the
solution
and
build
it.
The
docker
file
that
you
generate
the
container
to
run
our
manager
engine.
Now,
let's
create
our
API
here
you
can
see
the
group
that
we
are
using
the
version
of
flower
API,
the
kind,
the
image
that
you
want
to
manage
and
the
plugin.
A
A
B
Let's
talk
about
the
confronto
plugin,
which
is
Handy
tool,
design
to
save
users
Time
by
simplifying
the
process
of
building
dashboards
to
visualize
operator
status.
The
plugin
generates
manifest
based
on
default
metrics,
allowing
users
to
easily
copy
and
paste
the
content
into
the
governor
web
UI
the
instant
observation
of
the
operator
status.
B
Moreover,
it
features
a
customizable
config
entry
that
enables
users
to
visualize
their
own
user-defined
metrics
in
the
governor
panels,
without
record
from
the
plugin
users
can
efficiently
monitor
the
performance
of
The
Operators
with
ease
here
is
a
quick
demo
on
the
memcache
operator
to
trigger
the
plugin.
We
use
the
sub
command
edits.
B
C
Hello,
everyone,
my
name,
is
Rashmi
gautipati
and
I
am
from
the
operator
SDK
team
at
Red,
Hat
I'd
like
to
introduce
Phase
2
plugins
in
queue
Builder
and
operator
SDK
as
you've.
Seen
from
the
introduction
and
background
so
far,
cumulus
simplifies
building
a
kubernetes
operator
and
allows
you
to
quickly
create
and
manage
and
operate
a
project.
An
important
goal
of
cube
Builder
is
to
have
an
extensible,
CLI
and
Scaffolding.
C
So
what
does
it
mean
to
have
an
extensible,
sale
and
Scaffolding?
It
means
that
Q
Builder
can
be
imported
and
used
as
a
library
in
other
projects,
for
example,
being
able
to
provide
customizations
such
that
other
projects
can
use
Q
Builder's
workflow
with
non-go
Lang
operators
such
as
ansible,
or
help
in
order
for
these
projects
to
have
customized
content
based
on
their
needs.
We
need
to
have
extensions
that
will
modify
the
queue
Builders
base.
Scaffolding
before
scaffolded
files
are
written
out
to
the
disk
and
what
helps
achieve
these
extensions
are
through
plugins.
C
Let's
see
how
Q
Builder
provides
extensible
CLI
and
Scaffolding
options
through
plugins.
So
what
is
a
plugin?
A
plug-in
is
defined
as
a
software
component.
That
adds
a
specific
feature
to
an
existing
computer
program
and
that's
exactly
what
the
plugins
do
in
Cube
Builder.
So
there
are
like
three
main
sub-commands
in
it:
create
API
and
create
web
hook.
So
when
any
of
these
sub
commands
are
called
their
respective
plugins
are
responsible
for
implementing
the
code
that
needs
to
be
run.
Commands.
C
C
Phase
1
enable
key
Builder
to
be
more
extensible
by
defining
new
plugin
interfaces
and
providing
a
new
CLI,
thereby
adding
the
ability
for
cube
Builder
to
be
imported
as
a
library
in
other
projects
currently
phase.
One
plugins
are
all
go
based,
so
they
have
to
be
compiled
with
the
cube
Builder
binary
and
they
cannot
be
external
phase.
1.5
introduce
the
ability
to
chain
plugins,
meaning
more
than
one
plugin
can
be
executed.
Along
with
the
cube
Builder
CLI,
however,
phase
1.5
plugins
are
still
go
based
and
their
internal
plugins
that
need
to
be
compiled
in
here's.
C
C
C
Let's
look
at
the
workflow
that
occurs
when
a
user
runs
a
net
command
and
provides
two
external
plugins
with
their
names
and
versions.
So
cue
Builder
discovers
those
plug-in
binaries
in
their
respective
name.
Slash
version
directories
once
they're
discovered,
cubital
constructs
and
sends
a
plug-in
request
Json
to
both
the
plugins
over
standarding.
C
The
plugin
request
consists
of
the
command
that
was
initiated
all
of
the
raw
flags
and
an
empty
universe
that
contains
the
current
virtual
state
of
file
contents
that
is
not
written
to
the
disk.
Yet
after
receiving
the
plugin
request,
the
external
plugins
construct
a
plug-in
response
that
contains
information
on
the
modified
Universe,
based
on
the
new
files
that
was
scaffolded
by
the
external
plugin
and
writes
it
back
via
standard
out
in
the
Json
format.
C
It's
most
natural
for
this
use
case
since
plugins
must
have
a
group
like
name
and
version.
So
when
any
of
the
sub
commands
like
init,
create
API
or
create
web
hook
are
in
both
Cube
Builder
first
discovers
the
external
plugins
by
traversing,
through
the
plug-in
root
directory
to
match
the
plugin
name
and
one
level
down.
C
So
this
is
going
to
be
the
plugins
root
and
on
Linux,
the
default
path
for
the
plugins
route
would
be
a
different
one.
So
if
we
look
at
the
directory
structure
of
the
plugin
under
plugins,
we
have
the
my
external
plugin
directory,
which
has
V1
as
a
subdirectory
and
under
V1
this
my
extern
plugin
dot
py,
which
is
the
external
python
plugin.
C
So
every
plugin
gets
its
own
directory
constructed
using
the
plugin
name
and
plug-in
version
for
the
executable
to
be
placed
in
and
Cube
Builder
will
search
for
the
plugin
binary,
with
the
name
in
the
name,
slash
version
directory
of
the
plugin,
so
in
Cube
Builder
main
directory.
Let's
create
a
new
project.
C
Now,
let's
run
the
init
command
by
specifying
the
name
of
the
external
plugin
in
the
dash
dash
plugins
field.
What
happens
now
is
that
Cube
Builder
detects
the
OS
and
it
discovers
my
external
plugin
in
the
path
that
we
just
talked
about.
It
also
validates
the
name,
slash
version
directory
and
checks,
whether
the
plugin
is
an
executable
based
on
the
bitmask
and
then
it
runs
the
plugin.
So
this
results
in
the
scaffolds
like
project
file
and
license
header
and
the
domain.py
and
main.py.
C
So
the
file
contents
are
provided
by
the
external
plugin
in
the
universe
object.
It
represents
the
modified
file
contents
that
the
external
plugin
writes
back
to
queue
Builder,
as
we've
talked
about
in
the
previous
slides,
so
communication
between
Cube
Builder
and
the
plugin
happens
through
plug-in
requests
and
plugin
response
by
passing
the
updated,
Universe
back
and
forth
to
each
other.
C
C
So
if
you
look
at
gvk.py
its
scaffolds,
a
class
memcached
and
group
as
cache
version
as
V1
Alpha,
One
and
kind
as
memcached,
these
are
the
values
we
specified
for
the
flags
when
we
ran
the
create
API
command
and
also
an
init
command.
That
sets
the
name
and
namespace,
and
now,
let's
run
the
create
webhook
command
by
specifying
the
external
plugin
name
and
group
as
cache
version
as
V1
Alpha,
One
and
kind
as
memcached,
and
this
results
in
the
scaffold
webhook.py
yep.
C
So
these
are
three
sub
commands
to
initialize
the
project,
scaffold,
kubernetes,
API
definitions
and
web
Hooks,
and
this
is
how
external
plugins
can
be
discovered
and
run
with
Cube
Builder,
and
this
concludes
the
talk
and
quick
demo
on
one
of
the
recent
updates
in
queue
Builder,
which
are
Phase
2
plugins.
Thank
you
for
watching.
D
D
It
provides
us
with
a
binary
called
controller
chain
that
helps
in
scaffolding
out
code
for
deep
copy
generation,
custom
resource
definition
and
rbac
manifests
UI
would
have
probably
heard
the
very
common
term
called
Marcus
or
marker
comments,
which
are
present
in
the
operator
project
control
agent
performs
the
task
of
reading
those
markers
and
Scaffolding
output,
which
could
either
be
yaml
definitions
or
just
go
code,
provides
us
with
three
different
generators.
It
also
has
the
option
to
specify
output
rules,
wherein
we
could
mention
the
location
of
the
scaffolded
content.
D
Let's
walk
through
a
sample
code.
Here
we
see
that
the
BusyBox
API
spec
is
defined
and
contains
a
field
name
size.
On
top
of
this,
we
see
the
controller
chain
marker
commands
that
contain
the
tag
queue
Builder.
These
are
validation,
markers
and
here
they
mean
that
the
minimum
possible
value
should
be
1
and
the
maximum
could
be
3.
D
D
The
major
utilities
which
controller
tools
provides
us
with
is
the
ability
to
Define
markers
in
the
format
we
want
pass
them
with
any
custom
logic
and
scaffold
out
relevant
bits
of
code.
The
first
step
is
to
declare
the
format
of
a
marker
and
create
a
definition
out
of
them.
The
commonly
used
helper
for
this
is
marker.make
definition.
The
link
is
to
the
same
is
present
in
this
slide.
D
Markers
can
be
defined
to
be
on
a
type
on
a
package
or
on
a
field
like
the
cube,
Builder
object,
marker
or
say
a
validation
or
a
webhook
marker.
The
marker
format
does
accept
arguments
and
these
fields
can
be
defined
as
a
struct
and
passed
on
to
the
definition.
Step
2
is
parsing
of
markers.
This
is
done
using
chengo,
for
which
we
have
wrappers
in
controller
tools,
and
the
reference
again
is
present
in
the
slide.
D
D
Now
that
we
have
reached
the
end
of
the
presentation,
we
would
like
to
welcome
you
all
to
be
a
part
of
our
community.
We
do
have
a
slack
Channel
under
the
kubernetes
org
named
Cube
Builder,
and
we
also
run
bi-weekly
Community
meetings.
Please
do
join
the
Google
group
to
receive,
invites
and
updates
on
the
things
happening
in
the
community.
D
We
have
the
references
here.
We
have
the
link
to
the
cube,
Builder
documentation,
the
quick
start
guide,
the
link
to
different
plugins,
which
we
discussed
and
the
link
to
use
Cube
Builder.
As
a
library,
we
also
have
links
to
controller
runtime
controller
tools
and
a
few
API
conventions
followed
by
kubernetes.