So implementieren Sie die RPC-Schnittstelle mit Go

In den letzten Jahren hat Remote Procedure Call (RPC) mit der rasanten Entwicklung der Internet-Technologie und dem Aufstieg des Cloud Computing immer mehr Aufmerksamkeit bei Entwicklern auf sich gezogen. Die Go-Sprache selbst ist leichtgewichtig und mit umfassender Bibliotheks- und Framework-Unterstützung können RPC-Dienste problemlos implementiert werden. In diesem Artikel stellen wir vor, wie man RPC-Schnittstellen mit Go implementiert.

1. Überblick über RPC

RPC (Remote Procedure Call) oder Remote Procedure Call ist ein Protokoll, das es verschiedenen Prozessen oder Computern ermöglicht, miteinander zu kommunizieren und Funktionen oder Methoden auf anderen Prozessen oder Maschinen aufzurufen. Das Grundprinzip von RPC besteht darin, den Aufruf einer Funktion oder Methode in einen Netzwerkkommunikationsprozess zu kapseln, sodass der Verbraucher (Aufrufer) Dienste auf dem Remote-Computer wie bei einem lokalen Aufruf aufrufen kann.

Zu den gängigen RPC-Frameworks gehören derzeit gRPC, Thrift, Dubbo usw. Unter anderem ist gRPC ein leistungsstarkes RPC-Framework, das auf HTTP/2 Open Source von Google basiert und mehrere Programmiersprachen unterstützt, darunter C++, Java, Python, Go usw. gRPC verwendet Protokollpuffer als Serialisierungsprotokoll, mit denen leistungsstarke, skalierbare verteilte Anwendungen wie verteilte Systeme und Mikrodienste erstellt werden können.

2. Verwenden Sie Go, um die RPC-Schnittstelle zu implementieren.

1. Abhängigkeiten installieren und herunterladen.

Bevor Sie Go zum Implementieren der RPC-Schnittstelle verwenden, müssen Sie die Go-Entwicklungsumgebung und die RPC-Framework-Unterstützung installieren. Hier entscheiden wir uns für die Verwendung des gRPC-Frameworks.

Zuerst müssen wir das gRPC Go-Sprach-Plug-in und das Protobuf-Tool installieren:

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

Nach Abschluss der Installation können wir protobuf2.0 oder höher verwenden, um eine .proto-Datei zu schreiben, um den Dienst und die Nachrichtenstruktur zu beschreiben. Zum Beispiel schreiben wir eine einfache .proto-Datei:

syntax = "proto3";

package helloworld;

// 定义 HelloService
service HelloService {
  // 定义 SayHello 方法
  rpc SayHello (HelloRequest) returns (HelloResponse) {}
}

// 定义入参结构体: HelloRequest
message HelloRequest {
  string name = 1;
}

// 定义出参结构体: HelloResponse
message HelloResponse {
  string message = 1;
}

2. Code generieren

Wir können den folgenden Befehl verwenden, um Go-Code basierend auf der .proto-Datei zu generieren:

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

Nachdem wir den obigen Befehl ausgeführt haben, können wir den erhalten entsprechende Go-Codedatei, zum Beispiel:

syntax = "proto3";

package helloworld;

// 定义 HelloService
service HelloService {
  // 定义 SayHello 方法
  rpc SayHello (HelloRequest) returns (HelloResponse) {}
}

// 定义入参结构体: HelloRequest
message HelloRequest {
  string name = 1;
}

// 定义出参结构体: HelloResponse
message HelloResponse {
  string message = 1;
}

3. Implementierung des Servers

Als nächstes müssen wir einen Server implementieren. Zuerst müssen wir eine HelloServiceImpl-Struktur definieren, um die obige HelloService-Schnittstelle zu implementieren:

package main

import (
  "context"
  pb "github.com/user/helloworld"
)

type HelloServiceImpl struct {
}

func (s *HelloServiceImpl) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloResponse, error) {
  return &pb.HelloResponse{Message: "Hello, " + req.Name + "!"}, nil
}

Im obigen Code definieren wir eine HelloServiceImpl-Struktur und implementieren die SayHello-Methode in der HelloService-Schnittstelle. Diese Methode empfängt als Parameter ein Kontextobjekt und ein HelloRequest-Objekt und gibt als Ergebnis ein HelloResponse-Objekt zurück. Unter diesen ist ctx das Kontextobjekt, das zur Steuerung des Anforderungsprozesses verwendet wird. req ist ein HelloRequest-Objekt, das die Anforderungsparameter beim Aufruf der SayHello-Methode enthält.

Als nächstes müssen wir einen gRPC-Server erstellen und das HelloServiceImpl-Objekt beim Server registrieren:

package main

import (
  "log"
  "net"
  pb "github.com/user/helloworld"
  "google.golang.org/grpc"
)

func main() {
  listenPort, err := net.Listen("tcp", ":4300")
  if err != nil {
    log.Fatalf("failed to listen: %v", err)
  }

  grpcServer := grpc.NewServer()

  // 注册服务实现
  pb.RegisterHelloServiceServer(grpcServer, &HelloServiceImpl{})

  // 启动服务
  if err := grpcServer.Serve(listenPort); err != nil {
    log.Fatalf("failed to serve: %v", err)
  }
}

Im obigen Code definieren wir zuerst einen Überwachungsport, erstellen dann einen gRPC-Server und registrieren das HelloServiceImpl-Objekt auf der Dienstseite. Schließlich starten wir den gRPC-Dienst und warten auf HTTP2-Anfragen.

4. Implementieren des Clients

Da wir nun einen gRPC-Server implementiert haben, müssen wir als Nächstes einen gRPC-Client implementieren. In Go können wir auf den gRPC-Server zugreifen, indem wir die entsprechende Client-Methode aufrufen. Beispielsweise können wir eine Client-Datei mit dem Namen „main“ erstellen und den folgenden Code implementieren:

package main

import (
  "context"
  "log"
  "os"
  "time"

  pb "github.com/user/helloworld"
  "google.golang.org/grpc"
)

func main() {
  // 连接服务器
  conn, err := grpc.Dial(":4300", grpc.WithInsecure(), grpc.WithTimeout(5*time.Second))
  if err != nil {
    log.Fatalf("Failed to connect: %v", err)
  }
  defer conn.Close()

  // 创建客户端
  c := pb.NewHelloServiceClient(conn)

  // 组装请求参数
  name := "go grpc"
  req := &pb.HelloRequest{Name: name}

  // 调用 SayHello 方法
  resp, err := c.SayHello(context.Background(), req)
  if err != nil {
    log.Fatalf("[ERROR] SayHello err: %v
", err)
    os.Exit(1)
  }
  log.Printf("[INFO] SayHello resp: %s
", resp.Message)
}

Im obigen Code erstellen wir zunächst eine gRPC-Verbindung und stellen eine Verbindung zum Server her, erstellen dann ein HelloServiceClient-Objekt und stellen die Anforderungsparameter zusammen. Abschließend rufen wir die SayHello-Methode auf und geben die Antwort aus. Nachdem der obige Code ausgeführt wurde, können wir das Ausgabeergebnis sehen:

INFO: SayHello resp: "Hello, go grpc!"

5. Führen Sie den Dienst aus

Abschließend müssen wir die Server- und Client-Codes kompilieren und dann den Dienst starten. Sie können die folgenden Schritte ausführen:

$ cd $GOPATH/src/github.com/user/helloworld
$ go run serve/main.go  // 启动gRPC服务端
$ go run client/main.go  // 启动gRPC客户端

Wenn alles gut geht, können wir die Client-Ausgabe sehen: „Hello, go grpc!“.

3. Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie man Go zur Implementierung der RPC-Schnittstelle verwendet. Darunter haben wir das klassische gRPC-Framework verwendet und ein einfaches Hello World-Beispiel implementiert. Es ist erwähnenswert, dass Go neben gRPC auch über viele andere RPC-Frameworks verfügt, darunter Thrift, Dubbo und JSON-RPC usw., und Entwickler können flexibel entsprechend den tatsächlichen Anforderungen wählen.

Bei Verwendung des RPC-Frameworks müssen wir das geeignete Serialisierungsprotokoll und Übertragungsprotokoll basierend auf den tatsächlichen Anforderungen auswählen. Normalerweise empfehlen wir die Verwendung von Protokollpuffern und dem HTTP/2-Protokoll, um effiziente RPC-Aufrufe zu implementieren und den Anforderungen großer verteilter Systeme gerecht zu werden.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die RPC-Schnittstelle mit Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!