माइक्रोसॉर्फ़ ब्लॉग लिखना - भाग 1 "सामान्य विवरण"

इस लेख में मैं अपना अनुभव सर्गेसमासलोव के साथ "से एक ब्लॉग बनाने" कार्य के उदाहरण का उपयोग करके माइक्रोसिस्टवर्क आर्किटेक्चर का उपयोग करके विशिष्ट समस्याओं को सुलझाने के साथ साझा करना चाहता हूं (इस उम्मीद में कि पाठक कल्पना कर सकता है कि ब्लॉग कैसे व्यवस्थित किया जाता है और इसे कार्यक्षमता पर सवाल नहीं उठाना चाहिए :)

तो, हमारे ब्लॉग में 5 microservices शामिल होंगे जो गोलंग में लिखे गए हैं:

• गेटवे एपीआई (एपी-जीडब्ल्यू) - अनुरोधों के मार्ग, प्रमाणीकरण, लॉगिंग और अनुरेखण के लिए जिम्मेदार
• उपयोगकर्ता (उपयोगकर्ता) - उपयोगकर्ताओं का पंजीकरण / प्रमाणीकरण, लॉगिंग, अनुरोधों का अनुरेखण
• लेख (पोस्ट) - अनुरोधों के लेख (सीआरयूडी), लॉगिंग, ट्रेसिंग और प्राधिकरण बनाना / पढ़ना / संशोधित / हटाना
• टिप्पणियां (टिप्पणी) - अनुरोधों (लॉगिंग, ट्रेसिंग और प्राधिकरण) की टिप्पणियों (CRUD) को बनाएं / पढ़ें / संशोधित / हटाएं
• श्रेणियां (श्रेणी) - अनुरोधों की श्रेणी बनाना (पढ़ना / बदलना / हटाना / हटाना), लॉगिंग, अनुरेखण और प्राधिकरण

क्लाइंट एप्लिकेशन (वेब ​​/ फ्रंटएंड) vue.js पर लागू किया जाएगा और आरईएसटी एपीआई के माध्यम से माइक्रोसर्विसेज के साथ बातचीत करेगा, और स्वयं माइक्रोसॉर्क्स जीआरपीसी के माध्यम से एक-दूसरे के साथ बातचीत करेंगे।

भंडारण के रूप में हम MongoDB का उपयोग करेंगे।

हम केक पर एक अलग चेरी के साथ दिखाएंगे कि न्यूनतम श्रम के साथ सक्रिय रूप से विकसित परियोजना में एपीआई प्रलेखन (स्वैगर प्रारूप में) को अप-टू-डेट कैसे रखा जाए।

ब्लॉग घटक आरेख

प्रत्येक माइक्रो सर्विस को एक अलग डॉकटर कंटेनर में लागू किया जाएगा, और डॉकटर-कंपोज़ का उपयोग करके प्रोजेक्ट लॉन्च किया जाएगा।

उदाहरण में तुरंत आरक्षण करें, विकास की प्रक्रिया को सरल बनाने के लिए, मैं दो मान्यताओं का उपयोग करूंगा जिनका उत्पादन में उपयोग नहीं किया जाना चाहिए।

• डेटाबेस को डॉकटर कंटेनर में तैनात किया जाता है। यह दृष्टिकोण भंडारण विश्वसनीयता को कम करता है (हाईलाड 2018 में चर्चा की गई योजना के अपवाद के साथ)।
• पूरे प्रोजेक्ट को एक गिट रिपॉजिटरी में होस्ट किया गया है। यह दृष्टिकोण माइक्रोसर्विस आर्किटेक्चर - अलगाव के बुनियादी सिद्धांतों में से एक का खंडन करता है, और अंतर-घटक कनेक्टिविटी की संभावना को बढ़ाता है।

आप यहां प्रोजेक्ट का डेमो और सोर्स कोड यहां देख सकते हैं।

परियोजना की संरचना

विकास की प्रक्रिया का निर्माण कैसे होगा

जैसा कि मैंने पहले कहा था, माइक्रोसर्विसेज के बीच बातचीत जीआरपीसी पर आधारित होगी। संक्षेप में, जीआरपीसी एक उच्च प्रदर्शन वाली रूपरेखा है जिसे दूरस्थ प्रक्रियाओं (आरपीसी) के लिए Google द्वारा विकसित किया गया है - यह HTTP / 2 के शीर्ष पर काम करता है। जीआरपीसी तथाकथित प्रोटोफाइल (नीचे उदाहरण देखें) पर आधारित है, जिसका मुख्य कार्य दो चीजों को कॉम्पैक्ट रूप में घोषित करना है:

• सेवा इंटरफेस (एपीआई इंटरफेस का एनालॉग) की पूरी सूची दें;
• वर्णन करें कि प्रत्येक इंटरफ़ेस के इनपुट को क्या खिलाया जाता है और आउटपुट पर हमें क्या मिलता है।

नीचे, एक उदाहरण के रूप में, श्रेणी सेवा का प्रोटोफाइल दिया गया है।

syntax = "proto3"; package protobuf; import "google/api/annotations.proto"; //   Category service CategoryService { //  rpc Create (CreateCategoryRequest) returns (CreateCategoryResponse) { option (google.api.http) = { post: "/api/v1/category" }; } //  rpc Update (UpdateCategoryRequest) returns (UpdateCategoryResponse) { option (google.api.http) = { post: "/api/v1/category/{Slug}" }; } //  rpc Delete (DeleteCategoryRequest) returns (DeleteCategoryResponse) { option (google.api.http) = { delete: "/api/v1/category/{Slug}" }; } //   SLUG rpc Get (GetCategoryRequest) returns (GetCategoryResponse) { option (google.api.http) = { get: "/api/v1/category/{Slug}" }; } // rpc Find (FindCategoryRequest) returns (FindCategoryResponse) { option (google.api.http) = { get: "/api/v1/category" }; } } //------------------------------------------ // CREATE //------------------------------------------ message CreateCategoryRequest { string ParentId = 1; string Name = 2; string Path = 3; } message CreateCategoryResponse { Category Category = 1; } //------------------------------------------ // UPDATE //------------------------------------------ message UpdateCategoryRequest { string Slug = 1; string ParentId = 2; string Name = 4; string Path = 5; int32 Status = 6; } message UpdateCategoryResponse { int32 Status =1; } //------------------------------------------ // DELETE //------------------------------------------ message DeleteCategoryRequest { string Slug = 1; } message DeleteCategoryResponse { int32 Status =1; } //------------------------------------------ // GET //------------------------------------------ message GetCategoryRequest { string Slug = 1; } message GetCategoryResponse { Category Category = 1; } //------------------------------------------ // FIND //------------------------------------------ message FindCategoryRequest { string Slug = 1; } message FindCategoryResponse { repeated Category Categories = 1; } //------------------------------------------ // CATEGORY //------------------------------------------ message Category { string Slug = 1; string ParentId = 2; string Path = 3; string Name = 4; int32 Status = 5; } 

अब जब हम सामान्य शब्दों में समझ गए हैं कि एक प्रोटोफाइल की आवश्यकता क्यों है, तो आइए देखें कि हमारे माइक्रोसर्विस की विकास प्रक्रिया कैसे दिखाई देगी:

1. हम प्रोटोफाइल में सेवा की संरचना का वर्णन करते हैं;
2. हम कोड जनरेटर ((./bin/protogen.sh) शुरू करते हैं, यह हमारे लिए सर्वर कोड का मुख्य भाग उत्पन्न करेगा + यह क्लाइंट कोड बनाएगा, उदाहरण के लिए, एपीआई गेटवे + के लिए यह स्वैगर प्रारूप में अप-टू-डेट प्रलेखन बनाएगा;
3. हम सभी को अपने हाथों से करना है एक विशेष फ़ाइल /protobuf/functions.go में इंटरफेस के कार्यान्वयन के लिए कोड लिखना है।

इसके अलावा, यदि हम अपने किसी माइक्रोसॉफ़्ट में बदलाव करना चाहते हैं, तो हम उपरोक्त एल्गोरिथम के अनुसार आगे बढ़ते हैं: हम प्रोटॉफ़ाइल को संपादित करते हैं, प्रोटोजेन चलाते हैं, हम फ़ंक्शंस में कार्यान्वयन संपादित करते हैं। इसलिए, और परिवर्तन दस्तावेज़ों और क्लाइंट्स के लिए स्वचालित रूप से "छोड़" देंगे।

लेख में जारी रखा गया "गेटवे एपीआई के माइक्रोसर्विस पार्ट 2 पर एक ब्लॉग लिखना । "