Skip to main content

Launching MongoDB

Learn how to launch and deploy MongoDB database instances on KloudBean. KloudBean provides managed MongoDB database with high performance and robust security policies.

Overview​

KloudBean provides managed MongoDB database. KloudBean databases are high performant and having good security policies as well.

KloudBean Managed MongoDB Benefits​

High Performance:

  • Optimized Configuration: Pre-configured for optimal performance
  • Fast Query Execution: Efficient document-based query processing
  • Efficient Resource Usage: Smart resource allocation
  • Scalable Architecture: Built to scale horizontally with sharding
  • Flexible Schema: Document-based storage for flexible data models

Security Policies:

  • Encrypted Connections: SSL/TLS encryption for secure connections
  • Access Control: Granular access control and IP whitelisting
  • Regular Updates: Automatic security updates and patches

Easy Setup and Access:

  • Few Steps Installation: It is a few steps installation process
  • Quick Deployment: Database creation takes only 2-5 minutes
  • Simple Configuration: Minimal configuration required
  • Easy Access: Straightforward access to database credentials
  • User-Friendly Interface: Intuitive dashboard for management

Additional Benefits:

  • High Availability: Built-in replica sets for redundancy
  • Monitoring: Real-time performance monitoring
  • Scalability: Easy scaling as your needs grow
  • Support: Expert support from KloudBean team
  • Replication: Built-in replication for high availability

Prerequisites​

  • An active KloudBean account
  • Understanding of NoSQL database concepts
  • Payment method for database provisioning

Launching MongoDB Database​

Step 1: Navigate to Database Section​

In order to launch MongoDB database:

From your KloudBean dashboard navigate to Managed database or from top header click on "DBS".

On DBS page there is a button "Launch Database".

Database Step 1

Once you click it will take you to database provision page.

Step 2: Select Database Engine​

Where you have to select:

Database engine: Select MongoDB from here.

MongoDB Launch Step 1

Step 3: Provide Database Details​

Next step is to provide following database detail:

MongoDB Launch Step 2

Required Information:

  1. Database Name:

    • Enter a unique name for your database
    • Use lowercase letters, numbers, and underscores
    • Example: myapp_db, production_db

  2. Database User:

    • Create a username for database access
    • Use lowercase letters, numbers, and underscores
    • Example: myapp_user, db_admin

  3. Database Version:

    • Select MongoDB version:
      • MongoDB 7.0 (latest, recommended)
      • MongoDB 6.0 (stable)
      • MongoDB 5.0 (legacy support)
    • Choose based on your application requirements

  4. Server Location:

    • Choose the geographic location for your database
    • Select region closest to your application servers
    • Consider data residency requirements

Step 4: Select Server Size​

Once these details are added:

Decide server size and select most suitable size. Note that you can scale your database up any time, contact KloudBean for that.

Server Size Options:

  • Small: Suitable for development and testing
  • Medium: Good for small to medium applications
  • Large: For production applications with high traffic
  • Custom: Custom configuration for specific needs

Scaling Options:

  • Vertical Scaling: Increase CPU, RAM, or storage
  • Horizontal Scaling: Add shards or replica set members
  • Contact Support: Reach out to KloudBean support for scaling assistance

Considerations:

  • Current Needs: Start with size that meets current needs
  • Growth Projection: Consider future growth when selecting size
  • Cost Optimization: Start smaller and scale as needed
  • Performance: Larger sizes offer better performance

Step 5: Launch Database​

Click on "Launch now" button, it will take you to the payment screen, where you will complete your payment.

Payment Process:

  1. Review Configuration: Verify all settings are correct
  2. Payment Method: Select your payment method
  3. Complete Payment: Complete the payment process
  4. Confirmation: Receive confirmation of payment

Once payment is completed, your database creation process will be initiated, and it will take around 2-5 minutes to create and configure your high performance database.

Creation Process:

  • Database instance provisioning
  • MongoDB installation and configuration
  • Security setup and encryption
  • Network configuration

Once created you will see your database in DBS page.

MongoDB Access Step 1

Accessing Database Details​

Step 1: Navigate to Database Administration​

In order to get database access detail click on your database and it will take you to database administration page where all the database access information is listed.

MongoDB Access Step 2

Step 2: View Database Credentials​

Database Access Information:

Host:

  • Database server hostname or IP address
  • Use this to connect to your database
  • Example: mongodb-123456.kloudbeansite.com or 192.168.1.100

Port:

  • MongoDB port number (usually 27017)
  • Default MongoDB port for connections
  • Example: 27017

Database Name:

  • Name of your database
  • Use this in connection strings
  • Example: myapp_db

Master User:

  • Username for database access
  • Primary database user credentials
  • Example: myapp_user

Database Password:

  • Password for database authentication
  • Keep this secure and never expose publicly
  • Use this with Master User for authentication

IP Address:

  • Database server IP address
  • Use for IP whitelisting if needed
  • Example: 192.168.1.100

You can use this information to use this database in your application.

Database Replicas​

Overview​

KloudBean provides 2 database replicas as well along with the main database, where syncing is already configured.

Replica Set Configuration:

  • Main Database: Primary database instance
  • Replica Set 1: First replica instance
  • Replica Set 2: Second replica instance

Benefits of Replicas:

  • High Availability: Automatic failover if primary fails
  • Read Scaling: Distribute read operations across replicas
  • Data Redundancy: Multiple copies of your data
  • Automatic Syncing: Data is automatically synchronized across all replicas

Replica Ports​

Port Configuration:

  • Main Database: Port 27017 (primary instance)
  • Replica Set 1: Port 27018 (first replica)
  • Replica Set 2: Port 27019 (second replica)

All replicas use the same:

  • Host: Same hostname or IP address as main database
  • Username: Same Master User credentials
  • Password: Same Database Password
  • Database Name: Same database name

Connecting to Replicas​

Connecting to Main Database (Port 27017)​

Using MongoDB Shell:

mongosh "mongodb://[USERNAME]:[PASSWORD]@[HOST]:27017/[DATABASE_NAME]?authSource=admin"

Example:

mongosh "mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin"

Connecting to Replica Set 1 (Port 27018)​

Using MongoDB Shell:

mongosh "mongodb://[USERNAME]:[PASSWORD]@[HOST]:27018/[DATABASE_NAME]?authSource=admin"

Example:

mongosh "mongodb://myapp_user:[email protected]:27018/myapp_db?authSource=admin"

Connecting to Replica Set 2 (Port 27019)​

Using MongoDB Shell:

mongosh "mongodb://[USERNAME]:[PASSWORD]@[HOST]:27019/[DATABASE_NAME]?authSource=admin"

Example:

mongosh "mongodb://myapp_user:[email protected]:27019/myapp_db?authSource=admin"

Connecting to Replica Set (All Replicas)​

For automatic failover and read distribution, connect to the replica set:

mongosh "mongodb://[USERNAME]:[PASSWORD]@[HOST]:27017,[HOST]:27018,[HOST]:27019/[DATABASE_NAME]?authSource=admin&replicaSet=rs0"

Example:

mongosh "mongodb://myapp_user:[email protected]:27017,mongodb-123456.kloudbeansite.com:27018,mongodb-123456.kloudbeansite.com:27019/myapp_db?authSource=admin&replicaSet=rs0"

Benefits of Replica Set Connection:

  • Automatic Failover: Automatically switches to available replica if primary fails
  • Read Preference: Distribute reads across replicas
  • Write Safety: Ensures writes are replicated to multiple nodes

Using Replicas in Applications​

Node.js (MongoDB Driver)​

Connect to Replica Set:

const { MongoClient } = require('mongodb');

const uri = 'mongodb://myapp_user:[email protected]:27017,mongodb-123456.kloudbeansite.com:27018,mongodb-123456.kloudbeansite.com:27019/myapp_db?authSource=admin&replicaSet=rs0';

const client = new MongoClient(uri, {
  replicaSet: 'rs0',
  readPreference: 'secondaryPreferred' // Prefer reading from replicas
});

await client.connect();

Connect to Specific Replica:

// Connect to Replica Set 1 (port 27018)
const uri = 'mongodb://myapp_user:[email protected]:27018/myapp_db?authSource=admin';
const client = new MongoClient(uri);

Node.js (Mongoose)​

Connect to Replica Set:

const mongoose = require('mongoose');

const uri = 'mongodb://myapp_user:[email protected]:27017,mongodb-123456.kloudbeansite.com:27018,mongodb-123456.kloudbeansite.com:27019/myapp_db?authSource=admin&replicaSet=rs0';

mongoose.connect(uri, {
  readPreference: 'secondaryPreferred'
});

Python (pymongo)​

Connect to Replica Set:

from pymongo import MongoClient

uri = 'mongodb://myapp_user:[email protected]:27017,mongodb-123456.kloudbeansite.com:27018,mongodb-123456.kloudbeansite.com:27019/myapp_db?authSource=admin&replicaSet=rs0'

client = MongoClient(uri, read_preference='secondaryPreferred')

Connect to Specific Replica:

# Connect to Replica Set 1 (port 27018)
uri = 'mongodb://myapp_user:[email protected]:27018/myapp_db?authSource=admin'
client = MongoClient(uri)

PHP​

Connect to Replica Set:

<?php
$uri = 'mongodb://myapp_user:[email protected]:27017,mongodb-123456.kloudbeansite.com:27018,mongodb-123456.kloudbeansite.com:27019/myapp_db?authSource=admin&replicaSet=rs0';
$client = new MongoDB\Client($uri, [
    'readPreference' => 'secondaryPreferred'
]);
?>

Replica Set Status​

Check Replica Set Status:

// In MongoDB shell
rs.status()

Check Replica Set Configuration:

// In MongoDB shell
rs.conf()

Check Current Primary:

// In MongoDB shell
rs.isMaster()

Best Practices for Replicas​

Read Operations:

  • Use Replicas for Reads: Distribute read operations across replicas to reduce load on primary
  • Read Preference: Use secondaryPreferred for read-heavy applications
  • Connection Pooling: Use connection pooling for better performance

Write Operations:

  • Write to Primary: Always write to the primary instance (port 27017)
  • Write Concern: Configure write concern to ensure data is replicated
  • Automatic Failover: Replica set automatically handles failover

Monitoring:

  • Monitor Replica Lag: Check replication lag between primary and replicas
  • Health Checks: Regularly check replica set health
  • Performance: Monitor performance across all replicas

Accessing Database​

Database Access Status​

By default, the public access to your database is disabled.

In order to check access status, navigate to "Database Specifications" section of "Access" tab.

Database Public Access

This represents that access is disabled and you cannot access it.

Enabling Database Access​

In order to access database you have to whitelist the IP address of your source server or you have to enable public access of your database.

Important: Do Not Enable Public Access Unnecessarily

Why Public Access Should Be Avoided:

  • Security Risk: Public access exposes your database to the entire internet
  • Attack Surface: Increases vulnerability to attacks and unauthorized access
  • Compliance Issues: May violate data protection regulations
  • Best Practice: Always use IP whitelisting instead of public access

When Public Access Might Be Needed:

  • Development/Testing: Only for non-production environments
  • Temporary Access: For specific, time-limited tasks
  • With Additional Security: Combined with strong passwords and SSL

Recommended Approach:

  • IP Whitelisting: Always prefer IP whitelisting over public access
  • Specific IPs: Whitelist only specific IP addresses that need access
  • Source Server IP: Whitelist your application server's IP address
  • VPN Access: Consider VPN for additional security layer

To get to know how you can update database access, read document: Controlling Database Access

Once access is enabled, now you can access your database.

Accessing Database from MongoDB Compass​

Step 1: Install MongoDB Compass​

Download and Install:

  1. Download: Go to MongoDB Compass Download Page
  2. Install: Follow installation instructions for your operating system
  3. Launch: Open MongoDB Compass

Step 2: Create New Connection​

  1. Click "New Connection" or the "+" button
  2. Enter Connection String: 
    mongodb://[USERNAME]:[PASSWORD]@[HOST]:[PORT]/[DATABASE_NAME]?authSource=admin
  3. Example: 
    mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin
  4. Click "Connect"

Step 3: Connect to Database​

  1. Enter Credentials: If prompted, enter username and password
  2. Select Database: Choose your database from the list
  3. You're Connected: You should now see your database and collections

Step 4: Using MongoDB Compass​

Common Operations:

  • Browse Collections: Click on collections to view documents
  • Query Documents: Use the filter bar to query documents
  • Create Collections: Click "Create Collection" to add new collections
  • Import/Export: Use Import/Export tools for data management
  • View Schema: Analyze collection schema
  • Run Aggregations: Use aggregation pipeline builder

Accessing Database from Shell/Command Line​

Step 1: Install MongoDB Shell​

On Linux (Ubuntu/Debian):

sudo apt update
sudo apt install mongodb-database-tools

On macOS:

brew install mongosh

On Windows:

Step 2: Connect to Database​

Basic Connection Command:

mongosh "mongodb://[USERNAME]:[PASSWORD]@[HOST]:[PORT]/[DATABASE_NAME]?authSource=admin"

Example:

mongosh "mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin"

Alternative: Interactive Connection:

mongosh --host [HOST] --port [PORT] --username [USERNAME] --password [PASSWORD] --authenticationDatabase admin

Step 3: Basic MongoDB Commands​

Once connected, you can run MongoDB commands:

Show Databases:

show dbs

Use Database:

use database_name

Show Collections:

show collections

Create Collection:

db.createCollection("users")

Insert Document:

db.users.insertOne({
    username: "john_doe",
    email: "[email protected]",
    created_at: new Date()
})

Insert Multiple Documents:

db.users.insertMany([
    { username: "john_doe", email: "[email protected]" },
    { username: "jane_doe", email: "[email protected]" }
])

Find Documents:

// Find all documents
db.users.find()

// Find with filter
db.users.find({ username: "john_doe" })

// Find one document
db.users.findOne({ email: "[email protected]" })

// Find with projection
db.users.find({}, { username: 1, email: 1 })

Update Documents:

// Update one document
db.users.updateOne(
    { username: "john_doe" },
    { $set: { email: "[email protected]" } }
)

// Update multiple documents
db.users.updateMany(
    { status: "inactive" },
    { $set: { status: "active" } }
)

Delete Documents:

// Delete one document
db.users.deleteOne({ username: "john_doe" })

// Delete multiple documents
db.users.deleteMany({ status: "inactive" })

Create Index:

// Create single field index
db.users.createIndex({ email: 1 })

// Create unique index
db.users.createIndex({ email: 1 }, { unique: true })

// Create compound index
db.users.createIndex({ username: 1, email: 1 })

Exit MongoDB Shell:

exit
-- or
quit()

Using Database Credentials in Your Application​

Connection String Format​

Standard MongoDB Connection String:

mongodb://[USERNAME]:[PASSWORD]@[HOST]:[PORT]/[DATABASE_NAME]?authSource=admin

Example:

mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin

Node.js​

Using mongodb package:

const { MongoClient } = require('mongodb');

const uri = 'mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin';
const client = new MongoClient(uri);

async function run() {
  try {
    await client.connect();
    const db = client.db('myapp_db');
    const collection = db.collection('users');
    
    // Insert document
    await collection.insertOne({ username: 'john_doe', email: '[email protected]' });
    
    // Find documents
    const users = await collection.find({}).toArray();
    console.log(users);
  } finally {
    await client.close();
  }
}

run().catch(console.error);

Using mongoose:

const mongoose = require('mongoose');

const uri = 'mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin';

mongoose.connect(uri)
  .then(() => console.log('Connected to MongoDB'))
  .catch(err => console.error('Connection error:', err));

// Define schema
const userSchema = new mongoose.Schema({
  username: String,
  email: String,
  created_at: { type: Date, default: Date.now }
});

const User = mongoose.model('User', userSchema);

// Use model
const user = new User({ username: 'john_doe', email: '[email protected]' });
await user.save();

Python​

Using pymongo:

from pymongo import MongoClient

uri = 'mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin'
client = MongoClient(uri)

db = client['myapp_db']
collection = db['users']

# Insert document
collection.insert_one({
    'username': 'john_doe',
    'email': '[email protected]'
})

# Find documents
users = collection.find({})
for user in users:
    print(user)

client.close()

PHP​

Using MongoDB PHP Library:

<?php
require 'vendor/autoload.php';

$uri = 'mongodb://myapp_user:[email protected]:27017/myapp_db?authSource=admin';
$client = new MongoDB\Client($uri);

$db = $client->selectDatabase('myapp_db');
$collection = $db->selectCollection('users');

// Insert document
$collection->insertOne([
    'username' => 'john_doe',
    'email' => '[email protected]'
]);

// Find documents
$users = $collection->find([]);
foreach ($users as $user) {
    print_r($user);
}
?>

Best Practices​

Security​

  • Strong Passwords: Use strong, unique passwords for database users
  • IP Whitelisting: Always use IP whitelisting instead of public access
  • SSL/TLS: Enable SSL/TLS encryption for all connections
  • Regular Updates: Keep MongoDB updated to latest version
  • Access Control: Implement proper user permissions and access control

Performance​

  • Proper Indexing: Create indexes on frequently queried fields
  • Query Optimization: Optimize your queries and use projections
  • Connection Pooling: Use connection pooling in applications
  • Resource Monitoring: Monitor database performance regularly
  • Regular Maintenance: Perform regular database maintenance
  • Data Modeling: Design efficient document structures

Management​

  • Monitor Usage: Monitor database usage and performance
  • Scale When Needed: Scale your database as your needs grow
  • Documentation: Document your database configuration
  • Version Control: Keep track of schema changes

Troubleshooting​

Connection Issues​

Cannot Connect to Database:

  • Check IP Whitelist: Verify your IP is whitelisted
  • Check Credentials: Verify host, port, username, and password
  • Check Network: Verify network connectivity
  • Check Firewall: Check firewall rules
  • Review Access Settings: Check database access configuration
  • Check authSource: Verify authentication database is correct

Authentication Errors:

  • Verify Credentials: Check username and password
  • Check authSource: Verify authSource parameter is set correctly
  • Check User Permissions: Verify user has necessary permissions
  • Check Database Access: Verify user has access to the database

Performance Issues​

Slow Queries:

  • Check Indexes: Verify proper indexes exist
  • Optimize Queries: Review and optimize slow queries
  • Check Resources: Monitor CPU, memory, and disk usage
  • Review Configuration: Review MongoDB configuration
  • Use Explain: Use explain() to analyze query performance

Connection Limits:

  • Check Limits: Verify connection limits
  • Close Connections: Close unused connections
  • Use Connection Pooling: Implement connection pooling
  • Review Active Connections: Check for connection leaks

Next Steps​

After launching your MongoDB database: