Cómo crear una API segura con gRPC

Una llamada a procedimiento remoto de Google (gRPC) es la versión de código abierto de Google del framework de llamadas a procedimientos remotos (RPC). Es un protocolo de comunicación que aprovecha las tecnologías HTTP/2 y Protocol Buffers (protobuf). gRPC permite que un cliente o servidor remoto se comunique con otro servidor con solo llamar a la función del servidor receptor como si fuera local. Esto facilita mucho la comunicación y la transferencia de grandes conjuntos de datos entre el cliente y el servidor en sistemas distribuidos.

Al igual que otros sistemas RPC, gRPC define un servicio. Especifica sus métodos y tipos de retorno mediante protobuf —un protocolo de Google para la serialización y deserialización—, lo que facilita la definición de servicios y la generación automática de bibliotecas cliente. gRPC usa este protocolo, actualmente en la versión 3, como lenguaje de definición de interfaces y conjunto de herramientas de serialización.

Para la mayoría de las aplicaciones modernas, gRPC es una excelente opción gracias a su compatibilidad con todo tipo de datos. Es ideal para grandes volúmenes de datos, como los datos de streaming, y puede ser excesivo para aplicaciones sencillas en las que la transferencia de grandes cantidades de datos no es una prioridad.

En este artículo aprenderás a usar gRPC mediante la comunicación entre un cliente y un servidor de dos aplicaciones Node.js. También destacaremos algunas medidas de seguridad para usar gRPC como mecanismo de comunicación en tus servicios.

Requisitos previos del tutorial

Para este tutorial, debes tener OpenSSL y Node.js (versión 4.0 o posterior) instalados en tu PC. Es fundamental tener conocimientos básicos de Node.js y JavaScript. También debes asegurarte de que tu entorno de trabajo tenga privilegios de administrador.

Configurar el proyecto de Node.js

Primero, para establecer la estructura de carpetas de la aplicación, crea una carpeta llamada event-app-node-grpc e inicializa un proyecto de Node.js con npm. Para ello, escribe los siguientes comandos:

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

Una vez inicializada la aplicación, crea la siguiente estructura de carpetas. Puedes consultar en GitHub el código completo que usamos en este tutorial:

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

Instalar paquetes

En la terminal, ve al directorio raíz de la aplicación. Instala los siguientes paquetes con el comando npm install, como se muestra en el siguiente fragmento de código:

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

Veamos los paquetes que acabas de instalar en el fragmento de código anterior:

• Express es el servidor HTTP de tu aplicación.

• @grpc/grpc-js es una biblioteca de gRPC para Node.js. Permite crear un servicio gRPC en el entorno de ejecución de Node.js.

• @grpc/proto-loader es un paquete necesario para cargar archivos protobuf y usarlos con gRPC. Usa la versión 3 del paquete protobuf.js.

Después de instalar los paquetes anteriores, abre el archivo package.json y agrega las siguientes configuraciones a las etiquetas scripts, como se muestra en el fragmento de código:

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

Las configuraciones adicionales del fragmento de código anterior corresponden a la configuración del entorno de ejecución de la aplicación y a la generación del certificado SSL. Una vez agregadas, el archivo package.json actualizado debería verse como el siguiente fragmento de código:

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}

El fragmento de código anterior muestra el archivo package.json actualizado después de agregar a la etiqueta scripts los comandos para configurar el entorno de ejecución de la aplicación y generar el certificado SSL.

Definir el Protocol Buffer

En este tutorial se muestra cómo usar gRPC en una aplicación sencilla de seguimiento de eventos. La aplicación de demostración recibe detalles de eventos y los guarda en una base de datos en memoria, y permite actualizar, consultar y eliminar los datos de los eventos.

En las aplicaciones gRPC, la interfaz del servicio y las cargas útiles necesarias se definen en un archivo protobuf para permitir la comunicación entre distintas aplicaciones. Los archivos protobuf tienen la extensión .proto, como se muestra en el esquema de configuración del proyecto.

Ahora, en el directorio raíz de la aplicación, crea un archivo events.proto y agrega el siguiente código. Puedes consultar como referencia el esquema de estructura del proyecto que definimos antes.

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}

En los fragmentos de código de definición de proto anteriores, primero especificamos la versión de Protocol Buffer con la definición syntax = "proto3" y, después, definimos el servicio de protocolo.

Luego, en la descripción del servicio de eventos del protocolo, creamos un servicio llamado EventService. Después, creamos funciones rpc dentro de este servicio, junto con los parámetros necesarios y los valores de retorno esperados. Puedes definir tantos servicios como necesite tu aplicación, pero, para simplificar, definimos solo uno.

También definimos los tipos de datos para la función rpc en la definición de EventService y los valores de retorno mediante el sistema exclusivo de numeración de campos de gRPC. Este sistema especifica la cantidad de bytes que se usan durante la codificación. Consulta más detalles en la documentación oficial de protobuf.

Crear el servidor gRPC

Siguiendo la estructura de carpetas anterior, crea una carpeta server en el directorio raíz de la aplicación y, dentro de ella, crea un archivo index.js. Pega el siguiente fragmento de código en el archivo server/index.js que acabas de crear:

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

En el fragmento de código anterior, importamos el archivo events.proto que definimos antes y lo asignamos a la variable PROTO_PATH. Luego, lo cargamos con el método loadSync de la biblioteca protoLoader. Después, guardamos las definiciones de proto en la variable eventsProto, que las contiene todas.

A continuación, agrega el siguiente fragmento de código justo después de la variable eventsProto en el archivo server/index.js que definimos antes.

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

En el fragmento de código anterior, requerimos el paquete node:crypto y su función randomUUID, que sirve para generar cadenas únicas aleatorias para los ID de nuestros eventos. Como en este tutorial usamos una base de datos en memoria, la definiremos como un arreglo para almacenar la lista de eventos. Luego, configuraremos la instancia del servidor con una nueva llamada al método grpc.Server.

A continuación, registraremos los servicios de la aplicación. Para ello, agrega el siguiente fragmento de código justo después de la variable server del fragmento anterior:

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

En el fragmento de código anterior, llamamos al método addService en la instancia del servidor gRPC para registrar los servicios de la aplicación. En esencia, se trata de operaciones para crear, leer y actualizar eventos.

Para iniciar el servidor de la aplicación, pega el siguiente fragmento de código justo después del método addService del fragmento anterior.

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

Crear el cliente gRPC

Siguiendo la estructura de carpetas anterior, crea una carpeta client en el directorio raíz de la aplicación y, dentro de ella, crea dos archivos: index.js y app.js. Pega el siguiente fragmento de código en el archivo 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;

En el fragmento de código anterior, importamos las definiciones de proto que creamos antes y las cargamos con protoLoader. Conectamos el cliente grpc a la dirección IP de la aplicación del servidor y exportamos el servicio de eventos con el nombre de variable client. También agregamos un certificado SSL al cliente para autorizar y cifrar las comunicaciones entre el cliente y el servidor.

Luego, pega el siguiente fragmento de código en el archivo 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});

En el fragmento de código anterior, importamos event-service desde el archivo client/app.js. Después, configuramos un servidor Express con endpoints sencillos para gestionar la creation, la update, la fetch y la delete de eventos mediante llamadas remotas a la aplicación del servidor con gRPC.

Probar las aplicaciones del servidor y del cliente

En este punto, podemos probar lo que hicimos para asegurarnos de que todo vaya bien.

El servidor

Ve al directorio raíz del proyecto desde la terminal y ejecuta los siguientes comandos:

1$bash
2$ npm run start

La aplicación del servidor debería estar disponible en 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

El cliente

Abre una nueva ventana de terminal, ve a la carpeta client desde el directorio raíz de la aplicación y ejecuta los siguientes comandos:

1$bash
2$ node index

La aplicación debería estar disponible en 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

Para probarla, ve a localhost:50050 en tu navegador o usa una herramienta para probar APIs, como Postman. Deberías ver el evento predeterminado que agregamos inicialmente a nuestro arreglo de eventos. La respuesta debería ser igual a la de la siguiente captura de pantalla:

Autenticar y proteger la API gRPC

El protocolo gRPC admite varios mecanismos de autenticación, por lo que se adapta fácilmente a sistemas nuevos y existentes. Podemos implementar la autenticación en las comunicaciones entre clientes y servidores gRPC con mecanismos recomendados, como SSL y TLS, con o sin autenticación basada en tokens de Google. También podemos crear una autenticación personalizada extendiendo la función de autenticación integrada en gRPC.

De forma predeterminada, gRPC incluye los siguientes mecanismos de autenticación:

• SSL y TLS para autenticar el servidor y cifrar los datos intercambiados entre el cliente y el servidor

• ALTS (un protocolo de autenticación y transporte mutuo diseñado por Google) para proteger las comunicaciones RPC de las aplicaciones que se ejecutan en Google Cloud Platform (GCP)

• Un mecanismo genérico de autenticación basada en tokens para adjuntar credenciales basadas en metadatos a las solicitudes y respuestas

En este tutorial implementaremos la autenticación con SSL, como mencionamos en la introducción, y luego modificaremos los archivos client/app.js y server/index.js para incorporar este cambio.

Generar un certificado SSL con OpenSSL

Primero, generemos un certificado SSL con OpenSSL. Para este proceso, necesitarás tener OpenSSL instalado y permiso para ejecutar scripts de Bash. Estos requisitos son fundamentales para evitar errores de permisos.

En la estructura de carpetas, crea una carpeta scripts y, dentro de ella, un archivo llamado generate-certs.sh. Pega el siguiente fragmento de código en ese archivo:

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

El código anterior genera los certificados SSL necesarios para establecer una conexión segura y cifrada entre las aplicaciones del servidor y del cliente. Al ejecutarse, crea una carpeta certs, genera los certificados SSL del servidor y del cliente con OpenSSL y los guarda en la carpeta certs. Para obtener más información sobre estas configuraciones y su funcionamiento, visita el sitio web de OpenSSL.

Generar un certificado SSL para la aplicación con npm

Ahora, usa el script para generar un certificado SSL para tu aplicación. Ejecuta los siguientes comandos en la terminal, desde el directorio raíz de la aplicación.

1$bash
2$ npm run generate:certs

Esto crea una carpeta certs que contiene los certificados SSL generados.

Ten en cuenta que se requieren algunos privilegios de administrador. Si aparece un error de permisos al ejecutar el script, usa los siguientes comandos para otorgarle el permiso de ejecución y vuelve a intentarlo.

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

Deberías ver el siguiente resultado en la 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

Actualizar los archivos client/app.js y server/index.js

Hasta ahora, generamos los certificados SSL necesarios para autenticar nuestras API gRPC. Ahora modificaremos los archivos client/index.js y server/index.js para que funcionen con estos certificados.

En el archivo client/app.js actualizado que se muestra a continuación, incorporamos el módulo fs para leer los certificados generados. Luego, usamos esos certificados para crear credenciales SSL de gRPC y, por último, las aplicamos al servicio 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;

También incorporamos el módulo fs en el archivo server/index.js actualizado que se muestra a continuación para leer los certificados generados. Luego, usamos esos certificados para crear credenciales SSL de gRPC y las aplicamos al servidor.

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

Ejecutar las aplicaciones del servidor y del cliente

Implementamos correctamente una solución de gestión de eventos con las especificaciones de gRPC. Para probar los endpoints, inicia la aplicación desde la terminal siguiendo los pasos que se indican a continuación.

El servidor

Ve al directorio raíz del proyecto desde la terminal y ejecuta los siguientes comandos:

1$bash
2$ npm run start

Después de ejecutarlos, la aplicación del servidor debería estar disponible en 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

El cliente

Abre una nueva ventana de la terminal, ve a la carpeta client desde el directorio raíz de la aplicación y ejecuta los siguientes comandos:

1$bash
2$ node index

Después de ejecutarlos, la aplicación del cliente debería estar disponible en http://localhost:50050:

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

Para probar la aplicación, ve a localhost:50050 en tu navegador o usa una herramienta para probar API, como Postman. Deberías ver el evento predeterminado que agregamos inicialmente a nuestro arreglo de eventos. La respuesta debería coincidir con la siguiente captura de pantalla:

Puedes probar otros endpoints agregados a la aplicación para asegurarte de que todo funcione como esperas.

¡Creaste una API segura con gRPC!

En este tutorial, creamos una API sencilla con gRPC y Node.js, y explicamos cómo funciona y cuáles son sus numerosas ventajas, como HTTP/2 y SSL/TLS para la autenticación y el cifrado de extremo a extremo, que mejoran la seguridad de las API.

A pesar de estas ventajas, gRPC también tiene puntos débiles: compatibilidad limitada con navegadores, un formato de datos difícil de leer para las personas, una curva de aprendizaje pronunciada y poca compatibilidad con el almacenamiento en caché en el borde. Sin embargo, gracias a su rendimiento incomparable y su naturaleza multilingüe, gRPC es la mejor opción para la comunicación entre microservicios internos. El protocolo gRPC es impresionante y, desde su lanzamiento inicial en agosto de 2016, ha logrado una adopción considerable en la industria. Sin duda, seguirá creciendo.

Hay muchas otras cosas que puedes hacer con gRPC. El ejemplo de este tutorial es apenas la punta del iceberg de todo lo que ofrece. Consulta la documentación para ampliar tus conocimientos sobre gRPC y mejorar los procesos de comunicación de tu aplicación, así como las estrategias para mantener la seguridad de gRPC.

Más recursos sobre API:

• Cómo crear una API GraphQL segura con Node.js

• Cómo contenerizar aplicaciones de Go con Docker