gRPC e Protocol Buffers: una introduzione.

Spread the love

gRPC è una tecnologia nata in Google che astrae il concetto di classe immergendolo in quello di cloud: supponiamo che il nostro progetto locale sfrutti una classe Figura che realizza una figura piana della geometria.

Chi l’ha detto che la classe debba trovarsi sullo stesso PC in cui stiamo sviluppando il nostro progetto?

Protocol Buffers è una tecnologia open source di Google che implementa questa architettura: istanziare nel nostro ambiente local un oggetto (stub) definito altrove:

gRPC architecture
gRPC architecture

gRPC è stato inizialmente creato da Google, che da oltre un decennio utilizza un’unica infrastruttura RPC generica chiamata Stubby per connettere il gran numero di microservizi in esecuzione all’interno e attraverso i suoi data center. Nel marzo 2015, Google ha deciso di creare una nuova versione di Stubby rendendola open source.

In gRPC, un’applicazione client può chiamare direttamente un metodo su un’applicazione server su un computer diverso come se fosse un oggetto locale, semplificando la creazione di applicazioni e servizi distribuiti. Come in molti sistemi RPC, gRPC si basa sull’idea di definire un servizio, specificando i metodi che possono essere chiamati da remoto con i relativi parametri e tipi di ritorno. Sul lato server, il server implementa questa interfaccia ed esegue un server gRPC per gestire le chiamate client. Dal lato client, il client ha uno stub (indicato semplicemente come client in alcuni linguaggi) che fornisce gli stessi metodi del server.

I client e i server gRPC possono essere eseguiti e comunicare tra loro in una varietà di ambienti, dai server interni a Google al desktop, e possono essere scritti in qualsiasi linguaggio supportato da gRPC. Quindi, ad esempio, puoi creare facilmente un server gRPC in Java con client in Go, Python o Ruby. Inoltre, le ultime API di Google disporranno di versioni gRPC delle rispettive interfacce, consentendoti di integrare facilmente le funzionalità Google nelle tue applicazioni.

Lavorare con i protocol buffer (PB) di gRPC

Si parte dalla definizione del messaggio che può essere un file JSON o più convenientemente un file di tipo proto (per protocol), per esempio questo potrebbe essere il contenuto del file message.proto:

message Person {
  string name = 1;
  int32 id = 2;
  bool has_ponycopter = 3;
}

Nota che 1, 2 e 3 sono i segnaposto, non sono assegnazioni.

Quindi, una volta specificate le strutture dati, si utilizza il compilatore del protocol buffer protocper generare classi di accesso ai dati nel linguaggio di programmazione scelto nella definizione del prototipo. Queste classi forniscono semplici metodi di accesso (get/set) per ciascun campo, come name()set_name(), nonché metodi per serializzare/analizzare l’intera struttura da/verso byte grezzi. Quindi, ad esempio, se il linguaggio scelto è C++, l’esecuzione del compilatore nell’esempio sopra genererà una classe chiamata Person. Puoi quindi utilizzare questa classe nella tua applicazione per popolare, serializzare e recuperare Personi messaggi del protocol buffer.

Oltre ai dati, nei file proto vengono definiti anche i servizi:

// The greeter service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

Il comando protoc (compilatore) poi esegue la magia, convertendo i file .proto in classi nel linguaggio scelto per il progetto.

La versione 3 di PB (proto3) è disponibile nei seguenti linguaggi di programmazione:  Java, C++, Dart, Python, Objective-C, C#, un runtime lite (Android Java), Ruby e JavaScript. Anche PHP con l’adozione di un plugin.

Riferimenti

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.