Mastering Microservices: gRPC with Node.js Explained

Microservices have taken over the software development world, making applications more scalable and modular. But with microservices comes the challenge of efficient service-to-service communication. Traditionally, REST APIs have been the go-to solution, but they come with limitations like JSON serialization overhead, lack of strong typing, and inefficient network usage. 

This is where gRPC (Google Remote Procedure Call) comes in. Built on HTTP/2, gRPC is fast, efficient, and perfect for real-time microservices communication. 

What is gRPC? 

gRPC was developed by Google and is an open-source framework that enables communication between services in a distributed system. Unlike REST, which relies on text-based JSON over HTTP/1.1, gRPC uses binary serialization (Protocol Buffers) over HTTP/2, making it significantly faster and more efficient. 

Key Features of gRPC: 

→ Protocol Buffers (Protobufs): A lightweight and efficient serialization format. 
→ Streaming Support: Unlike REST, gRPC supports bidirectional streaming. 
→ Strong Typing: Enforces strict contract-based communication. 
→ Automatic Code Generation: Reduces boilerplate code in client-server interactions. 

How gRPC Works 

At its core, gRPC works as follows: 

1. Define the service contract using a .proto file. 
2. Generate server and client stubs from the .proto file. 
3. Implement the server logic in Node.js. 
4. Client interacts with the server using gRPC-generated code. 

Setting Up gRPC in Node.js 

Let’s jump into building a simple gRPC service in Node.js. 

Step 1: Install Dependencies 

First, set up a Node.js project and install gRPC libraries:

 

mkdir grpc-node-microservices && cd grpc-node-microservices
npm init -y
npm install @grpc/grpc-js @grpc/proto-loader

Step 2: Define the gRPC Service 

Create a proto directory and add a file called service.proto:

 

syntax = "proto3";

package users;

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

message UserRequest {
  string userId = 1;
}

message UserResponse {
  string userId = 1;
  string name = 2;
  int32 age = 3;
}

This defines a UserService with an RPC method GetUser that takes a UserRequest and returns a UserResponse. 

Step 3: Implement the gRPC Server 

Now, create a server.js file:

 

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const packageDefinition = protoLoader.loadSync('proto/service.proto');
const usersProto = grpc.loadPackageDefinition(packageDefinition).users;

const server = new grpc.Server();

const userData = {
  "1": { userId: "1", name: "Alice", age: 25 },
  "2": { userId: "2", name: "Bob", age: 30 }
};

server.addService(usersProto.UserService.service, {
  GetUser: (call, callback) => {
    const user = userData[call.request.userId];
    if (user) {
      callback(null, user);
    } else {
      callback({ code: grpc.status.NOT_FOUND, details: "User not found" });
    }
  }
});

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

This server listens on port 50051 and returns user data. 

Step 4: Implement the gRPC Client 

Create a client.js file:

 

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const packageDefinition = protoLoader.loadSync('proto/service.proto');
const usersProto = grpc.loadPackageDefinition(packageDefinition).users;

const client = new usersProto.UserService('127.0.0.1:50051', grpc.credentials.createInsecure());

client.GetUser({ userId: "1" }, (error, response) => {
  if (error) {
    console.error(error);
  } else {
    console.log('User:', response);
  }
});

Run the server first:

 

node server.js

Then, run the client:

 

node client.js

You should see:

 

User: { userId: '1', name: 'Alice', age: 25 }

Advanced gRPC Features in Node.js 

1. Streaming: Unlike REST, gRPC supports four types of communication: 
      - Unary RPC (Single request, single response) 
      - Server Streaming RPC (Single request, multiple responses) 
      - Client Streaming RPC (Multiple requests, single response) 
      - Bi-Directional Streaming RPC (Multiple requests, multiple responses) 

2. Interceptors and Middleware 
      - Just like Express middleware, gRPC has interceptors to handle authentication, logging, etc. 

3. Error Handling 
      - Use grpc.status to define custom errors like grpc.status.PERMISSION_DENIED.

gRPC vs REST in Microservices 

Feature	gRPC	REST
Protocol	HTTP/2	HTTP/1.1
Serialization	Protobuf (binary)	JSON (text)
Speed	Faster	Slower
Streaming	Yes	No
Strong Typing	Yes	No
Interoperability	Limited to gRPC-supported languages	Universal

When to Use gRPC? 
→ Internal microservices communication 
→ High-performance real-time services 
→ Language-agnostic service interactions 

When to Stick with REST? 
→ Public APIs 
→ Simple CRUD applications 

Conclusion 

gRPC is a game-changer for microservices, offering faster and more efficient communication compared to REST.

You may also like:

1. 10 Common Mistakes with Synchronous Code in Node.js

2. Why 85% of Developers Use Express.js Wrongly

3. Implementing Zero-Downtime Deployments in Node.js

4. 10 Common Memory Management Mistakes in Node.js

5. 5 Key Differences Between ^ and ~ in package.json

6. Scaling Node.js for Robust Multi-Tenant Architectures

7. 6 Common Mistakes in Domain-Driven Design (DDD) with Express.js

8. 10 Performance Enhancements in Node.js Using V8

9. Can Node.js Handle Millions of Users?

10. Express.js Secrets That Senior Developers Don’t Share

Read more blogs from Here

Share your experiences in the comments, and let’s discuss how to tackle them!

Follow me on Linkedin