Golang GRPC

In diesem Tutorial werden wir untersuchen, wie man mit GRPC arbeitet, indem wir einen Echo -GRPC -Client und Server erstellen.

Was ist GRPC?

GRPC ist ein Hochleistungs-Remote-Prozedur-Aufruf-Framework, mit dem Entwickler Dienste über Systeme hinweg verbinden können. Mit GRPC können die Client- und Server -Apps einwandfrei kommunizieren.

Einfach ausgedrückt ermöglicht GRPC eine Client -Anwendung, auf eine Serveranwendung (auch in Remote -Maschinen) Methoden zuzugreifen und zu verwenden, als ob sie in derselben Anwendung definiert wäre. Es ist ein wichtiger Baustein für Microservices.

Anforderungen

Um diesem Tutorial zu folgen, müssen Sie:

Die neueste Version des Go -Compilers.
Protokollpuffer Compiler (Protoc) Version 3
Gehen Sie Plugins für die Arbeit mit Protokollpuffern.

Führen Sie den Befehl wie unten angegeben aus

Installieren Sie Google.Golang.org/protobuf/cmd/protoc-gen-go@
Installieren Sie Google.Golang.org/grpc/cmd/protoc-gen-go-grpc@neuest

Der nächste Schritt besteht darin, Ihren Pfad zu aktualisieren, damit Sie die Protoc -Befehle verwenden können:

Exportpfad = "$ path: $ (go eng gopath)/bin"

Golang GRPC Server

Für dieses Tutorial erstellen wir einen einfachen GRPC.

Erstellen Sie zunächst ein Arbeitsverzeichnis:

Mkdir GRPC-TUT
CD GRPC-TUT

Erstellen Sie als nächstes einen Server.GO -Datei, die den Code für den GRPC -Server enthält:

Berührungsserver.gehen

Öffnen Sie die Datei mit Ihrem Texteditor und fügen Sie die folgenden Zeilen hinzu:

Paket Main
importieren (
"Protokoll"
"Netz"
)

Im vorherigen Code importieren wir die Protokoll- und Netzpakete, mit denen wir Fehler protokollieren und einen Hörer mit dem Nettopaket festlegen können.

Als nächstes richten wir die Hauptfunktion ein und erstellen einen Hörer auf Port 9001/TCP:

func main ()
Hörer, ERR: = NET.Hören Sie ("TCP", ": 9001")
Wenn er irrt != nil
Protokoll.Tödlich (arr)

Der nächste Schritt besteht darin, das GRPC -Paket für das GO -Programm zu importieren. Auf diese Weise können wir einen GRPC -Server und die Endpunkte einrichten, die wir bedienen möchten, bevor wir ihn mit dem Hörer auf TCP verbinden.

importieren "Google.Golang.org/grpc "

Zurück in der Hauptfunktion können wir einen GRPC -Server erstellen, wie im folgenden Code gezeigt:

Grpserver: = GRPC.TAWERVER ()
Wenn er: = grpServer.Dienen (Zuhörer); irren != nil
Protokoll.Tödlich (arr)

Wir erstellen einen GRPC -Server mit der Methode der Newserver () im vorherigen Code. Wir bedienen dann den Server über den zuvor erstellten TCP -Listener, den wir zuvor erstellt haben.

Und damit haben wir einen GRPC -Server. Es tut jedoch nicht viel. Wir können dies erweitern, indem wir eine einfache Echo -Anwendung erstellen.

Die Bewerbung empfängt die Nachricht vom Client und gibt dieselbe Nachricht an den Client zurück.

Echo -Proto -Datei

Um unsere Echo -Anwendung einzurichten, müssen wir eine erstellen .Protodatei. Die Proto -Datei enthält die Definitionen für die Anwendung.

Touch Echo.Proto

Der erste Eintrag in der Proto -Datei ist die Paketerklärung. Dies verhindert Namenskollisionen in anderen Anwendungen.

syntax = "proto3";
Paket -Echo;
Option Go_Package = "./Echo";

Sie können den Namen ändern, um den Namen Ihres Pakets widerzuspiegeln.

Sobald wir die Paketerklärung haben, müssen wir Nachrichtendefinitionen hinzufügen. Dies definiert einen Container oder eine Struktur der Nachricht, die von den Clients empfangen wird:

Nachrichtennachricht
String Body = 1;

Als nächstes müssen wir den Dienst definieren. In unserem Beispiel nennen wir den Dienst als EchoService wie gezeigt:

Service EchoService
rpc echo (message) gibt (message) zurück

Der Dienst definiert eine Methode, die ein GRPC -Client anruft. Die Methode nimmt einfach die Nachricht und gibt die Nachricht zurück. Dies schafft eine Echo -Anwendung.

Zusammenstellung der Protokollpuffer

Jetzt haben wir den Proto für unsere Anwendung definiert. Als nächstes müssen wir die Klassen generieren, mit denen wir Daten mit der Go -Programmiersprache lesen und schreiben werden.

Wir können dies mit dem Protokollpuffer Compiler tun:

Protoc --go_out =./echo --go-grpc_out =./echo --go-grpc_opt = required_unimplemented_servers = false echo.Proto

Die vorherigen Befehle sollten den GO -Code generieren, der zum Registrieren und Rufen des GRPC -Servers erforderlich ist.

Der nächste Schritt besteht darin, das RPC für die Echo -Methode zu definieren. Wir können dies tun, indem wir eine Go -Datei im Echo -Verzeichnis erstellen wie:

Touch Echo.gehen

Fügen Sie in der Datei den Code wie gezeigt hinzu:

Paket echo
importieren (
"fmt"
"Golang.org/x/net/context "// Anforderungskontext abrufen
)
Geben Sie Serverstruct ein

Func (S *Server) Echo (CTX -Kontext.Kontext, Nachricht *Nachricht) ( *Nachricht, Fehler)
fmt.Printf ("Nachricht erhalten: %s", Nachricht.Körper)
Rückkehr & Nachricht Body: "Hallo zurück!", nil

Der nächste Schritt besteht darin, den Code in das Echo -Paket zu importieren. Gehen Sie zurück zum Server.GO -Datei und fügen Sie die folgende Importklausel hinzu:

Importieren "GRPC/Echo"

Sie müssen den Go -Modulmanager für Ihr Projekt initialisieren.

Fügen Sie in der Hauptserverdatei die folgenden Zeilen hinzu, um einen neuen Chat -Server zu erstellen und zu registrieren:

S: = Echo.Server
Echo.RegisterechoServiceServer (GrpServer usw.)

Und damit haben wir den Code für den GRPC -Server aus dem Weg.

GRPC -Client

Der nächste Schritt besteht darin, einen Client zu erstellen, der mit dem GRPC -Server interagieren kann. Beginnen Sie mit dem Erstellen eines Datei -Clients.in das Hauptverzeichnis gehen.

berühren ./Klient.gehen

Beginnen wir mit unseren Importen. Für diesen benötigen wir die Pakete für Protokoll-, Kontext-, Echo- und GRPC -Pakete

importieren (
"Protokoll"
"Golang.org/x/net/context "
"Google.Golang.org/grpc "
"GRPC/Echo"
)

Beginnen wir als nächstes mit der Hauptfunktion:

func main ()
// Zeiger auf GRPC Conn
var conn *grpc.ClientConn
// eine Verbindung zum GRPC -Server herstellen (unsichere Verbindung)
Conn, ERR: = GRPC.Zifferblatt (": 9001", GRPC.Withinsecure ())
Wenn er irrt != nil
Protokoll.Tödlich (arr)

// Conn schließen
Verschiebung Conn.Schließen()
// Echo Service Client
E: = Echo.NeweChoServiceClient (Conn)
// Nachrichtentext
Nachricht: = Echo.Nachricht
Körper: "Hallo",

resp, arr: = e.Echo (Kontext.Hintergrund (), & Nachricht)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

fmt.Printf ("%s", resp.Körper)

Der vorherige Code implementiert einen GRPC -Client, der die Meldung "Hallo" sendet und "Hallo zurück" vom Server erhält.

Testen

Führen Sie den Server nach Abschluss aus.Gehen Sie und Kunde.gehen. Wenn er erfolgreich ist, sollte der Server wie unten gezeigt mit „Hi zurück“ antworten:

Sie haben erfolgreich einen GRPC -Server und einen Client in Go erstellt.

Abschluss

Dieser Leitfaden dient als absolute Grund für die Implementierung von GRPC in Go. Wenn Sie bei GRPC und Protobufs neu sind, kann es Zeit dauern, die Implementierung zu erfassen. Mit einigen Praktiken und Implementierungen sind Sie jedoch in der Lage, komplexe GRPC -Dienste zu erstellen. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Tutorials finden Sie in anderen Linux -Artikeln.