►
From YouTube: Knative Functions: An Introduction, Demonstration and Roadmap - Lance Ball & Mauricio Salatino
Description
Knative Functions: An Introduction, Demonstration and Roadmap - Lance Ball, Red Hat (WG lead) & Mauricio Salatino, VMware
Knative Functions fall somewhere between a CaaS (Containers-as-a-Service) and a FaaS (Function-as-a-Service) and provide an experience similar to Google Functions or Azure Container Apps. Those platforms allow you to run your applications without the need to know about containers or Kubernetes. They take source code, often just a function, and convert it into a runnable artifact, deployed on a cluster, while hiding from you all of the Kubernetes and container details. In this talk, you will learn about Knative Functions: what they are; how the project was created and evolved; and most importantly how you can use them to quickly and easily deploy event-driven, Knative Serverless applications. Lance and Mauricio will be live coding to create, build and deploy functions that consume and produce CloudEvents in multiple programming languages, illustrating the polyglot nature of Kubernetes and the Serverless capabilities of Knative.
A
B
So
my
name
is
maurice
latino.
I
do
work
for
vmware,
I'm
24
7
there
on
gay
native
and
I'm
super
excited
to
be
working
on
the
functions
project
we
launched.
This
is
exciting
stuff.
So
I
think
that
we
can
just
crack
on
right,
yeah
and
before
we
start,
we
built
the
game
using
functions
and
and
that's
kind
of
like
what
we
want
to
show
today.
So
I
will
quickly
show
you
how
the
game
works,
because
we
will
be
playing
together
at
the
end
of
the
session.
So
we
want
we.
B
I
wanted
just
to
show
you
how
kind
of
the
interaction
goes,
because
it's
going
to
go
fast
and
if
you
want
to
play
and
get
some
points,
and
you
know
get
some
swag,
you
will
need
to
understand
how
it
works
first.
So
the
first
thing
that
we
do
is
we
just
create
a
player
name
and
then
we
play
and
as
you
can
guess,
we
are
going
to
be
playing
through
a
set
of
questions
and
each
question
is
going
to
be
basically
triggering
a
new
function,
as
you
might
guess,
because
we
are
talking
about
functions.
B
B
Then
you
just
get
the
answer
from
the
next
level
and
there
might
be
questions
that
ask
you
to
do
different
things,
but
the
important
thing
of
the
game,
something
that
will
happen
at
the
end
of
the
timer
there
is
that
you
will
be
able
to
tweet
this
course
and
also
we
will
be
kind
of
using
a
hashtag
in
twitter.
Just
to
you
know,
score
different
participants
and
you
know
and
just
track
who
is
playing,
and
I
will
be
using
this
through
kubecon.
B
So
you
know
at
the
end
we
will
be
doing
some
raffle
and
just
getting
some
swag
when
things
work
and
the
internet
works,
there
will
be
a
twitter
button
there.
That's
where
you
can
tweet,
so
we
will
be
playing
together
at
the
end
of
the
presentation,
and
I
will
be
also
talking
about.
How
did
we
build
this
game
and
how
this
game
is
kinda
like
evolving
lance?
Okay,
you
go
next,
go.
A
A
So
why
do
we
talk
about
functions?
Well,
functions
are
really
the
single
responsibility
principle
on
steroids
when
you
think
about
single
responsibility
principle,
usually
you
think
about
microservices,
where
you
have
some
sort
of
object
like
an
order
and
then
you've
got
a
set
of
services
that
can
create,
update,
delete
this
order
thing
and
that's
a
single
responsibility.
A
But
the
truth
is:
that's.
There's
a
lot
more
going
on
there
right
as
an
application
developer.
You
have
to
open
up
your
network
connections,
you
have
to
be
listening
for
operating
system
signals
and
that
sort
of
thing
functions,
sort
of
narrow
all
of
this
down
to
actually
just
a
single
responsibility,
and
that
is
your
business
logic
right.
A
Your
function
receives
some
input.
Has
some
output?
That's
it
and
that's
all
you
have
to
think
about
as
a
function
developer
so
much
so
that
these
functions
are
meant
to
be
very
portable,
there's
no
dependency
in
the
code
on
k-native
itself.
So
if
you
write
a
function
in,
let's
say
node.js
and
you
package
that
up
as
a
module,
you
can
deploy
it
as
a
function
on
k-native,
but
you
could
also
use
it
just
as
a
module
in
some
other
application
somewhere
else,
they're
very
independent
and
portable.
A
We
provide
some
pretty
powerful,
tooling
k
functions
cli,
as
well
as
the
ability
to
extend
that
cli
with
what
we
were,
calling
language
packs
and
there's
a
contract
to
extend
the
sort
of
capabilities
of
the
funk
cli
that
way
through
language
packs.
The
main
thing
for
us
is
developer
happiness
right.
Making
it
very
easy,
knativ
already
makes
it
really
easy
for
developers
to
get
started
on
kubernetes.
This
just
takes
that
one
step
further,
so
why
do
we
do
it
in
k
native
well?
A
First
of
all,
it
already
makes
things
easy
for
developers
and
I
like
to
think
of
functions
as
sort
of
the
the
programming
model
and
k
native
as
the
deployment
model
right.
So
these
functions
in
theory
could
be
deployed.
Any
number
of
places
right
now
k
native,
makes
the
most
sense
because
it's
kubernetes
kubernetes-based,
it's
containerized
deployment
and
k-native
k-native,
serving
provides
all
the
things
that
you
need.
A
In
order
for
you
to
receive
like
http,
ingress
right,
incoming
http
connect
connections
are
handled
by
k-native
serving
you
don't
have
to
think
about
it
as
a
function
developer
and
then
in
more
advanced
cases.
When
we're
talking
about
reactive
type
of
functions,
we
get
k-native
eventing
involved
where
you
can
get
events
coming
in
through
kafka
or
rabbit
mq
and
those
flow
through
the
k-native
eventing
system
through
channels
and
triggers
and
brokers,
and
that
sort
of
thing
all
in
the
form
of
cloud
events
and
the
functions
that
we
we
support
are
can
be
invoked.
A
The
characteristics
of
k-native
functions
are:
are
this:
we've
got
a
handful
of
languages
that
we
support
just
out
of
the
box,
so
to
get
started,
you
can
write
your
functions
in
node.js,
go
python
spring
boot,
typescript,
rust,
carcass
and,
like
I
said
you
can
extend
that.
So
if
you're
a
vendor
or
a
you
know
like
a
large
organization,
a
large
company
like
say,
american
express
and
you've
got
a
bunch
of
dependencies
that
all
of
your
developers
use
in
all
of
their
projects.
You
can
use
a
language
pack
to
sort
of
customize
the
developer
experience.
A
We
support
a
couple
of
different
build
strategies,
s2i
and
build
packs
for
the
local
experience
for
the
developer
on
their
laptop
or
pushing
to
like
a
development
cluster
or
a
staging
cluster.
And
then,
of
course,
you
don't
want
developers
pushing
code
directly
to
a
production
system.
You
want
to
have
that
part
of
a
ci
cd
pipeline.
A
A
Make
this
big
screen,
maybe
make
it
a
little
bit
bigger
okay,
so
we
have
in
addition
to
everything
I've
mentioned.
We
also
have
a
plug-in
for
vs
code
and
intellij
and
it's
a
little
rough
around
the
edges.
This
is
all
pretty
new
stuff,
but
I
was
really
excited
to
show
it
off
to
you.
So
I'm
going
to
try
and
use
it
today.
Hopefully
everything
will
go
okay,
so
the
first
thing
I
want
to
do
is
create
a
function.
I
can
do
that
through
the
plugin.
A
It
prompts
me
for
the
name
of
a
function
I'm
going
to
call
this
viewer
because
basically,
every
function
out
of
the
box
is
just
an
echo
function,
so
we're
going
to
view
some
cloud
events
as
you
can
see,
we
support
all
these
different
runtimes
node
is
going
to
be
easy
to
demonstrate.
So
we'll
do
that
and
let's
look
at
cloud
events
since
this
is
a
cncf
event
and
I'm
going
to
create
this
in
my
little
demo
folder
here.
A
So
I
create
a
function
and
it
asks
me
if
I
want
to
add
to
the
workspace.
I
will
do
so
and
now
you
can
see
over
here
on
the
left.
I've
got
a
project
that
looks
pretty
much
like
any
other
node.js
project.
I've
got
an
index.js.
This
is
where
my
function
lives
and,
as
you
can
see,
this
function
is
what
like
less
than
40
lines
of
code.
A
Half
of
it
is
comments,
imports
and
then
we've
got
this
dependency
here
on
cloud
events.
I
mentioned
that
because
I
want
to
point
out
that
this
is
very
much
like
any
other
node
project
so,
like
I
can
update
change
dependencies.
I
happen
to
know
that
the
invocation
framework
here
fast
js
runtime,
has
has
been
bumped
to
0.90,
so
I
can
do
an
npm
install
and
it'll
easily
just
bump
up
my
you
know
my
dependencies
there's
nothing
sort
of
unusual
about
this
project
in
any
way.
A
B
A
A
A
Yeah,
so
we
we're
using
build
packs
to
build
the
function,
and
now
it's
pushing
my
it's
already
created
an
oci
container
image.
It
takes
that
container
image
puts
pushes
it
up
to
a
registry,
in
this
case
it's
pushing
to
quay.io
and
yeah.
It
should
already
be.
I
hope
I
didn't
control
c
that
and
now
I
can
run
funk
invoke.
A
A
And
then
funk
invoke
send
a
cloud
event
to
my
function:
it'll
it
might.
The
funk
invoke
knows
if
my
function
is
running
locally
or
if
it's
running
in
the
cluster,
if
it's
running
locally
it'll
prefer
that,
because
that
is
the
sort
of
developer
inner
loop
right,
the
developer
inner
loop
is
I'm
going
to
make
some
changes
to
my
code.
I
want
to
build
it.
I
want
to
test
it.
I
want
to
build
it.
I
want
to
test
it
speaking
of
testing.
A
A
So
as
a
developer
and
I'm
showing
you
node.js,
but
obviously
we
have
all
these
different
runtimes
as
a
developer.
Your
developer
experience
is
going
to
kind
of
just
be
like
any
other
developer.
Any
other
experience
that
you
have
for
that.
Given
runtime,
you
don't
have
to
think
about
yaml.
You
don't
have
to
think
about
containers.
A
B
Let's
do
that
so
yeah
and
I
guess
that
part
of
the
the
presentation
here
is
to
show
what
the
project
can
do
and
you
know
like
building
functions,
it's
a
different
programming
model
and
that's
why
I
wanted
to
quickly
go
over
like
the
interaction
patterns.
Here.
I
don't
know
if
you
can
see
my
screen
now.
B
Nope.
Yes,
loading
loading
all
right,
but
I
have
like
again
the
same
thing:
yeah
there
you
go
so
basically
aslan
mentioned
at
the
beginning.
We
have
like
different
interactions,
so
we
can
just
do
like
synchronous
interactions
using
http
and
there
are
like
different
patterns
and
I'm
pretty
interested
in
this,
because
the
more
advanced
functions
that
we
build,
the
more
patterns
that
we
will
discover
and
that's
why
that
was
the
main
reason
to
build
like
a
more
like
large
application
to
start
showing
this
in
action.
B
So,
as
you
can
imagine,
you
can
like
do
an
http
request
and
then
just
execute
the
function
and
forget
about
it
like
function
will
do
something
probably
store
data
somewhere
and
then
you
can
move
forward
or
you
can
just
be
waiting
for
some
results
from
the
function
and
most
commonly
because
the
functions
are
stateless.
You
will
be
needed.
B
Kinda
like
to
connect
to
an
external
state,
to
read
or
or
write,
data
right,
k
native
is
taking
care
of
the
auto
scaling
like
scaling
up
or
based
on
demand
and
based
on
requests
and
also
scaling
down,
and
also
buffering
the
request
when
there
is
no
instance
of
a
function
that
that's
pretty
nice
for
developers
you.
But
you
need
to
be
aware
that
that's
kind
of
like
the
behavior
when
you're
building
functions,
so
whatever
you
are
doing
inside
a
function
you
need
to
be.
B
You
need
to
know
that
the
platform
will
automatically
scale
it
up
and
at
some
point
your
function
might
be
completely
downscaled
to
zero
things
that
you
need
to
have
in
mind
to
when
you
build
functions.
There
are
some
other
interaction
patterns
that
goes
more
into
the
async
space.
Like
asynchronous
interactions,
where
you
might
contact
like
you,
know
a
function
and
the
function
will
need
to
do
a
like
a
long
batch
process
and
this
kind
of
like
mechanisms
where
you
know
they
are
going
to
post
the
results
somewhere
else.
B
So
you
need
to
kind
of
like
understand
how
to
go
and
fetch
those
results
or
have
like
a
channel
to
be
able
to
get
those
results
back
to
the
application.
And
then
we
move
to
the
cloud
domains.
Event
based
space,
where
you
can
have
functions
that
are
going
to
react
based
on
events,
so
basically
consuming
an
event
like
reacting
when
an
event
happens
and
then
emitting
an
event
as
a
result
which
allows
you
to
go
and
change
functions
together.
B
Right,
like
one
function
can
consume
the
events
that
other
functions
are
producing
and
then
you
start
building
this
more
like
evidence-driven
applications
or
you
can
mix
and
match
all
the
things
that
I
mentioned
before.
You
can
have
like
http
based
functions,
emitting
events
and
then
notifying
other
functions
to
do
some
other
stuff,
and
this
is
actually
how
we
build
the
quiz
game
that
I
showed
you
at
the
beginning.
B
The
application
that
we
built-
it's
pretty
simple
but,
as
you
might
know
like
as
soon
as
you
start
going
building
something
that
needs
to
work
and
that
we
are
all
going
to
be
playing
together,
things
get
complex
and
for
this
application
we
try
to
keep
it
as
simple
as
possible,
like
the
application
is
built
like
with
that
idea
of
each
question
in
the
quiz
game.
It's
a
different
function.
B
We
have
created
a
different
function
to
deal
with
every
every
request
and
we
are
storing
a
state
in
radius
right
and,
as
you
might
think,
this
in
this
case,
because
we
are
doing
all
synchronous
requests,
we
will
need
to
take
kind
of
like
the
latency.
You
know
into
account
to
make
sure
that
you
know
our
application
can
react
and
can
work
correctly
for
for
all
the
users
right
like
if
we
have
all
this
room
playing.
B
At
the
same
time,
we
will
need
to
bootstrap
this
and
scale
up
these
functions
for
that
to
work.
There
are
different
ways
of
doing
this.
We've
done
it
in
this
way.
Just
to
test
this.
This
approach
the
synchronous
approach
and
then
we
extended
it
with
events,
and
we
will
be
seeing
that
in
action,
but
what
this
makes
like
what
this
diagram
is
showing
is
that
we
also
have
like
an
orchestrator
in
this
case.
B
So
if
you
have
synchronous
interactions,
you
will
need
to
have
some
component
that
has
the
logic
on
which
function
to
call
next,
and
in
this
case
that's
kind
of
like
the
game
front,
end
that
we
have
in
there
and
then
we
have
a
react
application.
On
the
other
side,
there
are
some
challenges
and
some
good
stuff
about
this.
B
That's
these
building
applications
in
this
way
right
when
I
do
not,
I
haven't
been
using
functions
for
for
a
long
time,
and
now,
when
I
switch
to
build
this
application,
it's
pretty
interesting
how
you
need
to
change.
You
know,
like
the
the
mindset
on
on
the
things
that
you
are
going
to
put
there
in
the
function,
so
the
platform
can
take
care
of
all
these
like
upscaling
and
downscaling.
B
So
definitely
you
need
a
game
like
an
orchestrator
in
this
case
that
I
mentioned
before,
and
that's
the
only
reason
because
you
need
the
only
reason
why
you
need.
That
is
because
you
need
to
coordinate
which
functions
are
going
to
be
called
and
in
which
order.
We
need
to
take
into
account
the
latency,
and
you
will
see
that
the
first
person
playing
this
game
will
need
to
wait
for
the
function
to
get
started.
B
But
all
of
you
will
need
to
wait
for
redis
to
write
stuff
into
into
the
database
and
to
read
data
from
it
and
yeah
and
another
thing
to
take
into
account
when
you're
building.
This
kind
of
applications
is
that
if
you
are
connecting
to
a
database
and
your
functions
are
going
to
be
scaled
up,
you
might
start
hitting
unlike
bottlenecks
on
the
database.
If
you
know,
if
you
run
out
of
connections,
because
you
will
have
lots
of
replicas
just
trying
to
connect
to
the
database.
B
For
that
reason,
we
decided
to
also
add
some
like
reactive
stuff,
on
top
of
this
application
and
in
this
case,
we're
using
k
native
eventing
to
deal
with
cloud
events
and
route
cloud
events
across
different
components
in
the
application.
So
each
level
here,
like
every
time
that
you
are
working
like
answering
a
question.
B
It's
going
to
a
media
cloud
event
to
a
native
broker
that
this,
this
kind
of
cloud
events
router
that
is
going
to
send
you
know
the
events
to
the
front
end
and
we
are
going
to
use
our
socket
to
send
the
events
back
to
the
client
side,
which
is
pretty
nice.
Everything
is
cloud
event
based,
so
we
are
routing
events
even
to
the
front
end
like
even
to
the
client
side
code
that
it's
running
into
your
laptops
and
that's
pretty
cool.
B
I
think
like
because
the
programming
model
again,
it's
all
the
same
and
it
works
like
kind
of
nice
and
going
down
doubling
down
on
what
lance
mentioned
before.
I
really
love
the
idea
of
of
having
kind
of
like
functions
written
in
different
languages.
Oh
sorry
about
that,
I
just
want
to
mirror
my
screen
and
I
cannot
do
it
from
here
right
there
you
go.
B
I
don't
know
why,
for
some
reason
like
it
was
mirroring
before
now
it
is
not
mirroring
again.
Now
it's
mirroring.
I
guess
there
you
go.
So
what
I
wanted
to
show
is
like
quickly
two
functions
that
we
have
here
like
one
in
go
again,
the
same
thing
that
lance
built,
but
now
using
radius
and
connecting
to
a
database,
and
what
you
can
see
is
that
we
have
just
a
single.
You
know,
entry
point
for
the
function.
B
This
is
kind
of
like
how
are
we
going
to
invoke
the
function
once
it's
deployed,
and
then
you
know
again
like
simple
like
like
typical
developer
stuff
and
go,
we
are
connecting
to
reddis.
We
are
storing
some
data
in
there.
We
are
emitting
some
cloud
events
from
here
and
the
same
thing
just
to
prove
the
point.
We
have
built
different
levels
using
different
languages.
We
have
another
function,
written
in,
go
sorry
in
springboot
in
this
case,
which
is
pretty
simple.
B
It's
following
like
java
conventions
and
java
function,
interfaces
which
is
pretty
nice
because,
again,
if
you're
building
functions
in
java,
that's
pretty
much
what
you
want
to
use
you
can
you
can
like
import?
Any
other
java
function
and
just
expose
it
as
a
knit
function,
pretty
easily
again
same
thing.
We
are
connecting
to
radius.
We
are
connecting
emitting
cloud
events
all
using
kind
of
like
the
libraries
that
the
language
provides.
B
Because
again,
there
is
no
technology
stack
kind
of
like
locking
you
can
choose
whatever
you
want
and
then
produce
and
consume
cloud
events
or
create
http.
You
know
request
in
any
language
and
and
yeah,
and
that's
kind
of
like
very
interesting,
because
you
can
start
extending
your
like
synchronous,
applications
with
reactive
stuff
and
start
like
adding
on
top
of
the
things
that
you
already
have
like
those,
these
more
event-driven
features
that
I
will
be
showing
in
the
game
before
we
go
and
play
together.
Let's
talk
a
little
bit
about
the
role
map
right,
oh
yeah,.
A
C
A
A
A
We
don't
need
to
get
into
that
right
now
and
we're
going
to
continue
to
build
out
the
plugins
for
vs
code
and
intellij,
and
then
these
external
template
repositories
are
basically
examples
of
the
language
packs
and
we're
going
to
continue
to
build
that
stuff
out
as
well,
very
excited
about.
What's
going
on
here,
yeah.
B
Definitely
around
like
those
templates,
as
you
can
see
like,
if
I'm
building
a
lot
of
levels
for
the
application
they
are
all
built
in,
go
or
in
a
spring
boot.
It
makes
a
lot
of
sense
to
have
this
external
repository,
where
you
can
put
templates
that
will
make
your
life
easier
as
a
developer
and
funk
allows
you
just
to
point
to
his
repositories
and
get
started
with
something
that
it's
not
like
a
very
like
a
very
empty.
B
You
know,
shell
for
a
function,
so
I
think
that
it's
time
to
play,
if
you
open
your
phone,
you
can
go
there.
I
think
that
there
is
something
missing
in
the
application
that
it's
reporting
issues,
but
we
will
probably
be
adding
that
if
the
application
fails,
you
know
this
is
you
can
get
it
there?
There
you
go.
So
if
you
open
the
application,
you
will
be
able
to
start
playing
there
and
you
can.
You
will
go
through
five
questions.
What
I
want
to
do,
while
you
are
open
the
application.
B
B
B
You
can
see,
but
at
least
people
is
playing
right,
like
some
people
manage
to
get
into
the
application
and
they
are
playing
look
at
that.
We
have
like
24
people
playing
25.
Now
26.,
that's
pretty
cool
there
you
go
so
we
will
be
looking
at
the
you
know,
the
at
the
scores
and
and
then
sharing
some
some
prices
with
you
folks,
but
that's
pretty
much
it.
One
of
the
things
that
we
want
to
do
with
the
demo
is
just
to
share
to
share
it,
so
you
can
run
it
on
your
own
environments.
B
C
Hi
thanks
thanks
for
the
talk.
This
is
your
scrambling
of
arctic
finds
cold
starts,
are
actually
a
big
thing
with
this,
can
you
elaborate
a
bit
with
the
different
language
packages
are
like,
I
know,
quarkx
can
compile
natively,
which
prevents
a
cold
start
due
to
like
sub
milliseconds.
But
can
you
elaborate
a
bit
on
the
other
languages
supported?
B
Yeah,
so
it
really
depends
on
the
technology
stack
right.
So
if
you're
using
quercus,
as
you
said
like,
if
you
use
ralph
vm
like
the
native
compilation,
you
will
have
a
fast.
You
know
gold
style
because
that's
kind
of
like
what
you're
doing
you're
compiling
natively,
so
that
will
start
fast
in
spring.
We
have
a
spring
native.
It
does
the
same
thing.
You
can
just
do
the
same
thing
in
go.
It's
pretty
fast,
all
the
time,
because
again
it's
just
compiled,
so
it
really
depends
on
like
the
language
that
you're
using
and
the
technology
stack.
B
B
A
36,
the
funk
binary,
runs
on
arm
amd,
x86
64..
I'm
trying
to
think
what
else
I
think.
That's
it
that's
idea,
yeah
and,
and
then
the
the
the
builder
images
the
build
pack
builder
images.
I
think
right
now
there
is
not
an
arm
64
builder
image,
but
hopefully
that's
coming
soon.
That's
we
don't
produce
those
we're
using
pocato
builder
images,
although
it
is
pluggable,
you
could
use
your
own
if
you,
if
you've
got
an
arm,
64
builder
image
that
that
you
like
it's
pluggable,.
D
F
D
A
So
we
have
a
funk,
config
command
that
you
can
use
to
do
things
like
set
environment
variables
on
your
function
and
those
environment
variables
may
be
pulled
from
a
persistent
volume
or
secrets
or
from
something
in
your
environment.
You
know
itself
or
a
hard
coded
value
and
that
kind
of
stuff
is
hidden.
The
the
yaml
is
hidden
from
the
user
through
the
the
things
like
funk,
config.