Serverless is a misnomer because there are servers. We will discuss what Serverless is, how it is part of an evolving abstraction, and what's on the horizon - InterCloud.

1. From Serverless to InterCloud
Definition
Abstraction
Responsibilities
Advantages/Challenges
Futures
Wayne Scarano, aws-sa, cissp, ccsk
sga.com
wscarano@sga.com

2. What is Serverless?
• AWS Lambda is a serverless compute service that runs your code in
response to events and automatically manages the underlying
compute resources for you. You pay only for the compute time
you consume - there is no charge when your code is not running.
• Azure Functions is a serverless event driven experience that extends
the existing Azure App Service platform. These nano-services can
scale based on demand and you pay only for the resources you
consume.
• IBM® Bluemix® OpenWhisk is a distributed, event-driven
compute service also referred to as Serverless computing or as
Function as a Service (FaaS)
• Google Cloud Functions is a lightweight, event-based,
asynchronous compute solution that allows you to create small,
single-purpose functions that respond to cloud events without the
need to manage a server or a runtime environment.

3. Definition
Serverless === Function as a Service (FaaS)
An on-demand scalable compute service,
running a small stateless function,
triggered by an event,
billed only for resources used,
operating on abstracted servers.
Cloud services are components for building applications.

4. How Does Serverless Work?
AWS
Source: Amazon Web Services

5. Adoption: Benefits/Trust Threshold
The benefits of abstraction for existing capabilities
and the creation of
new cloud capabilities/services
is driving rapid cloud adoption when trusted.
Benefits + Trust Adoption

6. Continuous Abstraction Enabled With Trust
2006 AWS Elastic Compute Cloud (EC2)
• Infrastructure as a Service (IaaS).
• Abstracts/Replaces: On-premises/Leased Datacenter, Server
hardware/hypervisor, Networking, and associated Security
• Workloads: Migration, Utilize Cloud Services
AWS EC2

7. Continuous Abstraction Enabled With Trust
2014 AWS Lambda
• Function as a Service (Serverless)
• IaaS replaced by FaaS and is managed by trusted cloud providers
• Abstract: Server O/S and Containers
AWS Lambda

8. Continuous Abstraction Enabled With Trust
2016 InterCloud
• Multi-cloud applications/solutions
• Applications access cloud services across multiple trusted cloud
providers based
• Use cloud services natively
• Abstraction:
• Serverless Framework abstracts the serverless architecture
(build, deploy, update, delete).
• Auth0 – Login and identity abstraction. Provides single sign-
on services, abstracting various login and identity services into
a single API including public APIs like Facebook Connect and
public or private instances of Active Directory and LDAP.

9. The right service, for the right price, in the right
location, at the right time.

10. region
AWS Cloud
virtual private
cloud
region
route
table
subnet
Availability
Zone
Network
ACL
security
group
Amazon
EC2
account Infrastructure as a Service (IaaS)
Source: SGA Business Systems, Inc.

11. region
AWS Cloud
virtual private
cloud
region
route
table
subnet
Availability
Zone
Network
ACL
security
group
Amazon
EC2
account
Serverless – LessOps
Source: SGA Business Systems, Inc.

12. Shared Responsibility (IaaS)
Source: AWS Security Best Practices White Paper

13. Shared Responsibility (Serverless)
Source: AWS Security Best Practices White Paper. Modified by SGA.

14. Serverless
Potential Advantages
LessOps – Automated administration with no servers to provision or manage
Lower Cost - Pay only for what you use
Small functions are easier to code and provides focus on business logic
Built-in fault tolerance, automatic scaling, integrated security,
Automatic logging
Server security responsibility and risk transferred to provider
No need for remote server access (SSH/RDP) and management

15. Potential Lower Cost
Example – AWS Lambda pricing:
• Requests - Number of times code is triggered
• Free => 1M requests per month
• $0.20 per 1 million requests thereafter ($0.0000002 per request)
• Duration - 100ms that code executes (rounded up)
• Free => 400,000 GB-seconds of compute time per month
• Price depends on amount of memory allocated for the function
• $0.00001667 for every GB-second used
Calculator => http://serverlesscalc.com/
Estimate and pilot all potential charges (other services,
network, etc.)

16. Serverless Challenges
LessOps requires new ways of thinking about deployment, testing, etc.
Serverless billing can be challenging and not always cheaper than IaaS.
Invoking functions requires the cloud vendors to launch containers (startup
considerations).
New development skills required including cloud knowledge
Small stateless functions require new coding patterns

17. New Coding Patterns
Source: http://blog.serverless.com/serverless-architecture-code-patterns/
• Microservices Pattern – One function per operation (e.g., single http endpoint)
• Services Pattern – One function can handle multiple operations (e.g., CRUD)
• Monolithic Pattern – Entire app in one function (e.g., all http endpoints point to the
function)
• Graph Pattern – Similar to Monolithic Pattern
• Uses GraphQL* to reduce entire REST API and all endpoints to 1 or 2 endpoints.
• Graph Gateway Pattern – Isolated GraphQL query into second tier of Lambda
functions
• Retains a Microservices architecture while using GraphQL
*GraphQL
The abstraction of data access and relationships between clients and servers.

18. What’s the big picture?
Cloud services are components for building applications
Serverless is a cloud compute service.
Compute service plus other services allow you to build applications.
Program the cloud.

19. What’s the bigger picture?
Today – Isolated cloud networks operating independently, worldwide
Program the InterCloud
Integration of disparate cloud services functioning as an InterCloud.
InterCloud services are components for building applications.

20. 2022 Predictions and Thank You!
Serverless usage will exceed IaaS
Serverless/Microservice/API architectures will standardize
DevOps  LessOps  ServerlessOps
sga.com/perspective