--- title: "Serverless development with Serverless Framework" url: "https://www.bekk.christmas/post/2019/09/serverless-development-with-serverless-framework" authors: ["Henrik Wingerei"] published: "2019-12-09" updated: "2024-11-07T13:05:28Z" language: "en-US" type: "article" tags: ["Sky"] --- # Serverless development with Serverless Framework If you've read [yesterdays](https://thecloud.christmas/2019/8) post about ZEIT Now, you've already seen one of many approaches to develop and deploy a serverless API. In this post we will have a look at an alternative you can use to develop serverless applications, namely [Serverless Framework](https://serverless.com/). Serverless Framework can be used to develop, deploy and test your serverless applications targeted towards different cloud providers, or as they describe themselves: "The complete solution for building & operating serverless applications." Let's have a look on what this framework is all about. ## In short Serverless Framework is a Node.js CLI for defining, deploying, and testing serverless applications across multiple cloud providers, with AWS as the main example here. A small serverless.yml file can describe services, functions, events, and resources, and Serverless Framework turns that into a deployed API backed by Lambda, API Gateway, and DynamoDB. - **For:** Backend developers building serverless applications on AWS - **Good to know beforehand:** Basic familiarity with AWS Lambda, API Gateway, and DynamoDB _AI-generated_ Serverless Framework is a node CLI tool which can be installed via npm by running `npm install -g serverless`. As mentioned the framework can be used against many different cloud [providers](https://serverless.com/framework/docs/providers/). AWS, Azure and Google is supported, but also more "exotic" providers like [Cloudflare Workers](https://workers.cloudflare.com/), [OpenWhisk](https://openwhisk.apache.org/) and [Alibaba Cloud](https://www.alibabacloud.com/). In this post we will focus on how to use Serverless Framework on AWS. ## Serverless Framework concepts Serverless Framework has four main concepts which you should know before we look on some example code. **Service** You can think of this as an application or as a ... yeah, service. It typically consists of multiple functions ([Lambda](https://docs.aws.amazon.com/lambda/) in our case) and different resources as databases, [S3 buckets](https://aws.amazon.com/s3/), [API gateway](https://aws.amazon.com/api-gateway/) and other managed services. **Functions** On AWS this is equivalent to AWS Lambda. A single piece of code deployed to AWS which triggers based on different kinds of events in the cloud ecosystem. In your service you can define multiple functions, and you can deploy and invoke them via the Serverless Framework CLI. **Events** Events are what trigger your functions you have defined in your service. On AWS this can be anything from a HTTP request from API Gateway, an image uploaded to a S3 bucket, a new entry in a [DynamoDB](https://aws.amazon.com/dynamodb) table, a [CloudWatch](https://aws.amazon.com/cloudwatch/) alert and [lots more](https://serverless.com/framework/docs/providers/aws/events/). **Resources** These are any resources which is needed by your service, and typically what your functions use. Typical resources may be a database like DynamoDB , S3 bucket or a [SNS](https://aws.amazon.com/sns/) topic. ## What does this look like in practice? Below is an example of a service defined in a file called `serverless.yml`. The service is an API which you can use to create new christmas wishes, and return a list of all your wishes. ```yaml service: wishlist provider: name: aws runtime: nodejs12.x region: eu-central-1 iamRoleStatements: - Effect: "Allow" Action: - dynamodb:Scan - dynamodb:PutItem Resource: "arn:aws:dynamodb:eu-central-1:*:*" functions: wishlist: handler: wishlist.wishlist events: - http: GET wishes newWish: handler: newWish.newWish events: - http: POST wishes resources: Resources: WishlistTable: Type: AWS::DynamoDB::Table Properties: TableName: wishlist AttributeDefinitions: - AttributeName: id AttributeType: S - AttributeName: wish AttributeType: S KeySchema: - AttributeName: id KeyType: HASH - AttributeName: wish KeyType: RANGE ProvisionedThroughput: ReadCapacityUnits: 1 WriteCapacityUnits: 1 ``` We start by defining the name for our service, `wishlist`. Then we define which provider we would like to use, `aws`, runtime for our functions, `nodejs`, and which region we would like our service to be deployed to, `eu-central-1`. The `iamRoleStatements` declares that our functions are allowed to query and add items to our DynamoDB table. The last block, `resources`, defines our DynamoDB table where our wishes are stored. The functions block could do with a more detailed explanation. ```yaml functions: wishlist: handler: wishlist.wishlist events: - http: GET wishes newWish: handler: newWish.newWish events: - http: POST wishes ``` Here we declare two functions. The `wishlist` function is a function that returns all wishes from our DynamoDB table. In the `events` block we define that this should trigger on a http GET request with the path `/wishes`. The `newWish` function will, as the name applies, create a new wish in our DynamoDB table. It triggers on a http POST request with the path `/wishes`. The actual code for the two functions is listed below. **List all wishes** ```js const AWS = require("aws-sdk"); const dynamoDb = new AWS.DynamoDB.DocumentClient(); module.exports.wishlist = async () => { try { const result = await dynamoDb.scan({ TableName: "wishlist" }).promise(); return { statusCode: 200, body: JSON.stringify(result), }; } catch (e) { return { statusCode: 500, body: e.message, }; } }; ``` **Add new wish** ```js const AWS = require("aws-sdk"); const dynamoDb = new AWS.DynamoDB.DocumentClient(); module.exports.newWish = async (event) => { try { const result = await dynamoDb .put({ TableName: "wishlist", Item: JSON.parse(event.body) }) .promise(); return { statusCode: 200, body: JSON.stringify(result), }; } catch (e) { return { statusCode: 500, body: e.message, }; } }; ``` ## So, how do we actually deploy our service to the cloud? To deploy our service just run the command `sls deploy`. Serverless Framework will deploy all your functions and necessary infrastructure, and print the URL for your brand new serverless API at the bottom. ```bash $ sls deploy ....... Serverless: Stack update finished... Service Information service: wishlist stage: dev region: eu-central-1 stack: wishlist-dev resources: 17 api keys: None endpoints: GET - https://ny8fxydfd5.execute-api.eu-central-1.amazonaws.com/dev/wishes POST - https://ny8fxydfd5.execute-api.eu-central-1.amazonaws.com/dev/wishes functions: wishlist: wishlist-dev-wishlist newWish: wishlist-dev-newWish layers: None ``` So what actually happend here? Under the hood, Serverless Framework creates a [CloudFormation](https://aws.amazon.com/cloudformation/) template and uploads that to AWS. CloudFormation will take this template and provision all of the necessary services, deploy the functions and link all the services nicely together. In our case the framework created a DynamoDB table, two functions and an API Gateway. With just a small yaml file, two functions and some shell commands, you suddenly have an API which autoscales automatically and you only pay when the API is in use. I think that's pretty cool! # What's next? This was only a simple example of what Serverless Framework can do for you when developing serverless applications. In addition to create more complex applications, the framework can be used to test your functions locally or trigger them directly in the cloud, and you can use the framework for accessing logs and other metrics. Serverless Framework also comes with a [Dashboard](https://serverless.com/dashboard/) which gives you a "A unified view of your Serverless applications, featuring monitoring, alerting, deployments & much more". All in all, Serverless Framework is a nice alternative to use for developing serverless applications. It supports multiple cloud providers (although the support is limited on some of them) and comes with lots of [plugins](https://serverless.com/plugins/) to help you speed up your development. It has some limitations, and `yaml` can be frustrating to debug some times, but I will absolutely recommend you to try it out if you're interested in developing serverless applications! ## Relevant resources recommended by the author - [Serverless Framework](https://serverless.com/) - [Code and architecture examples](https://serverless.com/examples/) - [Serverless Framework's blog](https://serverless.com/blog/)