CODE GAZETTE

What are gRPCs?

gRPC is an open-source framework used for service-to-service communication developed by Google. The abbreviation RPC in its name, Remote Procedure Call, indicates that we can call a method on a remote server as if it were our own method. It is based around the idea of defining a service, 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.

Why We Needed gRPC ?

Before gRPC, microservices typically communicated using HTTP/1.1, often with JSON as the payload format for RESTful APIs. While effective, this approach had limitations. JSON’s text-based format results in larger payloads and slower serialization/deserialization compared to binary formats. Additionally, HTTP/1.1’s sequential request-response model can introduce latency due to head-of-line blocking, and real-time communication often required complex solutions like WebSockets for streaming use cases. This is where gRPC shines. Developed by Google, gRPC addresses these issues by offering a high-performance RPC framework that delivers smaller, faster payloads, low-latency communication, and native support for real-time streaming. This makes gRPC ideal for microservices, distributed systems, and applications requiring efficient, scalable communication.

How gRPC's works under the hood?

                       A small flow diagram 
[Client Code]
    ↓
[Client Stub] ← auto-generated
    ↓
[Protobuf Serialization]
    ↓
[HTTP/2 Transport]
    ↓
[Server Stub] ← auto-generated
    ↓
[Service Implementation]

gRPC works by having a client stub serialize a method call into a Protocol Buffers message, sent over an HTTP/2 connection with headers and metadata. The server deserializes the message, executes the service logic, and serializes the response back to the client. HTTP/2 enables efficient, multiplexed, and streaming communication, with the connection reused for low latency.

Using gRPC with Node.js

Let’s apply what we’ve learned by building a small implementation that demonstrates gRPC’s messaging and streaming capabilities. What are we building? We will create a simple application that allows users to send messages with their username and receive a stream of messages based on a subscribed room, using Server-Sent Events (SSE) for real-time notifications. Project Structure: We will create four repositories: A simple client using React A proxy server to act as a bridge between the client and other services A Redis server for message broadcasting A gRPC server to handle messaging and streaming logic

chat.proto

syntax = "proto3";

service ChatService {
  rpc SendMessage (MessageRequest) returns (MessageResponse);
  rpc StreamNotifications (NotificationRequest) returns (stream NotificationResponse);
}

message MessageRequest {
  string user = 1;
  string content = 2;
}

message MessageResponse {
  string status = 1;
}

message NotificationRequest {
  string user = 1;
}

message NotificationResponse {
  string message = 1;
}

So this chat.proto file defines the gRPC service and structure using Protocol Buffers.

It specifies a unary SendMessage RPC for sending chat messages and a server-streaming StreamNotifications RPC for real-time notifications. It includes message structures like MessageRequest (with user and content) and NotificationResponse (with message), which are serialized into a compact binary format for efficient HTTP/2 transport.

grpc.server

const PROTO_PATH = path.join(__dirname, 'proto/chat.proto');
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
});
const chatProto = grpc.loadPackageDefinition(packageDefinition).ChatService;

// gRPC service implementation
const sendMessage = async (call, callback) => {
  const { user, content } = call.request;
  console.log(`Received message from ${user}: ${content}`);

  await redisClient.publish('chat_channel', `${user}: ${content}`);

  callback(null, { status: 'Message received and published' });
};
const streamNotifications = (call) => {
  const { user } = call.request;
  const subscriber = redis.createClient({ url: 'redis://localhost:6379' });
  subscriber.connect();
  subscriber.subscribe('chat_channel', (message) => {
    if (message.startsWith(`${user}:`)) {
      call.write({ message });
    }
  });
  call.on('cancelled', () => {
    subscriber.quit();
  });
};
// Start gRPC server
const server = new grpc.Server();
server.addService(chatProto.service, {
  SendMessage: sendMessage,
  StreamNotifications: streamNotifications
});

server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), () => {
  console.log('gRPC server running on port 50051');
  server.start();
});

The grpcServer.js file implements the gRPC server for the ChatService defined in chat.proto. It handles the unary SendMessage RPC by deserializing the client’s MessageRequest, publishing the message to a Redis channel, and returning a MessageResponse. For the server-streaming StreamNotifications RPC, it subscribes to Redis, filters messages for the specified user, and streams NotificationResponse messages over an HTTP/2 connection.

grpc client proxy

const PROTO_PATH = path.join(__dirname, '../grpc-server/proto/chat.proto');
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
});
const ChatService = grpc.loadPackageDefinition(packageDefinition).ChatService;

const client = new ChatService('localhost:50051', grpc.credentials.createInsecure());

console.log('Testing gRPC connection...');
client.SendMessage({ user: 'test', content: 'hello' }, (err, response) => {
  if (err) console.error('Connection Test Error:', err);
  else console.log('Connection Test Success:', response);
});

module.exports = {
  sendMessage: (user, content, callback) => {
    client.SendMessage({ user, content }, (err, response) => {
      callback(err, response);
    });
  },
  streamNotifications: (user, onData) => {
    if (!user || user.trim() === '') {
      console.log('Invalid user for stream');
      return { cancel: () => { } };
    }
    const call = client.StreamNotifications({ user });
    call.on('data', (data) => {
      onData(data);
    });
    call.on('end', () => {
      console.log('Stream ended');
    });
    call.on('error', (err) => {
      if (err.code === grpc.status.CANCELLED) {
        console.log('Stream cancelled by client');
      } else {
        console.error('Stream error:', err);
      }
    });
    return call;
  }
};

The grpcClient.js file sets up a gRPC client to interact with the ChatService defined in chat.proto. It loads the Protobuf definition, creates a client connected to the gRPC server at localhost:50051, and exports two functions: sendMessage to send chat messages, and streamNotifications to initiate the server-streaming StreamNotifications. This client is used by the Express server to relay messages and streams between the React client and the gRPC backend.

proxy server.js

app.use(express.json());

// REST endpoint to send messages
app.post('/send', (req, res) => {
  const { user, content } = req.body;
  if (!user || !content) {
    return res.status(400).json({ error: 'User and content are required' });
  }
  sendMessage(user, content, (err, response) => {
    if (err) {
      console.error('SendMessage error:', err);
      return res.status(500).json({ error: err.message });
    }
    console.log(`Sent message for user: ${user}`);
    res.json({ status: response.status });
  });
});

// Server-Sent Events for streaming notifications
app.get('/notifications/:user', (req, res) => {
  const user = req.params.user;
  if (!user || user.trim() === '') {
    console.log('Invalid user parameter');
    return res.status(400).send('User parameter is required');
  }
  console.log(`Starting SSE for user: ${user}`);
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');

  const stream = streamNotifications(user, (data) => {
    console.log(`Sending notification to user ${user}: ${JSON.stringify(data)}`);
    res.write(`data: ${JSON.stringify(data)}\n\n`);
  });

  req.on('close', () => {
    console.log(`SSE connection closed for user: ${user}`);
    stream.cancel();
  });

  // Keep SSE alive with periodic pings
  const keepAlive = setInterval(() => {
    res.write(': ping\n\n');
  }, 15000);

  req.on('close', () => {
    clearInterval(keepAlive);
  });
});

app.listen(3001, () => console.log('API server running on port 3001'));

The file runs an Express proxy that connects a React client to the gRPC backend. Its /send endpoint triggers the unary SendMessage RPC, forwarding the client’s message to the gRPC server and returning the response as JSON. The /notifications/:user endpoint uses Server-Sent Events (SSE) to stream NotificationResponse messages from the gRPC StreamNotifications RPC, converting HTTP/2 streams into browser-compatible real-time updates.

These were the main files that handle all the core tasks. For the complete application, you can check out the GitHub repository here: Click here

I believe I’ve covered all the essential concepts needed to understand gRPC and how to use it with Node.js.

As a personal remark — based on my experience — gRPC is genuinely fun to work with, especially when it comes to scalability. It can truly be a game changer in terms of performance and efficiency for modern backend systems. !

Building Real-Time Apps with gRPC: A Complete Guide Using Node.js and Redis

What are gRPCs?

Why We Needed gRPC ?

How gRPC's works under the hood?

Using gRPC with Node.js

Comments