►
From YouTube: At the Helm without a Steering Wheel – Your Chart as a Kubernetes Operator Daniel Messer, Red Hat
Description
Join us for Kubernetes Forums Seoul, Sydney, 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
At the Helm without a Steering Wheel – Your Chart as a Kubernetes Operator Daniel Messer, Red Hat
A
Audio
vice
awesome:
okay,
thanks
for
joining
this
session.
Thanks
for
your
interest,
I
heard
I
had
some
pretty
stiff
competition,
actually
next
door,
where
they
walk
all
through
the
nice
new.
How
many
free
features
in
the
workshop
but
I
think
I'm
gonna
have
a
nifty
little
trick
up
my
sleeve
here
for
you
as
well,
which
is
how
you
can
turn
your
hound
chart
into
an
operator
and
actually
run
it
like
an
operator
on
Cluster
with,
in
the
ideal
case,
a
single
command.
A
Okay,
almost
everybody
awesome
who
has
heard
and
has
a
good
grip
on
the
operator
pattern
itself.
Okay,
couple
of
hands
all
right,
so
that's
where
we
are
gonna
quite
do
a
quick
level
set
right.
So
if
the
CRD
is
our
way
of
introducing
basically
new
object
types
on
the
cluster,
the
operator
is
what
makes
this
useful
right.
A
If
you
have
a
C
or
D
define-
and
you
register
it
on
your
cluster-
which
you
by
the
way,
need
to
cast
admin
privileges
for-
and
you
create
an
instance
of
that
new
object
type,
nothing
happens
right
other
than
a
couple
of
HCD
database
entries
getting
graded
yeah.
Nothing
really
happens
on
the
cluster.
So
what
needs
to
happen
is
there's
a
custom
controller
in
the
background
who
starts
reacting
on
these
custom
resource
definitions,
popping
up
getting
modified
or
getting
deleted,
and
that's
exactly
what
an
operator
is.
A
Technically,
it's
a
custom
controller
running
on
the
cluster,
interacting
with
the
cube
API
and
watching
its
custom
resource
definitions.
That's
what
it
does
and
that's
the
chance
to
make
an
operator
a
really
valuable
piece
of
software,
because
what
we
see
is
that
operators
are
the
place
where
you
basically
codify
the
knowledge,
how
to
run
an
application.
This
is
the
type
of
knowledge
that
usually
sits
in
the
brains
of
admins,
controlling
the
application
outside
of
the
cluster
in
sort
of
scripts
and
complex
continiously
pipelines
that
are
all
outside
of
the
cluster.
A
All
that
is
getting
Kodi
while
in
software
and
runs
inside
a
cluster
and
makes
this
available
behind
a
custom
resource
definitions.
So
it's
a
native
object
right,
it's
a
native
kubernetes
api
and
you
can
create
it
with
the
regular
queue
control
tuning
and
then
the
operator
on
your
behalf,
will
kind
of
always
look
at
what
is
stated
in
the
CR
D
in
the
spec
section
and
what
is
actually
currently
existing
on
the
cluster
and
we'll
try
to
make
that
match
right
and
it
does
is
in
a
software
loop.
A
So,
basically,
an
operator
is
a
big
software
loop,
looking
at
the
CR
these
out
there
and
try
to
make
that
happen,
and
usually
what
it
does
is
it
uses
the
low-level,
more
basic,
Panetta's
objects
and
functionalities
to
do
so
right.
So
that's
kind
of
what
an
operator
does
it's
acting
on
your
behalf
and
providing
you
a
managed
service
like
experience.
So
why
would
you
want
to
do
something
like
that
now?
Stateless
applications
are
very
easy
to
do
on
kubernetes
right,
deploying
applications
is
also
very
easy.
A
These
days,
thanks
to
him
on
kubernetes,
but
looking
at
the
application
of
its
lifecycle.
You
know
it
only
spends
like
10%
of
its
lifecycle,
time
in
development
and
then
deployment
the
rest
of
the
time
it
actually
spends
running
on
the
cluster
servicing
the
users
right
and
that's
where
they
to
operations
come
in.
A
Like
common
events,
like
you
know,
if
it's
database
backup
restore
failover,
failed
back,
complex,
V,
orchestration
and
reconfiguration,
that
requires
sequencing
all
these
are
they
to
operation
management
tasks
that
are
a
little
bit
harder
to
do
with
the
out-of-the-box
features
of
kubernetes
right,
so
automating.
These
operations
is
part
of
the
operator.
A
piece
of
software
sitting
inside
the
cluster
right
next
to
the
application
is
really
what
makes
an
operator
valuable.
The
other
thing
for
the
users
is,
it
feels
like
a
managed
service.
You
get
from
one
of
those
top
providers
right.
A
So
if
the
cluster
admin
installed
an
operator
on
the
cluster
that,
for
instance,
gives
you
and
my
sequel
database
right,
a
user
could
con
could
come
in
and
and
created
an
object
called
my
sequel
database
cluster
and
basically
ask
the
operator
for
a
database
cluster
as
specified
in
the
spec
section
of
that
object,
and
the
operator
will
do
it
for
him
right.
He
doesn't
need
to
know
how
that
actually
works
and,
what's
the
best
practice
to
deploy
a
Moorea
to
be
in
production
in
kubernetes
and
what
are
the
best
configuration
values?
A
That's
all
inside
the
operator
what
the
user
sees
as
a
single
object.
That's
basically
his
new
user
interface
of
asking
the
operator
to
do
something
and
the
operator
gives
it
this
service
and
in
life
cycles
this
instance
over
time
with
the
additional
features
and
the
cool
thing
about
that
is
that
this
happens
constantly
alright.
So,
as
I
said,
you
operate
as
a
software
loop,
basically
right.
A
So
if
something
is
bypassing
the
operator
like
me
as
the
user
accidentally,
deleting
that
very
important
config
map
that
had
to
my
dot
CNF
inside
the
operator
is
going
to
restore
it
in
the
next
three
considerations
of
right,
which
is
gonna
happen
in
next
couple
of
seconds.
So
you
have
also
automatically
remediation
of
any
configuration
drift,
which
is
ensured
by
something
that
runs
inside
a
cluster
and
not
outside
trying
to
impose
itself
right.
This
makes
it
very
portable
and
integrates
very
natively
with
you
know.
You
do
things
on
cube
anyway.
A
Now
with
that,
why
would
you
run
in
your
hand
shard
as
an
operator?
Well,
obviously,
there's
nothing
wrong
with
with
ham
charts
as
such,
but
what
you
get
in
addition,
when
you
run
it
as
an
operator,
is
a
very
nice
user
interface
right,
you
suddenly
have
a
top-level
object,
a
C
or
D
that
represents,
in
instance,
and
actually
a
release
of
your
chart
right
on
cluster,
which
is
to
go
to
point
on
cluster
people
can
go
to
to
reconfigure
this.
A
You
know
create
it
or
delete
it
or
whatever,
without
any
kind
of
additional,
tooling
right
customers
that
use
this
love
this,
because
it
enables
get-ups
quite
easily
right.
It's
just
another
kubernetes
object
that
I
need
to
basically
keep
control,
apply,
minus
F
right,
it's
it's
as
simple
as
that.
There's
no
additional
tuning
required,
also
because
it's
a
CR
D.
It
is
now
subject
to
the
standard.
Q
R
back
features
right,
so
you
can
forbid
certain
users
in
certain
namespaces
to
create
a
release
of
a
certain
shot.
A
If
you
wanted
to
do
that,
maybe
it's
a
complex
or
resourceful
application,
or
maybe
it
is
attached
to
a
license
right.
You
can
actually
do
that
with
you
know,
native
cube
features.
It's
it's
just
another
object
from
this
point
on
for
healthy
to
users
as
helmets
approaching
GA,
you
get
to
basically
have
your
charts
run
without
Taylor
on
the
cluster
side,
and
you
have
the
operator.
A
Have
it's
our
big
tailor
to
what
it
actually
uses
right
and
the
SDK,
which
is
a
component
you
can
use
to
create
such
operators
helps
you
to
do
so,
instead
of
like
having
a
component
on
cluster
that
needs
to
have
cross
the
admin
privileges.
You
have
a
component
as
in
the
operator
based
on
your
hamstrung
cluster.
A
That
only
has
enough
privileges
to
do
what
it
needs
to
do,
and
it
also
can
be
against
scope
down
very
easily
to
just
a
particular
namespace,
so
that
the
operator
doesn't
even
react
to
some
of
the
objects
popping
up
in
other
namespaces
and
finally,
the
releases
are
applied
constantly
right.
So
again,
there
is
concentration
of
any
configuration
drift
when
you
delete
an
object
that
was
deployed
by
the
chart
or
as
part
of
a
release
right.
A
So
the
operator
will
restore
that
in
the
next
week
conciliation
loop,
which
is
you
know,
on
a
not
too
busy
cluster
effectively
immediately.
So
you
get
a
very
nice
handling,
a
very
easily
approachable
way
of
deploying
software
or
instances
of
software
for
users
that
are
not
class
element.
Now,
how
do
you
get
to
this
I'm?
A
product
manager
at
Retta
I,
should
have
probably
introduced
myself.
My
name
is
Daniel
Messer
I'm,
a
PMI
rated
for
something
we
call
the
operator
framework.
A
This
is
an
open
source
project
aimed
at
kubernetes
the
kubernetes
community
to
surf,
on
the
one
hand,
those
people
who
want
to
write
operators
as
well
as
dos
which
are
operating
clusters
and
want
to
run
operators
at
scale
on
a
cluster
in
a
very
safe
fashion.
An
operator
is
really
like
a
kernel
extension
on
a
on
a
on
a
modern
operating
system.
You
want
to
have
some
special
handling
around
that
right.
A
You
don't
want
to
just
have
every
user
be
able
to
load
those,
and
you
know
to
potentially
disruptive
stuff
on
your
cluster
very
similar,
an
operator
er.
These
are
always
global
right.
Operators
are
usually
very
privileged
as
well,
so
there's
a
component
called
the
lifecycle
manager,
which
makes
that
a
little
bit
easier
and
also
centrally
manage
the
operator
installed
on
the
cluster.
A
Now
the
operator
SDK
is
looking
for
is
looking
at
the
developers
who
are
experts
and
how
to
manage
an
application.
These
are
usually
IVs
or
people
who
wrote
the
application
and
gives
them
several
options
to
actually
create
an
operator.
Most
of
the
operators
today
are
written
in
go,
which
is
basically
straight
forward
because
kubernetes
is
written
in
go
and
there
are
very
mature
libraries
like
controller
runtime
and
that
allow
you
to
connect
to
the
kubernetes
api.
A
What
the
operators
UK
does
here
is
scaffolding,
a
lot
of
the
boilerplate
code,
that
you
would
always
need
to
write
if
you
want
to
write
an
operator
interacting
with
the
kubernetes
api
for
those
who
are
not
too
savvy
and
go,
there's
also
the
option
to
create
operators
based
on
ansible
playbooks.
So
ansible
has
very
nice
modules
for
injecting
with
kubernetes,
and
you
can
basically
write
playbooks.
A
That
then
run
as
part
of
the
operator,
reconsidering
your
customer
source
definitions
and
then
there's
the
interesting
stuff
for
you,
which
is
the
helm
based
operator,
which
is
also
part
of
the
sdk.
That's
basically
an
approach
to
write
an
operator
without
writing
a
single
line
of
code
at
all.
What
you
do
is,
basically
you
convert
it
shard
to
an
operator
which
runs
on
cluster
and
with
the
framework,
you
also
get
some
additional
testing
and
verification
tooling.
To
make
sure
you
know,
your
packaging
is
correct.
A
The
operator
behaves
after
best
practices,
and
then
you
can
basically
also
publish
and
share
that
with
the
community
on
something
we
call
the
operator
hub,
which
diana's
gonna
talk
about
in
the
in
the
end
a
little
bit
now,
how
do
you
actually
create
an
operator
from
a
mount
chart?
It's
very
easy.
This
is
the
single
command
that
makes
that
happen.
A
That's
at
the
very
at
the
very
basic
level
of
what
and
how
and
based
operator
does
it
execute
a
ham
chart
upon
the
presence
or
modification
of
a
custom
resource
definition,
and
this
commands
scaffolds
this
custom
resource
definition
for
you,
and
it
also
takes
your
existing
ham
chart
in
this
case
from
the
official
chart
repo
as
an
input.
So
what
it
does
is
basically
creating
a
folder
layout
that
looks
like
this
and
for
those
of
you
doing
hamsters
regularly,
you
see
that
that
ham,
charts
directory
there
looks
very
familiar
debts.
The
chart
itself
right.
A
That's
the
unmodified
version
of
the
chart
that
has
just
been
copied
basically
into
the
sub
directory,
and
then
there
are
a
couple
of
additional
things
here:
there's
the
built
directory,
which
contains
the
docker
file.
This
is
how
you
build
the
operator.
Do
you
operate
it
on
the
cluster?
Is
a
port
running
with
privileges
to
connect
to
the
communities
API
as
part
of
a
normal
deployment?
That's
really
what
it
comes
down
to
on
the
cluster.
It's
really
as
simple
as
that
to
deploy
this
part.
We
give
you
all
the
necessary
basic
pinellas
manifests
here.
A
There's
a
deployment
role,
role,
binding
a
service
account
which
create
which
has
the
necessary
hour
break
for
the
operator
to
be
allowed
to
create
stuff
on
cluster.
This
is
where
it's
usually
sometimes
a
little
bit
trickier
than
just
the
single
command.
That
I've
shown
you
on
a
previous
slide,
because
we
kind
of
need
to
be
very
specific
and
cube
about
the
stuff
you
want.
People
or
service
accounts
in
this
case
gives
access
to
write.
So
we
need
to
be
listing
on
a
career,
API
level
on
a
proverb
level.
A
The
rules
that
we
want
this
operator
to
and
to
be
able
to
do,
and
the
SDK
helps
you
with
scaffolding
that
to
like
an
80%
solution
by
looking
at
your
chart
right.
So
it
will
look
at
the
objects
that
are
part
of
your
chart
and
created
required
object
for
that
it
will
also
automatically
require
or
create
a
required
object
to
watch
and
create
see.
Are
these
or
just
watch
the
ADIZ
not
create
series,
and
that
is
usually
fine
for
90%
of
the
charts
right?
A
Sometimes
there
is
an
additional
thing
recently
missing,
because
some
stuff
is
wrapped
in
templates
in
helm,
and
we
cannot
just
you
know,
guess
when
that
will
materialize
on
Cluster.
So
usually
things
that
are
missing
are
like
what
disruption
budgets
or
finalize
or
stuff
like
that.
But
it's
very
easy
to
add
in
this
existing
role
binding
and
that's
basically,
what
makes
up
an
operator
right.
It's
the
chart.
It's
the
base
image
that
connects
your
chart
to
a
custom
resource
definition.
The
custom
resource
definition
is
also
already
scaffolded
and
named
after
the
chart
for
you.
A
A
Inside
the
image
of
the
operator
right,
but
that's
basically
it
you
create
a
custom
resource
definition.
The
helm
operator
makes
the
connection
to
your
chart
packages
this
up
for
you
and
in
an
image,
and
you
run
it
on
cluster.
That's
all
that
happens
right.
You
take
the
chart,
create
the
operator
image
from
it.
A
I
have
an
example
operator
here:
it's
not
Tomcat,
it's
cockroach
to
be
a
big
fan
of
their
database
by
the
way
and
I
have
created
an
operator
from
that.
What
I
did
is
basically
run
that
opera,
SDK,
new
command
type
helm
and
then
chart
equals
stable,
cockroach
to
be
in
the
basic
created
this
directory
layout
here
for
me,
so,
like
I,
showed
on
a
slide
before
you
have
the
chart
itself
unmodified
completely
the
same.
You
have
the
docker
file
that
builds
the
operator.
A
A
So
that's
all
there
is,
and
the
only
thing
I
had
to
do
here
is
basically
in
the
deployment
which
is
here
in
this
folder
change
or
like
give
the
actual
location
of
the
image
that
I
that
I
created
and
pushed
to
a
registry
in
this
case
quay
today.
Oh
by
the
way,
is
this
sort
of
freed
for
you
in
the
background.
A
Okay,
awesome!
So
that's
it
where
I
can
operate
it
as
a
normal
kubernetes
application.
So,
in
order
to
deploy
this,
what
I'm
going
to
be
doing
here
is
I'm
gonna
first
create
the
CRD,
that's
a
special
thing
about
operators.
It
is
here
these
need
to
be
there
first
and
then
the
operator
can
start,
because,
if
there's
nothing
to
register
against,
it
will
throw
an
error.
So
I
do
basically
Cube
control,
apply
minus
F
in
this
CR
D.
A
That's
that
and
then
I
deploy
the
rest
of
this
whole
shebang.
Just
like
that
and
I'm
watching
my
default
namespace
here,
which
I
happen
to
be
in
and
what
you'll
see
in
a
second
is
that
the
operator
will
come
up
as
a
regular
part
right.
That's
really
what
it
is
and
it
has
to
write
permissions
based
on
what
the
SDK
scaffolded
out
and
it
will
now
be
able
to
deploy
my
chart.
So
my
chart
is
now
a
custom
resource
definition
and
the
very
cool
thing
about
this
is
that
I,
what
the
SDK
basically
does.
A
A
So
this
is
what
I
do
I
create
a
cockroach
DB
object
like
I,
create
the
province
parts
PBC's,
config
maps
on
a
kubernetes,
give
it
a
name
and
then
in
the
specs
section
should
look
very
familiar
even
says
so
here
I
have
all
the
contents
of
the
value
store
demo
inside
so
nothing
changes
from
the
user
perspective.
He
gets
all
the
same
values.
He
gets
the
same.
Ux
right.
It
looks
like
a
hamon
store,
but
only
it
is
a
native
coop
object,
so
I
can
basically
apply
that
as
well
and
then
magically.
A
In
the
background,
the
chart
starts
to
deploy
right,
I,
get
a
release,
and
there
are
a
couple
of
more
things
happening
here,
based
on
llamo
operator,
the
object
that
is
now
there
I
can
now
basically
say
give
me
all.
Cockroach
tea
beans,
instances,
Q
control,
cap,
cockroach
to
be
and
I
have.
One
I
have
one
instance
here
and
if
I
look
at
that,
it's
a
regular
kubernetes
object
right.
Api
version
has
a
name
and
here's
the
spec
right
in
the
status
of
this
object.
I
also
see
what
the
operator
did.
A
A
It
will
basically
in
a
moment
say
that
this
release
has
been
reconciled
and
the
database
is
ready
to
use.
So,
let's
see
if
I
can
connect
to
this
thing,
I'm
gonna
run
this
command
here,
which
will
basically
launch
a
cockroach
to
be
sequel,
client
in
a
container,
and
that
should
basically
give
me
in
a
second,
depending
on
the
Wi-Fi,
a
secure
command
prompt,
which
means
I'm
ready
to
use
the
database.
A
There
we
go
it's
life,
it's
running
and
I
can
start
running
the
application
all
right
now,
since
this
is
an
operator
right
and
there's
an
object
that
the
operator
watches
over,
which
is
basically
my
release.
I
can
also
edit
that,
like
I,
would
edit
any
other
kubernetes
object
with
control
edit.
So
let's
say
I
wanted
to
decrease
the
castle
a
bit
here.
That's
maybe
a
little
bit
too
much
for
a
database.
A
You
may
want
to
tone
it
down
to
like
35%
of
the
available
memory,
I
edit,
that
and
then
the
operator
sees
that
I
basically
modified
this
and
the
helm
operator
right.
That's
what's
happening
here
and
as
such,
you
can
see
the
primary
user
interface
for
the
user
consuming
this
is
that
one
object
that
represents
the
entire
application
stack.
He
doesn't
need
to
know
anything
about
what's
happening
in
the
background
like
that,
there's
a
stateful
set
and
a
couple
of
secret
some
config
Maps.
It
just
behaves
like
a
regular
Capitan.
A
This
application
makes
it
extremely
easy
to
use
in
get-ups
environments
in
CI
pipelines
and
just
feels
very
native
to
kubernetes
itself
right,
there's,
no
additional
tooling
for
the
developer.
On
the
other
side,
for
the
people
writing
the
chart,
nothing
changes
either
right.
The
way
we
basically
bring
this
to
life
is
we
use
the
tiller,
rendering
templating
engine
inside
the
operator
and
and
do
basically
what
would
happen
in
a
normal
helm
setup
right.
So
we
also
support
things
like
the
lifecycle,
hoops
or
composite
charts
right.
A
So
there
is
giving
no
change
in
the
way
you
write
or
orchestrate
your
chart
and
we're
actually
working
closely
with
the
hell.
Maintainer
is
here
to
enable
Hambley
free
in
this
as
well,
but
from
the
maintainer
perspective,
nothing
changes,
it's
just
a
different
way
of
getting
it
to
the
on
the
hood
onto
the
cluster
in
a
way
that
feels
a
little
bit
more
at
home
for
people
that
just
know
kubernetes
right
and
just
want
to
see
kubernetes
things.
So
I
edited
at
my
cockroach
to
be
instance
and
had
reconciled
it.
A
It
went
through
all
the
instances
and
we
started
them
one
by
another.
We
could
do
other
fancy
things
here,
like
you
know,
bump
up
the
replica
count,
and
it
would
do
that
as
well
and
spawn
new
instances
feels
very
much
at
home
for
anyone
who
used
helm
Paul
from
the
developer
in
the
user
site.
But
you
have
a
native
interface
to
that.
A
Couple
of
additional
notes,
so
since
this
is
now
an
operator
and
since
you
actually
extended
the
kubernetes
api,
there
are
a
couple
of
additional
best
practices.
We
tend
to
give
people
who
and
never
start
on
this
endeavor.
So
when
a
chart
is
updated
right,
you
basically
just
copy
that
into
that
short
directory
and
create
a
new
image.
A
You
use
semantic
versioning,
ideally
to
denote,
there's
a
new
version
of
the
operator,
and
you
made
it
available
to
people
easy
as
that,
when
the
chart
introduces
new
values
right
and
there's,
and
it's
significant
enough
so
that
you
cannot
omit
that
value
and
the
best
practice
here
is
also
to
bump
this.
Your
D
version
right
because
it's
an
API
and
there
are
conventions
about
those
API-
is
in
their
versioning.
A
So
when
you
add
new
fields
that
are
not
optional,
you
can
just
bump
the
C
or
D
version,
and
that
will
basically
tell
users
Oh
something
changed.
I
cannot
regard
this
as
comfortable
to
the
older
version
of
that
API
and
also
your
operator
will.
Basically,
your
new
operator
will
only
watch
that
new
API
by
default,
so
new
values
should
then
also
yield
a
new
customer
resource
definition.
There's
not
anything.
You
need
to
do
here
explicitly
all
the
values
are
supported,
out-of-the-box,
but
it's
probably
a
good
example
to
update
your
example.
A
That
has
a
simple
or
a
CD
pipeline
that
has
actually
a
smoke
test
inside,
which
would
you
know,
install
your
operator
and
quickly
run
it
against
the
samples
you
are,
and
that
would
yield
our
problems
right
away
and
it's
very
easy
to
see
in
the
log
from
the
operator
itself.
What's
the
problem
chart
features,
we
support
everything
that
you
know
how
many
two
supports:
there's
no
change
for
the
maintainer
of
the
chart,
and
there
is.
A
There
are
some
good
practices
abroad,
updating
operators
which
you
can
probably
talk
about
after
this
session
and
and
the
coffee
break,
we
have
an
entire
component
called
the
operator
lifecycle
manager
on
Cluster
that
deals
with
that
and
make
sure
that
operators
are
updated.
If
you
want
even
over-the-air
and
quotes
on
in
the
background-
and
you
also
get
a
very
predictable
update
path
right
operators
are
long-running
workloads
on
a
cluster
very
privileged,
so
you're
not
just
gonna
rip
and
replace
those
in
production.
B
The
other
thing
that
we've
done
in
in
addition
to
this
is
create
operator
hub,
do
and
what
I'm
encouraging
people
to
do
is
take
a
look
there.
It
basically
takes
your
helmet
art,
you
run
it
through
the
sdk.
We
have
a
community
repository
and
you
can
make
a
pull
request
and
add
it
in
and
it's
got
72,
maybe
75
descending
74
that
are
in
and
these
run
on
any
kubernetes
anywhere.
So
it's
a
very
generic.
B
It's
very
open
public
place
for
people
to
have
access
to
operators
that
you
build
based
on
your
helmet
arts
or
whether
you're
doing
them
with
go
or
all
kinds
of
different
things
that
people
are
doing
so
it's
very
open
and
very
public
community
space
for
sharing
operators.
So,
if
you've
gone
through
all
the
trouble
of
creating
helm
charts
for
your
applications,
I'd
highly
encourage
you
to
try
out
the
operator
SDK
and
then
take
a
wander
over
to
if
I
hit
contribute,
am
I.
Gonna!
B
Guess
if
you
go
to
operator
hub
that
IO
everything
you
know
need
to
know
about
creating
a
pull
request
and
getting
it
added
in
is
all
hosted
there
and
any
feedback.
You
have
please
just
reach
out
to
me
on
the
coffee
break,
we'd
love
to
see
more
of
your
helmet
charts
up
here
and
making
it
easier
for
people
to
use
your
applications
and
so
maybe
have
a
little
time
for
Q&A.
Yes,.
A
B
A
The
SDK
side,
so
one
thing
you're
going
to
do
for
pers,
is
increase
a
little
bit
on
the
UX
side.
So
you
have
seen
like
when
you
get
an
instance
of
your
hound
based
operator,
there's
not
a
lot
of
information
there
and
the
non
yeah
Mel
output.
So
we
are
going
to
scaffold
automatically
some
additional
printer
columns
on
the
CID
to
make
that
a
little
bit
easier,
we're
working
with
the
hell
maintainer
to
get
V
free
support
as
soon
as
it's
there
and
it's
GA
as
well,
and
also
in
continue
to
invest
in
this.
A
Our
bag
management
system
and
one
thing
that
I
like
to
highlight
as
well
as
we
have
as
part
of
the
way
we
handle
operators
with
the
last
recommendation,
cluster
and
notion
of
dependency
management
right.
So
we
also
allow
an
operator
to
depend
on
another
operator,
so
you
can
actually
like
Lego
bricks
and
you
know,
pull
together
a
larger
application
sticks
that
are
managed
by
individual
ham,
shards
or
there's
a
go
operator
here
and
ants
will
operate
over
there.