grpc

Go的RPC标准库

简单使用

Go语言标准库(net/rpc)的RPC规则：方法只能有两个可序列化的参数，其中第二个参数是指针类型，并且返回一个error类型，同时必须是公开的方法。

type HelloService struct {}
func (p *HelloService) Hello(request string, reply *string) error {
    *reply = "hello:" + request
    return nil
}
func main() {
    rpc.RegisterName("HelloService", new(HelloService))
    listener, err := net.Listen("tcp", ":1234")
    if err != nil {
        log.Fatal("ListenTCP error:", err)
    }
    conn, err := listener.Accept()
    if err != nil {
        log.Fatal("Accept error:", err)
    }
    rpc.ServeConn(conn)
}

一个服务可以有多个方法，rpc.RegisterName函数调用会将对象类型中所有满足RPC规则的对象方法注册为RPC函数，所有注册的方法会放在“HelloService”服务空间之下。

客户端代码：

func main() {
    client, err := rpc.Dial("tcp", "localhost:1234")
    if err != nil {
        log.Fatal("dialing:", err)
    }
    var reply string
    err = client.Call("HelloService.Hello", "Tom", &reply)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(reply)
}

跨语言使用

Go的rpc标准库请求模板.PNG

Go标准库的rpc响应模板.PNG

{"method":"HelloService.Hello","params":["hello"],"id":1}
{"id":1,"result":"hello:Tom","error":null}
无论采用何种语言，只要遵循同样的json结构，以同样的流程就可以和Go语言编写的RPC服务进行通信。这样我们就实现了跨语言的RPC。

HTTP上的RPC

func main() {
    rpc.RegisterName("HelloService", new(HelloService))
    http.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
        var conn io.ReadWriteCloser = struct {
            io.Writer
            io.ReadCloser
        }{
            ReadCloser: r.Body,
            Writer:     w,
        }
        rpc.ServeRequest(jsonrpc.NewServerCodec(conn)) 
   })
   http.ListenAndServe(":1234", nil)
}

Protobuf

Protobuf是Protocol Buffers的简称，它是Google公司开发的一种数据描述语言，并于2008年对外开源。Protobuf刚开源时的定位类似于XML、JSON等数据描述语言，通过附带工具生成代码并实现将结构化数据序列化的功能。但是我们更关注的是Protobuf作为接口规范的描述语言，可以作为设计安全的跨语言PRC接口的基础工具。

#hello.proto
syntax = "proto3";
option go_package = ".;main";
package main;
message String {
    string value = 1;
}

Protobuf核心的工具集是C++语言开发的，安装官方的protoc工具，可以从https://github.com/google/protobuf/releases下载。在官方的protoc编译器中并不支持Go语言。要想基于上面的hello.proto文件生成相应的Go代码，需要安装相应的插件。然后是安装针对Go语言的代码生成插件，可以通过go get google.golang.org/protobuf/cmd/protoc-gen-go命令安装（这个是老版本的：github.com/golang/protobuf/protoc-gen-go）。然后通过以下命令生成相应的Go代码：protoc --go_out=. hello.proto其中go_out参数告知protoc编译器去加载对应的protoc-gen-go工具，然后通过该工具生成代码，生成代码放到当前目录，最后是一系列要处理的protobuf文件的列表，此时目录下会有一个hello.pb.go的文件。

不过用Protobuf定义语言无关的RPC服务接口才是它真正的价值所在。修改一下上面的hello.proto文件：

#hello.proto
syntax = "proto3";
option go_package = ".;main";
package main;
message String {
    string value = 1;
}
service HelloService{
    rpc Hello (String) returns (String);
}

然后安装go get google.golang.org/grpc/cmd/protoc-gen-go-grpc，然后执行命令生成gRPC代码：protoc --go-grpc_out=. .\hello.proto。此时目录下会出现一个hello_grpc.pb.go的文件。

Protobuf的protoc编译器是通过插件机制实现对不同语言的支持。比如protoc命令出现--xxx_out格式的参数，那么protoc将首先查询是否有内置的xxx插件，如果没有内置的xxx插件那么将继续查询当前系统中是否存在protoc-gen-xxx命名的可执行程序，最终通过查询到的插件生成代码。在上面的例子中，--go_out=.会针对hello.proto文件里的message生成相关代码，而--go-grpc_out=.会针对hello.proto文件里的service生成相关代码。

gRPC

gRPC技术栈.PNG

安装gRPC的核心库：go get google.golang.org/grpc
上文讲的，执行protoc --go-grpc_out=. .\hello.proto就可以生成对应的grpc代码。gRPC插件会为服务端和客户端生成不同的接口：

//客户端
type helloServiceClient struct {
    cc grpc.ClientConnInterface
}
func NewHelloServiceClient(cc grpc.ClientConnInterface) HelloServiceClient {
    return &helloServiceClient{cc}
}
type HelloServiceClient interface {
    Hello(ctx context.Context, in *String, opts ...grpc.CallOption) (*String, error)
}
func (c *helloServiceClient) Hello(ctx context.Context, in *String, opts ...grpc.CallOption) (*String, error) {
    out := new(String)
    err := c.cc.Invoke(ctx, "/main.HelloService/Hello", in, out, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}
//服务端
type HelloServiceServer interface {
    Hello(context.Context, *String) (*String, error)
    mustEmbedUnimplementedHelloServiceServer()
}
func RegisterHelloServiceServer(s grpc.ServiceRegistrar, srv HelloServiceServer) {
    s.RegisterService(&_HelloService_serviceDesc, srv)
}
type UnimplementedHelloServiceServer struct {
}
func (UnimplementedHelloServiceServer) mustEmbedUnimplementedHelloServiceServer() {}

基于grpc重新实现前面的例子：

//服务端
package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
)

type HelloServiceImpl struct {
    UnimplementedHelloServiceServer
}

func (p *HelloServiceImpl) Hello(ctx context.Context, args *String) (*String, error) {
    reply := &String{Value: "hello " + args.GetValue()}
    return reply, nil
}

func main() {
    grpcServer := grpc.NewServer()
    RegisterHelloServiceServer(grpcServer, new(HelloServiceImpl))
    lis, err := net.Listen("tcp", ":8899")
    if err != nil {
        log.Fatal(err)
    }
    grpcServer.Serve(lis)
}
//----------------------------------------------------------------------
//客户端
package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/grpc"
)

func main() {
    conn, err := grpc.Dial("localhost:8899", grpc.WithInsecure())
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    clien := NewHelloServiceClient(conn)
    reply, err := client.Hello(context.Background(), &String{
        Value: "Wang",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(reply.GetValue())
}

gRPC流

RPC是远程函数调用，因此每次调用的函数参数和返回值不能太大，否则将严重影响每次调用的响应时间。因此传统的RPC方法调用对于上传和下载较大数据量场景并不适合。为此，gRPC框架针对服务器端和客户端分别提供了流特性。

gRPC和TLS

先分别生成服务端和客户端的私钥和证书：

#服务端
$ openssl genrsa -out server.key 2048
$ openssl req -new -x509 -days 3650 \
    -subj "/C=GB/L=China/O=grpc-server/CN=server.grpc.io" \
    -key server.key -out server.crt
----------------------------------------------------------------------------------
#客户端
$ openssl genrsa -out client.key 2048
$ openssl req -new -x509 -days 3650 \
    -subj "/C=GB/L=China/O=grpc-client/CN=client.grpc.io" \
    -key client.key -out client.crt

以上命令将生成server.key、server.crt、client.key和client.crt四个文件。其中以.key为后缀名的是私钥文件，需要妥善保管。以.crt为后缀名是证书文件，也可以简单理解为公钥文件，并不需要秘密保存。在subj参数中的/CN=server.grpc.io表示服务器的名字为server.grpc.io，在验证服务器的证书时需要用到该信息。