►
From YouTube: Extending K8s- Introducing Custom Resources, Controllers, Operators & Schedulers by Oladipupo Ajayi
Description
Kubernetes has become a major tool in the cloud native space because of its ease of use and ability to scale workloads effectively coupled with the wide range of use cases covered by its robust API, as the use of Kubernetes increases there will be scenarios Kubernetes will not be able to handle by default. Kubernetes was made to be highly configurable and extensible, what this means is that you can customize your Kubernetes cluster to do precisely what you want it to do or extend the functionalities that Kubernetes already offers. There are several ways Kubernetes functionality can be extended and some of them will be introduced and discussed
---
KCD Africa 2022 is the 2nd iteration of the Kubernetes Community Days Africa, a CNCF-powered free community event. Visit https://kcdafrica.com for more information.
A
C
B
D
Schedulers
and
if
there
is
time
I'll
be
able
to
do
a
simple
demo
while
we're
at
it
yeah
so
for,
like
I
said
my
name
is
dick
paul,
I'm
a
cloud
data
engineer
at
continuous
solutions,
I'm
a
cloud
acrobats
cloud,
engineer,
devops
engineer
and
everything
on
adws
and
azure.
Also
software
engineer,
when
I
can,
I
basically
write
python
and
golang
building
for
now
majorly,
focusing
on
building
controllers
and
operators
yeah
nice
to
meet
you.
D
So,
let's,
let's,
let's,
let's
get
to,
let's
get
going
so
yeah.
What
is
kubernetes
I
I
don't
want
to
focus
so
much
on
what
kubernetes
is
and
definition,
but
I'm
going
to
mention
just
a
couple
of
things.
First
off
kubernetes,
like
we
know,
is
a
content
orchestration
tool.
It
helps
orchestrate
containers,
manages
them
and
their
entire
life
cycle
pretty
much
like
that's
a
very
simple
definition
of
what
kubernetes
is
like.
I
said
the
some
of
the
features
are
it
autonomous
deployments,
helps
with
auto
scaling,
helps
with
self-healing.
D
D
D
It's
really
awesome,
but
kubernetes
being
a
very
highly
extensive
system,
and
what
I
mean
is
that
you
can
add
your
own
features
and
if
you
go
to
kubernetes
github
repository
because
it's
open
source
there
are
no,
there
are
really
no
patches
right,
no
requests
to
add
like
basic
major
features
right.
So,
if
I
as
a
company,
I
need
a
particular
feature
right
on
kubernetes
and
is
not
available
in
the
default
installation.
D
I
can
always
add
it
myself
because
of
this
extensibility,
and
what
actually
makes
this
happen.
What
makes
this
is
I
extensibility
happen
is
because
the
other
humanities
is
built
on
apis,
so
everything
you're,
seeing
from
your
board
to
your
services
and
everything
at
apis.
So
everything
is
communicating
with
api
you're
communicating
with
kubernetes
through
the
api
you're
doing
kubernetes
communicating
with
yourself
through
the
keyboard,
analysis,
api
and
that's
one
of
the
real
beauties
of
kubernetes.
D
That
is
not
being
spoken
so
much
about
so
yeah,
exciting
keyboarding
is
what
does
what
do
I
mean
when
I
say
extending
kubernetes
majorly?
What
it
means
is
that
I
add
any
new
functionality,
like
I
mentioned
earlier,
that
isn't
part
of
your
default
kubernetes
installation.
So
if
I
have,
if
I
decide
to
install,
maybe
kubernetes
1.22,
for
example,
1.21
there's
a
set
of
features
that
comes
with
it,
but
then
there
are
times
when
what
you
need.
D
What
you
actually
need
is
not
included
in
this
particular
in
the
default
installation,
and
you
can
also
always
add
some
things
with
it.
So
yeah,
that's
what
extended
kubernetes
mean
here
yeah
several
risk
awarenesses
can
be
extended
like
a
lot
of
ways,
but
for
this
talk
we'll
be
focused
immediately
on
including
endpoints
and
adding
functionality
to
the
kubernetes
api.
D
I'll
explain
what
this
means
as
I
go
on
and
to
become
clear
as
I
as
I
move
on,
but
majorly,
focusing
on
creating
endpoints
and
adding
functionality
to
the
endpoint,
pretty
much
very,
very
simple.
So,
let's
take
it
back.
Let's
take
a
step
back
and
see:
we've
already
defined
what
pivot
net
is
right,
but
then,
let's
look
at
something
I'm
sure
a
couple
of
us
will
be
familiar
with
this
image,
so
this
image
is
the
kubernetes
cluster
and
the
components
that
make
up
a
kubernetes
cluster.
D
D
So
we
have
our
controller
manager
yeah
we
have
our
xcd
sd
is
molecular
storage
that
stores
a
key
value
pair
of
all
of
the
resources
all
of
these
resources
within
kubernetes.
So
your
port,
your
services,
your
deployment,
all
the
information
that
kubernetes
needs
to
know
to
keep
states
of
that
resource
is
stored
in
fcd,
and
then
we
have
the
scheduler.
The
scheduler,
basically,
is
what
the
scheduler
does
is
it
schedules
sports
to
nodes
simple,
and
then
we
have
our
cloud
controller
manager,
which
is
majorly
for
cloud
providers.
D
So,
for
example,
we
have
we're
looking
at
aks
in
aws
or
aks
in
azure
or
gk
in
google.
They
all
have
this
feature
whereby
it
makes
it
easy
for
them
to
be
able
to
connect
to
the
baseline
infrastructure.
So
it's
not
it's
not
it's
not
a
it's
not
part.
It's
not
a
a
major
part
of
the
kubernetes
cluster
but
majorly
for
cloud
providers,
people
that
need
it
like
I
mentioned
earlier,
and
then
we
have
our
worker
nodes
here
and
those
were
candidates.
D
Visually
connects
to
the
cluster,
keep
ctl
and
keep
proxy
so
pretty
much.
This
is
what
you
have
for
every
default
installation,
and
this,
as
you
can
see,
the
api
sits
at
the
center
of
everything
and
the
division
is
because
that
is
knowledge
like
the
update
of
the
cluster
itself,
every
communication
that
happens
within
the
kubernetes
cluster
from
outside
the
kubernetes
cluster
into
the
cluster,
for
example,
as
a
user,
I'm
using
cube
ctl
everything
goes
to
this
gives
api's
level
and
the
api
server
itself.
D
D
All
of
this
thing
happens
through
the
api
server
and
this
api
server
api
actually
coordinates
out
all
the
resources
or
objects
that
assess
within
the
cluster.
Now,
as
you
can
see
in
the
diagram
below
you
can
see,
this
is
very
similar
to
the
image
that
we
had
initially,
but
then
there's.
There
is
a
an
attachment
to
the
right
hand,
side
and
that
point
is
more
or
less
like
showing
how
the
http
endpoints
actually
looks
like.
D
So
we
have
some
set
of
endpoints
like
the
lcd
metrics,
so
things
like
these
are
like
common
to
applications
where
you
can
check
the
outs
and
then
get
logs
and
metrics
from
the
cluster
and
then
for
very
specific
things
like,
for
example,
pods.
Oh,
I
want
to
get
a
list
of
my
pods
now,
for
example,
in
my
cluster,
the
end
point
I'll
go
to
majorly
is
the
api
for
slash
api
for
transfection,
one
first
large
ports,
and
I
can
use
my
http
verbs.
D
My
get
my
list
my
creates
my
updates
on
all
of
these,
and
then
those
are
the
things
this.
This
majorly
is
very
familiar
with
us
right
for
especially
for
software
engineers
that
are
used
to
creating
api
as
an
endpoint
and
all
of
that,
so
this
is
what
is
going
on.
In
the
background.
That's
it's
that's.
We
are
not
saying
like
a
typical
humanities.
User
is
not
saying
so
yeah
here
we
have
it.
So
this
is
an
example
of
the
kubernetes
api
now
down
to
what
we
actually
want
to
talk
about
today.
D
Talking
about
resources,
very,
very,
very,
very,
like
you
said,
there's
this
thing
or
is
actually
true
that
the
board
is
like
this,
the
it's
the
simplest
units
right
within
a
cluster
within
the
kubernetes
cluster
right,
but
that
sport
itself
is
actually
a
resource,
and,
like
I
mentioned,
all,
resources
in
kubernetes
are
endpoints.
So
when
you
have
anything
about
your
node
node
resource,
you
think
about
your
port
resource.
You
talk
about
your
service
resource,
you
think
about
your
name
space.
D
You
talk
about
your
volume
and
so
many
other
things,
your
job,
your
current
jobs,
anything
you
can
think
of.
They
are
all
endpoints
like
I've
mentioned,
and
I
try
to.
I
try
to
build
them
here,
but
now
that's
what
is
there
now
to
be
looking
at
the
right
hand,
side
of
of
the
slide
right
now
we
would
see
there
is
a
point
where
we
have
a
kubernetes
object
and
something
that
is
in
the
kubernetes
object.
Like
I
mentioned,
everything
is
a
is
a
resource.
D
It's
a
kubernetes
resource,
but
not
everything
that
is
a
keyboardist
object
and
the
difference
majorly
is
objects,
are
usually
like
existing
entities.
So,
for
example,
I
I
created
a
resource
type,
I
already
suspect,
which
is
namespace
and
pods
right,
and
then
I
created
a
resource
instance
with
my
offer.
That's
do
qct
apply
and
I
create
a
board
right.
That
creation
of
board
is
a
resource
instance,
but
what
comes
out
of
it
right
that
pod
instance
that
has
this
entire
metadata
and
the
id
and
everything
being
pesticided
in
lcd?
D
Is
the
kubernetes
object
itself
so
in
comparison
to
when
you
do
like
a
cuba,
city
or
api
resources
command,
for
example,
this
job?
What
this
does
is
it
lists
a
set
of
resources
for
us
right.
It's
a
resource
instance,
but
not
an
object,
and
the
reason
is
not
an
object
is
because
it's
not
being
pest
listed
in
the
xcd
in
the
cluster,
so
it's
just
doing
something,
but
it's
not
actually
an
entity,
that's
doing
something
that
needs
to
be
monitored
or
controlled,
or
we
will
go
back
to
when
we
need
them.
D
D
D
So,
in
the
previous
slide,
you
saw
how
we
created
a
kubernetes
object,
a
kubernetes
sport
object
right
with
a
resource
type
of
port,
so
we
can
do
the
same
thing
for
our
custom
resources
and
say:
okay,
I
want
to
create
a
custom
resource
called
foo
foo
bar
something,
and
I
wanted
to
be
able
to
create
a
kubernetes
object
of
of
night
of
type,
a
full
bar,
for
example,
and
how
do
we
do
that?
How
do
we
say?
D
Okay,
do
I
add
this
fullback
resource
right
to
my
endpoints,
my
kubernetes
endpoints,
and
the
way
we
do
that
is
we
do
we
use
a
kubernetes
with
a
custom
resource
definition,
so
a
custom
resource
definition.
Majorly
is
like
like
a
template
and
what
that
template
does.
Is
it's
used
to
add
endpoints
to
our
resource,
to
acquiences
api,
and
that's
that's
what
it
does
here.
It
adds
endpoint
and
it
has
fields
and
metadata
that
can
be
filled
into
that
resource
endpoint.
D
So,
for
example,
the
image
that
we
have
here
we
have
the
aml
file,
which
is
the
custom
resource
definition.
It
creates
a
custom
resource
as
an
endpoint.
That's
what
you
have
in
the
middle
and
anytime.
We
call
that
endpoint
you
can
use
that
endpoint,
which
is
a
resource
now
custom
resource.
Now
you
can
use
create
a
lot
of
objects,
a
collection
of
kubernetes
api
objects
of
that
custom
resource
time.
So
I'll
take
it
again.
D
D
Now,
if
I
want
to
create
an
object
of
that
resource
type,
I
would
have
to
query
the
custom
resource
endpoint
to
be
able
to
have
to
be
able
to
create
that
object
and
to
be
able
to
query
it
list
it
get
it
delete
it
just
the
same
way.
An
api
would
work
normally
yeah.
So
for
for
this.
For
this,
this
is
what
we
have
for
custom
resources,
but
then
they
really
don't
do
anything.
D
Custom
resources
are
just
they
are
just
labels
or,
let
me
say,
like
string,
for
example,
you
know
when
you
do
maybe
a
you
know
in
programming
when
you
do
a
equals
to
quotation
mark
abcd
that
doesn't
do
anything.
It's
just
a
placeholder
right.
So
custom
resources
are
like
this
so
that
they
don't
do
anything
they
don't
have
any
power
of
their
own.
They
don't.
They
cannot
think
by
themselves
more
like
a
caricature
in
if
I
can
use
that,
but
what
actually
makes
them
do
something
like,
for
example,
our
partner.
D
We
know
that
our
pod
objects
takes
an
image
right,
runs
that
image
and
then
exposes
an
a
port
and
then
an
endpoint
that
we
can
access
the
application
that
is
running
within
that
port
right.
What
makes
that
possible
and
what
makes
that
possible
are
controllers,
like
I
mentioned
before,
when
we're
looking
at
the
things
that
were
in
the
control
plane
right,
we
talked
about
the
controller
manager,
so
the
controller
manager
contains
all
the
logic
that
all
the
resources
are
using
all
the
default
resources.
D
So
by
default
resources
I
mean
ports
name,
space
nodes
demand
sets
deployments,
stateful
sets.
How
are
they
reconciled?
What
did
they
do
so
controllers
are
telling
you
to
do
that,
for
us,
so
controllers
are
like
are
control
loops
that
track
a
kubernetes
api
type
to
make
sure
that
the
current
state
matches
the
desired
states.
D
So
one
thing
I
need
to
mention
before
we
continue
is
that
kubernetes
was
built
on
an
event-driven
architecture
and
what
what
that
means
is
that
a
controller
kubernetes
watches
for
changes
to
a
particular
event
and
then
triggers
the
necessary
the
necessary
things
that
needs
to
do
based
on
that
event.
So,
for
example,
if
I
do
a
create
event
now,
if
I
do
keep
ctrl
grades
or
could
secure
apply,
and
then
I
pass
in
a
file
a
pod
file,
I'm
passing
I'm
sending
an
event
to
the
kubernetes
cluster.
D
It
picks
that
up
looks
at
my
file,
gets
the
gets
the
resource
kind
and
then
passes
it
to
the
right
controller,
and
the
controller
knows
what
to
do
by
creating
whatever
it
needs
to
do
so.
For
our
quad
example,
it
looks
it
says.
Oh,
this
is
a
port
kind
of
pod
resource
type
and
what
it
does
is
it
takes
this.
This
schema
the
name,
the
name
space,
the
container
image,
the
container
name,
the
container
ports,
for
example,
and
does
something
which
is
and
what
we
have
is.
D
So
that's
how
it
works
so
for
controllers
is
what
a
controller
is
that
black
box
you're
not
saying
right
when
we,
when
we
do
keep
city
apply
or
keep
still
get
or
keep
self-described
right.
All
of
those
things
are
part
of
the
controller,
and
the
control
actually
maintains
that,
for
us,
so
controllers
would
look
at
our
desired
state,
so
our
desired
state
is
what
we
send
into
kubernetes
and
the
actual
state
is
what
is
actually
happening
within
kubernetes.
D
So,
for
example,
if
I
send
in
a
deployment
now
a
deployment
type-
and
I
specify
I
want
to
have
three
or
three
instances
of
a
particular
image
running
right.
So
that's
my
desired
stage
right
by
the
time
I
send
it
in
it
starts
with
zero,
and
then
it
increases
to
one
two
and
three,
and
then
it
stops.
If
any
of
the
ports
is
deleted,
or
maybe
it's
down
for
whatever
reason,
the
actual
state
and
disaster
are
no
longer
in
sync,
so
in
the
controller,
what
the
controller
does
is.
D
It
makes
sure
that
if
it
turns
the
actual
speed
of
the
of
that
particular
resource
into
the
desired
state,
so
you
don't
continue
doing
that
in
a
loop,
but
then,
instead
of
doing
a
loop
and
trying
to
make
sure
make
sure
that
everything
works,
it
can
overwhelm
the
system.
So
that's
why
they
opted
in
for
an
event
driven
architecture.
Remember
when
there
is
a
change,
there's
an
event
is
sent
and
then
the
controller
can
take
care
of
whatever
is
happening
there.
D
So
yeah
we've
talked
about
controllers
now.
Custom
controllers,
which
is
what
we
want
to
talk
about
right
for
some
custom
resources,
like
I
mentioned,
are
just
endpoints,
created
by
custom
resource
definitions,
so
they're
just
like
an
api
that
kind
of
query
object
within
them.
They
don't
do
anything
more
than
that.
Custom
controllers,
like
are
the
logic
that
brings
those
custom
resources
or
the
object
they
create
to
life
like
they
become
responsive.
D
That's
what
I
mean
and,
like
I
mentioned
kubernetes,
is
a
declarative
programming
model
which
means
that
unity
takes
the
viral
state
of
the
objects
you
want
to
achieve.
That
is
all
you.
Do
you
don't
care
about
what
is
happening
in
the
background,
or
you
know
that
I
have
declared
this
and
I
expect
kubernetes
to
give
me
what
I've
declared
right
and
because
kubernetes
custom
controllers
extend
the
functionality
of
the
kubernetes
api
on
built-in
resources
right.
D
D
Actually,
they
usually,
they
are
used
typically,
when
a
use
case
is
not
covered
by
the
built-in
controller
manager
for
a
beauty,
resource
type,
so
very
important
for
us
to
make
to
notes
there
is
that
they
they
are
used
for
use
cases
that
are
not
covered
by
the
built-in
controller
manager
in
our
control
plane
for
building
resource
time
by
building
resource
types.
The
things
I
mean
are
things
like
pods,
namespaces
deployments
and
so
on.
D
So
like
a
typical
example
of
when
you
want
to
use
a
custom
controller,
is
let's
say
that
we
have
an
application
that
uses
a
configmar
right
to
maybe
send
some
environment
variables
into
the
containers
that
we
are
creating
so
but
then
there's
always
the
possibility
that
those
values
can
change
a
typical
manual
process
would
have
been.
If
I
need
to
make
an
update
to
my
configma
right,
I
make
the
update
to
the
configmap
with
the
key
and
and
but
then
what
happens
is
that
the
pods
that
are
running
on
that
configmap?
D
Don't
change,
because
the
values
are
being
passed
at
runtime
now
for
me
to
be
able
to
make
sure
that
the
ports
have
these
the
necessary
things,
I
would
have
to
go
and
stop
the
board
and
then
restart
it
right.
So
that's
the
manual
process
that
we
need
to
do
now.
We
can
create
a
controller
that
watches
for
the
configmap
resource
type
and
watches
for
changes
the
configmar
values
when
a
controller
detects
a
change
to
the
value
it
automatically
restarts
the
pod
force.
D
So
that
is
one
of
the
beauty
of
controllers,
and
that's
why
it
has
gained
so
much
traction
over
the
last
three
four
years,
because
it's
actually
very,
very,
very
reliable
and
it's
very
useful
for
some
particular
use
cases
like
this
one
that
we
mentioned.
So
that's
what
custom
controllers
are
yeah
in
some
way.
Custom
controllers
are
written
by
you
and
work
with
built-in
resources,
so
deployment
traffic
assets
and
so
on
and
and
custom
resources.
They
don't
exist
in
the
cube
controller
manager.
So
what
I
mean
is
like
I
mentioned.
D
The
keep
controller
manager
only
contains
controllers
for
default
resource
types
right,
but
then
these
controllers
do
not
live
in
there.
What
that
means
is
that,
and
they
are
independent
of
the
cycle's
life
cycle.
What
that
means
is
that
I
can
deploy
my
controller
somewhere
else
and
it's
to
still
be
watching
for
changes
to
my
kubernetes
cluster.
D
So,
for
example,
if
I
delete
I,
if
a
entire
cluster
goes
down,
for
example,
the
controller
has
to
be
running,
it
might
not
just
receive
any
event,
and
when
you
create
your
cluster
again,
you
continue
working,
so
it
doesn't
have
to
be
deployed
on
your
kubernetes
cluster.
That's
what
this
means
that
what
the
sentence
means-
and
we
can
only
separate
it
like
a
separate
application
that
is
cleaving
on
its
own
yeah,
so
operators
yeah.
So
this
is
the
next
step
to
controllers
and
what
they
do
so.
D
Operators
majorly
abuse
on
top
the
human
abstraction
to
automate
the
entire
life
cycle
of
the
application
in
manages.
So,
for
example,
we
have
humanities
resources
like
I've
mentioned
controllers
concept
for
building
resources
like
for
specific
key
skills.
Now,
controllers
are
usually
used
for
building
resources
right,
but
operators
majorly,
focus
on
custom
objects
and
custom
resources.
So,
like
you
mentioned,
we
have
custom
resources
right.
We've
have
custom
objects
that
are
created.
The
custom
is
just
being
created
by
the
custom
resource
definition.
D
Now,
when
we
take
it
a
step
back-
and
we
say:
okay,
yes,
controllers,
create
controllers
control,
the
life
cycle
of
built-in
resources.
What
about
the
our
own
native
custom
resource
types
are
created
and
the
objects
we
create
through
those
resource
types,
but
that's
where
operators
come
in,
so
that's
what
they
do
they.
They
are
custom
controllers
right.
D
Their
pc
machine
was
the
same
thing,
but
they
track
and
manage
custom
objects
created
by
custom
resource
definitions.
Operators
are
quite
powerful
in
their
use
cases
and
they
also
help
to
automate
the
operations
of
your
clinical
application
like
more
like
an
sra
tool
and
a
software
administrator
for
expanded
software
application.
Like
the
example
I
gave
earlier,
a
an
sr
engineer
will
have
needed
to
go
and
stop
that
board
and
restart
it
right
or
your
controller.
D
D
So
for
the
last
piece
here,
which
is
the
because,
as
I
mentioned,
scheduling,
journey
or
basically
ensure
that
ports
are
assigned
to
the
best
possible
available
nodes,
that's
what
they
do
like
they
don't
do
any
other
thing:
they're
not
complex.
That
is
this.
That's
the
definition
yeah,
like
I
said,
inbuilt,
there's
an
input.
D
Scheduler
called
this
cube
scheduler,
which
I'm
those
like
most
of
the
scenarios
that
we
would
need
schedulers
for
like
most
of
the
scenarios
when
schedulers
for,
but
there
are
times
that
there
are
use
cases
whereby
the
q
scheduler
will
not
be
able
to
undo
and
that's
when
we
can.
We
need
to
probably
need
to
write
our
own
scheduler
and
attach
it
to
our
kubernetes
cluster
so
that
we
can
use
that
scheduler
instead
of
the
default,
keep
scheduler.
D
So
a
typical
example
is
maybe,
for
example,
I
have
a
deployment
or
a
stateful
set
right,
and
I
want
to.
I
want
to
be
able
to
order
outputs
are
deployed
across
multiple
zones.
So,
let's
assume
I
have
a
kubernetes
cluster
right
and
I
have
multiple
nodes.
Let
me
select
10
or
15
availability
zones
across
multiple
places,
and
I
have
worker
nodes
in
all
of
those
zones.
D
What
the
scheduler
guide,
scheduler
that
says.
Okay,
this
is
the
order
in
which
I
want
this
node
these
ports
to
be
deployed
to
this
node.
So
I
can
say:
oh,
we
need
to
go
to
availabilities
on
a
first
then
go
to
availability,
create
the
port.
There
then
come
back
to
b
and
go
to
e
and
come
back
to
f.
So
that
is
a
typical
example
of
what
a
custom
scheduler
does
yeah.
D
So
that's
what
it
does
the
use
cases
for
this
one,
actually
not
as
much
or
as
visible
as
that
of
controllers
or
operators,
but
then
they
can
also
be
useful
yeah.
So
in
in
foresight
on
hand,
sides
we
have
quantities,
really
has
become
like
a
major
tool
in
eternity
space
right
when
you
say,
and
a
lot
of
people
would
say
when
you
say
kibanet
is
you
mean
cloud
native
right?
D
So
clarity
is
like
it
was
across
the
cloud
and
kubernetes
and
the
other
way
around
because
of
its
use
of
you
use
an
ability
to
scale
workloads
effectively
with
his
wide
range
of
use
cases
by
its
robust
api.
So,
as
the
adoption
of
kubernetes
actually
increases,
there
will
be
scenarios.
Humanities
is
not
equipped
to
end
by
default,
but
then
that's
where
extensibility
comes
into
play
and
we
can
also
always
extend
it
any
way
we
want,
in
whatever
fashion
that
we
want
to
extend
it
I'll.
D
B
D
What
I'm
going
to
do
is
I'm
going
to
show
us
our
custom
resource.
These
are
created
through
custom
resource
definitions
and
we'll
see
how
a
controller
is
being
used.
So
this
arm
controller
here
is
pretty
much
basic
and
simple
and
what
it
does
is.
It
creates
an
nginx
image
without
us
specifying
the
engineer's
image,
and
so
it's
just
very
basic.
It
just
shows
our
controllers
actually
work.
Now,
for,
like
I
mentioned,
there
are
a
lot
of
custom
resource
types
that
we
have
in
default,
kubernetes
cluster.
So
let
me
show
you
a
couple.
D
So
we
can
see
a
lot.
I
know
that
I
will
be
able
to
recognize
some
of
the
some
of
these
things.
Like
you
can
see
nodes,
you
can
support,
cancel
secret
service
account,
and
so
these
are
the
default
values
for
this
default
resource
types
for
kubernetes
in
kubernetes.
Right
and
now
we
want
to
create
a
new
resource
type
called
nginx
operator,
and
so
let's
do
something
real
quick,
let's
see
if
we
can
find
it
within
our
resource
types.
At
the
moment.
D
D
Yes,
so
this
is
a
typical
example
of
what
we
would
have
in
a
custom
resource
definition.
So
you
can
see
it's
a
and
again.
Customization
is
actually
custom
resource
type,
also,
which
is
which
which
which,
but
that's
what
makes
is
really
beautiful,
so
yeah
using
an
api
in
points,
okay
or
the
api
right.
So
you
can
see
it
has
a
kind
custom
resource
definition.
D
It
has
the
name.
So
this
is
going
to
be
the
name
of
our
custom
resource
type,
and
you
can
see
that
a
couple
of
things
that
have
been
mentioned,
the
group-
it
belongs
to
the
plural
form,
which
is
this
nns
operator,
singular
form
engineers
operator
and
we
are
specifying
that
is
a
namespace
resource
type.
There
are
two
types
of
resource
types:
there's
names,
namespace
and
cluster
wide,
so
clusterwise
are
operators
that
you
don't
need
to
specify
your
namespace
to
be
able
to
access
them,
but
I
bought
for
namespace
operator.
D
So
this
is
what
it
does
a
what
in
a
what
it's
something
to
notice
the
status
staples,
stop
resource.
It
shows
us
so,
for
example,
if
I
have,
if
I
say
I
want
to
have
three
replicas,
for
example-
and
I
only
have
one
right
it's
going
to
be
so
this
is
the
status
pretty
much
is
where
the
actual
script
of
that
resource
type
is
recorded.
D
D
So
I've
created
I've
added
my
custom
resource
definition
now
coming
back
here
again,
I
can,
let
me
do
decent
command
again
to
check
so,
as
you
can
see
now-
and
I
have
an
nginx
resource
type
here
with
everything
we
need
now,
what's
the
next
thing
we
need
to
do
so.
The
next
thing
we
need
to
do
now
is
we
create
our
kubernetes
object
right
so
yeah,
let's,
let's
let's
go
ahead
and
do
that
since
we
already
have
our
custom
resource
type
coming
so
for
our
engine
xd.
D
D
D
We
can't
see
any
any
part
being
created
and
the
reason
for
this
is
because
we
do
not
have
any
controller
behind
it.
That's
listening
to
activities
of
this
resource
type
to
know
what
to
do
so.
Like
I
said
it's
just
like
a
placeholder.
Nothing
happens
like
I'm,
not
seeing
anything.
Nothing
is
going
on.
So
if
I
do,
for
example,
qctl
describe.
D
You
can
see
at
the
bottom
you
can
see.
There
are
no
events
coming
in
at
the
bottom,
so
nothing
is
going
on.
We
don't
know
what's
going
on,
so
how
do
we?
How
do
we?
How
do
we
make
sure
that
what
we
have
is
actually
going?
It's
actually
quite
fine.
We
will
need
to
create
a
controller
and
deploy
our
controller
so
for
this
demo,
I'm
just
going
to
run
it
like.
I
said
to
joshua
what
I've
said.
I
don't
need
to
deploy
my
controller
on
kubernetes.
D
I
can
just
run
it
as
an
application,
so
for
this
one
we
are
using
go
right
to
write
our
controller,
and
this
is
the
logic
here.
This
is
very
simple,
very
basic.
Just
this
is
all
you
need
to
run
it
a
lot
of
things.
I
won't.
I
won't
spend
time
to
explain
what
all
of
this
is
doing,
but
what
you
just
need
to
know
is
that
this
is
what
we
need
we
are
making.
D
D
As
you
can
see,
you
know
initially,
when
we
did
keepsake
gets
bored,
nothing
was
running
now
we
can
see
our
engineers
of
creator
filterboard
actually
running
now,
let's,
let's
there's
one
more
thing,
to
show
that
it's
actually
working
the
way
suppose,
let's
delete
one
of
these
ports.
So
if
I
delete
one
of
them,
qctl
delete.
D
Yes,
so
that
the
little
one
of
the
parts,
let's
see
what
happens,
so
what
that
means
is
that
it's
going
to
change
state
rights,
our
state.
So
if
you
do
because
this
is
quite
fast,
it
will
probably
be
done
by
now,
so
won't
be
able
to
see
it.
So
it's
actually
running
again
changes
four
seconds
ago.
So,
if
we
have
done
something
like
keep,
ctl
describe
nginx.