Developing Microservices with NestJS and MongoDB for Scalability

In the ever-evolving world of software development, scalability and maintainability are paramount. Microservices architecture has emerged as a robust solution to these challenges, allowing developers to build modular applications that can be deployed independently. In this article, we’ll explore how to develop microservices using NestJS and MongoDB, two powerful tools that simplify the process while enhancing performance. Whether you’re a seasoned developer or a newcomer, this guide will provide actionable insights and code examples to get you started.

Understanding Microservices Architecture

What are Microservices?

Microservices architecture is a design approach where an application is structured as a collection of loosely coupled services. Each service is responsible for a specific business capability, enabling teams to develop, deploy, and scale applications independently. This architecture offers several benefits:

• Scalability: Services can be scaled individually based on demand.
• Flexibility: Different technologies can be used for different services.
• Resilience: Failure in one service doesn’t affect the entire application.

Why Choose NestJS and MongoDB?

• NestJS: A progressive Node.js framework that leverages TypeScript, making it easy to build scalable and maintainable server-side applications. It incorporates the best practices from Angular and provides a modular architecture.
• MongoDB: A NoSQL database that stores data in flexible, JSON-like documents. It’s designed for scalability and high availability, making it an excellent choice for microservices.

Setting Up Your Environment

Before diving into coding, ensure you have the following tools installed on your machine:

• Node.js: Version 14 or higher
• MongoDB: Either locally or using a cloud service like MongoDB Atlas
• Nest CLI: Install using npm:

bash npm i -g @nestjs/cli

Creating a Microservice with NestJS

Step 1: Initialize a New NestJS Project

Start by creating a new NestJS project:

nest new microservice-demo
cd microservice-demo

Step 2: Install Required Packages

You’ll need the MongoDB driver and Mongoose for data modeling:

npm install @nestjs/mongoose mongoose

Step 3: Create a User Module

Let’s create a simple user management microservice. Begin by generating a new module, service, and controller:

nest generate module users
nest generate service users
nest generate controller users

Step 4: Define User Schema

Create a user schema to define the structure of your data. In users/schema/user.schema.ts, add:

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class User extends Document {
  @Prop({ required: true })
  name: string;

  @Prop({ required: true, unique: true })
  email: string;

  @Prop()
  age: number;
}

export const UserSchema = SchemaFactory.createForClass(User);

Step 5: Update Users Module

In users/users.module.ts, import Mongoose and register the User schema:

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
import { User, UserSchema } from './schema/user.schema';

@Module({
  imports: [MongooseModule.forFeature([{ name: User.name, schema: UserSchema }])],
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

Step 6: Implement Users Service

Next, implement the user service in users/users.service.ts:

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User } from './schema/user.schema';

@Injectable()
export class UsersService {
  constructor(@InjectModel(User.name) private userModel: Model<User>) {}

  async create(userDto: CreateUserDto): Promise<User> {
    const createdUser = new this.userModel(userDto);
    return createdUser.save();
  }

  async findAll(): Promise<User[]> {
    return this.userModel.find().exec();
  }
}

Step 7: Define User DTO

Create a Data Transfer Object (DTO) for user creation in users/dto/create-user.dto.ts:

import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';

export class CreateUserDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsEmail()
  email: string;

  @IsOptional()
  age?: number;
}

Step 8: Implement Users Controller

Finally, implement the controller in users/users.controller.ts:

import { Body, Controller, Get, Post } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { UsersService } from './users.service';
import { User } from './schema/user.schema';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  async create(@Body() createUserDto: CreateUserDto): Promise<User> {
    return this.usersService.create(createUserDto);
  }

  @Get()
  async findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }
}

Step 9: Connect to MongoDB

In your main application file main.ts, connect to MongoDB:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { MongooseModule } from '@nestjs/mongoose';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await MongooseModule.forRoot('mongodb://localhost/nest'); // Update with your MongoDB URI
  await app.listen(3000);
}
bootstrap();

Testing Your Microservice

Run your application with:

npm run start

Use Postman or any API client to test your endpoints:

• Create User: POST to http://localhost:3000/users with a JSON body like:

json { "name": "John Doe", "email": "john@example.com", "age": 30 }

• Get Users: GET http://localhost:3000/users.

Conclusion

By following this guide, you’ve built a basic microservice using NestJS and MongoDB, which can be scaled and maintained independently. This architecture not only enhances your application’s performance but also improves collaboration among teams. As you further develop your microservices, consider exploring additional features like authentication, logging, and service communication to enhance functionality and robustness.

With NestJS and MongoDB, you have the tools to build scalable applications that can grow alongside your business needs. Happy coding!