Comment implémenter l'interface RPC à l'aide de Go

Ces dernières années, avec le développement rapide de la technologie Internet et l'essor du cloud computing, l'appel de procédure à distance (RPC) a attiré de plus en plus l'attention des développeurs. Le langage Go lui-même est léger et, grâce à une riche prise en charge de bibliothèques et de frameworks, les services RPC peuvent être facilement implémentés. Dans cet article, nous présenterons comment implémenter les interfaces RPC à l'aide de Go.

1. Présentation de RPC

RPC (Remote Procedure Call), ou appel de procédure distante, est un protocole qui permet à différents processus ou ordinateurs de communiquer entre eux et d'appeler des fonctions ou des méthodes sur d'autres processus ou machines. Le principe de base de RPC est d'encapsuler l'appel d'une fonction ou d'une méthode dans un processus de communication réseau, afin que le consommateur (l'appelant) puisse appeler les services sur la machine distante comme un appel local.

Actuellement, les frameworks RPC courants incluent gRPC, Thrift, Dubbo, etc. Parmi eux, gRPC est un framework RPC hautes performances basé sur HTTP/2 open source par Google et prend en charge plusieurs langages de programmation, dont C++, Java, Python, Go, etc. gRPC utilise Protocol Buffers comme protocole de sérialisation, qui peut être utilisé pour créer des applications distribuées hautes performances et évolutives telles que des systèmes distribués et des microservices.

2. Utilisez Go pour implémenter l'interface RPC

1. Installer et télécharger les dépendances

Avant d'utiliser Go pour implémenter l'interface RPC, nous devons installer l'environnement de développement Go et la prise en charge du framework RPC. Ici, nous choisissons d'utiliser le framework gRPC.

Tout d'abord, nous devons installer le plug-in de langage gRPC Go et l'outil protobuf :

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

Une fois l'installation terminée, nous pouvons utiliser protobuf2.0 ou supérieur pour écrire un fichier .proto pour décrire le service et la structure des messages. Par exemple, nous écrivons un simple fichier .proto :

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. Générer le code

Nous pouvons utiliser la commande suivante pour générer du code Go basé sur le fichier .proto :

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

Après avoir exécuté la commande ci-dessus, nous pouvons obtenir le Fichier de code Go correspondant, par exemple :

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. Implémentation du serveur

Ensuite, nous devons implémenter un serveur. Tout d'abord, nous devons définir une structure HelloServiceImpl pour implémenter l'interface HelloService ci-dessus :

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
}

Dans le code ci-dessus, nous définissons une structure HelloServiceImpl et implémentons la méthode SayHello dans l'interface HelloService. Cette méthode reçoit un objet contextuel et un objet HelloRequest comme paramètres et renvoie un objet HelloResponse comme résultat. Parmi eux, ctx est l'objet contextuel utilisé pour contrôler le processus de requête. req est un objet HelloRequest, contenant les paramètres de requête lors de l'appel de la méthode SayHello.

Ensuite, nous devons créer un serveur gRPC et enregistrer l'objet HelloServiceImpl sur le serveur :

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)
  }
}

Dans le code ci-dessus, nous définissons d'abord un port d'écoute, puis créons un serveur gRPC et enregistrons l'objet HelloServiceImpl du côté du service. Enfin, nous démarrons le service gRPC et écoutons les requêtes HTTP2.

4. Implémentation du client

Maintenant que nous avons implémenté un serveur gRPC, nous devons ensuite implémenter un client gRPC. Dans Go, nous pouvons accéder au serveur gRPC en appelant la méthode client correspondante. Par exemple, nous pouvons créer un fichier client nommé main et implémenter le code suivant :

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)
}

Dans le code ci-dessus, nous créons d'abord une connexion gRPC et nous connectons au serveur, puis créons un objet HelloServiceClient et assemblons les paramètres de la requête. Enfin, nous appelons la méthode SayHello et affichons la réponse. Une fois le code ci-dessus exécuté, nous pouvons voir le résultat :

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

5. Exécuter le service

Enfin, nous devons compiler les codes serveur et client, puis démarrer le service. Vous pouvez suivre les étapes ci-dessous :

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

Si tout se passe bien, nous pouvons voir le résultat du client : "Bonjour, allez grpc !".

3. Résumé

Dans cet article, nous avons présenté comment utiliser Go pour implémenter l'interface RPC. Parmi eux, nous avons utilisé le framework gRPC classique et implémenté un exemple simple de Hello World. Il convient de mentionner qu'en plus de gRPC, Go dispose également de nombreux autres frameworks RPC, notamment Thrift, Dubbo et JSON-RPC, etc., et les développeurs peuvent choisir de manière flexible en fonction des besoins réels.

Lors de l'utilisation du framework RPC, nous devons choisir le protocole de sérialisation et le protocole de transmission appropriés en fonction des besoins réels. Normalement, nous recommandons d'utiliser les Protocol Buffers et le protocole HTTP/2 pour implémenter des appels RPC efficaces afin de répondre aux besoins des systèmes distribués à grande échelle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!