gRPC Streaming

The client sends a single request and the server responds with a stream of messages. The client reads from the returned stream until there are no more messages. Critical for personalization: A decisioning engine can push a continuous feed of real-time recommendations, price updates, or inventory alerts to a client after a single subscription request. gRPC guarantees message ordering within an individual stream.

The client writes a sequence of messages and sends them to the server, again using a provided stream. Once the client has finished writing the messages, it waits for the server to read them all and return a single response. Use case: Uploading a batch of user behavioral events (clicks, views, dwell time) to a feature store for real-time sessionization, where the server processes the entire stream and returns an acknowledgment or aggregated result.

Both sides send a sequence of messages using a read-write stream. The two streams operate independently, so clients and servers can read and write in whatever order they like. The server can respond to a client request with a stream of updates while simultaneously receiving a stream of user interactions. This is the foundation for real-time, conversational personalization, enabling a continuous feedback loop between a user's device and a decisioning engine with minimal latency overhead.

The language-neutral, platform-neutral serialization mechanism that underpins gRPC. Protobuf uses a compact binary format defined by .proto files, which are compiled to generate client and server code. This provides strictly typed contracts and significantly smaller payloads compared to JSON or XML. For streaming, Protobuf ensures each message in the stream adheres to a predefined schema, eliminating parsing ambiguity and reducing CPU overhead during serialization/deserialization at high throughput.

The transport layer that makes gRPC streaming viable. Unlike HTTP/1.1's request-response lockstep, HTTP/2 supports full-duplex multiplexing over a single TCP connection. Key enablers include:

• Binary framing: Messages are split into frames that can be interleaved.
• Stream prioritization: Critical messages can bypass less urgent ones.
• Header compression (HPACK): Reduces overhead for repeated metadata. This allows a single connection to host multiple concurrent bidirectional streams without head-of-line blocking.

A critical flow-control mechanism that prevents a fast producer from overwhelming a slow consumer in a streaming pipeline. In gRPC, backpressure is built into the HTTP/2 transport layer via flow-control windows. When a client's receive buffer fills up, it signals the server to pause transmission. This propagates upstream, ensuring system stability without dropping messages. Without this, a server pushing 100k events/second could crash a client processing at 10k events/second.

The downstream engine that consumes and acts on gRPC streams. Technologies like Apache Kafka Streams or Apache Flink ingest the continuous flow of messages for real-time analytics, transformation, or materialized views. gRPC streaming serves as the ingestion pipe, while the stream processor handles:

• Windowing: Aggregating events over time intervals.
• Stateful operations: Maintaining context across individual messages.
• Exactly-once semantics: Ensuring each event is processed durably.

An architectural pattern that naturally pairs with gRPC streaming. Commands (writes) are sent via unary RPCs to update state, while Queries (reads) are served by subscribing to a gRPC server-side stream that pushes state changes in real time. This decouples the write model from the read model, allowing the query stream to be optimized for a specific view. For example, a PlaceOrder command triggers an OrderStatusUpdate event streamed to a customer's mobile app.