►
From YouTube: Metacontroller with Knative Functions - Kubernetes Controllers Made Simple - Lance Ball, Red Hat
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe 2023 in Amsterdam, The Netherlands from April 17-21. Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Metacontroller with Knative Functions - Kubernetes Controllers Made Simple - Lance Ball, Red Hat
Kubernetes custom controllers provide a way to manage structured data through a familiar declarative API. Metacontroller is an add-on for Kubernetes that makes it easy to write and deploy custom controllers. Knative Functions are a component of Knative that make it incredibly simple to write and deploy cloud native serverless functions. Put all of these three together, and you have an amazing trifecta of power. In this talk, Lance will illustrate how API developers and devops engineers can use these combined tools to up their Kubernetes game. An brief overview of Kubernetes controllers, along with an introduction to the Metacontroller and Knative Functions projects will be followed by a look at how the combination of these two technologies allow users to quickly deploy new APIs using the Metacontroller API and the Knative Function programming and deployment models. Attendees will see a live demonstration of these capabilities in action, and will learn how Knative Functions can be extended to provide even more customization for controllers in their own organizations.
A
A
I'm
sure
you've
already
you've
heard
that
my
name
is
Lance
wall
I'm,
a
software
engineer
at
Red,
Hat
I,
am
the
co-lead
of
the
functions
working
group
for
k-native,
along
with
Mauricio
salatino,
and
today,
I
just
want
to
share
with
you
some
things
that
I
learned
about,
while
digging
into
the
metacontroller
project,
while
at
the
same
time
working
really
hard
on
k-native
functions.
The
main
thing
that
I
got
from
this
experiment
myself
was
that
these
two
things
actually
work
really
well
together.
A
So
first,
let's
talk
about
kubernetes
controllers.
I
know
this
is
probably
a
subject
that
many
of
you
are
already
familiar
with,
but
just
to
set
a
little
bit
of
a
Baseline
controllers.
Allow
you
to
manage
the
state
of
your
cluster
by
running
in
a
control
Loop,
examining
the
current
state
and
working
to
achieve
some
sort
of
desired
State.
It's
a
pretty
simple
concept
from
the
kubernetes
controller
documentation.
A
The
classic
example
is
a
thermostat
right,
a
thermostat
just
measures
the
current
temperature
and
takes
some
action
to
achieve
the
desired
state,
which
is
you
know,
some
other
temperature
turn
on
the
blower
or
the
radiator
or
whatever.
So
this
idea
is
really
simple,
but
also
quite
powerful
and
it's
kind
of
the
foundation
about
around
a
lot
of
what
kubernetes
is
built
on
and
in
fact,
even
more
importantly,
a
lot
of
it
allows
this
entire
ecosystem
to
exist
like
k-native,
the
fundamental
Architectural
Components
of
k-native
are
controllers
and
custom
resources.
A
So
together
these
two
things
bring
a
lot
of
really
nice
power,
but
the
downside
is
that
there
can
potentially
be
a
lot
of
sort
of
friction
and
mental
overhead
to
achieve
something.
That's
really
really
simple.
Potentially
right,
let's
say:
I
have
a
controller
and
I
want
to
just
spin
up
a
pod.
Every
time
a
new
resource
is
deployed.
That's
all
I
want
to
do
learning
the
kubernetes
apis
and-
and
all
of
this
just
to
do
that
very
simple
thing
is
kind
of
a
lot.
A
We
can
do
that.
We
can
do
it
with
meta
controllers
and
and
functions
so
I'm
going
to
show
you
how
to
do
that
today.
The
Meta
controller
API
is
really
nice
because
it
makes
it
easy
to
do
all
of
this
stuff
that
I
just
described
this
Json
in
and
Json
out.
It's
basically
a
web
hook
that
is
implemented
in
the
so
basically
to
write
a
meta
controller.
Api
you
create
a
web
hook
right.
It's
just
a
little
thing
that
runs
that
receives
some
Json
and
returns
some
Json
describing
the
desired
state.
A
A
Its
primary
purpose
is
to
manage
a
set
of
objects
based
on
the
desired
State
specified
in
a
parent
object.
Okay,
so
existing
controllers
that
you're,
probably
familiar
with
like
a
jobs
controller,
is
exactly
this
right
in
the
job.
You
specify
the
workload
and
the
controller
is
doing
some
action
to
spin
up
the
pods
to
make
that
make
that
job
happen.
So
let's
look
at
an
example
of
a
composite
controller
in
a
meta
controller.
A
So
here's
a
composite
controller
that
acts
kind
of
like
a
regular
kubernetes
job
controller,
but
instead
of
jobs,
it's
managing
index
jobs
and
I
have
a
thing
somewhere.
Here
we
go
so
instead
of
jobs,
it's
managing
index
jobs
and
you
can
see
the
parent
resource
that
we
care
about
here
is
index
jobs
and
it
has
these
child
resources
pods.
So
it's
just
like
a
regular
jobs
controller
except
for
the
pods
that
get
spun
up
to
do
the
work,
get
an
index
right
and
then
down
at
the
bottom
is
our
little
sink
hook.
A
A
If
some
other
controller
comes
along
and
starts
messing
around
with
the
index
jobs,
we
can
imagine
that
our
controller
probably
is
going
to
get
into
some
kind
of
bad
state.
So
what
can
we
do
if
there's
a
resource
that
already
exists,
that
we
want
to
have
some
add
some
some
functionality
to
some
Behavior
to?
Well,
that's
where
decorator
controllers
come
in,
so
a
decorator
controller
adds
new
Behavior
to
existing
resources.
Okay
native
service
is
a
good
example
of
this
right.
If
I
were
to
mess
around
with
the
k-native
service.
A
Using
that
composite
controller
I
would
imagine
that
the
probably
the
k-native
serving
controller
would
you
know
either
overwrite
my
changes
or
get
into
some
sort
of
bad
State.
Not
so,
with
decorator
controllers,
with
decorator
controllers,
you
can
Define
rules
for
which
resources
you
want
to
watch.
A
You
can
filter
those
resources
on
labels
or
annotations,
and
then
basically,
what
this
allows
you
to
do
is
add
new
Behavior
to
existing
resources
without
having
to
re-implement
the
resource
right
when
I
with
the
index
job
controller,
that
I
just
showed
you
that's
basically
a
re-implementation
of
the
job
controller.
Why
would
I?
Why
would
I
want
to
re-implement
it
if
I
don't
have
to
if
I
could
just
add
some
existing
Behavior
to
a
current
resource
right?
A
So
let's
take
a
look
at
an
example
of
that
this
example
is
like
the
first
one.
This
is
also
from
the
metacontroller
website.
This
is
an
example
of
a
decorator
controller
that
watches
for
stateful
sets.
You
can
see
here
the
resources
that
I
care
about
are
stateful
sets
and
I'm
I'm
filtering
on
these
annotation
selectors.
A
So
if
the
the
staple
set
has
a
service
per
pod
label
or
service
and
service
per
pod
ports
annotations,
then
my
my
little
web
hook
down
here,
my
sync
web
Hook
is
called
with
that
stateful
set
and
then
what
it
does.
Is
it
spins
up
a
service
for
every
stateful
set
that
for
every
pod
in
a
staple
set
that
has
those
those
annotations
right?
A
A
It
just
sort
of
makes
things
a
little
bit
easier,
reduces
the
amount
of
friction
to
get
going
with
a
controller,
so
we've
seen
some
yaml
now
that
declares
what
our
controllers
are
interested
in
and
the
resources
that
it's
going
to
be
managing.
We
have
some
kind
of
basic
understanding
of
these
Concepts,
but
we
haven't
really
seen
any
of
the
code
that
actually
does
this
management.
So
you
know
what
does
that
code?
Do?
What
do
these
sync
hooks
do
on
The
Meta
controller
website?
A
There
are
a
lot
of
different
examples
with
a
bunch
of
different
ways
to
to
deploy
a
sink
hook
for
your
meta
controller,
but,
as
I
was
working
on,
this
I
I
was
starting
to
think
that
maybe
actually
k-native
functions
would
be
a
good
way
to
implement
the
work.
Part
of
this
you
know
of
a
meta
controller,
so
I
want
to
show
you
an
example
of
that,
but
first
in
case
you're
not
familiar
with
k-native
functions.
A
Let's
take
a
quick
look
at
what
they
are
and
how
they
work.
So
k-native
functions
provide
a
really
simple
programming
model
for
dealing
with
k-native
services
and
events,
and
all
this
sort
of
k-native
abstractions
they're
small,
focused
pieces
of
code.
You
can
write
them
in:
go
Java,
JavaScript,
python,
typescript,
rust,
they're
deployed
as
k-native
services,
so
you're
just
writing
a
little
function.
A
A
A
A
A
I
have
to
I
have
to
come
down
here
and
look
at
what
I'm
doing
know
that
oh
yeah
yeah,
okay,
thank
you
yeah.
Why
don't
I
just
stand
right
here?
Thank
you.
Now
I
can
see.
Okay,
yeah
I'm,
good,
okay,
thanks
for
all
the
help,
y'all,
okay,
all
right,
Cloud
events,
hello
and
there
no
create,
let's
see,
am
I
doing
something
wrong.
Oh
right,
it's
node
see
how
easy
it
is.
A
Okay,
so
it's
created
the
project.
It's
created
the
project
in
the
hello
directory.
We
can
see
that
it
looks
a
lot
like
just
any
other
node.js
project.
If
I
look
at
the
index.js
file,
we
can
see
a
lot
of
comments
in
there
and
it's
basically
just
a
function.
A
function
in
this
case
called
handle.
It
receives
a
context,
object
which
is
basically
describing
a
little
bit.
A
A
A
I
want
my
meta
controller
to
observe
or
watch
k-native
Services,
all
right,
I,
only
care
about
services
that
are
functions
so
one
of
the
things
that
the
the
funk
CLI
does
is
it
annotates
well
adds
labels
and
annotations
to
the
services
and
we
can
identify
k-native
service.
That
is
a
function
through
this
label
function.knative.dev.
A
So
it
will
only
send
my
sinkhook
k-native
services
that
have
this
label
and
then
what
the
sync
hook
will
do
is
create
a
trigger
for
every
function
that
gets
deployed
or
updated
a
trigger
is
created
or
updated.
It's
kind
of
a
dumb
trigger
so
for
every
single
event
that
comes
in
through
the
system
through
the
default
broker,
they'll
all
get
sent
to
the
k-native
service.
So,
let's
see
if
we
can
do
that,
all
right,
so
here's
how
we
would
create
the
the
function.
A
The
Meta
controller
function,
this
one
I
don't
have
to
type
so
we
use
the
funk.
Cli
create
the
languages
node.js
the
type
or
the
template
is
meta
controller.
We're
going
to
point
it
at
the
repository.
This
is
this.
This
is
basically
just
a
tiny
URL
for
that
GitHub
URL
I
was
just
showing
you
earlier
and
then
we're
going
to
call
it
meta
controller,
and
we
actually
let
me
go
ahead
and
bring
up
vs
code
now
and
we
can
well.
Let's
do
it
like
this.
A
All
right,
so
this
is
what
the
the
Yama
looks
like
from
my
controller.
You
can
see
that
it's
a
decorator
controller,
the
resources
I'm
interested
in
are
k-native
services
and
I
want
to
match
on
the
label.
Function.Knative.Dev
is
true,
and
then
the
attachments
that
I'm
going
to
apply
to
these
services
are
triggers,
and
then
here's
my
little
web
hook
so.
A
So
you
can
see
here
it's
just
a
function
in
this
case.
It's
not
a
function,
that's
receiving
a
cloud
event.
It's
so
we're
just
getting
the
context.
The
context
contains
an
object
in
Json
or
actually
in
in
a
JavaScript
function.
It
just
gets
turned
into
a
JavaScript
object.
That
is
the
that
represents
the
service
itself
that
we're
interested
in
and
you
can
see
you
know,
I
want
to
be
kind
of
smart
about
not
attaching
a
trigger
to
The,
Meta
controller
function
itself
and
then
finally,
we
return
an
array
of
attachments.
A
A
Okay,
all
right!
So
now,
let's
deploy
it
all
right.
I've
already
created
the
The
Meta
controller
project
template
using
the
using
the
funk
CLI
I
was
worried
a
little
bit
about
networking,
stuff
and,
and
things
like
that,
I
I
didn't
really
want
to.
Let's
remove
that
old
one
or
the
first
one
I
created
so
I've
already
built
it.
When
you
like
I,
said
earlier,
when
you
create
a
a
function,
it
gets
built
as
a
container
image.
A
A
Now,
okay
get
pods
all
right,
so
I'm
going
to
deploy
this
meta
controller
function,
and
you
can
see
that
it
immediately
is
deployed
to
the
cluster
and
is
now
running
all
right.
So
the
next
thing
I
need
to
do
is
deploy
I
just
did
that
oh
I
need
to
deploy
the
the
the
yaml
itself.
So
that's
just
the
cube
cuddle
apply,
The
Decorator
controller
I
showed
you
that
earlier
okay,
so
now
we've
deployed
the
controller
and
the
the
sync
web
hook.
A
We
also
want
to
deploy
a
couple
of
other
things
in
order
to
test
this
out.
First
of
all,
we're
going
to
need
the
default
event
broker.
I
showed
you
this
in
the
in
the
diagram,
a
simple
Event,
Source
and
then
finally
deploy
a
function
to
see
if
we
get
a
trigger
attached
to
it.
So
let's
go
do
those
things.
The
first
thing
I
said
was
to
create
a
broker.
One
of
the
nice
things
about
the
the
k-native
CLI.
Is
that
there's
so
much
you
can
do
just
with
the
CLI?
A
You
don't
have
to
touch
yaml
so
to
create
a
default
broker.
Well,
I
already
did
that
earlier,
apparently
and
then
to
create
the
the
source
ping
create.
So
this
is
I'm
gonna
I'm,
creating
a
ping
source
and
ping
source
is
just
a
source
that
comes
out
of
an
event
source
that
comes
out
of
the
box
with
k-native,
and
it's
really
nice
and
useful
for
testing
and
that
sort
of
thing
like
what
we're
doing
right
now.
A
A
Now,
that's
a
feature
of
you
know:
k-native
spin
down
to
zero,
so
the
The
Meta
controller
pod
is
not
up
and
running,
but
you
will
see
in
a
moment
once
I
get
my
my
my
viewer
function,
going
we'll
see
that
spin
right
back
up
okay,
so
we
we've
created
the
Ping
Source.
We've
created
the
broker.
Now,
let's
go
up
here
and
I've
got
this
viewer
function,
it's
a
little
go
function.
So
if
I
look
at
handle.go.
A
We
can
see
it's
not
really
doing
much.
It
receives
a
cloud
event
and
prints
it
to
the
console
and
returns.
That's
it
so
I'm
going
to
Funk,
deploy
this
I've
already
built
this
one
as
well.
Now
what
should
happen?
Is
we
see
that
the
viewer
spun
up
and
we
see
that
the
meta
controller
spun
up
as
well,
because
I've
now
deployed
this
function?
The
Meta
controller
in
theory
has
created
a
new
trigger
for
me.
A
Let's
see,
KN
trigger
list
and
I
see
that
there
is
a
trigger
now
created
for
this
viewer
function
and
if
I
look
at
the
logs
for
the
viewer
function,
I
should
see,
at
least
in
a
minute
a
new
Cloud
event
come
in
theory.
If
my
ping
source
is
working
correctly,
do
a
little
tap
dance
to
take
the
minute
there
we
go
all
right.
All
I
had
to
do
is
do
a
little
tap
dance.
A
Okay,
did
I
lose
the
signal
there.
We
go.
Okay,
that's
it
I've
done
all
these
things,
oh
yeah,
okay,
so
the
other
thing
I
wanted
to
do
was
show
you
the
cleanup
right.
So,
like
I,
said
meta
controller
itself,
you
saw
the
the
sync
function.
Wasn't
doing
any
cleanup
at
all,
but
meta
controller
itself
does
a
nice
job
of
doing
that
for
me.
So
somehow
I've
got
my
Emojis
up
there.
Now,
if
I
do
a
KN
service
delete
viewer.
A
A
All
right
so
I
just
want
to
say
one
of
my
biggest
takeaways
from
all
of
this
and
sorry
for
the
fumbling
around
with
the
the
the
the
CLI
and
everything.
But
my
biggest
takeaway
from
all
of
this
is
that
these
two
things
actually
seem
to
work
really
well
together.
I
had
a
lot
of
fun
playing
with
metacontroller
and
I've
had
a
huge
amount
of
fun
working
on
k-native
functions,
so
I
just
want
to
end
it.
By
sharing
this
with
you,
I
wish
I
had
audio.