gRPC-Kommunikation

1. Einführung in gRPC

gRPC ist ein leistungsstarkes Open-Source- und allgemeines RPC-Framework (Remote Procedure Call), Open Source, das von Google verwaltet wird. Es verwendet Protokollpuffer (protobuf) als Schnittstellendefinitionssprache (IDL), um plattform- und sprachübergreifende RPC-Aufrufunterstützung bereitzustellen. gRPC hat die folgenden Eigenschaften:

1. Hohe Leistung : Mithilfe des HTTP/2-Protokolls, das Funktionen wie Multiplexing und Flusskontrolle unterstützt, können große Datenmengen effizient zwischen dem Client und dem Server übertragen werden. Gleichzeitig nutzt gRPC auch plattformoptimierte Serialisierungs- und Deserialisierungstechnologien, um die Kommunikationseffizienz zu verbessern.
2. Einfach und benutzerfreundlich : Die IDL-Sprache von gRPC ist einfach und leicht zu verstehen und bietet außerdem Tools zum automatischen Generieren von Code, um die Benutzerentwicklung zu erleichtern. Benutzer müssen nur die IDL definieren und Code generieren, um Remote-Prozeduraufrufe im Code auf ähnliche Weise wie lokale Funktionsaufrufe durchzuführen.
3. Mehrsprachige Unterstützung : gRPC unterstützt mehrere Programmiersprachen wie C++, Java, Python, Go, Ruby usw. und kann RPC-Aufrufe zwischen verschiedenen Programmiersprachen durchführen.
4. Skalierbarkeit : gRPC unterstützt verschiedene Erweiterungen, einschließlich Interceptors, Lastausgleich, Authentifizierung und Autorisierung usw., um den Anforderungen verschiedener Szenarien gerecht zu werden.
5. Sicherheit : gRPC unterstützt die sichere SSL/TLS-Übertragung und bietet außerdem einen tokenbasierten Authentifizierungsmechanismus, um die Kommunikationssicherheit zu gewährleisten.

Kurz gesagt bietet gRPC ein effizientes, skalierbares, mehrsprachiges und sicheres RPC-Framework, das für die Kommunikation zwischen Diensten in großen verteilten Systemen wie der Microservice-Architektur geeignet ist.

Dieser Artikel dient als Beispiel, um die Verwendung von gRPC zum Entwickeln eines einfachen Dienstes vorzustellen.

2. Vorbereitung

2.1 Protokoll installieren

Entpacken Sie die vorkompilierte Version des Protokolls, die dem Github-/usr/local/ System entspricht, wie folgt. Am Beispiel von Version 22.3 lauten die spezifischen Vorgänge wie folgt:

wget https://github.com/protocolbuffers/protobuf/releases/download/v22.3/protoc-22.3-linux-x86_64.zip
unzip protoc-22.3-linux-x86_64.zip -d /usr/local/
ldconfig 
protoc --version
# libprotoc 22.3

2.2 Go-bezogene Plug-Ins installieren

Installieren Sie google.golang.org/protobuf/cmd/protoc-gen-go@latest.
Installieren Sie google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

3. Üben

3.1 Protodatei schreiben

syntax = "proto3";
 
option go_package = "./;hello";
 
package hello;
 
message HelloRequest{
    string name = 1;
}
 
message HelloResponse{
    string message = 1;
}
 
service ExampleService{
    rpc SayHi (HelloRequest) returns (HelloResponse);
}

service ExampleServiceEs ist der von uns definierte Dienst, rpc SayHi (HelloRequest) returns (HelloResponse);der die im Dienst bereitgestellte Schnittstelle darstellt. Protoc generiert den entsprechenden Code basierend auf der von uns definierten Proto-Datei.

3.2 Verwenden Sie Protoc, um Code zu generieren

Führen Sie den folgenden Befehl im Terminal aus, um den benötigten Code zu generieren:

protoc --go_out=. --go-grpc_out=. hello.proto

--go_out gibt das Generierungsverzeichnis von GO-Dateien an, --go-grpc_out gibt das Generierungsverzeichnis von GRPC-Dateien an

Wenn Sie zu diesem Zeitpunkt die generierte GO-Datei öffnen, wird höchstwahrscheinlich ein roter Fehler angezeigt. Zu diesem Zeitpunkt können Sie go mod tidydie Abhängigkeiten im aktuellen Verzeichnis synchronisieren.

3.3 Schreiben Sie serverseitigen Code

Das Beispiel implementiert einfach einen Echo-Dienst. Der Servercode lautet wie folgt:

package main
 
import (
	"context"
	"net"
 
	pb "github.com/mengbin92/hello/protos/hello"
	"google.golang.org/grpc"
)
 
// 服务实体
type HelloService struct {
	pb.UnimplementedExampleServiceServer
}
 
// 实现我们proto文件定义的接口
func (sv *HelloService) SayHi(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
	return &pb.HelloResponse{Message: "hello " + in.Name}, nil
}
 
func main() {
	// 创建grpc服务示例
	sv := grpc.NewServer()
	// 注册我们的服务
	pb.RegisterExampleServiceServer(sv, new(HelloService))
 
	// 绑定端口，提供服务
	lis, err := net.Listen("tcp", ":50001")
	if err != nil {
		panic(err)
	}
	// 启动服务
	sv.Serve(lis)
}

Nach dem Start des Dienstes blockiert der Server und wartet auf die Verbindung des Clients, bis er killein Signal empfängt:

go run server.go

3.4 Client implementieren

package main
 
import (
	"context"
	"fmt"
 
	pb "github.com/mengbin92/hello/protos/hello"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)
 
func main() {
	// 创建grpc连接
	conn, err := grpc.Dial("localhost:50001", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		panic(err)
	}
	defer conn.Close()
 
	// 实例化客户端
	client := pb.NewExampleServiceClient(conn)
 
	// 发送请求
	req := &pb.HelloRequest{Name: "world"}
	resp, err := client.SayHi(context.TODO(), req)
	if err != nil {
		panic(err)
	}
	fmt.Printf("get response from server: %s\n", resp.Message)
}

Nachdem der Client gestartet ist, sendet er es an den Server worldund der Server gibt Folgendes zurück hello world:

go run client.go
# get response from server: hello world

Zu diesem Zeitpunkt ist ein einfacher gRPC-Dienst abgeschlossen.