Jules Testard - Software Engineer, Docker Inc Since the advent of AWS Lambda in 2014, the Function as a Service (FaaS) programming paradigm has gained a lot of traction in the cloud community. Since then, interest has increased for developers and entreprises to build their own open source solutions on top of Kubernetes. A number of competing frameworks in this space have been developed. In this talk, we will look at three specific frameworks (OpenFaas, Nuclio and FN) and for each framework we will: Show how to create, deploy, and invoke a function using that framework Show how Docker images and containers are used by each framework under the hood Investigate how the frameworks leverage KNative to build, ship and run applications on Kubernetes

1. Jules Testard
Software Engineer, Docker
Inc
Docker Containers in
the Serverless World

2. What is Serverless?
● Serverless: also called FaaS
● FaaS: Function-As-A-Service
● Programming model in which applications are written as a set of
“functions”, run in ephemeral containers
package function
import (
"encoding/json"
)
// Handle a serverless request
func Handle(req []byte) string {
var e CloudEvent
if err := json.Unmarshal(req, &e); err != nil {
panic(err)
}
if Authenticate(e.Data) {
return "authentication successful"
}
return "authentication failed"
}

3. What is Serverless?
Public Cloud FaaS
● Public cloud manages the
function lifecycle and execution
● “Pay-as-you-go” model. Pricing is
based on actual amount of
resources consumed by the
function execution
● Pioneered by AWS, with AWS
Lambda (2014)
Private/Installable FaaS
● Installed using an orchestrator
such as Docker Swarm or
Kubernetes on a cluster
● Function management and
lifecycle handled in orchestrator.
● More recently developed (2016).
● Serverless: also called FaaS
● FaaS: Function-As-A-Service
● Programming model in which applications are written as a set of
“functions”, run in ephemeral containers

4. Serverless Pros
● Eliminates server maintenance
○ Developer time is spent on building actual value
○ (installable framework) -> maintenance goes to ops team
● Automatic Scaling
● Significant Price Drop
● Modernize traditional application (MTA)

5. LibHive: 90% cost reduction on small app
Small web app running on
AWS using a public cloud application
moved to AWS
Lambda
application fully
managed by Ec2
and ELB

6. HeavyWater: from 30,000$/mo to 3700$/mo
HeavyWater processes
files in batch using AWS
1000 Ec2 machines
200 Ec2
machines
39M AWS
Lambda
invocations

7. Serverless Cons
● (Still) hard to observe
● Cold Starts*
● Hard to hire knowledgeable developers
○ ecosystem is very new
● Each platform has specific tools
○ No common tooling
● Heavier reliance on vendor ecosystems

8. Public or Installable?
Public over Installable:
● Free below free tier
○ i.e. AWS Lambda has 1M requests/mo for free
● No ops team required
● Integrated within each cloud
○ i.e. a cloudwatch event can trigger an AWS Lambda
call

9. Public or Installable?
Installable over Public:
● Can be much more performant if properly configured
● Functions can be as big as you like* and run for as
long as you like
● Can be much cheaper on large scale (back of the
envelope
● Can run without the internet
*: within available resources

10. FaaS in 2018

11. Source: CNCF Serverless WG Our Focus

12. Overview of (some) open source
serverless frameworks

13. ● Creator: Alex Ellis, launched at DockerCon17
● Github stars: 12,100
● Start Date: Dec 18, 2016
● Contributors: 83
● Runs on Kubernetes and Swarm

14. RESTful
entrypoint
(CLI/API/WEB)
Metrics
Entrypoint
for function
process
Orchestrator

15. OpenFaaS example: authentication
package function
import (
"encoding/json"
)
// Handle a serverless request
func Handle(req []byte) string {
var e CloudEvent
if err := json.Unmarshal(req, &e); err != nil {
panic(err)
}
if Authenticate(e.Data) {
return "authentication successful"
}
return "authentication failed"
}
provider:
name: faas
gateway: http://12.123.123.123:33000
functions:
simple-auth:
lang: go
handler: ./simple-auth
image: julestestard/simpleauth

16. DTR
Docker
Hub
1. faas-cli build
2. faas-cli push
function
3. faas-cli deploy
function
4. faas-cli invoke
function
Native Tooling: faas-cli

17. Open FaaS Demo

18. ● Github stars: 2,300
● Starte Date: Jun 4, 2017
● Focuses on data processing and
performance
● Contributors: 33
● Runs on Kubernetes
● Sponsored by Iguazio

19. Pod
Creates function artifact
(runs in CLI context)
Kubernetes deployment
Kubernetes deployment

20. Nuclio example: authentication
package main
import (
"encoding/json"
"github.com/nuclio/nuclio-sdk-go"
)
// Handle a serverless request
func Handler(context *nuclio.Context, event nuclio.Event) (interface{}, error) {
var e CloudEvent
if err := json.Unmarshal(event.GetBody(), &e); err != nil {
return nil, err
}
if Authenticate(e.Data) {
return "authentication successful", nil
}
return "authentication denied", nil
}
relies on nuclio SDK

21. Any host
nuctl build
processor-simple-auth
image

22. apiVersion:
"nuclio.io/v1"
kind: Function
metadata:
name: simple-auth
namespace: nuclio
spec:
runtime: golang
handler: main:Handler
minReplicas: 0
maxReplicas: 10
Any host
nuctl deploy
Function CRD

23. Nuclio Demo

24. Knative
● Kubernetes-based platform to build, deploy,
and manage modern serverless workloads.
● Release Date: Jun 4, 2018 (currently at v0.2)
● Contributors: 50
● Runs on Kubernetes
● Sponsored by Google, Pivotal, IBM, Red Hat,
and SAP

25. Knative

26. Knative
Function developers
Function framework
maintainers

27. DTR
Docker
Hub
1. faas-cli build
2. faas-cli push
function
Istio
Envoy

28. Istio
apiVersion: serving.knative.dev/v1alpha1
kind: Service
metadata:
name: knative-hello-world
namespace: default
spec:
runLatest:
configuration:
revisionTemplate:
spec:
container:
image: julestestard/hello-world-http
kube api
server
Envoy5. curl -v -X POST
-d $data -H "Host:
knative-hello-world-
openfaas.default.ex
ample.com"
http://...
4. deploy knative
serving
kubectl apply
serving.knative
service
kube deployment
for function
replicas=0
knative hello-world pod
knative hello-world pod
knative hello-world pod
kube deployment
for function
replicas=3

29. OpenFaaS Knative Demo

30. Tools which will influence the future of FaaS:
- CloudFlare isolates
- AWS FireCracker
- Pulumi
New Trends

31. CloudFlare Isolates
● All functions which use the same runtime will use the same process
● Node JS runtime overhead: 35MB
● Node JS runtime using CloudFlag isolates: 3MB

32. AWS Firecracker
● Open Source Project
● Designed for multi-tenant function
services
● MicroVM: lightweight virtual machine
● Same hardware-virtualization-based
security as VMs
● Almost as fast to start as a container

33. Pulumi
Cloud Native Infrastructure as Code on any cloud with real
programming languages

34. Thank you!
Jules Testard
Install OpenFaas, Nuclio and Knative
on Docker EE and code samples