How To Use Serverless Framework And Fauna To Build Serverless Application.

Quick summary 〜 we’ll explore the different part/tools needed to build serverless application with Fauna and Serverless framework. We’ll cover the different working parts of an application that makes it serverless.

To begin this learning, we’ll start with the underlying concept of serverless — serverless applications, what made it different from our regular applications. Then cover the roles Fauna and Serverless Framework play within serverless applications.

Introduction

The first thought when serverless is mentioned for developers who are not familiar with the term would be that it doesn’t require servers. Glad to let you know that your application would still require servers to function. A simple explanation to serverless is:

This allows the serverless provider to provide the services needed by the users to write and deploy code without the hassle of worrying about the underlying infrastructure needed for the application.

Within this tutorial, we’ll discuss serverless as function-as-a-service, a serverless backend service allowing developers to write and update modular pieces of code on the fly, and these pieces of code would be executed in response to certain events within the application. The approach would be that we’ll write our code in the form of functions that would handle different tasks or requests within the application. So when we deploy our functions, we’ll invoke them in the format of an event.

This gives serverless applications the ability to scale dynamically per request, and won’t require any capacity planning or provisioning for the application.

That brings us to a common issue that we face when building serverless applications, available popular cloud databases are yet to have this support level of elasticity — you have to pay for capacity you don’t use. Then there’s also the lack of operations like joins, indexes, authentication, and other capabilities necessary to build a rich application. This brings Fauna into the picture.

Introduction To Fauna And Serverless Framework

Fauna uses a pre-existing infrastructure to build web applications without the usual setting-up of custom settings. Fauna as Serverless Cloud is a globally distributed database that requires no provisioning. The capacity for our applications is metered and also available on-demand — we’ll only pay for what we use within our serverless application. Fauna is a flexible, developer-friendly, transactional database delivered as a secure and scalable cloud API with native GraphQL. This gives the flexibility that provides us with reasons never to worry about database provisioning, scaling, sharing, replication, or correctness.

Serverless Framework is open source software that builds, compiles, and packages code for serverless deployment, and then deploys the package to the cloud. Serverless Framework helps develop, deploy, troubleshoot and secure our serverless applications with radically less overhead and cost by using the Serverless Framework. The Serverless Framework consists of an open source CLI and a hosted dashboard. Together, they provide you with full serverless application lifecycle management.

Enough of the talk, let’s dive into exploring the different parts of serverless application with Fauna and Serverless Framework.

Prerequisite

  • Basic knowledge of Fauna, yet not compulsory.
  • Have NodeJS v12.0 or a higher version installed on our local machine.
  • Basic knowledge of Serverless framework, yet not compulsory.

Get started with Serverless Framework

Our first approach would be installation of Serverless framework globally on our local machine to quickly set up and provision serverless functions on multiple cloud providers.

We can install Serverless framework as a standalone binary, or with npm. We’ll cover both installations for preference sake.

Install as a standalone binary:

MacOS/Linux

curl -o- -L https://slss.io/install | bash

The above command will install the latest version, just run the command in your terminal.

curl -o- -L https://slss.io/install | VERSION=2.21.1 bash

The above command shows how to install a specific version by setting a VERSION variable.

Window

We’ll use one of the Windows’ package manager, Chocolatey.

choco install serverless

Install through npm:

npm install -g serverless

The above command installs the serverless CLI through the node package manager, npm.

Once the installation is through, it will look for AWS keys in the normal environment variables.

Get started with Fauna

We’ll start by signing in into our existing fauna account to get started with Fauna, or register for a new account as a new user using either email credentials or using an existing Github account. Register for a new account here. Once the account is created or signed in, we’ll be welcomed by the dashboard screen. There’s also fauna shell if you love the shell environment. It easily allows you to create and/or modify resources on Fauna through the terminal.

To use fauna shell, follow the below command:

npm install --global fauna-shell
fauna cloud-login

Now we’re ready to start exploring our data and experiment with queries in the Fauna dashboard. Open the dashboard, it will look something like this:

Now we are logged in or have our accounts created, we can go ahead to create our Fauna. We’ll go through following simple steps to create the new fauna database using Fauna services. We start with naming our database. In this tutorial, we will name our database debt_tracker.

With the database created, the next step is to create a new data collection from the Fauna dashboard. Navigate to the Collection tab on the side menu and create a new collection by clicking on the NEW COLLECTION button.

We’ll then go ahead to give whatever name is well suited to our collection. Here we will also call it debt_tracker.

Next step is to grap our API key from the Security link on the sidebar. Click on the new key button to generate the API key we would be using for our application.

The next screen will display the API key for the database we just created. Note to copy and store the API key at once. The key disappears once you leave the current page to another page.

Get started with Our Serverless Application

Now we’ll learn the different working parts of building a serverless application so that you can easily go ahead and build a full application from the simple code units demonstrated within this tutorial.

Let’s start by cloning the serverless-crud project that would easily help us with a demo code template to perform CRUD functions with our application.

serverless install --url https://github.com/faunadb/serverless-crud

Side note 〜 please do well to rename some of the files to represent the name of the application you’re building. Within this tutorial, the base name will change from todos to debt_tracker

Once done with the cloning, we’ll change directory, cd into the service, the cloned folder and then install all the dependencies needed within the folder.

cd serverless-crud
npm install

Once all the packages are fully installed, we will navigate into the serverless.yml file and then look for the field with the name, MY_FAUNADB_SERVER_SECRET and replace the value with our API key we’ve copied and saved previously. Also do the same as above for the package.json file.

The serverless.yml file, which simply is a config file that is specific to Serverless framework, contains metadata of the utilities that will be looked into soon. Our focus will be mainly on the functions field and all its values. This contains the necessary information on how our serverless functions are structured to perform:

functions:
create:
handler: handler.create
events:
- http:
path: debt_tracker
method: post
cors: true
readAll:
handler: handler.readAll
events:
- http:
path: debt_tracker
method: get
cors: true
readOne:
handler: handler.readOne
events:
- http:
path: debt_tracker/{id}
method: get
cors: true
update:
handler: handler.update
events:
- http:
path: debt_tracker/{id}
method: put
cors: true
delete:
handler: handler.delete
events:
- http:
path: debt_tracker/{id}
method: delete
cors: true

The above code, easily explained, means look for a folder functions that contains a file handler.js. Within this file are defined utilities, functions, that are defined and exported for specific actions. From the above code, we’ve five serverless functions that will perform the CRUD operation to our database that we had set up earlier within this tutorial. So let’s navigate into the handler.js file to explore the functions.

Within the handler.js file is where our serverless functions which were defined within the same working directory with the handler.js are imported to make different specific requests to the database.

("use strict");

const debt_trackerCreate = require("./todos-create.js");
const debt_trackerReadAll = require("./todos-read-all.js");
const debt_trackerReadOne = require("./todos-read-one.js");
const debt_trackerUpdate = require("./todos-update.js");
const debt_trackerDelete = require("./todos-delete.js");

module.exports.create = (event, context, callback) => {
debt_trackerCreate(event, (error, result) => {
const response = {
statusCode: 200,
headers: {
"Access-Control-Allow-Origin": "*"
},
body: JSON.stringify(result)
};
context.succeed(response);
});
};

module.exports.readAll = (event, context, callback) => {
debt_trackerReadAll(event, (error, result) => {
const response = {
statusCode: 200,
headers: {
"Access-Control-Allow-Origin": "*"
},
body: JSON.stringify(result)
};
context.succeed(response);
});
};

module.exports.readOne = (event, context, callback) => {
debt_trackerReadOne(event, (error, result) => {
const response = {
statusCode: 200,
headers: {
"Access-Control-Allow-Origin": "*"
},
body: JSON.stringify(result)
};
context.succeed(response);
});
};

module.exports.update = (event, context, callback) => {
debt_trackerUpdate(event, (error, result) => {
const response = {
statusCode: 200,
headers: {
"Access-Control-Allow-Origin": "*"
},
body: JSON.stringify(result)
};
context.succeed(response);
});
};

module.exports.delete = (event, context, callback) => {
debt_trackerDelete(event, (error, result) => {
const response = {
statusCode: 200,
headers: {
"Access-Control-Allow-Origin": "*"
},
body: JSON.stringify(result)
};
context.succeed(response);
});
};

The first function will take an object data and create a debt document within our database for us automatically. The second function reaches out to the database and fetches all the debt documents we have created. While for the third, fourth and fifth functions will fetch, update or delete a particular debt document with the ID provided for it.

Now we have made all these available, the next would be to deploy our application to any cloud provider of your choice. And simply perform API requests against the exposed endpoints within our application.

To create a debt document, run the command:

curl -X POST https://XXXX.execute-api.region.amazonaws.com/dev/debt_tracker --data '{ "debt" : "Owing the UN a visit" }'

To read all the debt documents, run the command:

curl https://XXXX.execute-api.region.amazonaws.com/dev/debt_tracker

To read one of the debt documents, run the command with an ID provided:

curl https://XXXX.execute-api.region.amazonaws.com/dev/debt_tracker/<id>

To update one of the debt documents, run the command with an ID provided:

curl -X PUT https://XXXX.execute-api.region.amazonaws.com/dev/debt_tracker/<id> --data '{ "debt" : "Owing my travel agency" }'

To delete one of the debt documents, run the command with an ID provided:

curl -X DELETE https://XXXX.execute-api.region.amazonaws.com/dev/debt_tracker/<id>

This covers the samples to what our request to the endpoints would look like.

Conclusion

I will love to say congrats for making it to the end of this tutorial. As we’ve built this project and looking forward to building more projects using a serverless architecture, the choice of what tools/framework to use will always fall to Fauna and the Serverless.com framework with any cloud services provider. The endless benefits we can always look forward to, like the example of serverless code dynamically provisioning resources using FauanDB’s multi-tenant QoS features, and the easy integration of Fauna with other serverless components.

Resources

Technical Author | Software Engineer