►
From YouTube: Event Driven applications on Kubernetes with KEDA
Description
KEDA is an open source project and enables event-driven autoscaling for Kubernetes workloads.KEDA scalers can detect if a deployment should be activated or deactivated, and feed custom metrics for a specific event source.
In this episode, our friend Jeff Hollan joins Cecil to show us how we can use KEDA to scale out our .NET applications running on Kubernetes
[00:00] - Intro
[01:15] - What is KEDA?
[03:38] - KEDA’s relationship with Azure Functions
[05:53] - Moving KEDA to the CNCF
[08:40] - .NET Worker service demo
[12:44] - Supported Keda triggers
[14:37] - Working with ACI and Virtual Kubelets
[17:09] - Does KEDA work alongside other Kubernetes projects?
[18:45] - Getting started with KEDA
KEDA
https://keda.sh/
KEDA on GitHub
https://github.com/kedacore
Create a function on Linux using a custom container
https://docs.microsoft.com/azure/azure-functions/functions-create-function-linux-custom-image?WT.mc_id=ondotnet-c9-cephilli
.NET Sample with Service Bus
https://github.com/kedacore/sample-dotnet-worker-servicebus-queue
A
A
Hey
everyone
welcome
to
another
episode
of
the
on.net
show.
My
name
is
cecil
phillip,
and
today
today
we
have
my
friend
jeff
holland,
who,
which
actually
turns
out
when
I
was
looking
at.
The
stats
today
seems
to
be
like
our
most
repeated
guest
on
the
show
he's
back
today
and
he's
going
to
talk
to
us
about
some
really
cool
stuff
about
cada
and
kubernetes
and
and
all
types
of
great
stuff,
so
jeff,
thank
you
for
coming
on.
Man.
Have
you
been.
B
A
Sure
sure
sure
so
I've
been
you
know
I
pay
attention
to
what's
going
on
online
and
in
the
community
and
stuff
and
I've
been
seeing,
you
talk
a
lot
about
this
project
called
cada,
and
so
you
know
I've
seen
you
give
some
presentations
about
it.
I've
seen
blog
posts
about
it,
but
I
thought
I
have
to
have
you
come
in
the
show
and
let
me
know
what
exactly
is
this
thing
about?
So
could
you
give
me
a
really
quick
elevator
pitch
like
what
is
keda
and
like
what
is
it
supposed
to
do?.
B
How
do
we
make
it
so
that
if
you
want
a
function,
that's
processing
on
cue
messages
that,
if
there's
a
million
things
in
that
queue
that
we
can
really
quickly
and
process
all
those
events
and
what
we
noticed
as
a
team
is,
we
are
learning
and
working
with
users
who
wanted
to
use
specifically
functions
in
kubernetes
was
that
kubernetes
did
not
have
a
very
good
way
to
do
event
driven
scale.
Kubernetes
has
auto
scaling
there.
B
You're,
like
hey
jeff,
you're
in
charge
of
food.
One
way
that
I
could
go
about
this,
which
would
be
super
inefficient,
is,
I
could
say,
like
okay,
I'm
gonna
start
and
I'm
gonna
order.
One
pizza.
I
have
no
idea
how
many
people
are
gonna
come
to
this
party,
I'm
just
gonna
order,
one
pizza
and
I'm
gonna
watch
and
once
there's
only
like
two
slices
left,
then
I'm
gonna
call
and
ask
them
to
deliver
another
pizza.
B
It
would
work,
everyone
would
get
enough
food,
but
if
you
had
a
thousand
people
show
up
to
this
party,
it's
not
gonna,
be
most
people
are
going
to
be
really
unhappy,
are
waiting
for
a
long
time
for
their
slice.
So
the
better
way
would
be
that
I'm,
like
hey
cecil,
how
many
people
are
coming
to
your
party
and
you're
like?
B
Oh,
it's
a
thousand
I'm
gonna
order,
whatever
200
pizzas
from
the
get-go
and
have
them
all
there
ready
to
go
so
keda
does
the
exact
same
thing,
but
instead
of
pizzas,
it's
you
know
I
need
cpu.
I
need
this
code
to
run
and
kata
lets.
It
know:
hey,
there's
a
bunch
of
messages
in
this
queue,
there's
a
bunch
of
work
that
needs
to
be
done.
So
we
can
do
this
really
good
event
driven
scale
stuff.
So
it
brings
that
capability
into
a
kubernetes
and
micro
service
world.
A
So
jeff
every
time
I
heard
about
cadet,
it
was
always
tied
for
me
with
like
azure
functions
like
cada
azure
functions,
kata
azure
functions
right,
so
I
always
thought
that
cata
was
a
project
that
allowed
us
to
run
functions
on
kubernetes,
but
I
kind
of
feel
like
that's
not
the
case,
so
I'm
not
totally
sure.
So.
Could
you
debug
that
for
me
for
a
little
bit
like
what
exactly
does
kata
do
in
relation
to
azure
functions
or
are
they
like
two
completely
different
things
like
what's
their
relationship?
There
sure.
B
Yeah-
and
that
is
that's
the
primary
motivation
like
why
our
team
in
azure
functions,
started
this
project
and
continued
to
fund
and
maintain
it,
because
we
do
want
to
enable
people
to
run
azure
functions
in
a
container
inside
of
kubernetes
on
whatever
cloud
or
platform
they
want
and
have
those
functions
behave
the
same
way
do
that
cool
scale
and
scale
out
thing.
However,
when
we
designed
it,
we
really
wanted
to
build.
You
know
I
kind
of
mentioned.
B
The
problem
kubernetes
in
general
has
where
it
doesn't
do
that
event
driven
scale
thing
of
seeing
how
many
people
are
coming
to
the
party
and
so
we're
like.
Well,
let's
not
just
build
this
in
a
way
that
it
only
benefits.
Azure
functions.
Let's
make
sure
we
build
it
in
a
way
that
any
type
of
application
that
you
can
build
could
hook
into
the
same
scale
and
so
yeah.
It's
primary
use
case
for
my
team
is
hey,
take
your
functions
around
elsewhere,
but
we
have
a
bunch
of
people.
B
In
fact,
probably
more
so
now,
like
cada,
is
a
cncf
project.
It's
out
in
the
open.
We've
got
contributions
and
users
from
a
bunch
of
different
places,
so
some
people
are
using
it
with
functions,
but
a
lot
of
them
are,
you
know,
hey.
I
have
this
dotnet
worker
service,
that's
not
using
azure
functions
at
all,
but
it's
pulling
messages
from
a
queue
or
it's
pulling
messages
from
an
event
hub
or
wherever
it's
pulling
messages
from.
Can
this
service
do
a
function,
scale
thing,
and
so
we
built
it.
B
A
A
That
you
set
up
yep,
that's
it
all
right
cool.
I
know
you
also
mentioned
that
this
is
also
part
of
the
cncf
right,
which
stands
for
like
the
cloud
native
computing
foundation.
What
was
it
like
for
you
to
start
working
in
that
world?
And
you
know,
get
this
project
to
the
point
that
it
could
be.
You
know
one
of
the
hosted
projects
there.
B
Yeah,
it
was
always
a
goal
when
we
were
first
meeting
about
you
know.
How
do
we
do
this
in
kubernetes
we're
like?
Oh,
this
would
be
awesome,
nav
and
then
cncf,
because,
if
you're
unfamiliar
that's
the
foundation
that
owns
kubernetes
the
kubernetes
trademark,
all
the
kubernetes
work,
a
bunch
of
kubernetes
related
projects.
Are
there
like
helm
prometheus
if
you're
in
that
world?
It's
it's
something
you
know,
and
it
did
take
a
bit
to
get
there
like
they.
They
have
kind
of
different
levels
of
projects.
B
B
This
is
something
that's
getting
adopted
more
than
just
microsoft
like
we
need
to
make
sure
that
this
is
valid
for
not
just
a
single
vendor
in
the
bit
to
do
it
is
it's
us
saying
you
know
we,
the
azure
functions
team,
the
microsoft
team,
red
hat,
who
partnered
with
us
on
this.
We
don't
own
it
anymore.
We're
gonna
give
this
to
the
community.
We
want
the
community
to
build
it
with
us,
we're
not
in
charge
of
the
trademark.
We
can't
like
there's
a
world
that
cata
v3
or
v2.
They
make
it.
B
So
it's
incompatible
with
azure
functions.
I
don't
think
it's
gonna
happen,
but
it
could
happen
and
we're
like
look
if
that's
where
this
project's
gonna
go.
We're
gonna
give
it
to
the
community.
So
there
was
a
bit
of
work
there
to
show
that
we
were.
You
know
we
meant
what
we
said,
but
it's
now
officially
there
and
open
source
and
being
used
by
a
bunch
of
different
folks.
That's.
A
Is
that
now
it's
again
like
you
said
it's
not
just
a
microsoft
thing,
it's
an
ecosystem
thing,
so
you
know
you
get
to
partner
and
build
relationships
with
these
different
companies
and
also
see
different
scenarios
with
how
people
are
actually
using
some
of
these
projects
that
we're
building.
So
I'm
sure,
from
that
perspective,
there's
been
a
lot
of
learning
and
a
lot
of
insightful.
You
know
feedback,
that's
come
from
being
in
that
foundation.
B
Yeah
and
it's
like
every
week,
we've
got
these
weekly
stand-ups
and
you
know
there's
one
or
two
people
from
microsoft,
but
then
there's
seven
or
eight
people
from
everywhere
else
and
we're
all
meeting
together
to
understand
like
what
could
the
shoes?
How
could
it
benefit?
So
it's
been
a
really
eye-opening
project,
but
it's
a
lot
of
fun
and
I've
really
liked
that
flavor
of
let's
build
this
and
own
by
the
community
and
not
just
you,
know
hey.
B
A
B
B
Here,
that's
going
to
pull
in
messages
from
a
queue
in
this
case
it's
an
azure
service,
best
queue,
and
so
I've
written
this
up
in
my
project
here,
I've
got
a
nice
docker
file
for
it,
and
here
I've
defined
a
few
things
that
kubernetes
needs
to
actually
run
this
app,
and
so
I
have
if
you've
used
kubernetes
before
this
is
a
yaml
file
that
says
hey.
This
is
the
container
that
I
want
you
to
run.
B
This
is
the
connection
string
that
you
should
use
for
the
queue
just
stuff
to
get
that
container
up
and
running,
but
the
secret
sauce
is
this
auto
scaling
stuff?
This
is
what
keda
does
saying
hey.
This
is
a
cada
yaml
definition
and
I'm
gonna
say:
hey
that
order
processor,
dot,
net
worker
service
that
I
deployed.
I
want
you
to
scale
it
based
on
cue
messages
coming
from
azure
service
bus,
so
here
I've
told
k
to
hey
scale.
This
thing,
based
on
cue
messages
coming
from
azure
service
bus.
B
This
is
how
you
can
authenticate
with
that
service
bus,
whether
you're
using
connection
strings
or
pod
identity,
and
I
can
even
define
how
aggressive
scale
so
here
by
setting
this
number
to
five
for
q
length.
I'm
saying
every
five
messages
on
that
queue.
I
kind
of
want
one
instance
of
that
container
running.
So
if
I
drop
in
20
queue
messages,
I'm
kind
of
telling
kubernetes
four
containers
running
my.networker
is
probably
the
right
number
here
and
then
I
deploy
this
to
kubernetes
and
it
does
the
rest-
and
so
here
I
have
here
in
this
console
window.
B
My
kubernetes
cluster-
and
here
is
my
order.
Processor
container
that
I
was
just
showing
you
and
what's
cool
here
is
this
is
something
kubernetes
can't
do
by
default,
but
you'll
actually
see
right
now
it's
running
at
zero.
It
has
no
containers
running,
it's
all
the
way
down
to
zero,
it's
not
taking
any
compute
and
the
reason
it
can
do.
That
is
because
cada
is
looking
at
that
service
bus
queue
and
it
said:
hey,
there's
no
work
here.
B
There's
no
queue
messages,
so
why
should
we
spin
up
this.net
worker
so
it
scaled
it
all
the
way
down
to
zero.
So
I'm
saving
my
compute
processing
for
other
workloads
like
this
website
that
I
have
running
that
actually
is
running
and
so
kind
of
the
magic
happens
here.
Let's
go
ahead
and
watch
the
containers
that
are
running
in
my
cluster.
Here's
a
website
that
I
have
that
just
visualizes
the
queue
length
I'll
show
you
that
in
a
second
actually
I'll
show
you
that
right
now,
so
I
have
this
website
that
shows
us
the
queue
length.
B
B
Yeah,
a
lot
of
pizzas
we're
gonna
drop.
I
even
see
pizza
show
up
here
on
the
left,
so
I'm
dropping
a
thousand
messages
here
in
this
queue
you
can
see
here
in
this
visualizer.
This
cue
is
getting
filled
up
with
a
bunch
of
stuff
and
if
we
switch
over
here
to
this
window,
you
can
see
really
before.
I
even
finish
that
first
sentence,
kate
has
been
like
hey
kubernetes.
B
You
know
this
order.
Processor
continue.
You
gave
me,
I
can
see,
there's
a
bunch
of
work
piling
up
for
it
and
so
very
quickly.
It
shot
up
to
four.
Now
it's
scaling
out
more
to
eight
and
keita's
driving.
This
thing
out.
It's
scaling
out
really
really
quickly
much
faster
than
kubernetes
by
default
would
do,
and
that's
because
kate
is
looking
at
this
bar
chart.
That's
literally
got
off
the
screen.
I
didn't
realize
this
page
only
goes
to
500.
B
I've
blown
off
my
own
chart,
but
that's
okay,
because
kate
is
making
sure
that
my
container
is
consuming
that
and
draining
that,
and
if
we
stuck
around
here
for
a
few
more
seconds,
you'd
see
this
bar
chart
go
all
the
way
down
to
zero
I'd,
probably
even
scale
out
a
few
more
times.
So
that's
kind
of
what
kate
is
doing
for
me.
I
I
had
my
simple
service
bus
process
could
have
been
a
service
bus
azure
function.
In
my
case
it
was
just
this
worker
project.
B
A
B
Yeah
and
there's
a
ton
I'm
going
to
switch
over
here
to
the
cada
landing
page
cata.sh,
which
is
a
great
place
to
get
started,
and
if
I
just
hover
over
here,
I
know
it's
a
little
bit
small.
I
think
I
have
a
grid
view
lower
I'll
zoom
in
here,
but
you
can
just
see
there's
a
bunch
of
different
event,
sources
that
cada
knows
how
to
talk
to
and
scale
your
workloads
on.
So
again,
this
is
a
cncf
project.
It's
not
just
microsoft!
B
So
you'll
see
here,
you
know
there
might
be
aws
cloudwatch
events
or
azure
event,
hub
events
or
my
sequel
events
or
rabbitmq
events.
So
there's
about
20
right
now.
These
are
constantly
being
contributed
and
added,
but
these
are
just
an
example
of
some
of
those
event
sources
that
if
you
have
work
or
data,
that's
happening
in
one
of
these
spots,
cada
can
now
scale
your
container.
Based
on
these
events,.
B
Exactly
that
and
one
of
the
other
kind
of
founding
principles
we
had
when
building
cata
was
we
didn't
want
to
replace
the
kubernetes
ecosystem.
We
just
wanted
to
extend
it
and
enhance
it.
So
all
of
your
regular
ci
cd
process
tools,
whether
it's
helm
or
you're,
using
the
auto
scaler
policies
as
it
is
we
just
attach
alongside
it,
so
we're
not
replacing
anything.
Kubernetes
provides
tools
or
otherwise
we
just
kind
of
amp
it
up
with
this
piece
of
functionality.
A
B
It
does
that
that
actually
gets
pretty
exciting,
in
fact,
I'll
I'll
go
ahead
and
just
stop
sharing
my
screen
here
for
a
second.
So
this
is
one
of
the
fun
parts
about
that.
Serverless
promise
is
that
in
azure
we
have
this
feature
called
virtual
nodes.
Where
imagine
that
I
did
that
q
demo,
I
just
ran,
but
I
need
to
go
really
really
far
really
really
fast.
B
If
I
run
out
of
actual
compute
like
what,
if
I
only
have
10
servers
in
my
cluster,
what
if
I
need
20
to
handle
the
amount
of
pizzas
that
people
are
ordering,
you
can
actually
scale
out
to
these
serverless
containers,
these
virtual
nodes,
cada
parties
in
that
world,
as
well
so
cada
can
tell
kubernetes,
which
can
tell
azure
jeff
saying
he
needs
some
more
containers
here,
running
this.net
worker.
I
don't
have
enough
resources
here
on
my
vms.
B
Go
ahead
and
spin
up
azure
container
instances
go
ahead
and
spin
up
these
virtual
nodes
to
scale
out
indefinitely
indefinitely
into
these
serverless
containers
so
that
that
works
great
too.
You
just
have
to
modify
your
yaml
with
the
little
annotations
for
virtual
nodes
and
say,
like
a
run
exclusively
on
these
serverless
containers
or
burst
out
to
these
containers,
but
it
all
works
well
together.
A
And
also
from
an
application
perspective,
there's
there
shouldn't
be
any
changes
to
the
way
that
my
code
runs:
there's
no
sdks
or
packages
for
me
to
install.
You
know
obviously
like
we're
not
trying
not
to
write
to
the
file
system
or
anything
like
that,
because
you
know
these
things
spin
up
and
down,
but
other
than
that,
like
my
code,
is
essentially
the
same
right.
B
A
Yeah,
listen
to
cues,
I
get
messages
I
make
http
requests.
I
do
database
things
and
you
know
my
my
app
doesn't
need
to
know
about
cada.
It
doesn't
even
need
to
know
that
I'm
running
in
you
know
running
in
that
world
at
all,
like
I
could
just
write
my
app
and
then
now
from
an
infrastructure
perspective.
B
Exactly
right-
and
you
can
even
have
you
know-
maybe
three
apps-
that
don't
use
cada
and
one
app
that
does
all
running
in
the
same
cluster.
It's
just
up
to
you
in
the
app
thing
about
cada
they're,
just
running
along
and
then
one
day,
you're
like
hey
kata,
keep
an
eye
on
this
queue
and
scale
this
thing,
and
it
will
do
it.
But
you
don't
have
to
change
any
code.
You
could
bring
existing
apps
popping
kata
pop
off
kada.
Everything
works.
Fine
you're,
just
kind
of
messing
with
these
yaml
files.
A
B
Sure
yeah
they
can
work
side
by
side.
In
fact,
the
k
native
project
has
a
sample
in
their
repo,
which
is
you
know,
hey
what,
if
I
have
things,
I'm
publishing
decay
native
that
are
more
q,
triggered
or
cubase
scaling.
I
would
say
one
big
distinction:
if
you're
learning
about
this
kubernetes
ecosystem,
maybe
you've
heard
words
like
k-native
yeah,
k-native's
approach
is
it's
trying
to
be
an
entire
platform?
It's
like
50
features
that
does
everything
from
istio-like
things
to
scaling
things
to
deploying
things.
B
B
However,
the
approach
is
a
little
bit
different
in
that
when
you
use
cada,
it's
just
a
single
feature,
we're
just
like
hey.
This
is
just
the
scale
piece
and
yeah.
K-Native
does
scaling
things
too,
but
you
can
kind
of
have
the
kata
thing
run
alongside
it
as
well,
but
it's
very
low
opinionated
non-intrusive
approach,
so
they
work
well
with
each
other.
It's
just
worth
noting.
A
Got
it
got
it
so
so
jeff?
If
I
was
supposed
to
like
like
say
I
want
to,
I
want
to
try.
Okay,
I
want
to
try
it
out
in
my
own
clusters
and
things
of
that
nature.
Where
would
I
go
exactly
to
get
like
the
getting
started
information?
Maybe
there's
some
sample
apps
or
some
demos
that
I
could
take
a
look
at
to
see.
You
know
what
what
the
getting
started
experience
is
going
to
look
like.
B
Yeah
the
site-
I
showed
you
a
minute
ago,
like
sh,
so
k-e-d-a
dot,
s-h,
that's
the
main
landing
page
it'll.
Take
you
off
to
a
video
where
I've
got
like
a
whole
45-minute
presentation
around
this
thing
from
kubecon
and
then
there's
a
bunch
of
samples
we've
got
samples
of
using
it
with
functions
the
sample.
B
I
showed
you
of
a
q
trigger.net
worker,
that's
one
of
the
open
source
samples
that
we'll
link
to
from
that
page,
there's
a
whole
there's
like
50
different
samples
at
this
point
that
you
could
go
play
around
with
so
definitely
worth
going
and
poking
around
it's
one
of
those
things
that
you
follow.
One
of
those
quick
starts.
It
takes
about
30
minutes.
Maybe
it's
the
first
thing:
you've
really
done
with
kubernetes
it'll
kind
of
walk
you
through
a
lot
of
it
step
by
step,
so
definitely
encourage
you
to
check
it
out.
B
A
And
so
what
we'll
do
is
we'll
make
sure
that
all
that
information
we'll
put
in
the
show
notes
so
if
anyone's
watching,
hopefully
you're
watching
if
folks
are
still
watching,
you
can
go
down
and
you
know
check
out
the
links
and
the
samples
and
all
those
types
of
things
and
then,
while
you're
there
too
we'll
make
sure
to
put
in
some
of
just
older
episodes.
So
we
make
sure
that
we
keep
getting
hits
on
those
so
that
you
know
we'll
encourage
them
to
come
back
on
another
time.