python对于grpc的简单操作（三）

已于 2023-09-20 13:27:12 修改
阅读量3k 收藏 10
点赞数 2
分类专栏： grpc 网络相关 写着玩 文章标签： python rpc grpc
于 2022-08-09 14:39:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43810267/article/details/126222414
版权

python对于grpc的简单操作（三）


今天介绍python对于grpc的流式传输，主要有三种，以及视频的流式传输

  1. 客户端流，服务端非流（单流）
  2. 服务端流，客户端非流（单流）
  3. 客户端流，服务端流（双流）

PS：其实无论是单流还是双流，都是在客户端和服务端建立长连接

（一）客户端流，服务端非流（单流）

上proto：

syntax = "proto3";   // 指定protobuf版本

package test;   // 此文件的标识符,不添加也可以,以防止协议消息类型之间的名称冲突

// 定义消息结构类型，字段编号，可不从1开始，但不能重复，request为数据结构名，可自由定义
message request {
	string message = 1;
}


// 定义消息结构类型，数据后面的编号不能重复，response为数据结构名，可自由定义
message response {
	string message = 1;
}

//定义服务，下面定义的这种为最简单的rpc服务，客户端发起请求，服务端返回结果,stream关键字用来定义流式传输
service StreamTest {
	rpc ClientStream (stream request) returns (response) {}
}

client.py

import logging
import time
import grpc
import test_pb2
import test_pb2_grpc


def send_stream():
    message_list = ['1', '2', '3', '4', '5', '6', '7']
    for i in message_list:
        # return #如果想主动断开，可以提前return
        yield test_pb2.request(message=i)
        time.sleep(1)


def run():
    with grpc.insecure_channel('localhost:10086') as channel:
        client = test_pb2_grpc.StreamTestStub(channel)  # 客户端使用Stub类发送请求,参数为频道,为了绑定链接
        response = client.ClientStream(send_stream())  # 需要将上面的send_stream传进来
        print('返回结果:', response.message)


if __name__ == '__main__':
    logging.basicConfig()
    run()

server.py

from concurrent import futures
import logging
import time
import grpc
import test_pb2
import test_pb2_grpc


class StreamTest(test_pb2_grpc.StreamTestServicer):
    def ClientStream(self, request_iterator, context):
        for i in request_iterator:
            # print(dir(request_iterator))
            print(i.message)
            # if i.message == '5':
            #     break
            #     return test_pb2.response(message='提前返回')

        return test_pb2.response(message='ok')

#如果想提前中断传输，客户端可以在接收函数在break或提前return
def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))  # 开启多线程
    test_pb2_grpc.add_StreamTestServicer_to_server(StreamTest(), server)  # 注册本地服务
    server.add_insecure_port('[::]:10086')  # 指定端口以及IP
    # server.add_insecure_port('0.0.0.0:10086')# 指定端口以及IP
    server.start()  # 启动服务器 start()是非阻塞的, 将实例化一个新线程来处理请求
    server.wait_for_termination()  # 阻塞调用线程，直到服务器终止


if __name__ == '__main__':
    logging.basicConfig()
    serve()

运行结果
在这里插入图片描述

（二）服务端流，客户端非流（单流）

上proto

syntax = "proto3";   // 指定protobuf版本

package test;   // 此文件的标识符,不添加也可以,以防止协议消息类型之间的名称冲突

// 定义消息结构类型，字段编号，可不从1开始，但不能重复，request为数据结构名，可自由定义
message request {
	string message = 1;
}


// 定义消息结构类型，数据后面的编号不能重复，response为数据结构名，可自由定义
message response {
	string message = 1;
}

//定义服务，下面定义的这种为最简单的rpc服务，客户端发起请求，服务端返回结果,stream关键字用来定义流式传输
service StreamTest {
	rpc ClientStream (stream request) returns (response) {}//客户端发流
	rpc ServerStream (request) returns (stream response) {}//服务端发流
}

client.py

import logging
import time
import grpc
import test_pb2
import test_pb2_grpc


def run():
    with grpc.insecure_channel('localhost:10086') as channel:
        client = test_pb2_grpc.StreamTestStub(channel)  # 客户端使用Stub类发送请求,参数为频道,为了绑定链接
        response = client.ServerStream(test_pb2.request(message='start'))  # 返回结果是一个迭代器
        for i in response:
            print('返回结果:', i.message)
            # if i.message == '5':#客户端主动断开连接可使用braek或return
            #     return


if __name__ == '__main__':
    logging.basicConfig()
    run()

server.py

from concurrent import futures
import logging
import time
import grpc
import test_pb2
import test_pb2_grpc


class StreamTest(test_pb2_grpc.StreamTestServicer):
    def ClientStream(self, request_iterator, context):
        for i in request_iterator:
            print(i.message)
        return test_pb2.response(message='ok')

    def ServerStream(self, request, context):
        print(request)
        message_list = ['1', '2', '3', '4', '5', '6', '7']
        for i in message_list:
            # if context.is_active():#context.is_active()判断连接状态

            # if i == '5':#服务端主动断开连接可使用braek或return
            #     return

            time.sleep(1)
            print('给客户端发送数据', i)
            yield test_pb2.response(message=i)
        print(context.is_active())


def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))  # 开启多线程
    test_pb2_grpc.add_StreamTestServicer_to_server(StreamTest(), server)  # 注册本地服务
    server.add_insecure_port('[::]:10086')  # 指定端口以及IP
    # server.add_insecure_port('0.0.0.0:10086')# 指定端口以及IP
    server.start()  # 启动服务器 start()是非阻塞的, 将实例化一个新线程来处理请求
    server.wait_for_termination()  # 阻塞调用线程，直到服务器终止


if __name__ == '__main__':
    logging.basicConfig()
    serve()

运行效果
在这里插入图片描述

（三）客户端流，服务端流（双流）

上proto

syntax = "proto3";   // 指定protobuf版本

package test;   // 此文件的标识符,不添加也可以,以防止协议消息类型之间的名称冲突

// 定义消息结构类型，字段编号，可不从1开始，但不能重复，request为数据结构名，可自由定义
message request {
	string message = 1;
}


// 定义消息结构类型，数据后面的编号不能重复，response为数据结构名，可自由定义
message response {
	string message = 1;
}

//定义服务，下面定义的这种为最简单的rpc服务，客户端发起请求，服务端返回结果,stream关键字用来定义流式传输
service StreamTest {
	rpc ClientStream (stream request) returns (response) {}//客户端发流
	rpc ServerStream (request) returns (stream response) {}//服务端发流
	rpc BothStream (stream request) returns (stream response) {}//双流
}

client.py

import logging
import time
import grpc
import test_pb2
import test_pb2_grpc


def send_stream():
    message_list = ['1', '2', '3', '4', '5', '6', '7']
    for i in message_list:
        time.sleep(1)
        yield test_pb2.request(message=i)


def run():
    with grpc.insecure_channel('localhost:10086') as channel:
        client = test_pb2_grpc.StreamTestStub(channel)  # 客户端使用Stub类发送请求,参数为频道,为了绑定链接
        response = client.BothStream(send_stream())  # 返回结果是一个迭代器
        for i in response:
            print('客户端收到', i.message)


if __name__ == '__main__':
    logging.basicConfig()
    run()

server.py

from concurrent import futures
import logging
import time
import grpc
import test_pb2
import test_pb2_grpc

from threading import Thread


def send(message):
    for i in message:
        yield test_pb2.response(message=i)


class StreamTest(test_pb2_grpc.StreamTestServicer):
    def ClientStream(self, request_iterator, context):
        for i in request_iterator:
            print(i.message)
        return test_pb2.response(message='ok')

    def ServerStream(self, request, context):
        print(request)
        message_list = ['1', '2', '3', '4', '5', '6', '7']
        for i in message_list:
            time.sleep(1)
            print('给客户端发送数据', i)
            yield test_pb2.response(message=i)

    def BothStream(self, request_iterator, context):

        for i in request_iterator:
        	#当然下面的yield也可以放在这，是可以同时接收和发送的
            print('服务端收到',i.message)

        for j in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
            time.sleep(1)
            yield test_pb2.response(message=j)


def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))  # 开启多线程
    test_pb2_grpc.add_StreamTestServicer_to_server(StreamTest(), server)  # 注册本地服务
    server.add_insecure_port('[::]:10086')  # 指定端口以及IP
    # server.add_insecure_port('0.0.0.0:10086')# 指定端口以及IP
    server.start()  # 启动服务器 start()是非阻塞的, 将实例化一个新线程来处理请求
    server.wait_for_termination()  # 阻塞调用线程，直到服务器终止


if __name__ == '__main__':
    logging.basicConfig()
    serve()

执行效果
在这里插入图片描述

（四）视频的流式传输

proto文件

syntax = "proto3";   // 指定protobuf版本

package test;   // 此文件的标识符,不添加也可以,以防止协议消息类型之间的名称冲突

// 定义消息结构类型，字段编号，可不从1开始，但不能重复，request为数据结构名，可自由定义
message request {
	bytes data = 1;
}


// 定义消息结构类型，数据后面的编号不能重复，response为数据结构名，可自由定义
message response {
	string message = 1;
}

//定义服务，下面定义的这种为最简单的rpc服务，客户端发起请求，服务端返回结果,stream关键字用来定义流式传输
service StreamTest {
	rpc ClientStream (stream request) returns (response) {}
}

client.py

import logging
import os
import grpc
import test_pb2
import test_pb2_grpc



def send_stream():
    with open('input.mp4', 'rb') as f:
        size = os.path.getsize('input.mp4') / 1024
        n = 0
        while True:
            content = f.read(1024)
            if content:
                n = n + 1
                print('传输进度:{}%'.format(round(n / size * 100, 2)))
                yield test_pb2.request(data=content)
            else:
                break


def run():
    with grpc.insecure_channel('localhost:10086', options=[
        ('grpc.max_send_message_length', 256 * 1024 * 1024),  # 修改数据传输的大小限制，因为图片数据可能较大
        ('grpc.max_receive_message_length', 256 * 1024 * 1024),
    ]) as channel:
        client = test_pb2_grpc.StreamTestStub(channel)  # 客户端使用Stub类发送请求,参数为频道,为了绑定链接
        response = client.ClientStream(send_stream())  # 需要将上面的send_stream传进来
        print('返回结果:', response.message)


if __name__ == '__main__':
    logging.basicConfig()
    run()

server.py

from concurrent import futures
import logging
import time

import grpc
import test_pb2
import test_pb2_grpc



class StreamTest(test_pb2_grpc.StreamTestServicer):
    def ClientStream(self, request_iterator, context):
        with open('output.mp4', 'wb') as f:
            for i in request_iterator:
                f.write(i.data)

        print('接收完成')

        return test_pb2.response(message='ok')


# 如果想提前中断传输，客户端可以在接收函数在break或提前return
def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),options=[
        ('grpc.max_send_message_length', 256 * 1024 * 1024),  # 修改数据传输的大小限制，因为图片数据可能较大
        ('grpc.max_receive_message_length', 256 * 1024 * 1024),
    ])  # 开启多线程
    test_pb2_grpc.add_StreamTestServicer_to_server(StreamTest(), server)  # 注册本地服务
    server.add_insecure_port('[::]:10086')  # 指定端口以及IP
    # server.add_insecure_port('0.0.0.0:10086')# 指定端口以及IP
    server.start()  # 启动服务器 start()是非阻塞的, 将实例化一个新线程来处理请求
    server.wait_for_termination()  # 阻塞调用线程，直到服务器终止


if __name__ == '__main__':
    logging.basicConfig()
    serve()

执行效果
在这里插入图片描述

（五）结语

如果有什么错误的地方，还请大家批评指正。最后，希望小伙伴们都能有所收获。写这些，仅记录自己学习python操作grpc的过程在这里插入图片描述

gRPC：gRPC在Python中的实现
kkchenjj的博客
07-12 1264
在gRPC中，服务接口的定义是通过.proto文件完成的。这个文件使用Protocol Buffers语言，不仅定义了服务的接口，还描述了服务中方法的参数和返回类型。下面是一个简单的.proto文件示例，定义了一个名为Greeter的服务，该服务有一个SayHello方法，接收一个消息并返回一个HelloReply消息。// 定义消息类型// 定义服务在这个例子中，和HelloReply是消息类型，分别包含一个string字段。SayHello方法是一个RPC（远程过程调用）方法，它接收一个。
Python-gRPC实践(3)--使用Python实现gRPC服务
Saki_Python的博客
10-26 1671
通过前面的文章了解到了gRPC是什么，以及清楚使用它的优缺点，现在终于可以开始实现一个gRPC服务了。这里演示的是一个用户与书互动的项目，用户可以通过该项目进行注册，登录，注销等操作，同时也可以上传，查看和评论对应的书籍，通常情况下我们会由一个简单的Web应用来提供这些服务，现在，我们假设这个服务非常庞大，需要把他们按照功能拆分成不同的微服务了，这些服务与Web应用通过gRPC进行通信。注：由于篇幅原因，不会夹杂大量的源代码，需要跳转到Github。
Python grpc超时机制代码示例
09-16
主要介绍了Python grpc超时机制代码示例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python对于grpc的简单操作（一）
????爱好者的博客
08-02 5954
python对grpc的简单操作，以及图片如何通过grpc在客户端和服务端之间传输
python基础13 gRPC的使用（一）
最新发布
genispan的专栏
04-09 816
包含一系列名称-值对的信息的逻辑记录。每个项目通常称为字段。记录中必须定义字段类型、字段名称和字段编号。字段编号作为唯一标识符，不应更改。它从 1 开始，1 到 15 范围内的数字需要一个字节来编码。另一方面，16 到 2047 范围内的数字需要两个字节进行编码。在上述示例中，gRPC服务接收两个参数（一个int32类型和一个string类型），并返回一个string类型。代表服务定义。每个服务可以有一个或多个具有自己的请求和响应定义的 rpc。//其他rpc定义。
用Python进行gRPC接口测试(二)
m0_75277660的博客
11-15 181
各位被困在家中的小伙伴们，大家新年好~今天将继续为大家带来用Python进行gRPC接口测试的续集，上次主要讲了一下前期准备工作和简单RPC通信方式的实现，这次我们将着眼于另一类gRPC接口的通信形式——流式RPC。
Python语言实现gRPC通信
热门推荐
bocai_xiaodaidai的博客
01-13 1万+
gRPC 简介： gRPC 是一款高性能、开源的 RPC 框架，产自 Google，基于 ProtoBuf 序列化协议进行开发，支持多种语言（Golang、Python、Java等），本篇只介绍 Python 的 gRPC 使用。因为 gRPC 对 HTTP/2 协议的支持使其在 Android、IOS 等客户端后端服务的开发领域具有良好的前景。gRPC 提供了一种简单的方法来定义服务，同时客...
python-gRPC
未知的无限可能
07-24 1553
​ python语言的gRPC操作，服务和服务之间调用需要使用RPC，gRPC是一款语言中立、平台中立、开源的远程过程调用系统，gRPC客户端和服务端可以在多种环境中运行和交互，例如用java写一个服务端，可以用go语言写客户端调用。
python实现GRPC
guzhoumingyue的专栏
07-20 566
gRPC是Google开发的一种高性能、开源的远程过程调用(RPC)框架，它支持多种编程语言，包括Python。使用gRPC可以轻松地构建分布式系统，使得不同服务之间的通信更加简单、高效。这就是一个简单的Python实现gRPC的demo。你可以根据自己的需求定制更复杂的服务和消息类型。前者包含了消息类型的定义，后者包含了gRPC服务的定义。
python grpc多进程_python-gRPC使用
weixin_39691055的博客
12-21 1164
什么是gRPC在 gRPC 里客户端 应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法(包含参数和返回类型)。在服务端实现这个接口，并运行一个 gRPC 服务器来处理客户端调用。在客户端拥有一个存根 能够像服务端一样的方法。如何使用grpc在...
python-gRPC 异常处理
酱橙的博客
08-16 3385
简单介绍 当我们通过 grpc 进行客户端服务端通信时，健全的代码应该尽可能的对不同的异常情况进行捕获并做出相应的处理。对于 grpc的话，我们可以通过 try-catch 的形式来进行捕获. 例如像是下面这样子： 应用层可以就像下面这样子进行书写，当然这种感觉不是特别好，具体可以参考本文后面的内容。 try: response = stub.SayHello(...) except grpc.RpcError as rpc_error: if rpc_error.code() ==
python发起grpc请求
qq_33306427的博客
03-10 464
python发起grpc请求
grpc python实现_python 使用gRPC
weixin_39706127的博客
12-22 372
Python gRPC简介grpc 是google 开源的一款rpc服务框架，可以轻松的实现跨语言的微服务，将项目中的各个模块独立出来，单独部署，独立升级，也可以根据模块的情况进行不同语言的变成。gRPC也是一个C/S框架，使用的是HTTP2 协议进行通信。准备.proto文件syntax = "proto3";package order;message OrderRequest {string ...
gRPC python教程
heroacool的专栏
07-27 206
目前来看最清晰的grpc python教程 https://www.jianshu.com/p/43fdfeb105ff?from=timeline&isappinstalled=0
grpc传输大量数据python_基于grpc的流式方式实现双向通讯(python)
weixin_39614276的博客
12-08 506
grpc介绍grpc是谷歌开源的一套基于rpc实现的通讯框架(官网有更完整的定义)。在搞懂grpc之前，首先要弄懂rpc是什么。下面是自己理解的rpc定义，若有不对，望指出：rpc官方称为 远程过程调用 。我这里理解为远程函数调用，即一个本机程序调用另一个机器的程序中的某个函数。因不是同一机器调用，故需要远程访问操作。与远程过程调用相反的则是“近程过程调用”(哈哈，自己乱起的)。其实就是实现和调用...
gRPC 框架 简单使用（python版）
Java_KW的博客
04-21 1万+
文章目录一、gRPC 简介概述协议缓冲区二、gRPC 的 Hello World协议缓冲区gRPC 服务端gRPC 客户端启动 gRPC 一、gRPC 简介 概述 gRPC是搭建分布式应用接口和客户端的框架。在 gRPC 中，客户端应用程序可以直接调用不同机器上的服务器应用程序上的方法，就像它是本地对象一样，可以更容易创建分布式应用程序和服务。与许多 RPC 系统一样，gRPC 基于定义服务的思想，指定可以远程调用的方法及其参数和返回类型。在服务端，服务端实现这个接口并运行一个 gRPC 服务器来处理客户端
27.grpc python 使用教程
qq_42197919的博客
10-31 448
1.写protobuf 文件 syntax = "proto3"; package rpc_package; // define a service service AirRecognitionService { // define the interface and data type rpc SVMAirRecognition(MLAirRequest) return...
python如何实现GRPC服务，python实现简单的grpc通信
尚拙的博客
09-07 7357
通常我们利用grpc来接收不同客户端的请求，并将请求数据做业务逻辑处理，最后再返回给客户端。就好像通信基站一样，接收四面八方传来的手机通信请求，基站将这些请求做相应的处理，再返回给不同客户端，达到互联的目的。 总的来说，python实现简单的grpc需要以下步骤：定义protobuf——>通过protobuf生成2份方法文件——>定义服务端——>定义客户端。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值