🥇हम Yandex.Cloud में 10 इवेंट स्वीकार करते हैं। भाग 000

सभी को नमस्कार दोस्तों!

* यह लेख REBRAIN & Yandex.Cloud ओपन वर्कशॉप पर आधारित है, यदि आप वीडियो देखना पसंद करते हैं, तो आप इसे इस लिंक पर पा सकते हैं - https://youtu.be/cZLezUm0ekE

हमें हाल ही में Yandex.Cloud को लाइव आज़माने का अवसर मिला। चूंकि हम लंबी और कड़ी जांच करना चाहते थे, इसलिए हमने क्लाउड बेस के साथ एक साधारण वर्डप्रेस ब्लॉग लॉन्च करने का विचार तुरंत त्याग दिया - यह बहुत उबाऊ था। कुछ विचार के बाद, हमने वास्तविक समय मोड में घटनाओं को प्राप्त करने और उनका विश्लेषण करने के लिए उत्पादन सेवा वास्तुकला के समान कुछ तैनात करने का निर्णय लिया।

मुझे पूरा यकीन है कि अधिकांश ऑनलाइन (और न केवल) व्यवसाय किसी तरह अपने उपयोगकर्ताओं और उनके कार्यों के बारे में जानकारी का एक पहाड़ एकत्र करते हैं। कम से कम, कुछ निर्णय लेने के लिए यह आवश्यक है - उदाहरण के लिए, यदि आप एक ऑनलाइन गेम का प्रबंधन करते हैं, तो आप आंकड़ों को देख सकते हैं कि उपयोगकर्ता किस स्तर पर अक्सर फंस जाते हैं और अपना खिलौना हटा देते हैं। या उपयोगकर्ता आपकी साइट को बिना कुछ खरीदे क्यों छोड़ देते हैं (हैलो, Yandex.Metrica)।

तो, हमारी कहानी: कैसे हमने गोलांग में एक एप्लिकेशन लिखा, काफ्का बनाम रैबिटएमक्यू बनाम वाईक्यू का परीक्षण किया, एक क्लिकहाउस क्लस्टर में डेटा स्ट्रीमिंग लिखी और यांडेक्स डेटालेंस का उपयोग करके डेटा की कल्पना की। स्वाभाविक रूप से, यह सब डॉकर, टेराफॉर्म, गिटलैब सीआई और निश्चित रूप से, प्रोमेथियस के रूप में बुनियादी ढांचे की प्रसन्नता से भरा हुआ था। चल दर!

मैं तुरंत एक आरक्षण करना चाहूंगा कि हम एक बार में सब कुछ कॉन्फ़िगर करने में सक्षम नहीं होंगे - इसके लिए हमें श्रृंखला में कई लेखों की आवश्यकता होगी। संरचना के बारे में थोड़ा:

भाग 1 (आप इसे पढ़ रहे हैं)। हम समाधान की विशिष्टताओं और वास्तुकला पर निर्णय लेंगे, और गोलांग में एक एप्लिकेशन भी लिखेंगे।
भाग 2। हम अपने एप्लिकेशन को उत्पादन में जारी करते हैं, इसे स्केलेबल बनाते हैं और लोड का परीक्षण करते हैं।
भाग 3. आइए यह पता लगाने की कोशिश करें कि हमें संदेशों को फ़ाइलों में नहीं बल्कि बफर में संग्रहीत करने की आवश्यकता क्यों है, और काफ्का, रैबिटएमक्यू और यांडेक्स कतार सेवा की तुलना भी करें।
भाग 4 हम एक क्लिकहाउस क्लस्टर तैनात करेंगे, वहां बफर से डेटा स्थानांतरित करने के लिए एक स्ट्रीमिंग सेवा लिखेंगे, और डेटालेंस में विज़ुअलाइज़ेशन सेट करेंगे।
भाग 5 आइए पूरे बुनियादी ढांचे को उचित आकार में लाएं - गिटलैब सीआई का उपयोग करके सीआई/सीडी सेट करें, प्रोमेथियस और कॉन्सल का उपयोग करके निगरानी और सेवा खोज को कनेक्ट करें।

टी

सबसे पहले, आइए संदर्भ की शर्तें तैयार करें - परिणामस्वरूप हम वास्तव में क्या प्राप्त करना चाहते हैं।

हम इवेंट्स.किस.आईएम (किस.आईएम एक परीक्षण डोमेन है जिसे हम सभी लेखों में उपयोग करेंगे) जैसा एक समापन बिंदु चाहते हैं, जिसे HTTPS का उपयोग करके इवेंट प्राप्त करना चाहिए।
ईवेंट एक सरल json हैं जैसे: {"इवेंट": "व्यू", "ओएस": "लिनक्स", "ब्राउज़र": "क्रोम"}। अंतिम चरण में हम कुछ और फ़ील्ड जोड़ेंगे, लेकिन यह कोई बड़ी भूमिका नहीं निभाएगा। आप चाहें तो प्रोटोबफ पर स्विच कर सकते हैं।
सेवा प्रति सेकंड 10 घटनाओं को संसाधित करने में सक्षम होनी चाहिए।
हमारे समाधान में केवल नए उदाहरण जोड़कर क्षैतिज रूप से स्केल करना संभव होना चाहिए। और यह अच्छा होगा यदि हम क्लाइंट अनुरोधों के लिए विलंबता को कम करने के लिए सामने के हिस्से को विभिन्न जियोलोकेशन पर ले जा सकें।
दोष सहिष्णुता। समाधान पर्याप्त रूप से स्थिर होना चाहिए और किसी भी हिस्से के गिरने (निश्चित रूप से एक निश्चित संख्या तक) से बचने में सक्षम होना चाहिए।

आर्किटेक्चर

सामान्य तौर पर, इस प्रकार के कार्य के लिए, शास्त्रीय वास्तुकला का लंबे समय से आविष्कार किया गया है जो कुशल स्केलिंग की अनुमति देता है। यह आंकड़ा हमारे समाधान का एक उदाहरण दिखाता है।

तो हमारे पास क्या है:

1. बाईं ओर हमारे उपकरण हैं जो विभिन्न घटनाओं को उत्पन्न करते हैं, चाहे वह स्मार्टफोन पर खिलौने में एक स्तर पूरा करने वाले खिलाड़ी हों या नियमित ब्राउज़र के माध्यम से ऑनलाइन स्टोर में ऑर्डर बनाना हो। एक घटना, जैसा कि विनिर्देश में निर्दिष्ट है, एक सरल json है जो हमारे समापन बिंदु -events.kis.im पर भेजा जाता है।

2. पहले दो सर्वर सरल बैलेंसर हैं, उनके मुख्य कार्य हैं:

लगातार उपलब्ध रहें. ऐसा करने के लिए, आप उदाहरण के लिए, कीपलिवेड का उपयोग कर सकते हैं, जो समस्याओं के मामले में वर्चुअल आईपी को नोड्स के बीच स्विच कर देगा।
टीएलएस समाप्त करें. हां, हम उन पर टीएलएस समाप्त कर देंगे। सबसे पहले, ताकि हमारा समाधान तकनीकी विशिष्टताओं का अनुपालन करे, और दूसरा, हमारे बैकएंड सर्वर से एन्क्रिप्टेड कनेक्शन स्थापित करने के बोझ से राहत दे सके।
आने वाले अनुरोधों को उपलब्ध बैकएंड सर्वर पर संतुलित करें। यहां मुख्य शब्द पहुंच योग्य है। इसके आधार पर, हम इस समझ में आते हैं कि लोड बैलेंसर्स को अनुप्रयोगों के साथ हमारे सर्वर की निगरानी करने और विफल नोड्स पर ट्रैफ़िक को संतुलित करने से रोकने में सक्षम होना चाहिए।

3. बैलेंसर्स के बाद, हमारे पास काफी सरल एप्लिकेशन चलाने वाले एप्लिकेशन सर्वर हैं। यह HTTP के माध्यम से आने वाले अनुरोधों को स्वीकार करने, भेजे गए जेसन को सत्यापित करने और डेटा को बफर में डालने में सक्षम होना चाहिए।

4. आरेख काफ्का को एक बफर के रूप में दिखाता है, हालांकि, निश्चित रूप से, इस स्तर पर अन्य समान सेवाओं का उपयोग किया जा सकता है। हम तीसरे लेख में काफ्का, RabbitMQ और yqs की तुलना करेंगे।

5. हमारे आर्किटेक्चर का अंतिम बिंदु क्लिकहाउस है - एक स्तंभ डेटाबेस जो आपको बड़ी मात्रा में डेटा संग्रहीत और संसाधित करने की अनुमति देता है। इस स्तर पर, हमें डेटा को बफ़र से स्टोरेज सिस्टम में ही स्थानांतरित करने की आवश्यकता है (इस पर लेख 4 में अधिक जानकारी दी गई है)।

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

वैसे, यदि आप हमारी तकनीकी विशिष्टताओं और पैमाने के वैकल्पिक भाग को विभिन्न जियोलोकेशन में लागू करना चाहते हैं, तो इससे आसान कुछ भी नहीं है:

प्रत्येक जियोलोकेशन में हम एप्लिकेशन और काफ्का के साथ एक लोड बैलेंसर तैनात करते हैं। सामान्य तौर पर, 2 एप्लिकेशन सर्वर, 3 काफ्का नोड्स और एक क्लाउड बैलेंसर, उदाहरण के लिए, क्लाउडफ्लेयर, पर्याप्त हैं, जो क्लाइंट के स्रोत आईपी पते के आधार पर जियोलोकेशन द्वारा एप्लिकेशन नोड्स और बैलेंस अनुरोधों की उपलब्धता की जांच करेगा। इस प्रकार, एक अमेरिकी ग्राहक द्वारा भेजा गया डेटा अमेरिकी सर्वर पर आ जाएगा। और अफ़्रीका का डेटा अफ़्रीकी में है.

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

तो, हमने आर्किटेक्चर को सुलझा लिया है - आइए Yandex.Cloud को हिलाना शुरू करें!

एक आवेदन पत्र लिखना

क्लाउड से पहले, आपको अभी भी थोड़ा धैर्य रखना होगा और आने वाली घटनाओं को संसाधित करने के लिए एक काफी सरल सेवा लिखनी होगी। हम गोलांग का उपयोग करेंगे क्योंकि इसने नेटवर्क एप्लिकेशन लिखने के लिए एक भाषा के रूप में खुद को बहुत अच्छी तरह साबित कर दिया है।

एक घंटा (शायद कुछ घंटे) बिताने के बाद, हमें कुछ इस तरह मिलता है: https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/main.go.

वे कौन से मुख्य बिंदु हैं जिन्हें मैं यहां नोट करना चाहूंगा:

1. एप्लिकेशन शुरू करते समय, आप दो झंडे निर्दिष्ट कर सकते हैं। एक उस पोर्ट के लिए ज़िम्मेदार है जिस पर हम आने वाले http अनुरोधों (-addr) को सुनेंगे। दूसरा काफ्का सर्वर पते के लिए है जहां हम अपनी घटनाओं को रिकॉर्ड करेंगे (-काफ्का):

addr     = flag.String("addr", ":8080", "TCP address to listen to")
kafka    = flag.String("kafka", "127.0.0.1:9092", "Kafka endpoints”)

2. एप्लिकेशन सारामा लाइब्रेरी का उपयोग करता है ([] github.com/Shopify/sarama) काफ्का क्लस्टर को संदेश भेजने के लिए। हमने तुरंत अधिकतम प्रसंस्करण गति के उद्देश्य से सेटिंग्स सेट कीं:

config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal
config.Producer.Compression = sarama.CompressionSnappy
config.Producer.Return.Successes = true

3. हमारे एप्लिकेशन में एक अंतर्निहित प्रोमेथियस क्लाइंट भी है, जो विभिन्न मेट्रिक्स एकत्र करता है, जैसे:

हमारे आवेदन के लिए अनुरोधों की संख्या;
अनुरोध निष्पादित करते समय त्रुटियों की संख्या (पोस्ट अनुरोध को पढ़ना असंभव, टूटा हुआ जेसन, काफ्का को लिखना असंभव);
ग्राहक से एक अनुरोध के लिए प्रसंस्करण समय, जिसमें काफ्का को संदेश लिखने का समय भी शामिल है।

4. तीन समापन बिंदु जिन पर हमारा एप्लिकेशन प्रक्रिया करता है:

/स्थिति - यह दिखाने के लिए कि हम जीवित हैं, बस 'ओके' लौटें। हालाँकि आप कुछ जाँचें जोड़ सकते हैं, जैसे काफ्का क्लस्टर की उपलब्धता।
/मेट्रिक्स - इस यूआरएल के अनुसार, प्रोमेथियस क्लाइंट अपने द्वारा एकत्र किए गए मेट्रिक्स को वापस कर देगा।
/पोस्ट मुख्य समापन बिंदु है जहां json के साथ POST अनुरोध भेजे जाएंगे। हमारा एप्लिकेशन वैधता के लिए json की जांच करता है और यदि सब कुछ ठीक है, तो यह डेटा को काफ्का क्लस्टर में लिखता है।

मैं एक आरक्षण कर दूँगा कि कोड सही नहीं है - इसे पूरा किया जा सकता है (और किया जाना चाहिए!)। उदाहरण के लिए, आप अंतर्निहित नेट/http का उपयोग बंद कर सकते हैं और तेज़ fasthttp पर स्विच कर सकते हैं। या आप json वैधता जांच को बाद के चरण में ले जाकर प्रसंस्करण समय और सीपीयू संसाधन प्राप्त कर सकते हैं - जब डेटा बफर से क्लिकहाउस क्लस्टर में स्थानांतरित किया जाता है।

मुद्दे के विकास पक्ष के अलावा, हमने तुरंत अपने भविष्य के बुनियादी ढांचे के बारे में सोचा और डॉकर के माध्यम से अपने एप्लिकेशन को तैनात करने का निर्णय लिया। एप्लिकेशन के निर्माण के लिए अंतिम Dockerfile है https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/Dockerfile. सामान्य तौर पर, यह काफी सरल है, एकमात्र बिंदु जिस पर मैं ध्यान देना चाहूंगा वह है मल्टीस्टेज असेंबली, जो हमें अपने कंटेनर की अंतिम छवि को कम करने की अनुमति देती है।

बादल में पहला कदम

सबसे पहले आप रजिस्टर करें Cloud.yandex.ru. सभी आवश्यक फ़ील्ड भरने के बाद, हमारा एक खाता बनाया जाएगा और एक निश्चित राशि का अनुदान दिया जाएगा, जिसका उपयोग क्लाउड सेवाओं का परीक्षण करने के लिए किया जा सकता है। यदि आप हमारे लेख के सभी चरणों को दोहराना चाहते हैं, तो यह अनुदान आपके लिए पर्याप्त होना चाहिए।

पंजीकरण के बाद, आपके लिए एक अलग क्लाउड और एक डिफ़ॉल्ट निर्देशिका बनाई जाएगी, जिसमें आप क्लाउड संसाधन बनाना शुरू कर सकते हैं। सामान्य तौर पर, Yandex.Cloud में, संसाधनों का संबंध इस तरह दिखता है:

आप एक खाते के लिए कई क्लाउड बना सकते हैं. और क्लाउड के अंदर, विभिन्न कंपनी परियोजनाओं के लिए अलग-अलग निर्देशिकाएँ बनाएं। आप इसके बारे में दस्तावेज़ में अधिक पढ़ सकते हैं - https://cloud.yandex.ru/docs/resource-manager/concepts/resources-hierarchy. वैसे, मैं अक्सर नीचे पाठ में इसका उल्लेख करूंगा। जब मैंने पूरे बुनियादी ढांचे को नए सिरे से स्थापित किया, तो दस्तावेज़ीकरण ने मुझे एक से अधिक बार मदद की, इसलिए मैं आपको इसका अध्ययन करने की सलाह देता हूं।

क्लाउड को प्रबंधित करने के लिए, आप वेब इंटरफ़ेस और कंसोल उपयोगिता - yc दोनों का उपयोग कर सकते हैं। इंस्टॉलेशन एक कमांड के साथ किया जाता है (लिनक्स और मैक ओएस के लिए):

curl https://storage.yandexcloud.net/yandexcloud-yc/install.sh | bash

यदि आपका आंतरिक सुरक्षा विशेषज्ञ इंटरनेट से स्क्रिप्ट चलाने के बारे में क्रोधित है, तो, सबसे पहले, आप स्क्रिप्ट खोल सकते हैं और इसे पढ़ सकते हैं, और दूसरी बात, हम इसे अपने उपयोगकर्ता के तहत चलाते हैं - बिना रूट अधिकारों के।

यदि आप विंडोज़ के लिए क्लाइंट स्थापित करना चाहते हैं, तो आप निर्देशों का उपयोग कर सकते हैं यहां और फिर निष्पादित करें yc initइसे पूरी तरह से अनुकूलित करने के लिए:

vozerov@mba:~ $ yc init
Welcome! This command will take you through the configuration process.
Please go to https://oauth.yandex.ru/authorize?response_type=token&client_id= in order to obtain OAuth token.

Please enter OAuth token:
Please select cloud to use:
 [1] cloud-b1gv67ihgfu3bp (id = b1gv67ihgfu3bpt24o0q)
 [2] fevlake-cloud (id = b1g6bvup3toribomnh30)
Please enter your numeric choice: 2
Your current cloud has been set to 'fevlake-cloud' (id = b1g6bvup3toribomnh30).
Please choose folder to use:
 [1] default (id = b1g5r6h11knotfr8vjp7)
 [2] Create a new folder
Please enter your numeric choice: 1
Your current folder has been set to 'default' (id = b1g5r6h11knotfr8vjp7).
Do you want to configure a default Compute zone? [Y/n]
Which zone do you want to use as a profile default?
 [1] ru-central1-a
 [2] ru-central1-b
 [3] ru-central1-c
 [4] Don't set default zone
Please enter your numeric choice: 1
Your profile default Compute zone has been set to 'ru-central1-a'.
vozerov@mba:~ $

सिद्धांत रूप में, प्रक्रिया सरल है - सबसे पहले आपको क्लाउड को प्रबंधित करने के लिए एक OAuth टोकन प्राप्त करना होगा, क्लाउड और उस फ़ोल्डर का चयन करें जिसका आप उपयोग करेंगे।

यदि आपके पास एक ही क्लाउड में कई खाते या फ़ोल्डर हैं, तो आप yc config प्रोफ़ाइल बनाएं और उनके बीच स्विच करके अलग-अलग सेटिंग्स के साथ अतिरिक्त प्रोफ़ाइल बना सकते हैं।

उपरोक्त विधियों के अलावा, Yandex.Cloud टीम ने बहुत अच्छा लिखा टेराफॉर्म के लिए प्लगइन क्लाउड संसाधनों के प्रबंधन के लिए। अपनी ओर से, मैंने एक गिट रिपॉजिटरी तैयार की, जहां मैंने उन सभी संसाधनों का वर्णन किया जो लेख के हिस्से के रूप में बनाए जाएंगे - https://github.com/rebrainme/yandex-cloud-events/. हम मास्टर शाखा में रुचि रखते हैं, आइए इसे स्थानीय रूप से क्लोन करें:


vozerov@mba:~ $ git clone https://github.com/rebrainme/yandex-cloud-events/ events
Cloning into 'events'...
remote: Enumerating objects: 100, done.
remote: Counting objects: 100% (100/100), done.
remote: Compressing objects: 100% (68/68), done.
remote: Total 100 (delta 37), reused 89 (delta 26), pack-reused 0
Receiving objects: 100% (100/100), 25.65 KiB | 168.00 KiB/s, done.
Resolving deltas: 100% (37/37), done.
vozerov@mba:~ $ cd events/terraform/

टेराफ़ॉर्म में उपयोग किए जाने वाले सभी मुख्य वेरिएबल्स main.tf फ़ाइल में लिखे गए हैं। आरंभ करने के लिए, निम्नलिखित सामग्री के साथ टेराफॉर्म फ़ोल्डर में एक Private.auto.tfvars फ़ाइल बनाएं:

# Yandex Cloud Oauth token
yc_token = ""
# Yandex Cloud ID
yc_cloud_id = ""
# Yandex Cloud folder ID
yc_folder_id = ""
# Default Yandex Cloud Region
yc_region = "ru-central1-a"
# Cloudflare email
cf_email = ""
# Cloudflare token
cf_token = ""
# Cloudflare zone id
cf_zone_id = ""

सभी वेरिएबल्स को yc कॉन्फ़िगरेशन सूची से लिया जा सकता है, क्योंकि हमने कंसोल उपयोगिता को पहले ही कॉन्फ़िगर कर लिया है। मैं आपको सलाह देता हूं कि आप तुरंत Private.auto.tfvars को .gitignore में जोड़ें, ताकि गलती से निजी डेटा प्रकाशित न हो।

Private.auto.tfvars में हमने Cloudflare से डेटा भी निर्दिष्ट किया है - DNS रिकॉर्ड बनाने और मुख्य डोमेन इवेंट्स.kis.im को हमारे सर्वर पर प्रॉक्सी करने के लिए। यदि आप क्लाउडफ़ेयर का उपयोग नहीं करना चाहते हैं, तो main.tf और dns.tf फ़ाइल में क्लाउडफ़ेयर प्रदाता के आरंभीकरण को हटा दें, जो आवश्यक डीएनएस रिकॉर्ड बनाने के लिए ज़िम्मेदार है।

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

आभासी नेटवर्क

ईमानदारी से कहें तो, आप इस चरण को छोड़ सकते हैं, क्योंकि जब आप एक नया क्लाउड बनाते हैं, तो आपके पास स्वचालित रूप से एक अलग नेटवर्क और 3 सबनेट बनाए जाएंगे - प्रत्येक उपलब्धता क्षेत्र के लिए एक। लेकिन हम फिर भी अपने प्रोजेक्ट के लिए अपने पते के साथ एक अलग नेटवर्क बनाना चाहेंगे। Yandex.Cloud में नेटवर्क कैसे काम करता है इसका सामान्य आरेख नीचे दिए गए चित्र में दिखाया गया है (ईमानदारी से लिया गया है)। https://cloud.yandex.ru/docs/vpc/concepts/)

तो, आप एक सामान्य नेटवर्क बनाते हैं जिसके भीतर संसाधन एक दूसरे के साथ संचार कर सकते हैं। प्रत्येक उपलब्धता क्षेत्र के लिए, अपने स्वयं के पते के साथ एक सबनेट बनाया जाता है और सामान्य नेटवर्क से जोड़ा जाता है। परिणामस्वरूप, इसमें मौजूद सभी क्लाउड संसाधन संचार कर सकते हैं, भले ही वे विभिन्न उपलब्धता क्षेत्रों में हों। विभिन्न क्लाउड नेटवर्क से जुड़े संसाधन केवल बाहरी पतों के माध्यम से एक दूसरे को देख सकते हैं। वैसे ये जादू अंदर कैसे काम करता है, हेब्रे पर अच्छी तरह से वर्णित किया गया था.

नेटवर्क निर्माण का वर्णन रिपॉजिटरी से नेटवर्क.tf फ़ाइल में किया गया है। वहां हम एक सामान्य निजी नेटवर्क आंतरिक बनाते हैं और विभिन्न उपलब्धता क्षेत्रों में तीन सबनेट को इससे जोड़ते हैं - आंतरिक-ए (172.16.1.0/24), आंतरिक-बी (172.16.2.0/24), आंतरिक-सी (172.16.3.0/24) ).

टेराफॉर्म प्रारंभ करें और नेटवर्क बनाएं:

vozerov@mba:~/events/terraform (master) $ terraform init
... skipped ..

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_vpc_subnet.internal-a -target yandex_vpc_subnet.internal-b -target yandex_vpc_subnet.internal-c

... skipped ...

Plan: 4 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

yandex_vpc_network.internal: Creating...
yandex_vpc_network.internal: Creation complete after 3s [id=enp2g2rhile7gbqlbrkr]
yandex_vpc_subnet.internal-a: Creating...
yandex_vpc_subnet.internal-b: Creating...
yandex_vpc_subnet.internal-c: Creating...
yandex_vpc_subnet.internal-a: Creation complete after 6s [id=e9b1dad6mgoj2v4funog]
yandex_vpc_subnet.internal-b: Creation complete after 7s [id=e2liv5i4amu52p64ac9p]
yandex_vpc_subnet.internal-c: Still creating... [10s elapsed]
yandex_vpc_subnet.internal-c: Creation complete after 10s [id=b0c2qhsj2vranoc9vhcq]

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.

महान! हमने अपना नेटवर्क बना लिया है और अब अपनी आंतरिक सेवाएँ बनाने के लिए तैयार हैं।

वर्चुअल मशीनें बनाना

एप्लिकेशन का परीक्षण करने के लिए, हमें केवल दो वर्चुअल मशीनें बनाने की आवश्यकता होगी - हमें एप्लिकेशन बनाने और चलाने के लिए पहले की आवश्यकता होगी, काफ्का चलाने के लिए दूसरे की, जिसका उपयोग हम आने वाले संदेशों को संग्रहीत करने के लिए करेंगे। और हम एक और मशीन बनाएंगे जहां हम एप्लिकेशन की निगरानी के लिए प्रोमेथियस को कॉन्फ़िगर करेंगे।

वर्चुअल मशीनों को ansible का उपयोग करके कॉन्फ़िगर किया जाएगा, इसलिए टेराफ़ॉर्म शुरू करने से पहले, सुनिश्चित करें कि आपके पास ansible के नवीनतम संस्करणों में से एक है। और ansible Galaxy के साथ आवश्यक भूमिकाएँ स्थापित करें:

vozerov@mba:~/events/terraform (master) $ cd ../ansible/
vozerov@mba:~/events/ansible (master) $ ansible-galaxy install -r requirements.yml
- cloudalchemy-prometheus (master) is already installed, skipping.
- cloudalchemy-grafana (master) is already installed, skipping.
- sansible.kafka (master) is already installed, skipping.
- sansible.zookeeper (master) is already installed, skipping.
- geerlingguy.docker (master) is already installed, skipping.
vozerov@mba:~/events/ansible (master) $

Ansible फ़ोल्डर के अंदर एक उदाहरण .ansible.cfg कॉन्फ़िगरेशन फ़ाइल है जिसका मैं उपयोग करता हूँ। यह काम आ सकता है.

वर्चुअल मशीनें बनाने से पहले, सुनिश्चित करें कि आपके पास ssh-एजेंट चल रहा है और एक ssh कुंजी जोड़ी गई है, अन्यथा टेराफॉर्म बनाई गई मशीनों से कनेक्ट नहीं हो पाएगा। निःसंदेह, मुझे ओएस एक्स में एक बग का पता चला: https://github.com/ansible/ansible/issues/32499#issuecomment-341578864. इसे दोबारा होने से रोकने के लिए, टेराफॉर्म लॉन्च करने से पहले env में एक छोटा वेरिएबल जोड़ें:

vozerov@mba:~/events/terraform (master) $ export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES

टेराफ़ॉर्म वाले फ़ोल्डर में हम आवश्यक संसाधन बनाते हैं:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_compute_instance.build -target yandex_compute_instance.monitoring -target yandex_compute_instance.kafka
yandex_vpc_network.internal: Refreshing state... [id=enp2g2rhile7gbqlbrkr]
data.yandex_compute_image.ubuntu_image: Refreshing state...
yandex_vpc_subnet.internal-a: Refreshing state... [id=e9b1dad6mgoj2v4funog]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

... skipped ...

Plan: 3 to add, 0 to change, 0 to destroy.

... skipped ...

यदि सब कुछ सफलतापूर्वक समाप्त हो गया (और यह होना चाहिए), तो हमारे पास तीन वर्चुअल मशीनें होंगी:

बिल्ड - किसी एप्लिकेशन के परीक्षण और निर्माण के लिए एक मशीन। डॉकर को Ansible द्वारा स्वचालित रूप से स्थापित किया गया था।
मॉनिटरिंग - एक मॉनिटरिंग मशीन - प्रोमेथियस और ग्राफाना इस पर स्थापित है। लॉगिन / पासवर्ड मानक: व्यवस्थापक / व्यवस्थापक
काफ्का एक छोटी मशीन है जिसमें काफ्का स्थापित है, जो पोर्ट 9092 पर पहुंच योग्य है।

आइए सुनिश्चित करें कि वे सभी अपनी जगह पर हैं:

vozerov@mba:~/events (master) $ yc compute instance list
+----------------------+------------+---------------+---------+---------------+-------------+
|          ID          |    NAME    |    ZONE ID    | STATUS  |  EXTERNAL IP  | INTERNAL IP |
+----------------------+------------+---------------+---------+---------------+-------------+
| fhm081u8bkbqf1pa5kgj | monitoring | ru-central1-a | RUNNING | 84.201.159.71 | 172.16.1.35 |
| fhmf37k03oobgu9jmd7p | kafka      | ru-central1-a | RUNNING | 84.201.173.41 | 172.16.1.31 |
| fhmt9pl1i8sf7ga6flgp | build      | ru-central1-a | RUNNING | 84.201.132.3  | 172.16.1.26 |
+----------------------+------------+---------------+---------+---------------+-------------+

संसाधन मौजूद हैं, और यहां से हम उनके आईपी पते प्राप्त कर सकते हैं। निम्नलिखित के दौरान मैं एसएसएच के माध्यम से कनेक्ट करने और एप्लिकेशन का परीक्षण करने के लिए आईपी पते का उपयोग करूंगा। यदि आपके पास टेराफ़ॉर्म से जुड़ा क्लाउडफ़ेयर खाता है, तो बेझिझक नए बनाए गए DNS नामों का उपयोग करें।
वैसे, वर्चुअल मशीन बनाते समय, एक आंतरिक आईपी और एक आंतरिक डीएनएस नाम दिया जाता है, ताकि आप नाम से नेटवर्क के भीतर सर्वर तक पहुंच सकें:

ubuntu@build:~$ ping kafka.ru-central1.internal
PING kafka.ru-central1.internal (172.16.1.31) 56(84) bytes of data.
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=1 ttl=63 time=1.23 ms
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=2 ttl=63 time=0.625 ms
^C
--- kafka.ru-central1.internal ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.625/0.931/1.238/0.308 ms

यह हमारे लिए एप्लिकेशन को kafk के साथ समापन बिंदु इंगित करने के लिए उपयोगी होगा।

एप्लिकेशन को असेंबल करना

बढ़िया, सर्वर हैं, एक एप्लिकेशन है - जो कुछ बचा है उसे इकट्ठा करना और प्रकाशित करना है। बिल्ड के लिए हम सामान्य डॉकर बिल्ड का उपयोग करेंगे, लेकिन छवि भंडारण के रूप में हम यांडेक्स - कंटेनर रजिस्ट्री की एक सेवा का उपयोग करेंगे। लेकिन सबसे पहले चीज़ें.

हम एप्लिकेशन को बिल्ड मशीन में कॉपी करते हैं, एसएसएच के माध्यम से लॉग इन करते हैं और छवि को इकट्ठा करते हैं:

vozerov@mba:~/events/terraform (master) $ cd ..
vozerov@mba:~/events (master) $ rsync -av app/ [email protected]:app/

... skipped ...

sent 3849 bytes  received 70 bytes  7838.00 bytes/sec
total size is 3644  speedup is 0.93

vozerov@mba:~/events (master) $ ssh 84.201.132.3 -l ubuntu
ubuntu@build:~$ cd app
ubuntu@build:~/app$ sudo docker build -t app .
Sending build context to Docker daemon  6.144kB
Step 1/9 : FROM golang:latest AS build
... skipped ...

Successfully built 9760afd8ef65
Successfully tagged app:latest

आधी लड़ाई हो चुकी है - अब हम अपने एप्लिकेशन को लॉन्च करके और काफ्का को भेजकर इसकी कार्यक्षमता की जांच कर सकते हैं:

ubuntu@build:~/app$ sudo docker run --name app -d -p 8080:8080 app /app/app -kafka=kafka.ru-central1.internal:9092</code>

С локальной машинки можно отправить тестовый event и посмотреть на ответ:

<code>vozerov@mba:~/events (master) $ curl -D - -s -X POST -d '{"key1":"data1"}' http://84.201.132.3:8080/post
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 13 Apr 2020 13:53:54 GMT
Content-Length: 41

{"status":"ok","partition":0,"Offset":0}
vozerov@mba:~/events (master) $

एप्लिकेशन ने रिकॉर्डिंग की सफलता के साथ प्रतिक्रिया दी और विभाजन और ऑफसेट की आईडी का संकेत दिया जिसमें संदेश शामिल था। बस इतना करना बाकी है कि Yandex.Cloud में एक रजिस्ट्री बनाएं और वहां अपनी छवि अपलोड करें (तीन पंक्तियों का उपयोग करके इसे कैसे करें, इसका वर्णन रजिस्ट्री.tf फ़ाइल में किया गया है)। एक भंडारण बनाएँ:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_container_registry.events

... skipped ...

Plan: 1 to add, 0 to change, 0 to destroy.

... skipped ...

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

कंटेनर रजिस्ट्री में प्रमाणित करने के कई तरीके हैं - एक ओथ टोकन, एक आईएएम टोकन, या एक सेवा खाता कुंजी का उपयोग करना। इन विधियों के बारे में अधिक विवरण दस्तावेज़ में पाया जा सकता है। https://cloud.yandex.ru/docs/container-registry/operations/authentication. हम सेवा खाता कुंजी का उपयोग करेंगे, इसलिए हम एक खाता बनाएंगे:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_iam_service_account.docker -target yandex_resourcemanager_folder_iam_binding.puller -target yandex_resourcemanager_folder_iam_binding.pusher

... skipped ...

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.

अब जो कुछ बचा है वह इसके लिए एक कुंजी बनाना है:

vozerov@mba:~/events/terraform (master) $ yc iam key create --service-account-name docker -o key.json
id: ajej8a06kdfbehbrh91p
service_account_id: ajep6d38k895srp9osij
created_at: "2020-04-13T14:00:30Z"
key_algorithm: RSA_2048

हम अपने भंडारण की आईडी के बारे में जानकारी प्राप्त करते हैं, कुंजी स्थानांतरित करते हैं और लॉग इन करते हैं:

vozerov@mba:~/events/terraform (master) $ scp key.json [email protected]:
key.json                                                                                                                    100% 2392   215.1KB/s   00:00

vozerov@mba:~/events/terraform (master) $ ssh 84.201.132.3 -l ubuntu

ubuntu@build:~$ cat key.json | sudo docker login --username json_key --password-stdin cr.yandex
WARNING! Your password will be stored unencrypted in /home/ubuntu/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
ubuntu@build:~$

छवि को रजिस्ट्री में अपलोड करने के लिए, हमें कंटेनर रजिस्ट्री आईडी की आवश्यकता है, हम इसे yc उपयोगिता से लेते हैं:

vozerov@mba:~ $ yc container registry get events
id: crpdgj6c9umdhgaqjfmm
folder_id:
name: events
status: ACTIVE
created_at: "2020-04-13T13:56:41.914Z"

उसके बाद, हम अपनी छवि को एक नए नाम के साथ टैग करते हैं और अपलोड करते हैं:

ubuntu@build:~$ sudo docker tag app cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
ubuntu@build:~$ sudo docker push cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
The push refers to repository [cr.yandex/crpdgj6c9umdhgaqjfmm/events]
8c286e154c6e: Pushed
477c318b05cb: Pushed
beee9f30bc1f: Pushed
v1: digest: sha256:1dd5aaa9dbdde2f60d833be0bed1c352724be3ea3158bcac3cdee41d47c5e380 size: 946

हम सत्यापित कर सकते हैं कि छवि सफलतापूर्वक लोड हुई है:

vozerov@mba:~/events/terraform (master) $ yc container repository list
+----------------------+-----------------------------+
|          ID          |            NAME             |
+----------------------+-----------------------------+
| crpe8mqtrgmuq07accvn | crpdgj6c9umdhgaqjfmm/events |
+----------------------+-----------------------------+

वैसे, यदि आप लिनक्स मशीन पर yc उपयोगिता स्थापित करते हैं, तो आप कमांड का उपयोग कर सकते हैं

yc container registry configure-docker

डॉकर को कॉन्फ़िगर करने के लिए.

निष्कर्ष

हमने बहुत मेहनत की है और उसका परिणाम है:

हम अपनी भावी सेवा की रूपरेखा लेकर आए हैं।
हमने गोलांग में एक एप्लिकेशन लिखा जो हमारे व्यावसायिक तर्क को लागू करता है।
हमने इसे एकत्र किया और एक निजी कंटेनर रजिस्ट्री में डाल दिया।

अगले भाग में, हम दिलचस्प चीज़ों की ओर बढ़ेंगे - हम अपने एप्लिकेशन को उत्पादन में जारी करेंगे और अंत में उस पर लोड लॉन्च करेंगे। स्विच मत करो!

यह सामग्री ओपन वर्कशॉप REBRAIN & Yandex.Cloud की वीडियो रिकॉर्डिंग में है: हम Yandex क्लाउड पर प्रति सेकंड 10 अनुरोध स्वीकार करते हैं - https://youtu.be/cZLezUm0ekE

यदि आप ऐसे आयोजनों में ऑनलाइन भाग लेने और वास्तविक समय में प्रश्न पूछने में रुचि रखते हैं, तो हमसे जुड़ें रेब्रेन चैनल द्वारा DevOps.

हम इस तरह के आयोजन की मेजबानी करने का अवसर देने के लिए Yandex.Cloud को विशेष धन्यवाद देना चाहते हैं। उनसे लिंक करें - https://cloud.yandex.ru/prices

यदि आपको क्लाउड पर जाने की आवश्यकता है या आपके बुनियादी ढांचे के बारे में प्रश्न हैं, एक अनुरोध सबमिट करने के लिए स्वतंत्र महसूस करें.

पीएस हमारे पास प्रति माह 2 मुफ्त ऑडिट हैं, शायद आपकी परियोजना उनमें से एक होगी।

स्रोत: www.habr.com

हम Yandex.Cloud में 10 इवेंट स्वीकार करते हैं। भाग ---- पहला

टी