What is gRPC?

gRPC is a robust open-source RPC (Remote Procedure Call) framework used to build scalable and fast APIs. It allows the client and server applications to communicate transparently and develop connected systems through HTTP/2. gRCP is a part of Cloud Native Computation Foundation like Docker or Kubernetes.

gRPC provides a new reality for RPC by making it interoperable, modern, and efficient using technologies like Protocol buffers and HTTP/2.

Definition

gRPC (gRPC Remote Procedure Calls) is a cross-platform high-performance remote procedure call (RPC) framework. gRPC was initially created by Google, but it is open source and is used in many organizations. gRPC can run in any environment, and use cases range from microservices to the "last mile" of computing (mobile, web, and Internet of Things).

gRPC uses HTTP/2 for transport, Protocol Buffers as the interface description language, can efficiently connect services in and across data centers with pluggable support for load balancing, tracing, health checking and authentication, bidirectional streaming, flow control, blocking or nonblocking bindings, and cancellation and timeouts. It generates cross-platform client and server bindings for many languages. Most common usage scenarios include connecting services in a microservices style architecture or connecting mobile device clients to backend services.

Like many RPC systems, gRPC is based on defining a service in terms of functions (methods) that can be called remotely. For each method, you define the parameters and return types. Services, parameters, and return types are defined in .proto files using Google's open-source language-neutral protocol buffers mechanism.

Use cases

We can see that, gRPC seems to be very complex by definition. So, what is it used for in software development? It is designed for use cases where low-latency and high-throughput communication is required. It is particularly well-suited for use cases such as:

Microservices that need to communicate with each other
Real-time streaming of data between services
High-performance distributed systems
Mobile and web applications that need to communicate with a backend

As mentioned above, gRPC provides an interface for communication between the client and the server, mobile and web applications. So, what’s the difference between Restful and GraphQL? Or Microservices, what’s the difference between gRPC and event/message? In the next article, we will jump into detail.

How does gRPC work?

In gRPC, a client application can directly call a method on a server application on a different machine as if it were a local object, making it easier for you to create distributed applications and services. As in many RPC systems, gRPC is based on the idea of defining a service and specifying the methods that can be called remotely with their parameters and return types.

On the server side, the server implements this interface and runs a gRPC server to handle client calls. On the client side, the client has a stub (referred to as just a client in some languages) that provides the same methods as the server.

gRPC clients and servers can run and talk to each other in a variety of environments - from servers inside Google to your desktop - and can be written in any of gRPC’s supported languages. So, for example, you can easily create a gRPC server in Java with clients in Go, Python, or Ruby. In addition, the latest Google APIs will have gRPC versions of their interfaces, letting you easily build Google functionality into your applications.

Benefit

High-Performance Transfers: gRPC uses a binary serialization format (Protocol Buffers) which results in faster serialization and parsing compared to traditional text-based formats like JSON or XML as well as smaller message sizes. This makes the transmission more efficient, with lower resources while still saving bandwidth.
Multiplexing: gRPC makes use of HTTP/2 protocol, which is a big enhancement over HTTP/1.1. HTTP/2 introduces features such as request and response multiplexing over a single connection, header compression, and server push. This results in a reduction in latency and network transfer speeds while improving overall performance.
Language-Agnostic & Code Generation: gRPC uses Protocol Buffers to define messages and services, which compile into code in a variety of programming languages including Java, C++, and Python. This makes communication between services simple and flexible regardless of the language used for development. It also allows developers to compile their code in their preferred language while reducing the amount of boilerplate code needed to write.
Cross-Platform: gRPC supports running on multiple platforms, including Linux, Windows, and macOS. This makes it easier to develop and deploy services in a variety of environments.
Secure: gRPC considers security to be a first-class citizen. It supports built-in SSL/TLS encryption for secure transfers and mutual authentication
Streaming Support: gRPC provides many different types of APIs, including unary, server streaming, client streaming, and bidirectional streaming. These APIs allow for a variety of different communication patterns between the client and server.
Strong Community Support: Because it was developed by Google and gained a lot of traction in the community, gRPC is being widely adopted and keeps being continuously improved by developers and organizations.

Reference

[1] https://grpc.io/docs

[2] https://blog.shiftasia.com/grpc-vs-rest-speed-comparation/

[3] https://en.wikipedia.org/wiki/GRPC

[4] https://www.blip.pt/blog/posts/beyond-rest-exploring-the-benefits-of-grpc/

Part 1: Introduction to gRPC Framework