C++ में gRPC: माइक्रोसर्विसेज और उससे आगे के लिए एक शक्तिशाली उपकरण

C++ में gRPC: जब यह वास्तव में आवश्यक है (और जब इससे दूर रहना बेहतर है)

कल्पना करें: आप C++ में एक उच्च-लोड वाला बैकएंड लिख रहे हैं। सर्वर प्रति सेकंड हजारों अनुरोधों को संसाधित करता है, डेटा पैकेट में उड़ता है, और क्लाइंट तत्काल प्रतिक्रिया की मांग करते हैं। JSON के साथ REST API धीमा होने लगता है - पार्सिंग CPU को खा जाती है, पैकेट फूल जाते हैं, और स्ट्रीमिंग डेटा ट्रांसमिशन के लिए आपको अस्थायी समाधान करने पड़ते हैं। परिचित लगता है?

यहाँ पर gRPC मंच पर आता है - Google का रिमोट प्रक्रिया कॉल के लिए एक आधुनिक फ्रेमवर्क। यह बाइनरी प्रोटोकॉल (Protobuf) का उपयोग करता है, स्ट्रीमिंग, द्वि-दिशात्मक संचार का समर्थन करता है, और क्लासिक REST की तुलना में कई गुना तेजी से काम करता है। लेकिन, किसी भी शक्तिशाली उपकरण की तरह, C++ में gRPC के लिए एक सचेत दृष्टिकोण की आवश्यकता होती है। इस लेख में, हम विश्लेषण करेंगे कि इसका कार्यान्वयन कब एक सोने की खान है, और कब यह एक अनावश्यक सिरदर्द है।

यह लेख C++ डेवलपर्स के लिए लिखा गया है जिन्होंने पहले से gRPC के बारे में सुना है, लेकिन समझना चाहते हैं: "क्या मुझे इसकी आवश्यकता है?" कोई बकवास नहीं - केवल अभ्यास, कोड और ईमानदार सिफारिशें।

gRPC क्या है और C++ इसका सबसे अच्छा दोस्त क्यों है?

gRPC दो स्तंभों पर बना है: डेटा सीरियलाइजेशन के लिए Protocol Buffers (Protobuf) और ट्रांसपोर्ट के लिए HTTP/2। Protobuf संरचित डेटा को एक कॉम्पैक्ट बाइनरी प्रारूप में बदल देता है जो JSON की तुलना में कहीं अधिक तेजी से पार्स होता है। HTTP/2, बदले में, एक कनेक्शन पर अनुरोधों को मल्टीप्लेक्स करने और सर्वर/क्लाइंट स्ट्रीमिंग की अनुमति देता है।

C++ यहाँ अपने तत्व में है: मेमोरी पर निम्न-स्तरीय नियंत्रण, न्यूनतम ओवरहेड, Protobuf के साथ आदर्श एकीकरण (.proto फ़ाइलों से कोड जनरेशन)। परिणामस्वरूप, C++ पर gRPC देशी सॉकेट एक्सचेंज के करीब प्रदर्शन देता है, लेकिन तैयार RPC फ्रेमवर्क की सुविधा के साथ।

Protobuf के बारे में संक्षेप में (समझने के लिए)

कल्पना करें कि आप user.proto फ़ाइल में डेटा संरचना का वर्णन कर रहे हैं:

syntax = "proto3";\n\nmessage User {\n  int32 id = 1;\n  string name = 2;\n  string email = 3;\n}\n\nservice UserService {\n  rpc GetUser (UserRequest) returns (User);\n}\n\nmessage UserRequest {\n  int32 user_id = 1;\n}\n

फिर protoc कंपाइलर सीरियलाइजेशन/डिसीरियलाइजेशन विधियों के साथ C++ क्लासेस जनरेट करता है। आप बस user.name() कॉल करते हैं, और हुड के नीचे - 100+ बाइट JSON के बजाय 20 बाइट आकार का एक बाइनरी पैकेट होता है।

C++ में gRPC कब चुनें: 5 ठोस परिदृश्य

1. उच्च लोड के साथ माइक्रोसर्विस आर्किटेक्चर

यदि आपके पास C++ पर 10-50 माइक्रोसर्विसेज हैं जो लगातार एक दूसरे के साथ संवाद करती हैं, तो gRPC एक जरूरी है। कारण: कम विलंबता और अनुबंधों की सख्त टाइपिंग।

उदाहरण: भुगतान सेवा और अधिसूचना सेवा। gRPC के बिना, आप "user_id": 123 फ़ील्ड के साथ JSON भेजेंगे। फ़ील्ड नाम में टाइपो - और बग प्रोडक्शन में चला जाएगा। gRPC के साथ, अनुबंध .proto फ़ाइल में सख्ती से परिभाषित है, संकलन त्रुटि बिल्ड चरण में पकड़ी जाएगी।

वास्तविक कोड: C++ पर सर्वर साइड (सरलीकृत):

#include <grpcpp/grpcpp.h>\n#include "user.grpc.pb.h"\n\nclass UserServiceImpl final : public UserService::Service {\n  grpc::Status GetUser(grpc::ServerContext* context,\n                       const UserRequest* request,\n                       User* reply) override {\n    // DB में खोज का अनुकरण\n    reply->set_id(request->user_id());\n    reply->set_name("Alice");\n    reply->set_email("alice@example.com");\n    return grpc::Status::OK;\n  }\n};\n\nvoid RunServer() {\n  std::string server_address("0.0.0.0:50051");\n  UserServiceImpl service;\n\n  grpc::ServerBuilder builder;\n  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());\n  builder.RegisterService(&service);\n\n  std::unique_ptr<grpc::Server> server(builder.BuildAndStart());\n  std::cout << "Server listening on " << server_address << std::endl;\n  server->Wait();\n}\n

क्लाइंट कॉल - और भी सरल