Etude du protocole gRPC

Etudiant : Alexandre Desbos

Tuteur : David Télisson

Introduction

gRPC est une technologie open source développée par google en 2015. Il s’agit d’un framework RPC Remote Procedure Call qui permet de faire des appels de fonctions à distance. Il est basé sur deux technologies qui sont HTTP/2 et protocol Buffers. Cette technologie est utilisé notamment pour la création d'API

Les technologies du protocole gRPC

gRPC repose principalement sur deux technologies qui le rende efficace, le protocol Buffers et HTTP/2.

Protocol buffers

Le protocol buffers est un format d’échange de données developpé par google. Il utilise un encodage binaire et permet de sérialiser et déserialiser des données. La définition des données à sérialiser est écrite dans des fichiers de configuration appelés fichiers proto (.proto). Ces fichiers contiennent les configurations appelées messages. Les fichiers proto peuvent alors être compilés pour générer le code dans le langage de programmation de l'utilisateur. Les languages supportés officiellement sont:

-C#
-C++
-Go
-Objective-C
-Java
-Python
-Ruby

HTTP/2

HTTP/2 est la mise à niveau du protocole de transfert hypertexte HTTP/1. C'est un protocole de communication client-serveur, ces principaux objectifs sont de réduire la latence en permettant le multiplexage complet des demandes et des réponses, de minimiser la surcharge du protocole par une compression efficace des champs d'en-tête HTTP et d'ajouter la prise en charge de la hiérarchisation des demandes et du server push. Pour répondre à ces exigences, il existe un grand nombre d'autres améliorations du protocole, telles que de nouveaux mécanismes de contrôle de flux, de traitement des erreurs et de mise à niveau.

Comparaison de gRPC et REST

Dans la programmation web, les API REST sont aujourd'hui utilisées par la majorité des developpeurs. Malgré cela, depuis quelques temps, le gRPC devient une alternative très interresante à REST et pourrait potentiellement le remplacer. On voit sur le tableaux ci-dessous les différences principales entre ces deux technologies.

Application

Dans cette partie, nous allons implémenter un PoC qui montre le fonctionnement du protocole gPRC entre un serveur et un client développées dans des langages différents. Le code est accesible sur github

Installation

Il faut commencer par installer la dernière version stable de python et de nodejs.
Les commandes suivantes permette d'installer les outils de nécessaire pour faire du gRPC.

$pip install grpcio
$pip install grpc-tools
$npm install -g request
$npm config set unsafe-perm true
$npm install protoc-gen-grpc -g
$npm install grpc
$npm install google-protobuf

écrire le fichier proto

La mise en œuvre de gRPC commence toujours par la rédaction d’un fichier proto dans lequel on définit les services que l'on veut. Dans notre application, on crée un service inscription USMB et ont défini ensuite le type de la requète et le type de la réponse.

//USMB.proto

//version de la syntaxe
syntax = "proto3";    
 
//On définit un service
service Inscription {
  rpc InscriptionUSMB(InscriptionRequest) returns (InscriptionResponse);  
}
 
//On définit les types de message
 
//La requète attend un entier et une chaine de caractère
message InscriptionRequest {
  int32 annee = 1;   
  string nom = 2; 
}
 
//La reponse sera une chaine de caractère
message InscriptionResponse {
  string message = 1;
}

géneration du code

Pour génerer le code avec le compilateur protoc, rentrer les commande suivante dans un terminal de commande:

$python -m grpc_tools.protoc --proto_path=. --python_out=. --grpc_python_out=. USMB.proto
$protoc --js_out=import_style=commonjs,binary:. USMB.proto
$protoc-gen-grpc --grpc_out=. --proto_path=. USMB.proto

Deux fichiers javascript et deux fichiers python ont été crée dans le dossier, ces fichiers ne doivent pas être édité !

création du serveur

On implemente maintenant un serveur en python.

#server.py

import grpc
import concurrent
from concurrent import futures

#On importe les fichiers généré par le compilateur protoc
import USMB_pb2
import USMB_pb2_grpc


#On définit la fonction réponse du serveur
class InscriptionServicer(USMB_pb2_grpc.InscriptionServicer):
  def InscriptionUSMB(self, request, context):
    print('requête reçu')
    response = USMB_pb2.InscriptionResponse()
    response.message = f"Bonjour {request.nom}, vous êtes inscrit en {request.annee}ème année à l'univesité de Savoie"
    return response


#On définit un serveur sur le port 50051
def main():
  server = grpc.server(futures.ThreadPoolExecutor(max_workers=5))
  USMB_pb2_grpc.add_InscriptionServicer_to_server(InscriptionServicer(), server)
  print('Serveur lancé. En écoute sur le port 50051')
  server.add_insecure_port('[::]:50051')
  server.start()
  server.wait_for_termination()

main()

On récupère les fichiers géneré par protoc, on définit la fonction réponse du serveur dans une class crée dans les fichiers grpc. On définit un serveur en local.

création du client

On implémente un client en javascript.

//client.js

const grpc = require('grpc');
//On imoporte les fichiers javascript géneré par le compilateur 
const messages = require('./USMB_pb');
const services = require('./USMB_grpc_pb');

//On se connecte au serveur 
function main() {
  const client = new services.InscriptionClient(
    'localhost:50051', grpc.credentials.createInsecure()
  );

  //On rentre nos valeurs d'entrées
  const InscriptionRequest = new messages.InscriptionRequest();
  InscriptionRequest.setAnnee(3);
  InscriptionRequest.setNom('Alexandre Desbos');

  //On regarde si il y a une erreur
  client.inscriptionUSMB(InscriptionRequest, function (err, response) {
    if (err) {
      console.log('Il y a une erreur', err);
    } else {
      console.log('réponse de python:', response.getMessage());
    }
  })
}

main();

On récupère les fichiers géneré par protoc, on se connecte au serveur et on définit la valeur des messages.

Résultat

Maintenant que tout est prêt, on peur réaliser la connection entre le serveur et le client. Dans un terminal de commande, on execute le fichier python:

$python serveur.py

Puis dans un autre terminal, on execute le fichier javascript pour envoyé une requète au serveur:

$node client.js

Le client reçoit une réponse du serveur !

Liens utiles

https://grpc.io/
https://developers.google.com/protocol-buffers
https://developers.google.com/web/fundamentals/performance/http2
https://github.com/uw-labs/bloomrpc