This document discusses serverless computing and functions as a service (FaaS). It describes serverless as using cloud-based services to implement backend logic and functions that are triggered by events. Key benefits include not having to manage servers or scale infrastructure, while paying only for resources used. However, there are limitations like additional complexity, statelessness of functions, and vendor lock-in. Examples provided include using AWS Lambda for an automated video uploading/processing pipeline and faculty onboarding tasks. Programming challenges of statelessness and tooling options are also covered.

1. Serverless
Obie Fernandez

3. Basics

4. serverless: pervasive
use of functional
computing resources

5. Backend as a
Service (BaaS)
Implementing server-side logic and
state primarily using third-party,
cloud-based services.
Main examples:
● Parse
● Firebase

6. Functions as a
Service (FaaS)
Custom, event-triggered backend code
deployed into stateless compute
containers fully managed by cloud
computing vendors.
Main examples:
● AWS Lambda
● IBM OpenWhisk
● Google Cloud Functions
● Azure Functions

7. Benefits of the approach
● No operating systems to choose, secure, patch, or manage.
● No servers to right size, monitor, or scale out.
● No risk to your cost by over-provisioning.
● No risk to your performance by under-provisioning.

8. But my favorite benefit has to
do with what it does to your
application architecture...

10. Microservices vs. Monoliths
Choosing microservice approach provides natural and compulsive incentive to
design components in a loosely-coupled, highly cohesive way

11. Image credit: http://martinfowler.com/articles/serverless.html

12. Image credit: http://martinfowler.com/articles/serverless.html

13. Drawbacks
● Additional complexity involved in programming and deployment versus
monolithic systems
● FaaS event-based, ephemeral (non-stateful) and resource constrained by
nature.
● Vendor lock-in
● Other limitations...

14. Execution Duration
Limited

15. Startup Latency

16. Integration Testing

17. Let’s talk about FaaS benefits again...

18. Optimization can drive cost savings
Any performance optimizations you make to your code will not only increase the
speed of your app but will also have a direct and immediate link to reduction in
operational costs
For example, if each of your operations currently take 1 second to run and you
reduce that to 200ms you’ll immediately see 80% savings in compute costs
without making any infrastructural changes.

19. Scale more cheaply
Jobs with very small load requirements can be broken down into microservices by
logic / domain even if the operational costs of such fine granularity might have
been otherwise prohibitive.
If your total workload is relatively small (but not entirely insignificant) you may not
need to pay for any compute at all due to the 'free tier' provided by some FaaS
vendors.

20. Example:
Inconsistent Traffic
Baseline traffic is 20 req/s but every 5
minutes spikes to 200 req/s for 10s.
Baseline performance maxes out your
server, but you don't want to reduce
response time during the traffic spikes.
Traditionally you increase your total
hardware capability by 10x to handle
the spikes, even though they only
account for less than 4% of uptime.
Auto-scaling not a good option due to
how long new instances of servers will
take to come up - by the time your new
instances have booted the spike phase
will be over.

21. Real-world Examples

24. Example: Video Uploader
Automates the video production process for
content producers.
Replaces manual Jenkins job with two lambdas that
automatically detect source file uploads, encode
them via Zencoder, and then register them with the
CMS so content producers can associate the
encoded videos with the proper courses and
content.
Less than 200 lines of code total.

25. Example: PennStation
Automates faculty onboarding
● Creation of LMS account
● Creation of primary and backup
Adobe Connect rooms
● Creation of primary and backup
conference phone lines
● Attachment of the lines to the rooms
The tasks that comprise PennStation's behavior are
controlled by an underlying directed graph, in which each
task is a node. The graph's edges determine which tasks execute.

26. Extra Topics

27. Extra Topic: Programming without
local state
For any given invocation of a function,
none of the in-process or host state
that you create will be available to any
subsequent invocation.
Twelve-factor processes are stateless
and share-nothing. Any data that
needs to persist must be stored in a
stateful backing service, typically a
database.
-- The Twelve-Factor App

28. Extra Topic:
Tooling
● Serverless Framework
● Apex
● Gordon
● Roll-your-own

29. Learn more...
My book is available at
Leanpub
http://leanpub.com/serverless
Serverless Meetup
NYC
http://meetup.com/Serverless-NYC