简介：

gRPC 是Google发布的一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。gRPC提供了支持多种编程语言的、对网络设备进行配置和纳管的方法。目前提供 C、Java 和 Go 语言版本，分别是：grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C# 支持。

gRPC

实现：

环境：

Python 3.8 or Anaconda3

grpcio

protobuf

通过pip安装依赖

pip install grpcio

pip install protobuf

pip install grpcio-tools

实现proto文件：

gRPC通过 protocol buffers来定义 gRPC service 和方法 request 以及 response 的类型。

要定义请求的和响应的数据类型，需要在 .proto 文件中指定关键字 message。要定义一个服务，需要 .proto 文件中指定关键字 service。

gRPC 允许你定义四类服务方法，通过stream关键字来控制：

一元模式RPC，即客户端发送一个请求给服务端，从服务端获取一个应答，就像一次普通的函数调用。

服务端流模式 RPC，即客户端发送一个请求给服务端，可获取一个数据流用来读取一系列消息。客户端从返回的数据流里一直读取直到没有更多消息为止。

客户端流模式 RPC，即客户端用提供的一个数据流写入并发送一系列消息给服务端。一旦客户端完成消息写入，就等待服务端读取这些消息并返回应答。

双向流模式 RPC，即两边都可以分别通过一个读写数据流来发送一系列消息。这两个数据流操作是相互独立的，所以客户端和服务端能按其希望的任意顺序读写，例如：服务端可以在写应答前等待所有的客户端消息，或者它可以先读一个消息再写一个消息，或者是读写相结合的其他方式。每个数据流里消息的顺序会被保持。

如下一个简单地grpc proto文件demo.proto，定义了数据传输的格式和四种不同的服务类型：

// protocal buffers 语法版本声明

syntax="proto3";

// message 定义了传输数据的格式，等号之后的数字是字段编号，每个编号都是唯一的。message结构类似于结构体

message Request {

int32 client_id = 1;

string request_data = 2;

}

message Response {

int32 server_id = 1;

string response_data = 2;

}

// 定义gRPC服务方法

service gRPCDemo {

// 一元模式(在一次调用中, 客户端只能向服务器传输一次请求数据, 服务器也只能返回一次响应)

rpc SimpleMethod(Request) returns (Response);

// 客户端流模式(在一次调用中, 客户端可以多次向服务器传输数据, 但是服务器只能返回一次响应)

rpc ClientStreamMethod(stream Request) returns (Response);

// 服务端流模式(在一次调用中, 客户端只能一次向服务器传输数据, 但是服务器可以多次返回响应)

rpc ServerStreamMethod(Request) returns (stream Response);

// 双向流模式 (在一次调用中, 客户端和服务器都可以向对方多次收发数据)

rpc BidirectStremMethod(stream Request) returns (stream Response);

}

通过下列命令可以根据demo.proto自动生成客户端和服务端的代码，我们需要做的只是继承里面实现具体处理逻辑的方法并实现他们，而不需要关系具体的传输逻辑。

python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. ./demo.proto

执行后会生成demo_pb2.py和demo_pb2_grpc.py两个文件，里面分别实现了消息类、服务的抽象类和客户端应用使用的函数。

实现服务端与客户端：

服务端：

继承gRPCDemoServicer的抽象类，实现proto里定义的函数。一元模式接收和返回的是request类和response类，流模式接收和返回的是类的迭代器。

import grpc

import demo_pb2

import demo_pb2_grpc

from concurrent import futures

from threading import Thread

SERVER_ID = 1

SERVER_ADDRESS = "localhost:50051"

class DemoService(demo_pb2_grpc.gRPCDemoServicer):

def SimpleMethod(self, request, context):

print('call simple method from client {}'.format(request.client_id))

print('data details: {}'.format(request.request_data))

reponse = demo_pb2.Response(server_id=SERVER_ID, response_data='simple data')

return reponse

def ClientStreamMethod(self, request_iterator, context):

for i, request in enumerate(request_iterator):

print('data {} details: {}'.format(i, request.request_data))

reponse = demo_pb2.Response(server_id=SERVER_ID, response_data='client stream data')

return reponse

def ServerStreamMethod(self, request, context):

for i in range(5):

response = demo_pb2.Response(server_id=SERVER_ID, response_data='server stream data {}'.format(i))

yield response

def BidirectStremMethod(self, request_iterator, context):

# 开启一个子线程去接收数据

def parse_request():

for request in request_iterator:

print("recv from client(%d), message= %s" %

(request.client_id, request.request_data))

t = Thread(target=parse_request)

t.start()

for i in range(5):

yield demo_pb2.Response(

server_id=SERVER_ID,

response_data=("send by Python server, message= %d" % i))

t.join()

def main():

server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))

demo_pb2_grpc.add_gRPCDemoServicer_to_server(DemoService(), server)

server.add_insecure_port(SERVER_ADDRESS)

print("------------------start Python GRPC server")

server.start()

server.wait_for_termination()

if __name__ == '__main__':

main()

客户端：

与服务端通过指定端口建立通道，通过gRPCDemoStub类实例化一个客户端向服务端发送请求。客户端可以像调用本地函数一样来调用服务端的函数。

import grpc

import time

import demo_pb2

import demo_pb2_grpc

client_ID = 1

SERVER_ADDRESS = "localhost:50051"

def simple_method(stub):

request = demo_pb2.Request(client_id=client_ID, request_data='simple call')

response = stub.SimpleMethod(request)

print(response.response_data)

def client_stream_method(stub):

# 创建一个生成器

def request_messages():

for i in range(5):

request = demo_pb2.Request(

client_id=client_ID,

request_data=("called by Python client, message:%d" % i))

yield request

response = stub.ClientStreamingMethod(request_messages())

def server_stream_method(stub):

request = demo_pb2.Request(client_id=client_ID, request_data='server stream call')

response = stub.ServerStreamMethod(request)

for res in response:

print(res.response_data)

def bidirectional_streaming_method(stub):

print("--------------Call BidirectionalStreamingMethod Begin---------------")

# 创建一个生成器

def request_messages():

for i in range(5):

request = demo_pb2.Request(

client_id=client_ID,

request_data=("called by Python client, message: %d" % i))

yield request

time.sleep(1)

response_iterator = stub.BidirectionalStreamingMethod(request_messages())

for response in response_iterator:

print("recv from server(%d), message=%s" % (response.server_id, response.response_data))

print("--------------Call BidirectionalStreamingMethod Over---------------")

def main():

MAX_MESSAGE_LENGTH = 1024 * 1024 * 10

options = [('grpc.max_send_message_length', MAX_MESSAGE_LENGTH),

('grpc.max_receive_message_length', MAX_MESSAGE_LENGTH)]

with grpc.insecure_channel(SERVER_ADDRESS, options=options) as channel:

stub = demo_pb2_grpc.gRPCDemoStub(channel)

simple_method(stub)

# server_stream_method(stub)

if __name__ == '__main__':

main()

通信测试：

一元模式：

服务端挂起在50051端口等待请求，客户端发起一次请求服务端对应的函数就被调用一次。

server

服务端流模式：

服务端挂起在50051端口等待请求，客户端发起多次请求，服务端函数仅调用一次，将客户端的多次请求当做一个迭代器来处理。

client

server