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 basé sur deux technologie qui sont HTTP/2 et protocol Buffers. Cette technologie est utilisé notamment pour la création d'API.

Les technologies du protocole gRPC

RPC

Le RPC[1], Remote Procedure Call est un protocole réseaux qui permet de faire des appels de fonctions à distance, il permet à une machine de demander un service à un programme situé sur une autre machine. Il utilise le modèle client-serveur, le programme qui fait la requête est un client, et le programme fournisseur de services est le serveur.

Protocol buffer

Le protocole buffers est un outil de sérialisation et désérialisation de données developpé par google. Il utilise un encodage binaire ce qui permet d’avoir un bon typage des messages mais aussi une transmission de données rapide. Il génère

HTTP/2

HTTP/2 est la mise à niveau du protocole de transfert hypertexte HTTP/1. C'est un protocole de communication client-serveur, son objectif est d'améliorer les performances des sites Web. HTTP/2 est conçu pour résoudre de nombreux problèmes de performances inhérents à HTTP/1.1. Les principaux avantages sont le mode server push et le multiplexage.

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.

//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

création du serveur

On implemente maintenant un serveur en python.

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()

création du client

On implémente un client en javascript.

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();

Connection entre le serveur et le client

Maintenant que tout est prêt, 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