Eine sichere API mit gRPC erstellen

Ein Google Remote Procedure Call (gRPC) ist Googles Open-Source-Version des Remote-Procedure-Call-Frameworks (RPC). Es handelt sich um ein Kommunikationsprotokoll, das HTTP/2 und Protocol-Buffer-Technologien (protobuf) nutzt. Mit gRPC kann ein Remote-Client oder -Server mit einem anderen Server kommunizieren, indem er einfach die Funktion des empfangenden Servers aufruft, als wäre sie lokal verfügbar. Dadurch lassen sich in verteilten Systemen große Datenmengen viel einfacher zwischen Client und Server übertragen.

Wie andere RPC-Systeme definiert gRPC einen Service. Seine Methoden und Rückgabetypen werden mithilfe von protobuf festgelegt – einem Google-Protokoll zur Serialisierung und Deserialisierung. So lassen sich Services einfach definieren und Clientbibliotheken automatisch generieren. gRPC verwendet dieses Protokoll, derzeit in Version 3, als Schnittstellendefinitionssprache und Serialisierungstoolset.

Für die meisten modernen Anwendungen ist gRPC dank seiner hervorragenden Unterstützung aller Datentypen eine ausgezeichnete Wahl. Es eignet sich besonders für große Datenmengen, etwa bei Streaming-Daten, kann für einfache Anwendungen, bei denen umfangreiche Datenübertragungen kaum eine Rolle spielen, jedoch überdimensioniert sein.

In diesem Artikel erfahren Sie, wie Sie gRPC für die client- und serverähnliche Kommunikation zwischen zwei Node.js-Anwendungen verwenden. Außerdem stellen wir einige Sicherheitsmaßnahmen für den Einsatz von gRPC als Kommunikationsmechanismus in Ihren Services vor.

Voraussetzungen für das Tutorial

Für dieses Tutorial müssen OpenSSL und Node.js (Version 4.0 oder höher) auf Ihrem PC installiert sein. Grundkenntnisse in Node.js und JavaScript sind unerlässlich. Außerdem benötigen Sie in Ihrer Arbeitsumgebung Administratorrechte.

Node.js-Projekt einrichten

Erstellen Sie zunächst für die Ordnerstruktur der Anwendung einen Ordner mit dem Namen event-app-node-grpc und initialisieren Sie ein Node.js-Projekt mit npm, indem Sie die folgenden Befehle eingeben:

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

Nachdem Sie Ihre Anwendung initialisiert haben, erstellen Sie die folgende Ordnerstruktur. Den vollständigen, in diesem Tutorial verwendeten Code finden Sie auf GitHub:

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

Pakete installieren

Wechseln Sie im Terminal zum Stammverzeichnis Ihrer Anwendung. Installieren Sie die folgenden Pakete mit dem Befehl npm install, wie im folgenden Codeausschnitt gezeigt:

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

Sehen wir uns die Pakete an, die Sie im obigen Codeausschnitt installiert haben:

• Express ist der HTTP-Server Ihrer Anwendung.

• @grpc/grpc-js ist eine gRPC-Bibliothek für Node.js. Damit können wir einen gRPC-Service in der Node.js-Laufzeitumgebung erstellen.

• @grpc/proto-loader ist ein Paket, das zum Laden von protobuf-Dateien für die Verwendung mit gRPC benötigt wird. Es nutzt Version 3 des Pakets protobuf.js.

Öffnen Sie nach der Installation der oben genannten Pakete die Datei package.json und ergänzen Sie die folgenden Konfigurationen in den scripts-Tags, wie im nachstehenden Codeausschnitt gezeigt:

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

Die oben gezeigten zusätzlichen Konfigurationen dienen der Laufzeitkonfiguration der Anwendung und der Erstellung des SSL-Zertifikats. Nach dem Hinzufügen sollte Ihre aktualisierte Datei package.json dem folgenden Codeausschnitt ähneln:

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}

Der obige Codeausschnitt zeigt die aktualisierte Datei package.json mit den Befehlen für die Laufzeitkonfiguration der Anwendung und die Erstellung des SSL-Zertifikats im scripts-Tag.

Protocol Buffer definieren

Dieses Tutorial zeigt, wie Sie gRPC in einer einfachen Anwendung zur Ereignisverfolgung verwenden. Die Demoanwendung nimmt Ereignisdetails entgegen und speichert sie in einer In-Memory-Datenbank. Die Ereignisdaten können aktualisiert, abgerufen und gelöscht werden.

In gRPC-Anwendungen befinden sich die Service-Schnittstelle und die benötigten Payloads in einer protobuf-Datei, damit verschiedene Anwendungen miteinander kommunizieren können. protobuf-Dateien haben die Erweiterung .proto, wie im Schema für unsere Projekteinrichtung dargestellt.

Erstellen Sie nun im Stammverzeichnis Ihrer Anwendung eine Datei namens events.proto und fügen Sie den folgenden Code ein. Zur Orientierung können Sie sich die zuvor definierte Schema-Struktur des Projekts ansehen.

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}

In den obigen Codeausschnitten für die proto-Definition haben wir zunächst mit der Definition syntax = "proto3" die Protocol-Buffer-Version angegeben und anschließend die Protocol-Service-Definition festgelegt.

Als Nächstes haben wir in der Beschreibung des Protocol-Event-Service einen Service namens EventService erstellt. Innerhalb dieses Services haben wir rpc-Funktionen mit den erforderlichen Parametern und erwarteten Rückgabewerten definiert. Sie können so viele Services definieren, wie Ihre Anwendung benötigt. Der Einfachheit halber definieren wir hier jedoch nur einen.

In der Definition von EventService haben wir außerdem die Datentypen für die rpc-Funktion sowie die Rückgabewerte mithilfe des eindeutigen Feldnummerierungssystems von gRPC festgelegt. Dieses beschreibt, wie viele Bytes bei der Codierung verwendet werden. Weitere Informationen finden Sie in der offiziellen protobuf-Dokumentation.

gRPC-Server erstellen

Erstellen Sie entsprechend der oben beschriebenen Ordnerstruktur im Stammverzeichnis Ihrer Anwendung einen Ordner namens server und darin die Datei index.js. Fügen Sie den folgenden Codeausschnitt in die neu erstellte Datei server/index.js ein:

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

Im obigen Codeausschnitt haben wir die zuvor definierte Datei events.proto als Variable PROTO_PATH importiert und mit der Methode loadSync der Bibliothek protoLoader geladen. Anschließend haben wir die proto-Definitionen in der Variable eventsProto gespeichert, die alle proto-Definitionen enthält.

Fügen Sie nun direkt nach der Variable eventsProto den folgenden Codeausschnitt in die zuvor definierte Datei server/index.js ein.

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

Im obigen Codeausschnitt haben wir das Paket node:crypto und seine Funktion randomUUID eingebunden, mit der zufällige eindeutige Zeichenfolgen für unsere Ereignis-IDs generiert werden. Da wir für dieses Tutorial eine In-Memory-Datenbank verwenden, definieren wir sie als Array, in dem unsere Ereignisliste gespeichert wird. Anschließend richten wir unsere Serverinstanz ein, indem wir eine neue Methode grpc.Server aufrufen.

Als Nächstes registrieren wir die Anwendungsservices. Fügen Sie dazu den folgenden Codeausschnitt direkt nach der Variable server im obigen Code ein:

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

Im obigen Codeausschnitt haben wir die Methode addService für die gRPC-Serverinstanz aufgerufen, um die Anwendungsservices zu registrieren. Dabei handelte es sich im Wesentlichen um Vorgänge zum Erstellen, Lesen und Aktualisieren von Ereignissen.

Damit der Anwendungsserver gestartet werden kann, fügen Sie den folgenden Codeausschnitt direkt nach der Methode addService aus dem obigen Code ein.

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

gRPC-Client erstellen

Erstellen Sie entsprechend der oben beschriebenen Ordnerstruktur im Stammverzeichnis Ihrer Anwendung einen Ordner namens client. Legen Sie darin zwei Dateien an: index.js und app.js. Fügen Sie den folgenden Codeausschnitt in die Datei client/app.js ein.

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;

Im obigen Codeausschnitt haben wir die zuvor erstellten proto-Definitionen importiert, mit protoLoader geladen, den grpc-Client mit der IP-Adresse der Serveranwendung verbunden und den Event-Service unter dem Variablennamen client exportiert. Außerdem haben wir dem Client ein SSL-Zertifikat zur Authentifizierung und Verschlüsselung der Client-Server-Kommunikation hinzugefügt.

Fügen Sie anschließend den folgenden Codeausschnitt in die Datei client/index.js ein:

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

Im obigen Codeausschnitt haben wir event-service aus der Datei client/app.js importiert. Anschließend haben wir einen Express-Server mit einfachen Endpunkten zum creation, update, fetch und delete von Ereignissen eingerichtet. Dafür rufen wir die Serveranwendung mithilfe von gRPC-Techniken remote auf.

Server- und Clientanwendungen testen

Nun können wir unsere Arbeit testen und prüfen, ob alles wie geplant funktioniert.

Der Server

Wechseln Sie im Terminal zum Stammverzeichnis des Projekts und führen Sie dann die folgenden Befehle aus:

1$bash
2$ npm run start

Die Serveranwendung sollte unter http://localhost:50051 erreichbar sein:

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

Der Client

Öffnen Sie ein neues Terminalfenster, wechseln Sie vom Stammverzeichnis Ihrer Anwendung in den client-Ordner und führen Sie dann die folgenden Befehle aus:

1$bash
2$ node index

Die Anwendung sollte unter http://localhost:50050 erreichbar sein:

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

Rufen Sie zum Testen localhost:50050 in Ihrem Browser auf oder verwenden Sie ein API-Testtool wie Postman. Sie sollten das Standardereignis sehen, das wir anfangs zu unserem Ereignis-Array hinzugefügt haben. Die Antwort sollte mit dem folgenden Screenshot übereinstimmen:

gRPC-API authentifizieren und absichern

Das gRPC-Protokoll unterstützt verschiedene Authentifizierungsmechanismen und lässt sich dadurch einfach an neue und bestehende Systeme anpassen. Die Authentifizierung in der gRPC-Client-Server-Kommunikation können wir mithilfe empfohlener Mechanismen wie SSL und TLS implementieren, mit oder ohne Google-Token-basierte Authentifizierung. Außerdem können wir eine benutzerdefinierte Authentifizierung erstellen, indem wir die integrierte Authentifizierungsfunktion von gRPC erweitern.

Standardmäßig umfasst gRPC die folgenden Authentifizierungsmechanismen:

• SSL und TLS zur Authentifizierung des Servers und zur Verschlüsselung der zwischen Client und Server ausgetauschten Daten

• ALTS (ein von Google entwickeltes gegenseitiges Transport- und Authentifizierungsprotokoll) zur Absicherung der RPC-Kommunikation von Anwendungen auf der Google Cloud Platform (GCP)

• Ein generischer Token-basierter Authentifizierungsmechanismus zum Hinzufügen metadatenbasierter Anmeldedaten zu Anfragen und Antworten

Wie in der Einleitung des Tutorials erwähnt, implementieren wir die Authentifizierung in diesem Tutorial mit SSL. Anschließend ändern wir den Code in den Dateien client/app.js und server/index.js, damit er diese neue Funktion unterstützt.

SSL-Zertifikat mit OpenSSL generieren

Generieren wir zunächst mit OpenSSL ein SSL-Zertifikat. Dazu muss OpenSSL installiert sein. Außerdem benötigen Sie die Berechtigung zum Ausführen von Bash-Skripten. Diese Voraussetzungen sind wichtig, um Berechtigungsfehler zu vermeiden.

Erstellen Sie in unserer Ordnerstruktur einen Ordner namens scripts und darin eine Datei namens generate-certs.sh. Fügen Sie den folgenden Codeausschnitt in die Datei ein:

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

Der obige Code generiert die SSL-Zertifikate, die für eine sichere, verschlüsselte Verbindung zwischen Server- und Clientanwendung erforderlich sind. Bei der Ausführung erstellt er einen Ordner certs, generiert mit OpenSSL die SSL-Zertifikate für Server und Client und speichert sie anschließend im Ordner certs. Weitere Informationen zu diesen Konfigurationen und ihrer Funktion finden Sie auf der OpenSSL-Website.

SSL-Zertifikat für die Anwendung mit npm generieren

Verwenden Sie nun das Skript, um ein SSL-Zertifikat für Ihre Anwendung zu generieren. Führen Sie dazu im Terminal im Stammverzeichnis der Anwendung die folgenden Befehle aus.

1$bash
2$ npm run generate:certs

Dadurch wird ein Ordner certs erstellt, der die generierten SSL-Zertifikate enthält.

Beachten Sie, dass dafür Administratorrechte erforderlich sind. Wenn beim Ausführen des Skripts ein Berechtigungsfehler auftritt, erteilen Sie dem Skript mit den folgenden Befehlen die Berechtigung zum Ausführen und versuchen Sie es dann erneut.

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

Im Terminal sollte folgende Ausgabe erscheinen:

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

Dateien client/app.js und server/index.js aktualisieren

Wir haben nun die SSL-Zertifikate generiert, die zur Authentifizierung unserer gRPC-APIs erforderlich sind. Als Nächstes ändern wir die Dateien client/index.js und server/index.js, damit sie mit diesen generierten Zertifikaten arbeiten.

In der unten gezeigten aktualisierten Datei client/app.js haben wir das Modul fs hinzugefügt, um die generierten Zertifikate einzulesen. Anschließend haben wir damit gRPC-SSL-Anmeldedaten erstellt und diese schließlich auf den gRPC-Service angewendet.

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;

Auch in der unten gezeigten aktualisierten Datei server/index.js haben wir das Modul fs hinzugefügt, um die generierten Zertifikate einzulesen. Anschließend haben wir damit gRPC-SSL-Anmeldedaten erstellt und diese auf den Server angewendet.

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

Server- und Clientanwendungen ausführen

Wir haben erfolgreich eine Lösung zur Ereignisverwaltung mithilfe der gRPC-Spezifikationen implementiert. Um die Endpunkte zu testen, starten Sie die Anwendung über das Terminal und führen Sie die folgenden Schritte aus.

Der Server

Navigieren Sie im Terminal zum Stammverzeichnis des Projekts und führen Sie die folgenden Befehle aus:

1$bash
2$ npm run start

Anschließend sollte die Serveranwendung unter http://0.0.0.0:50051 verfügbar sein:

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

Der Client

Öffnen Sie ein neues Terminalfenster, navigieren Sie vom Stammverzeichnis Ihrer Anwendung zum Client-Ordner und führen Sie anschließend die folgenden Befehle aus:

1$bash
2$ node index

Anschließend sollte die Client-Anwendung unter http://localhost:50050 verfügbar sein:

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

Rufen Sie zum Testen der Anwendung in Ihrem Browser localhost:50050 auf oder verwenden Sie ein API-Testtool wie Postman. Sie sollten das Standardereignis sehen, das wir anfangs zu unserem Events-Array hinzugefügt haben. Ihre Antwort sollte mit dem folgenden Screenshot übereinstimmen:

Sie können nun weitere Endpunkte der Anwendung testen, um sicherzustellen, dass alles wie erwartet funktioniert.

Sie haben eine sichere API mit gRPC erstellt!

In diesem Tutorial haben wir mit Node.js eine einfache API in gRPC erstellt und ihre Funktionsweise sowie zahlreiche Vorteile beleuchtet, darunter HTTP/2 und SSL/TLS für die durchgängige Authentifizierung und Verschlüsselung zur Verbesserung der API-Sicherheit.

Trotz dieser Vorteile hat gRPC auch Schwächen: Dazu zählen die eingeschränkte Browser-Unterstützung, das nicht menschenlesbare Datenformat, die steile Lernkurve und die mangelnde Unterstützung für Edge-Caching. Doch ungeachtet dieser Einschränkungen ist gRPC dank seiner unübertroffenen Leistung und Mehrsprachigkeit die beste Option für die Kommunikation zwischen internen Microservices. Das gRPC-Protokoll ist beeindruckend und hat seit seiner ersten Veröffentlichung im August 2016 in der Branche breite Akzeptanz gefunden. Dieser Trend wird sich zweifellos fortsetzen.

Mit gRPC können Sie noch vieles mehr tun. Das Beispiel in diesem Tutorial kratzt nur an der Oberfläche dessen, was gRPC zu bieten hat. In der Dokumentation können Sie Ihr Wissen über gRPC vertiefen, um die Kommunikationsprozesse Ihrer Anwendung und Strategien zur Gewährleistung der gRPC-Sicherheit zu verbessern.

Weitere API-Ressourcen:

• Eine sichere GraphQL-API mit Node.js erstellen

• Go-Anwendungen mit Docker containerisieren