Linux C++ gPRC使用说明

DungDaj · 发表于 2021-12-25 09:40

一、基础概念

1.RPC

RPC 代指远程过程调用（Remote Procedure Call），它的调用包含了传输协议和编码（对象序列号）协议等等。允许运行于一台计算机的程序调用另一台计算机的子程序，而开发人员无需额外地为这个交互作用编程。)
1）RPC 框架

一个完整的 RPC 框架，应包含负载均衡、服务注册和发现、服务治理等功能，并具有可拓展性便于流量监控系统等接入。

常见 RPC 框架：

\	跨语言	多 IDL	服务治理	注册中心	服务管理
gRPC	√	×	×	×	×
Thrift	√	×	×	×	×
Rpcx	×	√	√	√	√
Dubbo	×	√	√	√	√

2）RPC优点

简单、通用、安全、效率。
3）RPC 生命周期

4）同步与异步

2.Protobuf

Protocol Buffers 是一种与语言、平台无关，可扩展的序列化结构化数据的方法，用.proto文件表示，常用于通信协议，数据存储等等。相较于 JSON、XML，它更小、更快、更简单，因此也更受开发人员的青眯。

protoc 是 protobuf 协议的编译器，一个.proto文件会生成一个.h和一个.cc文件。
1）语法

详细介绍参考： Language Guide (proto3)
syntax ="proto3";service SearchService{ rpc Search(SearchRequest) returns (SearchResponse);}message SearchRequest{ string query =1; int32 page_number =2; int32 result_per_page =3;}message SearchResponse{...}

2）数据类型

.proto Type	C++ Type	Java Type	Go Type	PHP Type
double	double	double	float64	float
float	float	float	float32	float
int32	int32	int	int32	integer
int64	int64	long	int64	integer/string
uint32	uint32	int	uint32	integer
uint64	uint64	long	uint64	integer/string
sint32	int32	int	int32	integer
sint64	int64	long	int64	integer/string
fixed32	uint32	int	uint32	integer
fixed64	uint64	long	uint64	integer/string
sfixed32	int32	int	int32	integer
sfixed64	int64	long	int64	integer/string
bool	bool	boolean	bool	boolean
string	string	String	string	string
bytes	string	ByteString	[]byte	string

3）Protobuf对比 XML的优势

3.gRPC

gRPC（gRPC Remote Procedure Calls）是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计，它采用了 Protobuf 作为 IDL（Interface description language）。
1）特点

2）通信过程

image

对象序列化

3）服务定义

gRPC 允许定义四种服务方法

服务器流式 RPC，客户端向服务器发送请求并获取流以读取一系列消息。客户端从返回的流中读取，直到没有更多消息。gRPC 保证单个 RPC 调用中的消息排序。

image

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);
客户端流式 RPC，单向流，客户端通过流式发起多次 RPC 请求给服务端，服务端发起一次响应给客户端。

image

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);
双向流式 RPC，由客户端以流式的方式发起请求，服务端同样以流式的方式响应请求

首个请求一定是 Client 发起，但具体交互方式（谁先谁后、一次发多少、响应多少、什么时候关闭）根据程序编写的方式来确定（可以结合协程）。

image

rpc BidiHello(stream HelloRequest) returns (stream HelloResponse);

4）gRPC 与 REST 对比

5）gRPC支持的语言与平台

Language	OS	Compilers / SDK
C/C++	Linux, Mac	GCC 4.9+, Clang 3.4+
C/C++	Windows 7+	Visual Studio 2015+
C#	Linux, Mac	.NET Core, Mono 4+
C#	Windows 7+	.NET Core, NET 4.5+
Dart	Windows, Linux, Mac	Dart 2.12+
Go	Windows, Linux, Mac	Go 1.13+
Java	Windows, Linux, Mac	JDK 8 recommended (Jelly Bean+ for Android)
Kotlin	Windows, Linux, Mac	Kotlin 1.3+
Node.js	Windows, Linux, Mac	Node v8+
Objective-C	macOS 10.10+, iOS 9.0+	Xcode 7.2+
PHP	Linux, Mac	PHP 7.0+
Python	Windows, Linux, Mac	Python 3.5+
Ruby	Windows, Linux, Mac	Ruby 2.3+

6）使用 API

从.proto文件中的服务定义开始，gRPC 提供了生成客户端和服务器端代码的协议缓冲区编译器插件。gRPC 用户通常在客户端调用这些 API，并在服务器端实现相应的 API。

stub

client

二、安装gRPC与protoc

gRPC Server 和 Client互相通讯，需要使用到如下库：

1.CMake编译与安装gRPC

# 选择一个目录来保存本地安装的软件包export MY_INSTALL_DIR=$HOME/.local# 将本地bin文件夹添加到路径变量export PATH="$MY_INSTALL_DIR/bin:$PATH"# 需要 3.13 或更高版本的cmakesudo apt install -y cmake# 或wget -q -O cmake-linux.sh https://github.com/Kitware/CMake/releases/download/v3.19.6/cmake-3.19.6-Linux-x86_64.sh~/.local/bin/cmake -versioncmake version 3.19.6# 安装构建 gRPC 所需的基本工具sudo apt install -y build-essential autoconf libtool pkg-config# 克隆grpc git clone --recurse-submodules -b v1.42.0 https://github.com/grpc/grpc# 构建和安装 gRPC 和协议缓冲区$ cd grpc$ mkdir -p cmake/build$ pushd cmake/build$ ~/.local/bin/cmake -DgRPC_INSTALL=ON \    -DgRPC_BUILD_TESTS=OFF \    -DCMAKE_INSTALL_PREFIX=$MY_INSTALL_DIR \    ../..$ make -j$ make install$ popd2.安装Protocol Buffers v3

wget https://github.com/protocolbuffers/protobuf/releases/download/v3.19.1/protobuf-all-3.19.1.zipunzip protobuf-all-3.19.1.zipcd protobuf-3.19.1/./configuremakemake installexport LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH# 查看版本$ protoc --versionlibprotoc 3.19.1三、构建并使用C++ gRPC示例

1.示例程序目录

基于https://github.com/grpc/grpc
$ tree grpc/examples/cpp/ -L 2examples/cpp/├── cmake│ └── common.cmake├── compression│ ├── BUILD│ ├── CMakeLists.txt│ ├── greeter_client.cc│ ├── greeter_server.cc│ ├── Makefile│ └── README.md├── helloworld    # 示例服务端与客户端程序│ ├── BUILD│ ├── cmake│ ├── cmake_externalproject│ ├── CMakeLists.txt│ ├── cocoapods│ ├── greeter_async_client2.cc│ ├── greeter_async_client.cc│ ├── greeter_async_server.cc│ ├── greeter_callback_client.cc│ ├── greeter_callback_server.cc│ ├── greeter_client.cc # gRPC Client程序│ ├── greeter_server.cc  # gRPC Server程序│ ├── Makefile│ ├── README.md│ ├── xds_greeter_client.cc│ └── xds_greeter_server.cc├── keyvaluestore│ ├── BUILD│ ├── caching_interceptor.h│ ├── client.cc│ ├── CMakeLists.txt│ └── server.cc├── load_balancing│ ├── BUILD│ ├── CMakeLists.txt│ ├── greeter_client.cc│ ├── greeter_server.cc│ ├── Makefile│ └── README.md├── metadata│ ├── BUILD│ ├── CMakeLists.txt│ ├── greeter_client.cc│ ├── greeter_server.cc│ ├── Makefile│ └── README.md├── README.md└── route_guide ├── BUILD ├── CMakeLists.txt ├── helper.cc ├── helper.h ├── Makefile ├── README.md ├── route_guide_callback_client.cc ├── route_guide_callback_server.cc ├── route_guide_client.cc ├── route_guide_db.json └── route_guide_server.cc $ tree examples/protos/ # 协议缓冲区文件examples/protos/├── auth_sample.proto├── BUILD├── hellostreamingworld.proto├── helloworld.proto├── keyvaluestore.proto├── README.md└── route_guide.proto2.使用协议缓冲区文件

gRPC 服务是使用协议缓冲区定义的，存放路径：examples/protos。服务器和客户端存根都有一个SayHello()RPC 方法。

examples/protos/helloworld.proto
syntax = "proto3";option java_multiple_files = true;option java_package = "io.grpc.examples.helloworld";option java_outer_classname = "HelloWorldProto";option objc_class_prefix = "HLW";package helloworld;// The greeting service definition.service Greeter {  // Sends a greeting  rpc SayHello (HelloRequest) returns (HelloReply) {}}// The request message containing the user's name.message HelloRequest {  string name = 1;}// The response message containing the greetingsmessage HelloReply {  string message = 1;}
协议缓冲区文件通过protoc工具生成服务类和消息类的代码

通过CMakeLists方式
project(HelloWorld C CXX)include(../cmake/common.cmake)# Proto fileget_filename_component(hw_proto "../../protos/helloworld.proto" ABSOLUTE)get_filename_component(hw_proto_path "${hw_proto}" PATH)# Generated sourcesset(hw_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.pb.cc")set(hw_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.pb.h")set(hw_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.grpc.pb.cc")set(hw_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.grpc.pb.h")add_custom_command( OUTPUT "${hw_proto_srcs}" "${hw_proto_hdrs}" "${hw_grpc_srcs}" "${hw_grpc_hdrs}" COMMAND ${_PROTOBUF_PROTOC} ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}" --cpp_out "${CMAKE_CURRENT_BINARY_DIR}" -I "${hw_proto_path}" --plugin=protoc-gen-grpc="${_GRPC_CPP_PLUGIN_EXECUTABLE}" "${hw_proto}" DEPENDS "${hw_proto}")
通过Makefile方式
PROTOC = protocGRPC_CPP_PLUGIN = grpc_cpp_pluginGRPC_CPP_PLUGIN_PATH ?= `which $(GRPC_CPP_PLUGIN)`PROTOS_PATH = ../../protos.PRECIOUS: %.grpc.pb.cc%.grpc.pb.cc: %.proto $(PROTOC) -I $(PROTOS_PATH) --grpc_out=. --plugin=protoc-gen-grpc=$(GRPC_CPP_PLUGIN_PATH) $<.PRECIOUS: %.pb.cc%.pb.cc: %.proto $(PROTOC) -I $(PROTOS_PATH) --cpp_out=. $<

1）服务类文件

#include "helloworld.pb.h"namespace helloworld { class StubInterface { class Stub final : public StubInterface { public: class async final : public StubInterface::async_interface { public: void SayHello(::grpc::ClientContext* context, const ::helloworld::HelloRequest* request, ::helloworld::HelloReply* response, std::function<void(::grpc::Status)>) override; void SayHello(::grpc::ClientContext* context, const ::helloworld::HelloRequest* request, ::helloworld::HelloReply* response, ::grpc::ClientUnaryReactor* reactor) override; void SayHelloAgain(::grpc::ClientContext* context, const ::helloworld::HelloRequest* request, ::helloworld::HelloReply* response, std::function<void(::grpc::Status)>) override; void SayHelloAgain(::grpc::ClientContext* context, const ::helloworld::HelloRequest* request, ::helloworld::HelloReply* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } }; // 定义客户端可以创建根存Stub的方法 static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); }; // 定义服务端需要实现的方法 class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // Sends a greeting virtual ::grpc::Status SayHello(::grpc::ServerContext* context, const ::helloworld::HelloRequest* request, ::helloworld::HelloReply* response); // Sends another greeting virtual ::grpc::Status SayHelloAgain(::grpc::ServerContext* context, const ::helloworld::HelloRequest* request, ::helloworld::HelloReply* response); }; }

2）消息类文件

提供对protobuf定义的消息进行读写等操作的方法
// HelloRequest// string name = 1;inline void HelloRequest::clear_name() { name_.ClearToEmpty();}inline const std::string& HelloRequest::name() const { // @@protoc_insertion_point(field_get:helloworld.HelloRequest.name) return _internal_name();}template <typename ArgT0, typename... ArgT>inline PROTOBUF_ALWAYS_INLINEvoid HelloRequest::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:helloworld.HelloRequest.name)}inline std::string* HelloRequest::mutable_name() { std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:helloworld.HelloRequest.name) return _s;}inline const std::string& HelloRequest::_internal_name() const { return name_.Get();}inline void HelloRequest::_internal_set_name(const std::string& value) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());}inline std::string* HelloRequest::_internal_mutable_name() { return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());}inline std::string* HelloRequest::release_name() { // @@protoc_insertion_point(field_release:helloworld.HelloRequest.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());}inline void HelloRequest::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArenaForAllocation()); // @@protoc_insertion_point(field_set_allocated:helloworld.HelloRequest.name)}// HelloReply// string message = 1;inline void HelloReply::clear_message() { message_.ClearToEmpty();}inline const std::string& HelloReply::message() const { // @@protoc_insertion_point(field_get:helloworld.HelloReply.message) return _internal_message();}template <typename ArgT0, typename... ArgT>inline PROTOBUF_ALWAYS_INLINEvoid HelloReply::set_message(ArgT0&& arg0, ArgT... args) { message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:helloworld.HelloReply.message)}inline std::string* HelloReply::mutable_message() { std::string* _s = _internal_mutable_message(); // @@protoc_insertion_point(field_mutable:helloworld.HelloReply.message) return _s;}inline const std::string& HelloReply::_internal_message() const { return message_.Get();}inline void HelloReply::_internal_set_message(const std::string& value) { message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());}inline std::string* HelloReply::_internal_mutable_message() { return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());}inline std::string* HelloReply::release_message() { // @@protoc_insertion_point(field_release:helloworld.HelloReply.message) return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());}inline void HelloReply::set_allocated_message(std::string* message) { if (message != nullptr) { } else { } message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message, GetArenaForAllocation()); // @@protoc_insertion_point(field_set_allocated:helloworld.HelloReply.message)}3.gRPC Server

greeter_server.cc
// greeter_server.cc#include <iostream>#include <memory>#include <string>#include <grpcpp/grpcpp.h>#ifdef BAZEL_BUILD#include "examples/protos/helloworld.grpc.pb.h"#else#include "helloworld.grpc.pb.h"#endifusing grpc::Server;using grpc::ServerBuilder;using grpc::ServerContext;using grpc::Status;using helloworld::HelloRequest;using helloworld::HelloReply;using helloworld::Greeter;// Logic and data behind the server's behavior.class GreeterServiceImpl final : public Greeter::Service { Status SayHello(ServerContext* context, const HelloRequest* request, HelloReply* reply) override { std::string prefix("Hello "); reply->set_message(prefix + request->name()); return Status::OK; }};void RunServer() { std::string server_address("0.0.0.0:50051"); GreeterServiceImpl service; ServerBuilder builder; // Listen on the given address without any authentication mechanism. builder.AddListeningPort(server_address, grpc::InsecureServerCredentials()); // Register "service" as the instance through which we'll communicate with // clients. In this case it corresponds to an *synchronous* service. builder.RegisterService(&service); // Finally assemble the server. std::unique_ptr<Server> server(builder.BuildAndStart()); std::cout << "Server listening on " << server_address << std::endl; // Wait for the server to shutdown. Note that some other thread must be // responsible for shutting down the server for this call to ever return. server->Wait();}int main(int argc, char** argv) { RunServer(); return 0;}

4.gRPC Client

greeter_client.cc
#include <iostream>#include <memory>#include <string>#include <grpcpp/grpcpp.h>#ifdef BAZEL_BUILD#include "examples/protos/helloworld.grpc.pb.h"#else#include "helloworld.grpc.pb.h"#endifusing grpc::Channel;using grpc::ClientContext;using grpc::Status;using helloworld::HelloRequest;using helloworld::HelloReply;using helloworld::Greeter;class GreeterClient { public: GreeterClient(std::shared_ptr<Channel> channel) : stub_(Greeter::NewStub(channel)) {} // Assembles the client's payload, sends it and presents the response back // from the server. std::string SayHello(const std::string& user) { // Data we are sending to the server. HelloRequest request; request.set_name(user); // Container for the data we expect from the server. HelloReply reply; // Context for the client. It could be used to convey extra information to // the server and/or tweak certain RPC behaviors. ClientContext context; // The actual RPC. Status status = stub_->SayHello(&context, request, &reply); // Act upon its status. if (status.ok()) { return reply.message(); } else { std::cout << status.error_code() << ": " << status.error_message() << std::endl; return "RPC failed"; } } private: std::unique_ptr<Greeter::Stub> stub_;};int main(int argc, char** argv) { // Instantiate the client. It requires a channel, out of which the actual RPCs // are created. This channel models a connection to an endpoint (in this case, // localhost at port 50051). We indicate that the channel isn't authenticated // (use of InsecureChannelCredentials()). GreeterClient greeter(grpc::CreateChannel( "localhost:50051", grpc::InsecureChannelCredentials())); std::string user("world"); std::string reply = greeter.SayHello(user); std::cout << "Greeter received: " << reply << std::endl; return 0;}

创建一个 gRPC通道，指定我们想要连接的服务器地址和端口：grpc::CreateChannel(
"localhost:50051", grpc::InsecureChannelCredentials())使用通道创建一个Greeter service的根存stub，使用从 .proto 生成NewStub的类中提供的方法通过根存调用服务方法：stub_->.SayHello(user)，几乎和调用本地方法一样简单

5.编译示例工程

编译helloworld程序
$ cd examples/cpp/helloworld$ mkdir -p cmake/build$ pushd cmake/build$ cmake -DCMAKE_PREFIX_PATH=$MY_INSTALL_DIR ../..$ make -j$ popd
编译所得文件
$ tree grpc/examples/cpp/helloworld/cmake/build/ -L 1cmake/build/├── CMakeCache.txt├── CMakeFiles├── cmake_install.cmake├── greeter_async_client├── greeter_async_client2├── greeter_async_server├── greeter_callback_client├── greeter_callback_server├── greeter_client├── greeter_server├── helloworld.grpc.pb.cc # 生成服务实现类代码├── helloworld.grpc.pb.h # 生成服务实现类的头文件 ├── helloworld.pb.cc # 生成消息实现类代码├── helloworld.pb.h # 生产消息实现类头文件├── libhw_grpc_proto.a└── Makefile
测试示例
$ cd cmake/build# 运行服务器$ ./greeter_server# 从不同的终端运行客户端并查看客户端输出：$ ./greeter_clientGreeter received: Hello world四、更新 gRPC 服务

1.修改.proto文件

对helloworld.proto添加一个SayHelloAgain()具有相同请求和响应类型的新方法：
// The greeting service definition.service Greeter { // Sends a greeting rpc SayHello (HelloRequest) returns (HelloReply) {} // Sends another greeting rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}}// The request message containing the user's name.message HelloRequest { string name = 1;}// The response message containing the greetingsmessage HelloReply { string message = 1;}2.重新生成 gRPC 代码

cd examples/cpp/helloworld/cmake/buildmake -j

3.更新应用程序

有新生成的服务器和客户端代码，但仍然需要在示例应用程序的人工编写部分中实现和调用新方法。

服务端实现新的服务类方法

打开examples/cpp/helloworld/greeter_server.cc，对GreeterServiceImpl类实现新的方法SayHelloAgain()
class GreeterServiceImpl final : public Greeter::Service { Status SayHello(ServerContext* context, const HelloRequest* request, HelloReply* reply) override { // ... } Status SayHelloAgain(ServerContext* context, const HelloRequest* request, HelloReply* reply) override { std::string prefix("Hello again "); reply->set_message(prefix + request->name()); return Status::OK; }};
客户端增加新的调用方法

现在存根中提供了一种新方法SayHelloAgain()，将遵循与现有模式相同的模式，SayHello()并添加一个新 SayHelloAgain()方法到GreeterClient。

打开examples/cpp/helloworld/greeter_client.cc。
class GreeterClient { public: // ... std::string SayHello(const std::string& user) { // ... } std::string SayHelloAgain(const std::string& user) { // Follows the same pattern as SayHello. HelloRequest request; request.set_name(user); HelloReply reply; ClientContext context; // Here we can use the stub's newly available method we just added. Status status = stub_->SayHelloAgain(&context, request, &reply); if (status.ok()) { return reply.message(); } else { std::cout << status.error_code() << ": " << status.error_message() << std::endl; return "RPC failed"; } }
在main()函数中调用这个新方法
int main(int argc, char** argv) { // ... std::string reply = greeter.SayHello(user); std::cout << "Greeter received: " << reply << std::endl; reply = greeter.SayHelloAgain(user); std::cout << "Greeter received: " << reply << std::endl; return 0;}
再次构建客户端和服务器
cd examples/cpp/helloworld/cmake/buildmake -j$ ./greeter_server$ ./greeter_clientGreeter received: Hello worldGreeter received: Hello Againworld

		自动登录	找回密码
密码			立即注册

Linux C++ gPRC使用说明

本帖子中包含更多资源

浏览过的版块