[gRPC] gRPC를 활용한 MSA 간 통신, Spring Boot에서 gRPC로 통신하기 (feat. 성능 측정)

1. gRPC란?

gRPC를 알아보기 앞서 RPC란 Remote Procedure Call의 약자로 다른 컴퓨터에 있는 어떤 기능을 자기 기능인 것 처럼 실행할 수 있는 프로토콜이다.

RPC는 언어 독립적이므로 서로 다른 프로그래밍 언어를 사용하는 서버와 클라이언트 사이에서도 사용될 수 있다.

개발자는 서버나 통신 과정에 대해 하나하나 알아두거나 고려할 필요 없이 마치 로컬 함수를 가져다 쓰듯 기능들을 필요에 따라 사용하는데 집중할 수 있다. 

 

 

gRPC는 구글에서 개발한 오픈소스 기술로 다양한 플랫폼에서 서로 다른 언어로 작성된 애플리케이션 간 통신을 위한 효율적이고 간편한 방법을 제공한다. gRPC는 이전의 RPC 시스템과 달리 대용량 데이터 전송 및 멀티플랫폼 지원 등의 문제를 해결할 수 있다. 현재까지도 지속적으로 업데이트와 개선이 이루어지며, 클라우드 네이티브 아키텍처와의 호환성도 강화되고 있다.

 

 

 

 

 

 

 

 

 

 

 

2. gRPC 등장 배경

gRPC 이전엔 RPC, Rest API 통신이 존재했다.

 

RPC

RPC는 IDL을 사용하여 인터페이스를 명시한다. IDL이란 Interface Definition Language 약자로 소프트웨어 컴포넌트의 인터페이스를 묘사하기 위한 명세 언어이다. 

 

어느 한 언어에 국한되지 않는 언어 중립적인 방법으로 인터페이스를 묘사함으로써, 같은 언어를 사용하지 않는 소프트웨어 컴포넌트 사이의 통신을 가능하게 한다.

 

RPC의 동작 흐름은 다음과 같다.

 

1. IDL을 통해 호출에 대한 인터페이스를 정의
2. 정의된 IDL을 기반으로 rpcgen이라는 rpc 프로토콜 컴파일러를 통해 코드(stub)가 생성된다. stub을 통해 Client는 procedure 호출을 위한 참조자가 생겼고, Server는 procedure 이해를 위한 참조가 생기게 됨.
3. Client는 자신의 프로그램에서 함수를 호출하는 것처럼 stub에 정의된 함수를 사용.
4. Client에서 Stub에 정의된 함수를 사용할 때 Client stub은 RPC 런타임을 통해 함수 호출.
5. Server는 수신된 procedure 호출에 대한 처리 후 결과 값 반환.
6. 최종적으로 Client 프로그램은 서버의 결과 값을 반환 받음.

 

RPC를 통해 하부 네트워크 프로토콜에 대해 신경 쓰지 않아도 되고, 프로그램 개발에만 집중할 수 있었지만 단점도 존재했다.

 

RPC 코드를 이해하기 어려울 뿐더러 에러 발생 시 디버깅이 어려운 단점이 존재한다.

이로 인해 데이터 통신을 Web을 활용해 해보려 했고 탄생한 것이 REST API 이다. 

 

 

 

REST

REST(REpresentational State Transfer)는 HTTP1.1 기반 URI를 통해 자원을 명시하고, HTTP Method(POST, GET, PUT, DELETE)를 통해 해당 자원에 대한 CRUD를 적용하는 것을 의미한다. 

 

REST는 HTTP 프로토콜의 인프라를 그대로 사용하기 때문에 별도의 인프라를 구축할 필요도 없고, REST API 메시지가 의도하는 바를 명확하게 나타내기 때문에 쉽게 파악할 수 있다. 

 

 

하지만, REST는 표준 자체가 존재하지 않아 정의가 필요하고, 사용할 수 있는 메소드도 4가지 밖에 없었다.

 

REST가 보편적으로 사용되던 중에, 2016년 구글에서 개발한 오픈소스 RPC 프레임워크인 gRPC가 등장한다. 

 

 

 

 

gRPC

google은 1주일 동안 띄우는 일주일 동안 띄우는 컨테이너가 약 20억개, 1초 동안 던지는 원격 호출의 수는 100억 번이라고 한다. 구글은 이러한 대규모 서비스를 운영하기 위해 gRPC를 개발했다.

 

gPRC는 IDL로 PB(Protocol Buffer)를 사용한다. 

 

 

 

 

 

 

 

 

 

 

 

3. gRPC의 장점

gRPC는 HTTP/1.1 이 아닌 HTTP/2 방식을 사용한다. 두 가지 차이점은 뭘까??

 

HTTP/1.1 vs HTTP/2

HTTP1.1은 기본적으로 한 Connection에 하나의 요청과 응답을 처리하기 때문에 동시 전송, 다수의 리소스를처리하기엔 성능 이슈가 있다. 

또한 무거운 Header가 요청 마다 중복 전달되어 비효율 적이었다. 

 

HTTP/2는 성능 뿐만 아니라 속도 면에서도 우수한데 한 Connection에 여러 개의 메시지를 주고 받을 수 있고, 무거웠던 Header를 압축하여 중복을 제거하고 전달하기 때문에 HTTP/1.1에 비해서 훨씬 효율적이었다. 

 

 

또한 반드시 클라이언트의 요청이 들어와야 응답을 할 수 있는 HTTP/1.1과 달리, 요청 없이도 서버가 리소스를 전달할 수 있어 클라이언트의 요청을 최소화 할 수 있다. 

 

 

 

 

 

 

 

 

 

 

4. Protobuf 란?

위에서 언급했듯이 gRPC는 IDL로 PB(Protocol Buffer)를 사용한다. 프로토콜 버퍼는 구조화된 데이터를 직렬화 하는 방식을 사용한다.

여기서 직렬화란 Java 시스템 내에서 사용하는 객체 또는 데이터를 Java 시스템 외에서도 사용할 수 있도록 Byte 형태로 데이터를 변환하는 기술이다. 

 

 

Protocol Buffer는 RPC의 IDL과 동일하게 중립적인 형태로 데이터 타입을 정의하기 위해서 proto File에 정의한다. 정의한 Proto File을 사용하려면 각 언어에 맞게 데이터 클래스로 생성해야 하기 때문에 protoc 컴파일러가 필요하다. (RPC에선 rpcgen)

 

protoc 컴파일러로 Profo File을 컴파일하면 각 언어에 맞게 데이터 클래스 파일을 생성해주기 때문이다. 

 

 

Proto File 정의 => protoc 컴파일러를 이용하여 컴파일 => 원하는 소스 파일 생성

 

 

 

 

 

 

 

 

 

 

 

 

5. Spring Boot 에서 gRPC 사용하기

gRPC - Client

- build.gradle

// grpc
buildscript {
    ext {
        protobufVersion = '3.25.1'
        protobufPluginVersion = '0.8.14'
        grpcVersion = '1.58.1'
    }
}

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.3.5'
    id 'io.spring.dependency-management' version '1.1.6'

    // grpc
    id 'com.google.protobuf' version '0.9.4'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

    // swagger
    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2'

    // grpc
    implementation "com.google.protobuf:protobuf-java-util:3.25.1"
    implementation 'com.google.protobuf:protobuf-java:3.25.1'
    implementation 'net.devh:grpc-client-spring-boot-starter:2.15.0.RELEASE' // 클라이언트 의존성 추가
    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
    implementation "io.grpc:grpc-stub:${grpcVersion}"
    compileOnly 'org.apache.tomcat:annotations-api:6.0.53'

    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
}

// grpc
protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:${protobufVersion}"
    }
    clean {
        delete generatedFilesBaseDir
    }
    plugins {
        grpc {
            artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
        }
    }
    generateProtoTasks {
        all()*.plugins {
            grpc{}
        }
    }
}

ext {
    set('springCloudVersion', "2023.0.2")
}

dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
    }
}

tasks.named('test') {
    useJUnitPlatform()
}

 

 

 

Proto file을 정의해준다. 이 파일은 server와 client 모두 가지고 있어야 한다. 확장자 명은 .proto 이다. 

📦src
 ┣ 📂main
 ┃ ┣ 📂java
 ┃ ┃ ┗ 📂com
 ┃ ┃ ┃ ┗ 📂example
 ┃ ┃ ┃ ┃ ┗ 📂grpcclient
 ┃ ┣ 📂proto
 ┃ ┃ ┗ 📜test.proto
 ┃ ┗ 📂resources
 ┃ ┃ ┗ 📜application.yml

 

 

- proto 파일

syntax = "proto3";

option java_multiple_files = true;
option java_outer_classname = "SampleProto";
option java_package = "com.example.grpc.proto";

package com.example.grpc;

// req 메시지 정의
message SampleRequest {
  string userId = 1;   // userId 필드의 식별자: 1
  string message = 2;  // messagee 필드의 식별자: 2
}

// res 메시지 정의
message SampleResponse {
  string message = 1;
}

// 서비스 정의
service SampleService {
  rpc SampleCall (SampleRequest) returns (SampleResponse) {}
}

 

 

- application.yml (client)

grpc:
  client:
    local-grpc-server: # 클라이언트 이름
      address: "static://localhost:9090" # 서버 주소 (로컬)
      negotiationType: "plaintext"
server:
  port: 8082

 

 

 

 

gRPC - Server

- build.gradle

client와 동일하지만 아래 부분만 변경

implementation 'net.devh:grpc-client-spring-boot-starter:2.15.0.RELEASE' // 클라이언트 의존성 추가

=> 

implementation 'net.devh:grpc-server-spring-boot-starter:2.15.0.RELEASE' // 서버 의존성 추가

 

 

 

- proto 파일

client 와 똑같은 파일 작성

 

 

- application.yml (server)

grpc:
  server:
    port: 9090 # gRPC 서버 포트
server:
  port: 8081

 

 

 

 

 

생성 후 build 해주면 build.generated 디렉토리 안에 proto 파일에서 생성한 service 클래스가 생성된다. 

 

 

 

 

- gRPC 요청 처리: SampleServiceGrpc 오버라이딩 (server)

@GrpcService
@Slf4j
public class GrpcServer extends SampleServiceGrpc.SampleServiceImplBase {

    @Override
    public void sampleCall(SampleRequest request, StreamObserver<SampleResponse> responseObserver) {
        String userId = request.getUserId();
        String message = request.getMessage();

        // 비즈니스 로직 처리
        String responseMessage = "Received message from userId: " + userId + ", message: " + message;

        log.info("[gRPC server] message: {}", responseMessage);


        // Response 생성
        SampleResponse response = SampleResponse.newBuilder()
            .setMessage(responseMessage)
            .build();

        // 응답 반환
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

 

여기서 SampleResponse와 SampleRequest는 proto 파일을 build하면서 생성된 클래스들이다. 

 

 

 

- gRPC 호출 (client)

@Service
@Slf4j
@RequiredArgsConstructor
public class GrpcClientService {

    @GrpcClient("local-grpc-server")
    private SampleServiceGrpc.SampleServiceBlockingStub sampleServiceBlockingStub;

    private final SampleClient sampleClient;

    public String sendMessage(String userId, String message) {
        SampleRequest request = SampleRequest.newBuilder()
            .setUserId(userId)
            .setMessage(message)
            .build();

        SampleResponse response = sampleServiceBlockingStub.sampleCall(request);

        log.info("[gRPC client] message: {}", response.getMessage());

        return response.getMessage();
    }
}

 

스프링에서는 @GrpcClient 어노테이션을 사용하여 gRPC Stub을 Spring의 DI(Dependency Injection) 방식으로 주입받아 사용할 수 있다. gRPC 클라이언트를 구성할 때 필요한 채널 생성, Stub 생성 등의 과정을 자동화하여 개발 편의성을 높여준다.

 

@GrpcClient 어노테이션은 설정 파일(application.yml)에 정의된 gRPC 서버 정보와 연결한다.

 

 

 

 

 

 

 

 

 

 

 

6. 성능 비교

Thread Group 설정은 다음과 같다.

 

 

 

gRPC 요청

 

 

 

 

 

HTTP 요청

 

 

 

 

gRPC의 경우 1175 TPS

HTTP의 경우 154 TPS

 

로 측정됐고 gRPC가 HTTP보다 약 663%의 빠른 성능을 보여줬다. 실제로 2배~10배 가량 빠르다고 한다.