Overall data flow of gRPC

In gRPC, the data flow involves a well-defined process where the client and server communicate seamlessly through remote procedure calls (RPCs). Let’s break down the data flow step by step using a practical example in Node.js.

Client-Side Data Flow:

Method Invocation:

• The client initiates an RPC by invoking a method on the auto-generated gRPC client, which corresponds to a remote procedure defined in the Protobuf service.

const request = { name: 'John' };
client.SayHello(request, (error, response) => {
  console.log(response.greeting);
});

In this example, SayHello is the remote procedure, and request contains the necessary data.

Serialization:

• The client serializes the request data into a binary format using Protocol Buffers (Protobuf). This binary data is more efficient for transmission than traditional text-based formats.

HTTP/2 Transport:

• The serialized data is sent over an HTTP/2 connection. gRPC utilizes HTTP/2 for its multiplexing capabilities, enabling multiple requests and responses to be interleaved over a single connection.

Server-Side Data Flow:

Deserialization:

• The server receives the binary data and deserializes it back into a format it can understand. This is possible because both the client and server have access to the Protobuf service definition, ensuring a shared understanding of the data structure.

Method Execution:

• The server executes the corresponding method, processing the received data and generating a response. In our example, the server processes the SayHello method and creates a greeting based on the client’s request.

server.addService(greeterProto, {
  SayHello: (call, callback) => {
    callback(null, { greeting: 'Hello ' + call.request.name });
  },
});

Serialization (Response):

• Similar to the client-side, the server serializes the response data (in this case, the greeting) into binary format using Protobuf.

HTTP/2 Transport (Response):

• The serialized response is sent back to the client over the same HTTP/2 connection.

Client-Side Data Flow (Response):

Deserialization (Response):

• The client receives the binary response and deserializes it back into a usable format. Now, the client has the server’s response in a structured form.

Callback Execution:

• The client’s callback function is executed, allowing the application to handle the server’s response. In our example, the client logs the received greeting.

Visualization

The following description outlines the comprehensive data flow for gRPC.

• In the initial step, the client initiates a REST call, with the request body typically formatted in JSON.
• During Steps 2 to 4, the order service, acting as a gRPC client, intercepts the REST call, transforms it, and initiates an RPC call to the payment service. The client stub is encoded into a binary format by gRPC and transmitted to the low-level transport layer.
• For Step 5, gRPC transmits the binary-encoded packets over the network using HTTP2. The use of binary encoding and network optimizations contributes to gRPC’s reputed 5X faster performance compared to JSON.
• Continuing to Steps 6 through 8, the payment service, functioning as a gRPC server, receives the network packets, decodes them, and triggers the server application.
• In Steps 9 to 11, the server application produces a result, which is then encoded and dispatched to the transport layer.
• Progressing to Steps 12 through 14, the order service receives the encoded packets, decodes them, and forwards the result to the client application.