grpc golang-Bereitstellung

gRPC ist Googles Open-Source-Hochleistungs-RPC-Framework (Remote Procedure Call), das mehrere Sprachen unterstützt, einschließlich Golang. In Golang ist gRPC-Code sehr einfach zu schreiben und zu verwenden, kann jedoch bei der tatsächlichen Bereitstellung auf einige Herausforderungen stoßen.

In diesem Artikel wird erläutert, wie Sie gRPC in Golang verwenden und auf dem Server bereitstellen.

1. gRPC installieren

In Golang müssen Sie gRPC und verwandte Protobuf-Bibliotheken installieren. Sie können den folgenden Befehl verwenden, um gRPC- und Protobuf-Bibliotheken zu installieren:

$ go get -u google.golang.org/grpc
$ go get -u github.com/golang/protobuf/{proto,protoc-gen-go}

2. Protodatei definieren

In gRPC müssen Sie ein Proto definieren Datei, um den gewünschten Dienst zu beschreiben. Beispielsweise möchten Sie möglicherweise einen Echo-Dienst definieren, der eine Nachricht akzeptiert und an den Client zurückgibt.

Das Folgende ist ein Beispiel einer Protodatei für einen einfachen Echo-Dienst:

syntax = "proto3";

option go_package = "echo";

service EchoService {
  rpc Echo (EchoMessage) returns (EchoMessage);
}

message EchoMessage {
  string message = 1;
}

In diesem Beispiel definieren wir einen Echo-Dienst, der einen EchoMessage-Nachrichtentyp hat, der Enthält eine Nachrichtenzeichenfolge und eine Echo-Methode, die eine EchoMessage-Nachricht akzeptiert und die Nachricht als Antwort zurückgibt.

3. Golang-Code generieren

Sobald Sie eine Protodatei definiert haben, können Sie den Protobuf-Compiler verwenden, um den entsprechenden Golang-Code zu generieren. Um Golang-Code zu generieren, müssen Sie den folgenden Befehl ausführen:

$ protoc --go_out=. echo.proto

Dadurch wird eine Datei namens echo.pb.go generiert, die den Code für Ihren Echo-Dienst enthält.

4. Implementieren des Dienstes

Als nächstes müssen Sie Ihren Echo-Dienst implementieren. In Ihrem Echo-Dienst müssen Sie die Echo-Methode implementieren, um die EchoMessage-Nachricht zu empfangen und an den Client zurückzusenden.

Das Folgende ist ein einfaches Beispiel für die Implementierung eines Echo-Dienstes:

type server struct{}

func (s *server) Echo(ctx context.Context, message *EchoMessage) (*EchoMessage, error) {
  return &EchoMessage{
    Message: message.Message,
  }, nil
}

func main() {
  s := grpc.NewServer()
  RegisterEchoServiceServer(s, &server{})
  lis, err := net.Listen("tcp", ":50051")
  if err != nil {
    log.Fatalf("failed to listen: %v", err)
  }
  if err := s.Serve(lis); err != nil {
    log.Fatalf("failed to serve: %v", err)
  }
}

In diesem Beispiel implementieren wir einen Servertyp, der eine Echo-Methode enthält. Wenn der Client die Echo-Methode aufruft, gibt er die empfangene Nachricht zurück.

Wir erstellen außerdem einen gRPC-Server in der Hauptfunktion und übergeben unsere Implementierung an die Registrierungsfunktion RegisterEchoServiceServer. Dann beginnen wir mit dem Abhören von Port 50051 und starten den Server.

5. Kompilieren und bereitstellen

Nach Abschluss der Implementierung des gRPC-Dienstes müssen Sie ihn kompilieren und auf dem Server bereitstellen. Sie können den folgenden Befehl verwenden, um Ihren Code zu kompilieren:

$ go build .

Dadurch wird eine ausführbare Datei erstellt, die Sie auf Ihrem Server bereitstellen können. Auf Ihrem Server können Sie den folgenden Befehl ausführen, um Ihren gRPC-Dienst zu starten:

$ ./your-program

In diesem Beispiel lautet der Name Ihres Programms „Ihr-Programm“. Beachten Sie, dass Sie vor der Ausführung Ihres Programms sicherstellen müssen, dass Ihr Server auf Port 50051 zugreifen kann.

6. Testen Sie den Code

Nach Abschluss der Bereitstellung können Sie Ihren Code mit dem gRPC-Client testen. Sie können den gRPC-Client mit dem folgenden Befehl installieren:

$ go get -u google.golang.org/grpc/cmd/protoc-gen-go-grpc

Um den gRPC-Client zu verwenden, müssen Sie eine Verbindung erstellen und diese Verbindung dann verwenden, um Ihren Echo-Dienst aufzurufen.

Hier ist ein einfaches gRPC-Client-Beispiel:

func main() {
  conn, err := grpc.Dial(":50051", grpc.WithInsecure())
  if err != nil {
    log.Fatalf("did not connect: %v", err)
  }
  defer conn.Close()

  c := NewEchoServiceClient(conn)
  message := &EchoMessage{Message: "hello world"}
  res, err := c.Echo(context.Background(), message)
  if err != nil {
    log.Fatalf("echo failed: %v", err)
  }
  log.Printf("echo response: %s", res.Message)
}

In diesem Beispiel erstellen wir eine Verbindung und verwenden diese Verbindung dann, um unseren Echo-Dienst aufzurufen. Wir haben eine EchoMessage-Nachricht weitergeleitet und dann getestet, ob unser Code ordnungsgemäß funktioniert, indem wir die Serverantwort ausgedruckt haben.

7. Fazit

gRPC ist ein effizientes RPC-Framework. Es wird sehr einfach sein, es in Golang zu verwenden, aber es kann während der Zeit schwierig sein Der eigentliche Bereitstellungsprozess ist auf einige Herausforderungen gestoßen. In diesem Artikel wird beschrieben, wie Sie gRPC und zugehörige Protobuf-Bibliotheken installieren, Protodateien definieren und Golang-Code generieren. Wir haben auch gezeigt, wie der Echo-Dienst implementiert und auf dem Server bereitgestellt wird. Abschließend haben wir auch demonstriert, wie man den gRPC-Client zum Testen des Codes verwendet.

Das obige ist der detaillierte Inhalt vongrpc golang-Bereitstellung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!