gRPC实操指南（golang）

1 RPC(Remote Procedure Call Protocol)

1.1 什么是RPC

RPC即远程调用协议&＃xff0c;简单来说就是调用远程的函数。

正常单机开发的情况下&＃xff0c;我们通过函数的方式实现部分功能的解耦

func sum(num1,num2 int) int {return num1 &＃43; num2
}


如上是一个最简单的求和函数&＃xff0c;我们只需要调用函数就可以实现求和的功能。

但大部分时候函数不会这么简单&＃xff0c;尤其对于非单机的分布式系统&＃xff0c;远程调用就尤为重要。

1.2 RPC业务场景

RPC的应用场景很广泛&＃xff1a;

•所有的分布式机都需要进行登陆的验证&＃xff0c;对于所有的主机都实现相同的登陆验证逻辑维护极差&＃xff0c;同时也失去部分分布式意义&＃xff0c;所以从解耦的角度考虑&＃xff0c;我们需要定义一个统一的登陆验证业务来做。•C/S架构的传输业务&＃xff0c;如股票软件&＃xff0c;每天需要用户登陆的时候去服务器拉取最新的数据&＃xff0c;或者较简单的文件传输业务&＃xff0c;登陆验证业务&＃xff0c;证书业务都可以使用rpc的方式•跨语言开发的项目&＃xff0c;比如web业务使用golang进行开发&＃xff0c;底层使用cpp或c&＃xff0c;部分脚本使用py&＃xff0c;跨语言通信可以通过RPC提供的不同语言的开发机制进行实现。

因而实际上&＃xff0c;RPC就是一个远程的函数&＃xff0c;只不过RPC协议做的就是把整个过程透明化&＃xff0c;以使得从开发角度来看&＃xff0c;和本地函数调用没有区别。

1.3 主流RPC框架

目前主流的RPC&＃xff0c;有ali的Dubbo&＃xff0c;还有google的gRPC&＃xff08;本文主题&＃xff09;等

一般RPC框架如下所示&＃xff1a;

•客户端&＃xff1a;客户端作为整个RPC业务的发起者&＃xff0c;如上所说的股票软件&＃xff0c;需要客户端主动发起请求去拉取最新的股票数据。•服务端&＃xff1a;服务端接受客户端的请求&＃xff0c;并做出相应的回应。简单来说&＃xff0c;函数实体在服务端&＃xff0c;数据处理在服务端。

服务端和客户端是每个RPC框架&＃xff0c;开发者可见度最高的部分&＃xff0c;实现RPC业务的重点就在于对C/S的设计和理解。首先&＃xff0c;客户端一定是率先发起请求的部分&＃xff0c;服务端一定是具体处理请求的部分。比如之前我们说的求和函数&＃xff0c;函数主体一定是在服务端&＃xff0c;客户端有两个数字num1&＃xff0c;num2&＃xff0c;向服务端发起RPC远程调用&＃xff0c;并最后拿到求和结果。

分清C/S很重要&＃xff01;&＃xff01;&＃xff01;&＃xff01;&＃xff01;

•客户端stub&＃xff0c;服务端stub&＃xff0c;可以变相的理解为应用层。主要是对客户端的rpc调用和服务端的返回进行序列化和反序列化&＃xff0c;并进行传输&＃xff0c;即把rpc业务抽象成tcp socket的send和receive。&＃xff08;gRPC使用的就是tcp&＃xff0c;http2.0协议&＃xff0c;建立在传输层&＃xff09;

2 gRPC

2.1 什么是gRPC

gRPC是google的开源RPC框架&＃xff0c;引用官网的一句话

A high-performance, open-source universal RPC framework


如图&＃xff0c;展示了gRPC跨语言开发的结构图&＃xff0c;本文将描述golang使用grpc的过程。

严格来说&＃xff0c;grpc通过tcp进行通信&＃xff0c;使用http2.0协议&＃xff0c;同时使用protobuf定义接口&＃xff0c;因而相对于传统的restful api来说&＃xff0c;速度更快&＃xff0c;数据更小&＃xff0c;接口要求更严谨。&＃xff08;protobuf此处不做详细介绍&＃xff0c;Google Protobuf[1]&＃xff09;

2.2 四种gRPC服务类型

准确来说不应称为四种&＃xff0c;实际上是因为rpc入参和出参都可实现流式或非流式&＃xff0c;进而排列组合形成四种常用的gRPC模式。

•简单RPC

即客户端发起一次请求&＃xff0c;服务端进行响应&＃xff08;类似restful api&＃xff09;。这种模式下&＃xff0c;rpc调用和本地函数基本相同&＃xff0c;常常用于登陆验证&＃xff0c;握手协议&＃xff0c;简单业务等。

    •客户端流RPC

即客户端流式发送请求&＃xff0c;有序发送很多req包&＃xff08;如文件流上传&＃xff09;&＃xff0c;server接收到所有的req包后会检测到EOF&＃xff0c;回发一个res并关闭连接。比如云计算应用&＃xff0c;客户端传输众多基础数据&＃xff0c;等待服务端计算完成并返回结果。

    •服务端流RPC

即客户端发起一次请求&＃xff0c;服务端会发很多res包&＃xff08;如文件流下载&＃xff09;&＃xff0c;server发送完成后关闭连接。常用于数据的拉取&＃xff0c;如请求大量数据&＃xff0c;无法及时进行反馈&＃xff0c;进而通过流式进行反馈。

    •双端流RPC

即双方对话&＃xff0c;可以实现一问一答&＃xff0c;一问多答&＃xff0c;多问一答等&＃xff0c;常用于聊天室等及时通讯业务。

3 gRPC实操

3.1 环境配置

3.1.1 首先使用go get获取grpc的官方软件包

go get google.golang.org/grpc


3.1.2 下载protobuf编译器

protobuf代码生成工具[2]&＃xff0c;通过proto文件生成对应的代码。

&＃xff08;此处需要加入环境变量&＃xff0c;各个系统操作不同&＃xff0c;不赘述&＃xff0c;protoc命令能够正常使用即可&＃xff09;

3.1.3 安装golang编译插件

我们需要.proto最终生成可用的golang代码&＃xff0c;因而需要独立安装golang grpc的插件

go get -u github.com/golang/protobuf/protoc-gen-go


3.2 编写proto文件

protobuf的详细语法见官方文档&＃xff0c;此处主要介绍rpc相关的内容

proto中rpc业务实际上就是一个函数&＃xff0c;由服务端重写&＃xff08;overwrite&＃xff09;的函数&＃xff0c;一般网上的文章会把gRPC分为四种&＃xff1a;简单RPC&＃xff0c;服务端流RPC&＃xff0c;客户端流RPC&＃xff0c;双端流RPC。实际上区别就在于rpc函数的入参和出参&＃xff0c;接下来详细介绍一下四种情况&＃xff0c;和一般的应用场景。

3.2.1 简单RPC

//指定使用proto3&＃xff08;proto2&＃xff0c;3有很多不同&＃xff0c;不可混写&＃xff09;
syntax &＃61; "proto3";
//指定生成的go_package,简单来说就是生成的go代码使用什么包&＃xff0c;即package proto
option go_package &＃61; ".;proto";//定义rpc服务
//此处rpc服务的定义&＃xff0c;一定要从服务端的角度考虑&＃xff0c;即接受请求&＃xff0c;处理请求并返回响应的一端
//请求接受一个LoginReq&＃xff08;username&＃43;password)
//响应回发一条msg&＃xff08;"true" or "false")
service Login{rpc Login(LoginReq)returns(LoginRes){}
}message LoginReq {string username &＃61; 1;string password &＃61; 2;
}message LoginRes {string msg &＃61; 1;
}


以上就是一个简单的RPC业务&＃xff0c;功能是进行登陆验证。

但实际上业务不会这么简单&＃xff0c;比如请求或者响应体特别大&＃xff0c;肯定不能封装到一个protobuf包进行传输&＃xff0c;因而需要使用流式传输&＃xff0c;如请求视频资源&＃xff0c;或者上传文件等&＃xff0c;此时就引出了两种单向流类型&＃xff0c;即客户端流和服务端流。

3.2.2 客户端流RPC

简单来说&＃xff0c;就是客户端请求是个流&＃xff0c;其他和简单RPC类似。

syntax &＃61; "proto3";
option go_package &＃61; ".;proto";//下载服务
//请求接受一个UploadReq&＃xff08;username&＃43;password)
//响应回发多条数据&＃xff08;"true" or "false")
service Upload{rpc Upload(stream UploadReq)returns(UploadRes){}
}message UploadReq {string path &＃61; 1;int64 offset &＃61; 2;int64 size &＃61; 3;bytes data &＃61; 4;
}message UploadRes {string msg &＃61; 1;
}


这里展示的应用场景为上传文件&＃xff0c;即客户端指定文件路径&＃xff0c;数据偏移量和大小&＃xff0c;以及传输的二进制数据&＃xff0c;打包通过protobuf发送给服务端&＃xff0c;服务端不停接受req并写文件&＃xff0c;最终写完之后给客户端一个反馈res。

RPC的流指的是客户端流式发送数据&＃xff0c;本质上是分块写的思想。即每个数据包指定路径&＃xff0c;偏移和写入大小&＃xff0c;同时包含数据内容&＃xff0c;每次写一个固定大小的块&＃xff08;如2M&＃xff09;&＃xff0c;流式指的是流式发送很多个块&＃xff0c;如1G为512个2M的块。

3.2.3 服务端流RPC

同上&＃xff5e;

syntax &＃61; "proto3";
option go_package &＃61; ".;proto";//下载服务
//请求接受一个DownloadReq&＃xff08;username&＃43;password)
//响应回发多条数据&＃xff08;"true" or "false")
service Download{rpc Download(DownloadReq)returns(stream DownloadRes){}
}message DownloadReq {string path &＃61; 1;int64 offset &＃61; 2;int64 size &＃61; 3;
}message DownloadRes {int64 offset &＃61; 1;int64 size &＃61; 2;bytes data &＃61; 3;
}


理解了客户端流&＃xff0c;服务端流也一样的道理&＃xff0c;客户端发送一个请求&＃xff0c;服务端不停的发送响应&＃xff0c;直到全部发送完成。

上述代码的场景即为下载文件&＃xff0c;发送一次请求&＃xff0c;请求读取某个路径下的文件&＃xff0c;比如读取6M大小&＃xff0c;从2M的位置开始读&＃xff0c;响应即分为三个块&＃xff0c;分别包含2-4&＃xff0c;4-6&＃xff0c;6-8的数据&＃xff08;块大小可以定制&＃xff0c;仅以2M举例&＃xff09;。

3.2.4 双端流RPC

双端流RPC就是入参&＃xff0c;出参皆为流。一般的应用场景&＃xff0c;如聊天室&＃xff0c;聊天室需要维持一个长链接&＃xff0c;连接过程中双方进行通信&＃xff0c;都是流式的信息&＃xff0c;类似应用场景使用双端流式的RPC。

综上&＃xff0c;其实分类的四种RPC本质上只是RPC函数在入参和出参上有一些不同&＃xff0c;本质上没有太大区别。但go中具体每个rpc业务的复写&＃xff0c;针对流式和非流式处理不同&＃xff0c;下面会详细描述&＃xff0c;golang中如何实现除双端流之外的三种RPC&＃xff08;双端流同理&＃xff09;。

3.3 生成go rpc代码

编写完proto文件就可以通过proto去生成对应的go语言代码了&＃xff5e;

protoc --go_out&＃61;plugins&＃61;grpc:. *.proto


protoc为编译器的命令&＃xff0c;指定使用插件为grpc&＃xff0c;输出目录为.&＃xff08;grpc:.&＃xff09;当前目录&＃xff0c;待编译文件为*.proto。此处可以指定某个文件编译&＃xff0c;也可以指定输出目录&＃xff0c;这条命令会编译当前目录下的所有proto文件并生成到当前目录。

以login为例子&＃xff0c;生成的pb.go&＃xff0c;rpc的核心就在Client和Server的两个interface中

Client interface

// LoginClient is the client API for Login service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LoginClient interface {Login(ctx context.Context, in *LoginReq, opts ...grpc.CallOption) (*LoginRes, error)
}


Server interface

// LoginServer is the server API for Login service.
type LoginServer interface {Login(context.Context, *LoginReq) (*LoginRes, error)
}


客户端调用Client interface的方法&＃xff0c;服务端重写Server interface的方法

一定要理解上述这句话&＃xff01;&＃xff01;&＃xff01;&＃xff01;&＃xff01;

例如这个列出服务器目录的rpc方法&＃xff0c;客户端只需要创建客户端实例对象&＃xff0c;然后调用这个方法就可以&＃xff0c;传入req&＃xff0c;接受res。因而我们说&＃xff0c;对于客户端来说&＃xff0c;此次调用和本地函数没有区别&＃xff0c;但实际上是gRPC实现的远程调用&＃xff0c;对于客户端开发是不可见的。

再说服务端&＃xff0c;服务端需要重写Server中的方法&＃xff0c;即服务端需要实现Server接口&＃xff0c;对req进行处理&＃xff0c;并生成res&＃xff0c;同时提供ctx上下文用作并发处理。

综上&＃xff01;&＃xff01;&＃xff01;&＃xff01;客户端是这个函数的调用者&＃xff0c;需要调用这个函数&＃xff0c;服务端是这个函数的定义者&＃xff0c;需要重写这个函数

3.4 服务端

下述代码皆可从我的github库中获得源码grpc-example[3]

3.4.1 重写Server interface

3.4.1.1 简单RPC

package mainimport ("context""grpcExample/simple_rpc/proto"
)type LoginServer struct {}//判断用户名&＃xff0c;密码是否为root,123456&＃xff0c;验证正确即返回
func (*LoginServer)Login(ctx context.Context, req *proto.LoginReq) (*proto.LoginRes, error) {//为降低复杂度&＃xff0c;此处不对ctx进行处理if req.Username &＃61;&＃61; "root" && req.Password &＃61;&＃61; "123456" {return &proto.LoginRes{Msg: "true"},nil} else {return &proto.LoginRes{Msg: "false"},nil}
}


此处的login函数即为server端重写的server interface的login函数&＃xff0c;目的是处理req&＃xff0c;生成res并返回。整个rpc业务的核心就在于服务端重写的方法&＃xff0c;此处验证用户名和密码并返回提示信息。&＃xff08;仅用于grpc演示&＃xff0c;忽略网络安全相关内容&＃xff09;

3.4.1.2 客户端流RPC

package mainimport ("grpcExample/client_stream_rpc/proto""io""log"
)type UploadServer struct{}func (*UploadServer) Upload(uploadServer proto.Upload_UploadServer) error {for {//循环接受客户端传的流数据recv, err :&＃61; uploadServer.Recv()//检测到EOF&＃xff08;客户端调用close&＃xff09;if err &＃61;&＃61; io.EOF {//发送reserr :&＃61; uploadServer.SendAndClose(&proto.UploadRes{Msg: "finish"})if err !&＃61; nil {return err}return nil} else if err !&＃61; nil{return err}log.Printf("get a upload data package~ offset:%v, size:%v\n",recv.Offset,recv.Size)}
}


客户端流式的rpc的入参是一个server对象&＃xff0c;可以通过这个server对象调用Recv函数获取客户端发送的每一个流。此处如果客户端关闭连接&＃xff0c;服务端会收到一个io.EOF的error&＃xff0c;因而此处需要对err进行判断处理&＃xff0c;如果客户端方传输完成关闭连接等待响应&＃xff0c;服务端检测到EOF&＃xff0c;应调用SendAndClose发送res响应信息并关闭连接&＃xff0c;进而完成客户端流的传输。

3.4.1.3 服务端流RPC

package mainimport ("grpcExample/server_stream_rpc/proto""log"
)type DownloadServer struct{}func (*DownloadServer) Download(req *proto.DownloadReq, downloadServer proto.Download_DownloadServer) error {offset :&＃61; req.Offset//循环发送数据for {err :&＃61; downloadServer.Send(&proto.DownloadRes{Offset: offset,Size: 4 * 1024,Data: nil,})if err !&＃61; nil {return err}offset &＃43;&＃61; 4 * 1024if offset >&＃61; req.Offset &＃43; req.Size {break}}return nil
}


3.4.2 注册服务

func main() {lis, err :&＃61; net.Listen("tcp", ":6012")if err !&＃61; nil {log.Fatalf("failed to listen: %v", err)}//构建一个新的服务端对象s :&＃61; grpc.NewServer()//向这个服务端对象注册服务proto.RegisterDownloadServer(s,&DownloadServer{})//注册服务端反射服务reflection.Register(s)//启动服务s.Serve(lis)//可配合ctx实现服务端的动态终止//s.Stop()
}


实际使用中&＃xff0c;可以将这部分独立为一个模块&＃xff0c;通过ctx控制server的启动和停止&＃xff0c;进而灵活的控制grpc服务。

3.5 客户端

3.5.1 调用Client func

3.5.1.1 简单RPC

package mainimport ("context""google.golang.org/grpc""grpcExample/simple_rpc/proto""log""time"
)func main() {//创立grpc连接grpcConn, err :&＃61; grpc.Dial("127.0.0.1"&＃43;":6012", grpc.WithInsecure())if err !&＃61; nil {log.Fatalln(err)}//通过grpc连接创建一个客户端实例对象client :&＃61; proto.NewLoginClient(grpcConn)//设置ctx超时&＃xff08;根据情况设定&＃xff09;ctx, cancel :&＃61; context.WithTimeout(context.Background(), 10*time.Second)defer cancel()//通过client客户端对象&＃xff0c;调用Login函数res, err :&＃61; client.Login(ctx, &proto.LoginReq{Username: "root",Password: "123456",})if err !&＃61; nil {log.Fatalln(err)}//输出登陆结果log.Println("the login answer is", res.Msg)
}


所以&＃xff0c;客户端只需要维持一个实例化的client对象&＃xff0c;通过client调用方法就可以使用RPC服务&＃xff0c;注意和服务端不同的是&＃xff0c;每个服务都需要一个客户端&＃xff0c;即服务端是在一个对象上注册很多个服务&＃xff0c;而客户端调用每个RPC业务都需要一个对应函数的Client对象。

3.5.1.2 客户端流RPC

package mainimport ("context""google.golang.org/grpc""grpcExample/client_stream_rpc/proto""log""time"
)func main(){//创立grpc连接grpcConn, err :&＃61; grpc.Dial("127.0.0.1"&＃43;":6012", grpc.WithInsecure())if err !&＃61; nil {log.Fatalln(err)}//通过grpc连接创建一个客户端实例对象client :&＃61; proto.NewUploadClient(grpcConn)//设置ctx超时&＃xff08;根据情况设定&＃xff09;ctx, cancel :&＃61; context.WithTimeout(context.Background(), 10*time.Second)defer cancel()//和简单rpc不同&＃xff0c;此时获得的不是res&＃xff0c;而是一个client的对象&＃xff0c;通过这个连接对象去发送数据uploadClient,err :&＃61; client.Upload(ctx)if err !&＃61; nil {log.Fatalln(err)}var offset int64var size int64size &＃61; 4 * 1024//循环处理数据&＃xff0c;当大于64kb退出for {err :&＃61; uploadClient.Send(&proto.UploadReq{Path: "../test.txt",Offset: offset,Size: size,Data: nil,})if err !&＃61; nil {log.Fatalln(err)}offset &＃43;&＃61; size//发送超过64KB&＃xff0c;调用CloseAndRecv方法接收responseif offset >&＃61; 64 * 1024 {res, err :&＃61; uploadClient.CloseAndRecv()if err !&＃61; nil {log.Fatalln(err)}log.Println("upload over~, response is ",res.Msg)break}}
}


客户端流在调用函数的时候获得的不是单纯的res对象&＃xff0c;而是一个client对象&＃xff0c;通过这个对象控制流的发送&＃xff0c;并且在发送完成后主动调用CloseAndRecv去关闭连接并接受服务端的返回res。

3.5.1.3 服务端流RPC

package mainimport ("context""google.golang.org/grpc""grpcExample/server_stream_rpc/proto""log""time"
)func main(){//创立grpc连接grpcConn, err :&＃61; grpc.Dial("127.0.0.1"&＃43;":6012", grpc.WithInsecure())if err !&＃61; nil {log.Fatalln(err)}//通过grpc连接创建一个客户端实例对象client :&＃61; proto.NewDownloadClient(grpcConn)//设置ctx超时&＃xff08;根据情况设定&＃xff09;ctx, cancel :&＃61; context.WithTimeout(context.Background(), 10*time.Second)defer cancel()//和简单rpc不同&＃xff0c;此时获得的不是res&＃xff0c;而是一个client的对象&＃xff0c;通过这个连接对象去读取数据downloadClient,err :&＃61; client.Download(ctx,&proto.DownloadReq{Path: "../test.txt",Offset: 0,Size: 64 * 1024,})if err !&＃61; nil {log.Fatalln(err)}//循环处理数据&＃xff0c;当监测到读取完成后退出for {res, err :&＃61; downloadClient.Recv()if err !&＃61; nil {log.Fatalln(err)}log.Printf("get a date package~ offset:%v, size:%v\n",res.Offset,res.Size)if res.Size &＃43; res.Offset >&＃61; 64 * 1024 {break}}log.Println("download over~")
}


此处获取的也是一个读取数据需要的对象&＃xff0c;即客户端发送请求后得到该对象&＃xff0c;通过该对象调用Recv来读取服务端流式发送的数据。

4 写在最后

建议先理解grpc的C/S架构

建议阅读&＃xff1a;

•Go gRPC教程[4]•gRPC-go example[5]

github(vx)&＃xff1a;cjq99419 欢迎提问和批评指正!

References

[1] Google Protobuf: https://developers.google.com/protocol-buffers
[2] protobuf代码生成工具: https://github.com/protocolbuffers/protobuf/releases
[3] grpc-example: https://github.com/cjq99419/grpc-example
[4] Go gRPC教程: https://studygolang.com/articles/28205
[5] gRPC-go example: https://github.com/grpc/grpc-go/tree/master/examples