背景
gRPC是Google開始的一個RPC服務框架， 是英文全名為Google Remote Procedure Call的簡稱。
廣泛的應用在有RPC場景的業務系統中，一些架構中將gRPC請求都經過一個gRPC服務代理節點或閘道器，進行服務的許可權現在，限流，服務呼叫簡化，增加請求統計等等諸多功能。
如下以Golang和gRPC為例，解析gRPC的轉發原理。
gRPC Proxy原理
基本原理如下
- 基於TCP啟動一個gRPC代理服務
- 攔截gRPC框架的服務對映，能將gRPC請求的服務攔截到轉發代理的一個函式實現中。
- 接收客戶端的請求，處理業務指標後轉發給服務端。
- 接收服務端的響應，處理業務指標後轉發給客戶端。
基於如上原理描述，通過如下圖所示，gRPC的客戶端將所有的請求都發給gRPC Server Proxy，這個代理閘道器實現請求轉發。
將gRPC Client的請求流轉發到gRPC 服務實現的節點上。並將服務處理結果響應返回給客戶端。
在這個圖中的轉發需要回答如下幾個問題
- Proxy怎麼知道哪些請求轉發到哪些服務節點上，轉發的依據是什麼？
- Proxy是否需要解析gRPC協議？
- Proxy上沒有服務的實現，該如何轉發？
簡化的gRPC服務處理流程
在回答如下問題之前，我們先簡單的分析一下gRPC伺服器的實現原理和流程。
- 編寫自己的服務實現，例子中以HelloWorld為例。
- 把自己的服務實現註冊到gRPC框架中
- 建立一個TCP的服務端監聽
- 基於TCP監聽啟動一個gRPC服務
- gRPC服務接收gRPC客戶端的TCP請求
- 解析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", }
如上程式碼中有如下幾個關鍵資訊需要解釋
- 服務Service名稱 demoapi.HelloWorldService，對應IDL檔案的package包名.service服務名稱
- 方法Method名稱 HelloWorld，對應IDL檔案的rpc方法
第三步，註冊HelloWorld服務到gRPC的服務對映中
- grpc.ServiceDesc是 gRPC服務註冊的服務描述資訊。
- gRPC服務註冊時，會建立以ServiceName為Key，包裝Methods為Value的一個Map對映m。
- Methods中的Handler就是如上的服務處理Handler。
對應的註冊程式碼如下
// 註冊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客戶端通過TCP連結，連線到gRPC服務端
- gRPC的Serve函式觸發TCP的Accept函式呼叫，生成一個和客戶端的網路連線
- grpc框架程式碼執行handleRawConn方法，將這個網路連線設定打破gRPC的傳輸層，做為網路的讀和寫實現
- 依次呼叫grpc流的handlerStream方法，用於處理gRPC資料流
- 這個函式中會接收gRPC請求的頭資訊，並解析得到服務名 如第二步中的服務名 demoapi.HelloWorldService
- 通過如下的服務名中的方法名HelloWorld，並在Method的map中找到這個方法的處理器函式Handler，並執行這個Handler函式，實現gRPC服務的呼叫
- 最後將處理結果返回
整體的資料流整理如下：
我們發現在gRPC框架程式碼中的handleStream存在兩類服務，一類是已知服務 knownService, 第二類是unknownService
這兩個有什麼區別呢？
已知服務 knownService就是gRPC服務端程式碼註冊到gRPC框架中的服務，叫做已知服務，其他沒有註冊的服務叫做未知服務。
為什麼我們要提到這個未知服務unknownService呢？著就是我們實現gRPC服務程式碼的關鍵所在，是前面問題三的答案，
要實現gRPC服務代理，我們在建立grpc服務grpc.NewServer時，傳遞一個未知服務的handler，將未知服務的處理進行接管，然後通過註冊的這個Handler實現gRPC代理轉發的邏輯。
基於如下描述，gRPC代理的原理如下圖所示：
- 建立grpc服務時，註冊一個未知服務處理器Handler和一個自定義的編碼Codec編碼和解碼，此處使用proto標準的Codec（回答簽名第二個問題）
- 這個handle給業務方預留一個director的介面，用於代理重定向轉發的grpc連線獲取，這樣proxy就可以通過redirector得到gRPCServer的grpc連線。
- proxy接收gRPC客戶端的連線，並使用gRPC的RecvMsg方法，接收客戶端的訊息請求
- proxy將接收到的gRPC客戶端訊息請求，通過SendHeader和SendMsg方法傳送給gRPC服務端。
- 同樣的方法，RecvMsg接收gRPC服務端的響應訊息，使用SendMsg傳送給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/mwitkow/grpc-proxy
done。
祝玩的開心~