마이크로서비스 개념과 NestJS 적용

# 새로운 사용자 서비스 프로젝트 생성
nest new users-service --skip-install
cd users-service
npm install @nestjs/microservices
npm install

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { MicroserviceOptions, Transport } from '@nestjs/microservices'; // MicroserviceOptions, Transport 임포트

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
    transport: Transport.TCP, // TCP 전송 방식 사용
    options: {
      host: 'localhost', // 서비스가 바인딩될 호스트
      port: 3001,        // 서비스가 리스닝할 포트
    },
  });
  await app.listen();
  console.log('Users Microservice is listening on port 3001');
}
bootstrap();

import { Controller } from '@nestjs/common';
import { MessagePattern, Payload } from '@nestjs/microservices'; // MessagePattern, Payload 임포트
import { UsersService } from './users.service';

interface User {
  id: number;
  name: string;
  email: string;
}

@Controller() // 마이크로서비스 컨트롤러는 일반적으로 경로가 없습니다.
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  // 'get_user_by_id' 메시지 패턴에 대한 핸들러
  @MessagePattern('get_user_by_id')
  getUserById(@Payload() id: number): User {
    console.log(`Users Service: Received request for user ID: ${id}`);
    // 실제로는 DB에서 조회
    const user = this.usersService.findOne(id);
    return user || null; // 사용자 없으면 null 반환
  }

  // 'create_user' 메시지 패턴에 대한 핸들러
  @MessagePattern('create_user')
  createUser(@Payload() userDto: { name: string; email: string }): User {
    console.log(`Users Service: Received request to create user: ${JSON.stringify(userDto)}`);
    const newUser = this.usersService.create(userDto);
    return newUser;
  }
}

import { Injectable } from '@nestjs/common';

interface User {
  id: number;
  name: string;
  email: string;
}

@Injectable()
export class UsersService {
  private users: User[] = [
    { id: 1, name: 'Alice', email: 'alice@example.com' },
    { id: 2, name: 'Bob', email: 'bob@example.com' },
  ];
  private nextId = 3;

  findOne(id: number): User | undefined {
    return this.users.find(user => user.id === id);
  }

  create(user: { name: string; email: string }): User {
    const newUser = { id: this.nextId++, ...user };
    this.users.push(newUser);
    return newUser;
  }
}

import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';

@Module({
  imports: [UsersModule],
  controllers: [],
  providers: [],
})
export class AppModule {}

# 새로운 주문 서비스 프로젝트 생성
nest new orders-service --skip-install
cd orders-service
npm install @nestjs/microservices
npm install

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000); // HTTP 요청을 받을 포트
  console.log('Orders Service is listening on port 3000 (HTTP)');
}
bootstrap();

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices'; // ClientsModule, Transport 임포트
import { OrdersController } from './orders.controller';
import { OrdersService } from './orders.service';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'USERS_SERVICE', // 클라이언트 프록시의 토큰 (주입 시 사용)
        transport: Transport.TCP, // Users Service와 동일한 전송 방식
        options: {
          host: 'localhost',
          port: 3001, // Users Service가 리스닝하는 포트
        },
      },
    ]),
  ],
  controllers: [OrdersController],
  providers: [OrdersService],
})
export class OrdersModule {}

import { Controller, Get, Post, Body, Param, Inject } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices'; // ClientProxy 임포트
import { OrdersService } from './orders.service';
import { Observable } from 'rxjs'; // Observable 임포트 (RxJS)
import { map } from 'rxjs/operators';

interface User {
  id: number;
  name: string;
  email: string;
}

@Controller('orders') // HTTP 엔드포인트
export class OrdersController {
  constructor(
    private readonly ordersService: OrdersService,
    @Inject('USERS_SERVICE') private readonly usersClient: ClientProxy, // 'USERS_SERVICE' 클라이언트 주입
  ) {}

  @Get(':orderId/user')
  async getOrderUser(@Param('orderId') orderId: string): Promise<User | string> {
    // 임시로 orderId를 사용자 ID로 사용한다고 가정
    const userId = parseInt(orderId, 10);

    // 'get_user_by_id' 패턴으로 사용자 서비스에 메시지 전송
    // send() 메서드는 Observable을 반환합니다.
    const userObservable: Observable<User> = this.usersClient.send('get_user_by_id', userId);

    return userObservable.pipe(
      map(user => {
        if (!user) {
          return `User for order ${orderId} not found in Users Service.`;
        }
        return user;
      })
    ).toPromise(); // Observable을 Promise로 변환하여 HTTP 응답
  }

  @Post('/create-order-with-user')
  async createOrderWithUser(@Body() orderDto: { userId: number; item: string }): Promise<any> {
    const { userId, item } = orderDto;

    // 사용자 서비스에 사용자 정보 요청 (Blocking call, 실제로는 비동기적으로 처리)
    const user: User = await this.usersClient.send('get_user_by_id', userId).toPromise();

    if (!user) {
      return { message: `User with ID ${userId} not found.` };
    }

    const order = this.ordersService.createOrder(userId, item);
    return { order, user };
  }
}

import { Injectable } from '@nestjs/common';

interface Order {
  id: number;
  userId: number;
  item: string;
  createdAt: Date;
}

@Injectable()
export class OrdersService {
  private orders: Order[] = [];
  private nextId = 1;

  createOrder(userId: number, item: string): Order {
    const newOrder = {
      id: this.nextId++,
      userId,
      item,
      createdAt: new Date(),
    };
    this.orders.push(newOrder);
    return newOrder;
  }
}

import { Module } from '@nestjs/common';
import { OrdersModule } from './orders/orders.module';

@Module({
  imports: [OrdersModule],
  controllers: [],
  providers: [],
})
export class AppModule {}