Unlocking Performance: Building High-Speed Microservices with Node.js and gRPC

+-------------------------------------------------------------------------------+
|                      REST JSON vs. gRPC Protobuf Network Hop                  |
+-------------------------------------------------------------------------------+
| REST API:                                                                     |
| [Client] ---> TCP Sockets ---> HTTP/1.1 POST ---> JSON String (~1,200 Bytes)  |
| (High parsing overhead, head-of-line blocking, high memory allocations)       |
|                                                                               |
| gRPC:                                                                         |
| [Client] ═══════════════ Multiplexed HTTP/2 Streams ══════════════> [Server]  |
| (Compact binary Protobuf (~140 Bytes), HPACK header compression, sub-ms RPC)  |
+-------------------------------------------------------------------------------+

graph TD
    Client([Node.js Client Service]) -->|Persistent HTTP/2 Multiplexed Channel| Svc[Greeter gRPC Microservice :50051]
    
    subgraph gRPC Handlers
        Svc -->|Unary RPC| Unary[SayHello: Request -> Response]
        Svc -->|Server Streaming| Stream[SayHelloStream: Server pushes live chunks]
    end

syntax = "proto3";

package greeter.v1;

service GreeterService {
  // Unary RPC: Single request returns single greeting
  rpc SayHello (HelloRequest) returns (HelloResponse);

  // Server Streaming RPC: Single request streams multiple real-time greetings
  rpc SayHelloStream (HelloRequest) returns (stream HelloResponse);
}

message HelloRequest {
  string name = 1;
  string language = 2;
}

message HelloResponse {
  string greeting = 1;
  int64 timestamp = 2;
}

npm init -y
npm install @grpc/grpc-js @grpc/proto-loader
npm install -D typescript @types/node ts-node

// src/server.ts
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import path from 'node:path';

const PROTO_PATH = path.resolve(__dirname, '../proto/greeter.proto');

const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
});

const proto = (grpc.loadPackageDefinition(packageDefinition) as any).greeter.v1;

const server = new grpc.Server({
  'grpc.max_receive_message_length': 1024 * 1024 * 4, // 4MB maximum payload
  'grpc.max_send_message_length': 1024 * 1024 * 4,
  'grpc.keepalive_time_ms': 10000,                    // 10s ping to maintain TCP connection
  'grpc.keepalive_timeout_ms': 5000,
});

server.addService(proto.GreeterService.service, {
  // 1. Unary RPC Handler
  sayHello: (
    call: grpc.ServerUnaryCall<any, any>,
    callback: grpc.sendUnaryData<any>
  ) => {
    const { name, language } = call.request;

    if (!name) {
      return callback({
        code: grpc.status.INVALID_ARGUMENT,
        message: 'Name parameter is required',
      });
    }

    const greetingPrefix = language === 'es' ? '¡Hola' : 'Hello';
    callback(null, {
      greeting: `${greetingPrefix}, ${name}!`,
      timestamp: Date.now(),
    });
  },

  // 2. Server Streaming RPC Handler
  sayHelloStream: (call: grpc.ServerWritableStream<any, any>) => {
    const { name } = call.request;
    const messages = ['Welcome', 'Processing profile', 'Synchronizing settings', 'Ready'];

    let index = 0;
    const timer = setInterval(() => {
      if (index >= messages.length) {
        clearInterval(timer);
        call.end(); // Terminate the stream
        return;
      }

      call.write({
        greeting: `${messages[index]}, ${name}!`,
        timestamp: Date.now(),
      });
      index++;
    }, 500);
  },
});

const BIND_ADDR = '0.0.0.0:50051';
server.bindAsync(BIND_ADDR, grpc.ServerCredentials.createInsecure(), (err, port) => {
  if (err) {
    console.error('Failed to bind gRPC server:', err);
    return;
  }
  console.log(`[gRPC Server] High-speed microservice running on port ${port}`);
});

// src/client.ts
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import path from 'node:path';

const PROTO_PATH = path.resolve(__dirname, '../proto/greeter.proto');
const packageDefinition = protoLoader.loadSync(PROTO_PATH);
const proto = (grpc.loadPackageDefinition(packageDefinition) as any).greeter.v1;

// Initialize persistent multiplexed client channel
const client = new proto.GreeterService(
  'localhost:50051',
  grpc.credentials.createInsecure(),
  {
    'grpc.keepalive_time_ms': 10000,
    'grpc.keepalive_timeout_ms': 5000,
  }
);

async function runClient() {
  console.log('--- 1. Invoking Unary RPC ---');
  client.sayHello(
    { name: 'Tahir Idrees', language: 'en' },
    (err: grpc.ServiceError | null, response: any) => {
      if (err) {
        console.error('Unary RPC Failed:', err.message);
        return;
      }
      console.log('Received Greeting:', response.greeting);
    }
  );

  console.log('\n--- 2. Invoking Streaming RPC ---');
  const stream = client.sayHelloStream({ name: 'Tahir Idrees' });

  stream.on('data', (response: any) => {
    console.log(`[Stream Chunk]: ${response.greeting}`);
  });

  stream.on('end', () => {
    console.log('Server stream concluded successfully.');
  });
}

runClient();