MongoDB with Microsoft Azure and ASP.NET Core – Complete End-to-End Guide with Real-Time E-Commerce Example

Introduction

Modern applications often need a database that can handle:

• Large volumes of data

• Rapidly changing data structures

• High read/write workloads

• Horizontal scalability

• JSON-based application data

• Microservices architectures

• Event-driven applications

MongoDB is a popular NoSQL document database designed for these types of workloads.

When MongoDB is deployed using MongoDB Atlas on Microsoft Azure, we can build a cloud-native architecture where:

Angular / React / Mobile
          |
          v
     Azure Front Door
          |
          v
 Azure API Management
          |
          v
 ASP.NET Core Web API
          |
          v
     MongoDB Atlas
       on Azure

MongoDB Atlas is MongoDB's fully managed cloud database service, and Atlas supports Microsoft Azure as a cloud provider. (MongoDB)

---

1. What is MongoDB?

MongoDB is a NoSQL document-oriented database.

Unlike SQL Server, where data is normally organized as:

Database
   |
   +-- Tables
          |
          +-- Rows

MongoDB organizes data as:

Database
   |
   +-- Collections
          |
          +-- Documents

A MongoDB document looks similar to JSON:

{
  "customerId": "CUST1001",
  "name": "Ravi Kumar",
  "email": "ravi@example.com",
  "city": "Hyderabad"
}

Internally MongoDB stores documents using BSON, which extends JSON with additional data types.

---

2. SQL Server vs MongoDB

SQL Server	MongoDB
Database	Database
Table	Collection
Row	Document
Column	Field
Primary Key	_id
JOIN	$lookup / application-level modeling
Stored Procedure	Application/service logic
Relational	Document-oriented
Fixed schema commonly used	Flexible document schema
SQL	MongoDB Query API

For example, SQL Server might contain:

Customers
-------------------------
CustomerId
Name
Email
City

MongoDB could contain:

{
  "_id": "CUST1001",
  "name": "Ravi Kumar",
  "email": "ravi@example.com",
  "city": "Hyderabad"
}

---

3. What is MongoDB Atlas?

MongoDB Atlas is the managed cloud service for MongoDB.

Instead of installing and maintaining MongoDB servers yourself, Atlas manages much of the database infrastructure.

Conceptually:

Your Application
       |
       | MongoDB Driver
       |
       v
+----------------------+
|   MongoDB Atlas      |
|                      |
|  MongoDB Cluster     |
|                      |
|  Database            |
|    |                 |
|  Collection          |
|    |                 |
|  Documents           |
+----------------------+

Atlas can deploy MongoDB clusters on Microsoft Azure. (MongoDB)

---

4. Why MongoDB on Azure?

A common enterprise architecture is:

Azure
│
├── Azure Front Door
│
├── API Management
│
├── AKS / App Service
│       │
│       └── ASP.NET Core APIs
│
├── Key Vault
│
├── Application Insights
│
└── MongoDB Atlas
        │
        └── MongoDB Cluster

Advantages include:

Scalability

MongoDB can scale horizontally using sharding.

High availability

Atlas supports replica-set based deployments, and Azure availability zones can be used for supported regions. (MongoDB)

Managed infrastructure

Atlas manages much of the operational database infrastructure.

Flexible document model

Different documents can contain different fields when your application requires a flexible schema.

Cloud integration

Applications running on Azure can connect to MongoDB Atlas using standard or private networking approaches.

---

5. Real-Time Example

Let's take an E-Commerce Order Management System.

Suppose customers place orders through an Angular application.

Architecture:

                Customer
                   |
                   v
            Angular Application
                   |
                   v
           Azure API Management
                   |
                   v
          ASP.NET Core Web API
                   |
       +-----------+-----------+
       |                       |
       v                       v
 MongoDB Atlas             Azure Service Bus
       |                       |
       v                       v
 Orders Collection       Other Microservices

The Order Service needs to store:

• Customer information

• Order information

• Products

• Quantity

• Price

• Shipping address

• Payment status

• Order status

• Created date

MongoDB is well suited to representing this as a document.

---

6. MongoDB Data Model

Our database can be:

ECommerceDB
   |
   +-- Orders
   |
   +-- Customers
   |
   +-- Products

For this example:

Database:
ECommerceDB

Collection:
Orders

---

7. Sample MongoDB Document

An order could look like this:

{
  "_id": "ORD10001",
  "customer": {
    "customerId": "CUST1001",
    "name": "Ravi Kumar",
    "email": "ravi@example.com"
  },
  "items": [
    {
      "productId": "P1001",
      "productName": "Laptop",
      "quantity": 1,
      "unitPrice": 75000
    },
    {
      "productId": "P1002",
      "productName": "Mouse",
      "quantity": 2,
      "unitPrice": 1500
    }
  ],
  "shippingAddress": {
    "street": "Hitech City",
    "city": "Hyderabad",
    "state": "Telangana",
    "country": "India",
    "postalCode": "500081"
  },
  "paymentStatus": "Paid",
  "orderStatus": "Confirmed",
  "totalAmount": 78000,
  "createdAt": "2026-09-17T08:30:00Z"
}

Notice that customer, items, and shipping information can be represented naturally inside the document.

---

8. MongoDB Terminology

Understanding the terminology is important.

MongoDB
   |
   +-- Database
          |
          +-- Collection
                  |
                  +-- Document
                          |
                          +-- Field

For our application:

MongoDB
   |
   +-- ECommerceDB
          |
          +-- Orders
          |
          +-- Customers
          |
          +-- Products

---

9. Create MongoDB Atlas on Azure

Go to MongoDB Atlas and create an Atlas organization/project.

When creating your cluster, select:

Cloud Provider:
Microsoft Azure

Then select an appropriate Azure region.

MongoDB currently lists Azure regions including Central India, South India and West India, among many other supported Azure regions. Availability and cluster-tier support vary by region. (MongoDB)

For an application primarily running in India, an appropriate India region can reduce network latency, subject to your application's requirements and the cluster tier available there.

---

10. Create Database User

Create a MongoDB database user such as:

Username:
ecommerce-api-user

Use a strong password.

Do not hard-code the password in source code.

Bad:

var connectionString =
    "mongodb+srv://user:password@cluster.mongodb.net";

Instead, use:

Azure Key Vault
       |
       v
ASP.NET Core
       |
       v
MongoDB Atlas

---

11. Configure Network Access

Atlas provides network controls that determine which clients can connect.

For development, you may configure an appropriate IP access rule.

For production, consider private networking where appropriate.

A production architecture could be:

Azure VNet
   |
   +-----------------------+
   |                       |
   v                       v
AKS                    Private Endpoint
   |                       |
   |                       v
   +--------------> MongoDB Atlas

MongoDB documents different connection approaches, including standard connections, peering and private endpoints depending on how the application network is configured. (MongoDB)

---

12. Get MongoDB Connection String

From Atlas, obtain the application connection string.

It generally resembles:

mongodb+srv://<username>:<password>@cluster0.xxxxx.mongodb.net/

The MongoDB .NET driver uses the connection URI together with MongoClient to establish the connection. (MongoDB)

Never publish your real connection string in GitHub or your blog.

---

13. Create ASP.NET Core Web API

Create the project:

dotnet new webapi -n Ecommerce.Api

Move into the project:

cd Ecommerce.Api

Install the MongoDB .NET driver:

dotnet add package MongoDB.Driver

MongoDB provides an official .NET/C# driver for connecting .NET applications to MongoDB deployments including Atlas. (MongoDB)

---

14. Configure appsettings.json

Create:

{
  "MongoDB": {
    "ConnectionString": "mongodb+srv://<username>:<password>@cluster0.xxxxx.mongodb.net/",
    "DatabaseName": "ECommerceDB",
    "OrdersCollectionName": "Orders"
  }
}

For production, don't store the actual secret directly in appsettings.json.

Instead:

Azure Key Vault
      |
      v
ASP.NET Core Configuration
      |
      v
MongoDB Driver

MongoDB's own REST API tutorial demonstrates storing the MongoDB URI, database name, and collection name in application configuration. (MongoDB)

---

15. Create MongoDB Settings Class

Create:

Configuration/
    MongoDbSettings.cs

public class MongoDbSettings
{
    public string ConnectionString { get; set; } = string.Empty;

    public string DatabaseName { get; set; } = string.Empty;

    public string OrdersCollectionName { get; set; } = string.Empty;
}

---

16. Create Order Model

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

public class Order
{
    [BsonId]
    public string Id { get; set; } = string.Empty;

    public Customer Customer { get; set; } = new();

    public List<OrderItem> Items { get; set; } = new();

    public ShippingAddress ShippingAddress { get; set; } = new();

    public decimal TotalAmount { get; set; }

    public string PaymentStatus { get; set; } = string.Empty;

    public string OrderStatus { get; set; } = string.Empty;

    public DateTime CreatedAt { get; set; }
}

---

17. Customer Model

public class Customer
{
    public string CustomerId { get; set; } = string.Empty;

    public string Name { get; set; } = string.Empty;

    public string Email { get; set; } = string.Empty;
}

---

18. OrderItem Model

public class OrderItem
{
    public string ProductId { get; set; } = string.Empty;

    public string ProductName { get; set; } = string.Empty;

    public int Quantity { get; set; }

    public decimal UnitPrice { get; set; }
}

---

19. ShippingAddress Model

public class ShippingAddress
{
    public string Street { get; set; } = string.Empty;

    public string City { get; set; } = string.Empty;

    public string State { get; set; } = string.Empty;

    public string Country { get; set; } = string.Empty;

    public string PostalCode { get; set; } = string.Empty;
}

---

20. Create MongoDB Service

Create:

Services/
    OrderService.cs

using MongoDB.Driver;

public class OrderService
{
    private readonly IMongoCollection<Order> _orders;

    public OrderService(IConfiguration configuration)
    {
        var connectionString =
            configuration["MongoDB:ConnectionString"];

        var databaseName =
            configuration["MongoDB:DatabaseName"];

        var collectionName =
            configuration["MongoDB:OrdersCollectionName"];

        var client = new MongoClient(connectionString);

        var database = client.GetDatabase(databaseName);

        _orders = database.GetCollection<Order>(collectionName);
    }
}

The basic MongoDB .NET architecture is:

MongoDB Connection String
          |
          v
     MongoClient
          |
          v
      Database
          |
          v
     Collection
          |
          v
      Documents

---

21. Insert Order

Add:

public async Task CreateAsync(Order order)
{
    await _orders.InsertOneAsync(order);
}

Complete example:

public async Task CreateAsync(Order order)
{
    order.Id = $"ORD{DateTime.UtcNow.Ticks}";

    order.CreatedAt = DateTime.UtcNow;

    await _orders.InsertOneAsync(order);
}

MongoDB creates the document in the Orders collection.

---

22. Insert Sample Data

You can insert this document:

{
  "_id": "ORD10001",
  "customer": {
    "customerId": "CUST1001",
    "name": "Ravi Kumar",
    "email": "ravi@example.com"
  },
  "items": [
    {
      "productId": "P1001",
      "productName": "Laptop",
      "quantity": 1,
      "unitPrice": 75000
    },
    {
      "productId": "P1002",
      "productName": "Mouse",
      "quantity": 2,
      "unitPrice": 1500
    }
  ],
  "shippingAddress": {
    "street": "Hitech City",
    "city": "Hyderabad",
    "state": "Telangana",
    "country": "India",
    "postalCode": "500081"
  },
  "totalAmount": 78000,
  "paymentStatus": "Paid",
  "orderStatus": "Confirmed",
  "createdAt": "2026-09-17T08:30:00Z"
}

---

23. Retrieve All Orders

public async Task<List<Order>> GetAllAsync()
{
    return await _orders
        .Find(_ => true)
        .ToListAsync();
}

Here:

.Find(_ => true)

means:

Return all documents.

---

24. Retrieve Order by ID

public async Task<Order?> GetByIdAsync(string id)
{
    return await _orders
        .Find(x => x.Id == id)
        .FirstOrDefaultAsync();
}

---

25. Search Orders by Customer

public async Task<List<Order>> GetByCustomerAsync(
    string customerId)
{
    return await _orders
        .Find(x => x.Customer.CustomerId == customerId)
        .ToListAsync();
}

This demonstrates querying a nested document property.

---

26. Search Orders by City

public async Task<List<Order>> GetByCityAsync(
    string city)
{
    return await _orders
        .Find(x => x.ShippingAddress.City == city)
        .ToListAsync();
}

For example:

GET /api/orders/city/Hyderabad

---

27. Update an Order

Suppose an order changes from:

Confirmed

to:

Shipped

We can write:

public async Task UpdateStatusAsync(
    string id,
    string status)
{
    var filter =
        Builders<Order>.Filter.Eq(x => x.Id, id);

    var update =
        Builders<Order>.Update
            .Set(x => x.OrderStatus, status);

    await _orders.UpdateOneAsync(
        filter,
        update);
}

---

28. Delete an Order

public async Task DeleteAsync(string id)
{
    await _orders.DeleteOneAsync(
        x => x.Id == id);
}

---

29. Create Controller

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly OrderService _service;

    public OrdersController(OrderService service)
    {
        _service = service;
    }

    [HttpGet]
    public async Task<IActionResult> GetAll()
    {
        var orders = await _service.GetAllAsync();

        return Ok(orders);
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetById(string id)
    {
        var order = await _service.GetByIdAsync(id);

        if (order == null)
            return NotFound();

        return Ok(order);
    }

    [HttpPost]
    public async Task<IActionResult> Create(Order order)
    {
        await _service.CreateAsync(order);

        return Ok(order);
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(string id)
    {
        await _service.DeleteAsync(id);

        return NoContent();
    }
}

---

30. Register MongoDB Service

In Program.cs:

builder.Services.AddSingleton<OrderService>();

Then:

var app = builder.Build();

app.MapControllers();

app.Run();

A simplified architecture becomes:

HTTP Request
     |
     v
OrdersController
     |
     v
OrderService
     |
     v
MongoClient
     |
     v
MongoDB Atlas
     |
     v
Orders Collection

---

31. POST Request Example

Send:

POST /api/orders
Content-Type: application/json

Request body:

{
  "customer": {
    "customerId": "CUST1002",
    "name": "Suresh",
    "email": "suresh@example.com"
  },
  "items": [
    {
      "productId": "P2001",
      "productName": "Mobile Phone",
      "quantity": 1,
      "unitPrice": 45000
    }
  ],
  "shippingAddress": {
    "street": "Madhapur",
    "city": "Hyderabad",
    "state": "Telangana",
    "country": "India",
    "postalCode": "500081"
  },
  "totalAmount": 45000,
  "paymentStatus": "Paid",
  "orderStatus": "Confirmed"
}

---

32. GET Request

GET /api/orders

Response:

[
  {
    "_id": "ORD10001",
    "customer": {
      "customerId": "CUST1001",
      "name": "Ravi Kumar"
    },
    "totalAmount": 78000,
    "orderStatus": "Confirmed"
  }
]

---

33. MongoDB Query Example

MongoDB shell query:

db.Orders.find({
    "customer.customerId": "CUST1001"
})

Another example:

db.Orders.find({
    "shippingAddress.city": "Hyderabad"
})

Find paid orders:

db.Orders.find({
    "paymentStatus": "Paid"
})

---

34. MongoDB Operators

MongoDB provides many query operators.

Greater Than

db.Orders.find({
    "totalAmount": {
        $gt: 50000
    }
})

Less Than

db.Orders.find({
    "totalAmount": {
        $lt: 50000
    }
})

Greater Than or Equal

db.Orders.find({
    "totalAmount": {
        $gte: 50000
    }
})

IN

db.Orders.find({
    "orderStatus": {
        $in: ["Confirmed", "Shipped"]
    }
})

---

35. MongoDB Indexes

Indexes are extremely important for production applications.

Suppose we frequently search:

CustomerId

Create an index:

db.Orders.createIndex({
    "customer.customerId": 1
})

For city:

db.Orders.createIndex({
    "shippingAddress.city": 1
})

For order status:

db.Orders.createIndex({
    "orderStatus": 1
})

The application should create indexes based on actual query patterns rather than creating indexes on every field.

MongoDB's .NET driver documentation includes dedicated guidance for creating and managing indexes. (MongoDB)

---

36. Compound Index

Suppose the application frequently queries:

Customer + Order Status

We can create:

db.Orders.createIndex({
    "customer.customerId": 1,
    "orderStatus": 1
})

This can support queries such as:

db.Orders.find({
    "customer.customerId": "CUST1001",
    "orderStatus": "Confirmed"
})

---

37. MongoDB Aggregation

Aggregation is one of MongoDB's powerful features.

Suppose we want:

Total sales by city

We can use:

db.Orders.aggregate([
    {
        $group: {
            _id: "$shippingAddress.city",
            totalSales: {
                $sum: "$totalAmount"
            }
        }
    }
])

Example result:

[
  {
    "_id": "Hyderabad",
    "totalSales": 2500000
  },
  {
    "_id": "Bangalore",
    "totalSales": 1800000
  }
]

---

38. Aggregation Pipeline

MongoDB aggregation works as a pipeline:

Documents
    |
    v
   $match
    |
    v
  $group
    |
    v
  $sort
    |
    v
 Result

Example:

db.Orders.aggregate([
    {
        $match: {
            "paymentStatus": "Paid"
        }
    },
    {
        $group: {
            _id: "$shippingAddress.city",
            totalSales: {
                $sum: "$totalAmount"
            }
        }
    },
    {
        $sort: {
            totalSales: -1
        }
    }
])

---

39. Consuming MongoDB Data from Angular

The frontend does not normally connect directly to MongoDB.

Instead:

Angular
   |
   | HTTP
   v
ASP.NET Core Web API
   |
   | MongoDB Driver
   v
MongoDB Atlas

Angular service:

@Injectable({
  providedIn: 'root'
})
export class OrderService {

  private apiUrl = 'https://api.example.com/api/orders';

  constructor(private http: HttpClient) {}

  getOrders() {
    return this.http.get<any[]>(this.apiUrl);
  }

  getOrder(id: string) {
    return this.http.get<any>(
      `${this.apiUrl}/${id}`
    );
  }
}

Component:

export class OrdersComponent {

  orders: any[] = [];

  constructor(
    private orderService: OrderService
  ) {}

  ngOnInit() {

    this.orderService
      .getOrders()
      .subscribe(data => {
        this.orders = data;
      });

  }
}

---

40. Complete Data Flow

When the Angular application requests orders:

1. User opens Orders screen
             |
             v
2. Angular sends HTTP GET
             |
             v
3. Azure API Management
             |
             v
4. ASP.NET Core API
             |
             v
5. OrderService
             |
             v
6. MongoDB Driver
             |
             v
7. MongoDB Atlas
             |
             v
8. Orders Collection
             |
             v
9. MongoDB returns documents
             |
             v
10. ASP.NET Core returns JSON
             |
             v
11. Angular displays data

---

41. Production Azure Architecture

For a larger enterprise system, the architecture could look like this:

                         Internet
                            |
                            v
                  +-------------------+
                  | Azure Front Door  |
                  +-------------------+
                            |
                            v
                  +-------------------+
                  | Azure API         |
                  | Management        |
                  +-------------------+
                            |
                            v
                  +-------------------+
                  | Azure Application |
                  | / AKS             |
                  +-------------------+
                            |
               +------------+------------+
               |                         |
               v                         v
        Order Microservice       Customer Service
               |                         |
               v                         v
        MongoDB Atlas              MongoDB Atlas
               |
               v
       Orders Collection

Supporting services:

Azure Key Vault
Azure Monitor
Application Insights
Azure Service Bus
Azure Container Registry
Azure DevOps

---

42. MongoDB with Microservices

MongoDB works particularly well with microservice architectures when each service owns its data.

For example:

Order Service
     |
     v
OrderDB
     |
     +-- Orders

Customer Service
     |
     v
CustomerDB
     |
     +-- Customers

Product Service
     |
     v
ProductDB
     |
     +-- Products

Instead of:

All Microservices
       |
       v
One Shared Database

we can use:

Order Service --------> Order Database

Customer Service -----> Customer Database

Product Service ------> Product Database

This helps maintain service ownership and reduces tight database coupling.

---

43. MongoDB and Azure Service Bus

Consider an order workflow:

Customer
   |
   v
Order API
   |
   v
MongoDB
   |
   v
Order Created
   |
   v
Azure Service Bus
   |
   +-----------> Inventory Service
   |
   +-----------> Payment Service
   |
   +-----------> Notification Service

For example:

{
  "eventType": "OrderCreated",
  "orderId": "ORD10001",
  "customerId": "CUST1001",
  "totalAmount": 78000
}

MongoDB stores the order state while Azure Service Bus can be used for asynchronous communication between services.

---

44. Security Architecture

A production architecture should avoid exposing database credentials.

Recommended:

Azure Key Vault
       |
       | Secret
       v
ASP.NET Core
       |
       | TLS
       v
MongoDB Atlas

Instead of:

appsettings.json
       |
       +-- username
       +-- password

Use:

Key Vault
   |
   v
Managed Identity
   |
   v
ASP.NET Core

Also consider:

• TLS encryption

• Network restrictions

• Private connectivity where appropriate

• Least-privilege database users

• Secret rotation

• Application-level authentication and authorization

• Audit and monitoring

---

45. Azure Deployment Flow

A typical CI/CD pipeline could be:

Developer
    |
    v
Git Repository
    |
    v
Azure DevOps Pipeline
    |
    +---- Build
    |
    +---- Unit Tests
    |
    +---- Security Scan
    |
    +---- Docker Build
    |
    +---- Push to ACR
    |
    v
Azure AKS
    |
    v
ASP.NET Core Container
    |
    v
MongoDB Atlas

---

46. Docker Example

A simplified Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base

WORKDIR /app

EXPOSE 8080

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build

WORKDIR /src

COPY . .

RUN dotnet restore

RUN dotnet publish \
    -c Release \
    -o /app/publish

FROM base AS final

WORKDIR /app

COPY --from=build /app/publish .

ENTRYPOINT ["dotnet", "Ecommerce.Api.dll"]

The container can then be deployed to Azure services such as AKS or another appropriate Azure hosting platform.

---

47. Performance Considerations

When using MongoDB in production, pay attention to:

1. Indexes

Create indexes for frequently executed queries.

2. Document Size

Avoid unnecessarily huge documents.

3. Query Projection

Retrieve only the fields you need when appropriate.

4. Connection Management

Reuse MongoClient rather than creating a new client for every request.

5. Pagination

Don't return millions of records in a single API request.

Example:

GET /api/orders?page=1&pageSize=50

6. Monitoring

Monitor:

CPU
Memory
Disk
Connections
Query performance
Latency
Operations per second

---

48. Pagination Example

A simple MongoDB pagination query:

public async Task<List<Order>> GetPagedAsync(
    int page,
    int pageSize)
{
    return await _orders
        .Find(_ => true)
        .Skip((page - 1) * pageSize)
        .Limit(pageSize)
        .ToListAsync();
}

For example:

page = 1
pageSize = 20

MongoDB returns the first 20 documents.

---

49. MongoDB Repository Pattern

For larger applications, you can introduce a repository layer:

Controller
    |
    v
Application Service
    |
    v
Repository
    |
    v
MongoDB

Example:

public interface IOrderRepository
{
    Task<List<Order>> GetAllAsync();

    Task<Order?> GetByIdAsync(string id);

    Task CreateAsync(Order order);

    Task UpdateAsync(Order order);

    Task DeleteAsync(string id);
}

Implementation:

public class OrderRepository : IOrderRepository
{
    private readonly IMongoCollection<Order> _orders;

    public OrderRepository(IMongoDatabase database)
    {
        _orders = database.GetCollection<Order>("Orders");
    }

    public async Task<List<Order>> GetAllAsync()
    {
        return await _orders
            .Find(_ => true)
            .ToListAsync();
    }

    public async Task<Order?> GetByIdAsync(string id)
    {
        return await _orders
            .Find(x => x.Id == id)
            .FirstOrDefaultAsync();
    }

    public async Task CreateAsync(Order order)
    {
        await _orders.InsertOneAsync(order);
    }

    public async Task UpdateAsync(Order order)
    {
        await _orders.ReplaceOneAsync(
            x => x.Id == order.Id,
            order);
    }

    public async Task DeleteAsync(string id)
    {
        await _orders.DeleteOneAsync(
            x => x.Id == id);
    }
}

---

50. Recommended Enterprise Project Structure

A clean architecture could look like:

Ecommerce.Api
│
├── Controllers
│     └── OrdersController.cs
│
├── Models
│     ├── Order.cs
│     ├── Customer.cs
│     └── OrderItem.cs
│
├── DTOs
│     ├── CreateOrderRequest.cs
│     └── OrderResponse.cs
│
├── Services
│     └── OrderService.cs
│
├── Repositories
│     ├── IOrderRepository.cs
│     └── OrderRepository.cs
│
├── Configuration
│     └── MongoDbSettings.cs
│
├── Program.cs
│
└── appsettings.json

---

51. MongoDB vs SQL Server – When to Use Which?

MongoDB can be useful when:

• Data is naturally document-oriented

• Schema changes frequently

• High-scale workloads require horizontal scaling

• Application data is naturally represented as JSON-like documents

• Microservices need independently owned data

• Flexible document structures are valuable

SQL Server can be preferable when:

• Strong relational modeling is central

• Complex joins dominate the workload

• Existing enterprise applications rely heavily on relational features

• Strong transactional relational constraints are fundamental

The choice should be based on workload and data requirements rather than simply choosing NoSQL because it is newer.

---

52. Real-Time End-to-End Example

Let's put everything together.

Suppose a customer purchases a laptop.

Step 1 – Customer

Customer submits:

Laptop
Quantity: 1
Price: ₹75,000

Step 2 – Angular

Angular sends:

POST /api/orders

Step 3 – Azure API Management

APIM handles API gateway responsibilities.

Step 4 – ASP.NET Core

The Order Controller receives the request.

Step 5 – Order Service

The service validates the order.

Step 6 – MongoDB

The Order Service saves:

{
  "_id": "ORD10001",
  "customer": {
    "customerId": "CUST1001"
  },
  "items": [
    {
      "productId": "P1001",
      "quantity": 1,
      "unitPrice": 75000
    }
  ],
  "totalAmount": 75000,
  "orderStatus": "Confirmed"
}

Step 7 – Event

The service publishes:

OrderCreated

to Azure Service Bus.

Step 8 – Inventory

Inventory Service receives the event.

Laptop Stock
100 → 99

Step 9 – Payment

Payment Service processes payment.

Step 10 – Notification

Notification Service sends the order confirmation.

Complete flow:

Angular
   |
   v
Azure API Management
   |
   v
Order API
   |
   v
Order Service
   |
   +--------------------+
   |                    |
   v                    v
MongoDB Atlas       Azure Service Bus
   |                    |
   |             +------+------+
   |             |             |
   |             v             v
   |        Inventory      Payment
   |                         |
   |                         v
   |                    Notification
   |
   v
Order Status

---

53. Important Production Best Practices

Database

• Use appropriate indexes.

• Design documents around access patterns.

• Avoid unnecessarily large documents.

• Monitor slow queries.

• Use appropriate replication/high availability configuration.

Application

• Reuse MongoClient.

• Use asynchronous APIs.

• Implement pagination.

• Use DTOs rather than exposing internal models directly.

• Validate incoming requests.

Security

• Never commit passwords.

• Use Azure Key Vault.

• Use least-privilege database accounts.

• Restrict network access.

• Use encrypted connections.

Azure

• Use Application Insights/Azure Monitor.

• Use managed identities where applicable.

• Use private networking where appropriate.

• Use CI/CD.

• Use autoscaling based on workload requirements.

Architecture

• Keep database ownership with the appropriate service.

• Use Service Bus for asynchronous communication where appropriate.

• Don't make every microservice directly access every other service's database.

---

54. Complete Architecture Summary

The complete enterprise architecture can be represented as:

                         USERS
                           |
                           v
                    Angular / Mobile
                           |
                           v
                  +-------------------+
                  | Azure Front Door  |
                  +-------------------+
                           |
                           v
                  +-------------------+
                  | Azure API         |
                  | Management        |
                  +-------------------+
                           |
                           v
                +-----------------------+
                | Azure AKS / App       |
                | Service               |
                +-----------------------+
                           |
                           v
                 ASP.NET Core Web API
                           |
              +------------+-------------+
              |                          |
              v                          v
       MongoDB Atlas              Azure Service Bus
              |                          |
              v                    +-----+------+
       ECommerceDB                 |            |
              |                    v            v
          Collections          Inventory     Payment
              |
       +------+------+
       |             |
    Orders        Customers
       |
       v
   Products
       
Supporting Services:
       
Azure Key Vault
Azure Monitor
Application Insights
Azure Container Registry
Azure DevOps

---

55. Conclusion

MongoDB provides a document-oriented approach to data storage that can be particularly useful for modern cloud-native and microservices applications.

When combined with MongoDB Atlas on Microsoft Azure, an ASP.NET Core application can follow a cloud architecture such as:

Frontend
   ↓
Azure API Management
   ↓
ASP.NET Core
   ↓
MongoDB Atlas on Azure

For an enterprise application, this can be extended with:

Azure Front Door
       ↓
API Management
       ↓
AKS
       ↓
Microservices
       ↓
MongoDB Atlas
       +
Azure Service Bus
       +
Azure Key Vault
       +
Application Insights

The official MongoDB .NET driver provides the APIs needed to connect to Atlas and perform CRUD, aggregation, indexing, and other database operations. (MongoDB)

Useful official references

MongoDB Atlas on Microsoft Azure
MongoDB .NET/C# Driver documentation
.NET Driver – Get Started
MongoDB Atlas Driver Connection Guide