gRPC - Microservicios en Lenguajes Diferentes [JS y PY]
Published: 2023-06-24 22:59:51

¡Hola, Jóvenes Coder! 🚀 ¿Listos para un nuevo viaje a través del emocionante mundo del desarrollo? Hoy, nos sumergiremos en gRPC, una tecnología muy poderosa para la comunicación entre servicios. Vamos a aprender qué es, cómo se aplica con Node.js y Python y cómo puede hacer que tu código sea más limpio y eficiente.

Si quieres ver un ejemplo de esta implementacion te recomeindo mi repositorio: [python-javascript-backend-microservice](https://github.com/Bryan-Herrera-DEV/python-javascript-backend-microservice)

## ¿Qué es gRPC? 🤔
gRPC es un marco de comunicación remota de alto rendimiento desarrollado por Google. gRPC utiliza HTTP/2 para la transferencia de datos y Protocol Buffers (también conocido como Protobuf) como lenguaje de interfaz. Es ideal para aplicaciones de microservicios debido a su eficiencia y capacidad para generar clientes y servidores en una variedad de idiomas.

## ¿Cómo se ve gRPC? 👀
Imagina que tienes dos amigos 🤖🤖 en diferentes ciudades que necesitan comunicarse. Un amigo (llamémoslo NodeBot) vive en NodeCity y el otro (PythonBot) vive en PythonTown. Ambos hablan diferentes idiomas, pero necesitan compartir información entre ellos.

Para solucionar esto, gRPC actúa como un intérprete que les permite comunicarse de manera efectiva, sin importar en qué idioma estén hablando.

Configuración básica en Node.js y Python
### 1. Instalación de gRPC y Protobuf
- En Node.js, instala gRPC usando npm:
```shell
npm install grpc @grpc/proto-loader
```
- En Python, instala gRPC usando pip:
```bash
pip install grpcio grpcio-tools
```

### 2. Creando el archivo Protobuf
Supongamos que NodeBot y PythonBot quieren intercambiar un mensaje simple "Hola". Creamos un archivo Protobuf (.proto) para definir el servicio y el mensaje:

```protobuf
syntax = "proto3";

service BotService {
    rpc DecirHola (HolaRequest) returns (HolaResponse) {}
}

message HolaRequest {
    string nombre = 1;
}

message HolaResponse {
    string mensaje = 1;
}
```
### 3. Generando código a partir de .proto
- En Node.js, puedes generar código dinámicamente en tiempo de ejecución:
```javascript
const PROTO_PATH = './path/to/your/proto/file';
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const packageDefinition = protoLoader.loadSync(PROTO_PATH);
const botProto = grpc.loadPackageDefinition(packageDefinition).botpackage;
```
- En Python, debes generar el código usando grpcio-tools antes de ejecutar el script:
```bash
python -m grpc_tools.protoc -I./ --python_out=./ --grpc_python_out=./ ./path/to/your/proto/file
```
### 4. Creando el servidor y el cliente
- En Node.js, para el servidor:
```javascript
const server = new grpc.Server();
server.addService(botProto.BotService.service, { DecirHola: decirHola });
server.bind('0.0.0.0:50051', grpc.ServerCredentials.createInsecure());
server.start();
```
Para el cliente:
```javascript
const client = new botProto.BotService('localhost:50051', grpc.credentials.createInsecure());
client.DecirHola({ nombre: 'NodeBot' }, (error, response) => {
    console.log(response.mensaje);
});
```
- En Python, para el servidor:
```python
from concurrent import futures
import grpc

import bot_pb2
import bot_pb2_grpc

class BotServiceServicer(bot_pb2_grpc.BotServiceServicer):
    def DecirHola(self, request, context):
        return bot_pb2.HolaResponse(mensaje='¡Hola, {}!'.format(request.nombre))

server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
bot_pb2_grpc.add_BotServiceServicer_to_server(BotServiceServicer(), server)
server.add_insecure_port('[::]:50051')
server.start()
```
Para el cliente:
```python
import grpc

import bot_pb2
import bot_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = bot_pb2_grpc.BotServiceStub(channel)
response = stub.DecirHola(bot_pb2.HolaRequest(nombre='PythonBot'))
print(response.mensaje)
```
## Conclusión 😎
gRPC es una forma poderosa de hacer que los servicios en diferentes lenguajes se comuniquen entre sí de manera eficiente. A través de la definición de Protocol Buffers y el uso de HTTP/2, gRPC permite que los servicios de gran escala se comuniquen sin problemas.

Asegúrate de explorar más sobre gRPC y sus características, como los streams y la autenticación. Recuerda, sigue codificando, sigue aprendiendo y sigue construyendo! 🚀💻