gRPC API

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// user.proto 파일 예시
syntax = "proto3"; // 프로토콜 버퍼 버전 지정

package user;

// 사용자 서비스 정의
service UserService {
  // 사용자 정보를 가져오는 RPC
  rpc GetUser (UserRequest) returns (UserResponse) {}
  // 사용자 생성 RPC
  rpc CreateUser (CreateUserRequest) returns (UserResponse) {}
}

// 요청 메시지 정의
message UserRequest {
  int32 user_id = 1;
}

// 사용자 생성 요청 메시지
message CreateUserRequest {
  string name = 1;
  string email = 2;
}

// 응답 메시지 정의
message UserResponse {
  int32 user_id = 1;
  string name = 2;
  string email = 3;
  enum Status {
    ACTIVE = 0;
    INACTIVE = 1;
    BANNED = 2;
  }
  Status status = 4;
}

1
2
3
4

# protoc 명령어 예시 (Node.js용 코드 생성)
protoc --js_out=import_style=commonjs,binary:./generated \
       --grpc-web_out=import_style=commonjs,mode=grpcwebtext:./generated \
       ./protos/*.proto

1

protoc --java_out=./generated-sources --grpc-java_out=./generated-sources greeting.proto

1
2
3
4
5
6
7
8

// Node.js에서의 오류 처리 예시
try {
  const response = await client.getUser({ user_id: 123 });
  console.log(response);
} catch (error) {
  console.error(`오류 발생: ${error.code} - ${error.message}`);
  // error.code는 gRPC 상태 코드를 포함합니다
}

1
2
3
4

// 클라이언트 측 메타데이터 예시 (Node.js)
const metadata = new grpc.Metadata();
metadata.set('authorization', 'Bearer ' + token);
client.getUser({ user_id: 123 }, metadata, callback);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 서버 측 SSL/TLS 설정
const fs = require('fs');
const grpc = require('@grpc/grpc-js');

const server = new grpc.Server();
// 서비스 등록…

// SSL/TLS 자격 증명 생성
const serverCredentials = grpc.ServerCredentials.createSsl(
  fs.readFileSync('ca.pem'),  // 루트 인증서
  [{
    private_key: fs.readFileSync('server-key.pem'),
    cert_chain: fs.readFileSync('server-cert.pem')
  }],
  true  // 클라이언트 인증 요구 여부
);

server.bindAsync('0.0.0.0:50051', serverCredentials, (err, port) => {
  if (!err) server.start();
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 클라이언트 측 SSL/TLS 설정
const grpc = require('@grpc/grpc-js');
const fs = require('fs');

// SSL/TLS 자격 증명 생성
const channelCredentials = grpc.credentials.createSsl(
  fs.readFileSync('ca.pem'),  // 루트 인증서
  fs.readFileSync('client-key.pem'),  // 클라이언트 키
  fs.readFileSync('client-cert.pem')  // 클라이언트 인증서
);

// 보안 채널을 통한 클라이언트 생성
const client = new userProto.UserService(
  'localhost:50051',
  channelCredentials
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 클라이언트 측 토큰 전송
function getAuthenticatedUser(userId) {
  // 메타데이터 객체 생성
  const metadata = new grpc.Metadata();
  metadata.add('authorization', 'Bearer ' + authToken);
  
  return new Promise((resolve, reject) => {
    client.getUser({ user_id: userId }, metadata, (err, response) => {
      if (err) {
        reject(err);
        return;
      }
      resolve(response);
    });
  });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// 서버 측 토큰 검증
function authInterceptor(options, nextCall) {
  return new grpc.InterceptingCall(nextCall(options), {
    start: function(metadata, listener, next) {
      const authHeader = metadata.get('authorization');
      
      if (!authHeader || !validateToken(authHeader[0])) {
        const error = {
          code: grpc.status.UNAUTHENTICATED,
          details: 'Invalid or missing authentication token'
        };
        
        const newListener = {
          onReceiveStatus: function(status, next) {
            next(error);
          }
        };
        
        next(metadata, newListener);
        return;
      }
      
      // 인증 성공, 계속 진행
      next(metadata, listener);
    }
  });
}

// 토큰 검증 로직
function validateToken(authHeader) {
  // "Bearer <token>" 형식에서 토큰 추출
  const token = authHeader.split(' ')[1];
  
  // 토큰 검증 로직 (JWT 등)
  // 실제 구현에서는 JWT 라이브러리 등을 사용하여 검증
  return token && token.length > 0;
}

// 인터셉터를 서버에 등록
const server = new grpc.Server({
  interceptors: [authInterceptor]
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// 권한 확인 함수
function checkPermission(metadata, method) {
  // 토큰에서 사용자 정보 및 역할 추출
  const authHeader = metadata.get('authorization')[0];
  const token = authHeader.split(' ')[1];
  const userInfo = decodeToken(token); // JWT 등에서 사용자 정보 추출
  
  // 메서드별 필요 권한 매핑
  const methodPermissions = {
    'GetUser': ['user:read', 'admin'],
    'CreateUser': ['user:write', 'admin'],
    'DeleteUser': ['admin'] // 관리자만 가능
  };
  
  // 필요한 권한 확인
  const requiredRoles = methodPermissions[method] || [];
  const userRoles = userInfo.roles || [];
  
  // 사용자 역할이 필요 권한 중 하나라도 포함하는지 확인
  return requiredRoles.some(role => userRoles.includes(role));
}

// 인터셉터에서 권한 확인
function authorizationInterceptor(options, nextCall) {
  return new grpc.InterceptingCall(nextCall(options), {
    start: function(metadata, listener, next) {
      // 메서드 이름 추출
      const method = options.method_definition.path.split('/').pop();
      
      if (!checkPermission(metadata, method)) {
        const error = {
          code: grpc.status.PERMISSION_DENIED,
          details: `Permission denied for method: ${method}`
        };
        
        const newListener = {
          onReceiveStatus: function(status, next) {
            next(error);
          }
        };
        
        next(metadata, newListener);
        return;
      }
      
      // 권한 확인 성공, 계속 진행
      next(metadata, listener);
    }
  });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// 간단한 메모리 기반 속도 제한 구현
class RateLimiter {
  constructor(limit, windowMs) {
    this.limit = limit; // 윈도우 기간 동안 허용되는 최대 요청 수
    this.windowMs = windowMs; // 밀리초 단위의 시간 윈도우
    this.clients = new Map(); // 클라이언트 IP 또는 ID별 요청 카운터
  }
  
  isAllowed(clientId) {
    const now = Date.now();
    
    if (!this.clients.has(clientId)) {
      // 새 클라이언트 등록
      this.clients.set(clientId, {
        count: 1,
        resetTime: now + this.windowMs
      });
      return true;
    }
    
    const client = this.clients.get(clientId);
    
    // 윈도우 기간이 지났으면 카운터 리셋
    if (now > client.resetTime) {
      client.count = 1;
      client.resetTime = now + this.windowMs;
      return true;
    }
    
    // 제한 내에 있는지 확인
    if (client.count < this.limit) {
      client.count++;
      return true;
    }
    
    // 제한 초과
    return false;
  }
}

// 속도 제한 인터셉터
const rateLimiter = new RateLimiter(100, 60 * 1000); // 분당 100 요청

function rateLimitInterceptor(options, nextCall) {
  return new grpc.InterceptingCall(nextCall(options), {
    start: function(metadata, listener, next) {
      // 클라이언트 ID 추출 (IP, 인증 토큰 등)
      const clientId = extractClientId(metadata);
      
      if (!rateLimiter.isAllowed(clientId)) {
        const error = {
          code: grpc.status.RESOURCE_EXHAUSTED,
          details: 'Rate limit exceeded. Try again later.'
        };
        
        const newListener = {
          onReceiveStatus: function(status, next) {
            next(error);
          }
        };
        
        next(metadata, newListener);
        return;
      }
      
      // 속도 제한 내에 있음, 계속 진행
      next(metadata, listener);
    }
  });
}

// 클라이언트 ID 추출 함수
function extractClientId(metadata) {
  // 인증 토큰에서 사용자 ID 추출
  const authHeader = metadata.get('authorization');
  if (authHeader && authHeader.length > 0) {
    const token = authHeader[0].split(' ')[1];
    const decoded = decodeToken(token);
    return decoded.sub || decoded.userId;
  }
  
  // IP 주소 사용 (실제로는 X-Forwarded-For 등 고려 필요)
  const clientIp = metadata.get('x-forwarded-for') || 'unknown';
  return clientIp;
}

1
2
3

# Protocol Buffer 컴파일러 설치 (Ubuntu)
$ apt-get install -y protobuf-compiler
$ protoc --version  # 버전 확인

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 로깅 인터셉터
function loggingInterceptor(options, nextCall) {
  return new grpc.InterceptingCall(nextCall(options), {
    start: function(metadata, listener, next) {
      const startTime = Date.now();
      const method = options.method_definition.path;
      console.log(`[${new Date().toISOString()}] gRPC 호출 시작: ${method}`);
      
      // 응답 리스너 래핑
      const newListener = {
        onReceiveMessage: function(message, next) {
          console.log(`[${new Date().toISOString()}] 메시지 수신: ${JSON.stringify(message)}`);
          next(message);
        },
        onReceiveStatus: function(status, next) {
          const duration = Date.now() - startTime;
          console.log(`[${new Date().toISOString()}] gRPC 호출 완료: ${method}, 상태: ${status.code}, 소요 시간: ${duration}ms`);
          next(status);
        }
      };
      
      next(metadata, newListener);
    },
    sendMessage: function(message, next) {
      console.log(`[${new Date().toISOString()}] 메시지 전송: ${JSON.stringify(message)}`);
      next(message);
    }
  });
}

// 인터셉터 등록
const server = new grpc.Server({
  interceptors: [loggingInterceptor]
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

const opentelemetry = require('@opentelemetry/api');
const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { GrpcInstrumentation } = require('@opentelemetry/instrumentation-grpc');
const { ZipkinExporter } = require('@opentelemetry/exporter-zipkin');
const { SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');

// 트레이서 제공자 설정
const provider = new NodeTracerProvider();

// Zipkin 익스포터 설정
const zipkinExporter = new ZipkinExporter({
  url: 'http://localhost:9411/api/v2/spans',
  serviceName: 'user-service'
});

// 스팬 프로세서 등록
provider.addSpanProcessor(new SimpleSpanProcessor(zipkinExporter));

// 제공자를 글로벌로 등록
provider.register();

// gRPC 계측 등록
registerInstrumentations({
  instrumentations: [
    new GrpcInstrumentation()
  ]
});

// 이제 gRPC 호출이 자동으로 추적됩니다

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// health.proto
syntax = "proto3";

package grpc.health.v1;

message HealthCheckRequest {
  string service = 1;
}

message HealthCheckResponse {
  enum ServingStatus {
    UNKNOWN = 0;
    SERVING = 1;
    NOT_SERVING = 2;
    SERVICE_UNKNOWN = 3;
  }
  ServingStatus status = 1;
}

service Health {
  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
  rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const path = require('path');

// 헬스 체크 proto 로드
const HEALTH_PROTO_PATH = path.join(__dirname, 'protos/health.proto');
const healthPackageDefinition = protoLoader.loadSync(HEALTH_PROTO_PATH);
const healthProto = grpc.loadPackageDefinition(healthPackageDefinition).grpc.health.v1;

// 서비스 상태 저장
const serviceStatus = {
  '': { status: 'SERVING' },  // 기본 상태 (전체 서버)
  'userservice.UserService': { status: 'SERVING' }  // 특정 서비스 상태
};

// 헬스 체크 서비스 구현
const healthImplementation = {
  check: (call, callback) => {
    const service = call.request.service;
    
    if (serviceStatus[service]) {
      callback(null, { 
        status: healthProto.HealthCheckResponse.ServingStatus[serviceStatus[service].status] 
      });
    } else {
      callback(null, { 
        status: healthProto.HealthCheckResponse.ServingStatus.SERVICE_UNKNOWN 
      });
    }
  },
  
  watch: (call) => {
    const service = call.request.service;
    
    if (!serviceStatus[service]) {
      call.write({ 
        status: healthProto.HealthCheckResponse.ServingStatus.SERVICE_UNKNOWN 
      });
      call.end();
      return;
    }
    
    // 초기 상태 전송
    call.write({ 
      status: healthProto.HealthCheckResponse.ServingStatus[serviceStatus[service].status] 
    });
    
    // 실제 구현에서는 서비스 상태 변경 이벤트를 구독하고
    // 상태가 변경될 때마다 새 상태를 전송할 수 있습니다
  }
};

// 메인 서버에 헬스 체크 서비스 추가
function addHealthService(server) {
  server.addService(healthProto.Health.service, healthImplementation);
}

1
2
3
4
5
6
7

# 프로젝트 디렉토리 생성 및 초기화
mkdir grpc-example
cd grpc-example
npm init -y

# 필요한 패키지 설치
npm install @grpc/grpc-js @grpc/proto-loader

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// 파일: protos/user_service.proto
syntax = "proto3";

package userservice;

// 사용자 서비스 정의
service UserService {
  // 사용자 정보 조회
  rpc GetUser (UserRequest) returns (UserResponse);
  
  // 사용자 목록 스트리밍
  rpc ListUsers (UsersRequest) returns (stream UserResponse);
  
  // 사용자 생성
  rpc CreateUser (CreateUserRequest) returns (UserResponse);
}

// 사용자 조회 요청
message UserRequest {
  string user_id = 1;
}

// 사용자 목록 요청
message UsersRequest {
  int32 limit = 1;  // 조회할 최대 사용자 수
}

// 사용자 생성 요청
message CreateUserRequest {
  string name = 1;
  string email = 2;
  int32 age = 3;
}

// 사용자 응답
message UserResponse {
  string user_id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
  string created_at = 5;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// 파일: server.js
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const path = require('path');

// Proto 파일 로드
const PROTO_PATH = path.join(__dirname, 'protos/user_service.proto');
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
});

const userProto = grpc.loadPackageDefinition(packageDefinition).userservice;

// 임시 데이터 저장소 (실제 애플리케이션에서는 데이터베이스를 사용할 것입니다)
const users = [
  {
    user_id: '1',
    name: '홍길동',
    email: 'hong@example.com',
    age: 30,
    created_at: new Date().toISOString()
  },
  {
    user_id: '2',
    name: '김철수',
    email: 'kim@example.com',
    age: 25,
    created_at: new Date().toISOString()
  }
];

// 서비스 메서드 구현
const getUser = (call, callback) => {
  const userId = call.request.user_id;
  const user = users.find(u => u.user_id === userId);
  
  if (user) {
    callback(null, user);
  } else {
    callback({
      code: grpc.status.NOT_FOUND,
      details: `User with ID ${userId} not found`
    });
  }
};

const listUsers = (call) => {
  const limit = call.request.limit || users.length;
  
  // 스트리밍 응답을 보냅니다
  users.slice(0, limit).forEach(user => {
    call.write(user);
  });
  
  // 스트림 종료
  call.end();
};

const createUser = (call, callback) => {
  const user = {
    user_id: (users.length + 1).toString(),
    name: call.request.name,
    email: call.request.email,
    age: call.request.age,
    created_at: new Date().toISOString()
  };
  
  users.push(user);
  callback(null, user);
};

// 서버 시작
function startServer() {
  const server = new grpc.Server();
  server.addService(userProto.UserService.service, {
    getUser,
    listUsers,
    createUser
  });
  
  server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), (err, port) => {
    if (err) {
      console.error('Failed to bind server:', err);
      return;
    }
    
    console.log(`Server running at http://0.0.0.0:${port}`);
    server.start();
  });
}

startServer();

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

// 파일: client.js
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const path = require('path');

// Proto 파일 로드 (서버와 동일)
const PROTO_PATH = path.join(__dirname, 'protos/user_service.proto');
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
});

const userProto = grpc.loadPackageDefinition(packageDefinition).userservice;

// 클라이언트 생성
const client = new userProto.UserService(
  'localhost:50051',
  grpc.credentials.createInsecure()
);

// 사용자 조회 메서드 호출
function getUser(userId) {
  return new Promise((resolve, reject) => {
    client.getUser({ user_id: userId }, (err, response) => {
      if (err) {
        reject(err);
        return;
      }
      resolve(response);
    });
  });
}

// 사용자 목록 스트리밍
function listUsers(limit) {
  return new Promise((resolve, reject) => {
    const users = [];
    const call = client.listUsers({ limit });
    
    call.on('data', (user) => {
      users.push(user);
      console.log('Received user:', user.name);
    });
    
    call.on('end', () => {
      console.log('Streaming completed');
      resolve(users);
    });
    
    call.on('error', (err) => {
      console.error('Streaming error:', err);
      reject(err);
    });
  });
}

// 사용자 생성 메서드 호출
function createUser(userData) {
  return new Promise((resolve, reject) => {
    client.createUser(userData, (err, response) => {
      if (err) {
        reject(err);
        return;
      }
      resolve(response);
    });
  });
}

// 메서드 호출 테스트
async function main() {
  try {
    // 사용자 생성 테스트
    console.log('Creating a new user...');
    const newUser = await createUser({
      name: '이영희',
      email: 'lee@example.com',
      age: 28
    });
    console.log('Created user:', newUser);
    
    // 사용자 조회 테스트
    console.log('\nFetching user with ID 1...');
    const user = await getUser('1');
    console.log('User details:', user);
    
    // 사용자 목록 조회 테스트
    console.log('\nFetching all users (streaming)...');
    const users = await listUsers(10);
    console.log(`Received ${users.length} users in total`);
    
  } catch (error) {
    console.error('Error:', error);
  }
}

main();

1
2
3
4
5

# 터미널 1: 서버 시작
node server.js

# 터미널 2: 클라이언트 실행
node client.js