🔌

gRPC 시작하기 - Bidirectional Streaming RPC

최민석·2026-04-15

gRPC 시작하기 - Bidirectional Streaming RPC

gRPC

🔌 gRPC with Go 시리즈

이전 글에서는 Client Streaming RPC를 다뤘습니다. 이번 글에서는 gRPC의 마지막 통신 패턴인 Bidirectional Streaming RPC를 구현해봅니다. 클라이언트와 서버가 동시에 스트림으로 데이터를 주고받는 패턴입니다.


Bidirectional Streaming이란

양쪽 모두 스트림으로 동시에 주고받습니다. 두 스트림은 독립적이라 순서와 타이밍이 자유롭습니다.

sequenceDiagram participant C as 클라이언트 participant S as 서버 C->>S: "hello" S-->>C: "HELLO" C->>S: "today" C->>S: "is the day" S-->>C: "TODAY" S-->>C: "IS THE DAY" C->>S: "last message." S-->>C: "LAST MESSAGE." Note over C,S: 클라이언트가 CloseSend → 서버가 EOF 수신 → 서버 return nil → 클라이언트가 EOF 수신

채팅, 실시간 게임, 양방향 모니터링 등에 사용됩니다.


proto 파일 정의

syntax = "proto3";

package echo.v1;

option go_package = "/pb";

message EchoRequest {
  string message = 1;
}

message EchoResponse {
  string message = 1;
}

service EchoService {
  rpc Echo(stream EchoRequest) returns (stream EchoResponse);
}

요청과 응답 모두에 stream 이 붙습니다. 이것만으로 gRPC가 Bidirectional Streaming으로 인식합니다.


4가지 패턴의 서버 시그니처 비교

패턴 서버 메서드 시그니처
Unary Method(context.Context, *Request) (*Response, error)
Server Streaming Method(*Request, grpc.ServerStreamingServer[Response]) error
Client Streaming Method(grpc.ClientStreamingServer[Request, Response]) error
Bidirectional Method(grpc.BidiStreamingServer[Request, Response]) error

Client Streaming과 비슷하게 stream 객체 하나를 받지만, 이번에는 Send와 Recv를 모두 사용합니다.


서버 구현

type EchoServer struct {
    pb.UnimplementedEchoServiceServer
}

func (es *EchoServer) Echo(stream grpc.BidiStreamingServer[pb.EchoRequest, pb.EchoResponse]) error {
    for {
        req, err := stream.Recv()
        if err != nil {
            if errors.Is(err, io.EOF) {
                return nil
            } else {
                return status.Error(codes.DataLoss, "unexpected error")
            }
        }
        resp := strings.ToUpper(req.GetMessage())
        stream.Send(&pb.EchoResponse{Message: resp})
    }
}

Recv로 메시지를 받고, 대문자로 변환하여 Send로 즉시 응답합니다. 클라이언트가 CloseSend를 호출하면 Recv가 io.EOF를 반환하고, return nil로 서버 스트림도 종료됩니다.

Client Streaming에서는 SendAndClose로 마지막에 한 번 응답했지만, Bidirectional에서는 Send를 여러 번 호출합니다. 응답도 스트림이기 때문입니다.


클라이언트 구현

Bidirectional Streaming에서는 Send와 Recv가 동시에 일어나야 합니다. Recv()가 블로킹되는 동안 Send()를 못 하면 양방향의 의미가 없습니다. 그래서 고루틴으로 분리합니다.

스트림 래퍼

type outStreamPort struct {
    grpc.BidiStreamingClient[pb.EchoRequest, pb.EchoResponse]
}

func (o *outStreamPort) Send(msg string) {
    o.BidiStreamingClient.Send(&pb.EchoRequest{Message: msg})
}

func (o *outStreamPort) Recv() error {
    msg, err := o.BidiStreamingClient.Recv()
    if err != nil {
        if errors.Is(err, io.EOF) {
            slog.Info("[*] connection ended")
        } else {
            slog.Error("[*] error occured", "err", err)
        }
        return err
    }
    slog.Info(fmt.Sprintf("[+] Received: %v", msg.Message))
    return nil
}

raw stream을 직접 다루지 않고, outStreamPort로 감싸서 Send는 문자열만 넘기면 되고 Recv는 출력과 에러 처리를 내부에서 합니다.

main 함수

func main() {
    conn, err := grpc.NewClient("localhost:50021", grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        slog.Error("[-] error occured", "err", err)
        return
    }
    defer conn.Close()

    client := pb.NewEchoServiceClient(conn)
    stream, err := client.Echo(context.Background())
    if err != nil {
        slog.Error("[-] error occured", "err", err)
        return
    }
    port := outStreamPort{BidiStreamingClient: stream}

    var wg sync.WaitGroup
    wg.Add(2)

    // Sender — 고루틴에서 메시지 전송
    go func(p *outStreamPort, wg *sync.WaitGroup) {
        defer wg.Done()
        p.Send("hello")
        time.Sleep(1 * time.Second)
        p.Send("today")
        time.Sleep(1 * time.Second)
        p.Send("is the day")
        time.Sleep(1 * time.Second)
        p.Send("last message.")
        p.CloseSend()
    }(&port, &wg)

    // Receiver — 고루틴에서 응답 수신
    go func(p *outStreamPort, wg *sync.WaitGroup) {
        defer wg.Done()
        for {
            err := p.Recv()
            if err != nil {
                break
            }
        }
    }(&port, &wg)

    wg.Wait()
}

Sender와 Receiver가 각각 고루틴에서 독립적으로 동작합니다. WaitGroup으로 두 고루틴 모두 완료되기를 기다립니다.

스트림 종료 흐름:

sequenceDiagram participant CS as 클라이언트 Sender participant CR as 클라이언트 Receiver participant S as 서버 CS->>S: Send (메시지들) S-->>CR: Send (응답들) CS->>S: CloseSend() Note right of S: Recv()가 io.EOF 반환 S->>S: return nil Note left of CR: Recv()가 io.EOF 반환 CR->>CR: 루프 탈출

CloseSend()가 없으면 서버의 Recv()가 영원히 블로킹되어 양쪽 모두 종료되지 않습니다.


4가지 패턴 Send/Recv 총정리

패턴 서버 클라이언트
Unary 인자로 받고 반환 호출하고 반환값 받음
Server Streaming Send 루프 → return nil Recv 루프 → io.EOF로 종료
Client Streaming Recv 루프 → SendAndClose Send 루프 → CloseAndRecv
Bidirectional Recv + Send 루프 → return nil Send 고루틴 + Recv 고루틴 → CloseSend

gRPC의 4가지 통신 패턴을 모두 살펴보았습니다. stream 키워드의 위치와 Send/Recv의 조합만 이해하면, 어떤 패턴이든 동일한 원리로 구현할 수 있습니다.

관련 포스트