Serverless applications with AWS

© 2019, Amazon Web Services, Inc. or its affiliates. All rights reserved.
Serverless Applications with
AWS
Javier Ramirez
@supercoco9
AWS Technical Evangelist

Development transformation at Amazon:
1994-2001 2002+
Monolithic architecture +
hierarchical organization
Decoupled services +
Two-pizza teams

Two-pizza team responsibility Venn diagram
Responsible for
THEIR
PRODUCT
Deployment tools
CI/CD tools
Monitoring tools
Metrics tool
Logging tools
APM tools
Infrastructure
provisioning tools
Security tools
Database management
tools
Testing tools
….
Not responsible for
*
*Unless their product belongs in the blue

Responsible for Not responsible for
*
NOT
THEIR
PRODUCT
*Unless their product belongs in the blue
Application development
Infrastructure management
Application configuration
Pipeline configuration
Alarms
Runbooks
Testing
Compliance
Roadmap tracking
Goals tracking
On-call
Support escalation
….

Determining the right balance
The more time spent on operational tasks, the
less time spent on development tasks

Responsible for
THEIR
PRODUCT
Not responsible for
NOT
THEIR
PRODUCT
Can we shift more from a
team’s responsibility to the
platform/shared services?

© 2018, Amazon Web Services, Inc. or its Affiliates. All rights reserved. Amazon Confidential and Trademark
7
AWS operational responsibility models
On-Premises Cloud
Less More
Compute Virtual Machine
EC2 Elastic Beanstalk AWS LambdaFargate
Databases MySQL MySQL on EC2
RDS MySQL RDS Aurora Aurora Serverless DynamoDB
Storage Storage
S3
Messaging ESBs
Amazon MQ Kinesis SQS / SNS
Analytics
Hadoop Hadoop on EC2 EMR Elasticsearch Service Athena

Serverless means …

Serverless means …
No servers to provision
or manage
Scales with usage
Never pay for idle Availability and fault
tolerance built in

No server is easier to manage than "no
server.”
Werner Vogels—Amazon CTO

Serverless means:

Serverless means:
Greater agility
Less overhead
Better focus
Increased scale
More flexibility
Faster time to market

13
AWS
Lambda
AWS
Fargate
Amazon
API Gateway
Amazon
SNS
Amazon
SQS
AWS
Step Functions
COMPUTE
DATA STORES
INTEGRATION
Amazon Aurora
Serverless
Amazon
S3
Amazon
DynamoDB
AWS
AppSync

Event-driven compute
Functions as a service
Serverless FaaS

Serverless applications
Services (anything)
Changes in
data state
Requests to
endpoints
Changes in
resource state
Event source Function
Node.js
Python
Java
C#
Go
Ruby
BYOR (Bring your own runtime)NEW!

AWS Lambda runtime API and layers
Features that allow developers to share, discover, and deploy both libraries
and languages as part of their serverless applications
Runtime API enables
developers to use
Lambda with any
programming language.
Layers let functions
easily share code.
Upload layer once,
reference within any
function.
Layers promote
separation of
responsibilities, lets
developers focus on
writing business logic.
Combined, runtime API
and layers allow
developers to share any
programming language
or language version with
others

Anatomy of a Lambda function
Handler() function
Function to be executed
upon invocation
Event object
Data sent during
Lambda function
Invocation
Context object
Methods available to
interact with runtime
information (request ID,
log group, more)
public String handleRequest(Book book, Context context) {
saveBook(book);
return book.getName() + " saved!";
}

Fine-grained pricing
Buy compute time in 100ms
increments
Low request charge
No hourly, daily, or monthly
minimums
No per-device fees
Never pay for idle
Free Tier
1M requests and 400,000 GBs of compute.
Every month, every customer.

AWS Lambda release history
LambdaPreview
Announcement
re:Invent2014
2015 2016 2017 2018
?
*As of October 2018, does not include region launches

Common Lambda 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
IT
Automation
• Policy engines
• Extending
AWS services
• Infrastructure
management

23
Changes to the architectural patterns

24
When the impact of change is small,
release velocity can increase
Monolith
Does everything
Microservices
Does one thing

25
MICROSERVICE
API
API
MICROSERVICE
MICROSERVICE
EVENT
API
MICROSERVICE
EVENT
API
MICROSERVICE
APPLICATION
Mobile client
Client
IoT
PERSISTENCE PERSISTENCE
Microservices architectures

26
Event-driven architectures

27
Decouple state from code using messaging
Queues
Simple
Fully-managed
Any volume
Pub/sub
Simple
Fully-managed
Flexible
Amazon Simple
Queue Service
Amazon Simple
Notification
Service
Messaging
Synchronization
Rapid
Fully-managed
Real-time
Amazon
CloudWatch
Events

28
And data streams
Ingest
Data streams
Data processing
Real-time
Data Store
Microservices
Performance at
scale
Fast and Flexible
Amazon Kinesis
Data Streams
Amazon
Dynamo DB
Data Stream Capture

29
APIs are the front door of microservices

Amazon API Gateway
Create a unified
API frontend for
multiple micro-
services
Authenticate and
authorize
requests to a
backend
DDoS protection
and throttling for
your backend
Throttle, meter,
and monetize API
usage by third-
party developers

API Gateway
Internet
Mobile apps
Websites
Services
AWS Lambda
functions
AWS
API Gateway
Cache
Endpoints on
Amazon EC2
Amazon
CloudWatch
monitoring
Amazon
CloudFront
Any other
AWS service
YOUR VPC
Endpoints in
Your VPC
Regional API endpoints
All publicly
accessible endpoints
AWS Lambda
functions

API Gateway WebSockets
Invoke AWS services
like Lambda, Kinesis, or any
HTTP endpoint based on
message content
Build real-time two-way
communication applications
chat, alerts and notifications,
and streaming dashboards
Fully managed APIs
to handle connections and
messages transfer between
users and backend services
Pay for what you use
based on connection minutes
and messages transferred
Stateful connection Stateless connection
Amazon API Gateway
WebSockets API
Public
endpoints on
Amazon EC2
Lambda
functions
Any other
AWS service
All publicly
accessible
endpoints
Amazon
Kinesis
Mobile apps
Chat
AWS IoT
devices
Dashboards

REST API versus GraphQL
GraphQLTraditional data-fetching
/posts
/postInfo
/postJustTitle
/postsByAuthor
/postNameStartsWithX
/commentsOnPost
GraphQL
query {
getPostNameComments {
postID
postName
postAuthor
commentID
commentText
}
}
With a REST-based interface, I
might need to make several calls
sequentially based on responses
from the previous call With GraphQL I can make one call

AWS AppSync
Real-time and offline data using GraphQL
Real-time
collaboration
Offline programming
model with sync
Your data sources
Fine-grained
access control

Serverless web application with API Gateway
API Gateway handles all your
application routing. It can
handle authentication and
authorization, throttling,
DDOS protection, and more.
Amazon S3
API Gateway
Lambda runs all the logic
behind your website and
interfaces with databases,
other backend services, or
anything else your site needs.
AWS Lambda
Amazon Simple Storage
Service (Amazon S3) stores all
of your static content: CSS,
JS, images, and more. You
would typically front this with
a CDN such as CloudFront.
Amazon
CloudFront

Serverless web application with AWS AppSync
AWS AppSync handles all of your
GraphQL query resolution. It can
retrieve data from data sources
such as Amazon DynamoDB,
Amazon Elasticsearch Service,
Lambda, and HTTP endpoints.
Data sources and/or Lambda
provide customer data or
backend logic.
Amazon S3
AWS Lambda
Amazon
CloudFront AWS AppSync
Amazon S3 stores all your
static content: CSS, JS,
images, more. You would
typically front this with a CDN
such as CloudFront.

40
Track status of data
and execution
Remove
redundant code
Build workflows to orchestrate everything

Coordination by function chaining

“I want
try/catch/finally”
“I want to select tasks
based on data”
“I want to retry
failed tasks”
A
B C
A
?
“I want to
sequence tasks”
BA
“I want to run tasks
in parallel”
CBA
Is this you?

Coordination must-haves
• Scales out
• Doesn’t lose state
• Deals with errors/timeouts
• Easy to build & operate
• Auditable
• Keep orchestration out of code

Application lifecycle in AWS Step Functions
Visualize in the
Console
Define
in JSON
Monitor
Executions

Execute One or One Million
Start
End
HelloWorld
Start
End
HelloWorld
Start
End
HelloWorld
Start
End
HelloWorld
Start
End
HelloWorld
Start
End
HelloWorld
Start
End
HelloWorld
Start
End
HelloWorld

Maximum Execution Time
AWS Lambda
Functions
15 minutes
AWS Step Functions
State Machines
1 year

O
pen
Source
Apache
License
https://states-language.net/spec.html

Seven state types
Task A single unit of work
Choice Adds branching logic
Parallel Fork and join the data across tasks
Wait Delay for a specified time
Fail Stops an execution and marks it as a failure
Succeed Stops an execution successfully
Pass Passes its input to its output

© 2018, Amazon Web Services, Inc. or Its Affiliates. All rights reserved.
State Example: Task
@technovangelist

State Example: Choice
@technovangelist

State Example: Succeed/Fail
@technovangelist

State Example: Pass
@technovangelist

State Example: Wait
@technovangelist

State Example: Parallel
@technovangelist

Task states for any compute
Long poll
Traditional server
Request or
Callback
Worker requests
tasks from Step
Functions
Step Functions
invokes the Task

Supported Service Integrations

Service Integration Patterns
Request Response
Call a service and let Step Functions progress to the next state
immediately after it gets an HTTP response.
"Send message to SNS": {
"Type":"Task",
"Resource":"arn:aws:states:::sns:publish",
"Parameters":{
"TopicArn":"arn:aws:sns:us-east-1:123456789012:myTopic",
"Message":"Hello from Step Functions!"
},
"Next":"NEXT_STATE"
}

Run a Job (.sync)
Call a service and have Step Functions wait for a job to complete.
"Manage Batch task": {
"Type": "Task",
"Resource": "arn:aws:states:::batch:submitJob.sync",
"Parameters": {
"JobDefinition": "arn:aws:batch:us-east-2:123456789012:job-definition/testJobDefinition",
"JobName": "testJob",
"JobQueue": "arn:aws:batch:us-east-2:123456789012:job-queue/testQueue"
},
"Next": "NEXT_STATE"
}

Wait for a Callback (.waitForTaskToken)
Call a service with a task token and have Step Functions wait until that
token is returned along with a payload.
"Send message to SQS": {
"Type": "Task",
"Resource": "arn:aws:states:::sqs:sendMessage.waitForTaskToken",
"Parameters": {
"QueueUrl": "https://sqs.us-east-2.amazonaws.com/123456789012/myQueue",
"MessageBody": {
"Message": "Hello from Step Functions!",
"TaskToken.$": "$$.Task.Token"
}
},
"Next": "NEXT_STATE"
}

Configure a Heartbeat Timeout for a Waiting Task
"Send message to SNS": {
"Type":"Task",
"Resource":"arn:aws:states:::sns:publish.waitForTaskToken",
"HeartbeatSeconds": 600,
"Parameters":{
"TopicArn":"arn:aws:sns:us-east-1:123456789012:myTopic",
"Message":"Let me know if everything is ok!"
},
"Next":"NEXT_STATE"
}
Set heartbeat timeout
interval to 10 minutes

Send task heartbeat/success/failure in JavaScript
const stepfunctions = new AWS.StepFunctions();
let data;
data = await stepfunctions.sendTaskHeartbeat({
taskToken: 'TASK_TOKEN'
}).promise();
data = await stepfunctions.sendTaskSuccess({
output: 'YOUR_OUTPUT',
}).promise();
data = await stepfunctions.sendTaskFailure({
error: 'ERROR_CODE’,
cause: 'EXPLANATION’,
}).promise();
Create service object
Send heartbeat
Send success + output
Send failure + error/cause
or

About WHOSAY
• WHOSAY is the largest and most
trusted influence marketer in the
world. Founded in 2010, WHOSAY is
built from the best of entertainment,
technology and advertising. WHOSAY
powers influence marketing
campaigns across all verticals and
utilizes every level of celebrity and
influencer, delivering measurably
superior results to other social and
mobile advertising.
• Step Functions is a part of the
WHOSAY MATCH application for
searching and identifying influencers
that match with brand campaigns

• When a celeb social media
post happens…
• Kick off a scheduled sequence
of analytics runs
Analytics data collection problem

Analytics data collection solution

Takeaways
“We can set it and
forget it, with no
maintenance, and it
is easy to support.
It was very easy to
get going.”
“Step Functions and
Lambda are a perfect
combination for building
event-driven and delayed
applications, even when
tasks need to run longer
than 5 minutes.”

About Thomson Reuters
• Global organization, HQ
in Toronto, 5,000+
employees
• Preparing news video
clips for global
broadcast and online
delivery

• Transcode 350 clips/day into
14 formats, fast
• It’s all done with FFmpeg. The
processing time is just about
100% of the video length
• Aargh!
Video processing problem

• 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

About Frame.io
• Frame.io is the world’s leading
workflow management platform for
video teams
• From small production agencies to
major broadcast media companies,
video teams of all sizes rely on
Frame.io to streamline their media
review and collaboration process
• Frame.io uses Step Functions to
process media, transcode to
different formats, create
thumbnails, and much more

1. Sometimes Lambda is best, sometimes ECS
2. Previously, all tied together with
pub/sub and
procedural code
3. Aargh!
Media transcoding problem

1. Use state machines to pick
execution engine
2. Use CloudWatch Events for
messaging and triggering
Step Functions
Media transcoding solution

Let’s peek at the code!
"Encoder Decider": {
"Type": "Choice",
"Default": "Run ECS Encoder",
"Choices": [
{
"Next": "Run Lambda Encoder",
"And": [
{
"Variable": "$.asset.size",
"NumericLessThanEquals": 2000000000
},
{
"Variable": "$.asset.duration_ms",
"NumericLessThanEquals": 10000
}
]
}
]
}

"Run ECS Encoder": {
"Type": "Task",
"Resource": "arn:…SubmitECSTask",
"Retry": [
{
"ErrorEquals": [
"NoResourceInCluster"
],
"IntervalSeconds": 5,
"MaxAttempts": 720,
"BackoffRate": 1.0
}
],
"ResultPath": "$.task",
"Next": "Wait X Seconds"
}
"Wait X Seconds": {
"Type": "Wait",
"SecondsPath": "$.task.wait_time",
"Next": "Get ECS Task Status"
},
"Get ECS Task Status": {
"Type": "Task",
"Resource": "arn:…ECSTaskStatus",
"Next": "ECS Task Complete?",
"ResultPath": "$.task.status"
}

"ECS Task Complete?": {
"Type": "Choice",
"Choices": [
{
"And": [
{
"Variable": "$.task.status",
"StringEquals": "FAILED"
},
{
"Variable": "$.task.attempt",
"NumericGreaterThanEquals": 3
}
],
"Next": "Fire Failed Event"
},
{
"StringEquals": "FAILED",
"Next": "Run ECS Encoder"
},
{
"StringEquals": "SUCCEEDED",
"Next": "Fire Successful Event"
}
],
"Default": "Wait X Seconds"
},
"Fire Successful Event": {
"Type": "Task",
"Resource": "aws:…SendSuccessfulEvent",
"End": true
},
"Fire Failed Event": {
"Type": "Task",
"Resource": "aws:…SendFailedEvent",
"End": true
}
These fire
CloudWatch
Events

Build PCI and HIPAA compliant serverless applications!
Serverless platform services that can be used in both:
AWS
Lambda
Amazon
S3
Amazon
CloudFront
Amazon
DynamoDB
Amazon
Kinesis
Data
Streams
Amazon
Cognito
Amazon API
Gateway
Amazon
SNS

Where do you ...
https://secure.flickr.com/photos/stevendepolo/57491920?

Start with a framework
AWS
Chalice

AWS Serverless Application Model (SAM)
AWS CloudFormation extension optimized for
serverless
New serverless resource types: functions, APIs,
and tables
Supports anything AWS CloudFormation supports
Open specification (Apache 2.0)
https://aws.amazon.com/serverless/sam

AWS Command Line Interface (AWS CLI)
CLI tool for local development, debugging, testing,
deploying, and monitoring of serverless applications
Supports API Gateway “proxy-style” and Lambda service
API testing
Response object and function logs available on your local
machine
Uses open source docker-lambda images to mimic
Lambda’s execution environment such as timeout, memory
limits, runtimes
Can tail production logs from CloudWatch logs
https://aws.amazon.com/serverless/sam

Infrastructure as code
✓
Make infrastructure
changes repeatable
and predictable
✓
Release infrastructure
changes using the
same tools as code
changes
✓
Replicate production
environment in a
staging environment
to enable continuous
testing

Infrastructure as code
Declarative
I tell you
what I need
I tell you
what to do
Imperative

Infrastructure as code best practices
✓
Infrastructure
and application
in the same
source repository
For example:
AWS CloudFormation
HashiCorp Terraform
✓
Deployments
include
infrastructure
updates

Infrastructure as code for serverless apps
For example:
AWS Serverless Application Model (SAM)
Serverless Framework

SAM template
AWSTemplateFormatVersion: '2010-09-09’
Transform: AWS::Serverless-2016-10-31
Resources:
GetFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.get
Runtime: nodejs8.10
CodeUri: src/
Policies:
- DynamoDBReadPolicy:
TableName: !Ref MyTable
Events:
GetResource:
Type: Api
Properties:
Path: /resource/{resourceId}
Method: get
MyTable:
Type: AWS::Serverless::SimpleTable
Just 20 lines to create:
• Lambda function
• IAM role
• API Gateway
• DynamoDB table

SAM CLI
https://github.com/awslabs/aws-sam-cli

© 2019, Amazon Web Services, Inc. or its affiliates. All rights reserved.S U M M I T
Nested apps to simplify solving recurring problems
Standard
Component
TweetSource:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:...
SemanticVersion: 2.0.0
Parameters:
TweetProcessorFunctionName: !Ref MyFunction
SearchText: '#serverless -filter:nativeretweets’
Custom
Business
Logic

https://github.com/danilop/first-step-functions

Centrica
Energy & services company: UK,
Ireland, & North America
Focus areas: Energy supply,
services, connected home,
distributed energy & power, energy
marketing, & trading
Over 25MN customer accounts and
£28 BN annual revenue

British Gas business—Digital
View
bills
Quote &
buy
Meter
readings
Pay

Old monolithic architecture
Monolith Highly coupled, server-side architecture
All changes needed comprehensive testing
Infrastructure monitoring, maintenance, &
upgrades
Slow & expensive
Introduction of new components & services
Very difficult
Monthly releases
Cycle time was in months & quarters

Approach
Proof of
concept
Engage Pilot Expand
Learn and
familiarize
Microservice ported
to Lambda
CloudFormation
Manual deployment
Serverless working
group:
Enterprise
architecture
Security
Networks
Service design &
introduction
Thin & deep slice
Guest meter read
journey
Phased rollout with
failover
Team: one
architect, two
developers, one QA
Amazon Cognito
Agent access
More journeys to
Lambdas
Database—Amazon
Relational Database
Service (Amazon
RDS)

Benefits
Cost reduction
An order of magnitude reduction in operational cost
Focus
Focus on the core business logic & customer experience without worrying about the
underlying infrastructure
Agility
Short release cycles with cycle time in days & weeks

aws.amazon.com/serverless

Obrigado
Javier Ramirez
@supercoco9
AWS Technical Evangelist

Serverless applications with AWS

More Related Content

Similar to Serverless applications with AWS (20)

More from javier ramirez (20)

Recently uploaded (20)

Serverless applications with AWS