grpc-python day01-day03

已于 2022-04-01 11:57:26 修改
阅读量3.5k 收藏 2
点赞数
分类专栏： gprc框架 文章标签： python grpc
于 2022-03-29 17:32:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yutu75/article/details/123823340
版权

文章目录

一、grpc-python介绍

RPC(Remote Procedure Call)远程过程调用，简单的理解是一个节点请求另一个节点提供的服务。如果 http 就是一种远程调用的协议。这里提到了远程过程调用，那么对于远程就应该有本地过程调用那么什么是本地过程调用，也就是调用本地方法对本地的对象进行操作。
例如调用 Add 方法向列表中添加一个对象。而远程过程调用，向列表添加对象方法并不在本地，调用远程提供 Add() 来实现该操作。

在这里插入图片描述

gRPC 是一个现代开源的高性能远程过程调用 (RPC) 框架，可以在任何环境中运行。它可以通过对负载平衡、跟踪、健康检查和身份验证的可插拔支持有效地连接数据中心内和跨数据中心的服务。它也适用于分布式计算的最后一英里，将设备、移动应用程序和浏览器连接到后端服务。
其由Google主要面向移动应用开发并基于http/2协议标准而设计，基于ProtoBuf( Protocol Buffers)序列化协议开发，且支持众多开发语言(python,golang,javascript,c,c++,php,ruby等)。
gRPC提供了一种简单的方法来精确地定义服务和为ios，android和后台支持服务自动生成可靠性很强的客户端功能库。客户端充分利用高级流和链接功能，从而有助于节省带宽，降低的TCP链接次数，节省CPU使用、和电池寿命。

grpc与restful的对比

gRPCREST
full name(全名)gRPC Remote Procedure CallsRepresentational State Transfer
payload (有效载荷)ProtobufJSON
unreadable binary data (不可读二进制流)readable data(可读文件)
HTTP协议HTTP/2HTTP1.1/HTTP/2
Performance(性能)faster(较快)一般
Safe (安全性)Type Safe (更安全)一般
Cross Language (跨语言)支持支持
clinet(是否需要客户端)需要一个不需要
mode(使用模式)Any functionGET/POST/PUT/DELETE/…

什么是protobuf?

  • protobuf (protocol buffer) 是google提供一个具有高效的协议数据交换格式工具库(类似json)，但相比于json，protobuf有更高的转化效率，时间效率和空间效率都是JSON的3-5倍数。
  • 具有跨语言性: 支持 python golang java c++ javascript等等。

学习视频：

https://space.bilibili.com/376995746/channel/seriesdetail?sid=1767554

二、 环境准备

环境：
Python3.8.5
Ubuntu20.04

grpc官网:
https://www.grpc.io/
官方操作文档:
https://www.grpc.io/docs/languages/python/quickstart/

模块安装

安装必要模块包

pip install grpcio-tools
pip install grpc

1. 创建proto文件，以及参数详解

创建helloworld.proto文件并添加以下代码:

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

package test;     // 包的命名名称

// 创建服务对象
service grpc_test {
	// 定义一个rpc函数
	rpc 
	Hello_grpc(Hello_grpc_req)		// 请求函数
	returns ( Hello_grpc_res){}		// 反回函数
}

message Hello_grpc_req {
	string name = 1;
	int age = 2;
}
message Hello_grpc_res{
	string result = 1;
}

2. 文件编译命令

使用 protoc 编译 helloworld.proto 文件, 生成 python 语言的实现

python -m grpc_tools.protoc --python_out=. --grpc_python_out=. -I. helloworld.proto

#编译 proto 文件：
python -m grpc_tools.protoc --python_out=. --grpc_python_out=. -I. helloworld.proto


python -m grpc_tools.protoc: python 下的 protoc 编译器通过 python 模块(module) 实现, 所以说这一步非常省心
--python_out=. : 编译生成处理 protobuf 相关的代码的路径, 这里生成到当前目录
--grpc_python_out=. : 编译生成处理 grpc 相关的代码的路径, 这里生成到当前目录
-I. helloworld.proto : proto 文件的路径, 这里的 proto 文件在当前目录
Makefile的使用

创建Makefile文件
Makefile内容：

proto:
	python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. helloworld.proto

命令执行:

make proto

创建了Makefile文件， 命令"make proto" 和 "python -m grpc_tools.protoc --python_out=. --grpc_python_out=. -I. helloworld.proto"效果是一样的。

3. 编译后生成的代码

helloworld_pb2.py: 用来和 protobuf 数据进行交互

  • 每一个message对应的信息存储，比如我们的request与response在这里被定义extension(延展)

helloworld_pb2_grpc.py: 用来和 grpc 进行交互

  • 用来存储每一个服务的server与客户端以及注册server的工具
  • 客户端名为: service_name + Stub
  • 服务端名为: service_name + Service
  • 注册服务为: add_服务端名_to_server

4. 创建服务端和客户端

服务端代码 server.py:

import time
import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc

from concurrent import futures # 进程线程包


class grpc_test(pb2_grpc.grpc_testServicer):
    def Hello_grpc(self, request, context):
        name = request.name
        age = request.age

        result = f'my name is {name}, i am {age} years old'
        return pb2.Hello_grpc_res(result=result)

def run():
    grpc_server = grpc.server(
        futures.ThreadPoolExecutor(max_workers=4)   # 指定线程数
    )
    pb2_grpc.add_grpc_testServicer_to_server(grpc_test(), grpc_server)  # 注册服务到grpc_server里
    grpc_server.add_insecure_port('0.0.0.0:6000')                       # 指定ip、端口号
    print('server will start at 0.0.0.0:6000')
    grpc_server.start()

    # 防止启动后直接结束添加阻塞，在其他语言不会出现这样的问题
    try:
        while 1:
            time.sleep(3600)
    except Exception as e:
        grpc_server.stop(0)
        print(e)
if __name__ == '__main__':
    run()

客户端 client.py:

import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc


def run():
    # 定义一个频道 绑定ip、端口号
    conn = grpc.insecure_channel('0.0.0.0:6000')
    
    # 生成客户端
    client = pb2_grpc.grpc_testStub(channel=conn)
    
    # 传入参数获取返回值
    response = client.Hello_grpc(pb2.Hello_grpc_req(
        name='yanilo',
        age=18
    ))
    print(response.result)

if __name__ == '__main__':
    run()

反回结果:

my name is yanilo, i am 18 years old

三、常用的protobuf数据类型

类型说明
string字符串类型，要求是utf-8或者7-bit与ascii编码的字符串
bytes比特类型
bool布尔类型
int3232整型
int6464位整型
float浮点类型
repeated数组(列表)repeated string data = 1；
map字典类型(python叫法) map<string,string> data = 1;

四、常用的protobuf的特殊字符

类型说明
package包名称
syntaxprotobuf版本
service定义服务
rpc定义服务中的方法
stream定义的方法传输为流传输
message定义消息体 message User{}
extend扩展消息体 extend User{}
import导入一些插件
//注释

五、不同数据类型示例

1. helloworld.proto:

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

package test;     // 包的命名名称

service grpc_test {
	// 定义一个rpc函数
	rpc Hello_grpc(Hello_grpc_req) returns (Hello_grpc_res){}
	rpc helle_test(hello_requests) returns (hello_response){}
}


message Hello_grpc_req {
	string name = 1;
	int32 age = 2;
}
message Hello_grpc_res{
	string result = 1;
}
message hello_requests{
	string name = 1;
	int64 age = 2;
	repeated string  data = 3;
	map<string,int64> number_1 = 4; // string,int32
	map<string,hello_requests_number_value> number = 5;
}

message hello_requests_number_value{
	string name = 1;
	int32 age = 2;
	bool is_active = 3;


}


message hello_response{
	string result = 1;
}

2. server.py:

import time

import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc


from concurrent import futures # 进程线程包


class grpc_test(pb2_grpc.grpc_testServicer):
    def Hello_grpc(self, request, context):
        name = request.name
        age = request.age

        result = f'my name is {name}, i am {age} years old'
        return pb2.Hello_grpc_res(result=result)

    def helle_test(self, request, context):
        name = request.name
        age = request.age
        data = request.data
        number_1 = request.number_1
        number= request.number
        result = f"{name}\n{age}\n{data}\n{number_1}\n{number}"
        return pb2.hello_response(result=result)

def run():
    grpc_server = grpc.server(
        futures.ThreadPoolExecutor(max_workers=4)   # 指定线程数
    )
    pb2_grpc.add_grpc_testServicer_to_server(grpc_test(), grpc_server)  # 注册服务到grpc_server里
    grpc_server.add_insecure_port('0.0.0.0:50010')                       # 指定ip、端口号
    print('server will start at 0.0.0.0:50010')
    grpc_server.start()

    # 防止启动后直接结束添加阻塞，在其他语言不会出现这样的问题
    try:
        while 1:
            time.sleep(3600)
    except Exception as e:
        grpc_server.stop(0)
        print(e)
if __name__ == '__main__':
    run()

3. client.py:

import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc


def run():
    # 定义一个频道 绑定ip、端口号
    conn = grpc.insecure_channel('127.0.0.1:50010')

    # 生成客户端
    client = pb2_grpc.grpc_testStub(channel=conn)

    # 传入参数获取返回值
    response = client.Hello_grpc(pb2.Hello_grpc_req(
        name='yanilo',
        age=18
    ))
    print(response.result)
    print('*****************')
    response1 = client.helle_test(pb2.hello_requests(
        name='yanilo',
        age=100,
        data=["qwq"],
        number_1={'k': 11,'k2': 22,'k3': 33},
        number={'k': pb2.hello_requests_number_value(
            age=123,
            name='yanilo_value',
            is_active=True
        )},

    ))
    print(response1.result)


if __name__ == '__main__':
    run()

4. 反回结果

服务端:

在这里插入图片描述
客户端：
在这里插入图片描述

六、grpc basic: 四种通信方式

1. unary 单程

  • 两者都是非流形式，客服端一次请求, 服务器一次应答，(上面的不同数据类型示例就是非流形式)
  • 客服端一次请求, 服务器一次应答

2. stream

单向流和双向流都是客户端与服务端建立长链接

  • 单向流：

    1. 一种是客户端不停给服务端发送流数据，服务器端只负责接收；
      客服端多次请求(流式), 服务器一次应答

    2. 一种是服务器端不停给客户端发送流数据，客户端只负责接收；
      客服端一次请求, 服务器多次应答(流式)

  • 双向流： 客户端与服务端建立长链接，双方发送和接收流数据；

proto 中想要表示流式传输, 只需要在proto文件中服务(service )的rpc函数里

stream在哪边 哪边就是推流方, 两边都有stream, 两边都是推流方, 其实说是流信息, 但其实 rpc请求的是一个http-alive而已, 是一个保持的http链接而已。
http-alive: 应该指一种链接状态吧,(疑惑.jpg)
stream在哪边 哪边就是推流方, 两边都有stream
添加 stream 关键字即可
例：

service grpc_test {
	// 定义一个rpc函数
	rpc
	
			test_client_stream(test_client_stream_requests)		
			// stream 服务端是推送流
			returns(stream test_client_stream_response){}
}

3. 单向流和双向流示例

3.1 单向流1

客户端每一秒给服务端端发送流数据，服务端接收流数据，但不传输流数据。
helloworld.proto：

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

package test;     // 包的命名名称

service grpc_test {
	// 定义一个rpc函数
	rpc
			// 客户端是推送流
			test_client(stream test_client_requests)
		
			returns( test_client_response){}
}
message test_client_requests{
	string data = 1;
}
message test_client_response{
	string result = 1;
}

执行命令:

make proto

server.py：

import time
import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc
from concurrent import futures   # 进程线程包

class grpc_test(pb2_grpc.grpc_testServicer):

    def test_client(self, request_iterator, context):
        # context.is_active()     # 检测客户端是否还活着
        # 接收来自客户端流数据
        index = 0
        for request in request_iterator:
            data = request.data
            index += 1
            result = f'receive {data},index:{index}'
            print(result)
            time.sleep(1)
            # 条件终止连接
            if index == 10:
                break
        return pb2.test_client_response(result='ok')

def run():
    grpc_server = grpc.server(
        futures.ThreadPoolExecutor(max_workers=4)   # 指定线程数
    )
    pb2_grpc.add_grpc_testServicer_to_server(grpc_test(), grpc_server)  # 注册服务到grpc_server里
    grpc_server.add_insecure_port('0.0.0.0:50010')                       # 指定ip、端口号
    print('server will start at 0.0.0.0:50010')
    grpc_server.start()

    # 防止启动后直接结束添加阻塞，在其他语言不会出现这样的问题
    try:
        while 1:
            time.sleep(3600)
    except Exception as e:
        grpc_server.stop(0)
        print(e)
if __name__ == '__main__':
    run()

client.py：

import random
import time
import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc

def test():
    """
    循环发送流数据
    每一秒中向服务端发送流数据
    :return: 
    """
    index = 0
    while True:
        index += 1
        time.sleep(1)
        str_random = str(random.random())
        yield pb2.test_client_requests(
            data=str_random
        )
        # 条件终止连接
        if index == 15:
            break
        
def run():
    # 定义一个频道 绑定ip、端口号
    conn = grpc.insecure_channel('127.0.0.1:50010')

    # 生成客户端
    client = pb2_grpc.grpc_testStub(channel=conn)

    # 传入参数获取返回值
    response = client.test_client(test())
    print(response)
  
  
if __name__ == '__main__':
    run()

结果:
在这里插入图片描述

3.2 单向流2

服务器每一秒给客户端发送流数据，客户端接收流数据，但不传输流数据。
helloworld.proto:

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

package test;     // 包的命名名称

service grpc_test {
	// 定义一个rpc函数
	rpc
	
			test_client_stream(test_client_stream_requests)		
			// stream 服务端是推送流
			returns(stream test_client_stream_response){}
}
message test_client_stream_requests{
	string data = 1;
}
message test_client_stream_response{
	string result = 1;
}

执行命令:

make proto

server.py：

import time
import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc


from concurrent import futures # 进程线程包


class grpc_test(pb2_grpc.grpc_testServicer):
    def test_client_stream(self, request, context):
        # context.is_active()     # 检测客户端是否还活着

        # 每一秒中向客户发送数据
        index = 0
        while context.is_active():
            data = request.data
            index += 1
            result = f'send {data},index:{index}'
            print(result)
            time.sleep(1)
            yield pb2.test_client_stream_response(result=result)



def run():
    grpc_server = grpc.server(
        futures.ThreadPoolExecutor(max_workers=4)   # 指定线程数
    )
    pb2_grpc.add_grpc_testServicer_to_server(grpc_test(), grpc_server)  # 注册服务到grpc_server里
    grpc_server.add_insecure_port('0.0.0.0:50010')                       # 指定ip、端口号
    print('server will start at 0.0.0.0:50010')
    grpc_server.start()

    # 防止启动后直接结束添加阻塞，在其他语言不会出现这样的问题
    try:
        while 1:
            time.sleep(3600)
    except Exception as e:
        grpc_server.stop(0)
        print(e)
if __name__ == '__main__':
    run()

client.py：

import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc

def run():
    # 定义一个频道 绑定ip、端口号
    conn = grpc.insecure_channel('127.0.0.1:50010')

    # 生成客户端
    client = pb2_grpc.grpc_testStub(channel=conn)

    # 传入参数获取返回值
    response = client.test_client_stream(pb2.test_client_stream_requests(
            data='yanilo'
    ))
    for i in response:
        print(i.result)

if __name__ == '__main__':
    run()

结果:
在这里插入图片描述

3.2 双向流

客服端和服务端都以流形式传输数据
helloworld.proto：

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

package test;     // 包的命名名称

service grpc_test {
	// 定义一个rpc函数
	rpc
			// 客服端和服务端都是推送流
			test_client(stream test_client_requests)
			returns( stream test_client_response){}
}
message test_client_requests{
	string data = 1;
}
message test_client_response{
	string result = 1;
}

执行命令:

make proto

server.py：

import time
import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc
from concurrent import futures   # 进程线程包

class grpc_test(pb2_grpc.grpc_testServicer):

    def test_client(self, request_iterator, context):
        # context.is_active()     # 检测客户端是否还活着

        # 接收来自客户端流数据， 且向客户端发送数据
        index = 0
        for request in request_iterator:
            data = request.data
            index += 1
            result = f'receive {data},index:{index}'
            print(result)
            time.sleep(1)
            # 条件终止连接
            if index == 10:
               # context.cancel()        # 强制终止连接，会引起客户端抛出异常
                break
            yield pb2.test_client_response(result=result)

def run():
    grpc_server = grpc.server(
        futures.ThreadPoolExecutor(max_workers=4)   # 指定线程数
    )
    pb2_grpc.add_grpc_testServicer_to_server(grpc_test(), grpc_server)  # 注册服务到grpc_server里
    grpc_server.add_insecure_port('0.0.0.0:50010')                       # 指定ip、端口号
    print('server will start at 0.0.0.0:50010')
    grpc_server.start()

    # 防止启动后直接结束添加阻塞，在其他语言不会出现这样的问题
    try:
        while 1:
            time.sleep(3600)
    except Exception as e:
        grpc_server.stop(0)
        print(e)
if __name__ == '__main__':
    run()

client.py：

import random
import time

import grpc
import helloworld_pb2 as pb2
import helloworld_pb2_grpc as pb2_grpc


def test():
    """
    循环发送流数据
    每一秒中向服务端发送流数据
    :return:
    """
    index = 0
    while True:
        index += 1
        time.sleep(1)
        str_random = str(random.random())
        yield pb2.test_client_requests(
            data=str_random
        )
        # 条件终止连接
        if index == 15:
            break



def run():
    # 定义一个频道 绑定ip、端口号
    conn = grpc.insecure_channel('127.0.0.1:50010')

    # 生成客户端
    client = pb2_grpc.grpc_testStub(channel=conn)

    # 传入参数获取返回值
    response = client.test_client(test(), timeout=10)       # timeout超出时长抛出异常

    for i in response:
        print(i)
if __name__ == '__main__':
    run()

结果：
在这里插入图片描述

七、错误码与服务端客户端发送与接收错误信息

太长了 ，换个文档继续写…

小鹿的
关注
专栏目录
grpc-python 与 grpc-go 互传图片文件
qq_34877350的博客
04-22 3110
将go语言作为客户端，python作为服务器端 go语言部分： go_client.proto: // Copyright 2015 gRPC authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compli...
Python通过proto协议搭建grpc服务详解-grpc响应数据结构的构成
weixin_42589052的博客
11-13 1726
grpc介绍： gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远程过程调用(RPC)系统。 在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 gRPC 服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。gRPC 提供了一种简单的方法来
grpc-python-helloworld
03-26
python发起grpc请求
qq_33306427的博客
03-10 428
python发起grpc请求
grpc-python-demos
05-10
将utils放在/usr/local/bin/
gRPC用python尝鲜
xueyubingsen的专栏
03-08 371
0 准备 参考资料 官方文档 下载gRPC git clone -b v1.27.0 https://github.com/grpc/grpc python环境 python virtualenv环境准备 $ python -m pip install virtualenv $ virtualenv grpc_venv $ source grpc_venv/Scripts/activate $ ...
grpc-python介绍及使用
kuokay的博客
05-09 1366
gRPC是什么 所谓RPC(remote procedure call 远程过程调用)框架实际是提供了一套机制，使得应用程序之间可以进行通信，而且也遵从server/client模型。使用的时候客户端调用server端提供的接口就像是调用本地的函数一样。如下图所示就是一个典型的RPC结构图。 gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。目前提供 C、Java 和 Go 语言版本，分别是：grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C
python/c++ 利用gRPC完成python远程调用c++
Hayley-L
03-14 4688
Python Django写的后台，想要调用小伙伴的c++模块方法，目前想到三种解决方案：http，gRPC,本地调用（ctypes，SWIG） 出于以下考虑： 后台与模型模块分离部署（部分模型模块对GPU，显存等有各类要求） 跨语言（Python 调用 c++方法） 简单，学习时长短 决定学习并尝试用gRPC完成此次调用。 步骤 编写.proto文件定义服务，规定接口样式。 用 proto...
Python gRPC 入门
m0_72829928的博客
09-19 368
先来看一个非常简单的例子。假设你想定义一个“搜索请求”的消息格式，每一个请求含有一个查询字符串、你感兴趣的查询结果所在的页数，以及每一页多少条查询结果。// 声明使用 proto3 语法// 每个字段都要指定数据类型// 这里的数字2 是标识符，最小的标识号可以从1开始，最大到2^29 - 1, or 536,870,911。不可以使用其中的[19000－19999]// 这里是注释，使用 //}文章的第一行指定了你正在使用 proto3 语法：如果不指定，编译器会使用 proto2。
grpc传输大量数据python_GRPC 传图像 python版
weixin_31085635的博客
02-15 630
1.编写proto文件：data.protosyntax = "proto3";//package example;service FormatData { //定义服务,用在rpc传输中rpc DoFormat(actionrequest) returns (actionresponse){}}message actionrequest {string text = 1;}message a...
【Python进阶学习】gRPC的基本使用教程
dream_successor的专栏
07-17 5463
【Python进阶学习】gRPC的基本使用教程前言快速上手gRPC了解protocol buffer语法使用使用工具生成对应语言的源代码搭建Python gRPC服务最佳实践gRPC的优势性能代码生成严格的规范流推荐使用gRPC的场景参考文献 前言 什么是RPC服务 RPC，是Remote Procedure Call的简称，翻译成中文就是远程过程调用。RPC就是允许程序调用另一个地址空间（通常是另一台机器上）的类方法或函数的一种服务。 它是一种架设在计算机网络之上并隐藏底层网络技术，可以像调用本地服务一样
gRPC Python 教程(一)： 原理与基本用法
Python技术探索
11-10 1210
gRPC 基于RPC，有很多优点，使用protobuf 序列化，采用 HTTP/2, 包头压缩，流式处理技术，支持双向通信，支持多语言环境, C++, Python, Go, Java，Rust等。
python对于grpc的简单操作（三）
????爱好者的博客
08-09 2597
grpc的流式传输，以及使用grpc流式传输大文件（视频）
python3中使用gRPC
一个人的博客
05-19 866
gRPC的一个官方案例
python grpc依赖库安装
github_zwl的博客
08-02 615
python-mpipinstall--upgrade--forcepip pipinstallsetuptools python -m pip install grpcio python -m pip install grpcio-tools python -m pip install grpcio-status
Python+grpc
About_one的博客
04-26 917
Grpc Demo grpc包 pip install grpcio #gRPC 的安装 pip install protobuf #ProtoBuf 相关的 python 依赖库 pip install grpcio-tools #python grpc 的 protobuf 编译工具 protobuf grpc是基于protobuf来进行数据传输的 分为四种传输方式 1. 一元RPC模式 2. 响应流式 RPC 3. 请求流式 RPC 4. 双向流式 RPC protobuf
python对于grpc的简单操作（一）
????爱好者的博客
08-02 4996
python对grpc的简单操作，以及图片如何通过grpc在客户端和服务端之间传输
python多维数组运用_gRPC 如何使用python表示多维数组
weixin_39656206的博客
12-05 279
在使用gRPC作为远程调用框架时，如何使用python来表示多维数组呢？gRPC中定义proto文件时，有一个参数是repeated，用来表示重复的数据类型，使用这个参数可以表示list类型。如下，我想表示一个三维数组，这个数组表示的是一个三通道RGB彩色图像，proto文件如下所示，proto文件中GrayFeature表示的是一个通道的灰度图像。syntax = "proto3";servic...
gRPC：gRPC在Python中的实现
最新发布
kkchenjj的博客
07-12 1150
在gRPC中，服务接口的定义是通过.proto文件完成的。这个文件使用Protocol Buffers语言，不仅定义了服务的接口，还描述了服务中方法的参数和返回类型。下面是一个简单的.proto文件示例，定义了一个名为Greeter的服务，该服务有一个SayHello方法，接收一个消息并返回一个HelloReply消息。// 定义消息类型// 定义服务在这个例子中，和HelloReply是消息类型，分别包含一个string字段。SayHello方法是一个RPC（远程过程调用）方法，它接收一个。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值