gRPC & Protocol Buffers 완전 가이드 2025: 마이크로서비스 통신의 새로운 표준

syntax = "proto3";

package ecommerce.v1;

option go_package = "github.com/mycompany/ecommerce/v1;ecommercev1";
option java_package = "com.mycompany.ecommerce.v1";

import "google/protobuf/timestamp.proto";
import "google/protobuf/empty.proto";

// 상품 서비스 정의
service ProductService {
  // 단일 상품 조회
  rpc GetProduct(GetProductRequest) returns (Product);
  // 상품 목록 조회
  rpc ListProducts(ListProductsRequest) returns (ListProductsResponse);
  // 상품 생성
  rpc CreateProduct(CreateProductRequest) returns (Product);
  // 상품 업데이트
  rpc UpdateProduct(UpdateProductRequest) returns (Product);
  // 상품 삭제
  rpc DeleteProduct(DeleteProductRequest) returns (google.protobuf.Empty);
}

message ScalarTypes {
  // 숫자 타입
  double price = 1;           // 64비트 부동소수점
  float rating = 2;           // 32비트 부동소수점
  int32 quantity = 3;         // 가변 길이 인코딩 (음수에 비효율적)
  int64 total_sales = 4;      // 가변 길이 인코딩
  uint32 age = 5;             // 부호 없는 32비트 정수
  uint64 view_count = 6;      // 부호 없는 64비트 정수
  sint32 temperature = 7;     // 음수에 효율적인 인코딩
  sint64 altitude = 8;        // 음수에 효율적인 인코딩
  fixed32 hash = 9;           // 항상 4바이트
  fixed64 large_hash = 10;    // 항상 8바이트

  // 문자열/바이트
  string name = 11;           // UTF-8 인코딩 문자열
  bytes thumbnail = 12;       // 임의 바이트 시퀀스

  // 불리언
  bool is_active = 13;
}

message Product {
  string id = 1;
  string name = 2;
  string description = 3;
  Money price = 4;
  Category category = 5;
  repeated string tags = 6;           // 반복 필드 (배열)
  map<string, string> metadata = 7;   // 맵 타입
  google.protobuf.Timestamp created_at = 8;
  ProductStatus status = 9;

  // 중첩 메시지
  message Dimension {
    double width = 1;
    double height = 2;
    double depth = 3;
    string unit = 4;
  }

  Dimension dimension = 10;
}

message Money {
  string currency_code = 1;  // ISO 4217
  int64 units = 2;           // 정수 부분
  int32 nanos = 3;           // 나노 단위 소수 부분
}

enum ProductStatus {
  PRODUCT_STATUS_UNSPECIFIED = 0;  // 항상 0번은 기본값
  PRODUCT_STATUS_DRAFT = 1;
  PRODUCT_STATUS_ACTIVE = 2;
  PRODUCT_STATUS_ARCHIVED = 3;
  PRODUCT_STATUS_DELETED = 4;
}

enum Category {
  CATEGORY_UNSPECIFIED = 0;
  CATEGORY_ELECTRONICS = 1;
  CATEGORY_CLOTHING = 2;
  CATEGORY_BOOKS = 3;
  CATEGORY_FOOD = 4;
}

message PaymentMethod {
  string id = 1;

  oneof method {
    CreditCard credit_card = 2;
    BankTransfer bank_transfer = 3;
    DigitalWallet digital_wallet = 4;
  }
}

message CreditCard {
  string card_number_masked = 1;
  string expiry_month = 2;
  string expiry_year = 3;
  string brand = 4;
}

message BankTransfer {
  string bank_name = 1;
  string account_number_masked = 2;
  string routing_number = 3;
}

message DigitalWallet {
  string provider = 1;  // "apple_pay", "google_pay"
  string email = 2;
}

message Product {
  string id = 1;
  string name = 2;
  // 삭제된 필드: 번호와 이름을 예약
  reserved 3, 6 to 8;
  reserved "old_price", "legacy_tag";

  // 새 필드 추가는 항상 안전
  string description = 4;
  Money price = 5;
  // 필드 9부터 추가
  string sku = 9;
}

service UserService {
  rpc GetUser(GetUserRequest) returns (User);
}

message GetUserRequest {
  string user_id = 1;
}

message User {
  string id = 1;
  string name = 2;
  string email = 3;
}

func (s *userServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    user, err := s.repo.FindByID(ctx, req.UserId)
    if err != nil {
        if errors.Is(err, ErrNotFound) {
            return nil, status.Errorf(codes.NotFound, "user %s not found", req.UserId)
        }
        return nil, status.Errorf(codes.Internal, "failed to get user: %v", err)
    }
    return toProtoUser(user), nil
}

import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';

const packageDefinition = protoLoader.loadSync('user.proto', {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
});

const proto = grpc.loadPackageDefinition(packageDefinition);
const client = new proto.UserService(
  'localhost:50051',
  grpc.credentials.createInsecure()
);

// Unary 호출
client.getUser({ user_id: 'user-123' }, (err, response) => {
  if (err) {
    console.error('Error:', err.message);
    return;
  }
  console.log('User:', response);
});

service OrderService {
  // 실시간 주문 상태 추적
  rpc TrackOrder(TrackOrderRequest) returns (stream OrderStatus);
}

message TrackOrderRequest {
  string order_id = 1;
}

message OrderStatus {
  string order_id = 1;
  string status = 2;
  string location = 3;
  google.protobuf.Timestamp updated_at = 4;
}

func (s *orderServer) TrackOrder(req *pb.TrackOrderRequest, stream pb.OrderService_TrackOrderServer) error {
    orderID := req.OrderId

    // 이벤트 채널 구독
    events := s.eventBus.Subscribe(orderID)
    defer s.eventBus.Unsubscribe(orderID, events)

    for {
        select {
        case event := <-events:
            status := &pb.OrderStatus{
                OrderId:   orderID,
                Status:    event.Status,
                Location:  event.Location,
                UpdatedAt: timestamppb.Now(),
            }
            if err := stream.Send(status); err != nil {
                return err
            }
            if event.Status == "delivered" {
                return nil
            }
        case <-stream.Context().Done():
            return stream.Context().Err()
        }
    }
}

service UploadService {
  // 파일 업로드
  rpc UploadFile(stream FileChunk) returns (UploadResponse);
}

message FileChunk {
  string filename = 1;
  bytes content = 2;
  int64 offset = 3;
}

message UploadResponse {
  string file_id = 1;
  int64 total_size = 2;
  string checksum = 3;
}

func (s *uploadServer) UploadFile(stream pb.UploadService_UploadFileServer) error {
    var totalSize int64
    var filename string
    buffer := bytes.Buffer{}

    for {
        chunk, err := stream.Recv()
        if err == io.EOF {
            // 모든 청크 수신 완료
            fileID, checksum := s.storage.Save(filename, buffer.Bytes())
            return stream.SendAndClose(&pb.UploadResponse{
                FileId:    fileID,
                TotalSize: totalSize,
                Checksum:  checksum,
            })
        }
        if err != nil {
            return status.Errorf(codes.Internal, "failed to receive chunk: %v", err)
        }
        filename = chunk.Filename
        totalSize += int64(len(chunk.Content))
        buffer.Write(chunk.Content)
    }
}

service ChatService {
  rpc Chat(stream ChatMessage) returns (stream ChatMessage);
}

message ChatMessage {
  string user_id = 1;
  string room_id = 2;
  string content = 3;
  google.protobuf.Timestamp sent_at = 4;
  MessageType type = 5;
}

enum MessageType {
  MESSAGE_TYPE_UNSPECIFIED = 0;
  MESSAGE_TYPE_TEXT = 1;
  MESSAGE_TYPE_IMAGE = 2;
  MESSAGE_TYPE_SYSTEM = 3;
}

func (s *chatServer) Chat(stream pb.ChatService_ChatServer) error {
    for {
        msg, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }

        // 같은 방의 모든 클라이언트에게 브로드캐스트
        s.mu.RLock()
        clients := s.rooms[msg.RoomId]
        s.mu.RUnlock()

        for _, client := range clients {
            if err := client.Send(msg); err != nil {
                log.Printf("failed to send to client: %v", err)
            }
        }
    }
}

HTTP/2 커넥션
├── Stream 1: GetUser RPC
├── Stream 3: ListProducts RPC  (동시 실행)
├── Stream 5: TrackOrder RPC    (서버 스트리밍)
└── Stream 7: Chat RPC          (양방향 스트리밍)

// 서버 설정
server := grpc.NewServer(
    grpc.KeepaliveParams(keepalive.ServerParameters{
        MaxConnectionIdle:     15 * time.Minute,
        MaxConnectionAge:      30 * time.Minute,
        MaxConnectionAgeGrace: 5 * time.Minute,
        Time:                  5 * time.Minute,
        Timeout:               1 * time.Minute,
    }),
    grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
        MinTime:             5 * time.Second,
        PermitWithoutStream: true,
    }),
    grpc.MaxRecvMsgSize(4 * 1024 * 1024), // 4MB
    grpc.MaxSendMsgSize(4 * 1024 * 1024), // 4MB
)

// 로깅 인터셉터
func loggingUnaryInterceptor(
    ctx context.Context,
    req interface{},
    info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler,
) (interface{}, error) {
    start := time.Now()

    // 요청 로깅
    log.Printf("gRPC call: %s", info.FullMethod)

    // 핸들러 실행
    resp, err := handler(ctx, req)

    // 응답 로깅
    duration := time.Since(start)
    statusCode := status.Code(err)
    log.Printf("gRPC response: method=%s duration=%v status=%s",
        info.FullMethod, duration, statusCode)

    return resp, err
}

// 인증 인터셉터
func authUnaryInterceptor(
    ctx context.Context,
    req interface{},
    info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler,
) (interface{}, error) {
    // 공개 메서드는 인증 건너뛰기
    if isPublicMethod(info.FullMethod) {
        return handler(ctx, req)
    }

    // 메타데이터에서 토큰 추출
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        return nil, status.Errorf(codes.Unauthenticated, "missing metadata")
    }

    tokens := md.Get("authorization")
    if len(tokens) == 0 {
        return nil, status.Errorf(codes.Unauthenticated, "missing token")
    }

    // 토큰 검증
    claims, err := validateToken(tokens[0])
    if err != nil {
        return nil, status.Errorf(codes.Unauthenticated, "invalid token: %v", err)
    }

    // 컨텍스트에 사용자 정보 추가
    ctx = context.WithValue(ctx, userClaimsKey, claims)
    return handler(ctx, req)
}

func loggingStreamInterceptor(
    srv interface{},
    ss grpc.ServerStream,
    info *grpc.StreamServerInfo,
    handler grpc.StreamHandler,
) error {
    start := time.Now()
    log.Printf("gRPC stream started: %s", info.FullMethod)

    // 래핑된 스트림으로 메시지 카운트
    wrapped := &wrappedStream{
        ServerStream: ss,
        recvCount:    0,
        sendCount:    0,
    }

    err := handler(srv, wrapped)

    log.Printf("gRPC stream ended: method=%s duration=%v recv=%d send=%d",
        info.FullMethod, time.Since(start), wrapped.recvCount, wrapped.sendCount)

    return err
}

type wrappedStream struct {
    grpc.ServerStream
    recvCount int
    sendCount int
}

func (w *wrappedStream) RecvMsg(m interface{}) error {
    err := w.ServerStream.RecvMsg(m)
    if err == nil {
        w.recvCount++
    }
    return err
}

func (w *wrappedStream) SendMsg(m interface{}) error {
    err := w.ServerStream.SendMsg(m)
    if err == nil {
        w.sendCount++
    }
    return err
}

server := grpc.NewServer(
    grpc.ChainUnaryInterceptor(
        recoveryUnaryInterceptor,    // 패닉 복구 (가장 바깥)
        loggingUnaryInterceptor,     // 로깅
        metricsUnaryInterceptor,     // 메트릭 수집
        authUnaryInterceptor,        // 인증
        rateLimitUnaryInterceptor,   // 속도 제한
        validationUnaryInterceptor,  // 입력 검증 (가장 안쪽)
    ),
    grpc.ChainStreamInterceptor(
        recoveryStreamInterceptor,
        loggingStreamInterceptor,
        authStreamInterceptor,
    ),
)

import (
    "google.golang.org/genproto/googleapis/rpc/errdetails"
    "google.golang.org/grpc/status"
)

func (s *productServer) CreateProduct(ctx context.Context, req *pb.CreateProductRequest) (*pb.Product, error) {
    // 입력 검증
    violations := validateCreateProduct(req)
    if len(violations) > 0 {
        st := status.New(codes.InvalidArgument, "invalid product data")

        br := &errdetails.BadRequest{}
        for _, v := range violations {
            br.FieldViolations = append(br.FieldViolations, &errdetails.BadRequest_FieldViolation{
                Field:       v.Field,
                Description: v.Description,
            })
        }

        st, err := st.WithDetails(br)
        if err != nil {
            return nil, status.Errorf(codes.Internal, "unexpected error: %v", err)
        }
        return nil, st.Err()
    }

    // 비즈니스 로직
    product, err := s.repo.Create(ctx, req)
    if err != nil {
        if isDuplicate(err) {
            st := status.New(codes.AlreadyExists, "product already exists")
            ri := &errdetails.ResourceInfo{
                ResourceType: "Product",
                ResourceName: req.Sku,
                Description:  "A product with this SKU already exists",
            }
            st, _ = st.WithDetails(ri)
            return nil, st.Err()
        }
        return nil, status.Errorf(codes.Internal, "failed to create product: %v", err)
    }

    return product, nil
}

// 클라이언트: deadline 설정
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

resp, err := client.GetProduct(ctx, &pb.GetProductRequest{ProductId: "prod-123"})
if err != nil {
    st := status.Convert(err)
    if st.Code() == codes.DeadlineExceeded {
        log.Println("Request timed out")
    }
}

// 서버: deadline 확인
func (s *server) GetProduct(ctx context.Context, req *pb.GetProductRequest) (*pb.Product, error) {
    // deadline 확인
    deadline, ok := ctx.Deadline()
    if ok {
        remaining := time.Until(deadline)
        if remaining < 100*time.Millisecond {
            return nil, status.Errorf(codes.DeadlineExceeded, "insufficient time remaining")
        }
    }

    // 하위 서비스 호출 시 남은 시간으로 deadline 전파
    product, err := s.repo.FindByID(ctx, req.ProductId)
    if err != nil {
        return nil, err
    }

    // 가격 서비스에 남은 시간의 80%만 할당
    remaining := time.Until(deadline)
    priceCtx, cancel := context.WithTimeout(ctx, remaining*80/100)
    defer cancel()

    price, err := s.priceClient.GetPrice(priceCtx, &pb.GetPriceRequest{
        ProductId: req.ProductId,
    })
    if err != nil {
        // 가격 조회 실패 시 캐시된 가격 사용
        price = s.priceCache.Get(req.ProductId)
    }

    product.Price = price
    return product, nil
}

import (
    "google.golang.org/grpc"
    "google.golang.org/grpc/resolver"
    _ "google.golang.org/grpc/balancer/roundrobin"
)

// 커스텀 리졸버 등록
resolver.Register(&myResolver{})

conn, err := grpc.Dial(
    "my-service:///product-service",
    grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`),
    grpc.WithTransportCredentials(insecure.NewCredentials()),
)

# envoy.yaml
static_resources:
  listeners:
    - name: grpc_listener
      address:
        socket_address:
          address: 0.0.0.0
          port_value: 9090
      filter_chains:
        - filters:
            - name: envoy.filters.network.http_connection_manager
              typed_config:
                "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
                stat_prefix: grpc
                codec_type: AUTO
                route_config:
                  name: local_route
                  virtual_hosts:
                    - name: grpc_service
                      domains: ["*"]
                      routes:
                        - match:
                            prefix: "/"
                            grpc: {}
                          route:
                            cluster: grpc_backend
                            timeout: 30s
                            retry_policy:
                              retry_on: "unavailable,resource-exhausted"
                              num_retries: 3
                http_filters:
                  - name: envoy.filters.http.router
                    typed_config:
                      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router

  clusters:
    - name: grpc_backend
      connect_timeout: 5s
      type: STRICT_DNS
      lb_policy: ROUND_ROBIN
      typed_extension_protocol_options:
        envoy.extensions.upstreams.http.v3.HttpProtocolOptions:
          "@type": type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions
          explicit_http_config:
            http2_protocol_options: {}
      load_assignment:
        cluster_name: grpc_backend
        endpoints:
          - lb_endpoints:
              - endpoint:
                  address:
                    socket_address:
                      address: product-service
                      port_value: 50051

# envoy-grpc-web.yaml
http_filters:
  - name: envoy.filters.http.grpc_web
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.grpc_web.v3.GrpcWeb
  - name: envoy.filters.http.cors
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.cors.v3.Cors
  - name: envoy.filters.http.router
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router

import { createGrpcWebTransport } from "@connectrpc/connect-web";
import { createClient } from "@connectrpc/connect";
import { ProductService } from "./gen/product_connect";

const transport = createGrpcWebTransport({
  baseUrl: "https://api.example.com",
});

const client = createClient(ProductService, transport);

// Unary 호출
async function getProduct(id: string) {
  try {
    const product = await client.getProduct({ productId: id });
    console.log("Product:", product.name, product.price);
  } catch (err) {
    if (err instanceof ConnectError) {
      console.error("gRPC Error:", err.code, err.message);
    }
  }
}

// Server Streaming
async function trackOrder(orderId: string) {
  for await (const status of client.trackOrder({ orderId })) {
    console.log("Order status:", status.status, status.location);
    updateUI(status);
  }
}

import "google.golang.org/grpc/reflection"

func main() {
    server := grpc.NewServer()
    pb.RegisterProductServiceServer(server, &productServer{})

    // 리플렉션 활성화 (개발 환경용)
    reflection.Register(server)

    lis, _ := net.Listen("tcp", ":50051")
    server.Serve(lis)
}

import "google.golang.org/grpc/health"
import healthpb "google.golang.org/grpc/health/grpc_health_v1"

func main() {
    server := grpc.NewServer()

    // 헬스 체크 서비스 등록
    healthServer := health.NewServer()
    healthpb.RegisterHealthServer(server, healthServer)

    // 서비스 상태 설정
    healthServer.SetServingStatus("product.v1.ProductService", healthpb.HealthCheckResponse_SERVING)

    // 주기적 헬스 체크
    go func() {
        for {
            if dbHealthy() {
                healthServer.SetServingStatus("", healthpb.HealthCheckResponse_SERVING)
            } else {
                healthServer.SetServingStatus("", healthpb.HealthCheckResponse_NOT_SERVING)
            }
            time.Sleep(10 * time.Second)
        }
    }()
}

# kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  template:
    spec:
      containers:
        - name: product-service
          image: product-service:latest
          ports:
            - containerPort: 50051
              name: grpc
          livenessProbe:
            grpc:
              port: 50051
            initialDelaySeconds: 10
            periodSeconds: 10
          readinessProbe:
            grpc:
              port: 50051
            initialDelaySeconds: 5
            periodSeconds: 5

# istio virtual service
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: product-service
spec:
  hosts:
    - product-service
  http:
    - match:
        - headers:
            content-type:
              exact: application/grpc
      route:
        - destination:
            host: product-service
            subset: v2
          weight: 90
        - destination:
            host: product-service
            subset: v1
          weight: 10
      retries:
        attempts: 3
        perTryTimeout: 2s
        retryOn: "unavailable,resource-exhausted"
      timeout: 10s

# linkerd service profile
apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
  name: product-service.default.svc.cluster.local
spec:
  routes:
    - name: GetProduct
      condition:
        method: POST
        pathRegex: /ecommerce.v1.ProductService/GetProduct
      responseClasses:
        - condition:
            status:
              min: 200
              max: 299
    - name: ListProducts
      condition:
        method: POST
        pathRegex: /ecommerce.v1.ProductService/ListProducts
      isRetryable: true

# 서비스 목록 조회 (리플렉션 필요)
grpcurl -plaintext localhost:50051 list

# 서비스 메서드 목록
grpcurl -plaintext localhost:50051 list ecommerce.v1.ProductService

# 메서드 설명
grpcurl -plaintext localhost:50051 describe ecommerce.v1.ProductService.GetProduct

# Unary 호출
grpcurl -plaintext \
  -d '{"product_id": "prod-123"}' \
  localhost:50051 ecommerce.v1.ProductService/GetProduct

# 헤더 포함 호출
grpcurl -plaintext \
  -H "Authorization: Bearer eyJhbGciOiJSUzI1NiIs..." \
  -d '{"name": "New Product", "price": {"currency_code": "USD", "units": 29, "nanos": 990000000}}' \
  localhost:50051 ecommerce.v1.ProductService/CreateProduct

func TestGetProduct(t *testing.T) {
    // 인메모리 gRPC 서버
    lis := bufconn.Listen(1024 * 1024)
    server := grpc.NewServer()
    pb.RegisterProductServiceServer(server, newTestProductServer())

    go func() {
        if err := server.Serve(lis); err != nil {
            t.Fatal(err)
        }
    }()
    defer server.Stop()

    // 클라이언트 연결
    conn, err := grpc.DialContext(context.Background(), "bufnet",
        grpc.WithContextDialer(func(ctx context.Context, s string) (net.Conn, error) {
            return lis.Dial()
        }),
        grpc.WithTransportCredentials(insecure.NewCredentials()),
    )
    require.NoError(t, err)
    defer conn.Close()

    client := pb.NewProductServiceClient(conn)

    // 테스트 실행
    resp, err := client.GetProduct(context.Background(), &pb.GetProductRequest{
        ProductId: "test-product-1",
    })

    require.NoError(t, err)
    assert.Equal(t, "test-product-1", resp.Id)
    assert.Equal(t, "Test Product", resp.Name)
}

# evans REPL 모드
evans --host localhost --port 50051 -r repl

# 패키지 선택
> package ecommerce.v1

# 서비스 선택
> service ProductService

# RPC 호출
> call GetProduct
product_id (TYPE_STRING) => prod-123
# 결과가 JSON으로 출력됨

func BenchmarkProtobufMarshal(b *testing.B) {
    product := createSampleProduct()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        proto.Marshal(product)
    }
}

func BenchmarkJSONMarshal(b *testing.B) {
    product := createSampleProductJSON()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        json.Marshal(product)
    }
}

ecommerce-grpc/
├── proto/
│   ├── buf.yaml
│   ├── buf.gen.yaml
│   └── ecommerce/
│       └── v1/
│           ├── product.proto
│           ├── order.proto
│           ├── payment.proto
│           └── common.proto
├── services/
│   ├── product/
│   │   ├── main.go
│   │   ├── server.go
│   │   ├── repository.go
│   │   └── server_test.go
│   ├── order/
│   │   ├── main.go
│   │   ├── server.go
│   │   └── saga.go
│   └── payment/
│       ├── main.go
│       └── server.go
├── gen/
│   └── ecommerce/
│       └── v1/
├── docker-compose.yaml
└── Makefile

# buf.gen.yaml
version: v2
plugins:
  - remote: buf.build/protocolbuffers/go
    out: gen
    opt:
      - paths=source_relative
  - remote: buf.build/grpc/go
    out: gen
    opt:
      - paths=source_relative
      - require_unimplemented_servers=false
  - remote: buf.build/connectrpc/go
    out: gen
    opt:
      - paths=source_relative

# 코드 생성
buf generate proto

# 린트
buf lint proto

# 하위 호환성 검사
buf breaking proto --against '.git#branch=main'