gRPC

Last updated Jan 28, 2023 Edit Source

gRPC is “a high performance, open source universal RPC framework”¹. RPC stands for Remote Procedure Call, which is a kind of API that abstracts the complexity of making calls to a remote API by providing to the developer functions that works like if it was local².

Quote

gRPC uses HTTP/2 under the covers, but HTTP is not exposed to the API designer³

gRPC uses Protocol Buffers as a serialisation format by default, but can use JSON. It works by extending the syntax of a .proto file.

We need to define the messages (basic Protobuf structure) that will be exchanged whenever it’s an argument or a return value, along with the services, that describe the procedures available.

Example from official tutorial¹

First the messages:

1 2 3 4 5 6 7 8 9

// The request message containing the user's name. message HelloRequest { string name = 1; } // The response message containing the greetings message HelloReply { string message = 1; }

and then the gRPC syntax to declare a service, a set of procedures:

1 2 3 4 5

// The greeter service definition. service Greeter { // Sends a greeting rpc SayHello (HelloRequest) returns (HelloReply) {} }

A few advantages of gRPC:

1. It abstracts away the calls to a remote API
2. Compatible with several popular languages
3. It makes possible to work with native objects of your current programming language
4. It generate the classes and object/messages for you from a .proto file

From the dedicated file, it creates a gRPC server to receive requests from clients that themselves use a dynamic library generated via protoc and a dedicated plugin.

This diagram illustrate how different clients/servers written in different languages can work together with the gRPC server and stubs (a client) created.

Although a few users would recommend to use a REST API to handle uploads, other says that it depends on the size of images and your app⁴.

Implementing file uploading in gRPC seems to be done via streams⁵⁶, one of its features. The core principle is to send files in small chunk (by default, gRPC limits incoming messages to 4 MB in case the developer hasn’t thought about message size, but it can be increased⁷) Note that we send the metadata apart from the file, and it’s not a standard so we have to define what’s inside (path, name, extension/type…).

Implementations seem to also use oneof keyword to avoid sending metadata each time we’re sending a chunk of file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

message MetaData {
	string filename = 1;
	string extension = 2;
}

message FileUploadRequest {
	oneof request {
		MetaData metadata = 1;
		bytes chunk = 2;
	}
}