Protocol Buffers (protobuf)

Protocol Buffers(이하 protobuf)는 Google에서 개발한 언어 중립적, 플랫폼 중립적, 확장 가능한 구조화된 데이터 직렬화 메커니즘이다. 2008년에 오픈소스로 공개되었으며, 현재는 많은 분산 시스템과 마이크로서비스 아키텍처에서 핵심적인 역할을 담당하고 있다.

protobuf는 XML이나 JSON과 같은 텍스트 기반 직렬화 형식의 대안으로 설계되었으며, 더 작고, 빠르며, 단순한 방식으로 구조화된 데이터를 인코딩하는 것을 목표로 한다. 특히 gRPC 프레임워크의 IDL(Interface Definition Language)로 채택되어 서비스 인터페이스를 정의하는 데 널리 사용된다.

Protocol Buffers는 효율적인 직렬화, 언어 중립성, 스키마 진화 지원 등의 장점으로 인해 분산 시스템과 마이크로서비스 아키텍처에서 널리 사용되고 있다. 특히 gRPC와의 통합을 통해 서비스 간 통신의 표준으로 자리 잡았으며, 높은 성능이 요구되는 환경에서 JSON이나 XML의 강력한 대안으로 작용한다.

그러나 인간 가독성 부족, 스키마 필요성, 일부 언어 지원 제한 등의 단점도 존재하므로, 사용 사례에 맞게 적절히 선택하는 것이 중요하다. 데이터 크기와 처리 속도가 중요한 시스템에서는 Protocol Buffers가 탁월한 선택이 될 수 있지만, 유연성과 가독성이 우선시되는 경우에는 JSON과 같은 다른 형식이 더 적합할 수 있다.

작동 원리

Protocol Buffers의 작동 방식은 다음과 같은 단계로 이루어진다:

  1. 메시지 정의
    먼저 .proto 파일에 데이터 구조(메시지)를 정의한다. 이 파일은 데이터의 스키마를 나타내며, 필드 이름, 타입, 그리고 필드 번호를 지정한다.

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

    syntax = "proto3";  // 프로토콜 버퍼 버전 지정

message Person {
  string name = 1;        // 1은 필드 번호(tag)
  int32 id = 2;           // 2는 필드 번호
  string email = 3;       // 3은 필드 번호

  enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
  }

  message PhoneNumber {
    string number = 1;
    PhoneType type = 2;
  }

  repeated PhoneNumber phones = 4;  // 반복 필드(배열)
}

  2. 코드 생성
    Protocol Buffers 컴파일러(protoc)를 사용하여 .proto 파일로부터 원하는 프로그래밍 언어의 클래스를 생성한다. 이 생성된 코드는 데이터 접근 메서드와 직렬화/역직렬화 기능을 제공한다.

    1
2
3

    protoc --java_out=./java-output ./my_message.proto  # Java 코드 생성
protoc --python_out=./python-output ./my_message.proto  # Python 코드 생성
protoc --cpp_out=./cpp-output ./my_message.proto  # C++ 코드 생성

  3. 데이터 직렬화 및 역직렬화
    생성된 클래스를 사용하여 데이터를 설정하고, 바이너리 형식으로 직렬화하거나 바이너리에서 역직렬화할 수 있다.
    Python 예제:

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

    # 메시지 생성 및 설정
person = Person()
person.name = "John Doe"
person.id = 1234
person.email = "johndoe@example.com"

phone = person.phones.add()
phone.number = "555-4321"
phone.type = Person.PhoneType.HOME

# 직렬화
serialized_data = person.SerializeToString()

# 역직렬화
new_person = Person()
new_person.ParseFromString(serialized_data)

주요 특징 및 장점

  1. 성능
    Protocol Buffers는 다음과 같은 성능상의 이점을 제공한다:

    • 작은 메시지 크기: 이진 형식으로 데이터를 인코딩하여 텍스트 기반 형식(JSON, XML)보다 2~10배 더 작은 크기를 가진다.
    • 빠른 파싱: 텍스트 파싱이 필요 없으므로 파싱 속도가 빠르다.
    • 효율적인 인코딩: 가변 길이 정수 인코딩(varint)을 사용하여 작은 값은 적은 바이트로 표현한다.

  2. 언어 중립성
    Protocol Buffers는 다양한 프로그래밍 언어를 지원한다:

    • C++
    • Java
    • Python
    • Go
    • Ruby
    • C#
    • JavaScript
    • PHP
    • Objective-C
    • Dart
      이는 다른 언어로 작성된 시스템 간의 통신을 단순화한다.

  3. 스키마 진화
    Protocol Buffers는 스키마 진화(Schema Evolution)를 지원하여 이전 버전과의 호환성을 유지하면서 데이터 구조를 변경할 수 있다:

    • 새로운 필드 추가: 기존 코드에 영향을 주지 않는다.
    • 필드 삭제: 미사용 필드로 표시하여 이전 버전의 코드가 계속 작동하도록 한다.
    • 필드 번호 재사용 방지: 필드 번호는 한 번 사용되면 재사용해서는 안 된다.
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

    // 원래 스키마
message Person {
  string name = 1;
  int32 id = 2;
}

// 진화된 스키마 (호환성 유지)
message Person {
  string name = 1;
  int32 id = 2;
  string email = 3;  // 새 필드 추가
  // int32 age = 2;  // 오류: 필드 번호 2 재사용
}

  4. 강력한 타입 체크
    Protocol Buffers는 정적 타입 시스템을 제공하여 컴파일 시간에 타입 오류를 검출할 수 있다. 이는 런타임에 발생할 수 있는 데이터 타입 불일치 문제를 미리 방지한다.

Protocol Buffers vs. 다른 직렬화 형식

JSON과의 비교

특성Protocol BuffersJSON
형식바이너리텍스트
크기작음상대적으로 큼
파싱 속도빠름상대적으로 느림
인간 가독성낮음 (바이너리)높음
스키마필수선택적
타입 체크강력함약함 또는 없음
언어 지원제한적 (코드 생성 필요)광범위
사용 용이성스키마 정의 및 코드 생성 필요바로 사용 가능

XML과의 비교

특성Protocol BuffersXML
형식바이너리텍스트
크기작음매우 큼
파싱 속도매우 빠름느림
인간 가독성낮음중간
스키마.proto 파일XSD, DTD 등
표현력중간높음
확장성제한적매우 높음

Avro와의 비교

특성Protocol BuffersAvro
스키마 진화필드 번호 기반필드 이름 기반
동적 타입제한적지원
스키마 포함스키마 별도 저장데이터와 함께 스키마 저장 가능
언어 통합코드 생성 필요동적 매핑 가능
직렬화 속도빠름비슷하게 빠름

Protocol Buffers의 버전

Protocol Buffers는 세 가지 주요 버전이 있다:

Proto2

초기 오픈소스 릴리스 버전으로, 다음과 같은 특징이 있다:

1
2
3
4
5
6
7

syntax = "proto2";

message Example {
  required int32 id = 1;  // 필수 필드
  optional string name = 2 [default = "unknown"];  // 선택적 필드, 기본값 지정
  repeated string tags = 3;  // 반복 필드
}

Proto3

2016년 출시된 단순화된 버전으로, 다음과 같은 변경 사항이 있다:

1
2
3
4
5
6
7

syntax = "proto3";

message Example {
  int32 id = 1;  // 모든 필드가 기본적으로 선택적
  string name = 2;  // 기본값은 타입에 따라 결정 (문자열의 경우 빈 문자열)
  repeated string tags = 3;
}

주요 차이점

기능proto2proto3
필수 필드지원미지원
명시적 기본값지원미지원 (타입별 기본값 사용)
알 수 없는 필드보존proto3.5 이전에는 폐기, 이후에는 보존
그룹지원 (권장하지 않음)미지원
확장지원Any 타입으로 대체
oneOf지원지원
맵(map)별도 문법기본 지원

gRPC에서의 Protocol Buffers

gRPC는 Protocol Buffers를 IDL(Interface Definition Language)로 사용하여 서비스 계약을 정의한다.

이는 다음과 같은 이점을 제공한다:

  1. 서비스 정의
    Protocol Buffers를 사용하여 RPC(원격 프로시저 호출) 서비스를 정의할 수 있다:

     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

    syntax = "proto3";

package tutorial;

// 서비스 정의
service RouteGuide {
  // 단순 RPC
  rpc GetFeature(Point) returns (Feature) {}

  // 서버 스트리밍 RPC
  rpc ListFeatures(Rectangle) returns (stream Feature) {}

  // 클라이언트 스트리밍 RPC
  rpc RecordRoute(stream Point) returns (RouteSummary) {}

  // 양방향 스트리밍 RPC
  rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}
}

// 입력 및 출력 메시지 정의
message Point {
  int32 latitude = 1;
  int32 longitude = 2;
}

message Rectangle {
  Point lo = 1;
  Point hi = 2;
}

message Feature {
  string name = 1;
  Point location = 2;
}

message RouteNote {
  Point location = 1;
  string message = 2;
}

message RouteSummary {
  int32 point_count = 1;
  int32 feature_count = 2;
  int32 distance = 3;
  int32 elapsed_time = 4;
}

  2. 코드 생성
    gRPC 플러그인을 사용하여 Protocol Buffers 컴파일러는 서비스 인터페이스 코드를 생성한다:

    1
2

    protoc --grpc_out=./grpc-output --plugin=protoc-gen-grpc=grpc_plugin \
       --java_out=./java-output ./service.proto

    이렇게 생성된 코드는 다음을 포함한다:

    • 서비스 인터페이스
    • 스텁(stub) 클래스
    • 서비스 구현을 위한 기본 클래스

  3. gRPC에서의 이점

    • 타입 안전성: 컴파일 시간에 타입 오류 검출
    • 언어 중립적 인터페이스: 다양한 언어로 된 클라이언트와 서버 간 통신
    • 효율적인 직렬화: 네트워크 대역폭 최적화
    • 쉬운 계약 진화: 새로운 기능 추가 시 하위 호환성 유지

실제 사용 사례

  1. Google 내부 시스템
    Google은 내부적으로 Protocol Buffers를 광범위하게 사용한다:

    • 데이터 저장 형식으로 사용
    • 마이크로서비스 간 통신
    • 대규모 분산 시스템(BigTable, Spanner 등)의 인터페이스

  2. 메시징 시스템

    • Kafka: Confluent Schema Registry에서 Protocol Buffers 지원
    • RabbitMQ: 메시지 직렬화 형식으로 사용 가능

  3. 대규모 서비스

    • Kubernetes: API 서버 통신에 사용
    • etcd: 내부 데이터 형식으로 활용
    • Envoy: 구성 및 API에 Protocol Buffers 사용

  4. 모바일 애플리케이션

    • 네트워크 사용량 최소화를 위한 클라이언트-서버 통신
    • 오프라인 데이터 저장에 활용

구현 모범 사례

  1. 필드 번호 관리

    • 1-15 범위의 필드 번호는 1바이트만 사용하므로 자주 사용되는 필드에 할당
    • 16-2047 범위의 필드 번호는 2바이트 사용
    • 필드 번호를 재사용하지 않도록 주의
    • 예약된 필드 번호를 사용하여 삭제된 필드 관리
    1
2
3
4
5
6
7

    message MyMessage {
  reserved 2, 15, 9 to 11;  // 이전에 사용된 필드 번호 예약
  reserved "foo", "bar";    // 이전에 사용된 필드 이름 예약

  string name = 1;
  // int32 id = 2;  // 오류: 예약된 필드 번호 사용
}

  2. 스키마 진화

    • 필드 추가 시 기본값 고려
    • 필드 삭제 시 번호를 예약하여 재사용 방지
    • 필드 타입 변경 시 호환성 규칙 준수 (예: int32 → int64는 가능, int32 → string은 불가능)

  3. 메시지 크기 최적화

    • 선택적 필드는 값이 기본값과 다를 때만 인코딩
    • 반복 필드는 [packed=true] 옵션 사용으로 크기 감소
    • 큰 문자열이나 바이트 필드는 압축 고려
    1
2
3

    message PackedExample {
  repeated int32 numbers = 1 [packed=true];  // 더 효율적인 인코딩
}

  4. 성능 고려 사항

    • 큰 메시지는 점진적으로 파싱 고려
    • 메모리 관리를 위해 아레나 할당자(arena allocator) 사용
    • 메시지 풀링(pooling)을 통한 객체 재사용

도구 및 생태계

  1. Protocol Buffers 컴파일러 (protoc)
    기본 Protocol Buffers 컴파일러는 C++, Java, Python 등의 언어 지원을 제공한다.

  2. 언어별 라이브러리
    공식 지원 언어 외에도 다양한 커뮤니티 구현이 있다:

    • protobuf-net (C#)
    • ScalaPB (Scala)
    • SwiftProtobuf (Swift)
    • ts-protoc-gen (TypeScript)

  3. 개발 도구

    • IDE 플러그인: IntelliJ, VSCode 등에서 .proto 파일 편집 지원
    • Buf: Protocol Buffers 개발 도구 및 린터
    • BloomRPC: gRPC 클라이언트 GUI 테스트 도구
    • protoc-gen-doc: .proto 파일에서 문서 생성

  4. 디버깅 도구

    • protoc-gen-pretty: 바이너리 형식을 읽기 쉬운 형태로 변환
    • Protocol Buffers 디코더: 바이너리 메시지 디코딩

제한 사항 및 고려 사항

  1. 인간 가독성
    Protocol Buffers 바이너리 형식은 인간이 직접 읽을 수 없다. 디버깅이나 검사를 위해서는 도구가 필요하다.

  2. 스키마 필요성
    JSON과 달리 Protocol Buffers는 항상 스키마가 필요하다. 스키마 없이는 메시지를 해석할 수 없다.

  3. 언어 지원 제한
    일부 언어에 대한 지원은 제한적이거나 커뮤니티 구현에 의존한다.

  4. 동적 타입 제한
    Protocol Buffers는 정적 타입 시스템을 기반으로 하므로, 동적 스키마나 유연한 구조가 필요한 경우에는 제한적일 수 있다.

용어 정리

용어설명
IDL(Interface Definition Language) 서로 다른 프로그래밍 언어로 작성된 소프트웨어 컴포넌트 간의 통신을 가능하게 하기 위해 인터페이스를 정의하는 언어이다. 이 언어는 특정 프로그래밍 언어에 종속되지 않고, 언어 중립적으로 설계되어 다양한 시스템과 환경에서 상호 운용성을 제공한다. IDL은 주로 원격 프로시저 호출(RPC) 시스템이나 분산 컴퓨팅 환경에서 사용되며, 데이터 타입과 함수 시그니처를 명확히 정의하여 컴포넌트 간의 통신을 원활하게 한다.

IDL의 주요 특징
1. 언어 중립성:
- IDL은 특정 프로그래밍 언어에 의존하지 않으므로, C++, Java, Python 등 서로 다른 언어로 작성된 컴포넌트 간의 통신을 지원한다.
2. 인터페이스 정의:
- IDL은 함수 구조와 객체 타입을 명확히 정의하여 소프트웨어 컴포넌트 간의 상호작용을 표준화한다.
3. 원격 프로시저 호출(RPC) 지원:
- IDL은 RPC 시스템에서 자주 사용되며, 서로 다른 운영 체제나 언어를 사용하는 시스템 간의 통신을 가능하게 한다.
4. 데이터 타입과 함수 시그니처 명세:
- 데이터 타입과 함수의 입력 및 출력 구조를 명확히 정의하여 컴포넌트 간의 데이터 교환을 표준화한다.
5. 다양한 구현체와 표준:
- IDL은 CORBA(OMG IDL), Microsoft RPC(MIDL), Protocol Buffers, Thrift 등 다양한 표준과 기술에서 활용된다..

참고 및 출처