이전 기사에서는 net/rpc 패키지를 사용하여 간단한 RPC 인터페이스를 구현하고 net/rpc와 함께 제공되는 Gob 인코딩과 JSON 인코딩을 사용해 Golang의 기본 사항을 학습했습니다. RPC. 이번 포스팅에서는 net/rpc를 protobuf와 결합하고 protobuf 플러그인을 만들어 코드 생성에 도움을 드릴 테니 시작해 보겠습니다.

이 기사는 Medium MPP 계획에 처음 게시되었습니다. 미디엄 사용자라면 미디엄에서 저를 팔로우해주세요. 매우 감사합니다.

작업 중에 gRPC와 protobuf를 사용했음이 틀림없지만 바인딩되어 있지 않습니다. gRPC는 JSON을 사용하여 인코딩할 수 있으며, protobuf는 다른 언어로 구현할 수 있습니다.

프로토콜 버퍼 (Protobuf)는 구조화된 데이터를 직렬화하는 데 사용되는 무료 오픈소스 크로스 플랫폼 데이터 형식입니다. 네트워크를 통해 서로 통신하는 프로그램을 개발하거나 데이터를 저장하는 데 유용합니다. 이 방법에는 일부 데이터의 구조를 설명하는 인터페이스 설명 언어와 구조화된 데이터를 나타내는 바이트 스트림을 생성하거나 파싱하기 위해 해당 설명에서 소스 코드를 생성하는 프로그램이 포함됩니다.

protobuf 사용 예

먼저 "문자열" 메시지를 정의하는 프로토 파일 hello-service.proto를 작성합니다.

syntax = "proto3";
package api;
option  go_package="api";

message String {
  string value = 1;
}

그런 다음 protoc 유틸리티를 사용하여 메시지 문자열에 대한 Go 코드를 생성합니다.

protoc --go_out=. hello-service.proto

그런 다음 protobuf 파일에서 생성된 문자열을 사용하도록 Hello 함수의 인수를 수정합니다.

type HelloServiceInterface = interface {  
    Hello(request api.String, reply *api.String) error  
}  

사용 방법은 이전과 별반 다르지 않습니다. 심지어 문자열을 직접 사용하는 것만큼 편리하지도 않습니다. 그렇다면 왜 protobuf를 사용해야 할까요? 앞서 말했듯이 Protobuf를 사용하여 언어 독립적인 RPC 서비스 인터페이스와 메시지를 정의한 다음 protoc 도구를 사용하여 다양한 언어로 코드를 생성하는 것이 진정한 가치가 있는 곳입니다. 예를 들어 gRPC 코드를 생성하려면 공식 플러그인 protoc-gen-go를 사용하세요.

protoc --go_out=plugins=grpc. hello-service.proto

protoc용 플러그인 시스템

protobuf 파일에서 코드를 생성하려면 protoc을 설치해야 하지만 protoc은 대상 언어가 무엇인지 모르므로 코드 생성을 도와주는 플러그인이 필요합니다. protoc의 플러그인 시스템은 어떻게 작동하나요? 위의 grpc를 예로 들어 보겠습니다.

여기에 --go_out 매개변수가 있습니다. 우리가 호출하는 플러그인은 protoc-gen-go이므로 매개변수는 go_out이라고 합니다. 이름이 XXX인 경우 매개변수는 XXX_out이라고 합니다.

protoc이 실행되면 먼저 protobuf 파일을 구문 분석하고 프로토콜 버퍼로 인코딩된 설명 데이터 세트를 생성합니다. 먼저 go 플러그인이 protoc에 포함되어 있는지 여부를 확인한 다음 $PATH에서 protoc-gen-go를 찾으려고 시도하고 찾을 수 없으면 오류를 보고한 다음 protoc-gen-go를 실행합니다. protoc-gen-go 명령을 실행하고 설명 데이터를 stdin을 통해 플러그인 명령으로 보냅니다. 플러그인이 파일 콘텐츠를 생성한 후 프로토콜 버퍼로 인코딩된 데이터를 stdout에 입력하여 protoc에 특정 파일을 생성하라고 지시합니다.

플러그인=grpc는 protoc-gen-go를 호출하기 위해 함께 제공되는 플러그인입니다. 사용하지 않으면 Go에서만 메시지가 생성되는데, 이 플러그인을 사용하면 grpc 관련 코드를 생성할 수 있습니다.

protoc 플러그인 사용자 정의

protobuf에 Hello 인터페이스 타이밍을 추가하면 protoc 플러그인을 맞춤설정하여 코드를 직접 생성할 수 있나요?

syntax = "proto3";  
package api;  
option  go_package="./api";  
service HelloService {  
  rpc Hello (String) returns (String) {}  
}  
message String {  
  string value = 1;
}

목적

이 글의 목표는 다음과 같은 RPC 서버 측 및 클라이언트 측 코드를 생성하는 데 사용할 플러그인을 만드는 것이었습니다.

// HelloService_rpc.pb.go
type HelloServiceInterface interface {  
    Hello(String, *String) error  
}  

func RegisterHelloService(  
    srv *rpc.Server, x HelloServiceInterface,  
) error {  
    if err := srv.RegisterName("HelloService", x); err != nil {  
       return err  
    }  
    return nil  
}  

type HelloServiceClient struct {  
    *rpc.Client  
}  

var _ HelloServiceInterface = (*HelloServiceClient)(nil)  

func DialHelloService(network, address string) (  
    *HelloServiceClient, error,  
) {  
    c, err := rpc.Dial(network, address)  
    if err != nil {  
       return nil, err  
    }  
    return &HelloServiceClient{Client: c}, nil  
}  

func (p *HelloServiceClient) Hello(  
    in String, out *String,  
) error {  
    return p.Client.Call("HelloService.Hello", in, out)  
}

이렇게 하면 비즈니스 코드가 다음과 같이 변경됩니다.

// service
func main() {  
    listener, err := net.Listen("tcp", ":1234")  
    if err != nil {  
       log.Fatal("ListenTCP error:", err)  
    }  
    _ = api.RegisterHelloService(rpc.DefaultServer, new(HelloService))  
    for {  
       conn, err := listener.Accept()  
       if err != nil {  
          log.Fatal("Accept error:", err)  
       }  
       go rpc.ServeConn(conn)  
    }  
}  

type HelloService struct{}  

func (p *HelloService) Hello(request api.String, reply *api.String) error {  
    log.Println("HelloService.proto Hello")  
    *reply = api.String{Value: "Hello:"   request.Value}  
    return nil  
}
// client.go
func main() {  
    client, err := api.DialHelloService("tcp", "localhost:1234")  
    if err != nil {  
       log.Fatal("net.Dial:", err)  
    }  
    reply := &api.String{}  
    err = client.Hello(api.String{Value: "Hello"}, reply)  
    if err != nil {  
       log.Fatal(err)  
    }  
    log.Println(reply)  
}

생성된 코드에 따르면 작업량은 이미 훨씬 적고 오류 가능성도 매우 낮습니다. 좋은 시작입니다.

위의 API 코드를 기반으로 템플릿 파일을 꺼낼 수 있습니다.

const tmplService = `  
import (  
    "net/rpc")  
type {{.ServiceName}}Interface interface {  
func Register{{.ServiceName}}(  
    if err := srv.RegisterName("{{.ServiceName}}", x); err != nil {        return err    }    return nil}  
    *rpc.Client}  
func Dial{{.ServiceName}}(network, address string) (  
{{range $_, $m := .MethodList}}  
    return p.Client.Call("{{$root.ServiceName}}.{{$m.MethodName}}", in, out)}  
`

전체 템플릿은 명확하며 나중에 다루게 될 MethodName, ServiceName 등과 같은 몇 가지 자리 표시자가 있습니다.

플러그인을 개발하는 방법은 무엇입니까?

Google은 플러그인 개발의 어려움을 크게 줄여주는 새로운 패키지 google.golang.org/protobuf/compile R/protogen을 도입하는 Go 언어 API 1을 출시했습니다.

1. 먼저 protoc-gen-go-spprpc와 같은 go 언어 프로젝트를 만듭니다.
2. 그런 다음 protogen.Options를 정의한 다음 Run 메서드를 호출하고 func(*protogen.Plugin) 오류 콜백을 전달해야 합니다. 메인 프로세스 코드의 끝입니다.
3. protogen.Options의 ParamFunc 매개변수를 설정할 수도 있습니다. 그러면 protogen이 명령줄에서 전달된 매개변수를 자동으로 구문 분석하게 됩니다. 표준 입력에서 protobuf 정보 읽기 및 디코딩, 입력 정보를 protobuf로 인코딩, stdout 작성과 같은 작업은 모두 protogen에 의해 처리됩니다. 우리가 해야 할 일은 protogen.Plugin과 상호작용하여 코드 생성 로직을 구현하는 것입니다.

각 서비스에서 가장 중요한 것은 서비스 이름이며, 각 서비스에는 일련의 메서드가 있습니다. 서비스에서 정의한 메소드의 경우 가장 중요한 것은 메소드 이름뿐 아니라 입력 매개변수의 이름과 출력 매개변수 유형입니다. 먼저 서비스의 메타 정보를 설명하기 위해 ServiceData를 정의해 보겠습니다.

// ServiceData 
type ServiceData struct {  
    PackageName string  
    ServiceName string  
    MethodList  []Method  
}
// Method 
type Method struct {  
    MethodName     string  
    InputTypeName  string  
    OutputTypeName string  
}

그런 다음 기본 논리, 코드 생성 논리, 그리고 마지막으로 코드를 생성하기 위한 tmpl 호출이 나옵니다.

func main() {  
    protogen.Options{}.Run(func(gen *protogen.Plugin) error {  
       for _, file := range gen.Files {  
          if !file.Generate {  
             continue  
          }  
          generateFile(gen, file)  
       }  
       return nil  
    })  
}  

// generateFile function definition
func generateFile(gen *protogen.Plugin, file *protogen.File) {  
    filename := file.GeneratedFilenamePrefix   "_rpc.pb.go"  
    g := gen.NewGeneratedFile(filename, file.GoImportPath)  
    tmpl, err := template.New("service").Parse(tmplService)  
    if err != nil {  
       log.Fatalf("Error parsing template: %v", err)  
    }  
    packageName := string(file.GoPackageName)  
// Iterate over each service to generate code
    for _, service := range file.Services {  
       serviceData := ServiceData{  
          ServiceName: service.GoName,  
          PackageName: packageName,  
       }  
       for _, method := range service.Methods {  
          inputType := method.Input.GoIdent.GoName  
          outputType := method.Output.GoIdent.GoName  

          serviceData.MethodList = append(serviceData.MethodList, Method{  
             MethodName:     method.GoName,  
             InputTypeName:  inputType,  
             OutputTypeName: outputType,  
          })  
       }  
// Perform template rendering
       err = tmpl.Execute(g, serviceData)  
       if err != nil {  
          log.Fatalf("Error executing template: %v", err)  
       }  
    }  
}

디버그 플러그인

마지막으로 컴파일된 바이너리 실행 파일 protoc-gen-go-spprpc를 $PATH에 넣은 후 protoc을 실행하여 원하는 코드를 생성합니다.

protoc --go_out=.. --go-spprpc_out=.. HelloService.proto

protoc-gen-go-spprpc는 실행하기 위해 protoc에 의존해야 하기 때문에 디버그하기가 약간 까다롭습니다. 우리는
를 사용할 수 있습니다

fmt.Fprintf(os.Stderr, "Fprintln: %v\n", err)

디버깅을 위해 오류 로그를 인쇄합니다.

요약

이 기사의 전부입니다. 먼저 protobuf를 사용하여 RPC 호출을 구현한 다음 코드 생성을 돕기 위해 protobuf 플러그인을 만들었습니다. 이는 protobuf RPC를 배울 수 있는 문을 열어주며, gRPC에 대한 철저한 이해를 위한 길입니다. 모두가 이 기술을 마스터할 수 있기를 바랍니다.

참조

1. https://taoshu.in/go/create-protoc-plugin.html
2. https://chai2010.cn/advanced-go-programming-book/ch4-rpc/ch4-02-pb-intro.html