gRPC ist ein leistungsstarkes, hochleistungsfähiges RPC-Framework (Remote Procedure Call), das zwar weniger häufig verwendet wird als REST, in bestimmten Szenarien jedoch erhebliche Vorteile bietet.

Darüber hinaus ist es sprachunabhängig und kann in jeder Umgebung ausgeführt werden, was es zu einer idealen Wahl für die Server-zu-Server-Kommunikation macht.

Ich werde nicht näher darauf eingehen, aber hier ist ein allgemeiner Link zu gRPC. Ich stelle eine praktische Anleitung zur Verfügung

Gehen Sie zum gRPC-Client 

Stellen wir uns vor, unser Go ist ein Client, aber ein Server wie für die Frontend-App React, Svelte usw.

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






Als Beispiel lädt das React-Frontend eine Datei hoch, Go verarbeitet sie, aber wir benötigen Antworten von Excel, wir werden die GPT-API verwenden. Während dies mit Go möglich ist, verfügt Python auf der anderen Seite über mehr Pakete, die unser Leben erleichtern können, wie langchan_openai, pandas for excel und so weiter.


Beginnen wir mit der Installation von gRPC, vorzugsweise in Ihrer virtuellen Umgebung .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"




Als nächstes sollten Sie den Protokollpuffer in Ihrem Betriebssystem installieren. Weitere Informationen finden Sie hier.

Lassen Sie uns ein Proto-Verzeichnis erstellen, in dem Sie Ihre Protokollpufferdatei speichern. Ich nenne sie excel.proto und füge Folgendes ein:


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;
}




Mit diesem gRPC-Dienst, ExcelService, können Kunden eine Datei hochladen, indem sie ihren Namen und Inhalt senden. Der Server antwortet mit demselben Dateiinhalt. 

Für Go ist es wichtig, go_package in Python zu übergeben. Die Zeile wird nicht benötigt.


vscode-proto3 ist eine gute Erweiterung zum Herunterladen, wenn Sie VSCode verwenden.


Nach all dem können Sie Ihre Proto-Dateien generieren. Ich bevorzuge sie auf derselben Ebene wie das Prot-Verzeichnis. Führen Sie dazu diesen Befehl aus:

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

Wenn erfolgreich zwei Dateien generiert werden sollen, fügen Sie optional bei vielen Anpassungen ein Makefile hinzu und definieren Sie es als oberen Proto-Befehl.


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
}




Wir stellen eine Verbindung her, um 50051 abzuhören, der unser Python-Server sein wird. &pb.FileRequest wurde zuvor mit dem Befehl proto generiert und jetzt importieren wir die Methoden. Wenn Sie laufen, erhalten Sie? da der Python-Server noch nicht eingerichtet ist.


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"





  
  
  Python-gRPC-Server


Da Python als Server fungiert, wird der Ansatz etwas anders sein, aber im Wesentlichen ist nicht dieselbe Proto-Datei außer dem Paketfeld erforderlich. Beginnen wir mit der Erstellung einer Basis main.py ohne gRPC, um einen Eindruck davon zu geben, wie GPT die Fragen in Excel ausfüllt.


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 ist ein einfaches Skript, das Fragen beantwortet, die Go uns sendet, aber der LOC ist aufgrund der dedizierten OpenAI-Bibliothek geringer, was es einfacher macht.


Wir beginnen auch damit, das Proto-Verzeichnis mit derselben Datei wie oben hinzuzufügen. Der Optionsabschnitt kann wie besprochen entfernt werden. Installieren Sie gRPC vorzugsweise in Ihrer virtuellen Umgebung und folgen Sie hier der Installation für die Proto-Generation, die ich ausgeführt habe.“


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




Um in derselben Ebene wie mein Proto-Verzeichnis zu sein denken Sie daran, __init.py hinzuzufügen!

Sobald die Dateien generiert wurden, können wir fortfahren.


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] 



Wir definieren den Server und fügen die ExcelService-Klasse hinzu, die die von der Protodatei generierten Methoden enthält. Da wir die Datei byteweise empfangen, müssen wir den IO-Byte-Reader verwenden und mit der weiteren Verarbeitung der Datei beginnen und die zweite Spalte füllen.


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




Am Ende kehren wir ☝️ zurück, damit unser Go-Kunde es erhalten kann.


Um Protodateien in Python finden zu können, sollten Sie jedoch einen Exportpfad definieren

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



  
  
  Client und Server ausführen




If all is good you can run

#First comes server

python3 -m main

#Then client

go run client.go Book1.xlsx




Und Sie sollten die aktualisierte XLSX-Datei auf der Go-Clientseite erhalten.


  
  
  Abschluss


In diesem Artikel haben wir die Grundlagen der Einrichtung der gRPC-Kommunikation zwischen Python-Server und Go-Client untersucht. Durch die Nutzung von gRPC haben wir eine nahtlose Möglichkeit geschaffen, eine Excel-Datei von einer Go-Anwendung an einen Python-Server zu senden, die Datei mithilfe der GPT-API von OpenAI zu verarbeiten und die geänderte Datei an den Go-Client zurückzugeben.