gRPC

gRPC (Các cuộc gọi thủ tục từ xa gRPC) là một khung công tác gọi thủ tục từ xa (RPC) mã nguồn mở chạy trên nhiều ngôn ngữ lập trình khác nhau, bao gồm cả C++. gRPC được thiết kế để có hiệu suất cao, hiệu quả và có thể mở rộng, khiến nó trở nên lý tưởng cho kiến trúc vi dịch vụ và các ứng dụng khác có yêu cầu hiệu suất cao.

gRPC sử dụng định dạng tuần tự hóa Bộ đệm giao thức (Protobuf) để trao đổi thông báo và định nghĩa phương thức. Bộ đệm giao thức cho phép tuần tự hóa hiệu quả hơn và nhỏ hơn so với các định dạng khác như JSON hoặc XML.

Bộ đệm giao thức

Trong gRPC, bạn bắt đầu bằng cách xác định định nghĩa dịch vụ và cấu trúc thông báo trong tệp .proto. Bạn có thể xác định cấu trúc dữ liệu và giao diện dịch vụ bằng định dạng nhị phân nhỏ gọn, trung lập về ngôn ngữ, trung lập về nền tảng.

Đây là một ví dụ về giao diện của nó:

syntax = "proto3";
 
package example;
 
// Định nghĩa dịch vụ gRPC
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}
 
// Định nghĩa thông báo yêu cầu
message HelloRequest {
  string name = 1;
}
 
// Định nghĩa thông báo trả lời
message HelloReply {
  string message = 1;
}

Sau khi xác định tệp .proto, bạn sử dụng trình biên dịch protoc để tạo mã code C++ tương ứng cho ứng dụng của mình.

Máy chủ gRPC C++

Để tạo máy chủ gRPC trong C++, trước tiên bạn cần triển khai giao diện dịch vụ do trình biên dịch protoc tạo ra. Đây là một triển khai ví dụ cho dịch vụ Greeter:

#include <grpcpp/grpcpp.h>
#include "example.grpc.pb.h"
 
using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using example::HelloRequest;
using example::HelloReply;
using example::Greeter;
 
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;
  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
  builder.RegisterService(&service);
 
  std::unique_ptr<Server> server(builder.BuildAndStart());
  std::cout << "Server listening on " << server_address << std::endl;
  server->Wait();
}
 
int main(int argc, char** argv) {
  RunServer();
  return 0;
}

Máy khách gRPC C++

Tương tự, để tạo ứng dụng khách gRPC C++, bạn sử dụng mã code được tạo từ trình biên dịch protoc và kết nối với máy chủ:

#include <grpcpp/grpcpp.h>
#include "example.grpc.pb.h"
 
using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using example::HelloRequest;
using example::HelloReply;
using example::Greeter;
 
class GreeterClient {
 public:
  GreeterClient(std::shared_ptr<Channel> channel) : stub_(Greeter::NewStub(channel)) {}
 
  std::string SayHello(const std::string& user) {
    HelloRequest request;
    request.set_name(user);
 
    HelloReply reply;
    ClientContext context;
 
    Status status = stub_->SayHello(&context, request, &reply);
 
    if (status.ok()) {
      return reply.message();
    } else {
      std::cout << "RPC failed" << std::endl;
      return "RPC failed";
    }
  }
 
 private:
  std::unique_ptr<Greeter::Stub> stub_;
};
 
int main(int argc, char** argv) {
  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;
}

Đây là một ví dụ cơ bản thể hiện giao tiếp máy khách-máy chủ bằng gRPC trong C++. Các tính năng nâng cao hơn như phát trực tuyến hai chiều, xử lý lỗi và xác thực cũng có thể được sử dụng trong gRPC. Để biết thêm thông tin, bạn có thể tham khảo tài liệu gRPC C++.

Bộ đệm giao thức (protobuf)TenorFlow