►
From YouTube: FaaS Meets Node.js Frameworks: Developing Cloud Native Node.js Applications at Speed - Chris Bailey
Description
Speakers: Chris Bailey
Function-as-a-Service (FaaS) and serverless platforms increase productivity by enabling you to focus on application code, with the platform taking care of how to deploy, configure, run and scale the code. They do however require you to adopt a new programming model, writing simple JavaScript functions or actions instead of using the expressive APIs that are available from Express.js, Hapi.js, Fastify, and other frameworks.
In this session, you’ll learn how it's now possible to create FaaS and serverless based applications using the same framework APIs that you use today, and see a live demo of an application being built and deployed as a serverless cloud native application on Kubernetes.
A
A
So
has
anybody
seen
this
kind
of
diagram
before
that
the
horizontal
axis
is
kind
of
like
ease
of
infrastructure
and
scaling?
The
vertical
axis
is
ease
of
development
and
kind
of
delegating
logic
and
implementation
to
to
runtimes
and
making
it
simpler
to
develop.
You
get
this
kind
of
arrow
on
it
and
it
has
infrastructure-as-a-service
container
as
a
service
platform
as
a
service
and
then
function
as
a
service.
A
Has
anybody
seen
this
before
okay,
so
the
the
kind
of
scope
here
is,
if
you're
doing
virtual
machines
with
something
like
OpenStack,
you
have
to
bring
the
entire
stack
of
software,
so
you're,
creating
a
virtual
machine
with
an
operating
system
with
an
install
of
a
runtime
like
nodejs.
You
then
bring
an
application
that
has
all
of
the
packages
that
you
want.
You
develop
the
code.
You
then
deploy
the
virtual
machine.
If
you
want
multiple
instances,
you
deploy
multiple
virtual
machines.
You
deal
with
a
proxy
load
balancer
in
front
of
it.
A
Essentially
you
do
everything,
but
you
have
complete
control
to
do
it
exactly
the
way
that
you
want
to.
As
you
move
across
the
axis
you
move
to
kubernetes.
This
will
now
orchestrate
multiple
containers
for
you,
so
you
don't
actually
have
to
worry
about
managing
virtual
machines
or
instances
that
can
be
done
by
the
platform
you're,
bringing
a
docker
container.
That
is
an
operating
system
which
you've
then
pre-installed,
pre-configured
you're,
bringing
your
own
node
run
time.
You
bring
your
node
up
vacation.
A
On
top
of
it,
you
move
over
to
platform
as-a-service,
you
don't
have
to
worry
about
operating
systems
or
installs
of
runtime.
You
just
bring
it
all
in
application,
and
when
you
get
too
far,
you
don't
worry
about
any
of
that.
You
just
bring
individual
functions
right,
so
individual
small
sets
of
lines
of
code
and
that's
it
so
I
as
as
I
said,
most
complicated,
most
control
cars
container
as
a
service.
You
start
to
delegate
scaling
to
the
platform
and
some
of
the
configuration
platform
as-a-service.
A
You
now
focus
on
applications
and
not
how
they
run
and
functions
means
you
get
to
concentrate
on
a
function
and
not
even
how
the
rest
of
the
application
works
so
wikipedia
defines
function
as
a
service
as
something
provides,
a
platform
that
allows
you
to
develop,
run
and
manage
application
functions
without
having
to
build
and
maintain
infrastructure.
So
that's
pretty
much
what
we've
just
described.
A
So
if
we
look
at
this,
this
axis,
you
have
servers
in
the
bottom
left-hand
corner.
This
is
where
you
build
servers
yourself.
You
deploy
service
yourself.
You
manage
everything
at
the
far
end
of
it.
When
you
move
to
function
as
a
service,
you
have
service
in
terms
of
scaling
when
load
comes
in,
you
actually
have
instances
of
that
function
based
on
the
load
service
is
actually
a
sect
of
effectively
a
on-demand
scaler
right.
A
When
the
two
come
together,
you
get
function
as
a
service,
so
function
as
a
service
is
both
service
and
functions,
but
you
can
actually
have
them
completely
independently
of
each
other.
So
FAR's
is
service
plus
functions.
So
how
does
files
actually
work?
How
does
it
let
you
write
small
units
of
code
and
scale
two
to
infinity
under
it?
So
this
is
the
model
for
Apache
open
wesker,
which
is
an
open
source
implementation
of
the
function
as
a
service
platform,
and
what
happens
is
as
a
developer.
You
can
write
a
function.
A
So
this
is
the
function
signature
that
you've
got
the
Apache
open
risk
for
nodejs.
You
have
a
function
which
you
then
export,
so
you
do
exports
dot
handler
equals
the
name
of
your
function
and
you
declare
something
that
receives
one
parameter,
which
is
params
and
you
return.
So
that's
the
function,
signature
one
one
parameter
in
one
parameter
ant
and
you
can
make
it
do
whatever
you
like,
but
that's
the
entire
function,
signature
that
you
get.
A
When
you
write
that
code,
you
can
generate
what
they
call
a
function
handler.
If
you
then
want
to
test
that
function
handler,
you
have
to
deploy
it
to
the
the
function
as
a
service
platform.
So
you
deploy
your
function
handler.
You
get
the
ability
to
do
run,
test
debug
on
the
functions
platform
and
that
function
handler
is
now
running
in
live.
It
runs
on
top
of
a
runtime
because
something
has
to
invoke
your
function.
A
When
a
request
comes
in
and
then
you
can
have
you
know
a
real
user
and
that
real
user
can
make
a
request
and
your
function
gets
invoked
and
that's
how
open
risk
largely
works
and
at
the
results
on
the
right
hand,
side
it
will
scale
on
demand
as
new
requests
come
in,
it
will
make
sure
there's
enough
runtimes
to
handle
it
and
the
simplified
development
is
I.
Didn't
need
to
be
a
docker
container.
I
didn't
need
to
deal
with
versions
of
node.
I
didn't
need
to
have
a
package.json
if
I
don't
want
to.
A
They
do
let
you
require
in
packages.
If
you
want
to,
but
I
only
have
to
write
a
single
function.
Declaration
put
some
code
into
it
and
it
works
now.
Let's
actually
dig
a
level
deeper
and
see
how
that
actually
gets
put
together,
so
the
open,
Wisc
runtime
is
actually
a
few
layers
itself.
Oh,
the
bottom
layer
is
a
docker
container,
so
it
is
actually
building
a
containerized
runtime.
On
top
of
that,
it
has
no
js'
running
an
HTTP
server
and
inside
the
HTTP
server.
There
are
two
rest
endpoints.
A
So
what
you've
actually
got?
There
is
a
full
micro
service.
That's
just
been
built
for
you
in
terms
of
scaling.
The
way
it
works
is
when
you
have
a
second
request:
it
actually
spins
up
a
second
instance.
So
if
I
have
four
requests,
I
have
four
instances.
If
my
function
that
are
running
so
it
has
a
model
of
one
request,
one
instance.
A
So
what
are
people
using
faz
for
well?
The
biggest
use
case
for
service
and
FAR's
is
actually
to
build
REST
API
so
that
the
number
one
use
case,
73
percent
of
people
surveyed
about
what
they're
using
functions
for
said,
I'm
building
REST
API,
another
26%
said
they
were
building
mobile
backends,
which
is
essentially
REST
API.
So
the
largest
use
case
by
a
long
way
for
functions
is
actually
just
to
build
REST
API,
but
the
problem
was
that
is
the
function.
Signature,
okay,
who
here's
built?
Rest
API,
is
using
something
like
Express
right.
A
A
Unfortunately,
this
just
gives
you
one
parameter
in
one
parameter
rang
and
it's
not
designed
to
help
you
best
will
build
REST
API,
so
it's
designed
to
be
flexible.
Instead,
it's
designed
to
be
that
it
can
be
invoked
by
any
kind
of
request.
It
doesn't
have
to
be
rest,
it
could
be
a
cron
job.
It
could
be
a
change
in
a
database,
but
if
you
want
to
build
REST
API,
it's
not
a
very
helpful
API
and
open
risk
isn't
alone.
This
is
the
same
for
all
functions
implementations.
This
is
a
WS
lambda.
A
This
gives
you
a
slightly
different
function.
Signature
you've
got
event
cool
context
in
callback,
but
again
you've
got
this.
This
problem
that
it's
not
designed
for
a
specific
use
case
or
a
domain.
You
have
a
generic
API,
but
you're
probably
going
to
be
wanting
to
build
REST
API.
So
wouldn't
it
be
nice
if
you
could
build
functions
using
the
api's
that
you're
used
to
and
given
that
it's
actually
going
to
build
it
into
a
full
micro
service.
Anyway,
we
could
build
that
micro
service
using
well-known
frameworks
like
Express.
A
So
that's
what
I'm
actually
going
to
show
you
how
to
do
so.
There's
two
technologies
I'm
going
to
cover
one
of
them
is
called
AB
City,
which
was
talked
about
by
Michael
Dawson
in
the
previous
session
to
a
certain
extent
and
the
other
one
is
Kay
native,
which
is
a
project
that
builds
on
top
of
kubernetes.
A
Now
that
then
says
you
bring
the
two
together
you
bring
the
two
axis
of
Farr's,
so
functions
and
servlets
together,
and
you
can
build
a
faz
platformer.
That
does
exactly
what
you
want
it
to
but
lets
you
use
Express
API,
if
you
want
to
so.
If
we
start
off
with
AB
city,
it
consists
of
three
things:
there's
a
CLI
that
lets
you
do
development
and
there's
also
some
IDE
plugins
for
it
there's
then
a
sense
of
Stax.
Now
these
stacks
are
actually
available
at
multiple
levels.
A
I'm
going
to
show
you
the
top
level,
which
is
building
a
function,
but
what
Michael
Dawson
showed
in
the
last
session
was
how
you
can
build
an
application
with
this
style,
but
you
can
build
an
entire
express
app.
You
can
have
access
to
the
express
app
object
itself.
You
can
work
with
Reuters,
you
can
register
middlewares
and
it
will
still
deal
with
metrics
and
monitoring
and
how
you
deploy
to
kubernetes
for
you
and
there's
a
lower
level
where
you
can
say
actually
I've
got
a
node
application.
A
A
So
if
I
bring
up
the
console
and
make
sure
my
directory
is
empty,
yep,
so
I'm
going
to
make
a
new
directory
for
a
back-end
and
then
I'm
going
to
do
abs,
D,
init
and
I'm,
going
to
edit
the
type
of
project
that
I
want
to
create,
which
is
no
Jess
functions.
Now
this
is
doing
two
things.
It's
going
to
create
a
very,
very
simple
project
structure
for
me,
so
I've
got
something
to
develop
from
and
then
it
brings
down
that
functions
runtime
that
I'm
going
to
use.
A
And
let's
make
this
a
little
bit
bigger,
so
what
I've
got
in
my
project
is
I've
got
a
package.json,
so
I
can
add
it
add
dependencies
as
I
as
normal
I've
got
to
get
ignore
foul
and
so
on.
I've
got
an
absolute
config
file.
That
gives
my
name
my
project,
a
name
and
it
says
which
version
at
the
runtime
I
want
to
use
and
then
I've
got
a
function
and
this
function
says
forget,
requests
so
module
that
exports
don't
get.
A
It
says
if
there's
a
get
request
on
the
URL
of
slash,
run
this
function,
which
is
hello
from
AB
city.
So
if
I
then
just
run
it
and
I
can
do
that
with
absolute
unn
and
what
that
does.
Is
it
just
takes
my
code
and
applies
it
to
the
functions
runtime
locally,
so
this
is
all
going
to
run
locally
on
my
laptop
I
now
have
a
project
that's
running
on
port
3000.
A
So
if
I
go
to
localhost,
3000
I
get
hello
from
AB
city,
so
I
just
built
and
deployed
a
function
into
a
container
and
I've
got
a
local
running
version
of
this.
Now
it
also
do
development
with
that
function.
Runtime.
If
you're
used
to
using
something
like
node
mon-sol,
you
make
changes,
it
gets
reflected
immediately.
The
same
system
applies,
so
let's
say:
I
want
to
stop
making
some
changes
to
my
function.
So
that's.
A
And
then,
instead
of
saying
hello
from
AB
city,
that's
get
it
to
rip
return,
a
random,
a
random
entry.
So
hopefully-
and
people
can
correct
me
if
my
programming
is
wrong-
we
want
math
dot
floor,
so
maths,
random,
and
then
we
want
times
that
by
fruits,
dot
length
and
hopefully
I,
look
okay
to
everyone.
Well,
we'll
see,
I'll
go
back
to
my
browser
and
it
says
Apple.
It
says
orange
orange
apple
banana,
okay,
so
it's
working,
so
it's
immediately
reflected
the
changes
that
I
am
making
in
the
container
as
I
build
and
run
it.
A
A
And
now
that's
up
and
running
I
can
connect
the
debugger
it's
connected
and
if
I
reload
it
it
jumps
to
the
breakpoint.
So,
even
though
this
is
all
running
in
a
new
functions,
runtime
inside
a
container
I've
got
everything
that
I'm
used
to
running
so
I've,
just
let
that
go
again
and
disable
the
breakpoint.
A
Now
as
well.
As
you
know,
giving
me
this
iterative
development
environment,
one
of
the
advantages
of
me
not
owning
the
entire
application
is
the
rest
of
the
microservice
can
do
stuff
on
my
hat
behalf,
so
one
of
the
things
it
gives
you
it's
very
simple:
it's
this!
It's
a
health
check
endpoint,
and
that's
because
this
is
going
to
get
run
inside
kubernetes
and
kubernetes
will
do
a
couple
of
things
for
you.
It
will
automatically
restart
any
application
that
is
struggling
right.
It
checks
for
liveness
and
when
it
pings
your
life
in
a
send
point.
A
If
it
doesn't
get
a
response,
it
restarts
you,
but
you
can
also
register
a
number
of
callbacks
which
you
can
do
as
promises
to
get.
Some
checks
run
against
your
application
to
determine
whether
you
want
to
tell
kubernetes
to
restart
you
as
well
as
liveness.
There's
also
readiness
works
in
exactly
the
same
way,
but
rather
than
being
restarted,
it
will
take
you
out
a
load-balancing
until
you
report
that
you
are
ready
to
receive
workload.
So
that's
built
into
the
functions
runtime
for
you.
A
You
also
have
the
ability
to
say
I
want
to
have
metrics,
so
there
is
a
metrics
endpoint.
This
isn't
designed
to
be
human,
readable
you'll,
see
what
it's
for
later
and
during
development
time.
We
also
add
a
metrics
dashboard.
No,
that's
not
it!
That's
the
URL!
There
we
go
so
what
this
provides
and
I'll
just
hit.
The
end
point
a
few
times
is:
this
provides
an
inbuilt
view
of
the
performance
of
my
function.
So
it
tells
me
about
the
CPU
usage
of
the
function
tells
me
about
its
memory
usage.
A
It
tells
me
about
incoming
HTTP
requests
and
my
throughput.
It
also
knows
about
the
JavaScript
heap.
It
knows
about
the
event
loop
time
latency
and
every
other
request,
and
this
socket
IO
request
here.
Is
this
dashboard
itself
running
as
well
as
that?
I
can
turn
on
profiling
and,
as
part
of
profiling,
it
will
start
to
generate
an
inbuilt
set
of
flame
charts
for
me.
So
it's
got
full
profiling
of
my
function
as
part
of
the
functions
runtime.
A
A
I
can
put
as
many
into
the
application
as
I
like
so
if
I
drag
in
another
function
and
what
this
function
does
is
if
I
just
expand
the
screen,
so
this
is
going
to
make
a
request,
and
so
it
hosts
a
function
on
slash
proxy
and
what
it
does
is.
It
makes
the
request
against
the
host
and
reports
fruit,
plus
whatever
the
response
was
from
the
host
by
default.
The
host
is
localhost
3000.
It
will
also
look
up
default,
backend,
URL
from
an
environment
and
you'll
see
why
we're
doing
that
in
a
second.
A
This
is
doing
exactly
the
same
thing:
it's
just
restarting
the
rut
at
the
run
time
which
I
stopped
from
debug
mode
and
I
put
back
into
run
mode,
and
now,
when
I
run,
my
application
and
I
go
to
slash.
I
still
have
my
random
fruits.
If
I
go
to
slash
proxy,
it's
just
got
an
annotation
in
front,
because
it's
calling
back
to
itself
so
I've
got
two
functions
running
inside
the
run
time.
A
This
is
all
running
locally
on
my
laptop,
so
the
next
thing
we're
going
to
do
is
we're
actually
going
to
deploy
it
to
kubernetes.
Now
the
way
I
do
that
is
super
simple
I
just
say,
deploy
it
now.
This
is
doing
two
things
on
my
behalf.
First
of
all,
it's
building
a
best
practice,
docker
image
with
my
application
in
so
it
starts
off
by
you
know.
A
All
of
your
local
development
uses
a
standard
node
image,
but
for
production
we're
using
the
node
slim
image,
so
you
don't
need
things
like
NPM
in
a
production
image,
because
all
of
your
modules
are
already
installed.
So
this
generates
a
production
image.
That's
a
hundred
and
ninety
Meg
in
size
rather
than
900
Meg,
and
then
it's
deployed
it
to
kubernetes
running
locally
on
my
laptop,
and
that
says
it's
now
available
here.
A
Now,
a
way
of
showing
you
that
that
is
true
is
I
can
go
to
this,
which
is
a
kubernetes
application
viewer,
and
it
has
now
detected
that
I've
got
my
deployed.
Back-End
I
can
click
on
it
its
deployed
as
two
resources,
so
in
kubernetes
terms
you
have
deployments,
and
then
you
have
services
and
services
expose
the
deployment,
so
hi
I
have
a
deployment
and
an
exposed
service.
A
It
knows
that
it's
a
project
called
back-end
that
it's
made
with
nodejs
functions,
version
zero
point,
one
point:
six:
if
I
actually
create
a
git
project
for
this,
it
knows
where
the
git
project
is
what
the
commit
was,
and
it
will
jump
you
back
to
the
git
project.
I
can
also
go
to
the
liveness
endpoint.
That
I
showed
you
earlier
if
I
want
to
or
I
can
go
to
the
metrics
dashboard
or
can
I
this
is
always
the
danger
of
doing
things.
Allow
you
isn't
it?
A
What
happened
to
my
metrics
dashboard
there
we
go
I
just
need
to
make
that
connection
available.
Let's
reload,
that
there
we
go.
So
this
is
my
metrics
dashboard,
so
it
jumps
me
through
to
the
metrics
dashboard
inside
kubernetes
that
knows
about
my
application,
so
the
registration
that
I've
got
an
application
that
has
monitoring
that's
done
with
kubernetes
automatically,
that's
part
of
using
the
functions
runtime.
It
knows
about
request,
durations
and
the
URLs
that
they're
on
it
knows
about
request,
count,
CPU
usage
memory,
usage,
etc.
A
A
So
for
my
my
back-end,
what
I'm
gonna
do
is
I'm
just
going
to
take
its
its
configuration,
which
was
generated
for
me
and
I'm,
going
to
say
that
under
the
service
I
want
to
provide
something
that
people
can
connect
to
I'm
going
to
set
its
category
as
open
API,
so
I'm
saying
exposes
a
rest
endpoint
and
by
default.
I
would
like
people
just
to
connect
to
slash
now,
once
I've
done,
that
I
can
do
a
run
task
of
an
absolutely
deploy.
A
A
If
I
then
open
vs
code
for
my
new
project,
what
I'm
gonna
do
is
very
simple:
I'm
going
to
go
to
my
last
project
where
I
had
this,
this
proxy
function
and
I'm
going
to
drag
it
over
now.
What
we
said
with
this
proxy
function
is
that
it
decides
where
it
connects
to
by
using
localhost
3000
all
this
environment
variable
default,
back-end
URL.
So
what
we're
going
to
do
is
we're
going
to
make
the
front-end
function.
A
Look
up
that
value
when
it's
deployed
defined
my
back-end
function
and
connect
the
two
together
now
I'm,
just
gonna
do
a
build
to
make
sure
that
it
builds
properly,
which
it
should
do,
and
this
is
going
to
result
in
a
local
docker
container.
But
by
building
it
it
runs
the
tests
as
well
and
then
once
I've
done
that
I'm
just
going
to
set
it
up
to
connect
to
the
backend
and
once
I've
done
that
I
can
deploy
it.
A
A
So
it
consumes
something
if
category
open
API
that
has
a
name
of
back-end
and
it
has
a
and
it's
in
the
default
namespace.
And
then,
if
everything
comes
together,
I
can
do
an
absolutely
deploy
and
I'm
now
going
to
have
two
functions
deployed
and
one
will
connect
to
the
other
again.
This
is
building
a
production,
docker
image
that
docker
image.
You
can
actually
run
any
way
that
you
like
you,
don't
need
to
be
using
this
deploy
system
to
run
it
because
it
is
just
a
full
micro
service.
Oh
dear.
A
This
is
one
of
those
things
where,
given
the
time
I'm
gonna
have
to
anyone
that
wants
to
see
it,
working
I
will
show
them
afterwards,
but
I
will
quickly
drop
back
to
the
slides
just
to
show
you
that
so
that's
kind
of
the
functioned
programming
piece.
What
actually
happens
here
is
in
the
CLI.
It
does
a
lookup
of
the
the
types
of
applications
that
we'll
want
to
build.
We
built
a
function,
there's
load
local
dev,
debug
cycle.
A
It
pulls
down
the
stack
as
you
build,
and
then
it
takes
that
function
and
once
you
built
it
built
a
product
eyes
version
of
the
stack
and
then
deploys
it
to
kubernetes,
and
then
it
integrates
with
everything
in
the
platform.
So
we've
got
the
monitoring.
We've
got
the
dashboard
during
and
so
on.
Now
what
Kay
native
does
for
you
just
to
finish
that
piece
off
is
when
you
deploy
Kay
native
its
style
of
service
and
scaling
is
very
different
to
open
wisk.
A
When
you
have
one
request
of
Kay
native
for
service,
you
have
one
instance
of
your
micro
service,
but
one
of
the
other
advantages
of
using
a
full
framework
is
so
who
here
runs?
You
know,
50,
parallel
requests.
Current
requests
through
Express
I
would
hope.
Most
people
don't
worry
about
the
concurrency
of
request
of
Express
write
it's
more
than
capable
of
handling
multiple
requests
at
the
same
time,
so
by
default,
Kay
native
will
say
well,
if
I
have
a
second
user
right,
I
don't
need
two
instances
of
Express
to
handle
two
concurrent
users.
A
Its
Tony
has
one.
In
fact,
if
there's
four
of
them,
it
will
still
only
use
one.
If
there's
a
hundred,
it
will
still
use
one
if
there's
101
it'll
add
a
second
one
that
is
configurable.
You
can
make
it
any
number
you
like
you
can
make
it
one
if
you
wanted
to,
but
because
frameworks
already
provide
concurrency
it
lets
you
put
more
requests
through.
A
So
it's
a
system
where
it
does
serve
less
based
on
full
microservices
and
absolutely
helps
you
build
those
micro-services
and
that's
where
I'll
leave
it.
So
those
are
the
two
projects
I'll
be
at
the
IBM
booth
today
tomorrow,
if
you've
got
any
questions
and
everything's
open-source
projects.
Thank
you.