Utilisez go-zero pour implémenter des appels RPC multilingues distribués

Avec la croissance de l'échelle des entreprises, l'existence d'applications uniques ne peut plus répondre aux besoins du système, et l'architecture distribuée est progressivement devenue la norme. Dans les systèmes distribués, RPC est devenu un élément indispensable. Il constitue un moyen pratique, efficace et fiable d'appeler des services à distance, permettant une interaction de données et des appels rapides et stables entre divers services.

Pour les appels RPC multilingues, le protocole de communication et le protocole de sérialisation doivent être compatibles avec plusieurs langages de programmation, ils sont donc relativement difficiles à mettre en œuvre. Cet article présentera comment utiliser le framework go-zero pour implémenter des appels RPC distribués multilingues, dans le but de fournir aux lecteurs une solution pratique.

1. go-zero framework introduction

go-zero est un framework Web léger qui utilise le net/natif du langage go Le module http fournit une méthode de développement d'API simple, facile à utiliser et hautes performances qui peut facilement combiner des services HTTP avec des microservices. go-zero peut nous aider à créer rapidement des applications serveur distribuées à haute concurrence, et le code et la documentation peuvent être obtenus gratuitement sur GitHub.

2. Mise en œuvre des appels RPC multilingues

2.1 Définir les services

Quand nous définissons les services en go-zero Vous vous devez d'abord écrire un fichier proto pour définir l'interface de communication entre le serveur et le client. Supposons que nous définissions un service nommé Exemple, qui contient deux méthodes :

syntax = "proto3";

package rpc;

service Example {
    rpc SayHello (Request) returns (Response);
    rpc GetUser (UserRequest) returns (UserResponse);
}

message Request {
    string name = 1;
}

message Response {
    string message = 1;
}

message UserRequest {
    string id = 1;
}

message UserResponse {
    string name = 1;
    string email = 2;
}

Après avoir défini le fichier proto, nous devons utiliser le compilateur protobuf pour le compiler dans un fichier source du langage go, exécutez la commande suivante :

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

Cela générera deux fichiers rpc.pb.go et rpc_grpc.pb.go.

2.2 Implémentation du serveur

Dans le framework go-zero, nous pouvons utiliser le module go-grpc pour implémenter le service grpc. Lors de l'implémentation du serveur, vous devez implémenter l'interface définie dans le fichier proto, utiliser server.NewServer fourni par go-zero et appeler la méthode AddService pour ajouter le service, puis démarrer le service grpc dans la méthode Init.

package server

import (
    "context"
    "rpc"

    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/core/stores/sqlx"
    "github.com/tal-tech/go-zero/core/syncx"
    "github.com/tal-tech/go-zero/zrpc"
    "google.golang.org/grpc"
)

type ExampleContext struct {
    Logx      logx.Logger
    SqlConn   sqlx.SqlConn
    CacheConn syncx.SharedCalls
}

type ExampleServer struct {
    Example rpc.ExampleServer
}

func NewExampleServer(ctx ExampleContext) *ExampleServer {
    return &ExampleServer{
        Example: &exampleService{
            ctx: ctx,
        },
    }
}

func (s *ExampleServer) Init() {
    server := zrpc.MustNewServer(zrpc.RpcServerConf{
        BindAddress: "localhost:7777",
    })
    rpc.RegisterExampleServer(server, s.Example)
    server.Start()
}

type exampleService struct {
    ctx ExampleContext
}

func (s *exampleService) SayHello(ctx context.Context, req *rpc.Request) (*rpc.Response, error) {
    return &rpc.Response{
        Message: "Hello, " + req.Name,
    }, nil
}

func (s *exampleService) GetUser(ctx context.Context, req *rpc.UserRequest) (*rpc.UserResponse, error) {
    // 查询数据库
    return &rpc.UserResponse{
        Name:  "name",
        Email: "email",
    }, nil
}

Sur le serveur, nous pouvons utiliser la méthode Init pour démarrer le serveur RPC, et utiliser MustNewServer pour créer le serveur RPC. Nous devons passer une structure RpcServerConf, incluant l'adresse que nous voulons lier.

2.3 Implémentation du client

Dans le framework go-zero, nous pouvons utiliser le module zrpc pour implémenter le client grpc. Utilisez zrpc.Dial pour créer une connexion et instancier le client rpc.

package client

import (
    "context"
    "rpc"

    "google.golang.org/grpc"
)

type ExampleClient struct {
    client rpc.ExampleClient
}

func NewExampleClient(conn *grpc.ClientConn) *ExampleClient {
    return &ExampleClient{
        client: rpc.NewExampleClient(conn),
    }
}

func (c *ExampleClient) SayHello(name string) (string, error) {
    resp, err := c.client.SayHello(context.Background(), &rpc.Request{
        Name: name,
    })
    if err != nil {
        return "", err
    }
    return resp.Message, nil
}

func (c *ExampleClient) GetUser(id string) (*rpc.UserResponse, error) {
    return c.client.GetUser(context.Background(), &rpc.UserRequest{
        Id: id,
    })
}

Sur le client, il suffit d'utiliser la fonction NewExampleClient pour créer le client RPC. La fonction de la méthode SayHello est d'obtenir une réponse du serveur et de la renvoyer. La méthode GetUser obtient la réponse des informations utilisateur du serveur et la renvoie sous la forme de UserResponse.

2.4 Test

Maintenant que nous avons implémenté le code serveur et client, nous pouvons le tester avec le code suivant :

package main

import (
    "fmt"
    "log"
    "rpc_example/client"
    "rpc_example/server"

    "google.golang.org/grpc"
)

func main() {
    ctx := server.ExampleContext{}
    conn, err := grpc.Dial("localhost:7777", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("grpc.Dial err :%v", err)
    }

    defer conn.Close()

    client := client.NewExampleClient(conn)
    resp, err := client.SayHello("Alice")
    if err != nil {
        log.Fatalf("client.SayHello err : %v", err)
    }

    fmt.Println(resp)

    user, err := client.GetUser("123")
    if err != nil {
        log.Fatalf("client.GetUser err : %v", err)
    }

    fmt.Println(user)
}

ci-dessus Dans code, nous créons une connexion grpc et appelons les méthodes SayHello et GetUser pour tester notre service RPC. Nous pouvons répondre avec succès avec des données correctes et confirmer que le service RPC fonctionne normalement.

3. Summary

Dans cet article, nous expliquons comment utiliser le framework go-zero pour implémenter des appels RPC multilingues distribués, ce qui implique module Def de go-zero, grpc, protobuf et zrpc et autres technologies. Lors de l'implémentation des services RPC, nous définissons d'abord l'interface RPC, puis écrivons le code serveur et client basé sur l'interface. Ajoutez enfin la méthode Init pour démarrer le service RPC. Si vous recherchez un framework de système distribué léger et facile à utiliser, go-zero est certainement un bon choix.

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!