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

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

npx @nestjs/cli@11 new users-service --skip-install
cd users-service
npm install @nestjs/microservices@11

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 | null {
    console.log(`Users Service: Received request for user ID: ${id}`);
    // 실제로는 DB에서 조회
    return this.usersService.findOne(id); // 사용자 없으면 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: '[email protected]' },
    { id: 2, name: 'Bob', email: '[email protected]' },
  ];
  private nextId = 3;

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

  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

npx @nestjs/cli@11 new orders-service --skip-install
cd orders-service
npm install @nestjs/microservices@11

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 {
  Body,
  Controller,
  Get,
  Inject,
  NotFoundException,
  Param,
  Post,
  RequestTimeoutException,
  ServiceUnavailableException,
} from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices'; // ClientProxy 임포트
import { OrdersService } from './orders.service';
import { firstValueFrom, timeout, TimeoutError } from 'rxjs';

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> {
    // 임시로 orderId를 사용자 ID로 사용한다고 가정
    const userId = parseInt(orderId, 10);
    const user = await this.requestUser(userId);

    if (!user) {
      throw new NotFoundException(`User for order ${orderId} not found.`);
    }
    return user;
  }

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

    const user = await this.requestUser(userId);

    if (!user) {
      throw new NotFoundException(`User with ID ${userId} not found.`);
    }

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

  private async requestUser(userId: number): Promise<User | null> {
    try {
      // send()는 cold Observable이므로 firstValueFrom()의 구독 때 전송됩니다.
      return await firstValueFrom(
        this.usersClient
          .send<User | null, number>('get_user_by_id', userId)
          .pipe(timeout(3000)),
      );
    } catch (error) {
      if (error instanceof TimeoutError) {
        throw new RequestTimeoutException('Users Service response timed out.');
      }
      throw new ServiceUnavailableException('Users Service request failed.');
    }
  }
}

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 {}