►
From YouTube: Keynote: What Next? Expanding Knative and Serverless - Evan Anderson, Senior Staff Engineer, VMware
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.
Keynote: What Next? Expanding Knative and Serverless - Evan Anderson, Senior Staff Engineer, VMware
With the addition of the "Functions" APIs to the Knative core, we've successfully added user-visible scope to the Knative project, fulfilling a 3-year journey for the project.
This also prompts the question, "what is a 'core' API, and what's next for Knative"? Evan will cover:
* The split between core, sandbox, and out-of-org
* Complementary projects for the current stack
* Broader Serverless on Kubernetes opportunities
* The outer bounds of Knative
Along the way, Evan will illustrate his points with historical examples and highlight shared opportunities between Knative and the larger CNCF ecosystem, including in security, management, and developer experience.
A
And
so
I
told
you
that
we
would
start
with
a
little
history
back
when
we
came
out
in
2018,
there
were
three
pieces
of
k-native.
There
was
serving
Eventing
and
build.
These
were
the
three
things
that
we
thought
people
struggled
with
when
they
were
trying
to
adopt
kubernetes.
How
do
I
get
myself
a
container?
How
do
I
run
it
container
easily?
How
do
I
connect
that
container
to
other
stuff?
A
What
does
that
mean?
What
what
is
a
core
k-native
project
versus
a
Sandbox
candida
project
and
the
names
are
kind
of
funny,
because
we've
had
istio
as
a
supporting
piece
of
k-native
since
day
one,
but
that
lives
in
sandbox.
So
why
does
functions
live
in
core?
Well,
the
last
time
we
tried
doing
this
before
a
global
pandemic
disrupted
our
plan
few
functions
20,
and
we
spend
a
lot
of
time
when
that
failed.
Talking
about
okay.
What
does
it
look
like?
A
Okay,
okay,
so
yeah,
it's
all
developer
facing
that's
awesome,
independent
usability!
So
when
we
started
we
said
look,
you
can
use
each
one
of
these
pieces
without
needing
other
pieces
they're
each
useful
on
their
own
question.
Mark
there.
K-Native
functions
is
mostly
intended
to
deploy
to
k-native
serving,
but
you
could.
A
Multiple
underlying
yes,
absolutely
if
you
wanted
to
build
a
Haskell
function,
build
pack,
you
absolutely
so
absolute
check,
mark
there
number
and
different
installations.
We
actually
don't
do
a
good
job
of
tracking
this
in
general,
but
both
red
hat
and
VMware
have
engaged
with
the
project
and
there's
some
early
signs
that
this
is
a
generally
useful
thing
and
the
quality
of
the
technical
implementation
we
get
a
thumbs
up.
A
The
team's
been
working
very
hard
to
make
sure
that
they
are
meeting
all
of
our
standard
k-native
quality
Gates
that
we
established
when
we
shipped
V1
so
and
they've
built
on
solid,
underlying
infrastructure
and
implementations.
So
somewhere
between
three
and
five
of
these
are
a
check
mark.
Now
we
are
headed
in
the
direction
where
this
feels
like
it
should
be
part
of
core,
and
we
wanted
to
recognize
and
signal
that.
A
A
A
bunch
of
these
are
ideas
that
we
don't
do.
There
are
ideas
for
the
next
thing
could
come
from
so
serving
is
basically
automatic.
Http
you've
got
a
web
server,
let's
just
be
able
to
grab
it
and
you've
got
as
many
web
servers
as
you
need,
and
you
don't
have
to
think
about
it.
It
does
all
the
stuff,
for
you
correctly.
A
Could
someone
integrate
K
native
to
that
pretty
easily?
It
feels
like
it
co-processors.
So
none
of
these
exist
today,
but
it
would
be
real
nice
if
you
could
just
say:
hey
Envoy
I
want
to
do
something
more
complex.
That
I
don't
really
know
how
to
put
into
the
envoy
configuration.
Let
me
just
call
out
to
k-native
and
like
maybe,
if
you're
a
customer,
who
spends
more
than
ten
thousand
dollars,
you
get
right
into
a
slightly
different
set
of
API
endpoints
or
something
like
that
be
really
cool.
A
If
you
could
do
that
with
serving-
and
you
know
just
plug
in
and
make
Envoy
better
or
similar.
Similarly,
if
you
have
a
database,
that
scales
out
like
snowflake
would
be
great.
If
you
could
Define
your
user
functions
in
any
language,
run
them
on
k-native
and
have
it
call
out
another
big
research
area,
I,
don't
quite
know
where
it
fits
in
webassembly
people
thought
hey
browsers,
do
this
great
sandboxing
and
defense
and
so
forth?
Could
we
use
this
to
render
Pros
it's
got
really
fast,
startup
times
cons.
A
The
binary
interface
is
completely
different
than
Linux
containers
that
we
have
today
another
place.
That
would
work
well
with
serving
that
we
don't
do
great
instructions
for
today
at
least
API
gateways.
I,
don't
know
if
it's
a
brand
new
thing,
I,
don't
know
if
it's
here's,
how
to
hold
the
existing
thing
better,
but
it'd
be
nice
and
a
flat
API
surface
to
customers
and
then
break
it
out
into
a
bunch
of
creative
services.
In
the
background
with
that,
we're
going
to
talk
a
little
bit
about
Eventing
and
event
driven
applications.
A
Today,
we
mostly
focus
on
routing
the
events
to
the
right
application,
but
there
are
some
of
the
patterns
out
there.
We
already
saw
stream
processing
you'll,
see
it
says,
event
stream,
Ingress
and
event
stream
egress.
Those
are
events.
What
does
it
look
like
to
hook
up
Eventing
with
stream
processing
another
place
at
the
AWS
ecosystem?
They
have
these
step
functions
particularly
little
State
machines
and
you
could
say
hey
my
order
goes
through
these
steps
and
then
you
can
have
a
hundred
thousand
little
State
machines
that
only
run
and
call
off
to
your
computation.
A
When
there's
some
work,
they
need
to
do,
and
so
it
would
be
really
cool
if
we
had
something
that
you
could
ping
that
did
these
little
State
machines,
so
k-native
serving
makes
it
easy
to
scale
Up
Your
Capacity
in
a
burst.
If
you
get
a
lot
of
work,
but
anything
good
news,
you
can
shift
things
out
over
time
or
you
can
say:
hey
I
need
to
do
this
in
the
future,
but
not
right.
Now,
oh,
a
a
nice
task.
Queue
would
be
a
great
complement
to
some
of
the
existing
mechanisms.
A
We
actually
don't
want
you
to
scale
up,
and-
and
we
want
you
to
wait
for
other
times
and
the
last
event
last
broadcast
is
different
from
all
these
others,
because
for
all
these
others,
we've
got
a
event
that
we
want
to
get
to
your
application
as
a
whole
and
any
one
piece
of
the
ad
application
can
handle
it
for
broadcast.
Every
single
piece
of
the
application
needs
to
get
that
message.
A
A
I
do
execution
model
one
common
pattern
that
you'll
see
that's
the
beginning
of
the
mapreduce
pattern,
is
go
over
a
table
and
for
each
row
in
the
table
run
something
now
you
can
build
this
two
separate
functions
today,
one
that
scans
the
table,
fires
off
a
bunch
of
events
and
a
second
one
that
consumes
each
event
and
processes
that
row,
but
a
really
really
cool.
If
you
could
actually
make
that
a
first
class
expression,
here's
my
scanner
and
then
here's
my
per
row
function
and
get
things
to
scan
out
horizontally.
A
So
durable
functions
is
another
cool
thing.
Okay
is
a
cool
thing.
That
Azure
has
that
that
lets
you
basically
build
sort
of
continuations
and
save
your
state.
So
you
run
a
little
like
bit
of
execution
and
then
you
sort
of
pause
and
you
return-
here's
my
state
and
then
you
can
pick
up
later
and
you
get
all
that
state
fed
back
into
your
application,
along
with
whatever
that
next
event
was
so
you
can
continue
great
and
then
we
talked
about
coprocessors,
so
I
think
there's
a
lot
easier.
A
A
Why
is
this
room
the
right
place
to
be
doing
it
well,
I
think,
there's
a
couple
of
advantages
that
k-native
has
we're
open
source
so,
like
everybody,
can
download
and
play
with
it.
We've
seen
a
whole
bunch
of
academic
institutions
and
so
forth.
Go
along
and
like
do
some
research
and
play
with
it
and
try
sticking
stuff
together.
We
have
an
open,
Community.
I
think
this
is
actually
the
biggest
part
we
bring
everyone
in
and
we
say
Hey
you
can.
A
And
the
last
piece
is
we
architecture
where
we
ability
as
a
goal,
so
we
want
people
to
be
able
to
run
this
run
K
native
in
production.
We
also
want
to
enable-
and
we
don't
want
to
break
the
production
people
with
the
experimenters,
but
we
want
to
enable
the
experimenters,
and
so
last
thing
before
I.
A
Go
is
to
remind
you
part
of
that
open
Community
is
that
we
get
to
choose
who's
going
to
guide
the
community,
and
that
means
that
we've
got
an
upcoming
steering
committee
election
if
you've
been
contributing
the
project
you're
probably
eligible
to
vote
check
at
the
site.
If
you've
got
it
and
if
you
know
someone
who
would
be
a
great
steering
committee
candidate
or
you
would
be
a
great
steering
committee,
commandant
sign
up
to
run,
I
forget
if
there's
two
or
three
seats
up
this
year,
but
there's
a
couple
seats
up
this
year.