gRPC Remote Procedure Calls

gRPC is basically Google’s way of making service-to-service communication super fast and efficient. It’s an open-source RPC framework built for speed, scalability, and flexibility, and it works across multiple programming languages—so you’re not stuck with just one tech stack. If you’re dealing with microservices, cloud apps, or real-time systems, gRPC is a solid choice. It’s great for high-performance APIs, streaming data, and inter-service calls without the overhead of REST. Plus, it uses HTTP/2 and Protobuf, which means smaller payloads, lower latency, and a much smoother experience overall.

HTTP/2 brings a significant improvement over HTTP/1.1 by making web communication faster and more efficient. Unlike its predecessor, which processes requests sequentially, HTTP/2 allows multiple requests to be sent simultaneously over a single connection, reducing wait times and improving page load speed. It also compresses headers, which helps minimize redundant data transmission, and prioritizes important resources, ensuring that critical elements load first. These enhancements lead to a smoother user experience, especially on modern, content-heavy websites. However, in some cases—such as when dealing with very simple requests or legacy systems that don’t support HTTP/2—HTTP/1.1 can still be a practical choice.

When use gRPC

gRPC is widely used in modern applications where performance, efficiency, and scalability are crucial. Some common use cases include:

• Microservices Communication – gRPC enables high-performance, low-latency communication between microservices, making it ideal for distributed architectures.
• Real-time Streaming – With its built-in support for bidirectional streaming, gRPC is perfect for applications requiring continuous data exchange, such as chat applications, stock market feeds, and live dashboards.
• IoT and Edge Computing – gRPC’s lightweight and efficient protocol makes it suitable for resource-constrained devices, allowing IoT applications to communicate efficiently with cloud services.
• Interoperability Across Languages – gRPC supports multiple programming languages, making it a great choice for systems where different services are built using different tech stacks.
• API Gateway for Backend Services – Many companies use gRPC as an internal API gateway to handle high-throughput backend operations before exposing REST or GraphQL endpoints for external clients.
• High-Performance Machine Learning Pipelines – In AI/ML workloads, gRPC helps in fast data transmission between distributed components, such as model training servers and inference services.

These use cases highlight how gRPC excels in high-performance, scalable, and real-time systems where traditional HTTP APIs might introduce latency or inefficiencies.

When use gRPC

gRPC Component Files

When setting up gRPC in a project, several key files are required to define services, handle communication, and integrate with different programming languages. Each file plays a specific role in ensuring smooth and efficient communication between clients and servers.

• .proto File – This is the core of any gRPC service. It defines the structure of requests, responses, and services using Protocol Buffers (protobuf). It specifies message types and service methods, acting as a contract between clients and servers.
• Generated Stub Files – Once the .proto file is compiled, gRPC generates client and server code in the desired programming language. These stubs provide ready-to-use methods for sending and receiving messages, eliminating the need to write boilerplate communication logic.
• Server Implementation – This file contains the actual logic for handling gRPC requests. It extends the generated server stubs, implementing methods that process client calls and return responses.
• Client Code – The client-side implementation is responsible for making RPC calls to the server. It uses the generated client stubs to send requests and receive responses efficiently.
• gRPC Configuration File (Optional) – Some applications may include configuration files to manage gRPC settings, such as authentication, load balancing, and connection parameters, to optimize performance.

These files collectively form the foundation of a gRPC service, ensuring seamless communication between distributed systems while maintaining efficiency and scalability

gRPC communitaction models

gRPC supports multiple communication models, making it suitable for various application needs. Below are the key types of gRPC communication along with real-world examples:

• Unary RPC – The client sends a single request and receives a single response, similar to a standard API call.
  Example: A mobile app requests user profile details from a backend service, and the server returns the data.
• Server Streaming RPC – The client sends one request, and the server streams multiple responses back.
  Example: A stock market application subscribes to price updates for a specific stock, receiving continuous updates from the server.
• Client Streaming RPC – The client streams multiple requests, and the server processes them and responds with a single message.
  Example: A file upload service where a client sends chunks of a large file, and the server returns a confirmation upon completion.
• Bidirectional Streaming RPC – Both client and server send and receive multiple messages in a continuous stream.
  Example: A real-time chat application where users can send and receive messages without waiting for previous messages to be processed.

These different types of gRPC communication make it a powerful tool for building modern, scalable, and real-time applications.

gRPC Component Files

Let’s take a look at a simple example of extending chat messages, this time using TypeScript.

syntax = "proto3";

package chat;

service ChatService {
  rpc ChatStream(stream ChatMessage) returns (stream ChatMessage);
}

message ChatMessage {
  string user = 1;
  string message = 2;
}

This file enables the generation of language-specific files used for sending messages. Let’s create server and client code to use it.

import * as grpc from "@grpc/grpc-js";
import { ChatServiceService, ChatServiceServer } from "../grpc_generated/chat";
import { ChatMessage } from "../grpc_generated/chat";

const chatServer: ChatServiceServer = {
    chatStream: (call) => {
        console.log("Client connected...");

        call.on("data", (message: ChatMessage) => {
            console.log(`${message.user} says: ${message.message}`);

            call.write(
                ChatMessage.create({
                    user: "Server",
                    message: `Message received!`,
                })
            );
        });

        call.on("end", () => {
            console.log("Client disconnected.");
            call.end();
        });
    },
};

const server = new grpc.Server();
server.addService(ChatServiceService, chatServer);
server.bindAsync("0.0.0.0:50051", grpc.ServerCredentials.createInsecure(), () => {
    console.log("Server running on port 50051");
});

import * as grpc from "@grpc/grpc-js";
import { ChatServiceClient } from "../grpc_generated/chat";
import { ChatMessage } from "../grpc_generated/chat";

const client = new ChatServiceClient("localhost:50051", grpc.credentials.createInsecure());
const stream = client.chatStream();

stream.on("data", (message: ChatMessage) => {
    console.log(`Server: ${message.message}`);
});

const sendMessage = (user: string, message: string) => {
    const chatMessage = ChatMessage.create({ user, message });
    stream.write(chatMessage);
};

// Simulated chat messages
sendMessage("Bro", "Test!");
setTimeout(() => sendMessage("Neo", "Test?"), 2000);
setTimeout(() => sendMessage("Dude", "Test!"), 4000);
setTimeout(() => stream.end(), 6000);