MongoDB Atlas Setup

Configuring and Connecting to a Cloud-Based NoSQL Database

What is MongoDB Atlas?

MongoDB Atlas is the official Database-as-a-Service (DBaaS) platform for MongoDB, providing a fully-managed cloud database service. With Atlas, you can deploy, operate, and scale MongoDB deployments in the cloud without the operational overhead of managing database infrastructure yourself.

Think of MongoDB Atlas as having all the power of MongoDB combined with the convenience of a managed service—you focus on building your application while Atlas handles the complexities of database management, security, backups, and scaling.

flowchart TD A[Your Application] -->|Connects to| B[MongoDB Atlas] B -->|Deployed on| C1[AWS] B -->|Deployed on| C2[Azure] B -->|Deployed on| C3[Google Cloud] B ---|Managed by MongoDB Team| D[Automated Backups] B ---|Managed by MongoDB Team| E[Security & Compliance] B ---|Managed by MongoDB Team| F[Scaling & Performance] B ---|Managed by MongoDB Team| G[Monitoring & Alerts] B ---|Managed by MongoDB Team| H[Updates & Patches]

Why Use MongoDB Atlas?

Multi-Cloud Deployment

Deploy your databases on AWS, Azure, or Google Cloud in over 80+ regions worldwide, enabling you to place your data close to your users or meet specific regional compliance requirements.

Automated Operations

Atlas automates time-consuming administration tasks such as infrastructure provisioning, database setup, patches, backups, and more. This reduces operational overhead and allows your team to focus on application development.

Built-in Security

Atlas includes comprehensive security features like encryption at rest and in transit, network isolation, VPC peering, IP whitelisting, and advanced authentication options to protect your data.

Elastic Scalability

Easily scale your database up or down without application downtime. Atlas allows you to add capacity, adjust performance, or enable global distribution with a few clicks.

Free Tier for Development

Atlas offers a generous free tier that includes a small shared cluster, 512MB storage, and basic monitoring—perfect for development and learning purposes.

Real-World Use Cases

  • Startups: Launch quickly without DevOps overhead, focusing resources on product development
  • Enterprise Applications: Deploy globally distributed databases that serve users with low latency
  • Mobile Apps: Build a scalable backend for user data, content, and analytics
  • IoT Systems: Handle large volumes of sensor data with flexible scaling
  • Development and Testing: Create on-demand environments without provisioning hardware

Setting Up Your MongoDB Atlas Account

Let's walk through the process of creating a MongoDB Atlas account and setting up your first cluster.

Step 1: Create an Atlas Account

  1. Visit MongoDB Atlas and click "Try Free"
  2. Sign up with your email, or use Google/GitHub authentication
  3. Complete the registration process by providing basic information
  4. Accept the terms of service

Step 2: Create Your First Project

  1. After signing in, you'll be prompted to create a new project
  2. Enter a project name (e.g., "My First Project")
  3. Click "Create Project"
  4. Optionally, add project members (for team collaboration)

Step 3: Deploy a Free Tier Cluster

  1. Click "Build a Database" to begin creating a cluster
  2. Select "FREE" option (M0 tier) for a free sandbox cluster
  3. Choose your preferred cloud provider (AWS, Azure, or Google Cloud)

    Note: For the free tier, provider selection doesn't significantly impact performance. Choose the one with a region closest to your location or target users.

  4. Select a region (typically, choose one closest to your users)
  5. Choose the "M0 Sandbox" tier (free forever)
  6. Enter a name for your cluster (e.g., "Cluster0" is the default)
  7. Click "Create Cluster" and wait a few minutes for provisioning

Creating a Free Tier Cluster in MongoDB Atlas

(Image showing the Atlas interface's free tier selection)

Step 4: Configure Security Settings

  1. Create a Database User:
    • In the sidebar, click "Database Access" under Security
    • Click "Add New Database User"
    • Choose "Password" as the authentication method
    • Enter a username and a secure password
    • Set appropriate database user privileges (typically "Read and Write to Any Database" for development)
    • Click "Add User"
  2. Configure Network Access:
    • In the sidebar, click "Network Access" under Security
    • Click "Add IP Address"
    • For development purposes, you can click "Allow Access from Anywhere" (not recommended for production)
    • Alternatively, add your specific IP address for more security
    • Click "Confirm"
⚠️ Security Considerations

For Development: Using "Allow Access from Anywhere" is convenient during development but exposes your database to the entire internet. Ensure you have strong credentials.

For Production: Always restrict access to specific IP addresses or IP ranges. Consider using VPC Peering or Private Link for additional security.

Step 5: Get Your Connection String

  1. Return to the "Database Deployments" page
  2. Click "Connect" on your cluster
  3. Select "Connect your application"
  4. Choose your driver version (e.g., Node.js, version 4.0 or later)
  5. Copy the provided connection string
  6. Replace <password> with your database user's password
  7. Replace <dbname> with your database name 

// Example connection string
mongodb+srv://username:@cluster0.mongodb.net/?retryWrites=true&w=majority

Connecting to MongoDB Atlas from Node.js

Now that you have set up your MongoDB Atlas cluster, let's learn how to connect to it from a Node.js application.

Using the MongoDB Native Driver


// Install the MongoDB driver
npm install mongodb

// Connect to MongoDB Atlas in your application
const { MongoClient } = require('mongodb');
require('dotenv').config(); // For handling environment variables

// Connection URI (store this in .env file for security)
const uri = process.env.MONGODB_URI;

// Create a new MongoClient
const client = new MongoClient(uri, {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

// Connect to the database
async function connectToDatabase() {
  try {
    // Connect to the MongoDB cluster
    await client.connect();
    console.log('Connected to MongoDB Atlas');
    
    // Return the database object
    return client.db('sample_database');
  } catch (error) {
    console.error('Error connecting to MongoDB:', error);
    process.exit(1);
  }
}

// Example usage
async function main() {
  const db = await connectToDatabase();
  const collection = db.collection('users');
  
  // Perform database operations
  const result = await collection.insertOne({
    name: 'John Doe',
    email: 'john@example.com',
    created: new Date()
  });
  
  console.log(`Inserted document with ID: ${result.insertedId}`);
  
  // Always close the connection when done
  await client.close();
}

main().catch(console.error);

Using Mongoose ODM


// Install Mongoose
npm install mongoose

// Connect to MongoDB Atlas with Mongoose
const mongoose = require('mongoose');
require('dotenv').config();

// Connection URI (store this in .env file for security)
const uri = process.env.MONGODB_URI;

// Connect to MongoDB
async function connectToDatabase() {
  try {
    await mongoose.connect(uri, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      useCreateIndex: true,
      useFindAndModify: false
    });
    
    console.log('Connected to MongoDB Atlas with Mongoose');
  } catch (error) {
    console.error('Error connecting to MongoDB:', error);
    process.exit(1);
  }
}

// Define a schema
const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    trim: true
  },
  email: {
    type: String,
    required: true,
    unique: true,
    trim: true,
    lowercase: true
  },
  created: {
    type: Date,
    default: Date.now
  }
});

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

// Example usage
async function main() {
  await connectToDatabase();
  
  // Create a new user
  const newUser = new User({
    name: 'Jane Doe',
    email: 'jane@example.com'
  });
  
  // Save to database
  await newUser.save();
  console.log('User saved to database');
  
  // Find all users
  const users = await User.find();
  console.log(`Found ${users.length} users`);
  
  // No need to explicitly close with Mongoose, but you can:
  // await mongoose.connection.close();
}

main().catch(console.error);

Using Environment Variables for Security

Always store your connection string in environment variables rather than hardcoding it in your application: 


// .env file
MONGODB_URI=mongodb+srv://username:password@cluster0.mongodb.net/mydatabase?retryWrites=true&w=majority
⚠️ Important Security Practices
  • Never commit your .env file to version control
  • Add .env to your .gitignore file
  • Use different database users for development and production
  • Follow the principle of least privilege when assigning user roles

Connection Options

Option Description Default
useNewUrlParser Use the new URL parser true
useUnifiedTopology Use the new Server Discovery and Monitoring engine true
retryWrites Automatically retry failed write operations true
w Write concern level (majority means wait for a majority of replica set members) 1
poolSize Number of connections in the connection pool 5
connectTimeoutMS Timeout for initial connection 30000 (30 seconds)
socketTimeoutMS Timeout for socket operations 360000 (6 minutes)

Exploring MongoDB Atlas Features

Beyond basic database hosting, MongoDB Atlas offers a rich set of features to help you manage, monitor, and optimize your databases.

Atlas Data Explorer

A web-based GUI for querying, visualizing, and manipulating your data directly in the Atlas dashboard:

  • Navigate through databases and collections
  • View, add, edit, and delete documents
  • Create and modify indexes
  • Execute aggregation pipelines
  • Analyze query performance

Atlas Data Explorer Interface

(Image of the Atlas Data Explorer interface)

Performance Monitoring

Comprehensive monitoring and profiling tools:

  • Real-time performance metrics
  • Database operation logs
  • Query profiler for identifying slow queries
  • Custom alerts for critical metrics
  • Performance advisor for index suggestions

Backup & Restore

Automated backup solutions to protect your data:

  • Continuous backups with point-in-time recovery
  • Scheduled snapshots
  • Cross-region backup support
  • Easy restoration through the UI

Scaling Options

Multiple ways to scale your database:

  • Vertical scaling (increase/decrease instance size)
  • Horizontal scaling (sharding)
  • Global clusters for multi-region deployments
  • Auto-scaling capabilities for workload-driven provisioning

Atlas Search

Full-text search capabilities powered by Lucene:

  • Advanced text search with natural language processing
  • Typo-tolerance and language analyzers
  • Faceting and filtering
  • Customizable scoring

// Example Atlas Search query
db.products.aggregate([
  {
    $search: {
      index: "default",
      text: {
        query: "wireless headphones",
        path: ["name", "description"]
      }
    }
  },
  {
    $limit: 10
  },
  {
    $project: {
      name: 1,
      price: 1,
      description: 1,
      score: { $meta: "searchScore" }
    }
  }
])

Atlas Data Lake

Query data stored in S3 buckets using MongoDB Query Language:

  • Connect to Amazon S3 storage
  • Federated queries across Atlas and Data Lake
  • Transform and analyze large datasets
  • No data movement required

Atlas Tier Options

MongoDB Atlas offers different tiers to meet various application needs:

Tier Description Best For
M0 (Free) Shared RAM and storage
512MB storage
Shared processing 		Development
Learning
Small projects
M2/M5 (Shared) Shared RAM and vCPUs
2GB or 5GB storage
Low-cost option 		Small applications
Startups
Testing environments
M10+ (Dedicated) Dedicated RAM and vCPUs
10GB+ storage
Multiple options available 		Production applications
Higher workloads
Enterprise needs
Serverless Pay only for resources used
Automatic scaling
No server management 		Variable workloads
Apps with unpredictable traffic
Minimizing operational overhead

Managing MongoDB Atlas Clusters

Let's explore how to manage and optimize your MongoDB Atlas clusters for different scenarios.

Scaling Your Cluster

  1. Vertical Scaling (Changing Cluster Tier):
    • Navigate to your cluster in the Atlas dashboard
    • Click "Configuration" tab
    • Click "Edit" next to Cluster Tier
    • Select your desired tier
    • Click "Confirm & Deploy"

    Note: Scaling operations typically do not cause downtime on dedicated clusters (M10+). Your cluster remains available during the scaling process.

  2. Horizontal Scaling (Sharding):
    • Available for M30+ clusters
    • Navigate to your cluster's Configuration tab
    • Click "Edit" next to Sharding
    • Enable sharding and configure shard count
    • Specify shard key for collections that need sharding

Cluster Configuration Options

Configuration Description When to Use
Cluster Tier RAM, vCPU, and storage capacity Increase when you need more resources for memory-intensive operations
Additional Storage Extra storage beyond tier default When you have more data but don't need more computing power
IOPS (M30+) I/O operations per second For write-heavy workloads requiring higher disk performance
Backup Options Continuous backups, frequency, retention Adjust based on your recovery point objective (RPO)
BI Connector Connect to business intelligence tools For analytics and reporting with tools like Tableau, PowerBI

Creating Database Users with Specific Permissions

Different applications or team members might need different levels of access to your databases: 


// MongoDB Shell command to create a read-only user
db.createUser({
  user: "read_only_user",
  pwd: "securePassword123",
  roles: [
    { role: "read", db: "myDatabase" }
  ]
})

// MongoDB Shell command to create an admin user
db.createUser({
  user: "admin_user",
  pwd: "superSecurePassword456",
  roles: [
    { role: "dbAdmin", db: "myDatabase" },
    { role: "readWrite", db: "myDatabase" }
  ]
})

In the Atlas UI:

  1. Go to Database Access in the Security section
  2. Click "Add New Database User"
  3. Enter username and password
  4. Choose "Built-in Role" or "Custom Role"
  5. For built-in roles, select from:
    • Atlas admin
    • Read and write to any database
    • Read any database
    • Custom (specific database and collection privileges)
  6. Click "Add User"

Monitoring Your Cluster

Atlas provides comprehensive monitoring tools to help you understand your database performance:

Performance Optimization Tip

Use the Performance Advisor in Atlas to identify missing indexes that could improve query performance. It analyzes your query patterns and makes recommendations specifically tailored to your workload.

Migrating Data to MongoDB Atlas

When moving from a self-hosted MongoDB instance or another database system to MongoDB Atlas, you have several migration options.

Live Migration Service

Atlas provides a managed live migration service that minimizes downtime when migrating from existing MongoDB deployments:

  1. In the Atlas UI, click "Live Migration" in the cluster creation flow
  2. Provide the connection information for your source MongoDB deployment
  3. Atlas establishes a connection to your source deployment
  4. Data is copied while your source database remains operational
  5. Once the initial sync completes, Atlas keeps the data in sync by applying ongoing operations
  6. When ready, you can cut over to the Atlas deployment with minimal downtime

Using mongodump and mongorestore

For smaller databases or offline migrations, you can use MongoDB's native tools: 


# Dump data from your source MongoDB
mongodump --uri="mongodb://username:password@source-host:port/database" --out=/path/to/dump

# Restore data to MongoDB Atlas
mongorestore --uri="mongodb+srv://username:password@cluster0.mongodb.net/database" /path/to/dump

Using mongoimport and mongoexport

For individual collections or JSON/CSV data: 


# Export a collection to JSON
mongoexport --uri="mongodb://username:password@source-host:port/database" \
            --collection=users \
            --out=users.json

# Import JSON data to Atlas
mongoimport --uri="mongodb+srv://username:password@cluster0.mongodb.net/database" \
            --collection=users \
            --file=users.json

Custom Migration Scripts

For complex migrations or when migrating from a different database system, you might need to write custom scripts: 


// Node.js script to migrate data from PostgreSQL to MongoDB Atlas
const { Client } = require('pg');
const { MongoClient } = require('mongodb');
require('dotenv').config();

// Source PostgreSQL connection
const pgClient = new Client({
  connectionString: process.env.POSTGRES_URI
});

// Target MongoDB Atlas connection
const mongoClient = new MongoClient(process.env.MONGODB_URI);

async function migrateData() {
  try {
    // Connect to both databases
    await pgClient.connect();
    await mongoClient.connect();
    
    const db = mongoClient.db('targetDatabase');
    const collection = db.collection('users');
    
    // Query data from PostgreSQL
    const pgResult = await pgClient.query('SELECT * FROM users');
    
    // Transform data if needed
    const transformedData = pgResult.rows.map(row => ({
      name: `${row.first_name} ${row.last_name}`,
      email: row.email,
      createdAt: row.created_at,
      // Transform other fields as needed
    }));
    
    // Insert into MongoDB Atlas
    if (transformedData.length > 0) {
      const result = await collection.insertMany(transformedData);
      console.log(`${result.insertedCount} documents migrated successfully`);
    } else {
      console.log('No data to migrate');
    }
  } catch (error) {
    console.error('Migration error:', error);
  } finally {
    // Close connections
    await pgClient.end();
    await mongoClient.close();
  }
}

migrateData().catch(console.error);

Security Best Practices for MongoDB Atlas

Securing your MongoDB Atlas deployment is crucial for protecting your data. Here are some best practices to follow:

Network Security

  • IP Allowlist: Restrict database access to specific IP addresses or ranges
  • VPC Peering: For production environments, set up VPC peering to establish a direct, private connection between your VPC and Atlas
  • Private Endpoints: Use AWS PrivateLink, Azure Private Link, or Google Private Service Connect to keep all traffic on the private network

Authentication and Authorization

  • Strong Passwords: Use long, complex passwords for all database users
  • Role-Based Access Control: Assign the minimum necessary permissions to each user
  • Database User Segregation: Create separate users for different applications or services
  • X.509 Certificates: Consider using certificate-based authentication for stronger security

Encryption

  • Encryption in Transit: Atlas enables TLS/SSL for all connections by default
  • Encryption at Rest: Atlas encrypts all storage and backups by default
  • Client-Side Field Level Encryption: For sensitive data, implement client-side encryption before sending to Atlas

Auditing and Compliance

  • Database Auditing: Enable auditing to track user activities and access patterns (Available on M10+ clusters)
  • Compliance: Atlas is compliant with major standards including SOC2, HIPAA, GDPR, ISO, PCI DSS, and more

Operational Security

  • Secure Application Code: Validate all input, prevent injection attacks, and implement proper error handling
  • Environment Variables: Store connection strings and credentials in environment variables, not in code
  • Regular Updates: Keep your drivers and application dependencies updated
  • Backup Strategy: Configure regular backups appropriate for your recovery needs

Setting Up Client-Side Field Level Encryption

For highly sensitive data, you can implement client-side field level encryption (CSFLE) to encrypt specific fields before they're sent to the database: 


// Node.js example of Client-Side Field Level Encryption
const { MongoClient, ClientEncryption } = require('mongodb');
const { readFileSync } = require('fs');

async function setupEncryptedConnection() {
  // Load the master key (should be securely managed in production)
  const localMasterKey = readFileSync('master-key.bin');
  
  // KMS providers configuration
  const kmsProviders = {
    local: {
      key: localMasterKey
    }
  };
  
  // Key vault namespace
  const keyVaultNamespace = 'encryption.__keyVault';
  
  // Schema map (which fields to encrypt)
  const schemaMap = {
    'mydatabase.patients': {
      bsonType: 'object',
      properties: {
        medicalRecordNumber: {
          encrypt: {
            bsonType: 'string',
            algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
          }
        },
        bloodType: {
          encrypt: {
            bsonType: 'string',
            algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
          }
        }
      }
    }
  };
  
  // Client with auto encryption
  const client = new MongoClient(process.env.MONGODB_URI, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    autoEncryption: {
      keyVaultNamespace,
      kmsProviders,
      schemaMap
    }
  });
  
  await client.connect();
  return client;
}

async function insertEncryptedDocument() {
  const client = await setupEncryptedConnection();
  
  try {
    const patientsCollection = client.db('mydatabase').collection('patients');
    
    // Insert document with encrypted fields
    await patientsCollection.insertOne({
      name: 'John Doe',
      medicalRecordNumber: 'MRN123456',  // Will be encrypted
      bloodType: 'O+',  // Will be encrypted
      dateOfBirth: new Date('1980-01-01')  // Not encrypted
    });
    
    console.log('Document inserted with encrypted fields');
  } finally {
    await client.close();
  }
}

insertEncryptedDocument().catch(console.error);

Practical Activities

Activity 1: Setting Up a Free Tier Cluster

  1. Create a MongoDB Atlas account if you don't have one
  2. Deploy a free tier (M0) cluster following the steps in this lecture
  3. Configure a database user with appropriate permissions
  4. Set up network access for your development environment
  5. Connect to your cluster using MongoDB Compass or the MongoDB Shell
  6. Create a test database and collection
  7. Insert, query, update, and delete some test documents

Activity 2: Building a Node.js Application with MongoDB Atlas

  1. Create a new Node.js Express application
  2. Connect it to your MongoDB Atlas cluster
  3. Implement a simple API with the following endpoints:
    • GET /api/items - List all items
    • GET /api/items/:id - Get a single item
    • POST /api/items - Create a new item
    • PUT /api/items/:id - Update an item
    • DELETE /api/items/:id - Delete an item
  4. Create a simple HTML frontend to interact with your API
  5. Implement proper error handling and validation
  6. Deploy your application to a hosting service like Heroku, Vercel, or Netlify

Activity 3: Exploring Advanced Atlas Features

  1. Enable Atlas Search on a collection
  2. Create a search index on specific fields
  3. Implement a text search feature in your application
  4. Set up automated backups for your cluster
  5. Create and test a restore operation
  6. Set up monitoring alerts for your cluster
  7. Use the Performance Advisor to identify and create optimal indexes
  8. Write a report on your findings and the benefits of these features

Further Reading and Resources

Coming Up: Mongoose ODM

In our next session, we'll dive deeper into Mongoose, the popular Object Data Modeling (ODM) library for MongoDB and Node.js. We'll learn how to define schemas, models, and relationships, and how to leverage Mongoose's powerful features to simplify working with MongoDB.