►
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
WIGM and Why You Want an Operator - Carson Anderson, Weave
Operators are amazing! At least that is what what they say. But what is the actual value they provide? Are they really better than just managing things with yaml? Yes, this is yet another presentation about operators. But with a twist: this presentation takes a new service from yaml, to templates, to two different operators. The presentation will introduce WIGM. A very simple piece of software deployed in Kubernetes that has one job: download and serve a single GIF. But even the simplest software comes with operational concerns: How to deploy many copies with different configurations? How to update them reliably? How to change configuration without breaking everything? This is a different kind of operator talk: One that covers the why of operators instead of just the how.
https://sched.co/UaeS
A
All
right
so,
let's
get
started
we're
here
for
a
Wiggum
and
why
you
want
an
operator
not
just
to
preach
about
what
they
are,
but
really
the
value
at.
Why
you
want
one
like
I
said
my
name
is
Carson
Anderson
I
work
for
weave,
not
that
weave
you
can
come.
Ask
me
about
cluster
networking
servers
mesh
get
ups,
but
that's
a
different
company.
My
weave
is
a
small
business
toolkit
with
a
focus
on
integrated
communications,
so
totally
different
company
we're
an
end-user
I'm
on
github
carcinoid.
A
That's
where
the
source
code
for
every
presentation
I've
ever
done
is
on
and
I'm
on,
Twitter
at
Carson
underscore
opps,
I'm
gonna
start
with
a
obligatory.
What
is
an
operator
slide?
I'm
gonna
put
a
lot
of
crap
on
the
screen
and
I'm,
not
gonna
read
any
of
it,
because
this
is
the
Google
definition
of
what
an
operator
is,
and
you
can
google
this
yourself
really
like.
Really
what
an
operator
is
is
a
pattern.
It
is
a
pattern
that
we
implement
using
kubernetes
tools.
A
Typically
in
the
communities,
API
and
communities
features
to
run
our
systems
in
a
more
pleasant
and
efficient
way.
That's
it!
There's!
No
language
there's
no
really
prescribed
toolkit.
It's
just
a
pattern
and
you'll
see
what
I
mean
when
we
build
some
operators
later.
So,
instead
of
preaching
what
an
operator
is,
we're
gonna
see
why
we
want
one
by
running
something
just
above
a
hello
world
bit
of
software.
It
is
not
much
more
than
hello
world,
but
it's
more
interesting.
A
We're
gonna
run
this
thing
that
I
wrote
and
we'll
show
you
the
code
for
this
in
a
second
called
Wiggum,
and
it
stands
for
wasteful
individual
gift
mirror
it's
exceedingly
simple
software.
That
really
is
just
bash
on
top
of
nginx,
and
it
does
exactly
what
it
sounds
like.
It
goes
out
to
the
Internet.
We
get
a
gift,
we
pull
it
down,
make
a
web
page
and
serve
that
web
page
up
again.
One
gift,
one
webpage,
one
pod,
one,
maybe
load
balancer
per
gif,
because
we're
gonna
be
doing
a
lot
of
these
right.
A
We're
not
gonna,
be
we're
gonna,
be
running
a
lot
of
different
servers.
We
want
to
spin
them
up
and
down
quickly.
We
want
to
operate
on
them
efficiently.
It
should
be
easy
to
do
all
these
things
that
have
gone
on
the
screen.
This
is
kind
of
a
basic.
If
you
look
at
this,
it's
just
basic
crud
for
your
application
and
as
a
bonus,
I'm
gonna
show
you
how
you
do
this
without
any
dedicated
images,
because
building
a
docker
image
for
each
gift
would
be
more
wasteful
than
even
I
want
to
go.
A
Every
time
we
deploy
Wiggum
we're
gonna,
deploy
it
with
a
handful
of
configuration.
We're
gonna
give
it
a
name
this
to
be
kubernetes
friendly,
because
it's
gonna
go
in
kubernetes
places.
We're
gonna,
give
it
a
couple
environment
variables,
a
source
link
because
we're
a
mirror.
So
we
go
out
and
get
some
original
gift,
a
title
that
we
put
in
our
HTML
and
then
to
business
decisions
for
each
deployment.
Do
we
create
a
dedicated
load
balancer
in
the
cloud
for
this
gift?
A
A
With
just
a
handful
of
things,
some
of
the
other
tools
break
down
and
operators
give
you
a
lot
of
visibility
and
a
lot
of
power,
and
every
time
we
do
this,
we'll
get
some
things
in
cribben
at
ease.
We're
gonna,
get
a
deployment
for
sure,
a
service
for
sure,
maybe
an
ingress
rule
again
depending
on
business
decision,
maybe
a
dedicated
load
balancer
in
the
cloud,
and
we
should
know
based
on
our
inputs,
what
we've
got
and
be
able
to
read
that
easily.
A
B
A
We're
gonna
do
this
with
pure
upstream
nginx
cuz
you
can.
This
is
the
software.
This
is
the
whole
thing.
It
is
bash.
On
top
of
nginx
we
get
curl,
we
download
our
upstream
gift.
We
make
a
web
page
with
this.
Really
cool
bash
is
I'm
called
a
here
doc,
that's
way
better
than
like
a
thousand
echos,
and
then
we
serve
it
like
this
is
the
simplest
software.
I
could
come
up
with
it's
better
than
a
hello
world.
A
That's
it
we're
gonna,
deploy
the
software
a
lot
and
we're
gonna
kind
of
compare
all
the
tools
that
you
might
use.
When
you
go
to
run
your
software
in
communities,
we're
gonna
start
with
the
amal,
because
all
roads
accrue
Nettie's
start
with
the
Amal.
That's
just
like
it's
a
document,
declarative
infrastructure.
You
have
your
declared
documents
and
we
all
choose
yamo
we're
gonna
move
on
to
helm
briefly,
to
see
how
just
moving
past
amble
to
literally
anything
else,
gets
better.
Then
we're
gonna
talk
about
operators
and
a
couple
forms.
A
First
thing:
I
talked
about
meta
controller,
which
I
did
not
write,
but
is
a
really
cool
way
that
you
just
write
a
web
hook
to
build
your
operator.
Instead
of
the
whole
infrastructure,
ignore
the
space
I'll
come
back
to
it.
We're
then
we're
gonna
talk
about
the
operator
SDK
and
writing
it
and
go
and
what
the
power
of
running
our
application
with
that
comes
from
in
the
middle,
by
the
way.
I
just
learned
about
this
thing
called
cuff
and
because
again,
operators
are
a
pattern,
not
a
prescribed
toolkit.
A
You
want
to
get
somewhere
in
usability
and
feature
set
between
meta
controller
and
the
operator
which
I'll
show
you
how
those
work
cop
is
actually
really
cool.
I
just
learned
about
last
night,
so
I
didn't
quite
have
time
to
write
a
new
demo
for
it,
but
it's
there
and
it
kind
of
fits
in
the
middle
of
those
two
feature
sets
every
time
we
use
one
of
these
systems,
I'm
going
to
evaluate
them.
The
same
way
we're
gonna,
do
basic
crud
we're
gonna,
create
a
new
instance.
We're
gonna,
create
a
load
balancer
and
not
create
ingress.
A
We're
gonna
update
the
title:
we're
gonna,
re-enable
ingress,
just
two
different
updates,
then
we're
gonna
report.
What
we've
done
and
then
delete
everything,
that's
it.
This
is
the
basic
like
rubric
for
testing
as
I.
Do
this
for
each
system,
so
I'm
gonna.
Do
it
four
times
you're
gonna
see
this
blue
box
move
and
just
just
help
you
keep
track,
hopefully
of
where
we
are
for
each
evaluation.
So,
let's
start
with
the
animal,
and
this
is
your
life
with
the
animal.
It
is
copy,
paste
and
type
furiously.
Maybe
a
bunch
of
gross
heads.
A
Here's
the
Wiggum
like
deployment
code
infrastructure
for
yamo,
what
I've
done
and
a
lot
of
people
are
tempted
to
do
when
you
start
using
ambos
and
put
all
of
my
kubernetes
resources
in
one
yellow
file,
so
my
deployments
are
easier,
so
I
can
just
copy
and
paste
one
file
to
do
a
new
Wiggum
release,
I'm
structuring
my
code
for
my
operational
concerns,
which
is
really
not
a
good
pattern
at
all.
I'm
gonna
dig
quickly
into
what
the
animal
is.
It's
basic,
boilerplate
stuff.
This
is
like
the
most
boilerplate
criminais
DS
deployment.
A
Ever
all
these
things
that
are
bolded
would
have
to
be
found
and
replaced.
Somehow,
if
you
release
with
the
animal,
so
you
might
use
ed
or
whatever
to
do
a
bunch
of
find
and
replaces
if
we
go
further
down
in
again.
Two
more
final
replaces
we
got
to
replace
the
title.
We
have
to
replace
the
link
and
hope
that
these
words
don't
appear
in
other
places
like
this
wouldn't
work
as
it
is
because
title
is
in
there
twice.
A
If
you
didn't
do
the
right
kind
of
said
patterns,
and
then
this
is
where
I
in
line
the
entire
Wiggum
software
that
bash
script
just
multi
lines,
yeah
mul,
stick
it
in
their
call
it
good.
If
we
go
further
in
here's
our
service,
it's
pretty
standard
stuff
that
the
one
thing
I'll
point
out
is:
we've
got
our
operational
decision
that
we
make
by
editing
code.
So
if
you
want
to
change
your
mind
about
a
release
edit
this
code
and
take
a
comment
out,
it's
even
worse
with
ingress.
A
If
we
want
to
change
our
mind
about
making
this
ingress
rule,
we
edit
the
source
code
and
take
a
chunk
of
it
out
and
say:
oh
that's
how
we
made
our
decision.
It
works,
but
it
really
falls
apart
quickly
and
you'll
see
that
in
the
demo.
So
let's
do
our
quick
evaluation
of
llamo,
so
we're
gonna
do
this.
We
would
copy
and
paste
again
we
structured
our
code
to
make
our
deploys
easy.
So
we
copy
and
paste
we
do
a
bunch
of
replaces
we
uncomment
one
line.
A
We
delete
another
section,
that's
three
different
kinds
of
operations:
to
do
all
these
different
decisions,
it's
already
painful
and
just
it's
ugly
and
brittle
our
update.
Our
first
updates,
not
too
bad.
You
could
edit
the
amal.
The
title
is
only
in
one
place.
If
you
want
to
update
the
title,
you
just
change
it
and
it'll,
probably
work
yeah.
If
I
wanted
to
re-enable
ingress
I
got
to
go,
find
that
code
I
deleted
from
the
right
point
in
time
that
I
made
this
release.
A
Do
all
the
finding
replaces
I
should
have
done
at
that
point
and
then
hope
it
works
and
I
don't
even
put
it
on
here.
Cuz.
It's
you.
Basically,
if
this
is
how
you
have
to
do
a
thing,
you
probably
just
won't
reporting's,
okay
right
again,
I'm
structuring
my
code
for
my
process,
which
is
not
good,
but
it
makes
reporting
easy.
Although
this
is
sort
of
a
force
for
the
trade
situation,
you
have
a
lot
of
data
not
really
relevant
to
my
decisions,
but
just
massive
amounts
of
data
and
deleting
is
fine
like
it
works.
A
So
that's
yeah
mol.
We
all
start
there.
It's
a
great
way
to
prototype
it
moves
quickly,
but
it
really
really
breaks
down
doing
with
the
most
basic
crud
on
the
simplest,
app
I
could
think
of
with
very
few
inputs.
It
already
is
terrible.
So
this
is
where
people
tend
to
move
in
to
helm
and
that's
fine
right.
You
start
to
feel
more
confident,
you're
getting
more
power.
You
can
restructure
your
code
to
be
for
your
codes
benefit,
not
your
deployment
benefit.
This
is
what
it
might
look
like.
A
I
can
now
split
out
that
yamo
into
multiple
templates
I've
got
some
chart
metadata
I've
got
my
release,
values
files
like
I'm,
not
gonna,
go
over
this.
There
are
a
lot
of
home
talks.
The
one
thing
I
think
is
important.
Here
is
when
we
move
into
helm
away
from
the
ammo.
We
really
start
to
like
put
into
code
what
our
decisions
are,
what
our
inputs
are,
and
we
put
them
in
hell'
them
in
this
values,
file
and
I'm,
going
to
bring
this
up
specifically
because
you'll
see
it
again.
A
When
you
come
to
operators
right,
we
now
describe
all
our
metadata
for
our
inputs
and
all
those
fine
and
replaces
are
now
templated
information.
If
this
is
great
going
further
down
in
this,
if
statement
in
the
middle
is
the
cool
part
no
longer
do
we
uncomment
a
section
of
code,
we
have
an
if
statement
for
a
decision,
which
is
what
a
decision
is
same
thing
with
ingress
that
whole
section.
We
don't
have
to
worry
about,
deleting
it
and
replacing
it.
We
just
don't
render
it
for
a
while.
So
let's
do
a
quick
evaluation
of
helm.
A
I
know
I'm
breezing
through
these
I
want
to
focus
on
operators,
so
in
helm,
where
you
would,
you
know,
create
a
values,
file
and
here
I'm
doing
again
with
the
Basheer
doc,
because
I'm
assists
admin
by
heart
and
I
like
bash.
So
we
write
this
whole
file.
We
use
helm,
install,
give
it
the
template
directory
and
the
values
file,
and
it
works
I'm
going
to
focus
on
the
bottom
section
in
here.
This
is
kind
of
where
things
start
to
break
down.
A
It's
kind
of
belies
the
complexity
here
at
the
bottom,
because
we've
got
to
have
the
helm
binary.
We
have
to
have
all
the
values
files
and
we
have
to
have
all
the
template
data.
It's
really
really
hard
with
this
system
to
integrate
other
things
into
rendering
your
home
charts.
It's
not
easy
to
create
a
an
integration
for
changing
it
in
your
decisions
or
deploying
new
things.
If
you
have
to
have
this
like
super
specific
constructed,
helm,
environment,
it
does
work,
but
it
kind
of
breaks
down.
Our
updates
are
much
cleaner.
A
Like
I
love
this,
you
just
change
a
file
and
do
an
upgrade
again.
You
have
to
have
a
specific
environment
to
have
homework,
but
it's
there
and
the
ingress.
It
almost
doesn't
look
like
I
changed
a
file
because
it's
the
same
process
for
ingress.
It's
not
I,
think
we
have
to
be
afraid
of
anymore.
It's
just
another
change
reporting
is
better.
We
have
a
little
bit
of
metadata,
but
it
still
too
much
data.
A
It's
not
really
telling
me
what
I
put
into
it
is
just
telling
me
all
the
things
and
I
have
to
infer
from
this
data.
What
I
really
want
and
deleting
is
fine
I,
have
nothing
to
say
about
deleting
in
helm,
except
use
the
purge
flag
or
just
always
use
the
purge
for
like
I.
Don't
know
why
it's
not
default
so--that's
helm
right,
we've
all
done
it!
It's
fine,
but
it's
not
great.
It's
not
perfect.
A
I,
don't
have
all
the
power
and
for
all
the
power
we
use
operators
and
when
you're
using
an
operator
you
just
spam
things
out,
left
and
right.
You
have
confidence
and
you're
just
creating
things
like
crazy
and
it's
always
entertaining,
and
it's
always
amazing.
This
is
where
I
come
back
to
the
values
file.
We've
already
kind
of
moved
all
our
decisions
into
code
and
to
use
an
operator.
We
do
this
thing
that
you've
probably
heard
a
lot.
Now
we
to
make
a
custom
resource,
we
wrap
that
same.
A
It's
the
exact
same
Gemmell
I'm,
just
wrapping
it
in
some
curry,
Nettie's
metadata
and
saying
hey.
This
is
the
speck
of
a
Wiggum
gift.
Now
and
and
of
course,
in
order
to
do
this,
you
have
to
tell
kubernetes,
okay,
here's
a
custom
resource
definition:
they're
gonna
be
called
Wiggum
gifts.
This
is
the
API
and
the
version.
One
thing
I
will
point
out.
Is
this
additional
printer
column
section
in
the
custom
resource
definition
now
I
can
tell
it
hey
if
somebody
uses
cube
control,
get
here's
the
exact
data
that
they'll
probably
want
to
see
by
default.
A
You
can
get
whatever
you
want
out
of
it
technically,
but
this
is
nice
to
set
some
sane
defaults
for
what
you
would
see
when
you're
reporting
back
and
you'll
see
that
in
a
second,
by
the
way
I
know
I
haven't
written
an
operator.
Yet
we're
gonna
talk
about
using
one
before
we
write
them,
because
the
point
is
I:
don't
care
I,
don't
care
how
it's
written,
I
really
don't
need
to
know.
A
Details
I
need
to
know
what
my
interface
is
and
how
to
use
it
and
the
implementation
is
someone
else's
problem
so
we're
starting
with
using
one
so
the
principle
of
every
operator,
no
matter
the
language
framework.
Whatever
is
the
same.
Three
steps
watch
seek
and
report.
We
watch
kubernetes
official
things
and
we
watch
our
custom
things.
We
get
all
the
events
as
things
change
in
the
community
with
the
creators
API
we
seek
do
kubernetes
or
whatever
changes
to
get
to
that
desired,
state
and
report
on
the
transition
to
that
state.
A
We
do
that
over
and
over
again
every
single
operator,
no
matter
what
follows
this
pattern.
It's
it's
actually
a
really
great
pattern.
So
if
I'm
gonna
use
an
operator,
this
is
all
I
really
need
to.
Don't
really
technically
need
this.
You
can
do
it
with
just
your
code
again
we're
back
to
llamó
because
all
roads
of
communities
starting
amel
and
that's
okay,
because
this
animal
is
just
the
right
amount.
A
So
I'm,
okay
with
it,
let's
do
a
quick
evaluation,
so
our
creation
is
create
the
Wiggum
gift
resource
and
then
use
cube,
control
or
any
API
tool
to
create
this
resource.
It
seems
as
simple
at
home,
but
it's
simpler,
because
I
don't
need
a
specific
environment.
I
don't
have
to
have
values,
files
and
templates.
I
really
just
need
my
inputs
and
a
way
to
put
them
into
system
and
go
edits
are
also
really
cool
because
we
have
all
the
same
kind
of
capabilities.
A
Kind
of
like
we
hadn't
tell
them,
but
the
left
side
has
all
these
options
now
right
we
can
do
Q
control
apply
edit
use
the
patch
command
or
any
API
patch.
To
do
these
edits
and
we'll
do
the
patches
in
the
demo,
with
with
cute
control
enabling
ingress
again,
you
can't
even
tell
I
switch
because
it's
the
same
thing
it's
now
this
thing
that
was
terrifying,
any
ammos
now
as
easily
as
anything
else.
This
is
where
I
think
it
gets
really
cool
the
reporting.
A
Now
we
have
the
ability
to
get
rid
of
all
the
excessive
details
and
get
just
what
we
want
right.
I
could
look
at
this
and
without
knowing
anything
about
the
crew
Venegas
resources
it
made.
I
can
see
what
the
inputs
are
and
where
it
is
in
that
progress
I'll
get
the
exact
information
I
need
without
having
to
deduce
anything
from
this
wall
of
output
and
I.
Think
this
is
a
lot
of
value.
A
You
can
get
custom
columns
from
crude
Control
Oregon
any
API
tool
and
deleting
is
break
like
API
delete,
keep
control,
delete,
it's
really
clean.
Let's
do
our
demo
so
on
the
top
I've
got
a
cluster
running
locally
with
k3s
I
love,
k3s,
recommend
it
to
everybody
who
hasn't
used
it
yet
and
what
I'm
gonna
do
is
run
a
scripted
demo
and
we're
gonna
use
our
operator
again,
not
even
talking
about
how
we
wrote
it
yet.
A
So
we
write
out
this
yamo
file
with
a
hair
doc
put
it
into
the
cluster
and
all
these
things
will
suddenly
exist.
Boom.
I
can
immediately
look
at
this
and
see
okay
well
here
here.
All
my
inputs
here
are
what
kind
of
service
I
made
whether
or
not
ingress
is
created,
what
the
title
is
and
whether
the
deployment
is
ready
or
not,
and
as
we
do
upgrades
you'll
see
the
deployment.
A
If
you
watch
these
truths
here
in
the
middle
it'll
change
to
false,
if
it's
ever
not
ready,
so
I
get
active
information,
just
what
I
need
we
go
ahead
and
proxy
and
you'll
see
we
can
work
there.
We
go
yay.
The
really
really
simple
software
works,
big
surprise,
let's
go
on
and
do
our
evaluation
here.
You
gotta
control,
see
that
okay,
so
we're
gonna.
Do
our
update
of
the
title
again
I'm
rewriting
the
file
for
the
demo,
but
you
could
use
any
editor
put
in
the
cluster
and
watch
that
true
change
to
false.
A
As
the
rollout
goes.
So
it's
false.
It's
not
ready
we're
in
the
middle
of
a
rollout.
Now
it's
true
it's
done
like
it,
wouldn't
be
that
quick
normally,
but
you
get
just
that
right
information
for
you.
We're
gonna
enable
ingress,
I'm
gonna,
do
a
patch
I,
don't
even
have
to
have
anything,
but
literally
the
field.
I
want
to
change
and
I
can
do
a
patch
and
the
operators
gonna
seek
it.
You'll
see
that
ingress
rule
will
pop
up
here
in
a
second
boom.
I,
don't
have
to
have
all
this
structure.
A
You
can
see
how
you
could
put
that
into
you
know
a
slack
bot
for
all
I
care,
I'm
gonna
proxy
and
see
our
changes.
We
should
get
on
your
title.
Yeah
that
didn't
work.
Okay,
you
guys
believe
me,
I,
don't
have
enough
time
to
stay
here
and
mess
with
it.
We're
gonna
do
another
release,
just
cuz,
it's
cool
you
can
see
which
we
do
multiple
releases
there
at
the
top.
It's
gonna
be
easier
to
consume,
lots
and
lots
of
these
releases
and
get
just
the
metadata
like
that.
A
First
wall
of
text,
when
we
did
our
yeah
mole
demo,
was
not
too
bad,
but
if
you
had
a
hundred
deployments-
and
you
have
to
deduce
from
a
hundred
like
this
giant
wall
of
text,
all
of
your
deployments,
their
decisions,
it
becomes
really
painful
reporting.
Here's
where
we
do
our
report
deleting
is
really
clean.
I'm
actually
gonna
do
one
other
quick
thing
that
I
think
is
really
cool.
I
wrote
this
demo
that
just
pulls
random
things
from
giffy
just
to
simulate.
A
What
if
I
just
gave
you
know
my
user
is
just
access
to
start,
creating
with
them
gifts
willy-nilly.
If
you
did
this
with
hella
more
raw
yeah
mole,
it
would
be
really
slow.
You
couldn't
just
write
it
in
a
tiny
little
batch
loop
and
it
would
be
really
really
hard
to
see
everything
and
all
the
things
that
people
are
deploying,
but
here
I'm
deploying
right
little
random
gifts
from
giffy,
and
it's
real
easy
for
me
to
tell,
but
whether
or
not
people
wanted
ingress
created
or
not
whether
or
not
they.
A
Whether
titles
are
like
whether
things
are
ready,
I
can
get
just
the
information,
I
need
and
nothing
more
so
we'll
move
on.
Let's
write
an
operator,
that's
what
we're
here
for
you
can
kind
of
see
the
value,
hopefully
I'm
selling
you
on
the
business
value
and
the
operational
value
of
moving
to
an
operator.
Now,
let's
see
how
easy
they
really
are
to
write,
because
it's
not
as
hard
as
you
think
so.
A
The
first
thing
we're
gonna
do
is
with
meta
controller,
but
a
controller
is
a
really
great
tool
where
you
just
write
the
web
book
and
it
does
the
business
logic
for
you,
so
we
have
our
same
chart
from
before,
but
the
only
thing
we
write
in
this
chart
is
that
little
bit
the
center,
where
we
credit
webhook,
to
do
the
calculation
of
the
business
logic.
This
is
what
it
takes
to
run,
something
with
meta
controller.
A
Omitting,
the
fact
that
you
have
to
install
it
ahead
of
time
you
create
a
config,
I'm
running
a
deployment
to
actually
run
the
webhook
and
then
there's
the
webhook
code.
This
is
the
meta
controller.
Config
ignore
the
spaces,
there's
a
reason.
What
we're
looking
at
here
is
saying:
okay,
we're
going
to
have
waiting
gifts
as
the
parent,
it
might
make
some
deployment
services
and-
and
if
any
of
those
things
change,
call
this
webhook.
A
That's
all
we're
saying
here
it's
more
verbose
in
detail
because
there's
more
options,
but
that's
the
core
where
what
we
have
a
parent
and
three
children.
This
is
a
kind
of
snippet
of
our
web
server
function
again,
I'm
writing
in
Python.
It
could
be
any
language,
you
just
have
a
standard,
you
parse
a
certain
hook
with
certain
inputs
and
you
output.
What
you
want
so
we
take
in
the
current
state
at
the
top
we
say:
here's
the
current
state
of
the
parent
and
the
children.
A
We
calculate
our
desired
state
and
then
we
return
from
the
web
hook.
What
we
want
based
on
you
know
the
inputs
or
whatever
we
whatever
you
want.
I
met
a
controller,
doesn't
work
to
make
the
output
real
because
we're
in
Python.
We
now
have
some
safety
where
we
can
do
car
cool
string
building.
We
have
like
more
flexibility
like
helm,
really
breaks
down.
If
you
do
complex
manipulations
of
objects,
but
Python
can
do
that
really
efficiently.
Our
business
decision
is
still
in
an
if
statement.
A
A
Now,
because
now
we
can
get
this
all
this
value
of
the
operator
and
really
only
write
one
function
and
that's
cool
the
main
thing
that
breaks
down
a
meta
controller
is
at
the
end
we
just
say
here's
what
I
want
and
we
hope
that
meta
controller
can
do
it
and
if
it
can't
and
it
fails,
we
don't
have
any
graceful
points
to
really
like
any
touch
points
to
say.
Well,
if
that
didn't
work,
don't
do
this,
we
just
splat
it
at
the
cluster
and
hope
it
works
kind
of
like
home.
A
So
to
get
the
real
power
you
want
to
go
to
golang
and
use
the
operator
is
decay,
hopefully,
because
it
takes
away
a
lot
of
the
horrible
boilerplate
of
operator.
Sdk
sorry
of
client
go,
but
we
still
have
that
same
pattern,
whether
it
no
matter
what
the
controller
is,
no
matter
what
you
read
it
and
it's
still
watch
seek
and
report.
The
difference
is
now
we
do
all
of
these
things,
or
rather
we
tell
meta
controller
to
generate
or
sorry
operator
SDK
to
generate
the
code
for
all
of
these
things.
A
This
is
what
it
takes
to
the
operator
SDK
to
make
a
new
operator.
You
say,
make
a
new
one,
call
it
Wiggum
and
it
morally
plates
out
a
lot
for
you.
If
we
dig
in
here
there's
a
lot
of
code
in
here,
the
one
thing,
I
wanna
point
out:
it's
already
generated
all
the
ammo
rack,
yamo,
all
roads,
starting
animal.
We
dinner
it's
all
the
ml
to
deploy
our
operator
in
the
cluster
immediately.
A
You
only
have
to
make
like
one
change
in
here
and
it's
all
usable
now
we
say
okay
operator,
SDK
I,
want
you
another
way
to
me.
Gifts
are
a
thing
and
that's
this
API
this
version
and
it
boilerplates
out
first
to
see
Rd
automatically
and
also
updates
its
role
to
say.
Oh
yeah,
you
should
also
have
the
ability
to
read
these
since
we
know
about
them.
It
also
generates
this
types
file,
which
is
where
I
really
really
get
excited.
Now
we've
got
our
the
same.
A
You
know
we
had
in
our
values
file
in
our
custom
resource,
but
explicitly
typed
and
go
right.
This
is,
if
you
squint,
it's
still
the
gift,
the
service
and
the
ingress
with
their
different
properties,
but
explicitly
type.
So
we
know
when
we
build
this
controller,
if
we're
trying
to
treat
things
as
types
that
they're
not
it
will
not
compile,
and
we
have
a
lot
more
safety,
big
advantage,
also
being
in
go.
A
If
we
wanted
to
say
for
a
waiting,
we
have
deployment,
have
people
specify
the
CPU
and
memory
requests
and
limits
I
don't
have
to
recreate
that
structure
in
my
operator,
I
can
pull
in
the
upstream
code
and
just
embed
the
resource
declaration
and
get
all
that
type
goodness
from
the
upstream
resources
and
kubernetes
right
in
my
own
resource,
which
is
really
really
great,
especially
for
that's.
Actually,
a
complex
object
right
there.
Now,
let's
make
our
reconcile
loop
for
our
Wiggum
gifts.
A
We
generate
that
with
boilerplate
generator
here,
and
it
would
primarily
make
this
way
come
gift
controller
file.
If
we
look
in
here,
there's
some
pseudocode.
This
is
what
the
controller
does
I'm
not
going
to
bore
you
with
the
details.
I
just
want
to
kind
of
show
you
what
it
does
it's.
What
meta
controller
does,
in
fact,
if
you
look
at
it,
it
says:
watch
the
parent
gif
and
then
the
child
deployment
service,
an
ingress
just
like
women,
meta
controller.
A
We
just
write
that
code
and
then
it
says,
if
any
of
those
things
change,
sync,
the
deployment
fail,
gracefully
sync,
the
service
ingress
again
failing
gracefully,
is
what
I
want
to
point
out
now
we're
stepping
through
them.
So
we
have
to
do
this,
those
steps
ourselves,
but
we
get
the
value
and
the
power
of
being
able
to
back
out
or
react
intelligently
to
problems
we
don't
just
have
to
splat
at
the
cluster
and
hope
it
works.
A
This
is
an
example
of
what
the
deployment
would
look
like
if
you
were
gonna
write
a
function
again,
the
go
code
starts
to
get
a
bit
longer,
that's
kind
of
one
of
the
downsides,
but
it's
still,
if
you
squint,
it's
still
the
same
deployment
that
we
had
in
yamo
and
helm
and
in
Python
it's
just
in
go
strictly
typed
structure.
We
have
all
the
kind
of
same
values
that
we
would
get
from
Python,
but
now
we
can
gun,
we
don't
have
to
like
get
nested
map
members.
We
can
just
drill
down
on
types.
A
We
have
strict
type
safety.
One
thing
I
want
to
say:
if
you
look
at
this
deployment
object,
it's
scary,
it's
kind
of
terrifying,
the
first
time
you're
in
client
go
and
you
try
to
write
a
kubernetes
official
object
in
strictly
type
structure.
It's
really
really
ugly
and
it's
so
ugly
that
I
made
a
tool
to
do
this.
For
you,
this
thing
called
struck
to
finds
its
director
fired
at
Carson
Arnett
and
you
can
basically
say
I've
already
got
a
yeah
Mille
to
define
this
thing.
A
A
It
works
just
on
the
latest
criminais
DS
version,
but
it
it
works
for
all
sorts
of
resources
and
it
tries
even
its
best
to
give
you
the
imports
and
make
sure
you
point
it
at
variables
when
you
need
to
so
I'm
proud
of
that,
hopefully
you'd
like
to
get
some
feedback
on
it.
Doing
that
by
hand
is
just
it's
the
worst.
A
The
other
thing
and
the
last
thing
I'll
say
about
being
and
client
go
and
having
the
client
go
operator
is
that
we
have
a
fully
faked
out
kubernetes
client
that
they
use
for
the
official
communities
testing.
So
I
have
really
really
good
unit
taste
testing
capabilities.
Once
I
move
into
client
go
right.
You
can
basically
there's
a
lot
of
code
in
here,
but
you
make
a
fake
client.
You
generate
your
fake.
Your
object
run
it
through
your
same
function
that
the
real
controller
would
use
and
check
the
output.
So
you
don't
need
integration
test.
A
You
can
do
unit
tests
to
make
sure
your
operator
always
behaves
the
exact
way.
You
expect
every
step
of
the
way.
So
that's
moving
on
to
client
go
hopefully
you're
starting
to
see
where
a
lot
of
the
power
comes
from
and
the
value
there's
more
work.
Is
you
kind
of
move
down
that
chain,
but
you
get
more
and
more
reliability
and
efficiency
and
business
value?
This
is
my
kind
of
opinion
of
where
the
things
are
and
how
they
relate
to
each
other.
A
Just
my
personal
opinion
here,
I
really
think
that
the
only
downside
of
using
good
client
go
in
the
operator.
Sdk
is
that
it's
got
this
learning
curve
and
I'm
trying
to
hopefully
help
ease
people
away
from
that
by
having
some
tools
like
struct,
if
I
and
using
the
operator
SDK
to
boilerplate
out
a
lot
of
the
work,
but
it's
basically
once
you
move
yeah,
most
really
only
good
for
iterating
it
and
developing.
A
If
you
ask
me
and
anything's
better,
that's
it
so
there's
the
link
to
the
source
code
there
at
the
top
I
use
k3s
for
all
my
demos
again,
I
really
really
love
that,
and
if
you
like
this,
you
should
check
out
my
specific
that
my
criminais
DS
deconstructed
talk.
It's
been
really
really
well-received
by
a
lot
of
people,
so
I'm
I'm,
proud
of
that
and
yeah
I
got
time
to
do.
I
have
time
for
some
questions.
B
A
Not
used
cube
builder
to
be
100%,
honest,
there
are
things
I'm
learning
every
day,
like
I,
said
I'd
really
heard
of
cop,
but
I
attended
the
session
yesterday.
So
no
strong
opinions
on
either
of
those.
My
strong
opinions
hopefully
come
across
as,
like
my
strong
opinion,
is
use
an
operator
like
you
can
immediately
that
immediately
see
the
value
that
comes
out
of
the
operator
pattern.
A
B
A
A
Let's
move
over
to
Matt
a
controller,
so
this
is
a
really
really
kind
of
abstracted
away.
A
lot
of
the
details
are
objective
way,
but
meta
controller
lets.
You
just
write
one
single
webhook
sync
function
and
it
could
be
in
any
language
here.
It's
in
Python,
but
literally
like
if
you
can
write
a
web
hook
and
say
I'm
gonna,
take
in
some
JSON
data,
calculate
what
I
want
spit
out
some
more
JSON
data
to
seek
the
new
state.
It
can
be
any
language,
there's,
obviously
it'll
come
up.
A
It
came
across
really
strong,
but
there
is
a
lot
of
power
and
being
and
go.
But
cop,
which
I
looked
at
yesterday
was
was
really
really
blew
me
away
on
how
little
boilerplate
and
you
can
get
a
lot
of
these
same
benefits
without
needing
to
learn.
You
go
and
sort
of
like
with
everything.
If
you
are
comfortable
and
your
team's
comfortable
with
a
specific
language
I
would
recommend
they
use
that
right.
C
Back
here
you
were,
you
were
talking
about
almost
interchangeably
about
using
the
operator,
SDK
and
then
client
go.
Were
you
actually
thinking
of
them
as
equivalent
or
are
you
talking
the
when
you
say
client
go?
You
really
mean
the
completely
bare
bones
without
the
the
operator
as
a
care,
or
are
you
thinking
about
about
you
know,
separately
or
together,
I
wasn't
I,
wasn't
clear
on
that
I.
A
Missed
it
you're
right,
I
am
miss
mashing
them
together,
because
operator
SDKs
does
use
client
go
under
the
hood
and
you
can
kind
of
get
access
to
the
bra
layers
of
that
when
you
need
to.
There
are
other
frameworks
that
don't
use
client
go
and
use
their
own
stuff,
so
I
I,
I,
use
them
interchangeably.
Okay,.
C
So
so
quick
follow-up
to
that,
then,
is
you
are
indicating
it
that
the
testing
capabilities
of
you
know
these
to
which
you
can
consider
equivalent
are
sort
of
better
than
you
know.
Each
increasing
layer
there,
okay
cool,
do
you
find
that
the
client
go
raw
has
even
better
testability
than
the
operator?
Is
the
Kay
plugged
in?
Thank
you
so.
A
That's
a
trick:
cuz
the
the
operator
SDK
doesn't
actually
I,
don't
think
last
I
checked
doesn't
have
any
like
functions
for
helping
you
generate
testing.
It
really
relies
on
the
fake
client.
That
is
that
I
show.
Is
the
official
client
go
fake
client
like
the
operator
SDK
didn't
rewrite
it?
It's
really
just
there
to
take
away
the
boilerplate
of
syncing,
so
yeah,
there's
no
stairs
I
wish.
There
was
I
wish,
there's
like
an
operator
SDK
like
nice,
pretty
way
to
write
unit
tests,
but
you
have
to
kind
of
get
in
the
weeds.
A
Is
a
really
good
question
and
I?
Don't
think,
there's
a
right
answer
to
that.
This
is
a
fight
that
people
have
I
personally
like
having
a
cluster
level
operator,
I,
don't
like
I,
don't
like
the
duplication
and
kind
of
the
enhanced
footprint
vulnerability
or
not
one,
but
like
things
that
could
break
by
running
one
at
every
namespace,
but
you're
right
you
having
a
cluster
level.
One
means
that
I
think
some
happens
or
it
goes
haywire.
A
It
gets
compromised
and
you
have
cluster
level
access,
but
as
far
as
where
the
operator
STK
is
fairly
opinionated
and
it
operates
by
default,
every
operator
that
you
build
to
the
upper
SDK,
if
you,
when
you
run
it
by
default,
it
runs
namespaced,
but
it
has
flags
to
go
cluster
cluster
wide,
which
I
basically
use
all
the
time.
So
that's
a
good
question.
Yeah.
A
It
does
so
the
question
is:
doesn't
it
have
to
be
privileged
and
yes,
depending
on
what
you're
operating
on
so
there's
a
difference
in
running
six
different
versions
of
the
same
operator
in
six
different
names
based
scoped
with
their
privilege
scoped
into
that
namespace?
Where,
if,
if
something
goes
wrong
or
then
it
can
really
only
do
things
in
a
namespace,
so
you're
kind
of
getting
these
blast,
radiuses
radii
the.
A
Custom
resource
yeah,
the
question
is,
you
have
to
do.
Cube
control
apply
with
the
custom
resource
definition
in
each
namespace.
That
thing
is
cluster
wide
custom
resource
definitions
have
to
be
clustered
wide.
The
difference
is
whether
or
not
the
operator
is
looking
at
a
single
namespace
or
all
of
them,
but
you're
right.
If
you're
gonna
have
a
custom
resource,
that's
either
all
or
nothing,
but
you
can.
Then
you
know
just
like
pods
are
technically
cluster
wide.
You
can
give
scope
to
access
to
pods
to
different
things.
You
know
by
namespace
or
deeper
anybody
else.
A
So
the
question
is:
is
there
like
a
specific
relationship
with
up
to
from
operators
applications,
or
is
there
a
specific
way
that
I
like
to
apply
operators
I?
Think
there's
a
lot
of
use
cases
for
them
that
don't
fit
the
norm.
So
I've
seen
like
three
major
use
case,
two
or
three
major
use
cases
that
I
really
like
one
of
them
is
really
that
you're
actually
seeing
I
mean
Amazon
was
actually
the
first
one
to
do
this.
A
Where
you
make
a
custom
resource
in
the
cloud
and
Amazon
is
written,
an
operator
that
will
spin
up
Amazon
things
for
you,
where
you're
using
the
criminais
DS
API
to
manage
Amazon
things
and
that's
an
operator
right.
It's
sync,
its
watching
cluster
state
and
syncing
States
somewhere
else,
but
that's
still
an
operator.
A
A
The
only
way
to
do
are
back
is
by
writing
to
a
config
map
and
inserting
a
multi-line
comment,
separated
value
bunch
of
are
back
data,
which
is
really
really
hard
to
do
at
any
sort
of
scale.
So
kind
of
to
me,
a
third
kind
of
operator,
I'm
thinking
about
making
this
for
weave,
is
where
you
would
take
a
custom
resource.
A
Instead
of
taking
the
one
thing
and
making
a
lot
of
things,
it's
the
inverse
pattern
where
I'm
saying
well,
this
single
config
map
entry
with
its
multi-link
strings
is
really
brittle
and
hard
to
manage
so
I'm
gonna
say
make
a
lot
of
custom
resources
and
have
a
operator
funnel
those
down
into
editing.
Just
one
tiny
thing
in
one
place,
which
is
I,
think
an
emerging
third
pattern.
A
Right,
so
the
question
is
about
operator
managers
and
whether
I'm
using
them
having
any
opinions
on
them.
This
is
sort
of
like
the
operator
of
operators
that
that
the
same
team,
that's
making
the
operator
SDK
is
trying
to
work
on
and
I
actually
like
that
I.
It's
kind
of
a
nitpick
on
me
that
I
can
make
this
really
cool
operator
and
that
I
always
have
to
like
have
yeah
mole
to
create
it
like
it's.
A
It's
actually
a
pain
in
the
butt
to
get
your
operator
into
the
cluster
I,
don't
think,
there's
an
a
clear
winner,
yet
I
haven't
used
any
that
really
blown
me
out
of
the
water,
but
I
desperately
see
the
need
for
one
I.
Think
it's
just
hard
to
no
one's
really
emerged
with
a
good
system
yet,
but
if
you've
never
used
an
operator
an
operator,
the
idea
is
that
somebody
and
there's
there
are
some
out
there.
I
just
haven't
had
any
personal
experience
with
them.
A
Where
there's
an
operator
in
your
cluster
that
someone
has
to
put
in
once
in
the
cluster
and
all
your
cluster
users
can
make
a
custom
resource
saying:
I
want
to
run
the
Wiggum
controller
or
the
Wiggum
operator
in
my
namespace,
and
you
just
make
a
custom
resource
asking
for
that
operator
and
the
operator
of
operators
makes
does
whatever
has
to
do
to
make
that
resource.
That
operator
run
and
work
for
you.
A
A
Anybody
else
I'm
sorry
it's
about
I
was
speaking
so
fast.
I
I
didn't
even
get
it
under
35
ever
at
home.
So
thank
you.
Yeah!
It's
high
energy
here,
I'm
really
caffeinated
up
I'm
appreciated
when
coming
out
by
the
way
it's
I
know
it's
like
the
second
to
last
talk
of
the
conference
and
everybody's
like
super
hung
over,
and
so
thank
you.
Thank
you
very
for
coming.