Going serverless

Going
Serverless
@jagthedrummer - OctoLabs.com/railsconf2016

!
!

Serverless?

Serverless

⚡ serverless.com ⚡
framework for building
web, mobile and IoT applications exclusively on
AWS Lambda, API Gateway, and related services

Vendor Lock-in !

OPS

Scale

Money

Jeremy Green
Consultant, Author, SaaSer
@jagthedrummer
jeremy@octolabs.com

IndependentConsultingManual.com
Remarq.io
Other Interests:
Drumming, Photography, and Brewing

clickfunnels.com

The Pieces

Lambda

API Gateway

DynamoDB

RDS

CloudFormation

Putting it all together

Coding in the
browser?

! → " → #

Serverless to the rescue
serverless.com
Manage Lambda, API Gateway and CloudFormation
via code and CLI instead of via GUI.
docs.serverless.com

Getting
started

First step
→ Create a new AWS account!
→ Srsly!

$ npm install -g serverless

$ sls project create

_______ __
| _ .-----.----.--.--.-----.----| .-----.-----.-----.
| |___| -__| _| | | -__| _| | -__|__ --|__ --|
|____ |_____|__| ___/|_____|__| |__|_____|_____|_____|
| | | The Serverless Application Framework
| | serverless.com, v0.5.5
`-------'

Serverless: Initializing Serverless Project...
Serverless: Enter a name for this project: (serverless-bkqhpg) going-serverless-demo

Serverless: Enter a new stage name for this project: (dev)

Serverless: For the "dev" stage, do you want to use an existing Amazon Web Services
profile or create a new one?
> Existing Profile
Create A New Profile
Serverless: Select a profile for your project:
> lambdatest
Serverless: Creating stage "dev"...

Serverless: Select a new region for your stage:
> us-east-1
us-west-2
eu-west-1
eu-central-1
ap-northeast-1
Serverless: Creating region "us-east-1" in stage "dev"...

Serverless: Deploying resources to stage "dev" in region "us-east-1" via Cloudformation
(~3 minutes)...
Serverless: Successfully deployed "dev" resources to "us-east-1"
Serverless: Successfully created region "us-east-1" within stage "dev"
Serverless: Successfully created stage "dev"
Serverless: Successfully initialized project "going-serverless-demo"

$ cd going-serverless-demo
$ tree
.
├── admin.env # AWS Profiles - gitignored
├── package.json # npm package file
├── s-project.json # project and author data
├── s-resources-cf.json # CloudFormation template
└── _meta # meta data for stage/regions config and variables - gitignored
   ├── resources
   │   └── s-resources-cf-dev-useast1.json
   └── variables
   ├── s-variables-common.json
   ├── s-variables-dev-useast1.json
   └── s-variables-dev.json
3 directories, 8 files

What should
we build?

Let's build
something real*

LPaaSleft-pad as a service*
* OK, "real" !

$ sls function create left-pad

Serverless: Please, select a runtime for this new Function
> nodejs4.3
python2.7
nodejs (v0.10, soon to be deprecated)

Serverless: For this new Function, would you like to create an
Endpoint, Event, or just the Function?
> Create Endpoint
Create Event
Just the Function...
Serverless: Successfully created function: "left-pad"

$ tree left-pad/
left-pad/
├── event.json # sample event for testing function locally
├── handler.js # function handler
└── s-function.json # data for your lambda function, endpoints and event sources

! it!

$ sls dash deploy

$ sls dash deploy
_______ __
| _ .-----.----.--.--.-----.----| .-----.-----.-----.
| |___| -__| _| | | -__| _| | -__|__ --|__ --|
|____ |_____|__| ___/|_____|__| |__|_____|_____|_____|
| | | The Serverless Application Framework
| | serverless.com, v0.5.5
`-------'
Serverless: Select the assets you wish to deploy:
left-pad
* function - left-pad
* endpoint - left-pad - GET
- - - - -
> Deploy
Cancel

Serverless: Deploying the specified functions in "dev" to the following regions: us-east-1
Serverless: ------------------------
Serverless: Successfully deployed the following functions in "dev" to the following regions:
Serverless: us-east-1 ------------------------
Serverless: left-pad (going-serverless-demo-left-pad):
arn:aws:lambda:us-east-1:852612687751:function:going-serverless-demo-left-pad:dev
Serverless: Deploying endpoints in "dev" to the following regions: us-east-1
Serverless: Successfully deployed endpoints in "dev" to the following regions:
Serverless: us-east-1 ------------------------
Serverless: GET - left-pad -
http://serverless.octolabs.com/left-pad

Anatomy of a
Lambda
Function

left-pad/handler.js
'use strict';
module.exports.handler = function(event, context, cb) {
return cb(null, {
message: 'Go Serverless! Your Lambda function executed successfully!'
});
};

event
used to pass data to the function
{
string: 'test',
padding: 10
}

context
provides runtime information
{
getRemainingTimeInMillis: function(){},
functionName: 'handler',
functionVersion: 'xyz',
awsRequestId: '12345',
identity: {...},
clientContext: {...}
}

callback
used to return data or an error
// signature
callback(error,data);
// call with error
callback("some error message");
//or call with data
callback(null, someData);

$ cd left-pad
$ npm init
...
$ npm install left-pad --save

left-pad/handler.js
let leftpad = require('left-pad');
};

left-pad/handler.js
var string = event.string || "",
padding = event.padding || 0,
};

left-pad/handler.js
paddedString = leftpad(string,padding),
payload = { paddedString };
};

left-pad/handler.js
paddedString = leftpad(string,padding),
payload = { paddedString };
return cb(null, payload);
};

left-pad/s-function.json (simpliﬁed)
{
"runtime": "nodejs4.3",
"handler": "handler.handler",
"memorySize": 1024
"endpoints": [
]
}

{
"memorySize": 1024
"endpoints": [
{
"path": "left-pad",
"method": "GET",
"requestTemplates": {
"application/json": {
}
}
}
]
}

{
"memorySize": 1024
"endpoints": [
{
"path": "left-pad",
"method": "GET",
"requestTemplates": {
"application/json": {
"string": "$input.params('string')",
"padding": "$input.params('padding')"
}
}
}
]
}

$ sls dash deploy
...
Serverless: GET - left-pad -
http://serverless.octolabs.com/left-pad

http://serverless.octolabs.com/left-pad?
string=test&padding=10
{
"paddedString":" test"
}

Testing
$ npm install -g mocha
$ npm install --save-dev chai

left-pad/handler_test.js
var expect = require("chai").expect;
var handler = require("./handler.js");
describe('handler', function(){
it('returns the right thing', function(){
});
});

var event = {
string: 'test',
padding: 10
};
});
});

var event = {
string: 'test',
padding: 10
};
var context = {};
});
});

var event = {
string: 'test',
padding: 10
};
var context = {};
var cb = function(error, response){
expect(error).to.be.null;
expect(response.paddedString).to.equal(" test");
};
});
});

$ mocha handler_test.js
handler
✓ returns the right thing
1 passing (9ms)

What about
Ruby?@jagthedrummer - OctoLabs.com/railsconf2016

mruby-hello-world$ tree .
.
├── event.json
├── handler.js
├── handler.rb # A ruby script! :D
├── mruby # The mruby executable
└── s-function.json

mruby-hello-world/handler.js
var spawn = require('child_process').spawn;
module.exports.handler = function(event, context, callback) {
var child = spawn('./mruby', ['handler.rb', JSON.stringify(event, null, 2)]);
}

var rubyOutput = [];
child.stdout.on('data', function (data) { rubyOutput.push(data.toString()); });
child.stderr.on('data', function (data) { rubyOutput.push(data.toString()); });
}

mruby-hello-world/handler.rb
puts 'Hello, Lambda from Ruby!'
puts ARGV

http://serverless.octolabs.com/mruby-hello-world
{
"message":"We're back from ruby land",
"rubyOutput":["Hello, Lambda from Ruby!n["{}"]n"]
}

This is not
production
ready!

How fast is all
of this?

API Gateway Latency

Remote API call timing comparison

Lambda timing comparison

Wrapping Up

AWS Provides the
Building Blocks

Serverless Provides
Structure and Process

You provide the

Thank you!
(And thanks to Click Funnels)
octolabs.com/railsconf2016

Bonus Slides

Lambda Pricing !
Charged by:
→ # of requests
→ length of execution

Lambda Request Pricing
First 1 million requests per month are free
$0.20 per 1 million requests thereafter
($0.0000002 per request)

Lambda Execution Pricing
First 400,000 GB-seconds per month are free
$0.00001667 for per GB-second thereafter

GB-second
=
LambdaMemoryInGigabytes * ExecutionTime
1GB * 1sec = 1 GB-sec
0.5GB * 2sec = 1 GB-sec
0.5GB * 0.5sec * 4executions = 1 GB-sec

Lambda Pricing Example
3 million executions per month
512MB of memory
1 second execution time
$18.74 per month

512MB of memory
0.5 second execution time
$6.24 per month

512MB of memory
0.2 second execution time
$0.40 per month

Lambda Lifecycle
!
1. You upload your code
2. Amazon doesn't do anything

Lambda Cold Start ❄
1. AWS Receives Execution Request
2. Container is provisioned
3. Container is loaded with your code
4. Your code begins execution
5. Your code returns a result

Time Passes
!
(But not too much)

Lambda Container Reuse
1. AWS Receives Execution Request
2. Your code begins execution
3. Your code returns a result

Possible Architectures
→ Monolithic
→ Microservices
→ Nanoservices

Monolithic Architecture
→ A single Lambda
handles multiple concerns
→ Multiple API Gateway
endpoints map to one Lambda
→ Cold start will be slow

Microservices Architecture
→ A single Lambda function for each concern/
resource
→ Multiple API Gateway enpoints map
to multiple Lambdas
→ Cold start not as slow

Nanoservices Architecture
→ A single Lambda function
for each logical function
→ One-to-one mapping between
API Gateway & Lambda
→ Fastest cold start

Going serverless

More Related Content

What's hot (18)

Viewers also liked (20)

Similar to Going serverless (20)

Recently uploaded (20)

Going serverless