Cos’è una RPC?

RPC, acronimo di Remote Procedure Call o Chiamata di Procedura Remota, è un protocollo che permette a un software di richiedere un servizio esposto da un altro software. Questi due software possono risiedere sulla stessa macchina o su macchine diverse, anche su reti differenti.

In sostanza, una chiamata RPC consiste nell’effettuare una chiamata a una funzione o procedura ospitata su un server, un dispositivo distinto o all’interno di un container. Quando si realizza una chiamata RPC, il sistema sottostante gestisce l’intero processo di comunicazione tra i due dispositivi, rendendo la procedura remota pressoché indistinguibile da una procedura locale dal punto di vista dello sviluppatore.

RPC è fondamentale in molte situazioni, ad esempio:

• Sistemi distribuiti di memorizzazione dei dati
• Servizi web
• Progetti di computazione distribuita
• Sistemi operativi
• Microservizi

Il valore di RPC

L’adozione di RPC offre numerosi benefici, rendendola una scelta vantaggiosa in diversi contesti. Innanzitutto, offre l’astrazione dalla complessità della rete: RPC maschera i dettagli del sistema di rete, consentendo agli sviluppatori di focalizzarsi sulla logica applicativa. Inoltre, RPC promuove un approccio modulare allo sviluppo del software, in cui ogni servizio può essere sviluppato, testato e distribuito autonomamente. Infine, grazie alla sua natura, RPC facilita l’interoperabilità tra diverse tecnologie e linguaggi di programmazione, semplificando l’integrazione tra vari sistemi o componenti.

JSON RPC: Un’innovazione nelle RPC

JSON RPC porta il concetto di RPC a un nuovo livello, introducendo flessibilità e interattività. Questo protocollo di trasmissione dati impiega il formato JSON (JavaScript Object Notation) per codificare i messaggi RPC, il che lo rende leggero, di facile lettura e scrittura, nonché indipendente dal linguaggio di programmazione utilizzato.

Il protocollo segue regole precise: ogni chiamata RPC viene codificata come un oggetto JSON che deve includere le seguenti proprietà:

• method: indica il nome del metodo da invocare
• params: si tratta di un array o di un oggetto che rappresenta i parametri del metodo
• id: rappresenta un identificatore univoco per la chiamata
• jsonrpc: specifica la versione del protocollo JSON RPC

La risposta, anch’essa codificata in JSON, riporta il risultato del metodo invocato o i dettagli dell’errore in caso di fallimento. Essa include le seguenti proprietà:

• jsonrpc: specifica la versione del protocollo JSON RPC
• id: rappresenta un identificatore univoco per la chiamata
• result: contiene il risultato della chiamata, che può essere un oggetto. Se un errore si è verificato, questa proprietà non sarà presente
• error: restituito in caso di errore, se popolato ha la seguente struttura:
  • code: un numero che indica il tipo di errore. Puoi consultare la lista dei possibili codici di errore e il loro significato al seguente link
  • message: un breve messaggio che descrive l’errore
  • data: un oggetto che fornisce ulteriori dettagli sull’errore, può essere omesso

Per approfondimenti e ulteriori dettagli sul protocollo, vi invito a consultare la documentazione ufficiale di JSON RPC.

Analisi dettagliata di JSON RPC

Il protocollo JSON RPC. si differenzia da altre soluzioni RPC per la sua flessibilità e interoperabilità. Non si tratta di un protocollo legato a un particolare linguaggio di programmazione o a un protocollo di trasporto specifico. Infatti, può essere utilizzato con qualsiasi linguaggio e può essere trasportato su qualsiasi protocollo di trasporto, offrendo una flessibilità senza precedenti. L’efficienza del protocollo è ulteriormente migliorata dalla possibilità di effettuare chiamate batch o chiamate di notifica, ottimizzando così l’uso delle risorse.

JRPC: Facilitare l’uso del JSON RPC

JRPC è un progetto che sto portando avanti con l’intento di rendere più diretta e intuitiva l’implementazione del protocollo JSON RPC. Questo progetto prevede due componenti chiave: una libreria server e una libreria client, create per semplificare l’integrazione del protocollo JSON RPC nelle applicazioni software. La libreria server gestisce con efficienza le richieste RPC, mentre la libreria client agevola l’elaborazione e la gestione delle chiamate RPC. Allo scopo di accelerare l’implementazione lato client, sto anche sviluppando una CLI.

Ecco un esempio chiaro e conciso di come funziona:

Per il server, basato su Fastify:

...
const jrpcServer = new Server({
    name: 'jrpc-server',
    version: '1.0.0',
    description: 'demo server',
});

jrpcServer.addMethod({
    "name": "hello",
    "description": "A simple hello world method",
    "params": [
        {
            "name": "name",
            "description": "The name of the person to say hello to",
            "schema": {
                "type": [
                    "string",
                    "null"
                ]
            }
        }
    ],
    "result": {
        "name": "result",
        "description": "The result of the hello world method",
        "schema": {
            "type": "string"
        }
    }
}, (name?: string): string => {
    if (!name) {
        return 'Hello World!';
    }
    return `Hello ${name}!`;
});

server.post('/jrpc', async (request, reply) => {
    const {body} = request;
    const result = await jrpcServer.executeRequest(JSON.stringify(body));
    reply.send(result);
})
...

Per il client:

...
export interface DemoRpcMethods {
    hello(name?: string): Promise<string>;
}

(async () => {
    ...
    const client = new JRPCClient<DemoRpcMethods>("http://127.0.0.1:3000/jrpc", resolver);
    const proxy = client.createProxy();
    console.log(await proxy.hello());
    console.log(await proxy.hello('Demo'));
})();

Come si può notare dal codice del client, è sufficiente definire un’interfaccia che descriva i metodi RPC e la libreria si occuperà del resto, eliminando la necessità di definire il payload della richiesta.

L’uso della CLI consente di generare automaticamente l’interfaccia a partire dallo schema prodotto dal server, semplificando ulteriormente il processo.

Per maggiori dettagli, visita il mio GitHub per vedere il codice demo completo.

Conclusione

Per concludere, JRPC è il mio contributo alla comunità di sviluppatori che lavora con JSON RPC. Credo fermamente che la collaborazione sia la chiave per lo sviluppo di software di qualità e per questo invito tutti a contribuire al progetto. Che tu abbia un’idea per una nuova funzionalità, una segnalazione di bug o un fix, ogni contributo è prezioso e fa la differenza.