►
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
Kubebuilder: SDK for Extending Kubernetes - Fan Zhang, VMware Inc & Mengqi Yu, Google
Kubebuilder is a SDK for extending Kubernetes that enables rapid development of custom APIs with best practices out of the box. In this talk, attendees will learn about: Key Kubernetes API extension points and their capabilities. An overview of Kubebuilder’s features and philosophy. Live demo of a workflow of building and publishing custom API/Operator using Kubebuilder At the end of this talk, attendees should develop a good understanding of how to use Kubebuilder to automate their custom workflows on top of Kubernetes, for example, automating backup/restore of MySQL cluster.
To learn more click here: https://sched.co/FuJf
A
A
A
So
this
is
the
agenda.
First,
we
will
go
through
overview
of
the
kubernetes
resources
on
the
CRT
and
we
were
talking
about
how
to
extend
the
community
API
and
the
co-pi
CRD.
We
will
introduce
the
computer.
Of
course
this
is
a
framework
and
SDK
and
last
we
are
wrong
demo
to
show
how
to
use
a
computer
first,
we
will
work
on
monkey
to
start.
B
First,
let's
talk
about
community
resources,
so
core
API
is
other
ApS
that
it's
provided
by
kubernetes
natively,
so
they
covered
the
most
common
aspect
like
stay
foe,
workload
and
stateless
workloads,
load,
balanced
load,
balancer
storage
under
community
API
are
very
powerful,
since
they
are
declarative
and
the
level
based
and
a
synchronized.
So
on
the
right
hand,
side
is
a
common
structure
of
criminality.
Object
spec
contains
the
desired
state
under
status
is
currently
observed
state,
so
the
user
declared
the
desired
state.
B
Karuna
tapi
is
awesome
and
powerful.
How
can
we
extend
terminalia
care
to
support
our
business
logic
to
see
Rd
at
the
recommended
approach
to
achieve
this?
So
when
you
create
a
CR
D,
the
API
server
create
a
new
restful
with
results
pass
at
runtime
for
each
version
you
specified
in
the
c
rd
after
you
create
energy
Rd.
You
can
add
controllers
and
web
books
to
manage
your
customer
results,
just
like
the
core
API.
B
Now
next,
let's
talk
about
customer
results,
lifecycle,
so
one
user
create
or
update
a
customer
results.
First
dates
under
request
to
the
API
server
and
that
API
server
will
send.
Our
automation
reveal
request
to
the
mutating
web
hook
to
do
the
defaulting,
and
the
web
book
will
return
a
response
with
patch
pages
to
the
API
server
data.
Api
server
then
we'll
send.
Another
automation
reveal
request
to
the
validating
web
hook
for
validation,
and
then
the
web
book
will
return
the
decision
to
the
API
server
either
automate
or
reject.
A
B
We
choose
to
use
the
from
scratch
approach,
then,
to
support
all
the
steps
of
the
customer
results.
Lifecycle
user
need
to
write
the
CRD
definition
to
the
code
generation
and
implement
the
controller,
the
webhook
and
manager
gos
and
the
builder,
and
the
published
image
and
deploy
them
in
the
cluster
and
the
next
we
would
like
I
will
come
back
to
a
fan
to
let
him
have
a
deep
dive
into
how
to
implement
how
difficult
is
to
implement
our.
A
First,
hello:
first,
let's
look
at
the
general
workflow
in
the
controller
built
from
scratch.
So
contrary
CI
infinity
loop
watching
other
objects
in
the
custard
and
then
performing
a
reconciliation
on
the
objects
controllers,
neither
mechanism
to
look
up
to
procure
objects
from
the
API
server
and
the
retreats
of
them
into
a
local
cache
for
a
better
performance.
So
this
mechanism
is
called
informer.
A
Normally,
this
is
shared
by
many
controllers,
so
it
won't
trigger
handling
directly
but
dispatch.
The
object
to
controller
and
ready
to
take
over
controllers
have
has
has
to
provide
the
event
handler
functions,
to
inform,
to
call
back
based
on
the
changes
of
the
objects
so
invent
handle
increase
the
increases.
The
objects
objects
are
key
to
the
work
creep
over
the
controller
of
the
customer
controller,
so
the
work
creates
a
user
for
the
object.
A
The
keys
and
the
controllers
has
a
working
loop,
two
percent
of
the
kids
from
the
work
week
and
they
used
the
indexer
to
retrieve
the
objects.
So,
in
the
end,
the
controller
performs
the
reconciliation
logic
for
the
curve
to
align
the
current
estate
restored
to
the
desired
status,
though
we
can
see
from
the
left-hand
side.
This
is
a
basic
stack.
You
have
to
be
familiar
ways
to
do.
You
do
have
a
controller
from
scratch
sounds
on
the
top.
This
one
is
a
man
entering
point
where
you
can
start
your
controller.
A
The
API
is
a
bad
type,
is
very
important
this,
where
you
can
define
your
Casey
Rd
and
you
have
to
register
your
versions
kind
api's
into
a
runtime
scheme
for
C,
where
C
serialization.
So
thanks
to
the
community
community,
we
have
a
very
powerful
tool
like
trying
to
go.
Trying
to
go
provides,
provides
a
tour
cache
library
for
building
local
cache
in
former
indexer
many
kinds
of
a
quiz,
etc
code
generator
tools
can
help
you
with
virtualized
concepts,
informers,
Lister's
and
typical
key
functions.
A
Typically
functions
requires
after
one
point
1.8
version
of
communities
and
their
user
has
to
write
a
code
to
facilitate
as
a
bunch
of
stuff.
We
talk
to
people.
The
last
important
part
is
to
implement
a
reconciliation
logic
in
the
controller.
So
for
many
users-
and
we
don't
need
much
stack,
especially
we
don't
need
to
write
the
stack,
so
one
by
one
user
would
really
want
to
because
it
is
very,
it
is
a
steep
learning
curve
for
further
serve
for
some
staff
for
some
use
cases.
User
just
need
to
write
a
control
over
very
simple.
A
So
this
diagram
shows
a
high-level
relationship
between
these
parts.
So,
as
a
binary,
the
computer
can
be
run
from
the
command
line.
This
is
a
command
line,
tour
to
initialize,
a
project
and
a
scarf
rotate
with
boiler
plates
and
the
peseta
structures,
including
include
including
the
hierarchy
of
api's
controllers
web
hooks.
A
An
entry
point
of
controllers
manager,
which
is
a
wrapper
of
the
controllers
and
the
web
hooks
docker
fires
is
also
provided.
Doctor
fires
is
for
build
and
pop
and
publish
the
image
so
make
fire
is
used
to
performing
some
operations
like
build
test
and
deploy
to
the
cluster
the
scarf
the
scarf
or
you
can
this.
A
A
A
A
A
The
controllers
have
to
be
added
to
the
controller
manager,
which
provides
a
shared
dependencies
like
local
cache,
rantin
scheme,
arrestor,
config
and
the
rest
of
client
the
coma
there
is
a
common
culture
pattern.
It's
abstract
here
to
us
your
series,
a
series
of
interfaces,
for
example,
the
reconciliation
function
of
the
controller,
can
be
extracted
to
our
reconciler
interface,
which
attacks
the
request
and
request
interface
and
the
returns
are
a
result,
interface
and
error.
A
The
request
to
contains
a
unique
information
to
identify
the
kubernetes
resources
or
CRD
the
requesters
are
including
the
work
we
instead
of
our
objects,
the
keys.
So
that's
the
difference
with
from
scratch,
approach
so
or
see.
Our
events
and
the
external
operations
like
webhook
poor
backs,
are
abstracted
to
the
source
source.
A
The
controller's
has
a
watch
function
which
function
Texas
stores
as
a
press
as
primary
documents.
The
source
is
a
process.
Divisor
event
a
hand
order
to
increase
the
request.
The
watch
functions
also
triggers
a
right.
We
can
reconcile
reconcider,
so
we
don't,
we
don't
have.
We
don't
have
time
to
deep
target
to
the
controller
controller
runtime
coded
based
on
the
use
cases
due
to
the
it's.
A
If
you
wanted
to
know
about
this
high-level
abstraction,
sorry
rods
and
the
Phillips
will
talk
will
give
out
will
give
out
supporting
the
coming
could
come
Seattle
in
this
December,
so
this
diagram
shows
a
major
interactive
points
in
controller
runtime
that
you
may
know
this.
As
I
said
manager
is
a
wrapper.
So
start
start.
This
is
a
start
appointed
to
create
a
controller
user
user
has
to
implement
or
reconcile
reconcile
interface.
The
controller
needs
to
be
added
back
to
manager
and
to
start
you
to
by
the
manager.
A
B
B
So
in
this
demo
we
are
going
to
use
cuter
to
scar
for
the
new
project
and
then
use
it
to
scar
for
the
CR
dapi
and
a
controller
and
a
web
hook.
And
after
after
that,
we
will
fill
in
some
business
logic.
And
then
we
will
build
the
image
and
deploying
the
mini
cube
cluster
to
make
tests
test
out
and
verify.
Since
works
correctly.
A
B
B
And
the
next
that
commits
the
generated
change
next
step-
let's
add
some
business
logic
by
applying
a
patch
and
then
let's
look
at
what
has
been
added,
so
you
can
see
that
in
this
testicle
we
add
a
field
called
a
replica
which
is
in
here
and
the
result
is
called
the
bounded
deployment.
This
is
a
spec.
A
B
B
B
B
B
So
if
things
work
correctly,
when
we
create
bound
a
deployment
with
replicas
equals
10
first
at
the
mutating
webhook
will
modify
the
replica
from
10
to
2
and
then
the
controller
watching
boundary
deployment
will
create
another
deployment
with
the
same
replica.
So,
let's
verify
by
using
our
cube
control
guide
deployment
and
though
we
grabbed
replica
few,
it
should
be
too.
B
Okay,
let's
do
a
quick
recap
after
the
demo,
so
from
the
demo
we
can
see
that
first
cubular
is
easy
to
use.
It
has
car
for
the
project
controller
web
who
by
simply
run
a
few
cubes
other
command
and
the
second
it
required
minimum
operations.
So
mostly,
you
only
need
to
fill
in
your
business
logic.
It's
a
easy
and
fast
and
the
third
streamline
the
workflow,
so
the
recommended
workflow
is
captured
in
them
make
well.
B
You
can
simply
do
that
by
running
make
with
different
targets,
and
then
there
are
some
resources:
first,
daizaku
Buddha
repo,
it's
under
criminal
physics
and
dentists,
track
channel
and
there's
a
workshop
from
philip
warthog,
which
you
can
try
offline
and
lastly,
contribution
are
welcomed.
Thank
you.