Lazy Panda

Developer

Posts
57
Comments
48
Likes
76
Posts
57
Comments
48
Likes
76
sidebar

Create serverless REST API using AWS Lambda API Gateway RDS postgres with Nodejs and Typescript

Creating REST API is very common for web applications and mobile apps. Once it is created, suddenly you need to think, about which server you are going to put the code. Then several questions will arise based on application performance, accessibility, cost, flexibility, and what not. AWS serverless will help you to reduce your certain questions list and get proper answers about them. 

 

Serverless works as a Functions-as-a-Service (FaaS) which offers low cost, no server management, a inherently scalable architecture, quick deployment and update.

Let's Begin...

Prerequisite:

  • You need to create a NodeJS with Typescript code for REST APIs.
  • Should have an AWS account.
  • It would be good to have a custom domain for REST endpoints.
  • Should be installed PostgresSQL locally.

 



Points will be covered in this tutorial

  1. NodeJs with Typescript code creation
  2. Enable serverless & other necessary npm packages installation
  3. AWS RDS Postgres DB creation
  4. Configuring YAML file & handler creation for lambda
  5. Connect node js with typescript code with Postgres
  6. Deploy & custom domain addition
  7. Test & Error discussion

NodeJS with Typescript Code creation

Initially, I started with simple nodejs, then I thought the same to do using Typescript with Nodejs. As I have started my career with Strongly typed languages like java & Objective C, So it becomes easy to pick up TypeScript with NodeJs. A complete Production-ready REST API creation using NodeJS & Typescript tutorial has been created previously, feel free to check this up. 

Also, the boilerplate code base has been uploaded to GitHub. You can find it here.

 


Enable serverless & other necessary npm packages installation

After downloading the application, start with installing npm packages. By using -g flag the serverless package will install globally.

npm install -g serverless

Also install @types/aws-lambdaserverless-offline, serverless-deployment-bucket as well. We'll use AWS Lambda as the computing service. An AWS Lambda function is basically a container. Once the Lambda is invoked, the container spins up and runs the code.

Along with installation, modify the scripts section in the package.json file like the below - 

"deploy": "npm run build && sls deploy --stage dev",

"start-offline": "npm run build && serverless offline --noTimeout"


AWS RDS Postgres DB creation

Login to your AWS console and navigate to the RDS window and select PostgresSQL, Version, Obviously for Free tire. Provide DB instance identifier, master username & password. Under the connectivity section, please choose public access as yes, so that you can connect AWS RDS to your locally installed PostgresSQL DB. Also, you can import/export your dump DB file to AWS PostgreSQL DB as well. 

Once you click on Create Database, it will take about 10 min to create it. So please wait and once it's status Available, navigate to the details page and keep a few items to be noted in a separate file like notepad or text editor. 

The following snapshot might help you to understand better - 

rds-postgress-available

 

 

Please copy the highlighted Endpoint and open your locally installed PostgresSQL DB. 

rds-postgress-local

 

Once AWS RDS PostgreSQL connected successfully, I created a tutorial table and inserted a few data into that table too, like below.

create-table-schema

If you have any other DB schema (dump) file, that can also be imported into PostgreSQL by running the following command.

pg_restore --verbose --clean --no-acl --no-owner -h <<DB endpoint>> -U <<User Name>> -d <<DB name>> latest.dump

Example: 

pg_restore --verbose --clean --no-acl --no-owner -h tutorial.xcderf12345.ap-south-1.rds.amazonaws.com -U master -d tutorial latest.dump


 

Configuring YAML file & handler creation for lambda

Once you set up / install PostgresSQL locally on your computer and connected with AWS RDS, it's time to create YAML and handler files to your nodejs with the Typescript codebase. The serverless framework can help you to get a scaffold project, but I would suggest creating the files by yourself so that you will get a clear idea on it. Create one serverless.yml file in the project root folder.

As you have seen, in the custom section at the top, I am reading the secrects.json file, and I am loading environment variables and passing them to the environment section. Let's have a look at what the secrets.json file looks like as well.

Next, you need to create a handler.ts file, and placed the following code over there - 

 

Once you modified your code and updated it with business logic, you can build and run it using the serverless-offline command.

npm run start-offline

And you could see the node application build successfully and it provides an x-API-key and the endpoint. You need to pass the x-API-key as a header to access the just build REST API. 

postman-rest-api-serverless


 

 

Connect node js with typescript code with Postgres

Once your REST API build & run perfectly with local data source, now its time to connect with PostgreSQL from nodejs & typescript code. To connect with DB, you need to install few npm packages to make a DB connection and execute queries. If you need details of node with Postgres you can check the node-postgres site.

Please install the following two npm packages - 

npm install --save-dev pg

npm install --save-dev @types/pg

The code refers to connect with Postgres with nodejs & typescript. 


Deploy & custom domain addition

 

Once your APIs are working perfectly with serverless-offline, you can deploy the code to the serverless lambda function by using a single command.

npm run deploy

The Serverless framework makes deployments quick and painless. It will take care of bundling up, push all code to the S3 bucket and from there it will send it to the lambda function. The following screenshot you will get from your terminal.

rest-api-serverless-deployPlease keep the x-api-key and pass it as a header from postman to check the API is working or not. 

For Custom Sub Domain - you can create a sub domain from API Gateway, and add subdomain like tutorial.lazypandatech.com, and saved it. 

rest-api-serverless-deploy

Also set API Mapping there as well, like below 

route53-record-set

Once you Saved it, it will appear in home page. Now you need to open route53 to create a record. Then select a simple route, Define a simple record and 

route53-record-set

After defining record set, wait for 10 min to reflect it. For more information about custom domains and deployment, you can check here as well.


Test & Error discussion

Now you can open postman, and execute the endpoint and you could see the response. The following error you may encounter during serverless configuration time or deployment time. 

Error 1: Bucket is not there

To solve this error you need to add the serverless-deployment-bucket as a plugin and mentioned it in your serverless.yml. Also, you need to add the bucket name. Please check the above section for yaml configuration.

npm i serverless-deployment-bucket

Error 2Invalid API identifier specified 

To solve this error, please check the proper endpoint path and make sure you are passing correct x-api-key as header.

Error 3: 429 Too many requests

I have faced this issue couple of times after deploying the code in Lambda functions. I re-deploy the rest API code and got separate x-api-key. Then after it works fine for me.

Error 3: 502 Bad Gateway Or Internal server error

To solve this error, open AWS RDS and select the DB instance name, navigate to Connectivity & Security. There you could see the VPC security Groups. 

rds-security-groupPlease click it, and select Inbound option and Edit it.

rds-security-group

rds-security-group

After allowing anywhere, you could see proper response in postman. 

This is an ever-evolving architecture. With the rise of a serverless relational database, the possibilities are endless in creating entirely serverless infrastructure. I’ve tried my best to explain the process of creating a proper API. 

You could find the complete codebase in GitHub.

Thanks & Happy Coding!

- Lazy Panda