gRPC를 이용한 서비스 간 통신

// proto/users.proto (프로젝트 루트 또는 shared/proto 폴더에 생성)

syntax = "proto3"; // Protocol Buffers 3 문법 사용

package users; // 패키지 이름

// UserService 정의
service UserService {
  // GetUserById RPC 메서드 정의
  // UserByIdRequest 메시지를 받아 User 메시지를 반환
  rpc GetUserById (UserByIdRequest) returns (User);
  // CreateUser RPC 메서드 정의
  // CreateUserRequest 메시지를 받아 User 메시지를 반환
  rpc CreateUser (CreateUserRequest) returns (User);
}

// UserByIdRequest 메시지 정의
message UserByIdRequest {
  int32 id = 1; // 필드 번호 1
}

// CreateUserRequest 메시지 정의
message CreateUserRequest {
  string name = 1;
  string email = 2;
}

// User 메시지 정의 (응답 및 반환 타입)
message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

npm install @nestjs/microservices @grpc/grpc-js @grpc/proto-loader
npm install --save-dev @types/grpc__proto-loader

// users-service/src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { join } from 'path'; // path 모듈 임포트

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
    transport: Transport.GRPC, // gRPC 전송 방식 사용
    options: {
      package: 'users', // .proto 파일에 정의된 패키지 이름
      protoPath: join(__dirname, '../../proto/users.proto'), // .proto 파일 경로
      url: 'localhost:50051', // gRPC 서버가 리스닝할 주소와 포트
      loader: {
        keepCase: true, // 필드 이름을 스네이크 케이스로 유지 (선택 사항)
        longs: String, // 64비트 정수를 문자열로 처리 (선택 사항, 데이터 정밀도 이슈 방지)
        enums: String, // enum 값을 문자열로 처리 (선택 사항)
        defaults: true, // 기본값 포함 (선택 사항)
        oneofs: true, // oneof 필드 처리 (선택 사항)
      },
    },
  });
  await app.listen();
  console.log('Users gRPC Microservice is listening on localhost:50051');
}
bootstrap();

// users-service/src/users/users.controller.ts (수정)
import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices'; // GrpcMethod 임포트
import { UsersService } from './users.service';

interface User { // proto 파일과 일치하도록 타입 정의 (필요시)
  id: number;
  name: string;
  email: string;
}

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

  // .proto 파일의 UserService.GetUserById 메서드에 매핑
  @GrpcMethod('UserService', 'GetUserById')
  getUserById(data: { id: number }): User { // data는 UserByIdRequest 메시지
    console.log(`Users gRPC Service: Received request for user ID: ${data.id}`);
    const user = this.usersService.findOne(data.id);
    if (!user) {
      // gRPC는 에러 코드와 메시지를 통해 에러를 전달합니다.
      // throw new RpcException({ code: status.NOT_FOUND, message: 'User not found' });
      // 간단한 예제에서는 null 반환 또는 특정 값으로 대체
      return { id: 0, name: '', email: '' }; // .proto에서 non-nullable이므로 빈 객체 반환
    }
    return user;
  }

  // .proto 파일의 UserService.CreateUser 메서드에 매핑
  @GrpcMethod('UserService', 'CreateUser')
  createUser(data: { name: string; email: string }): User { // data는 CreateUserRequest 메시지
    console.log(`Users gRPC Service: Received request to create user: ${JSON.stringify(data)}`);
    const newUser = this.usersService.create(data);
    return newUser;
  }
}

npm install @nestjs/microservices @grpc/grpc-js @grpc/proto-loader rxjs
npm install --save-dev @types/grpc__proto-loader

// orders-service/src/orders/orders.module.ts (수정)
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { OrdersController } from './orders.controller';
import { OrdersService } from './orders.service';
import { join } from 'path'; // path 모듈 임포트

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'USERS_SERVICE', // 클라이언트 프록시 토큰
        transport: Transport.GRPC, // gRPC 전송 방식 사용
        options: {
          package: 'users', // 연결할 gRPC 서비스의 패키지 이름
          protoPath: join(__dirname, '../../proto/users.proto'), // .proto 파일 경로
          url: 'localhost:50051', // 연결할 gRPC 서버의 주소와 포트
          loader: {
            keepCase: true,
            longs: String,
            enums: String,
            defaults: true,
            oneofs: true,
          },
        },
      },
    ]),
  ],
  controllers: [OrdersController],
  providers: [OrdersService],
})
export class OrdersModule {}

// orders-service/src/orders/orders.controller.ts (수정)
import { Controller, Get, Post, Body, Param, Inject, OnModuleInit } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices'; // ClientGrpc 임포트
import { OrdersService } from './orders.service';
import { Observable } from 'rxjs'; // Observable 임포트
import { toPromise } from 'rxjs-await'; // toPromise 임포트 (RxJS 6+에서 toPromise()는 직접 제공되지 않을 수 있음)

// toPromise()가 없으면 rxjs/operators의 lastValueFrom()을 사용할 수 있습니다.
import { lastValueFrom } from 'rxjs';

// .proto 파일에 정의된 서비스 인터페이스 정의
interface UserService {
  GetUserById(data: { id: number }): Observable<User>; // gRPC 메서드명과 매핑
  CreateUser(data: { name: string; email: string }): Observable<User>;
}

interface User { // proto 파일과 일치하도록 타입 정의
  id: number;
  name: string;
  email: string;
}

@Controller('orders')
export class OrdersController implements OnModuleInit {
  private userService: UserService; // gRPC 서비스 프록시를 저장할 변수

  constructor(
    private readonly ordersService: OrdersService,
    @Inject('USERS_SERVICE') private readonly client: ClientGrpc, // gRPC 클라이언트 주입
  ) {}

  // 모듈 초기화 시 gRPC 서비스 프록시를 가져옵니다.
  onModuleInit() {
    // getService<T>('ServiceName')을 통해 gRPC 서비스의 프록시를 가져옵니다.
    this.userService = this.client.getService<UserService>('UserService');
  }

  @Get(':orderId/user')
  async getOrderUser(@Param('orderId') orderId: string): Promise<User | string> {
    const userId = parseInt(orderId, 10);

    try {
      // gRPC 서비스 메서드 호출
      const user = await lastValueFrom(this.userService.GetUserById({ id: userId }));
      // gRPC는 존재하지 않는 경우 필드 기본값을 반환할 수 있으므로, 유효성 검사 필요
      if (!user || user.id === 0) { // 예: id가 0이면 찾지 못했다고 가정
        return `User for order ${orderId} not found in Users gRPC Service.`;
      }
      return user;
    } catch (error) {
      console.error('gRPC Error:', error.details);
      return `Error fetching user from gRPC service: ${error.details || error.message}`;
    }
  }

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

    let user: User;
    if (userId) { // 기존 사용자 조회
      try {
        user = await lastValueFrom(this.userService.GetUserById({ id: userId }));
        if (!user || user.id === 0) { // 사용자가 없거나 유효하지 않다면
          return { message: `User with ID ${userId} not found in gRPC service.` };
        }
      } catch (error) {
        console.error('gRPC Error:', error.details);
        return { message: `Error fetching user from gRPC service: ${error.details || error.message}` };
      }
    } else if (userName && userEmail) { // 새 사용자 생성
      try {
        user = await lastValueFrom(this.userService.CreateUser({ name: userName, email: userEmail }));
      } catch (error) {
        console.error('gRPC Error:', error.details);
        return { message: `Error creating user via gRPC service: ${error.details || error.message}` };
      }
    } else {
      return { message: 'Either userId or (userName and userEmail) must be provided.' };
    }

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