AWS Node JS MongoDB Deployment: 2 Easy Methods

MongoDB database offers various APIs that, when executed in a Node.JS app, provide access to create and perform numerous operations in the database. Node.JS is highly compatible with MongoDB and is a superior technology match for creating an effective backend for web applications that serve multiple clients simultaneously.

Together they can easily handle a large amount of data while concurrently managing the client’s request.

In this article, you will learn how to deploy the AWS Node JS MongoDB application properly. 

Prerequisites

• Basic understanding of deploying and backend development.

What is Node.JS?

Developed in 2009 by Ryan Dahl, Node.JS is asynchronous runtime designed to create highly scalable network applications. It uses JavaScript, a programming language, to concurrently deals with server-side requests. Node.JS is an open-source, event-driven platform that enterprises can use on OS X, Linux, and Microsoft Windows.

The rich library of JavaScript modules is equipped with built-in functions that simplify web application development. The non-blocking I/O architecture makes it lightweight and efficient, ideal for real-time data-focused applications.

NodeJS is the perfect technology for working with I/O bound apps, real-time data streaming, JSON APIs, Single Page Applications (SPAs), and data-intensive real-time applications (DIRT).

Key Features of Node.JS

Here are some features of Node.js:

1) Asynchronous Nature

Asynchronous means not waiting for an operation to complete but instead registering a listener to increase responsiveness. All the APIs in Node.JS are asynchronous, meaning Node.JS never waits to receive data from an API. Once Node.JS accesses an API, the server jumpers on to the next one while tracking the response of the previous API request.

The I/O non-blocking (asynchronous) way of working uses a notification mechanism called events that are callback functions. A callback function gets executed asynchronously only once when the event gets triggered by the event handler.

2) Single-Threaded

The Node.JS runtime environment employs single-threaded architecture with event looping for increasing scalability. The JavaScript event-based architecture inspires the Node.JS backend processing unit with a callback function working. Typically servers create a limited number of threads for managing and processing client requests. However, in Node.JS, the event mechanism allows it to deal with requests in an I/O non-blocking manner to make the backend more scalable.

3) Scalable

Scalability is one of the most critical concerns in software development. Multiple features of Node.JS like asynchronous nature, I/O non-blocking mechanism, and single-threaded event looping architecture contribute to its scalability. The runtime environment can manage requests concurrently and has cluster modules that handle the optimal load balancing of all the active CPU cores.

Understanding MongoDB

Under the guidance of SSPL (Server Side Public License), MongoDB is an open-source, document-based database created for data storage of large-scale applications. Released in February 2009, it is categorized as a NoSQL (Not only SQL) database since the data storage or retrieval process is not in the table format.

You can create various applications with MongoDB and other programming languages like C, C++, C#, Go, Java, Node.JS, Perl, Python, Ruby, and more. MongoDB dynamically stores data in the BSON formatted documents, which is the binary representation of JSON documents, meaning the MongoDB server converts the JSON data into a binary format to enhance the efficiency of query execution.

Key Features of MongoDB

Here are some key features of MongoDB:

1) Flexible

In traditional relational databases such as SQL, once you define a schema or the structure of the table, then it is tedious to modify it. Since MongoDB is a NoSQL database, it has no rigid structure to follow like SQL. It is schema-less and can hold numerous documents consisting of different numbers of sizes, content, and fields.

The collections in the MongoDB database do not enforce document structure as a default. Due to this flexibility, you can make the appropriate data modeling choices to suit your application’s requirements and performance. 

2) High Performance

MongoDB’s performance is very high, and data persistence regarding other databases is better due to the horizontal scalability features like sharding and replications. Sharding in the MongoDB database breaks down large data quantities into smaller, manageable parts called shards. These shards are equally distributed across multiple servers to promote optimal load balancing and data stability.

In MongoDB, there is one primary server and numerous secondary servers. All write operations are replicated on these secondary servers to ensure that the data is not lost and can be retrieved quickly if the primary server is unavailable due to server failure or crashes. Hence, MongoDB provides its users high performance, real-time data accessibility, and stability.

3) Indexing

Most enterprises face data issues due to a lack of index organization and management skills. Without the proper index management, the database will forcefully check each document to identify the one matching the query command.

MongoDB deals with this issue of data searching by intending appropriate indices to handle various accessibility issues while executing commands and load balancing to assist users. . The indexes developed by MongoDB accommodate real-time data search among all your documents, even those nested within massive arrays.

AWS Node JS MongoDB Connection

Since Node.JS is used for the server-side development of applications, it has to accept requests from the clients, perform the queries in the database and send the appropriate response back to the client’s browser. For effective database management, most enterprises prefer NoSQL databases like MongoDB.

This open-source database is flexible and can easily manage enormous amounts of data properly through its features like indexing, load balancing, and sharding. MongoDB also supports a Node.JS driver that provides a JavaScript API to implement an effective and quick network protocol to perform reading or writing operations.

You can quickly deploy applications built using Node.JS and MongoDB with Amazon Web services (AWS) products like Amazon EC2 and Amazon Lambda. 

In this article, you learn how to properly build a server Node.JS MongoDB AWS using Amazon EC2 and Amazon Lambda. 

1. Amazon EC2
2. AWS Lambda 

1) Amazon EC2

Following are the steps to use AWS EC2 to deploy your Node.JS MongoDB application:

Step 1: Create a new EC2 instance

• Log into your AWS account.
• Select the EC2 option among the various services.
• Click on the Launch button.
• According to your requirements, select the appropriate option.

• Configure the instance and add storage. The default side is 8 GB, but you can modify the size according to your needs.
• Add relevant tags and key-value pairs to enhance searching.
• Configure the Security group, click on review, then launch.
• Download this key pair and launch the instances. 

Step 2: Set up the SSH connection

Go to the newly created instance and click on the connect button. In the modal, enter the following:

#AWS Node JS MongoDB
> chmod 400 <pem file path>  
> ssh -i <pem file path> <user>@<public DNS>

Step 3: Install Node JS

• Connect your instance using SSH.
• Install the current version of nvm (node version manager).

#AWS Node JS MongoDB
curl -o- [https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh](https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh) | bash

• Activate nvm.

#AWS Node JS MongoDB
. ~/.nvm/nvm.sh

• Use nvm to install the Node.JS.

nvm install 7.9.0

Step 4: Install the MongoDB database

• Configure the package management system. 
• Install MongoDB using yum.

#AWS Node JS MongoDB
sudo yum install -y mongodb-org

• Run the MongoDB server.

#AWS Node JS MongoDB
sudo service mongod start

Step 5: Set up the Application 

• Connect the EC2 instance

#AWS Node JS MongoDB
ssh -i <pem file path> <user>@<public DNS>

• Run the command.

#AWS Node JS MongoDB
mkdir SampleExpressApp 
npm init

• Create a new app.js file and use MongoClient to connect the MongoDB database.
• Install the Express and MongoDB dependency.

#AWS Node JS MongoDB
npm install mongodb --save  
npm install express --save

• Start the server, and the application should start on port 3000.

2) Amazon Lambda

Following are the steps to use AWS Lambda to deploy your Node.JS MongoDB application:

Step 1: Set up MongoDB

• Navigate to the cluster page, and under the Security tab, press the add new user button.

• Under user privileges, select the Show advanced options, opt for the readWrite option and fill out the database file.

Press the Connect button to create the cluster.

• Copy the URI connection string.

Step 2: Install the Node.JS package 

• Create a folder such as mkdir lambda-atlas-create-doc. 
• Run the npm init in the command prompt of the file.
• Install MongoDB Node.js driver.
• Install the local lambda package.

#AWS Node JS MongoDB
(sudo) npm install lambda-local -g

• Import all the required dependencies and create a lambda code file.
• Run the file correctly.

Step 3: Create the Lambda function

• Zip the above-created Node.JS files:

#AWS Node JS MongoDB
zip -r archive.zip node_modules/ app.js package.json

• Sign in to the AWS console and go to the IAM Roles page.
• Create a role with the AWSLambdaBasicExecutionRole.
• Go to the AWS Lambda page and create a Lambda function.
• Select configure the function and complete it as per your requirements.
• Upload the zipped Node.JS file.

Step 4: Configure and secure the Lambda Variables 

• In the code, Create an environment variable named MONGODB_ATLAS_CLUSTER_URI.
• Set it to your MongoDB cluster URI value.
• Save and click on the test button.
• Check the enable encryption helpers checkbox.

• Select the Encrypt button for the variable.
• Add this code in the inline code editor,

const AWS = require('aws-sdk');

• Replace the else statement with the following code:

#AWS Node JS MongoDB
const kms = new AWS.KMS();
        kms.decrypt({ CiphertextBlob: new Buffer(uri, 'base64') }, (err, data) => {
            if (err) {
                console.log('Decrypt error:', err);
                return callback(err);
            }
            atlas_connection_uri = data.Plaintext.toString('ascii');
            processEvent(event, context, callback);
        });

• Save and click on the test button.

Conclusion

In this article, you understood the key features of Node.JS, MongoDB database, and how to deploy Node.JS MongoDB AWS via EC2 instances and AWS Lambda functions.

While Node.JS is a JavaScript environment for effective backend development, MongoDB is a NoSQL database with a flexible schema whose horizontal scalability features make it faster and more efficient.

With the assistance of AWS products, developers can easily connect and deploy a Node.JS MongoDB app. The combination of Node.JS and the MongoDB database helps to create a robust backend for growing enterprise applications. 

It is critical to consolidate data collected and managed across multiple applications and databases in your business for complete business performance analysis. This is a simple task to do with a Cloud-based ETL tool like Hevo.

Visit our Website to Explore Hevo

Hevo Data will automate your data transfer process, hence allowing you to focus on other aspects of your business like Analytics, Customer Management, etc. Hevo provides a wide range of sources – 150+ Data Sources (including 40+ Free Sources) – that connect with over 15+ Destinations and load them into a destination to analyze real-time data at transparent pricing and make Data Replication hassle-free.

Want to take Hevo for a ride? Sign Up for a 14-day free trial and simplify your Data Integration process. Do check out the pricing details to understand which plan fulfills all your business needs.

Share your thoughts on AWS Node JS MongoDB Deployment in the comments section below.