Serverless Architectures.pdf

© 2017, Amazon Web Services, Inc. or its Affiliates. All rights reserved.
Shaun Ray, AWS
July 2018 – Hong Kong RISE
Serverless Architectures
Breaking things in the wild

Serverless is about maximizing elasticity, cost
savings, and agility.

MULTIPLE POINTS TO OPTIMIZE
Amazon
API
Gateway
Amazon
Alexa
AWS
IoT Amazon
Kinesis
Amazon
SNS
Amazon
SES
AWS Step
Functions 2
Invocations
1
Functions
3
Interactions
Amazon
S3
Amazon
DynamoDB
Custom
endpoints
Amazon
CloudWatch
Amazon
Elasticsearch
EC2
instance

ANATOMY OF A FUNCTION
Your
function
Language
runtime
Function
container
Compute
substrate

THE REQUEST LIFECYCLE
Bootstrap
the runtime
Start your
code
Cold
start
Warm
start
Download
your code
Start new
container
AWS optimization Your optimization

SAME VIEW IN X-RAY

DEMO

THE FUNCTION LIFECYCLE
Bootstrap
the runtime
Start your
code
Warm
start
Download
your code
Start new
container
AWS optimization Your optimization
Cold
start

EFFICIENT FUNCTION CODE
• Avoid “fat”/monolithic functions
• Control the dependencies in your
function's deployment package
• Optimize for your language
• Node – Browserfy, Minify

EPHEMERAL FUNCTION ENVIRONMENT
• Lambda processes a single event
per-container
• No need for non-blocking execution
on the frontend
• REMEMBER – containers are reused
• Lazily load variables in the global
scope
• Don’t load it if you don’t need it –
cold starts are affected
import boto3
client = None
def my_handler(event, context):
global client
if not client:
client =
boto3.client("s3")
# process

CONCISE FUNCTION LOGIC
• Separate Lambda handler (entry point) from
core logic
• Use functions to TRANSFORM, not TRANSPORT
• Read only what you need
• Query filters in Amazon Aurora
• Use Amazon S3 select (new!)

200 seconds and 11.2 cents
# Download and process all keys
for key in src_keys:
response =
s3_client.get_object(Bucket=src_bucket,
Key=key)
contents = response['Body'].read()
for line in contents.split('n')[:-1]:
line_count +=1
try:
data = line.split(',')
srcIp = data[0][:8]
….
95 seconds and costs 2.8 cents
# Select IP Address and Keys
for key in src_keys:
response =
s3_client.select_object_content
(Bucket=src_bucket, Key=key,
expression =
SELECT SUBSTR(obj._1, 1, 8),
obj._2 FROM s3object as obj)
contents = response['Body'].read()
for line in contents:
line_count +=1
try:
….
A f t e rB e f o r e
SMALL CHANGES, BIG DIFFERENCE
(https://github.com/awslabs/lambda-refarch-mapreduce)

SMART RESOURCE ALLOCATION
Match resource allocation (up to 3 GB!) to logic
Stats for Lambda function that calculates 1000 times all prime
numbers <= 1000000
128 MB 11.722965sec $0.024628
256 MB 6.678945sec $0.028035
512 MB 3.194954sec $0.026830
1024 MB 1.465984sec $0.024638

IMPACT OF MEMORY CHANGE
50% increase
in memory
95th percentile
changes from
3s to 2.1s
https://blog.newrelic.com/2017/06/20/lambda-functions-xray-traces-
custom-serverless-metrics/

DON’T GUESSTIMATE!
alexcasalboni
aws-lambda-power-tuning

AWSome Selfie Challenge Architecture

D a t a S t o r a g e P a t t e r n s To d a y

Serverless Applications
Services (anything)
Changes in
data state
Requests to
endpoints
Changes in
resource state
Event source Lambda function
Node.js
Python
Java
C#
Go

Fan Out

source tweets
data source
source tweet
Amazon Simple
Storage Service
Firehose
delivery stream
transformed
records
delivery failure
Data transformation
function
transformation failure

Nutrition syndication

Nutrition syndication
Transform formula nutrition

Analytics data collection solution

• Derive keyframe locations
within the source
• Split the source at the
keyframes
• Process segments (typically
0.5 sec per) in parallel
• Concatenate segments
• Elapsed time: ~20 min down
to ~2 minutes
Video processing solution

Details
How to get from Lambda to Amazon S3:
ffmpeg -f concat –safe 0 -I filelist.ffcat –c copy pipe:0 |
aws s3 cp – s3://output-bucket/output-file.mp4

Details

Let’s peek at the code!
"Init": {
"Type": "Pass",
"ResultPath": "$.operation",
"Result": "prepare-split",
"Next": "PrepareSplit"
},
"PrepareSplit": {
"Type": "Task",
"Resource": "arn:…:ffmpeg-18HFP9FXFL6P",
"Next": "SplitPrepared"
},
"SplitPrepared": {
"Type": "Pass",
"Result": "perform-split",
"Next": "PerformSplit"
},
"PerformSplit": {
"Type": "Task",
"Next": "SplitPerformed"
},
"SplitPerformed": {
"Type": "Pass",
"Result": "poll-results",
"Next": "PreparePoll"
},
"PreparePoll": {
"Type": "Pass",
"ResultPath": "$.pollstatus",
"Result": "Submitted",
"Next": "WaitForResults"
}
Hmm…the same function,
throughout

Let’s peek at the code!
"WaitForResults": {
"Type": "Choice",
"Choices": [
{
"Variable": "$.pollstatus",
"StringEquals": "Complete",
"Next": "SegmentsCompleteState"
},
{
"StringEquals": "Progressing",
"Next": "loop_wait_using_seconds"
},
{
"StringEquals": "Submitted",
"Next": "loop_wait_using_seconds"
}
]
}
"loop_wait_using_seconds": {
"Type": "Wait",
"Seconds": 3,
"Next": "loop"
},
"loop": {
"Type": "Task",
"Next": "WaitForResults"
},
"SegmentsCompleteState": {
"Type": "Pass",
"Result": "concat",
"Next": "CompleteState"
},
"CompleteState": {
"Type": "Task",
"Resource": " arn:…:ffmpeg-18HFP9FXFL6P",
"End": true
}
Counts the segments,
sets $.pollstatus
Stitches segments together

Takeaways
Use Amazon S3
data events to
trigger parallel
Lambda
processing: win
Use Amazon S3
URLs to stream
video to
Lambda: win
Scaling to 1,000
Lambdas, rather
than 1,000 EC2
instances: win
Process video
segments in
parallel: win

MULTITHREADING? MAYBE
• <1.8GB is still single core
• CPU bound workloads won’t see gains – processes share
same resources
• >1.8GB is muti-core
• CPU bound workloads will gains, but need to multi thread
• I/O bound workloads WILL likely see gains
• e.g. parallel calculations to return

NO ORCHESTRATION IN CODESTARTJOB
JOB#XSTARTED
HTTPPOST
HTTPPOST
AREWETHEREYET?
NOPE!
WE’REDONE!
ZzZz
OR
time.sleep(10)

NO ORCHESTRATION IN CODE

INVOCATION PATHS
Amazon
API
Gateway
Amazon
Alexa
AWS
IoT Amazon
Kinesis
Amazon
SNS
Amazon
SES
AWS Step
Functions
Amazon
S3
Amazon
DynamoDB
Custom
endpoints
Amazon
CloudWatch
Amazon
Elasticsearch
EC2
instance

GATEWAYS AND ROUTERS
• Choose suitable entry point for client
applications
• Single, custom client? Use the
AWS SDK
• Not end user facing? use regional
endpoints on API Gateway
• Discard uninteresting events ASAP
• S3 – Event prefix
• SNS – Message filtering (new!)

• Scrutinize the event
• Must have provenance i.e. “What happened for this notification
to occur?”
• Additional content – identifier or payload
• Remember payload constraints
• Async invocation is only 128K
• Avoid large responses like an image
SUCCINT INVOCATIONS

EXAMPLE - SWITCH TO BINARY
'use strict';
const co = require('co');
const Promise = require('bluebird');
const protobuf = Promise.prmisifyAll(require("protobufjs"));
const lib = require('./lib');
const fs = require('fs');
module.exports.handler = co.wrap(function* (event, context, callback) {
console.log(JSON.stringify(event));
let players = lib.genPlayers();
let root = yield protobuf.loadAsync("functions/player.proto");
let Players = root.lookupType("protodemo.Players");
let message = Players.create(players);
let buffer = Players.encode(message).finish();
const response = {
statusCode: 200,
headers: { 'Content-Type': 'application/x-protobuf' },
body: buffer.toString('base64'),
isBase64Encoded: true
};
http://theburningmonk.com/2017/09/using-protocol-buffers-with-api-
gateway-and-aws-lambda/
The same response in
Protocol Buffers is nearly
40% smaller compared to
default JSON

VS.
RESILIENT: USE AN EVENT STORE

CONCURRENCY vs LATENCY
Streams
• Maximum theoretical throughput:
# shards * 2 MB / (s)
• Effective theoretical throughput:
( # shards * batch size (MB) ) /
( function duration (s) * retries
until expiry)
• If put / ingestion rate is greater than
the theoretical throughput, consider
increasing number of shards while
optimizing function duration to
increase throughput
Everything else
• Maximum Processing rate :
Maximum concurrency / average
duration (events per second)
• Effective Processing rate :
Effective concurrency / average
duration (events per second)
• Use concurrency metric (new!) and
duration metric to estimate processing
time

THINK CONCURRENT, NOT TPS
Queue based
Simple
No event store
Stream based

RESILENT: RETRY POLICIES
• Understand retry policies
• Sync never retried
• Async retried 2 times
• Streams retried all the time
• Leverage Dead Letter Queues
• SQS or SNS for replays
• REMEMBER: Retries count as invokes

BUILD YOUR OWN
http://theburningmonk.com/2017/04/aws-lambda-3-pro-tips-for-working-with-kinesis-streams/

Serverless Architectures.pdf

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Serverless Architectures.pdf

Ähnlich wie Serverless Architectures.pdf (20)

Mehr von Amazon Web Services

Mehr von Amazon Web Services (20)

Serverless Architectures.pdf