亲宝软件园·资讯

展开

Golang gRPC的Proxy的原理 Golang实现gRPC的Proxy的原理解析

Mr.YF 人气:0
想了解Golang实现gRPC的Proxy的原理解析的相关内容吗,Mr.YF在本文为您仔细讲解Golang gRPC的Proxy的原理的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Golang,gRPC的Proxy的原理,Golang,Proxy的原理,下面大家一起来学习吧。

背景

gRPC是Google开始的一个RPC服务框架, 是英文全名为Google Remote Procedure Call的简称。

广泛的应用在有RPC场景的业务系统中,一些架构中将gRPC请求都经过一个gRPC服务代理节点或网关,进行服务的权限现在,限流,服务调用简化,增加请求统计等等诸多功能。

如下以Golang和gRPC为例,解析gRPC的转发原理。

gRPC Proxy原理

基本原理如下

基于如上原理描述,通过如下图所示,gRPC的客户端将所有的请求都发给gRPC Server Proxy,这个代理网关实现请求转发。

将gRPC Client的请求流转发到gRPC 服务实现的节点上。并将服务处理结果响应返回给客户端。

在这个图中的转发需要回答如下几个问题

简化的gRPC服务处理流程

在回答如下问题之前,我们先简单的分析一下gRPC服务器的实现原理和流程。

简化的注册服务处理器函数,启动gRPC服务,调用请求和执行数据流图如下所示:

详细的gRPC服务运行原理

第一步,定义和编写HelloWorld的IDL文件

syntax = "proto3";

package demoapi;


// HelloWorld Service
service HelloWorldService {
   rpc HelloWorld(HelloWorldRequest) returns (HelloWorldResponse){};
}

// Request message
message HelloWorldRequest {
   string  request = 1;
}

// Response message
message HelloWorldResponse {
   string respose = 1;
}

在这个简单的IDL中,定义了一个HelloWorldService的gRPC服务,这个服务中有一个HelloWorld方法。

第二步,编译IDL文件

将IDL的proto文件编译成helloworld.pb.go的gRPC代码文件。

生成的代码文件中,我们可以看到如下信息

// Hello World的客户端接口
type HelloWorldServiceClient interface {
    HelloWorld(ctx context.Context, in *HelloWorldRequest, opts ...grpc.CallOption) (*HelloWorldResponse, error)
}

// Hello World的服务端接口
type HelloWorldServiceServer interface {
    HelloWorld(context.Context, *HelloWorldRequest) (*HelloWorldResponse, error)
}

// HelloWorld的服务注册处理器函数Handler
func _HelloWorldService_HelloWorld_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
    in := new(HelloWorldRequest)
    if err := dec(in); err != nil {
        return nil, err
    }
    if interceptor == nil {
        return srv.(HelloWorldServiceServer).HelloWorld(ctx, in)
    }
    info := &grpc.UnaryServerInfo{
        Server:     srv,
        FullMethod: "/demoapi.HelloWorldService/HelloWorld",
    }
    handler := func(ctx context.Context, req interface{}) (interface{}, error) {
        return srv.(HelloWorldServiceServer).HelloWorld(ctx, req.(*HelloWorldRequest))
    }
    return interceptor(ctx, in, info, handler)
}

// gRPC服务注册的服务描述信息
// gRPC服务注册时,会建立以ServiceName为Key,Methods为Value的一个Map映射
// Methods中的Handler就是如上的服务处理Handler
var _HelloWorldService_serviceDesc = grpc.ServiceDesc{
    ServiceName: "demoapi.HelloWorldService",
    HandlerType: (*HelloWorldServiceServer)(nil),
    Methods: []grpc.MethodDesc{
        {
            MethodName: "HelloWorld",
            Handler:    _HelloWorldService_HelloWorld_Handler,
        },
    },
    Streams:  []grpc.StreamDesc{},
    Metadata: "demoapi/HelloWorld.proto",
}

如上代码中有如下几个关键信息需要解释

第三步,注册HelloWorld服务到gRPC的服务映射中

对应的注册代码如下

// 注册gRPC服务
func RegisterHelloWorldServiceServer(s *grpc.Server, srv HelloWorldServiceServer) {
    s.RegisterService(&_HelloWorldService_serviceDesc, srv)
}

// Server is a gRPC server to serve RPC requests.
type Server struct {
       // ...
    m      map[string]*service // service name -> service info
}

// gRPC service.go的服务注册
func (s *Server) register(sd *ServiceDesc, ss interface{}) {
    srv := &service{
        server: ss,
        md:     make(map[string]*MethodDesc),
        sd:     make(map[string]*StreamDesc),
        mdata:  sd.Metadata,
    }
    for i := range sd.Methods {
        d := &sd.Methods[i]
        srv.md[d.MethodName] = d
    }
    for i := range sd.Streams {
        d := &sd.Streams[i]
        srv.sd[d.StreamName] = d
    }
    s.m[sd.ServiceName] = srv
}

第四步,接收客户端gRPC请求并处理

在这一步中,会进行如下几个步骤和函数的调用,也会回答前面的第一个问题。

整体的数据流整理如下:

我们发现在gRPC框架代码中的handleStream存在两类服务,一类是已知服务 knownService, 第二类是unknownService

这两个有什么区别呢?

已知服务 knownService就是gRPC服务端代码注册到gRPC框架中的服务,叫做已知服务,其他没有注册的服务叫做未知服务。

为什么我们要提到这个未知服务unknownService呢?着就是我们实现gRPC服务代码的关键所在,是前面问题三的答案,

要实现gRPC服务代理,我们在创建grpc服务grpc.NewServer时,传递一个未知服务的handler,将未知服务的处理进行接管,然后通过注册的这个Handler实现gRPC代理转发的逻辑。

基于如下描述,gRPC代理的原理如下图所示:

gRPC Proxy的实现逻辑如下图所示:

gRPC 代理服务的关键代码如下所示:

服务端到客户端的转发

// 转发服务端的数据流到客户端
func (s *handler) forwardServerToClient(src grpc.ServerStream, dst grpc.ClientStream) chan error {
    ret := make(chan error, 1)
    go func() {
        f := &frame{}
        for i := 0; ; i++ {
            if err := src.RecvMsg(f); err != nil {
                ret <- err // this can be io.EOF which is happy case
                break
            }
            if err := dst.SendMsg(f); err != nil {
                ret <- err
                break
            }
        }
    }()
    return ret
}

客户端到服务端的转发

// 转发客户端的数据流到服务端
func (s *handler) forwardClientToServer(src grpc.ClientStream, dst grpc.ServerStream) chan error {
    ret := make(chan error, 1)
    go func() {
        f := &frame{}
        for i := 0; ; i++ {
            if err := src.RecvMsg(f); err != nil {
                ret <- err // this can be io.EOF which is happy case
                break
            }
            if i == 0 {
                // This is a bit of a hack, but client to server headers are only readable after first client msg is
                // received but must be written to server stream before the first msg is flushed.
                // This is the only place to do it nicely.
                md, err := src.Header()
                if err != nil {
                    ret <- err
                    break
                }
                if err := dst.SendHeader(md); err != nil {
                    ret <- err
                    break
                }
            }
            if err := dst.SendMsg(f); err != nil {
                ret <- err
                break
            }
        }
    }()
    return ret
}

参考材料

https://github.com/grpc/grpc

https://github.com/mwitkow/grpc-proxy

加载全部内容

相关教程
猜你喜欢
用户评论