Créer une API sécurisée avec gRPC

Un appel de procédure distante de Google (gRPC) est la version open source de Google du framework d’appel de procédure distante (RPC). Il s’agit d’un protocole de communication qui s’appuie sur HTTP/2 et les technologies de tampon de protocole (protobuf). gRPC permet à un client ou à un serveur distant de communiquer avec un autre serveur en appelant simplement la fonction de ce dernier comme si elle était locale. Dans les systèmes distribués, la communication et le transfert de grands volumes de données entre client et serveur s’en trouvent simplifiés.

Comme les autres systèmes RPC, gRPC définit un service. Il en spécifie les méthodes et les types de retour à l’aide de protobuf — un protocole de sérialisation et de désérialisation de Google — afin de faciliter la définition des services et la génération automatique des bibliothèques clientes. gRPC utilise ce protocole, actuellement en version 3, comme langage de définition d’interface et ensemble d’outils de sérialisation.

Pour la plupart des applications modernes, gRPC est un excellent choix grâce à sa prise en charge remarquable de tous les types de données. Il convient particulièrement aux volumes de données importants, comme les données diffusées en continu, et peut être excessif pour les applications simples où le transfert de grandes quantités de données est peu préoccupant.

Cet article vous montre comment utiliser gRPC pour faire communiquer un client et un serveur, à la manière d’applications, entre deux applications Node.js. Nous présenterons également quelques mesures de sécurité à prendre lors de l’utilisation de gRPC comme mécanisme de communication dans vos services.

Prérequis du tutoriel

Pour suivre ce tutoriel, vous devez avoir installé OpenSSL et Node.js (version 4.0 ou ultérieure) sur votre ordinateur. Une bonne compréhension de Node.js et de JavaScript est indispensable. Vous devez également vous assurer que votre environnement de travail dispose des privilèges d’administrateur.

Configurer le projet Node.js

Pour commencer, créez un dossier appelé event-app-node-grpc afin de définir la structure des dossiers de l’application, puis initialisez un projet Node.js avec npm en saisissant les commandes suivantes :

1#bash
2$ mkdir event-app-node-grpc
3$ cd event-app-node-grpc
4$ npm init -y

Une fois votre application initialisée, créez la structure de dossiers suivante. Vous pouvez consulter sur GitHub le code complet utilisé dans ce tutoriel :

1Event-app-node-grpc
2client
3app.js
4index.js
5server
6index.js
7scripts
8generate-certs.sh
9events.proto
10README.md

Installer les packages

Dans le terminal, accédez au répertoire racine de votre application. Installez les packages suivants à l’aide de la commande npm install, comme indiqué dans l’extrait de code ci-dessous :

1#bash
2$ npm install express @grpc/grpc-js @grpc/proto-loader

Voyons à quoi servent les packages que vous venez d’installer dans l’extrait de code ci-dessus :

• Express est le serveur HTTP de votre application.

• @grpc/grpc-js est une bibliothèque gRPC pour Node.js. Elle nous permet de créer un service gRPC dans l’environnement d’exécution Node.js.

• @grpc/proto-loader est un package nécessaire au chargement des fichiers protobuf utilisés avec gRPC. Il utilise le package version 3 de protobuf.js.

Après avoir installé les packages ci-dessus, ouvrez le fichier package.json et ajoutez les configurations supplémentaires suivantes aux balises scripts, comme indiqué dans l’extrait de code ci-dessous :

1#package.json
2
3"scripts": {
4   "start": "node server/index.js",
5   "generate:certs": "./scripts/generate-certs.sh"
6 },

Les configurations supplémentaires de l’extrait de code ci-dessus concernent la configuration de l’environnement d’exécution de l’application et la génération du certificat SSL. Une fois ces configurations ajoutées, votre fichier package.json mis à jour devrait ressembler à l’extrait de code ci-dessous :

1#package.json(updated)
2
3{
4 "name": "event-app-node-grpc",
5 "version": "1.0.0",
6 "description": "A CRUD application to demonstrate the use of gRPC with NodeJS",
7 "main": "server/index.js",
8 "scripts": {
9   "start": "node server/index.js",
10   "generate:certs": "./scripts/generate-certs.sh"
11 },
12 "author": "(author name here)",
13 "license": "ISC",
14 "dependencies": {
15   "@grpc/proto-loader": "^0.6.12",
16   "express": "^4.18.1",
17   "@grpc/grpc-js": "^1.6.12
18 }
19}

L’extrait de code ci-dessus présente le fichier package.json mis à jour après l’ajout, dans la balise scripts, des commandes de configuration de l’environnement d’exécution de l’application et de génération du certificat SSL.

Définir le tampon de protocole

Ce tutoriel explique comment utiliser gRPC dans une application simple de suivi d’événements. Cette application de démonstration récupère les détails d’un événement et les enregistre dans une base de données en mémoire, tout en permettant de mettre à jour, récupérer et supprimer les données de l’événement.

Dans les applications gRPC, l’interface de service et les charges utiles requises sont définies dans un fichier protobuf afin de permettre la communication entre différentes applications. Les fichiers protobuf ont l’extension .proto, comme illustré dans le schéma de configuration de notre projet.

Dans le répertoire racine de votre application, créez maintenant un fichier events.proto et ajoutez-y le code suivant. Vous pouvez vous reporter au schéma de structure du projet défini précédemment.

1#events.proto
2
3syntax = "proto3";
4
5service EventService {
6   rpc GetAllEvents (Empty) returns (EventList) {}
7   rpc GetEvent (EventId) returns (Event) {}
8   rpc CreateEvent (Event) returns (Event) {}
9   rpc UpdateEvent (Event) returns (Event) {}
10   rpc DeleteEvent (EventId) returns (Empty) {}
11}
12
13message Empty {}
14
15message Event {
16   string id = 1;
17   string name = 2;
18   string description = 3;
19   string location = 4;
20   string duration = 5;
21   int32 lucky_number = 6;
22   string status = 7;
23}
24
25message EventList {
26   repeated Event events = 1;
27}
28
29message EventId {
30   string id = 1;
31}

Dans les extraits de code de définition proto ci-dessus, nous avons d’abord spécifié la version du tampon de protocole à l’aide de la définition syntax = "proto3", puis défini le service de protocole.

Ensuite, dans la description du service d’événements du protocole, nous avons créé un service appelé EventService. Nous avons ensuite créé des fonctions rpc au sein de ce service, avec leurs paramètres requis et leurs valeurs de retour attendues. Vous pouvez définir autant de services que nécessaire pour votre application, mais, pour simplifier, nous n’en définissons qu’un seul.

Nous avons également défini les types de données de la fonction rpc dans la définition EventService, ainsi que les valeurs de retour à l’aide du système de numérotation des champs propre à gRPC. Celui-ci indique le nombre d’octets utilisés lors de l’encodage. Pour en savoir plus, consultez la documentation officielle de protobuf.

Créer le serveur gRPC

En suivant la structure de dossiers ci-dessus, créez un dossier server dans le répertoire racine de votre application, puis créez un fichier index.js dans ce dossier. Collez l’extrait de code suivant dans le fichier server/index.js que vous venez de créer :

1#server/index.js
2
3const PROTO_PATH = "./events.proto";
4
5let grpc = require("@grpc/grpc-js");
6let protoLoader = require("@grpc/proto-loader");
7
8let packageDefinition = protoLoader.loadSync(PROTO_PATH, {
9   keepCase: true,
10   longs: String,
11   enums: String,
12   arrays: true
13});
14
15let eventsProto = grpc.loadPackageDefinition(packageDefinition);

Dans l’extrait de code ci-dessus, nous avons importé le fichier events.proto défini précédemment dans la variable PROTO_PATH, puis l’avons chargé à l’aide de la méthode loadSync de la bibliothèque protoLoader. Nous avons ensuite enregistré les définitions proto dans la variable eventsProto, qui les contient toutes.

Ajoutez ensuite l’extrait de code suivant juste après la variable eventsProto dans le fichier server/index.js défini précédemment.

1const { randomUUID } = require("node:crypto");
2
3const events = [
4   {
5       id: "34415c7c-f82d-4e44-88ca-ae2a1aaa92b7",
6       name: "Birthday Party",
7       description: "27th Birthday in Paris",
8       location: "Paris France",
9       duration: "All Day",
10       lucky_number: 27,
11       status: "Pending"
12   },
13];
14
15const server = new grpc.Server();

Dans l’extrait de code ci-dessus, nous avons importé le package node:crypto et sa fonction randomUUID, qui sert à générer des chaînes aléatoires uniques pour les identifiants de nos événements. Comme nous utilisons une base de données en mémoire pour ce tutoriel, nous la définirons sous forme de tableau pour stocker notre liste d’événements. Nous initialiserons ensuite notre instance de serveur en appelant une nouvelle méthode grpc.Server.

Nous allons ensuite enregistrer les services de l’application. Pour ce faire, ajoutez l’extrait de code suivant juste après la variable server dans l’extrait ci-dessus :

1server.addService(eventsProto.EventService.service, {
2
3   getAllEvents: (_, callback) => {
4       callback(null, { events });
5   },
6
7   getEvent: (call, callback) => {
8       let event = events.find(n => n.id == call.request.id);
9
10       if (event) {
11           callback(null, event);
12       } else {
13           callback({
14               code: grpc.status.NOT_FOUND,
15               details: "Event Not found"
16           });
17       }
18   },
19
20   createEvent: (call, callback) => {
21       let event = call.request;
22
23       event.id = randomUUID();
24       events.push(event);
25       callback(null, event);
26   },
27
28   updateEvent: (call, callback) => {
29       let existingEvent = events.find(n => n.id == call.request.id);
30
31       if (existingEvent) {
32           existingEvent.name = call.request.name;
33           existingEvent.description = call.request.description;
34           existingEvent.location = call.request.location;
35           existingEvent.duration = call.request.duration;
36           existingEvent.lucky_number = call.request.lucky_number;
37           existingEvent.status = call.request.status;
38           callback(null, existingEvent);
39       } else {
40           callback({
41               code: grpc.status.NOT_FOUND,
42               details: "Event Not found"
43           });
44       }
45   },
46
47   deleteEvent: (call, callback) => {
48       let existingEventIndex = events.findIndex(
49           n => n.id == call.request.id
50       );
51
52       if (existingEventIndex != -1) {
53           events.splice(existingEventIndex, 1);
54           callback(null, {});
55       } else {
56           callback({
57               code: grpc.status.NOT_FOUND,
58               details: "Event Not found"
59           });
60       }
61   }
62});

Dans l’extrait de code ci-dessus, nous avons appelé la méthode addService sur l’instance du serveur gRPC pour enregistrer les services de l’application, qui effectuent essentiellement des opérations de création, de lecture et de mise à jour des événements.

Pour permettre au serveur de l’application de démarrer, collez l’extrait de code suivant juste après la méthode addService de l’extrait ci-dessus.

1server.bindAsync("127.0.0.1:50051", grpc.ServerCredentials.createInsecure(), (error, port) => {
2console.log(`Server listening at http://127.0.0.1:${port}`);
3server.start();
4});

Créer le client gRPC

En suivant la structure de dossiers ci-dessus, créez un dossier client dans le répertoire racine de votre application, puis créez-y deux fichiers : index.js et app.js. Collez l’extrait de code suivant dans le fichier client/app.js.

1#client/app.js
2
3const PROTO_PATH = "../events.proto";
4const grpc = require("@grpc/grpc-js");
5const protoLoader = require("@grpc/proto-loader");
6
7let packageDefinition = protoLoader.loadSync(PROTO_PATH, {
8   keepCase: true,
9   longs: String,
10   enums: String,
11   arrays: true
12});
13
14const EventService = grpc.loadPackageDefinition(packageDefinition).EventService;
15const client = new EventService("127.0.0.1:50051", grpc.credentials.createInsecure());
16module.exports = client;

Dans l’extrait de code ci-dessus, nous avons importé les définitions proto créées précédemment, les avons chargées avec protoLoader, connecté le client grpc à l’adresse IP de l’application serveur, puis exporté le service d’événements sous le nom de variable client. Nous avons également associé un certificat SSL au client afin d’authentifier et de chiffrer les communications entre le client et le serveur.

Collez ensuite l’extrait de code suivant dans le fichier client/index.js :

1#client/index.js
2
3const client = require("./app");
4
5const express = require("express");
6const app = express();
7app.disable('x-powered-by');
8app.use(express.json());
9app.use(express.urlencoded());
10
11app.get("/", (req, res) => {
12   client.getAllEvents(null, (err, data) => {
13       if (!err) {
14           res.status(200).send({
15               data
16           });
17       }
18   });
19});
20
21app.post("/createEvent", (req, res) => {
22
23   let newEvent = {
24       name: req.body.name,
25       description: req.body.age,
26       location: req.body.address,
27       duration: req.body.address,
28       lucky_number: req.body.address,
29       status: req.body.status
30   };
31
32   client.insert(newEvent, (err, data) => {
33       if (err) throw err;
34       res.status(200).send({
35           data,
36           message: 'Event created successfully'
37       });
38   });
39});
40
41app.post("/updateEvent", (req, res) => {
42   let updateEvent = {
43       name: req.body.name,
44       description: req.body.age,
45       location: req.body.address,
46       duration: req.body.address,
47       lucky_number: req.body.address,
48       status: req.body.status
49   };
50
51   client.update(updateEvent, (err, data) => {
52       if (err) throw err;
53
54       res.status(200).send({
55           data,
56           message: 'Event updated successfully'
57       });
58   });
59});
60
61app.delete("/deleteEvent", (req, res) => {
62   client.remove({ id: req.body.eventId }, (err, _) => {
63       if (err) throw err;
64
65       res.status(200).send({
66           message: 'Event deleted successfully'
67       });
68   });
69});
70
71const PORT = process.env.PORT || 50050;
72app.listen(PORT, () => {
73   console.log("Client Server listening to port %d", PORT);
74});

Dans l’extrait de code ci-dessus, nous avons importé event-service depuis le fichier client/app.js. Nous avons ensuite configuré un serveur Express avec des points de terminaison simples pour gérer la creation, la update, la fetch et la delete des événements, en appelant à distance l’application serveur à l’aide de gRPC.

Tester les applications serveur et client

Nous pouvons maintenant tester notre travail pour vérifier que tout fonctionne comme prévu.

Le serveur

Dans le terminal, accédez au répertoire racine du projet, puis exécutez les commandes suivantes :

1$bash
2$ npm run start

L’application serveur devrait être accessible à l’adresse http://localhost:50051 :

1% npm run start
2> event-app-node-grpc@1.0.0 start
3> node server/index.js
4
5Server listening at https://127.0.0.1:50051

Le client

Ouvrez une nouvelle fenêtre de terminal, accédez au dossier client depuis le répertoire racine de votre application, puis exécutez les commandes suivantes :

1$bash
2$ node index

L’application devrait être accessible à l’adresse http://localhost:50050 :

1$ event-app-node-grpc  cd client
2$ event-app-node-grpc/client node index.js
3
4Client Server listening to port 50050

Pour tester, accédez à localhost:50050 dans votre navigateur ou utilisez un outil de test d’API comme Postman. Vous devriez voir l’événement par défaut que nous avons ajouté initialement à notre tableau d’événements. La réponse devrait être identique à la capture d’écran ci-dessous :

Authentifier et sécuriser l’API gRPC

Le protocole gRPC prend en charge différents mécanismes d’authentification, ce qui facilite son adaptation aux systèmes nouveaux ou existants. Pour mettre en œuvre l’authentification dans les communications client-serveur gRPC, nous pouvons utiliser des mécanismes recommandés comme SSL et TLS, avec ou sans authentification par jeton Google. Nous pouvons également créer une authentification personnalisée en étendant simplement la fonction d’authentification intégrée à gRPC.

Par défaut, gRPC intègre les mécanismes d’authentification suivants :

• SSL et TLS pour authentifier le serveur et chiffrer les données échangées entre le client et le serveur

• ALTS (un protocole de transport et d’authentification mutuelle conçu par Google) pour sécuriser les communications RPC des applications exécutées sur Google Cloud Platform (GCP)

• Un mécanisme générique d’authentification par jeton qui associe des identifiants basés sur des métadonnées aux requêtes et aux réponses

Comme indiqué dans l’introduction du tutoriel, nous allons mettre en œuvre l’authentification avec SSL, puis modifier nos fichiers client/app.js et server/index.js pour prendre en charge cette nouvelle configuration.

Générer un certificat SSL avec OpenSSL

Commençons par générer un certificat SSL avec OpenSSL. Vous devez avoir OpenSSL installé et disposer des autorisations nécessaires pour exécuter des scripts bash. Ces conditions sont indispensables pour éviter les erreurs d’autorisation.

Dans la structure de dossiers de notre projet, créez un dossier scripts, puis un fichier appelé generate-certs.sh à l’intérieur. Collez-y l’extrait de code suivant :

1#scripts/generate-certs.sh
2
3echo "Creating certs folder ..."
4mkdir certs && cd certs
5
6echo "Generating certificates ..."
7
8openssl genrsa -passout pass:1111 -des3 -out ca.key 4096
9
10openssl req -passin pass:1111 -new -x509 -days 365 -key ca.key -out ca.crt -subj  "/C=CL/ST=RM/L=Santiago/O=Test/OU=Test/CN=localhost"
11
12openssl genrsa -passout pass:1111 -des3 -out server.key 4096
13
14openssl req -passin pass:1111 -new -key server.key -out server.csr -subj  "/C=CL/ST=RM/L=Santiago/O=Test/OU=Server/CN=localhost"
15
16openssl x509 -req -passin pass:1111 -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt
17
18openssl rsa -passin pass:1111 -in server.key -out server.key
19
20openssl genrsa -passout pass:1111 -des3 -out client.key 4096
21
22openssl req -passin pass:1111 -new -key client.key -out client.csr -subj  "/C=CL/ST=RM/L=Santiago/O=Test/OU=Client/CN=localhost"
23
24openssl x509 -passin pass:1111 -req -days 365 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out client.crt
25
26openssl rsa -passin pass:1111 -in client.key -out client.key

Le code ci-dessus génère les certificats SSL nécessaires pour établir une connexion sécurisée et chiffrée entre les applications serveur et client. Lors de son exécution, il crée un dossier certs, génère avec OpenSSL les certificats SSL du serveur et du client, puis les enregistre dans le dossier certs. Pour en savoir plus sur ces configurations et leur rôle, consultez le site Web d’OpenSSL.

Générer un certificat SSL pour l’application avec npm

Utilisez maintenant le script pour générer un certificat SSL pour votre application. Dans le terminal, exécutez les commandes suivantes depuis le répertoire racine de l’application.

1$bash
2$ npm run generate:certs

Cette opération crée un dossier certs contenant les certificats SSL générés.

Notez que des privilèges d’administrateur sont nécessaires. Si vous obtenez une erreur d’autorisation en exécutant le script, utilisez les commandes suivantes pour lui accorder le privilège d’exécution, puis réessayez.

1$bash
2$ cd scripts
3$ chmod u+r+x generate-certs.sh
4$ ./generate-certs.sh

Le résultat suivant devrait s’afficher dans votre terminal :

1> event-app-node-grpc@1.0.0 generate:certs
2> ./scripts/generate-certs.sh
3
4Creating certs folder…
5Generating certificates…
6Generating RSA private key, 4096 bit long modulus
7………………………………………………..++
8……………..++
9
10e is 65537 (0x10001)
11Generating RSA private key, 4096 bit long modulus
12…………………++
13………………………………………….….….….….….………..…………..++
14e is 65537 (0x10001)
15Signature ok
16subject=/C=CL/ST=RM/L=Santiago/0=Test/OU=Server/CN=localhost
17Getting CA Private Key
18writing RSA key
19Generating RSA private key, 4096 bit long modulus
20………………………………………………..….….….…………..++
21.…………..++
22e is 65537 (0x10001)
23Signature ok
24subject=/C=CL/ST=RM/L=Santiago/0=Test/OU=Client/ON=localhost
25Getting CA Private Key
26writing RSA key

Mettre à jour les fichiers client/app.js et server/index.js

Nous avons généré les certificats SSL nécessaires à l’authentification de nos API gRPC. Nous allons maintenant modifier les fichiers client/index.js et server/index.js pour utiliser ces certificats.

Dans le fichier client/app.js mis à jour ci-dessous, nous avons ajouté le module fs pour lire les certificats générés. Nous avons ensuite utilisé ces certificats pour créer des identifiants SSL gRPC, puis les avons appliqués au service gRPC.

1#client/app.js(updated)
2
3const PROTO_PATH = "../events.proto";
4const fs = require('fs');
5const grpc = require("@grpc/grpc-js");
6const protoLoader = require("@grpc/proto-loader");
7
8let packageDefinition = protoLoader.loadSync(PROTO_PATH, {
9   keepCase: true,
10   longs: String,
11   enums: String,
12   arrays: true
13});
14
15const credentials = grpc.credentials.createSsl(
16   fs.readFileSync('../certs/ca.crt'),
17   fs.readFileSync('../certs/client.key'),
18   fs.readFileSync('../certs/client.crt')
19);
20
21const EventService = grpc.loadPackageDefinition(packageDefinition).EventService;
22const client = new EventService("localhost:50051",credentials);
23module.exports = client;

Dans le fichier server/index.js mis à jour ci-dessous, nous avons également ajouté le module fs pour lire les certificats générés. Nous les avons ensuite utilisés pour créer des identifiants SSL gRPC et les avons appliqués au serveur.

1#server/index.js(updated)
2
3const PROTO_PATH = "./events.proto";
4const fs = require('fs');
5
6let grpc = require("@grpc/grpc-js");
7let protoLoader = require("@grpc/proto-loader");
8
9let packageDefinition = protoLoader.loadSync(PROTO_PATH, {
10   keepCase: true,
11   longs: String,
12   enums: String,
13   arrays: true
14});
15
16let eventsProto = grpc.loadPackageDefinition(packageDefinition);
17
18const server = new grpc.Server();
19
20let credentials = grpc.ServerCredentials.createSsl(
21   fs.readFileSync('./certs/ca.crt'), [{
22   cert_chain: fs.readFileSync('./certs/server.crt'),
23   private_key: fs.readFileSync('./certs/server.key')
24}], true);
25
26----------
27
28----------
29
30server.bindAsync("0.0.0.0:50051", credentials, (error, port) => {
31console.log(`Server listening at http://0.0.0.0:${port}`);
32server.start();
33});

Exécuter les applications serveur et client

Nous avons mis en place avec succès une solution de gestion des événements conforme aux spécifications gRPC. Pour tester les points de terminaison, démarrez l’application depuis le terminal en suivant les étapes ci-dessous.

Le serveur

Dans le terminal, accédez au répertoire racine du projet et exécutez les commandes suivantes :

1$bash
2$ npm run start

Une fois ces commandes exécutées, l’application serveur devrait être accessible à l’adresse http://0.0.0.0:50051 :

1event-app-node-grpc % npm run start
2
3> event-app-node-grpc@1.0.0 start
4> node server/index.js
5
6Server listening at http://0.0.0.0:50051

Le client

Ouvrez une nouvelle fenêtre de terminal, accédez au dossier client depuis le répertoire racine de votre application, puis exécutez les commandes suivantes :

1$bash
2$ node index

Une fois ces commandes exécutées, l’application cliente devrait être accessible à l’adresse http://localhost:50050 :

1> event-app-node-grpc % cd client
2> client % node index
3Client Server listening to port 50050

Pour tester l’application, accédez à localhost:50050 dans votre navigateur ou utilisez un outil de test d’API comme Postman. Vous devriez voir l’événement par défaut que nous avons ajouté initialement à notre tableau d’événements. Le résultat devrait être identique à la capture d’écran ci-dessous :

Vous pouvez ensuite tester les autres points de terminaison ajoutés à l’application pour vérifier que tout fonctionne comme prévu.

Vous avez créé une API sécurisée avec gRPC !

Dans ce tutoriel, nous avons créé une API simple avec gRPC et Node.js, en présentant son fonctionnement et ses nombreux avantages, comme HTTP/2 et SSL/TLS, qui assurent l’authentification et le chiffrement de bout en bout afin de renforcer la sécurité des API.

Malgré ces avantages, gRPC présente aussi des inconvénients : prise en charge limitée par les navigateurs, format de données non lisible par l’humain, courbe d’apprentissage abrupte et prise en charge limitée de la mise en cache en périphérie. Malgré ces limites, gRPC reste le meilleur choix pour la communication entre microservices internes, grâce à ses performances inégalées et à sa prise en charge de plusieurs langages de programmation. Le protocole gRPC est impressionnant et s’est largement imposé dans le secteur depuis sa première publication en août 2016. Son adoption devrait continuer à progresser.

gRPC offre de nombreuses autres possibilités. L’exemple de ce tutoriel ne représente qu’une infime partie de ce qu’il permet de faire. Consultez la documentation pour approfondir vos connaissances de gRPC et améliorer les processus de communication de votre application ainsi que vos stratégies de sécurisation de gRPC.

Autres ressources sur les API :

• Créer une API GraphQL sécurisée avec Node.js

• Conteneuriser des applications Go avec Docker