Wie verwende ich GRPC in Go?

Mit der kontinuierlichen Weiterentwicklung moderner Anwendungen werden auch die Anforderungen an hohe Leistung und Skalierbarkeit immer höher. Daher gibt es eine verteilte Architektur auf Basis des RPC-Protokolls, um diese Anforderungen zu erfüllen. GRPC ist ein Open-Source-Framework, das auf Googles internem StuB basiert. GRPC bietet einen hoch skalierbaren Mechanismus für die Kommunikation zwischen Programmiersprachen, der darauf ausgelegt ist, die standardisierte Kommunikation zwischen Anwendungen effizient zu verwalten.

In diesem Artikel wird die Verwendung von GRPC in Go vorgestellt. Wir behandeln das Konzept von GRPC, die Schritte zur Kommunikation mithilfe von GRPC und ein Beispiel für die Implementierung eines einfachen GRPC-Dienstes in Go.

Das Konzept von GRPC

GRPC ist ein RPC-Framework, das auf HTTP/2 basiert und Protobuf als Standardmethode für die Datenserialisierung verwendet. Dies bedeutet, dass die Kommunikation zwischen verschiedenen Sprachen problemlos ermöglicht werden kann (unter Nutzung des von grpc bereitgestellten generierten Codes und der Middleware).

Skalierbarkeit: GRPC kann einfache und komplexe Authentifizierungs- und Autorisierungslogik auf der Code-Stream- und Verbindungsebene implementieren und mit modernen Computerplattformen wie Kubernetes zusammenarbeiten.

Kommunikation mit GRPC

In diesem Abschnitt stellen wir die detaillierten Schritte für die Kommunikation mit GRPC vor. In diesem Artikel implementieren wir einen einfachen GRPC-Dienst mithilfe der Go-Sprache.

Schritt 1: Protobuf-Datei definieren

Zuerst müssen wir unsere Protobuf-Datei definieren, um unsere Schnittstelle zu deklarieren. In diesem Beispiel definieren wir einen einfachen Dienst, der zwei Zahlen addiert. Das Folgende ist der Inhalt unserer .proto-Datei:

syntax = "proto3";

option go_package = ".;main";

package calculator;

message AddRequest {
    int32 x = 1;
    int32 y = 2;
}

message AddResponse {
    int32 result = 1;
}

service Calculator {
    rpc Add(AddRequest) returns (AddResponse);
}

In dieser Protobuf-Datei definieren wir zwei Nachrichten, AddRequest und AddResponse, sowie einen Service-Interface-Rechner, der eine Add-Methode bereitstellt. Die Methode empfängt zwei Zahlen als Parameter und gibt deren Summe zurück.

Schritt 2: GO-Code generieren

Als nächstes müssen wir das Protoc-Tool verwenden, um GO-Code zu generieren. Wir können Code auf folgende Weise generieren:

protoc --go_out=plugins=grpc:. *.proto

Dieser Befehl generiert eine Rechner.pb.go-Datei, die den GO-Code für die von uns definierten Dienste und Nachrichten enthält.

Schritt 3: Serverseitig implementieren

Auf der Serverseite müssen wir einen Dienst für die von uns definierte Schnittstelle implementieren. In unserem Beispiel ist unser Dienst nur ein einfacher Additionsdienst, der zwei Zahlen addiert und deren Summe zurückgibt. Das Folgende ist unser Servercode:

package main

import (
    "context"
    "net"
    "google.golang.org/grpc"
    pb "github.com/calculator"
)

type server struct{}

func (s *server) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
    result := req.X + req.Y
    return &pb.AddResponse{Result:result}, nil
}

func main() {
    l, err := net.Listen("tcp", ":8080")
    if err != nil {
        panic(err)
    }
    s := grpc.NewServer()

    pb.RegisterCalculatorServer(s, &server{})

    err = s.Serve(l)
    if err != nil {
        panic(err)
    }
}

Wir definieren zunächst eine Struktur mit dem Namen „server“ und fügen ihr eine Add-Methode hinzu. Diese Methode empfängt zwei Zahlen x und y, berechnet ihre Summe und gibt eine AddResponse als Antwortobjekt zurück.

Wir definieren außerdem eine Hauptfunktion, in der wir einen neuen grpc-Dienst erstellen und ihn an die lokale Adresse von Port 8080 binden. Wir injizieren auch den von uns definierten Dienst in den Grpc-Server und starten den Grpc-Server.

Schritt 4: Implementieren Sie den Client

Zuletzt müssen wir einen Clientcode schreiben, der Anfragen an unseren Server senden und Antworten empfangen kann. Bitte beachten Sie, dass die .proto-Dateien im client- und serverseitigen Code übereinstimmen müssen. Unten ist unser Client-Code:

package main

import (
    "context"
    "fmt"
    "google.golang.org/grpc"
    pb "github.com/calculator"
)

func main() {
    conn, err := grpc.Dial(":8080", grpc.WithInsecure())
    if err != nil {
        panic(err)
    }

    client := pb.NewCalculatorClient(conn)

    req := pb.AddRequest{X:2, Y:3}
    resp, err := client.Add(context.Background(), &req)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Result: %d", resp.Result)
}

In diesem Client-Code erstellen wir zunächst eine Verbindung zum GRPC-Server und verwenden diese Verbindung dann, um einen neuen Client zu erstellen. Als nächstes erstellen wir eine AddRequest, setzen ihre Werte auf 2 und 3 und senden die Anfrage an den Server. Schließlich empfangen und drucken wir die Antwort des Servers.

So führen Sie den Beispielcode aus

Um unseren Beispielcode auszuführen, müssen wir zunächst die Go-Entwicklungsumgebung einrichten und zugehörige Abhängigkeiten installieren. Angenommen, unser Codepaket heißt main. Um unseren Beispielcode lokal auszuführen, müssen Sie zunächst den folgenden Befehl ausführen:

go get -u google.golang.org/grpc
go get -u github.com/golang/protobuf/protoc-gen-go

Als nächstes führen Sie den protoc-Befehl aus, um Go-Code zu generieren:

protoc --go_out=plugins=grpc:. *.proto

Kompilieren Sie dann unseren Service und Client Code eingeben und separat starten:

go build server.go
go build client.go
./server
./client

Wenn alles gut geht, sendet der Client eine Hinzufügungsanforderung an den GRPC-Server und zeigt das Ergebnis als 5 an.

Fazit

In diesem Artikel wird die Verwendung von GRPC in der Go-Sprache vorgestellt. Wir haben zunächst das Konzept von GRPC besprochen und dann gezeigt, wie man Protobuf zum Definieren von Schnittstellenspezifikationen verwendet, wie man GO-Code generiert und wie man einen einfachen GRPC-Dienst implementiert. Mit diesen Schritten können Sie mit der Verwendung von GRPC in Go beginnen, um leistungsstarke und skalierbare verteilte Systeme zu implementieren.

Das obige ist der detaillierte Inhalt vonWie verwende ich GRPC in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!