MongoDB vs MySQL: Which One to Choose?

When deciding between MongoDB and MySQL, it's essential to consider your application's data model and performance needs. MongoDB is a NoSQL database that stores data in flexible, JSON-like documents, making it ideal for unstructured or semi-structured data. This is particularly useful for applications that require quick iterations and schema changes. On the other hand, MySQL is a relational database that stores data in structured tables, providing consistency and ensuring data integrity through relationships and transactions.

For most modern web applications, MongoDB offers better scalability and flexibility, especially when dealing with large datasets or real-time data. However, if your application requires strict ACID compliance (atomicity, consistency, isolation, durability) and complex joins, MySQL might be more appropriate.

In this guide, we'll focus on integrating MongoDB Atlas, which provides a cloud-based, flexible, and scalable solution for modern application development.

Prerequisites

Before we dive in, ensure you have the following:

• Access to cPanel with Terminal access enabled. The Core Hosting packages and VPS Hosting packages at Register.lk can fulfill the requirement for terminal access.
• Node.js installed on your cPanel account. (In Core Hosting packages, Node.js application is already installed. For VPS packages, you may need to install it manually if it hasn't been installed already.)

Step 1: Set Up MongoDB Atlas

1.1 Create a MongoDB Atlas Account

1. Visit the MongoDB Atlas website.
2. Sign up for an account by providing the required details.

1.2 Create a Cluster

1. Log in to your MongoDB Atlas account.
2. Click on "Build a Cluster" and follow the wizard. Select "Shared Clusters" for the free tier option.
3. Click "Create Cluster".

1.3 Create a Database

1. In the left sidebar, navigate to "Database".
2. Click on "Create Database".
3. Name your database (e.g: myDatabase).
4. Select a cluster, and complete the setup.

1.4 Create a Database User

1. In the left sidebar, navigate to "Database Access".
2. Click on "Add New Database User".

3. Set a username (e.g: dbUser) and a secure password.
4. Assign "Atlas admin" privileges.

5. Click "Add User".

1.5 Whitelist Your IP Address

1. Go to "Network Access" in the left sidebar.
2. Click "Add IP Address".
3. Whitelist Your IP Address

   To whitelist your hosting IP in MongoDB Atlas, log in to your cPanel account, navigate to the General Information panel on the right side and locate your Shared/Dedicated IP Address to use in the IP whitelist. If you prefer to allow access from any IP (not recommended for production), you can enter 0.0.0.0/0.

4. Click "Confirm".

1.6 Get the Connection String

1. Return to "Deployment" > "Database" > Clusters"" and click "Connect".

2. Select "Connect to your application" > "Drivers".

3. Ensure the driver is set to Node.js, and select the version that matches or is compatible with your hosting package.

4. Copy your connection string and save it somewhere safe, as you will need it in the later steps.

Step 2: Set Up Your Node.js Application on cPanel

2.1 Set Up Your Node.js Application on cPanel

• Click "Create Application".
• Select the appropriate Node.js version (e.g: 20.x).
• Set Application Mode to "Production".
• In the Application Root, enter your app directory (e.g: my-node-app).
• Enter the Application URL (e.g: https://yourdomain.com).
• For Application Startup File, enter app.js.
• Click "Create".

2.2 Enter the Virtual Environment

2.3 Access cPanel Terminal

1. Go back to your cPanel dashboard.
2. Navigate to "Terminal" under the Advanced section.
3. Run the copied command from the previous step to start the virtual environment.

2.4 Configure Environment for npm Commands

export PATH=/opt/alt/alt-nodejs20/bin:/opt/alt/alt-nodejs20/usr/bin:$PATH

2.5 Create Application Directory

1. Navigate to your home directory:
   Copy

   cd ~

2. Create a new directory for your application:
   Copy

   mkdir my-node-app

   
   
   Copy

   cd my-node-app

2.6 Initialize Node.js Project

npm init -y

2.7 Install Mongoose

npm install mongoose

2.8 Install express

Express is a minimal and flexible Node.js web application framework that provides essential features for web and mobile applications.

npm install express

Step 3: Create app.js

touch app.js

Step 4: Write the Code in app.js

Now that you have created the app.js file via the terminal, follow these steps to add the necessary code for your Node.js application:

1. Navigate to File Manager:

   Go to cPanel > File Manager and locate your application directory (e.g: public_html/my-node-app).

2. Locate the app.js file:

   In the application directory, find the file app.js.

3. Edit the File:

   Right-click on the app.js file and select Edit from the menu.

4. Paste the Following Code:

   Replace the existing contents of app.js with the code below:

   JavaScript Copy code

                             
                               const express = require('express');
                               const mongoose = require('mongoose');
                         
                               const app = express();
                               mongoose.set('debug', true); // Enable Mongoose debugging for detailed logs
                         
                               // Replace with your actual MongoDB connection string
                               const uri = 'mongodb+srv://dbUser:<db_password>@cluster0.39i8i.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0';
                         
                               // Connect to MongoDB Atlas
                               mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
                                 .then(() => console.log('Connected to MongoDB Atlas'))
                                 .catch(err => console.error('Error connecting to MongoDB Atlas:', err));
                         
                               // Define a Mongoose schema
                               const itemSchema = new mongoose.Schema({
                                 name: String,
                                 quantity: Number,
                                 price: Number
                               });
                         
                               // Create a Mongoose model
                               const Item = mongoose.model('Item', itemSchema);
                         
                               // Route to fetch all items from MongoDB
                               app.get('/', async (req, res) => {
                                 try {
                                   const items = await Item.find(); // Retrieve all items
                                   res.json(items); // Send the items as a JSON response
                                 } catch (err) {
                                   res.status(500).send('Error retrieving items from MongoDB');
                                 }
                               });
                         
                               // Route to add a new item (example)
                               app.get("/add-item", async (req, res) => {
                                 try {
                                   const newItem = new Item({
                                     name: 'Banana',
                                     quantity: 50,
                                     price: 0.5
                                   });
                                   const savedItem = await newItem.save();
                                   res.json({ message: 'Item added successfully', item: savedItem });
                                 } catch (err) {
                                   res.status(500).send('Error adding item to MongoDB');
                                 }
                               });
                         
                               // Listen on the port assigned by cPanel
                               const port = process.env.PORT || 3000;
                               app.listen(port, () => {
                                 console.log(`Server running on port ${port}`);
                               });
                             
                           

Important: You can copy and paste your MongoDB connection string into the uri variable, but remember to verify that your credentials are properly encoded if they contain special characters. For example, @ becomes %40 , and # becomes %23.
5. Save the Changes:

   After pasting the code, click Save Changes in the top right corner of the editor.

Step 5: Finalize Node.js Application Setup

Now, navigate back to cPanel and go to Setup Node.js App under the Software section.

• Locate your application (e.g: my-node-app).
• Click "Edit" to confirm that the Application Startup File is set to app.js and the Application Mode is correct.

5.1 Install Dependencies

After creating the application, click "Run NPM Install" to the Node.js application to install the dependencies listed in package.json.

5.2 Restart the Application

Click "Restart" to apply the changes.

Step 6: Run and Test Your Application

6.1 Check the Application Logs

1. In the Application Manager, click "View Logs" to see the output of your application.
2. You should see messages similar to:

   Connected to MongoDB Atlas
   Item saved: { ... }
   All items: [ ... ]
   				

6.2 Verify Data in MongoDB Atlas

1. Log in to your MongoDB Atlas account.
2. Click on "Browse Collections".
3. Navigate to your database and collection.
4. You should see the document(s) inserted by your application.

Conclusion

Additional Resources

• MongoDB Atlas Documentation: Getting Started with Atlas
• Mongoose Documentation: Mongoose Guides
• cPanel Documentation: How to Install a Node.js Application
• Register.lk: Unlocking the Power of Core Packages via Shell Access