Nel mondo dei microservizi e dei sistemi distribuiti, ogni millisecondo di riduzione della latenza conta. Una delle soluzioni che negli ultimi anni sta guadagnando sempre più popolarità è gRPC in Node.js. In questo articolo esamineremo come funziona il protocollo gRPC, perché può superare le tradizionali API REST in termini di prestazioni e quando conviene sceglierlo nei progetti basati su Node.js.
Cos’è gRPC?
gRPC (gRPC Remote Procedure Call) è un framework RPC open‑source sviluppato da Google. Si basa su HTTP/2, utilizza il formato binario di scambio dati – Protocol Buffers (Protobuf) – e definisce i contratti dei servizi nei file .proto. Grazie a ciò la comunicazione è sia veloce sia tipizzata in modo sicuro.
Come funziona sotto il cofano?
Il flusso di base in gRPC è il seguente:
- Il client e il server scambiano file
.protoche descrivono servizi e messaggi. - In base a questi file vengono generati stub (client) e servizi (server) nel linguaggio scelto.
- La connessione viene stabilita usando HTTP/2, che consente multiplexing, compressione degli header e una connessione persistente.
- I messaggi vengono serializzati nel formato binario Protobuf, riducendo la dimensione del payload rispetto a JSON.
In pratica ciò significa che, una volta stabilita la connessione, le successive chiamate ai metodi vengono inviate come piccoli frame binari, anziché come interi header HTTP/1.1.
gRPC vs REST – le differenze principali
Confrontando gRPC e le tradizionali API REST, è utile considerare alcuni aspetti chiave:
- Trasporto: gRPC utilizza HTTP/2, mentre REST utilizza più spesso HTTP/1.1. HTTP/2 offre maggiore larghezza di banda e minori latenze grazie al multiplexing.
- Formato dei dati: gRPC usa Protobuf, che è binario e molto più leggero rispetto al JSON testuale usato in REST.
- Modello di comunicazione: gRPC supporta non solo request‑response, ma anche streaming (server‑side, client‑side, bidirezionale), cosa più complessa da realizzare in puro REST.
- Tipizzazione: le definizioni in
.protogenerano codice tipizzato nei linguaggi di destinazione, eliminando molti errori legati a incompatibilità di schema.
Vale la pena sottolineare che ciò non significa che REST sia obsoleto – nella maggior parte dei casi la sua semplicità e il vasto supporto nei browser lo rendono la scelta migliore. gRPC, invece, brilla in ambienti dove le prestazioni e la forte tipizzazione sono fondamentali.
Prestazioni di gRPC vs HTTP/1.1
Studi e test interni su Coderia.it hanno dimostrato che, a carico identico, gRPC può essere da 2 a 5 volte più veloce rispetto al tradizionale REST basato su HTTP/1.1. I fattori principali sono la minore dimensione del payload, la connessione persistente e la possibilità di trasmettere più stream simultaneamente su un unico canale.
Tuttavia, per ottenere questi vantaggi è necessario tenere presente alcuni dettagli: il server deve supportare HTTP/2 e il client (ad esempio un browser) non sempre ha un supporto nativo per gRPC – in questi casi si utilizza il cosiddetto gRPC‑Web.
Implementazione di gRPC in Node.js e TypeScript
Di seguito un breve esempio su come configurare un semplice servizio “Calculator” in Node.js usando TypeScript.
// calculator.proto
syntax = "proto3";
package calculator;
service Calculator {
rpc Add (AddRequest) returns (AddResponse);
}
message AddRequest {
double a = 1;
double b = 2;
}
message AddResponse {
double result = 1;
}
Generiamo il codice con grpc-tools e protobufjs:
npx grpc_tools_node_protoc --ts_out=src --js_out=import_style=commonjs,binary:src \
--grpc_out=grpc_js:src --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts \
-I ./proto calculator.protoSuccessivamente implementiamo il server:
import * as grpc from '@grpc/grpc-js';
import { CalculatorService, ICalculatorServer } from './generated/calculator_grpc_pb';
import { AddRequest, AddResponse } from './generated/calculator_pb';
const server = new grpc.Server();
const calculatorImpl: ICalculatorServer = {
add: (call, callback) => {
const a = call.request.getA();
const b = call.request.getB();
const response = new AddResponse();
response.setResult(a + b);
callback(null, response);
},
};
server.addService(CalculatorService, calculatorImpl);
server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), () => {
server.start();
console.log('gRPC server running on port 50051');
});
Il client è analogo – crea lo stub e chiama il metodo add. Grazie a TypeScript si ottiene il completamento automatico completo e la verifica statica dei tipi.
Checklist pratica per l’adozione di gRPC in un progetto Node.js
- Verifica che tutti i componenti (server, client, load balancer) supportino HTTP/2.
- Stabilisci una convenzione per il versionamento dei file
.proto– le modifiche al contratto devono essere retro‑compatibili. - Configura la generazione del codice (ad esempio nella CI) – eviterai modifiche manuali.
- Abilita la compressione dei messaggi (gRPC supporta gzip) negli ambienti a larghezza di banda limitata.
- Assicurati di monitorare latenza e tasso di errori a livello RPC (ad esempio con OpenTelemetry).
Errori comuni e compromessi nell'uso di gRPC
Anche se gRPC offre numerosi vantaggi, nella pratica è possibile imbattersi in alcune trappole:
- Mancanza di supporto nativo nei browser – richiede uno strato gRPC‑Web o la traduzione verso REST.
- Complessità del protocollo – la gestione delle versioni dei file
.protoe del codice generato può risultare più difficile rispetto al mantenimento di un semplice endpoint JSON. - Dimensione del payload binario – in alcuni casi rende più difficile il debug con gli strumenti HTTP tradizionali.
Una soluzione frequente è un approccio ibrido: le interfacce critiche e ad alte prestazioni migrano a gRPC, mentre quelle meno intensive rimangono in REST.
«Scegliendo gRPC, non investiamo solo in un trasporto più veloce – costruiamo un contratto solido che protegge il nostro codice da cambiamenti imprevisti.»
In sintesi, gRPC in Node.js è uno strumento potente che consente di aumentare significativamente le prestazioni dei servizi backend, soprattutto nelle architetture a microservizi. Grazie alla forte tipizzazione, al supporto per lo streaming e all'uso efficiente di HTTP/2, diventa un'alternativa attraente alle tradizionali API REST. Se prevedi di costruire un sistema scalabile, vale la pena considerare gRPC fin dalle fasi di progettazione.
Hai domande o hai bisogno di assistenza per la migrazione a gRPC? Contatta il team di Coderia.it – insieme creeremo soluzioni solide e performanti su misura per le tue esigenze.
