利用Python语言的grpc实现消息传送详解
作者：we34dfg 发布时间：2023-09-12 14:00:07
标签：Python,grpc,消息
1. grpc开源包的安装
# conda
$ conda create -n grpc_env python=3.9
# install grpc
$ pip install grpc -i https://pypi.doubanio.com/simple
$ pip install grpc-tools -i https://pypi.doubanio.com/simple
# 有时proto生成py文件不对就是得换换grpc两个包的版本
2. grpc的使用之传送消息
整体结构，client.py server.py 和proto目录下的example.proto
1）在example.proto定义传送体
// 声明
syntax = "proto3";
package proto;
// service创建
service HelloService{
rpc Hello(Request) returns (Response) {} // 单单传送消息
}
// 请求参数消息体 1、2是指参数顺序
message Request {
string data = 1;
}
// 返回参数消息体
message Response {
int32 ret = 1; //返回码
string data = 2;
}
//python -m grpc_tools.protoc -I ./ --python_out=./ --grpc_python_out=./ ./example.proto
2) 在虚拟环境里使用命令生成py文件
$ conda activate grpc_env
$ f:
$ cd F:\examples
$ python -m grpc_tools.protoc -I ./ --python_out=./ --grpc_python_out=./ ./example.proto
在proto目录下会生成两个py文件，如下图所示：
3) 编辑client.py 和 server.py
# server.py
import time
import grpc
from concurrent import futures
from proto import example_pb2_grpc, example_pb2
class ServiceBack(example_pb2_grpc.HelloServiceServicer):
"""接口的具体功能实现"""
def Hello(self, request, context):
"""hello"""
data = request.data
print(data)
ret_data = "Response:" + data
return example_pb2.Response(ret=0, data=ret_data)
def server(ip: str, port: int) -> None:
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) # ⼤⼩为10的线程池
ai_servicer = ServiceBack()
example_pb2_grpc.add_HelloServiceServicer_to_server(ai_servicer, server)
server.add_insecure_port(f"{ip}:{port}")
server.start()
try:
print(f"server is started! ip:{ip} port:{str(port)}")
while True:
time.sleep(60 * 60)
except Exception as es:
print(es)
server.stop(0)
if __name__ == '__main__':
server("127.0.0.1", 8000)
# client.py
import grpc
from proto import example_pb2_grpc, example_pb2
def client(ip: str, port: int) -> None:
target = str(ip) + ":" + str(port)
channel = grpc.insecure_channel(target) # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
data = "hello 123"
request = example_pb2.Request(data=data)
res = cli.Hello(request)
print(f"ret：{res.ret}, data：{res.data}")
if __name__ == '__main__':
client("127.0.0.1", 8000)
3. grpc的使用之数据传输大小配置
默认情况下,gRPC 将传入消息限制为 4 MB。 传出消息没有限制。
1）example.proto定义不变
2）编辑client.py 和 server.py
# server.py
import time
import grpc
from concurrent import futures
from proto import example_pb2_grpc, example_pb2
class ServiceBack(example_pb2_grpc.HelloServiceServicer):
"""接口的具体功能实现"""
def Hello(self, request, context):
"""hello"""
data = request.data
print(data)
ret_data = "Response:" + data
return example_pb2.Response(ret=0, data=ret_data)
def server(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), options=options) # ⼤⼩为10的线程池
ai_servicer = ServiceBack()
example_pb2_grpc.add_HelloServiceServicer_to_server(ai_servicer, server)
server.add_insecure_port(f"{ip}:{port}")
server.start()
try:
print(f"server is started! ip:{ip} port:{str(port)}")
while True:
time.sleep(60 * 60)
except Exception as es:
print(es)
server.stop(0)
if __name__ == '__main__':
server("127.0.0.1", 8000)
# client.py
import grpc
from proto import example_pb2_grpc, example_pb2
def client(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
channel = grpc.insecure_channel(target, options=options) # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
data = "hello 123" * 1024 * 1024
request = example_pb2.Request(data=data)
res = cli.Hello(request)
print(f"ret：{res.ret}, data：{res.data}")
if __name__ == '__main__':
client("127.0.0.1", 8000)
4. grpc的使用之超时配置
1）example.proto定义不变
2）编辑client.py 和 server.py
# server.py
import time
import grpc
from concurrent import futures
from proto import example_pb2_grpc, example_pb2
class ServiceBack(example_pb2_grpc.HelloServiceServicer):
"""接口的具体功能实现"""
def Hello(self, request, context):
"""hello"""
data = request.data
print(data)
time.sleep(2)
ret_data = "Response:" + data
return example_pb2.Response(ret=0, data=ret_data)
def server(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), options=options) # ⼤⼩为10的线程池
ai_servicer = ServiceBack()
example_pb2_grpc.add_HelloServiceServicer_to_server(ai_servicer, server)
server.add_insecure_port(f"{ip}:{port}")
server.start()
try:
print(f"server is started! ip:{ip} port:{str(port)}")
while True:
time.sleep(60 * 60)
except Exception as es:
print(es)
server.stop(0)
if __name__ == '__main__':
server("127.0.0.1", 8000)
# client.py
import sys
import grpc
from proto import example_pb2_grpc, example_pb2
def client(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
channel = grpc.insecure_channel(target, options=options) # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
try:
data = "hello 123"
request = example_pb2.Request(data=data)
res = cli.Hello(request, timeout=1) # timeout 单位:秒
print(f"ret：{res.ret}, data：{res.data}")
except grpc.RpcError as rpc_error:
print("grpc.RpcError", rpc_error.details())
except Exception as es:
print(es)
finally:
sys.exit(-1)
if __name__ == '__main__':
client("127.0.0.1", 8000)
运行结果：
grpc.RpcError Deadline Exceeded
5. grpc之大文件之流stream传输
1）在example.proto重新定义传送体
// 声明
syntax = "proto3";
package proto;
// service创建
service HelloService{
rpc Hello(Request) returns (Response) {} // 单单传送消息
rpc ClientTOServer(stream UpFileRequest) returns (Response) {} // 流式上传文件
rpc ServerTOClient(Request) returns (stream UpFileRequest) {} // 流式下载文件
}
// 请求参数消息体 1、2是指参数顺序
message Request {
string data = 1;
}
// 返回参数消息体
message Response {
int32 ret = 1; //返回码
string data = 2;
}
message UpFileRequest {
string filename = 1;
int64 sendsize = 2;
int64 totalsize = 3;
bytes data = 4;
}
//python -m grpc_tools.protoc -I ./ --python_out=./ --grpc_python_out=./ ./example.proto
2）在虚拟环境里使用命令生成py文件，参考2. 2）
3）编辑client.py 和 server.py
# server.py
import os
import time
import grpc
from concurrent import futures
from proto import example_pb2_grpc, example_pb2
class ServiceBack(example_pb2_grpc.HelloServiceServicer):
"""接口的具体功能实现"""
def Hello(self, request, context):
"""hello"""
data = request.data
print(data)
time.sleep(2)
ret_data = "Response:" + data
return example_pb2.Response(ret=0, data=ret_data)
def ClientTOServer(self, request_iterator, context):
"""上传文件"""
data = bytearray()
for UpFileRequest in request_iterator:
file_name = UpFileRequest.filename
file_size = UpFileRequest.totalsize
file_data = UpFileRequest.data
print(f"文件名称：{file_name}， 文件总长度：{file_size}")
data.extend(file_data) # 拼接两个bytes
print(f"已接收长度：{len(data)}")
if len(data) == file_size:
with open("242_copy.mp3", "wb") as fw:
fw.write(data)
print(f"{file_name=} 下载完成")
(ret, res) = (0, file_name)
else:
print(f"{file_name=} 下载失败")
(ret, res) = (-1, file_name)
return example_pb2.Response(ret=ret, data=res)
def ServerTOClient(self, request, context):
"""下载文件"""
fp = request.data
print(f"下载文件：{fp=}")
# 获取文件名和文件大小
file_name = os.path.basename(fp)
file_size = os.path.getsize(fp) # 获取文件大小
# 发送文件内容
part_size = 1024 * 1024 # 每次读取1MB数据
count = 1
with open(fp, "rb") as fr:
while True:
try:
if count == 1:
count += 1
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size, sendsize=0, data=b"")
else:
context = fr.read(part_size)
if context:
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size,
sendsize=len(context),
data=context)
else:
print(f"发送完毕")
return 0
except Exception as es:
print(es)
def server(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), options=options) # ⼤⼩为10的线程池
ai_servicer = ServiceBack()
example_pb2_grpc.add_HelloServiceServicer_to_server(ai_servicer, server)
server.add_insecure_port(f"{ip}:{port}")
server.start()
try:
print(f"server is started! ip:{ip} port:{str(port)}")
while True:
time.sleep(60 * 60)
except Exception as es:
print(es)
server.stop(0)
if __name__ == '__main__':
server("127.0.0.1", 8000)
# client.py
import os
import sys
import grpc
from proto import example_pb2_grpc, example_pb2
def send_stream_data(fp: str):
"""迭代器发送大文件"""
# 获取文件名和文件大小
file_name = os.path.basename(fp)
file_size = os.path.getsize(fp) # 获取文件大小
# 发送文件内容
part_size = 1024 * 1024 # 每次读取1MB数据
count = 1
with open(fp, "rb") as fr:
while True:
try:
if count == 1:
count += 1
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size, sendsize=0, data=b"")
else:
context = fr.read(part_size)
if context:
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size, sendsize=len(context),
data=context)
else:
print(f"发送完毕")
return 0
except Exception as es:
print(es)
def client(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
channel = grpc.insecure_channel(target, options=options) # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
try:
data = "hello 123"
request = example_pb2.Request(data=data)
res = cli.Hello(request, timeout=1) # timeout 单位:秒
print(f"ret：{res.ret}, data：{res.data}")
except grpc.RpcError as rpc_error:
print("grpc.RpcError", rpc_error.details())
except Exception as es:
print(es)
finally:
sys.exit(-1)
def client_to_server(ip: str, port: int, fp: str):
"""
流式上传数据。
"""
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
channel = grpc.insecure_channel(target, options=options) # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
try:
request = send_stream_data(fp=fp)
res = cli.ClientTOServer(request, timeout=600) # timeout 单位:秒
print(f"ret：{res.ret}, data：{res.data}")
except grpc.RpcError as rpc_error:
print("grpc.RpcError", rpc_error.details())
except Exception as es:
print(es)
finally:
sys.exit(-1)
def server_to_client(ip: str, port: int, fp: str):
"""
流式上传数据。
"""
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
channel = grpc.insecure_channel(target, options=options) # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
try:
data = bytearray()
request = example_pb2.Request(data=fp)
filename = ""
for res in cli.ServerTOClient(request, timeout=300):
filename = res.filename
total_size = res.totalsize
data += res.data
if total_size == len(data):
with open("242_1.mp3", "wb") as fw:
fw.write(data)
print(f"{filename=} : {total_size=} 下载完成！")
else:
print(f"{filename=} 下载失败！")
except grpc.RpcError as rpc_error:
print("grpc.RpcError", rpc_error.details())
except Exception as es:
print(es)
finally:
sys.exit(-1)
if __name__ == '__main__':
# client("127.0.0.1", 8000)
# client_to_server("127.0.0.1", 8000, "242.mp3")
server_to_client("127.0.0.1", 8000, "242.mp3")
6. grpc之大文件之流async异步传输
# server.py
import os
import time
import grpc
from concurrent import futures
from proto import example_pb2_grpc, example_pb2
import asyncio
class ServiceBack(example_pb2_grpc.HelloServiceServicer):
"""接口的具体功能实现"""
def Hello(self, request, context):
"""hello"""
data = request.data
print(data)
time.sleep(2)
ret_data = "Response:" + data
return example_pb2.Response(ret=0, data=ret_data)
def ClientTOServer(self, request_iterator, context):
"""上传文件"""
data = bytearray()
for UpFileRequest in request_iterator:
file_name = UpFileRequest.filename
file_size = UpFileRequest.totalsize
file_data = UpFileRequest.data
print(f"文件名称：{file_name}， 文件总长度：{file_size}")
data.extend(file_data) # 拼接两个bytes
print(f"已接收长度：{len(data)}")
if len(data) == file_size:
with open("242_copy.mp3", "wb") as fw:
fw.write(data)
print(f"{file_name=} 下载完成")
(ret, res) = (0, file_name)
else:
print(f"{file_name=} 下载失败")
(ret, res) = (-1, file_name)
return example_pb2.Response(ret=ret, data=res)
def ServerTOClient(self, request, context):
"""下载文件"""
fp = request.data
print(f"下载文件：{fp=}")
# 获取文件名和文件大小
file_name = os.path.basename(fp)
file_size = os.path.getsize(fp) # 获取文件大小
# 发送文件内容
part_size = 1024 * 1024 # 每次读取1MB数据
count = 1
with open(fp, "rb") as fr:
while True:
try:
if count == 1:
count += 1
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size, sendsize=0, data=b"")
else:
context = fr.read(part_size)
if context:
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size,
sendsize=len(context),
data=context)
else:
print(f"发送完毕")
return 0
except Exception as es:
print(es)
async def server(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
server = grpc.aio.server(futures.ThreadPoolExecutor(max_workers=10), options=options) # ⼤⼩为10的线程池
ai_servicer = ServiceBack()
example_pb2_grpc.add_HelloServiceServicer_to_server(ai_servicer, server)
server.add_insecure_port(f"{ip}:{port}")
await server.start()
try:
print(f"server is started! ip:{ip} port:{str(port)}")
await server.wait_for_termination()
except Exception as es:
print(es)
await server.stop(None)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait([server("127.0.0.1", 8000)]))
loop.close()
# client.py
import os
import sys
import grpc
from proto import example_pb2_grpc, example_pb2
import asyncio
def send_stream_data(fp: str):
"""迭代器发送大文件"""
# 获取文件名和文件大小
file_name = os.path.basename(fp)
file_size = os.path.getsize(fp) # 获取文件大小
# 发送文件内容
part_size = 1024 * 1024 # 每次读取1MB数据
count = 1
with open(fp, "rb") as fr:
while True:
try:
if count == 1:
count += 1
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size, sendsize=0, data=b"")
else:
context = fr.read(part_size)
if context:
yield example_pb2.UpFileRequest(filename=file_name, totalsize=file_size, sendsize=len(context),
data=context)
else:
print(f"发送完毕")
return 0
except Exception as es:
print(es)
async def client(ip: str, port: int) -> None:
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
async with grpc.aio.insecure_channel(target, options=options) as channel: # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
try:
data = "hello 123"
request = example_pb2.Request(data=data)
res = await cli.Hello(request, timeout=3) # timeout 单位:秒
print(f"ret：{res.ret}, data：{res.data}")
except grpc.RpcError as rpc_error:
print("grpc.RpcError", rpc_error.details())
except Exception as es:
print(es)
finally:
sys.exit(-1)
async def client_to_server(ip: str, port: int, fp: str):
"""
流式上传数据。
"""
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
async with grpc.aio.insecure_channel(target, options=options) as channel: # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
try:
request = send_stream_data(fp=fp)
res = await cli.ClientTOServer(request, timeout=600) # timeout 单位:秒
print(f"ret：{res.ret}, data：{res.data}")
except grpc.RpcError as rpc_error:
print("grpc.RpcError", rpc_error.details())
except Exception as es:
print(es)
finally:
sys.exit(-1)
def server_to_client(ip: str, port: int, fp: str):
"""
流式上传数据。
"""
# 数据传输大小配置
max_message_length = 1024 * 1024 * 1024 # 1G
options = [('grpc.max_send_message_length', max_message_length),
('grpc.max_receive_message_length', max_message_length),
('grpc.enable_retries', 1),
]
target = str(ip) + ":" + str(port)
channel = grpc.insecure_channel(target, options=options) # 连接rpc服务器
cli = example_pb2_grpc.HelloServiceStub(channel) # 创建Stub
try:
data = bytearray()
request = example_pb2.Request(data=fp)
filename = ""
for res in cli.ServerTOClient(request, timeout=300):
filename = res.filename
total_size = res.totalsize
data += res.data
if total_size == len(data):
with open("242_1.mp3", "wb") as fw:
fw.write(data)
print(f"{filename=} : {total_size=} 下载完成！")
else:
print(f"{filename=} 下载失败！")
except grpc.RpcError as rpc_error:
print("grpc.RpcError", rpc_error.details())
except Exception as es:
print(es)
finally:
sys.exit(-1)
if __name__ == '__main__':
# asyncio.run(client("127.0.0.1", 8000))
asyncio.run(client_to_server("127.0.0.1", 8000, "242.mp3"))
# server_to_client("127.0.0.1", 8000, "242.mp3")
结论： 在本地测了一下不加async和加async的文件上传传送， async还慢点，嘿嘿嘿。
来源：https://blog.csdn.net/we34dfg/article/details/129663394
0
投稿猜你喜欢
前言：之前博主分享过knockoutJS和BootstrapTable的一些基础用法，都是写基础应用，根本谈不上封装，仅仅是避免了html控- 前言：之前，我写笔记的工具一直都是 notion，而且没有写博客的习惯。但是一是由于 notion 的服务器在
- 如下所示：from splinter.browser import Browserb = Browser('chrome')
- 本文实例讲述了Yii框架引用插件和ckeditor中body与P标签去除的方法。分享给大家供大家参考，具体如下：在Yii中引用插件注：插件和
- 场景：按下按钮，将左边的下拉选框内容发送给后端，后端再将返回的结果传给前端显示。按下按钮之前：按下按钮之后：代码结构这是flask默认的框架
- 300来行python代码实现简易版学生成绩管理系统，供大家参考，具体内容如下使用链表来实现class Node(object): def
- 代码如下:Function splitx(strs1 As String, strs2 A
- 1. 安装依赖pip install pypiserver passlib2. 创建packages目录mkdir packages3. 以
- 首先，与其他语言不同，JS的效率很大程度是取决于JS engine的效率。除了引擎实现的优劣外，引擎自己也会为一些特殊的代码模式采取一些优化
- 一、介绍Python远程调试，即在远程机器上运行python代码在本地进行调试，之前文章里的方式方法已经out，现在更新为当前版本已经成功实
- [1]定义:正则又叫规则或模式，是一个强大的字符串匹配工具，在javascript中是一个对象[2]特性：[2.1]贪婪性,匹配最长的[2.
- 在内容为主的网站中，搜索框往往是最常用的设计元素之一。从可用性的角度来看，搜索功能是用户有了明确的内容想看的时候最后使用的功能。如果一个网站
- 1.说明redis作为一个缓存数据库，在各方面都有很大作用，Python支持操作redis，如果你使用Django，有一个专为Django搭
- 前言在 Qt 中可以使用信号和槽机制很方便地实现部件之间的通信，考虑下面这样的场景：我想要点击任意一个专辑卡并通知主界面跳转到专辑界面，那么
- binlog二进制日志对于mysql数据库的重要性有多大，在此就不多说了。下面根据本人的日常操作经历，并结合网上参考资料，对binlog日志
- Error是Go语言开发中最基础也是最重要的部分，跟其他语言的try catch的作用基本一致，想想在PHP JAVA开发中，try cat
- pandas中的agg函数python中的agg函数通常用于调用groupby（）函数之后，对数据做一些聚合操作，包括sum，min,max
- 引言Supabase是一个自称的 "开源Firebase替代品"。我对与Supbase合作已经有一段时间了，我想我将尝试
- 一、引子Django 分页查询并返回 json ，需要将返回的 queryset 序列化， demo 如下：# coding=UTF-8im
- 拉勾网面试题1. 你首先说出三个不同的特殊数，要求必须是个位数，比如3、5、7。2. 让所有学生拍成一队，然后按顺序报数。3. 学生报数时，
