gRPC é uma estrutura de chamada de procedimento remoto (RPC) poderosa e de alto desempenho que, apesar de ser menos usada que REST, oferece vantagens significativas em determinados cenários.

Além disso, é independente de linguagem e pode ser executado em qualquer ambiente, o que o torna a escolha ideal para comunicação entre servidores.

Não vou me aprofundar na explicação completa disso, mas aqui está um link geral do gRPC. Vou fornecer um tutorial prático

Cliente gRPC 

Vamos imaginar que nosso Go é cliente, mas é um servidor para o aplicativo frontend React, Svelte etc.

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






Como exemplo, o frontend do React carrega um arquivo, vá processá-lo, mas precisamos de respostas do Excel, usaremos a API GPT. Embora isso possa ser feito com Go, o Python, por outro lado, tem mais pacotes que podem facilitar nossas vidas, como langchan_openai, pandas para Excel e assim por diante.


Vamos começar com a instalação do gRPC de preferência em seu 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"




Em seguida, você deve instalar o buffer de protocolo em seu sistema operacional, siga-o aqui.

Vamos criar um diretório proto onde você armazenará seu arquivo de buffer de protocolo. Vou nomeá-lo como excel.proto e colar isto:


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 serviço gRPC, ExcelService, permite que os clientes carreguem um arquivo enviando seu nome e conteúdo. O servidor responde com o mesmo conteúdo do arquivo. 

Para Go é essencial passar go_package em Python a linha não é necessária.


vscode-proto3 é uma boa extensão para download se você usar VSCode.


Depois de tudo isso você pode gerar seus arquivos proto, prefiro-os no mesmo nível do diretório prot, para isso execute este comando:

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative proto/excel.proto

Se dois arquivos forem gerados com sucesso, opcionalmente, se houver muitos ajustes, adicione um Makefile e defina-o como comando proto superior.


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
}




Fazemos uma conexão para escutar 50051 que será nosso servidor Python, &pb.FileRequest foi gerado anteriormente usando o comando proto e agora estamos importando os métodos. Se você correr você receberá? devido ao servidor Python ainda não estabelecido.


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 Python gRPC


Como o python atuará como um servidor, a abordagem será um pouco diferente, mas, em essência, o mesmo arquivo proto separado do campo do pacote não é necessário. Vamos começar criando uma base main.py sem o gRPC apenas para dar uma ideia de como o GPT preencherá as perguntas no 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





É um script simples que responderá às perguntas que Go nos enviará, mas o LOC é menor devido à biblioteca openai dedicada que torna isso mais fácil.


 Começamos adicionando também proto dir com o mesmo arquivo acima, a seção de opções pode ser removida conforme discutido. Instale o gRPC no seu virtualenv de preferência e siga aqui a instalação para geração do proto que executei"


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




Para estar no mesmo nível do meu diretório proto lembre-se de adicionar __init.py!

Os arquivos foram gerados, vamos continuar.


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 o servidor e adicionamos a classe ExcelService que contém os métodos gerados pelo arquivo proto. Como recebemos o arquivo por bytes, precisamos usar o leitor de bytes io e iniciar o processamento adicional do arquivo e preencher a segunda coluna.

resposta = excel_pb2.FileResponse(file_content=output.read())
response = excel_pb2.FileResponse(file_content=output.read())
No final estamos retornando ☝️ para nosso cliente Go receber.



Para poder encontrar arquivos proto em python, você deve definir um caminho de exportação


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



  
  
  Executando cliente e servidor




Se tudo estiver bem, você pode correr

#Primeiro vem o servidor

python3 -m principal

#Então cliente

vá executar client.go Book1.xlsx
response = excel_pb2.FileResponse(file_content=output.read())
E você deve obter o arquivo .xlsx atualizado no lado do cliente Go.



  
  
  Conclusão


Neste artigo, exploramos os fundamentos da configuração da comunicação gRPC entre o servidor Python e o cliente Go. Ao aproveitar o gRPC, estabelecemos uma maneira perfeita de enviar um arquivo Excel de um aplicativo Go para um servidor Python, processar o arquivo usando a API GPT da OpenAI e retornar o arquivo modificado de volta ao cliente Go.