The document provides an overview of serverless application development including bundling and deploying functions, continuous integration and delivery, versioning and stages, and monitoring. It discusses using AWS services like Lambda, API Gateway, CodeBuild, CodePipeline, CloudFormation, and CloudWatch for building, deploying, and monitoring serverless applications.
Innovate and Collaborate- Harnessing the Power of Open Source Software.pdf
Serverless Application Deep Dive
1. Deep Dive on Serverless Application
Development
Prakash Palanisamy, Solutions Architect
23-05-2017
2. Agenda
What is a Serverless Application?
What do we need to think about when building one?
• Bundling and Deploying
• Continuous Integration & Continuous Delivery
• Versioning, Stages, Variables
• Metrics, Monitoring, Logs, and Profiling
4. No servers to provision
or manage
Scales with usage
Never pay for idle Availability and fault
tolerance built in
Serverless means…
5. Serverless application
EVENT SOURCE SERVICES (ANYTHING)
Changes in
data state
Requests to
endpoints
Changes in
resource state
FUNCTION
Node.js
Python
Java
C#
6. API Gateway
Internet
Mobile Apps
Websites
Services
AWS Lambda
functions
AWS
API Gateway
Cache
Endpoints on
Amazon EC2
All publicly
accessible
endpoints
Amazon
CloudWatch
Monitoring
Amazon
CloudFront
Any other
AWS service
7. Amazon S3 Amazon
DynamoDB
Amazon
Kinesis
AWS
CloudFormation
AWS CloudTrail Amazon
CloudWatch
Amazon
Cognito
Amazon SNSAmazon
SES
Cron events
DATA STORES ENDPOINTS
CONFIGURATION REPOSITORIES EVENT/MESSAGE SERVICES
Example event sources that trigger AWS Lambda
… and a few more with more on the way!
AWS
CodeCommit
Amazon
API Gateway
Amazon
Alexa
AWS IoT AWS Step
Functions
8. 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
IT
Automation
• Policy engines
• Extending
AWS services
• Infrastructure
management
10. Building a deployment package
Node.js & Python
• .zip file consisting of
your code and any
dependencies
• Use npm/pip to
install libraries
• All dependencies
must be at root level
Java
• Either .zip file with all
code/dependencies,
or standalone .jar
• Use Maven / Eclipse
IDE plugins
• Compiled class &
resource files at root
level, required jars in
/lib directory
C# (.NET Core)
• Either .zip file with all
code/dependencies,
or a standalone .dll
• Use NuGet /
VisualStudio plugins
• All assemblies (.dll)
at root level
11. Create templates of your infrastructure
CloudFormation provisions AWS resources
based on dependency needs
Version control/replicate/update templates like
code
Integrates with development, CI/CD,
management tools
JSON and YAML supported
AWS CloudFormation
15. SAM template
AWSTemplateFormatVersion: '2010-09-09’
Transform: AWS::Serverless-2016-10-31
Resources:
GetHtmlFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: s3://sam-demo-bucket/todo_list.zip
Handler: index.gethtml
Runtime: nodejs4.3
Policies: AmazonDynamoDBReadOnlyAccess
Events:
GetHtml:
Type: Api
Properties:
Path: /{proxy+}
Method: ANY
ListTable:
Type: AWS::Serverless::SimpleTable
Tells CloudFormation this is a SAM
template it needs to “transform”
Creates a Lambda function with the
referenced managed IAM policy,
runtime, code at the referenced zip
location, and handler as defined. Also
creates an API Gateway and takes care
of all mapping/permissions necessary.
Creates a DynamoDB table with 5 Read
& Write units
16. AWS commands – Package & Deploy
Package
•Creates a deployment package (.zip file)
•Uploads deployment package to an Amazon S3 bucket
•Adds a CodeUri property with S3 URI
Deploy
•Calls CloudFormation ‘CreateChangeSet’ API
•Calls CloudFormation ‘ExecuteChangeSet’ API
18. Function versioning and aliases
• Versions = immutable copies of
code + configuration
• Aliases = mutable pointers to
versions
• Development against $LATEST
version
• Each version/alias gets its own
ARN
• Enables rollbacks, staged
promotions, “locked” behavior for
client
Lambda Function
Version $LATEST
Lambda Function
Version 123
Lambda Function
DEV Alias
Lambda Function
BETA Alias
Lambda Function
PROD Alias
19. Lambda Environment Variables
Key-value pairs that you can dynamically pass to your
function
Available via standard environment variable APIs such as
process.env for Node.js or os.environ for Python
Can optionally be encrypted via KMS
• Allows you to specify in IAM what roles have access to the keys
to decrypt the information
Useful for creating environments per stage (i.e. dev,
testing, production)
20. API Gateway Stages
Stages are named links to a deployed
version of your API
Recommended for managing API lifecycle
• dev/test/prod
• alpha/beta/gamma
Support for parameterized values via
stage variables
21. API Gateway Stage Variables
• Stage variables act like environment variables
• Use stage variables to store configuration values
• Stage variables are available in the $context object
• Values are accessible from most fields in API Gateway
• Lambda function ARN
• HTTP endpoint
• Custom authorizer function name
• Parameter mappings
22. Manage Multiple Versions and Stages of your APIs
Works like a source repository – clone your API to create a new version:
API 1
(v1) Stage (dev)
Stage (prod)
API 2
(v2)
Stage (dev)
23. Stage variables and Lambda alias for stages
Using Stage Variables in API Gateway together with Lambda function Aliases
helps you manage a single API configuration and Lambda function for multiple
stages
myLambdaFunction
1
2
3 = prod
4
5
6 = beta
7
8 = dev
My First API
Stage variable = lambdaAlias
Prod
lambdaAlias = prod
Beta
lambdaAlias = beta
Dev
lambdaAlias = dev
25. Fully managed build service that compiles source code,
runs tests, and produces software packages
Scales continuously and processes multiple builds
concurrently
You can provide custom build environments suited to
your needs via Docker images
Only pay by the minute for the compute resources you
use
Launched with CodePipeline and Jenkins integration
AWS CodeBuild
27. version: 0.1
environment_variables:
plaintext:
"INPUT_FILE": "saml.yaml”
"S3_BUCKET": "”
phases:
install:
commands:
- npm install
pre_build:
commands:
- eslint *.js
build:
commands:
- npm test
post_build:
commands:
- aws cloudformation package --template $INPUT_FILE --s3-
bucket $S3_BUCKET --output-template post-saml.yaml
artifacts:
type: zip
files:
- post-saml.yaml
- beta.json
Variables to be used by phases of
build
Examples for what you can do in the
phases of a build:
• You can install packages or run
commands to prepare your
environment in ”install”.
• Run syntax checking,
commands in “pre_build”.
• Execute your build
tool/command in “build”
• Test your app further or ship a
container image to a repository
in post_build
Create and store an artifact in S3
buildspec.yml Example
28. What service and release step corresponds with which tests?
UI
Service
Unit
Third Party
Tooling
AWS CodeBuild
BuildTest
29. Continuous delivery service for fast and
reliable application updates
Model and visualize your software release
process
Builds, tests, and deploys your code every time
there is a code change
Integrates with third-party tools and AWS
AWS CodePipeline
34. Deploy via CodePipeline
Pipeline flow:
1. Commit your code to a source code repository
2. Package in CodeBuild
3. Use CloudFormation actions in CodePipeline to
create or update stacks via SAM templates
Optional: Make use of ChangeSets
4. Make use of specific stage/environment
parameter files to pass in Lambda variables
5. Test our application between stages/environments
Optional: Make use of Manual Approvals
36. • Gain system-wide visibility into resource utilization,
application performance, and operational health
• Collect and track metrics with CloudWatch Metrics
• Collect and monitor log files with CloudWatch Logs
• Set alarms and send messages to SNS
• Automatically react changes via CloudWatch Events
Amazon CloudWatch
37. Lambda
• Default (free) metrics:
• Invocations
• Duration
• Throttles
• Errors
• Iterator Age
• Create custom metrics from inside
your application using “put-metric”
API call.
CloudWatch Metrics
API Gateway
• Default (free) metrics at Stage
level:
• Count
• 4XXError
• 5XXError
• Latency
• IntegrationLatency
• CacheHitcount
• CacheMissCount
• Detailed metrics
• Same set of metrics at method
level
• Can be enabled globally or only for
specific methods
38. CloudWatch Logs
Lambda Logging
• Logging directly from your code
• Basic request information included
API Gateway Logging
• 2 Levels of logging, ERROR and INFO
• Optionally log method request/body content
• Set globally in stage, or override per method
Log Pivots
• Build metrics based on log filters
• Jump to logs that generated metrics
40. • Identify performance bottlenecks and errors
• Pinpoint issues to specific service(s) in your
application
• Identify impact of issues on users of the
application
• Visualize the service call graph of your
application
AWS X-Ray
44. Putting it all together!
• Bundling and Deploying
• Continuous Integration & Continuous Delivery
• Versioning, Stages, Variables
• Metrics, Monitoring, Logs, and Profiling
45. 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.