Uniendo gRPC y FastAPI: Desarrollando servicios web de alto rendimiento.

Uniendo gRPC y FastAPI: Desarrollando servicios web de alto rendimiento

Introducción

gRPC y FastAPI son dos frameworks de desarrollo de servicios web que ofrecen diferentes ventajas y desventajas. gRPC es un framework RPC (Remote Procedure Call) que se basa en el protocolo HTTP/2, lo que lo hace muy eficiente en términos de rendimiento. FastAPI es un framework web HTTP que se basa en Python y ofrece una sintaxis sencilla y concisa.

En este tutorial, veremos cómo combinar gRPC y FastAPI para crear servicios web de alto rendimiento.

Prerequisitos

Para seguir este tutorial, necesitarás los siguientes prerequisitos:

Python 3.8 o superior
gRPC
FastAPI
Docker

Instalando los requisitos

Para instalar los requisitos, ejecuta los siguientes comandos:

pip install grpcio
pip install fastapi
pip install uvicorn

Creando el servicio gRPC

El primer paso es crear el servicio gRPC. Para ello, crearemos un archivo llamado server.py con el siguiente código:

import grpc

from helloworld_pb2 import HelloRequest, HelloReply
from helloworld_pb2_grpc import GreeterServicer


class Greeter(GreeterServicer):

    def SayHello(self, request, context):
        return HelloReply(message="Hello, {}!".format(request.name))


def main():
    server = grpc.server(
        [
            ("localhost", 50051),
        ],
        max_workers=10,
    )

    GreeterServicer.add_to_server(Greeter(), server)

    server.start()
    print("Servicio gRPC iniciado en http://localhost:50051")
    server.wait()


if __name__ == "__main__":
    main()

Este código crea un servicio gRPC que implementa el método SayHello(), que devuelve un mensaje de saludo personalizado.

Creando el servicio FastAPI

El siguiente paso es crear el servicio FastAPI. Para ello, crearemos un archivo llamado app.py con el siguiente código:

import grpc
from fastapi import FastAPI
from fastapi.middleware.grpc import GrpcMiddleware

from helloworld_pb2 import HelloRequest
from helloworld_pb2_grpc import GreeterStub


app = FastAPI()


@app.get("/")
def index():
    return "Hola, mundo!"


@app.post("/hello")
def hello(request: HelloRequest):
    stub = GreeterStub(grpc.insecure_channel("localhost:50051"))
    response = stub.SayHello(request)
    return {"message": response.message}


app.add_middleware(GrpcMiddleware(), prefix="/grpc")


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=8000)

Este código crea un servicio FastAPI que expone una ruta /hello que utiliza el servicio gRPC para devolver un mensaje de saludo personalizado.

Probando el servicio

Para probar el servicio, podemos ejecutar los siguientes comandos:

python server.py

uvicorn app:app --reload

A continuación, podemos probar el servicio gRPC con el siguiente comando:

grpcurl -d '{"name": "Bard"}' localhost:50051 helloworld.Greeter/SayHello

Esto debería devolver el siguiente resultado:

{
  "message": "Hello, Bard!"
}

También podemos probar el servicio FastAPI con el siguiente comando:

curl -X POST -H "Content-Type: application/json" -d '{"name": "Bard"}' localhost:8000/hello

Esto debería devolver el mismo resultado que el comando anterior.

Conclusión

En este tutorial, hemos visto cómo combinar gRPC y FastAPI para crear servicios web de alto rendimiento. gRPC proporciona un rendimiento excelente, mientras que FastAPI ofrece una sintaxis sencilla y concisa. Al combinar estos dos frameworks, podemos crear servicios web que sean eficientes y fáciles de desarrollar.

Recursos adicionales

Publicaciones relacionadas: