gRPC es un marco de llamada a procedimiento remoto (RPC) potente y de alto rendimiento que, a pesar de usarse con menos frecuencia que REST, ofrece ventajas significativas en ciertos escenarios.

Además, es independiente del idioma y puede ejecutarse en cualquier entorno, lo que lo convierte en una opción ideal para la comunicación de servidor a servidor.

No profundizaré en una explicación completa, pero aquí hay un enlace general de gRPC. Proporcionaré un tutorial práctico

Ir al cliente gRPC 

Imaginemos que nuestro Go es un cliente pero es un servidor como para la aplicación frontend React, Svelte, etc.

func getFirstArg() (string, error) {
    if len(os.Args) 






 Como ejemplo, la interfaz de React carga un archivo, ve a procesarlo pero necesitamos respuestas de Excel, usaremos la API de GPT. Si bien se puede hacer con Go, Python, por otro lado, tiene más paquetes que pueden facilitarnos la vida, como langchan_openai, pandas for excel, etc.


Comencemos con la instalación de gRPC preferiblemente en su virtualenv .venv


$ go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
$ export PATH="$PATH:$(go env GOPATH)/bin"




A continuación, debes instalar el búfer de protocolo en tu sistema operativo. Puedes seguirlo aquí.

Creemos un directorio proto donde almacenará su archivo de búfer de protocolo. Lo nombraré excel.proto y pegaré esto:


syntax = "proto3";
option go_package = "client-gRPC/proto";
service ExcelService {
    rpc UploadFile(FileRequest) returns (FileResponse);
}
message FileRequest {
    string file_name = 1;
    bytes file_content = 2;
}
message FileResponse {
    bytes file_content = 1;
}




Este servicio gRPC, ExcelService, permite a los clientes cargar un archivo enviando su nombre y contenido. El servidor responde con el mismo contenido del archivo. 

Para Go es esencial pasar go_package en Python, la línea no es necesaria.


vscode-proto3 es una buena extensión para descargar si usas VSCode.


Después de todo esto, puedes generar tus archivos proto. Lo prefiero en el mismo nivel que prot dir, para eso ejecuta este comando:

protocolo --go_out=. --go_opt=rutas=fuente_relativa --go-grpc_out=. --go-grpc_opt=paths=source_relative proto/excel.proto

Si se deben generar dos archivos con éxito, opcionalmente, si habría muchos ajustes, agregue un Makefile y defínalo como comando superior proto.


import (
    ....

    "google.golang.org/grpc"
    pb "client-gRPC/proto"
    "github.com/xuri/excelize/v2"
)

func main() {
    ....

    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("Failed to connect to gRPC server: %v", err)
    }
    defer conn.Close()

    client := pb.NewExcelServiceClient(conn)

    req := &pb.FileRequest{
        FileName:    filePath,
        FileContent: fileData,
    }

    res, err := client.UploadFile(context.Background(), req)
    if err != nil {
        log.Fatalf("Failed to upload file: %v", err)
    }

    outputFile := "output.xlsx"
    err = saveBytesAsExcel(outputFile, res.FileContent)
    if err != nil {
        log.Fatalf("Failed to save bytes as Excel file: %v", err)
    }

    fmt.Printf("Excel file saved as: %s\n", outputFile)
}

func saveBytesAsExcel(filePath string, fileContent []byte) error {
    f, err := excelize.OpenReader(bytes.NewReader(fileContent))
    if err != nil {
        return fmt.Errorf("failed to open Excel file: %v", err)
    }

    if err := f.SaveAs(filePath); err != nil {
        return fmt.Errorf("failed to save Excel file: %v", err)
    }
    return nil
}




Hacemos una conexión para escuchar 50051 que será nuestro servidor Python, &pb.FileRequest se generó anteriormente usando el comando proto y ahora estamos importando los métodos. Si corres, ¿recibirás? debido a que el servidor Python aún no está establecido.


Failed to upload file: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing: dial tcp 127.0.0.1:50051: connect: connection refused"





  
  
  Servidor gRPC de Python


Como Python actuará como servidor, el enfoque será ligeramente diferente pero, en esencia, no se requiere el mismo archivo de protocolo aparte del campo del paquete. Comencemos creando una base main.py sin gRPC solo para dar un vistazo de cómo GPT completará las preguntas en Excel.


import os
import openai
import pandas as pd
from dotenv import load_dotenv

def get_answer_from_gpt(apikey: str, question: str):
    openai.api_key = apikey
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": question}
        ]
    )
    return response['choices'][0]['message']['content'].strip()

def answer_questions_df(df: pd.DataFrame, apikey: str):
    answers = []

    for question in df.iloc[:, 0]: 
        answer = get_answer_from_gpt(apikey, question)
        answers.append(answer)
    return answers

if __name__ == "__main__":
    load_dotenv()

    openai_api_key = os.getenv("OPENAI_API_KEY", "OpenAI API key hasn't been set.")

    df = pd.read_excel('Book1.xlsx')

    df['Answer'] = answer_questions_df(df, openai_api_key





Es un script simple que responderá las preguntas que Go nos enviará, pero el LOC es menor debido a la biblioteca openai dedicada que lo hace más fácil.


 También comenzamos agregando proto dir con el mismo archivo que el anterior; la sección de opciones se puede eliminar como se describe. Instala gRPC en tu virtualenv preferiblemente y sigue aquí la instalación para la generación de proto que ejecuté"


python3 -m grpc_tools.protoc --proto_path=proto --python_out=proto --grpc_python_out=proto proto/excel.proto




Para estar en el mismo nivel que mi directorio proto recuerda agregar __init.py!

Una vez generados los archivos, continuemos.


import io
import grpc
from proto import excel_pb2_grpc as excel_grpc
from proto import excel_pb2

class ExcelService(excel_grpc.ExcelServiceServicer):
    def UploadFile(self, request, context):
        try:
            # Convert bytes to a file-like object
            file_like_object = io.BytesIO(request.file_content)

            # Load the workbook from the file-like object
            workbook = openpyxl.load_workbook(file_like_object)

            # Access the first sheet (or use appropriate logic to get the sheet you need)
            sheet = workbook.active

            # Convert the sheet to a DataFrame
            data = sheet.values
            columns = next(data)  # Get the header row
            df = pd.DataFrame(data, columns=columns)

            print("Loaded DataFrame:")
            print(df.head())

            # Ensure that the DataFrame is not empty and has questions
            if df.empty or df.shape[1] 



Definimos el servidor y agregamos la clase ExcelService que contiene los métodos generados por el archivo proto. Debido a que recibimos el archivo por bytes, debemos usar el lector de bytes io y comenzar el procesamiento adicional del archivo y completar la segunda columna.


response = excel_pb2.FileResponse(file_content=output.read())




Al final regresaremos ☝️ para que lo reciba nuestro cliente Go.


 Sin embargo, para poder encontrar archivos proto en Python, debes definir una ruta de exportación 

exportar PYTHONPATH=$PYTHONPATH:mnt/c/own_dev/gRPC/server/proto



  
  
  Ejecutando cliente y servidor




If all is good you can run

#First comes server

python3 -m main

#Then client

go run client.go Book1.xlsx




Y deberías obtener el archivo .xlsx actualizado en el lado del cliente de Go.


  
  
  Conclusión


En este artículo exploramos los fundamentos de la configuración de la comunicación gRPC entre el servidor Python y el cliente Go. Al aprovechar gRPC, establecimos una manera perfecta de enviar un archivo de Excel desde una aplicación Go a un servidor Python, procesar el archivo usando la API GPT de OpenAI y devolver el archivo modificado al cliente Go.