Verwenden Sie Go-Zero, um verteilte sprachübergreifende RPC-Aufrufe zu implementieren

Mit zunehmender Unternehmensgröße kann die Existenz einzelner Anwendungen die Anforderungen des Systems nicht mehr erfüllen, und die verteilte Architektur ist nach und nach zum Mainstream geworden. In verteilten Systemen ist RPC zu einem unverzichtbaren Bestandteil geworden. Es bietet eine bequeme, effiziente und zuverlässige Möglichkeit, Dienste aus der Ferne aufzurufen und ermöglicht eine schnelle und stabile Dateninteraktion und Anrufe zwischen verschiedenen Diensten.

Für sprachübergreifende RPC-Aufrufe müssen sowohl das Kommunikationsprotokoll als auch das Serialisierungsprotokoll mit mehreren Programmiersprachen kompatibel sein, sodass die Implementierung relativ schwierig ist. In diesem Artikel wird vorgestellt, wie das Go-Zero-Framework zur Implementierung sprachübergreifender verteilter RPC-Aufrufe verwendet wird, um den Lesern eine praktische Lösung zu bieten.

1. Einführung in das Go-Zero-Framework

go-zero ist ein leichtes Web-Framework, das das native Net/http-Modul der Go-Sprache verwendet, um eine Reihe einfacher, benutzerfreundlicher und leistungsstarker Funktionen bereitzustellen API-Entwicklungsmethoden können problemlos mit Microservices kombiniert werden. go-zero kann uns dabei helfen, schnell verteilte Serveranwendungen mit hoher Parallelität zu erstellen. Der Code und die Dokumentation sind kostenlos auf GitHub erhältlich.

2. Implementierung sprachübergreifender RPC-Aufrufe

2.1 Definieren von Diensten

Wenn wir Dienste in Go-Zero definieren, müssen wir zunächst eine Protodatei schreiben, um die Kommunikationsschnittstelle zwischen dem Server und dem Client zu definieren. Angenommen, wir definieren einen Dienst namens „Example“, der zwei Methoden enthält:

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

Nachdem wir die Protodatei definiert haben, müssen wir sie mit dem Protobuf-Compiler in eine Quelldatei in der Go-Sprache kompilieren und den folgenden Befehl ausführen:

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

This Es werden zwei Dateien generiert, rpc.pb.go und rpc_grpc.pb.go.

2.2 Implementierung des Servers

Im Go-Zero-Framework können wir das go-grpc-Modul verwenden, um den grpc-Dienst zu implementieren. Bei der Implementierung des Servers müssen Sie die in der Protodatei definierte Schnittstelle implementieren, server.NewServer von go-zero verwenden und die AddService-Methode aufrufen, um den Dienst hinzuzufügen, und dann den grpc-Dienst in der Init-Methode starten.

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
}

Auf dem Server können wir die Init-Methode verwenden, um den RPC-Server zu starten, und MustNewServer verwenden, um den RPC-Server zu erstellen. Wir müssen eine RpcServerConf-Struktur übergeben, die die Adresse enthält, die wir binden möchten.

2.3 Implementierung des Clients

Im Go-Zero-Framework können wir das zrpc-Modul verwenden, um den grpc-Client zu implementieren. Verwenden Sie zrpc.Dial, um eine Verbindung herzustellen und den RPC-Client zu instanziieren.

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

Auf dem Client müssen wir lediglich den RPC-Client mithilfe der NewExampleClient-Funktion erstellen. Die Funktion der SayHello-Methode besteht darin, eine Antwort vom Server zu erhalten und diese zurückzugeben. Die GetUser-Methode ruft die Benutzerinformationsantwort vom Server ab und gibt sie in Form von UserResponse zurück.

2.4 Testen

Da wir nun den Server- und Client-Code implementiert haben, können wir ihn mit dem folgenden Code testen:

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

Im obigen Code erstellen wir eine grpc-Verbindung und rufen die Methoden SayHello und GetUser auf, um unseren RPC zu testen Service. Wir können erfolgreich mit korrekten Daten antworten und bestätigen, dass der RPC-Dienst normal funktioniert.

3. Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie das Go-Zero-Framework zum Implementieren verteilter sprachübergreifender RPC-Aufrufe verwendet wird, was das Def-Modul, grpc, protobuf und zrpc sowie andere Technologien von go-zero umfasst. Bei der Implementierung von RPC-Diensten definieren wir zunächst die RPC-Schnittstelle und schreiben dann Server- und Clientcode basierend auf der Schnittstelle. Fügen Sie abschließend die Init-Methode hinzu, um den RPC-Dienst zu starten. Wenn Sie nach einem leichten, benutzerfreundlichen Framework für verteilte Systeme suchen, ist Go-Zero definitiv eine gute Wahl.

Das obige ist der detaillierte Inhalt vonVerwenden Sie Go-Zero, um verteilte sprachübergreifende RPC-Aufrufe zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!