Serverless Architectural Patterns and Best Practices

© 2018, Amazon Web Services, Inc. or its Affiliates. All rights reserved.
Serverless Architectural Patterns and
Best Practices

Intro

What is serverless?
Build and run applications
without thinking about servers

Let’s take a look at the evolution of computing
Physical Servers
in Datacenters
Virtual Servers
in Datacenters
Virtual Servers
in the Cloud

Each progressive step was better
Physical Servers
Datacenters
Virtual Servers
Datacenters
• Higher utilization
• Faster provisioning speed
• Improved uptime
• Disaster recovery
• Hardware independence
• Trade CAPEX for OPEX
• More scale
• Elastic resources
• Faster speed and agility
• Reduced maintenance
• Better availability and
fault tolerance
Virtual Servers
in the Cloud

But there are still limitations
Physical Servers
Datacenters
Virtual Servers
Datacenters
• Trade CAPEX for OPEX
• More scale
• Elastic resources
• Faster speed and agility
• Reduced maintenance
• Better availability and
fault tolerance
• Still need to administer
virtual servers
• Still need to manage
capacity and utilization
• Still need to size
workloads
• Still need to manage
availability, fault
tolerance
• Still expensive to run
intermittent jobs
Virtual Servers
in the Cloud

From the Iron Age to Freedom
SERVERLESS

No server is easier to manage than no server
All of this
goes away
Provisioning and utilization
Availability and fault tolerance
Scaling
Operations and management

Deliver on demand, never pay for idle
EVENT DRIVEN
CONTINUOUS SCALING PAY BY USAGE
Changes in
data state
Requests to
endpoints
Changes in
resource state

No servers to provision
or manage
Scales with usage
Never pay for idle Availability and fault
tolerance built in
Benefits of Lambda and serverless compute

ON PREM
CLOUD
“LEGACY” ARCHITECTURES
(monoliths, manual deployments)
MODERN ARCHITECTURES
(Microservices, API driven, event driven)
- Change in capacity
processes
- Change in cost
models
CONTAINERS
- Change in operational processes
- Change in development models
EC2
ECS/EKS/FARGATE
EKS/ECS/FARGATE
Containers vs Serverless = Containers + Serverless

Lambda execution model
Synchronous (push) Asynchronous (event)Stream-based
Amazon
API Gateway
AWS Lambda
function
Amazon
DynamoDBAmazon
SNS
/order
AWS Lambda
function
Amazon
S3
reqs
Amazon
Kinesis
changes
AWS Lambda
service
function

Amazon API Gateway
API Proxy
Amazon SNS
Amazon SQS
Messaging
AWS Lambda
Compute
Amazon S3
Storage
Monitoring and Debugging
AWS X-Ray
Orchestration
AWS Step Functions
Edge Compute
AWS Greengrass
Lambda@Edge
AWS: A Mature Serverless Portfolio
Amazon Kinesis
Analytics
Amazon Athena
Amazon DynamoDB
Database
Amazon Aurora
Serverless (coming soon)

Architectures

Web
Applications
• Static
websites
• Complex web
apps
• Packages for
Flask and
Express
Data
Processing
• Real time
• MapReduce
• Batch
Chatbots
• Powering
chatbot logic
Backends
• Apps &
services
• Mobile
• IoT
</></>
Amazon
Alexa
• Powering
voice-enabled
apps
• Alexa Skills
Kit
Autonomous
IT
• Policy engines
• Extending
AWS services
• Infrastructure
management
Common use cases

Web Applications and Backends
Internet
Mobile Apps
Websites
Services
AWS Lambda
function
AWS
API Gateway
Cache
All publicly
accessible
endpoints
Amazon
CloudWatch
Monitoring
Amazon
CloudFront
Amazon S3 AWS Lambda
function
AWS Lambda
function
Amazon DynamoDB
Web
Applications
• Static
websites
• Complex web
apps
• Packages for
Flask and
Express
Backends
• Apps &
services
• Mobile
• IoT
</></>
Common use cases

Web
Applications
• Static
websites
• Complex web
apps
• Packages for
Flask and
Express
Data
Processing
• Real time
• MapReduce
• Batch
Chatbots
• Powering
chatbot logic
Backends
• Apps &
services
• Mobile
• IoT
</></>
Amazon
Alexa
• Powering
voice-enabled
apps
• Alexa Skills
Kit
Autonomous
IT
• Policy engines
• Extending
AWS services
• Infrastructure
management
Data processing: Lambda + S3
Common use cases

Data
Processing
• Real time
• MapReduce
• Batch
Data processing: Lambda + Kinesis
Common use cases

Data
Processing
• Real time
• MapReduce
• Batch
Data processing: Lambda + Dynamo DB
Common use cases

How does serverless look like in
production?

Serverless Microservice
S3
CloudFront
Static
Content
Content
Delivery
API
Layer
Application
Layer
Persistency
Layer
API
Gateway
DynamoDBAWS
Lambda
Authentication
Authorization
Cognito

Demo

170 Lambda
functions in prod
1.2 GB deployment
packages in prod
95% cost saving vs
EC2
15x no. of prod
releases per month
Expanded to add
analytics, ratings,
people search
It’s a new world, a new day, a new life..

Design principles for Serverless
applications

General design principles
Speedy, simple, singular

Instead of Lambda based “monoliths”….
GET /pets
PUT /pets
DELETE /pets
GET /describe/pet/$id
PUT /describe/pet/$id
ONE LARGE LAMBDA FUNCTIONEVENT DRIVEN

Lambda based “nano-services”
EVENT DRIVEN Constellation of functions
GET /pets
PUT /pets
DELETE /pets
GET /describe/pet/$id
PUT /describe/pet/$id
Amazon
API Gateway

Think concurrent requests, not
total requests

Computer power
Lambda exposes only a memory control, this also affects the #
of ECUs allocated to a function
Is your code CPU, Network or memory-bound, it could be
cheaper to give more memory
> Memory > Cores

Lambda function runtimes
Icon made by Freepik from www.flaticon.com
Separate business logic from function signature
Choose dependencies/frameworks carefully
Interpret languages initialize much quicker but not
necessarily faster overall

Compute power: Don’t “guesstimate”
alexcasalboni
aws-lambda-power-tuning

Share nothing

Leverage container reuse but persistent storage for durable
state
s3 = boto3.resource('s3')
db = db.connect()
def lambda_handler(event, context):
global db
# verify if still connected
# otherwise carry on
if not db:
db = db.connect()
…
db.save(highly_durable_state)
...

Assume no hardware affinity

Orchestrate your application with
state machines, not functions

Don’t orchestrate within your functions…STARTJOB
JOB#XSTARTED
HTTPPOST
HTTPPOST
AREWETHEREYET?
NOPE!
WE’REDONE!
ZzZz
OR
time.sleep(10)

Step Functions with AWS Batch

Use events to trigger transactions

Design for failures and duplicates

Applying Saga pattern with AWS Step Functions
theburningmonk.com/2017/07/applying-the-saga-pattern-with-aws-lambda-and-step-functions

Best practices

API Gateway > Lambda Best Practices
• Global level throttling and Authorization are minimum baseline
• Maximum timeout is 30 seconds - If it’s timing out consider reviewing
• Another option is to use AWS Step Functions to orchestrate a more complex
processing
• If longer wait is unusual have Front-end to halt request then retry
• Service Proxy when suitable == Unnecessary calls to Lambda
Calls orchestrations == Step Functions
Inter-service communication == API GW || Async Lambda Invoke

Async Best Practices
• One DLQ per function – SQS or SNS
• When unable to send error to configured DLQ, DLQ Errors metric will be updated
• Duplicates may happen; code must be idempotent
• Understand retries and limitations for each Lambda Event Source
used
• Not all services support cross-account invocation; always refer to docs
• Enable SNS Delivery Status to ensure visibility on success/failure
rates
• Cloudwatch Metric Filter can aid create custom metrics out of pattern here
• Leverage Cloudwatch Events for scheduled calls

Deployment

Deployment best practices
• Single responsibility principle == Single function
• Share resource information across stacks via Export
value or SSM Parameter Store
• Build out multiple environments, such as for
Development, Test, Production and even DR using
the same template, even across accounts
• Shared code == Language specific packages
Shared Event Source == Same template
SAM Template
Source
Control
Dev
Test
Prod

Testing

Testing strategies
Run Unit tests locally
Run Integration/Acceptance tests with real services
Leverage SAM Local and Lambda runtime AMI

Local development with SAM Local (Beta)
Test functions locally via Docker containers
Run API Gateway locally with hot-reloading
Validate SAM templates
Support for remote debugging
https://github.com/awslabs/serverless-application-model

Monitoring

Cloudwatch – Metrics and streaming
Alarm on individual and aggregate metrics
(Throttling alarm !== Errors/Duration alarm)
Create Custom Metrics via Metric Filter
(Centralize logs from multiple accounts to Amazon ES)
Drill down application insights with X-Ray
(Too much time spent at logs == Lack of metrics)
Log only what’s necessary
(Use Environment Variables to control logging level)
built-in custom
Amazon Cloudwatch

X-Ray – Application Insights

Application instrumentation (Node.js)
const AWSXRay = require('aws-xray-sdk-core');
# Wraps AWS SDK and trace subsequent AWS Services
const AWS = AWSXRay.captureAWS(require('aws-sdk'));
const dynamoDb = new AWS.DynamoDB.DocumentClient();
const sqs = new AWS.SQS();
# Wraps HTTP calls made
const https = AWSXRay.captureHTTPs(require('https'));

Security

Vulnerabilities and security scan
Application Security Best practices still apply
(Input validation/sanitization, code review, etc..)
One IAM Role per function
(permissions are easy to add but hard to remove)
Encrypt secrets with KMS integration
(Leverage EC2 SSM Parameter Store for shared secrets)
Automate security scans/controls into CI/CD
(Dependency CVEs, static/dynamic analysis, etc.)

Resources
- AWS Lambda Resources https://aws.amazon.com/lambda/resources/
- 10 lessons from 10 years of AWS https://t.co/uny0wPz3o6
- Serverless Architectures with AWS Lambda https://bit.ly/2zVvp0w
- Optimizing Enterprise Economics with Serverless Architectures
https://bit.ly/2hQdy44
- Serverless Application Lens AWS Well-Architected Framework
http://bit.ly/2ALmKdz

Next steps
• See https://aws.amazon.com/serverless for reference architectures,
samples, and links to more content!
• Explore the AWS SAM specification on GitHub
• Visit the Lambda console, download a blueprint, and get started building
your own Serverless Applications
• Send us your questions, comments, and feedback on the AWS Lambda
Forums.

Thank you

Serverless Architectural Patterns and Best Practices

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Serverless Architectural Patterns and Best Practices

Similar to Serverless Architectural Patterns and Best Practices (20)

More from Amazon Web Services

More from Amazon Web Services (20)

Serverless Architectural Patterns and Best Practices