Use go-zero to implement distributed cross-language RPC calls

With the growth of business scale, the existence of single applications can no longer meet the needs of the system, and distributed architecture has gradually become the mainstream. In distributed systems, RPC has become an indispensable part. It provides a convenient, efficient, and reliable way to remotely call services, enabling fast and stable data interaction and calls between various services.

For cross-language RPC calls, both the communication protocol and the serialization protocol need to be compatible with multiple programming languages, so it is relatively difficult to implement. This article will introduce how to use the go-zero framework to implement cross-language distributed RPC calls, aiming to provide readers with a practical solution.

1. Introduction to go-zero framework

go-zero is a lightweight Web framework that uses the native net/http module of the go language and provides a set of A simple, easy-to-use, high-performance API development method that can easily combine HTTP services with microservices. go-zero can help us quickly build distributed, high-concurrency server applications, and the code and documentation can be obtained for free on GitHub.

2. Realize cross-language RPC calls

2.1 Define services

When we define services in go-zero, we need to first write a proto file and define Communication interface between server and client. Suppose we define a service named Example, which contains two methods:

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

After defining the proto file, we need to use the protobuf compiler to compile it into a go language source file and execute the following command:

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

This will generate two files, rpc.pb.go and rpc_grpc.pb.go.

2.2 Implementing the server

In the go-zero framework, we can use the go-grpc module to implement the grpc service. When implementing the server, you need to implement the interface defined in the proto file, use server.NewServer provided by go-zero and call the AddService method to add the service, and then start the grpc service in the Init method.

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
}

On the server, we can use the Init method to start the RPC server and use MustNewServer to create the RPC server. We must pass in an RpcServerConf structure containing the address we want to bind.

2.3 Implementing the client

In the go-zero framework, we can use the zrpc module to implement the grpc client. Use zrpc.Dial to create a connection and instantiate the rpc client.

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

On the client, we only need to use the NewExampleClient function to create an RPC client. The function of the SayHello method is to obtain a response from the server and return it. The GetUser method obtains the user information response from the server and returns it in the form of UserResponse.

2.4 Test

Now that we have implemented the server and client code, we can test it through the following code:

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

In the above code, we create Open a grpc connection and call the SayHello and GetUser methods to test our RPC service. We can successfully respond with the correct data and confirm that the RPC service is working normally.

3. Summary

In this article, we introduced how to use the go-zero framework to implement distributed cross-language RPC calls, which involves go-zero's Def module , grpc, protobuf and zrpc and other technologies. When implementing RPC services, we first define the RPC interface, and then write server and client code based on the interface. Finally add the Init method to start the RPC service. If you are looking for a lightweight, easy-to-use distributed system framework, go-zero is definitely a good choice.

The above is the detailed content of Use go-zero to implement distributed cross-language RPC calls. For more information, please follow other related articles on the PHP Chinese website!