AWS and Serverless Computing

Amazon Web Services and Serverless Apps
Roberto Casadei
Concurrent and Distributed Programming course
Department of Computer Science and Engineering (DISI)
Alma Mater Studiorum – Università of Bologna
June 4, 2019
R. Casadei AWS Serverless Apps on AWS 1/27

Outline
1 Amazon Web Services (AWS): Overview
2 Serverless Apps on AWS

Intro
Amazon Web Services (AWS) is a cloud computing platform, i.e., a platform of
web services offering solutions for computing, storing, and networking, at
different layers of abstraction
Services are charged for on a pay-per-use pricing model
As an AWS customer, you can choose among different data centers (regions)
As of 2019/05, AWS spans 66 Availability Zones within 21 geographic Regions around the world
Services are exposed through APIs: (1) HTTP, (2) web-based, (3) CLI, (4) SDK client

AWS Services (1/4)
https://docs.aws.amazon.com/—More than 90 services, e.g.:
Compute
Amazon EC2 (Elastic Compute Cloud): provides VMs
AWS Lambda: for serverless apps
Storage
Amazon S3 (Simple Storage Service): object storage
AWS Backup: to automate backup tasks across AWS services and on-premises
Database
Amazon DynamoDB: K/V, document store
Amazon RDS (Relational Database Service): managed RDBMS
Security, Identity, & Compliance
AWS IAM (Identity & Access Management)

AWS Services (2/4)
Machine Learning
Amazon Comprehend: uses NLP to extract insights from text
Amazon ML: provides GUI tools/wizards to ease creation of ML models
Amazon Translate
Management & Governance
AWS CloudFormation: helps create/provision of AWS infrastructure
declaratively/predictably/repeatedly
AWS Health: provides ongoing visibility of your AWS resources, services, and accounts
Networking & Content Delivery
Amazon API Gateway: for creating, publishing, maintaining, monitoring, and securing
REST and WebSocket APIs at any scale

AWS Services (3/4)
Analytics
Amazon Kinesis: to collect, process, and analyze video and data streams in real time
Amazon CloudSearch: for setting up search solutions for your website/app
AWS Glue: fully-managed ETL service
Amazon Redshift: data warehouse service
Application Integration
Amazon MQ: a managed message broker service for Apache ActiveMQ
Amazon SNS (Simple Notification Service): cloud-mediated notification service
Amazon SQS (Simple Queue Service): fully managed message queuing service
Internet of Things
AWS IoT Core: enables secure, bi-directional communication between Internet-connected
things and the AWS Cloud over MQTT and HTTP
AWS IoT Device Management: supports e.g. onboarding config, monitoring devices,
remote management etc.
AWS IoT Events: enables monitoring and triggers upon events

AWS Services (4/4)
Additionally:
AR & VR: Amazon Sumerian (for 3D scenes on the web), ...
Blockchain: Amazon Managed Blockchain
Business apps: Amazon Chime (for online meetings), ...
Customer Engagement: Amazon Connect (Contact-Center-as-a-Service)
Cryptography & PKI: AWS KMS (Key Management Service) (encryption keys), ...
Developer tools: AWS Cloud9 (cloud-based IDE), AWS CodeDeploy (deployment of
apps), ...
End User Computing: Amazon WorkSpaces (virtual desktops), ...
Game development: Amazon GameLift, Amazon Lumberyard
Media services: Amazon Elastic Transcoder (convert media ﬁles in S3 into formats
required by playback devices), ...
Migration & Transfer: services e.g. to migrate DB data from/to cloud
Mobile: AWS Device Farm (app testing service), ...
Robotics: AWS RoboMaker
Satellite: AWS Ground Station

How much does it cost?
Services are billed based on usage (invoiced on a monthly basis). For example:
Based on hours of usage – if you use a server for 61mins, usually it’s counted as 2hs.
Based on trafﬁc – Measure in GBs or num of requests.
Based on storage usage – Provisioned capacity or real usage.
AWS Simple Monthly Calculator: http://aws.amazon.com/calculator
AWS Budgets: you can create custom cost/usage budget alerts
Billing console: https://console.aws.amazon.com/billing/home
Billing example (x5 requests)

Free tier (as of May 2019)
https://aws.amazon.com/free/
Always free
AWS Lambda: 106
requests/month
Amazon DynamoDB: 25 GB storage
Amazon Glacier: 10 GB of long-term storage
…
12-month free (since subscription to AWS)
Amazon EC2: 750 hours/month
Amazon API Gateway: 106
ingress requests/month
Amazon RDS: 750 hours/month
AWS IoT: 250k messages/month
…

AWS Educate
https://aws.amazon.com/it/education/awseducate/
Free credits (annually renewable) for students and educators

Interacting with AWS
Web-based Management Console: https://console.aws.amazon.com
HTTP API
Example: EC2 Query API
https://ec2.amazonaws.com/?Action=RunInstances
&ImageId=ami-2bb65342
&MaxCount=3&MinCount=1
&Placement.AvailabilityZone=us-east-1a
&Monitoring.Enabled=true
&AUTHPARAMS
Command-line interface (CLI): aws ec2 run-instances ...
SDKs for multiple languages: Android, JS, Node.js, PHP, Ruby, Python, Java, .NET, Go.
$ npm install -D aws-sdk
AWS SDK for Node
const AWS = require('aws-sdk');
const ec2 = new AWS.EC2({region: 'us-east-1'});
Higher-level tools/services: e.g., AWS CloudFormation is an Infrastructure-as-Code
tool converts JSON/YAML blueprints (templates) into running infrastructure
{ infrastructure: { loadbalancer: {...}, cdn: {...}, database: {...}, dns : {...} }

Use AWS
Create an AWS Account and user
Create an AWS account: https://aws.amazon.com
Go to the AWS Management Console: https://console.aws.amazon.com
Enable billing alarms from Billing Dashboard and then create a billing alarm
Do NOT use the AWS root account: go to Services → IAM → Users → Add user and
create a user with “Programmatic access”, with AdministratorAccess policy.
Then, to make API calls (or use CLI) you need your user’s access keys.
CLI installation and initial setup
$ sudo pip install awscli
$ aws configure # configure credentials
# AWS Access Key ID [None]: XXXXXXXXXXXXXXXX
# AWS Secret Access Key [None]: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
# Default region name [None]: eu-central-1 (Alternatives: us-east-1..)
# Default output format [None]: json
$ aws help # Get available services
$ aws ec2 help # Get help for specific service
$ aws ec2 describe-regions help # Get help for specific action
When you aws configure, a ﬁle ~/.aws/credentials is created; then, when you run
a cmd, you may omit --profile and use the settings stored in the default proﬁle.
Command Format: aws <service> <action> [opts]

Outline
1 Amazon Web Services (AWS): Overview
2 Serverless Apps on AWS

Serverless » What
Serverless: a method of deploying and running apps on cloud infrastructure
Cloud execution model where pay-per-use + servers abstracted away
Serverless apps are event-driven, distributed, autoscalable
Providers: AWS Lambda, Google Cloud Functions, Azure Functions
Provider responsibilities: capacity planning, scaling, balancing, monitoring
Shouldn’t use when: always-up, websocket apps; latency is critical; ..
AWS Lambda
It runs code in response to events and automatically manages compute resources
Allows you to run functions written in Node.js, Python, C#, and JVM languages
Limits: 15 minutes max exec time (default 3secs); max 3GB memory (default 128MB)
Pricing: 0.2$ per million function execs + $0.000016 per GB of memory/month (for
storage of functions); see also free tier ○
AWS Lambda application development
Difﬁcult parts: deployment and function conﬁguration
Claudia is a Node.js library for deployment to AWS Lambda and API Gateway
Serverless Application Model (SAM), tool by AWS which uses AWS CloudFormation
Serverless Framework: similar to SAM, but supports other platforms (e.g., Azure)

Serverless » How it works
A serverless function runs only when triggered by an event
You pay only for its execution time; after exec, the function shuts down, while keeping its
trigger active.
Serverless app design: instead of having a server with API endpoints and business
logic, each part of your app is isolated to independent and autoscalable containers.
AWS services for serverless apps:
Lambda: compute service
API Gateway: accepts HTTP requests and routes them to other services
DynamoDB: autoscalable NoSQL DB
Example function
function lambdaFunction(event, context, callback) {
callback(null, 'Hello from AWS Lambda')
}
exports.handler = lambdaFunction;
AWS Lambda requires the module export to be an object of name handler
event keeps data passed by the service who triggered the function
Triggers examples: HTTP requests via API Gateway; changes in DynamoDB stores..
context contains data about your Lambda function: exec time, its trigger, etc.
callback is a way to reply (or error) to the trigger with arguments

What should I do, manually?
1) Control access to an API with IAM permissions:
https://docs.aws.amazon.com/apigateway/latest/developerguide/
setting-up.html
permissions.html
2) Create a REST API with Lambda Integrations in Amazon API Gateway
apigateway-getting-started-with-rest-apis.html
Lambda proxy integration (recommended): the entire client request is sent to the backend
Lambda function as is, mapped to the input event parameter of the function; the Lambda
function’s output is returned to the client as is.
Lambda non-proxy integration (custom): you conﬁgure the way parameters, headers, and
body of the client requests and responses are translated to/from Lambda functions

Amazon API Gateway
Amazon API Gateway is an AWS service for creating, publishing, maintaining,
monitoring, and securing REST and WebSocket APIs at any scale
API Gateway handles all the tasks involved in accepting and processing up to millions of
concurrent API calls, including trafﬁc management, authZ and access control, monitoring,
API version management, and routing to backend services (e.g., EC2, Lambda, ..)
Pricing (as of June 2019)
https://aws.amazon.com/api-gateway/pricing/
Free tier (ﬁrst 12-month)—per month: 1M REST API calls; 1M msgs & 750k connection
mins for Websocket APIs
REST APIs (US east): 3.5–1.5$ per million calls; 0.0020$/hour per 0.5GB cache
Data transfer (US-east Ohio): you’ll be charged at the EC2 data transfer rate
Data transfer IN to EC2 from Internet: 0$
Data transfer OUT from EC2 to Internet: 0$/GB up to 1GB/month; 0.09$/GB for next
999GB/month; ...
Data transfer OUT from EC2 to AWS: 0.01$/GB to US east Virginia; 0.02$/GB to EU (Frankfurt);
...

Claudia
Claudia is a Node.js library, built on top of AWS SDK, that eases the deployment of
Node.js projects to AWS Lambda and API Gateway. Components:
1) Claudia (Cmd-line tool): allowing creation and update of functions from terminal
2) Claudia API Builder: for creation of APIs for API Gateway
It automates all the error-prone deployment and conﬁguration tasks.
Creating and updating the function with a single command
Reducing boilerplate, allowing you to focus on your work
Managing multiple versions easily

Installing Claudia
$ npm install [--save-dev|-g] claudia claudia-api-builder
# If installed locally, run claudia via: node_modules/.bin/claudia
Claudia uses the AWS SDK for Node.js to function, and so requires AWS profile keys
Create a new AWS profile
Create a profile: AWS Console => Users tab => IAM section => Add user
− Attach existing policies: IAMFullAccess (to enable Claudia to create execution roles for
your lambdas; otherwise you need to use --role with claudia create);
AWSLambdaFullAccess (for Claudia deployments); AmazonAPIGatewayAdministrator (for
Claudia API); AmazonDynamoDBFullAccess; AmazonAPIGatewayPushToCloudWatchLogs
AWS roles/policies are important for production
− Once you confirm, you get an access key ID and a secret access key for your new user.
Finally, configure your profile with the AWS CLI
$ aws configure

Hello World Claudia1
$ npm install -g claudia
$ mkdir hello-world && cd hello-world
$ npm init
exports.handler = function (event, ctx, callback) {
console.log("Function: ", ctx.functionName, ctx.functionVersion);
console.log("Event data: ", JSON.stringify(event));
console.log("Request: ", ctx.awsRequestId);
console.log("Remaining time: ", ctx.getRemainingTimeInMillis());
callback(null, 'hello world');
};
$ claudia create --region us-east-1 --handler lambda.handler
$ claudia test-lambda
# change lambda code
$ claudia update
If name in package.json is XXX, Claudia creates an AWS role XXX-executor (with a
policy log-writer) and a function with name XXX
1https://claudiajs.com/tutorials/hello-world-lambda.html

Building APIs with Claudia
Claudia API Builder uses API Gateway proxy pass-through to capture all the HTTP
request details and structure them in a JS developer-friendly way.
$ npm install --save claudia-api-builder
api.js
const Api = require('claudia-api-builder');
const api = new Api();
api.get('/', () => 'Welcome to my API');
api.get('/hello/{x}', (req) => { return "hello " + req.pathParams.x; });
api.post('/act', (req) => { createSomething(req.body); }, {
success: 201, // "201 Created" status code on success
error: 400 // "400 Bad request" status code on error
});
module.exports = api; // export your Claudia API Builder instance
$ claudia create # Create a new lambda function
--region eu-central-1 # AWS region for deployment
--api-module api # api.js is the API entry point
# { "lambda": { ... }, // Lambda function info
# "api": { ..., "url": "<API-BASE-URL>" } }

How Claudia deploys your API (on claudia create)

DynamoDB
DynamoDB is a fully managed, autoscaled, propetary NoSQL DB provided by AWS
Data model: data tables (schemaless); attributes (one is primary key); items
Creating tables: you need to deﬁne the region for your table and the provisioned
throughput (i.e., the RD and WR capacity that should be reserved for you app)
For autoscaling, you need to deﬁne min and max capacity
aws dynamodb create-table
--table-name orders
--attribute-definitions AttributeName=orderId,AttributeType=S
--key-schema AttributeName=orderId,KeyType=HASH
--provisioned-throughput ReadCapacityUnits=1,WriteCapacityUnits=1
--region eu-central-1
--query TableDescription.TableArn
--output text
Output is the Amazon Resource Name (ARN) of the newly created table.
SDK API: in Node AWS SDK, use AWS.DynamoDB.DocumentClient to work asyncly
with DynamoDB
$ npm install --save aws-sdk

Working with DynamoDB (1/3)
Add IAM policy to allow Lambdas to communicate with DynamoDB
aws iam put-role-policy --policy-document file://./dynamodb.json
--role-name <lambda-executor> --policy-name OrdersApiDynamoDB
You can ﬁnd the value for -role-name in claudia.json
dynamodb.json: a JSON ﬁle that describes policies
{ "Version": "2012-10-17",
"Statement": [{
"Action": ["dynamodb:Scan", "dynamodb:DeleteItem",
"dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem"
,
"dynamodb:GetRecords", "dynamodb:GetShardIterator",
"dynamodb:DescribeStream", "dynamodb:ListStreams"],
"Effect": "Allow",
"Resource": "*"
}]
}

Programmatically add items
const AWS = require('aws-sdk');
const docClient = new AWS.DynamoDB.DocumentClient();
const uuid = require('uuid');
function createOrder(req) {
if (!req || !req.product) throw new Error('...');
return docClient.put({ TableName: 'orders',
Item: { orderId: uuid(), product: req.product, orderStatus: 'pending' }
})
.promise()
.then((res) => { console.log('Order saved:',res); return res; })
.catch((err) => { console.log('Err:',err); throw err; } );
};
module.exports = createOrder;
All AWS SDK classes have a promise() method that can, instead of default
callback behavior, return a promise.
Claudia API Builder expects a Promise for async operations

List all items from CLI
$ aws dynamodb scan --table-name orders
--region eu-central-1 --output json
CRUDs
function getOrders(orderId) {
if (typeof orderId === 'undefined')
return docClient.scan({TableName: 'pizza-orders'})
.promise().then(r => r.Items);
return docClient.get({TableName: 'pizza-orders', Key: {orderId: orderId}})
.promise().then(res => res.Item);
}
function updateOrder(orderId, opts) {
// ...
return docClient.update({TableName:'pizza-orders', Key:{orderId:orderId},
UpdateExpression: 'set pizza = :p, address=:a',
ExpressionAttributeValues: { ':p': opts.pizza, ':a': opts.address },
ReturnValues: 'ALL_NEW'
}).promise().then((res) => return res.Attributes);

Wrap-up
Key points
Cloud apps leverage services on the “cloud” through APIs
Understand the layers of abstractions (I/P/S-aaS)
When using a service, understand what is provided
Understand the pricing
Exercises
1. Take a look at the examples in the following repository:
https://bitbucket.org/unibo_disi/pcd-lab-aws-claudiajs
2. Read the docs to understand the pricing for DynamoDB:
https://aws.amazon.","lambda:
GetAccountSettings"com/dynamodb/pricing/on-demand/

References (1/1)
[1] AWS Documentation. https://docs.aws.amazon.com/. [Online; accessed 2019-06].
[2] S. Stojanovic and A. Simovic. Serverless Applications with Node.Js: Using AWS Lambda and
Claudia.Js. Manning Publications Company, 2019. ISBN: 9781617294723. URL:
https://books.google.it/books?id=e7rAswEACAAJ.
[3] M. Wittig, A. Wittig, and B. Whaley. Amazon Web Services in Action. Manning, 2018. ISBN:
9781617295119. URL: https://books.google.it/books?id=-LRotAEACAAJ.
R. Casadei Appendix References 28/27

AWS and Serverless Computing

More Related Content

Similar to AWS and Serverless Computing (12)

More from Roberto Casadei (20)

Recently uploaded (20)

AWS and Serverless Computing