go-zero를 사용하여 분산 언어 간 RPC 호출 구현

비즈니스 규모가 성장함에 따라 단일 애플리케이션의 존재는 더 이상 시스템 요구 사항을 충족할 수 없으며 분산 아키텍처가 점차 주류가 되었습니다. 분산 시스템에서 RPC는 원격으로 서비스를 호출하는 편리하고 효율적이며 안정적인 방법을 제공하여 빠르고 안정적인 데이터 상호 작용과 다양한 서비스 간의 호출을 가능하게 합니다.

언어 간 RPC 호출의 경우 통신 프로토콜과 직렬화 프로토콜 모두 여러 프로그래밍 언어와 호환되어야 하므로 구현하기가 상대적으로 어렵습니다. 이 기사에서는 독자에게 실용적인 솔루션을 제공하는 것을 목표로 go-zero 프레임워크를 사용하여 언어 간 분산 RPC 호출을 구현하는 방법을 소개합니다.

1. go-zero 프레임워크 소개

go-zero는 go 언어의 기본 net/http 모듈을 사용하여 간단하고 사용하기 쉬운 고성능 API 개발을 제공하는 경량 웹 프레임워크입니다. HTTP 서비스는 마이크로서비스와 쉽게 결합될 수 있습니다. go-zero는 분산형, 동시성 높은 서버 애플리케이션을 신속하게 구축하는 데 도움이 되며, GitHub에서 코드와 문서를 무료로 얻을 수 있습니다.

2. 언어 간 RPC 호출 구현

2.1 서비스 정의

go-zero에서 서비스를 정의할 때 먼저 서버와 클라이언트 간의 통신 인터페이스를 정의하는 proto 파일을 작성해야 합니다.

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

proto 파일을 정의한 후 protobuf 컴파일러를 사용하여 이를 go 언어의 소스 파일로 컴파일하고 다음 명령을 실행해야 합니다.

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

This rpc.pb.go 및 rpc_grpc.pb.go라는 두 개의 파일이 생성됩니다.

2.2 서버 구현

go-zero 프레임워크에서는 go-grpc 모듈을 사용하여 grpc 서비스를 구현할 수 있습니다. 서버 구현 시 proto 파일에 정의된 인터페이스를 구현하고, go-zero에서 제공하는 server.NewServer를 사용하고 AddService 메소드를 호출하여 서비스를 추가한 후 Init 메소드에서 grpc 서비스를 시작해야 합니다.

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
}

서버에서 Init 메소드를 사용하여 RPC 서버를 시작할 수 있고 MustNewServer를 사용하여 RPC 서버를 생성할 수 있습니다. 바인딩하려는 주소가 포함된 RpcServerConf 구조를 전달해야 합니다.

2.3 클라이언트 구현

go-zero 프레임워크에서는 zrpc 모듈을 사용하여 grpc 클라이언트를 구현할 수 있습니다. zrpc.Dial을 사용하여 연결을 만들고 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,
    })
}

클라이언트에서는 NewExampleClient 함수를 사용하여 RPC 클라이언트를 생성하기만 하면 됩니다. SayHello 메서드의 기능은 서버로부터 응답을 받아 반환하는 것입니다. GetUser 메서드는 서버로부터 사용자 정보 응답을 얻어 UserResponse 형식으로 반환합니다.

2.4 테스트

이제 서버와 클라이언트 코드를 구현했으므로 다음 코드로 테스트할 수 있습니다.

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

위 코드에서는 grpc 연결을 만들고 SayHello 및 GetUser 메서드를 호출하여 RPC를 테스트합니다. 서비스. 올바른 데이터로 성공적으로 응답할 수 있으며 RPC 서비스가 정상적으로 작동하는지 확인할 수 있습니다.

3. 요약

이 기사에서는 go-zero의 Def 모듈, grpc, protobuf, zrpc 및 기타 기술이 포함된 분산 언어 간 RPC 호출을 구현하기 위해 go-zero 프레임워크를 사용하는 방법을 소개했습니다. RPC 서비스를 구현할 때 먼저 RPC 인터페이스를 정의한 다음 인터페이스를 기반으로 서버 및 클라이언트 코드를 작성합니다. 마지막으로 Init 메서드를 추가하여 RPC 서비스를 시작합니다. 가볍고 사용하기 쉬운 분산 시스템 프레임워크를 찾고 있다면 go-zero가 확실히 좋은 선택입니다.

위 내용은 go-zero를 사용하여 분산 언어 간 RPC 호출 구현의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!