gRPC con Python

 

Hoy veremos un ejemplo de uso de gRPC con Python.

Para ello verificaremos la versión de Python y Pip instalados en nuestro sistema, ya que gRPC requiere al menos que se tenga la versión 3.7 para Python y la versión 9.0.1 o mayor de Pip.

Abrimos una terminal y tecleamos:

$ py --version # 3.13.3
$ pip --version # 25.2

¿Por qué Python?

• Es un lenguaje de programación multipropósito. 
• Permite el uso de diferentes paradigmas, como el orientado a objetos y hasta el funcional. 
• Posee miles de librerías que nos permiten trabajar con diversas herramientas, entre ellas gRPC.

¿Por qué gRPC?

• Es ideal para desarrollos modernos como microservicios que requieren alto rendimiento, baja latencia y comunicación eficiente. 
• Tiene soporte a lenguajes como Go, Python, Java, C# y C++.

Instalemos gRPC con ayuda de Pip:

$ pip install grpcio

Instalemos también las herramientas de gRPC :

$ pip install grpcio-tools

Verifiquemos la instalación:

$ pip list

Empezando con gRPC y Python

Una vez instaladas las herramientas necesarias podemos comenzar con un ejemplo sencillo. Pero antes de hacer nada, veremos que son los Protobuff y el protocolo de comunicación HTTP/2.

Protobuff será el mecanismo de serialización que usaremos en nuestro proyecto, ya que es el que usa gRPC. Además del protocolo HTTP/2 que es una evolución del protocolo HTTP. Ideal para este tipo de proyectos.

1. Definiremos un servicio holamundo.proto que contendrá lo siguiente:

syntax = "proto3";

service Saludar {
  rpc DecirHola (HolaRequest) returns (HolaReply);
}

message HolaRequest {
  string nombre = 1;
}

message HolaReply {
  string mensaje= 1;
}

El archivo define: 

• Un servicio llamado Saludar . 
• Un método DecirHola que recibe un HolaRequest y devuelve un HolaReply.

2. Generaremos el código gRPC a partir del archivo ``holamundo.proto``. Abrimos una terminal y tecleamos lo siguiente:

$ python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. holamundo.proto

Si todo va bien, te deberá generar dos archivos:

holamundo_pb2.py  # para mensajes
holamundo_pb2_grpc.py # para el servicio

3. Como nuestra aplicación es de tipo Cliente-Servidor crearemos dos programas, uno será el servidor y el otro el cliente.

servidor.py

import grpc
from concurrent import futures
import holamundo_pb2
import holamundo_pb2_grpc

class SaludarServicer(holamundo_pb2_grpc.SaludarServicer):
    def DecirHola(self, request, context):
        return holamundo_pb2.HolaReply(mensaje=f"Hola, {request.nombre}!")

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    holamundo_pb2_grpc.add_SaludarServicer_to_server(SaludarServicer(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    print("Servidor gRPC corriendo en el puerto 50051...")
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

Este programa actuará como el servidor que recibirá peticiones del cliente.

cliente.py

import grpc
import holamundo_pb2
import holamundo_pb2_grpc

def run():
    channel = grpc.insecure_channel('localhost:50051')
    stub = holamundo_pb2_grpc.SaludarStub(channel)
    response = stub.DecirHola(holamundo_pb2.HolaRequest(nombre="Alquimista"))
    print("Respuesta del servidor:", response.mensaje)

if __name__ == '__main__':
    run()

Este programa será nuestro cliente.

4. Ejecución del servidor:

$ python servidor.py

5. Abrimos otra terminal y ejecutaremos el cliete:

$ python cliente.py

Si todo va bien veremos lo siguiente del lado del Servidor:

Servidor gRPC corriendo en el puerto 50051...

Del Cliente:

Respuesta del servidor: Hola, Alquimista!

¡Hemos creado nuestra primera aplicación gRPC y Python!

En próximas entregas continuaremos con este tema.

Enlaces:

https://grpc.io/
https://www.python.org/
https://alquimistadecodigo.blogspot.com/2024/04/un-vistazo-grpc-una-alternativa-soap-y.html
https://codemonkeyjunior.blogspot.com/2026/01/grpc-y-graphql-en-una-comparativa.html
https://codemonkeyjunior.blogspot.com/2026/02/grpc-una-alternativa-para-servicios-de.html