आपका कोकीन Yandex Cloud Platform

हम पहले ही यैंडेक्स क्लाउड इंफ्रास्ट्रक्चर के बारे में हैबर से बात कर चुके हैं। आज कारोबार से नीचे उतरने के लिए शब्दों की बारी है - हम उन चरणों में दिखाना चाहते हैं कि कैसे एलिप्टिक्स और कोकेन पर अपने स्वयं के क्लाउड को तैनात किया जाए।

योजना

आइए एक छोटे बादल को स्थापित करने पर ध्यान दें जहां आप फ्लास्क का उपयोग करके एक परीक्षण एप्लिकेशन चला सकते हैं।

इस बादल में निम्नलिखित तत्व होते हैं:

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

प्रत्येक चरण में, हम मंच की सफलता का परीक्षण करने के लिए जांच करेंगे।



जैसा कि आप देख सकते हैं, डॉकर को सपोर्ट करने के लिए हमें कम से कम 3.8 के कर्नेल के साथ 5 (वर्चुअल वाले) मशीनों की आवश्यकता है। आवश्यक पैकेज भंडार में पाए जा सकते हैं।

एलिप्टिक्स पर 5 मिनट

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

आदेशों की एक जोड़ी में, यह इस तरह दिखता है:

 sudo apt-get install elliptics=2.24.14.31 elliptics-client=2.24.14.31 mkdir /tmp/history/ && mkdir /tmp/root cp /usr/share/doc/elliptics/examples/ioserv.conf ./tst_ioserv.conf 

Tst_ioserv.conf में आगे हमें शाब्दिक 3 पंक्तियों को बदलना होगा। तो:

 group = 1 addr = localhost:1025:2-0 192.168.50.201:1025:2-1 //    IP indexes_shard_count = 16 

उसके बाद, रन:

 dnet_ioserv -c tst_ioserv.conf 

कोकीन-रनटाइम + डोकर को कॉन्फ़िगर करना

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

मैं स्पष्ट करूंगा कि यद्यपि हमारा लक्ष्य एप्लिकेशन को डॉकटर कंटेनर में चलाना है, हम एप्लिकेशन को एक सामान्य प्रक्रिया के रूप में भी लॉन्च करेंगे।

कंटेनरीकरण अच्छा है। यह अनुप्रयोग के लिए पर्यावरणीय मुद्दों को हल करता है:

• नशा हमेशा हमारे साथ है;
• दो अनुप्रयोगों की निर्भरता के बीच कोई संघर्ष नहीं हैं;
• देव, परीक्षण, ठेस-वातावरण में पर्यावरण की अपरिहार्यता।

कंटेनर के बिना शुरू करना लागू होता है और सुविधाजनक होता है जब कोई निर्भरता नहीं होती है (उदाहरण के लिए, जाने पर एक अनुप्रयोग) या कंटेनर का उपयोग करने की तकनीकी क्षमता (उदाहरण के लिए, कर्नेल आवश्यक संस्करण से कम है और आप इसे अपडेट नहीं कर सकते हैं)।

रिपॉजिटरी को जोड़ने के बाद, आवश्यक पैकेज स्थापित करें:

 sudo apt-get install cocaine-runtime libcocaine-core2 libcocaine-plugin-docker2 libcocaine-plugin-elliptics=2.24.14.31 elliptics-client=2.24.14.31 

अनुप्रयोगों का प्रबंधन करने के लिए, हमें कोकीन-उपकरण उपयोगिता की आवश्यकता है। इसे स्थापित करने का सबसे आसान तरीका PyPI , मानक पायथन पैकेज रिपॉजिटरी से है।

आपको msgpack के लिए Python में बाइंडर्स इंस्टॉल करना होगा।

 sudo apt-get install msgpack-python 

और फिर कोकीन-औजार ।

 sudo pip install cocaine-tools 

हम डॉकटर को किसी भी सुविधाजनक तरीके से आधिकारिक दस्तावेज में वर्णित के रूप में स्थापित करते हैं। निम्नलिखित पथ का उपयोग किया जाता है:

 curl -s https://get.docker.io/ubuntu/ | sudo sh 

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

 sudo service cocaine-runtime stop 

डिफ़ॉल्ट कॉन्फ़िगरेशन फ़ाइल /etc/cocaine/cocaine-default.conf में स्थित है और इस तरह दिखता है:

 { "version": 2, "paths": { "plugins": "/usr/lib/cocaine", "runtime": "/var/run/cocaine" }, "services": { "logging": { "type": "logging" }, "storage": { "type": "storage", "args": { "backend": "core" } }, "node": { "type": "node", "args": { "runlist": "default" } } }, "storages": { "core": { "type": "files", "args": { "path": "/var/lib/cocaine" } }, "cache": { "type": "files", "args": { "path": "/var/cache/cocaine" } } }, "loggers": { "core": { "type": "syslog", "args": { "identity": "cocaine", "verbosity": "info" } } } } 

चलो बादल विन्यास बनाते हैं। ऐसा करने के लिए, आपको 2 संस्थाओं को कॉन्फ़िगर करने की आवश्यकता है:

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

प्रयोगों के लिए, प्रदान की गई डिफ़ॉल्ट कॉन्फ़िग की एक प्रति को संशोधित करना सुविधाजनक है (उदाहरण के लिए, /etc/cocaine/cocaine-cloud.conf )।

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

  "network" : { "group": "224.168.2.9" }, "services": { ... } 

एकमात्र समूह पैरामीटर मल्टीकास्ट समूह के पते का वर्णन करता है जिससे अलर्ट भेजे जाएंगे।
भंडारण को सेवाओं / भंडारण और भंडारण / मुख्य वर्गों को संशोधित करके कॉन्फ़िगर किया गया है:

 "storage": { "type": "elliptics" }, "storages" : { "core": { "type": "elliptics", "args": { "nodes" : { "192.168.50.201" : 1025 }, "io-thread-num" : 8, "wait-timeout" : 30, "check-timeout" : 60, "net-thread-num" : 8, "groups" : [1], "verbosity" : 2 } } } 

एलिप्टिक्स भंडारण कार्यान्वयन इसी प्लगइन द्वारा प्रदान किए जाते हैं। वैसे, हमारे पैकेज से सभी प्लगइन्स को / usr / lib / कोकीन में रखा जाता है, जहां कोकेन-रनटाइम डिफ़ॉल्ट रूप से उनके लिए दिखता है।

अब हम कोकीन को डिफ़ॉल्ट रूप से इस कॉन्फिगर के साथ शुरू करने के लिए मजबूर करेंगे। बनाने
/etc/default/cocaine-runtime :
CONFIG_PATH = "/ etc / कोकीन / कोकीन-क्लाउड ।conf"

नए कॉन्फ़िगरेशन के साथ कोकीन-रनटाइम चलाएं, सुनिश्चित करें कि प्रक्रिया काम कर रही है।


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

आप cocaine-tool info आदेश का उपयोग करके इस नोड के अनुप्रयोगों के बारे में जानकारी का अनुरोध कर सकते हैं। इस कमांड का आउटपुट अभी तक आश्चर्यजनक नहीं है, लेकिन इसे याद रखें - यह बहुत जल्द बदल जाएगा।

याद रखें कि कोकीन-रनटाइम और प्लगइन्स के अलावा, हमने डॉकर को स्थापित किया। जाँच करें कि यह भी सफलतापूर्वक शुरू हुआ:


हम मानते हैं कि दूसरी मशीन पर भी इसी तरह की कार्रवाई की जाएगी। कुल मिलाकर, हमारे पास कोकीन-रनटाइम चलने वाली 2 कारें हैं जो साझा भंडारण को देखते हैं - यह बहुत अच्छा है!

इस बिंदु पर, अनुप्रयोगों को चलाना पहले से ही संभव है। यह, ज़ाहिर है, एक बादल नहीं है, लेकिन फिर भी। अपनी आस्तीन ऊपर रोल, चलो शुरू हो जाओ।

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

हम एक उदाहरण के साथ रिपॉजिटरी को क्लोन करते हैं और डायरेक्टरी पर जाते हैं।

 git clone git@github.com:cocaine/cocaine-framework-python.git -b v0.11 cd cocaine-framework-python/examples/flask/ 

आप देख सकते हैं कि एप्लिकेशन कोड के अलावा, मेनिफ़ेस्ट .json यहाँ स्थित है:

 { "slave": "main.py" } 

इस फ़ाइल का मुख्य कार्य प्लेटफ़ॉर्म को यह बताना है कि क्या चलाना है। आप पर्यावरण भी पास कर सकते हैं।

क्लाउड में एक प्रक्रिया के रूप में हम जिस एप्लिकेशन को चलाना चाहते हैं, उसका कोड डाउनलोड करने के लिए, आपको निम्नलिखित कमांड चलाना होगा:

 cocaine-tool app upload --name example 

कोकीन-टूल आपके एप्लिकेशन को एक संग्रह में पैक करेगा और क्लाउड पर अपलोड करेगा। और फिर हम डाउनलोड किए गए एप्लिकेशन की सूची को देखते हैं।



यहाँ यह है, हमारे आवेदन! मुख्य बात फ्लास्क स्थापित करना नहीं भूलना है, जिसे हमारे आवेदन की आवश्यकता है। यहां कंटेनर के बिना चलने का नुकसान है।

 sudo apt-get install python-flask 

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

सबसे सरल प्रोफ़ाइल खाली JSON {} । इस स्थिति में, डिफ़ॉल्ट सेटिंग्स का उपयोग किया जाता है।

सभी उपलब्ध विकल्पों का विवरण विवरण में पाया जा सकता है। हम बाद में एक और दिलचस्प उदाहरण पर विचार करेंगे जब हम कंटेनर में एप्लिकेशन लॉन्च करेंगे।

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


अंत में, वह क्षण आ गया है जब आप स्विच को खींच सकते हैं और अनुप्रयोग शुरू होता है:

 cocaine-tool app start --name example --profile default 

अब cocaine-tool info कमांड का आउटपुट बदल गया है। यह दिखाता है कि कौन से एप्लिकेशन इस नोड पर चल रहे हैं और अनुप्रयोगों के बारे में आंकड़े।

आइए हमारे एप्लिकेशन को एक संदेश भेजने का प्रयास करें। इस प्रयोजन के लिए, बस इतनी छोटी अजगर लिपि ही पर्याप्त है:

 #!/usr/bin/env python from cocaine.services import Service app = Service("example") print(app.enqueue("write", "DATA").get()) print(app.enqueue("read", "DATA").get()) 

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

डॉकटर रजिस्ट्री

डॉकर-रजिस्ट्री आपके एप्लिकेशन छवियों (कंटेनरों) का निजी भंडार है। आप इसके बारे में आधिकारिक docker प्रलेखन में अधिक पढ़ सकते हैं।

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

डॉकर-रजिस्ट्री को चलाने का सबसे आसान तरीका डॉकटर का उपयोग करना है। ऐसा करने के लिए, हमें डॉकर को स्थापित करना होगा (ऊपर देखें) और कमांड को वांछित छवि दें।

 sudo docker run -p 5000:5000 registry 

रजिस्ट्री छवि को पहले रिपॉजिटरी, कैश्ड से लोड किया जाता है, और अगली बार यह जल्दी से शुरू हो जाएगा।

एक बार लॉन्च होने के बाद, डॉकर-रजिस्ट्री पोर्ट 5000 पर सुनेगी। हमने उसे पिंग किया:

 curl "http://192.168.50.4:5000/_ping" 

यह सेटअप पूरा करता है।

एक कंटेनर में अनुप्रयोगों का निर्माण और तैनाती करें

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

इसके अलावा, कोई भी डॉकर जो कंटेनर चलाना चाहता है, वह रजिस्ट्री से अपनी छवि लोड कर सकता है। Dockerfile सिंटैक्स, उपलब्ध कमांड यहाँ पाया जा सकता है। डॉकरफाइल के बजाय, आप एक बावर्ची नुस्खा या कठपुतली प्रकट प्रदान कर सकते हैं जिसे विधानसभा के दौरान कंटेनर के अंदर निष्पादित किया जाएगा।

इस एप्लिकेशन के लिए प्रोफ़ाइल में, आपको इन्सुलेशन डॉकर के प्रकार को निर्दिष्ट करना होगा। ऐसा करने के लिए, एक नया प्रोफ़ाइल बनाएं।

 { "queue-limit": 1000, "pool-limit": 10, "isolate": { "type": "docker", "args": { "memory_limit": 1000000000, "endpoint": "unix:///var/run/docker.sock", "registry": "registry.cloud.net:5000", "cpu_shares": 0 } }, "concurrency": 200 } 

हमने फाइल को docker-profile.json नाम से फाइल में रखा है, इसे docker-profile नाम से अपलोड करें

 cocaine-tool profile upload --name docker-profile --profile=docker-profile.json 

इस उदाहरण में, हमारे पास एक तैयार किया हुआ डॉकरफाइल है, और क्लाउड पर एप्लिकेशन डाउनलोड करना इस प्रकार है:

 sudo cocaine-tool app upload --docker=unix:///var/run/docker.sock --registry=registry.cloud.net:5000 --manifest manifest-docker.json --name example-docker --timeout 20000 

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


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

एकत्रीकरण नोड विन्यास

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

हमारे पास इस प्लगइन के दो कार्यान्वयन हैं। पहले को एडहॉक कहा जाता है। यह "बॉक्स से बाहर" उपलब्ध है और अतिरिक्त पैकेजों की स्थापना की आवश्यकता नहीं है। दूसरा कार्यान्वयन जिसे हम मुकाबले में उपयोग करते हैं, उसे आईपीवी कहा जाता है। जैसा कि नाम का अर्थ है, यह उसी नाम की तकनीक का उपयोग करता है। Adhoc का उपयोग करने के लिए बुद्धिमान है जब ipvs का उपयोग करना संभव नहीं है। और निश्चित रूप से, आप संतुलन के लिए अपनी पसंद की तकनीक का उपयोग करने के लिए इस प्लगइन का अपना कार्यान्वयन लिख सकते हैं।

शब्दों से कर्मों तक। पैकेज स्थापित करें:

 sudo apt-get install cocaine-runtime libcocaine-core2 libcocaine-plugin-ipvs2 libcocaine-plugin-elliptics=2.24.14.31 elliptics-client=2.24.14.31 

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

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

  "network": { "group": "224.168.2.9", "gateway": { "type": "ipvs" // adhoc } }, "services"... 

sudo service cocane-runtime restart , प्रक्रिया शुरू होनी चाहिए:

 cocaine /usr/bin/cocaine-runtime --daemonize --configuration /etc/cocaine/cocaine-gateway.conf --pidfile /var/run/cocaine/runtime.pid 

वास्तव में, प्रवेश द्वार कई मापदंडों को स्वीकार करता है (आप प्रलेखन में उनके बारे में पढ़ सकते हैं)।

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

कोकीन से देशी-प्रॉक्सी

कोकीन-देशी-प्रॉक्सी आपको HTTP पर क्लाउड एप्लिकेशन पर जाने की अनुमति देता है। इसे स्थापित करना और कॉन्फ़िगर करना बेहद सरल है।

 apt-get install cocaine-native-proxy 

फिर हमें लोकेटर सेक्शन में एकत्रित नोड्स की सूची को निर्दिष्ट करने की आवश्यकता है। हमारे मामले में, केवल एक ही नोड है। कड़ाई से बोलते हुए, वहां आप स्थान और नोड्स के पते निर्दिष्ट कर सकते हैं जो एकत्रीकरण मोड में काम नहीं करते हैं। यह इस कारण से बुरा है कि इस तरह के नोड को अन्य नोड्स पर सेवाओं और अनुप्रयोगों के बारे में कुछ भी नहीं पता है, जिसका अर्थ है कि आपके पास उन तक पहुंच नहीं होगी। मापदंडों का अधिक विस्तृत विवरण github.com/cocaine/cocaine-native-proxy/blob/master/README.md पर पाया जा सकता है

 { "endpoints": [ "0.0.0.0:8080" ], "backlog": 2048, "threads": 2, "application": { "locators": ["192.168.50.103:10053"], "service_pool": 5, "reconnect_timeout": 180, "request_timeout": 5 } } 

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

क्लाइंट कोड अब क्लाउड एंट्री पॉइंट के पते को इंगित करता है। मेरे मामले में - 192.168.50.103।

 #!/usr/bin/env python from cocaine.services import Service app = Service("example", host="192.168.50.103") print(app.enqueue("write", "DATA").get()) print(app.enqueue("read", "DATA").get()) 

फ्लास्क एप्लिकेशन को http ईवेंट हैंडलर कहा जाता है। वर्तमान में, HTTP प्रॉक्सी दो तरीकों का समर्थन करती है जो यह निर्धारित करती है कि किस इवेंट को किस एप्लिकेशन को भेजना है। पहली विधि मानती है कि पारित URL पैटर्न के अनुसार बनाया गया है: ///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . . ///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

 ///tail?arg=1&args=2.  URL   .       /tail?arg=1&args=2 .      . 
 
          X-Cocaine-Service, X-Cocaine-Event .      nginx . 
 
  ,       : 
 curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read" 
 
     
 
               .    ,               .           ,    .          .    .  ,       ,       (, 5%).     .        .        ,       ,       . 
 
    .       example ,  exampleGroup .     example   1000 .      .        
 service/locator: adding group 'exampleGroup' 
  
 
           exampleGroup .    ,    ,   app.py    hello: 
 @app.route('/') def hello(name=None): return "HELLO! I'm version #2" 
 
           ,   example2 . 
  
 
    
 curl "http://localhost:8080/exampleGroup/http/" 
 
   ,      .    example2  0 ,      HTTP-proxy     .   ,   HTTP-proxy    .   ,   . 
 
   
     ,     ,    .        ,     Cocaine   ,    c,   .      . 

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

 ///tail?arg=1&args=2.  URL   .       /tail?arg=1&args=2 .      . 
 
          X-Cocaine-Service, X-Cocaine-Event .      nginx . 
 
  ,       : 
 curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read" 
 
     
 
               .    ,               .           ,    .          .    .  ,       ,       (, 5%).     .        .        ,       ,       . 
 
    .       example ,  exampleGroup .     example   1000 .      .        
 service/locator: adding group 'exampleGroup' 
  
 
           exampleGroup .    ,    ,   app.py    hello: 
 @app.route('/') def hello(name=None): return "HELLO! I'm version #2" 
 
           ,   example2 . 
  
 
    
 curl "http://localhost:8080/exampleGroup/http/" 
 
   ,      .    example2  0 ,      HTTP-proxy     .   ,   HTTP-proxy    .   ,   . 
 
   
     ,     ,    .        ,     Cocaine   ,    c,   .      . 

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

 ///tail?arg=1&args=2.  URL   .       /tail?arg=1&args=2 .      . 
 
          X-Cocaine-Service, X-Cocaine-Event .      nginx . 
 
  ,       : 
 curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read" 
 
     
 
               .    ,               .           ,    .          .    .  ,       ,       (, 5%).     .        .        ,       ,       . 
 
    .       example ,  exampleGroup .     example   1000 .      .        
 service/locator: adding group 'exampleGroup' 
  
 
           exampleGroup .    ,    ,   app.py    hello: 
 @app.route('/') def hello(name=None): return "HELLO! I'm version #2" 
 
           ,   example2 . 
  
 
    
 curl "http://localhost:8080/exampleGroup/http/" 
 
   ,      .    example2  0 ,      HTTP-proxy     .   ,   HTTP-proxy    .   ,   . 
 
   
     ,     ,    .        ,     Cocaine   ,    c,   .      . 

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

 ///tail?arg=1&args=2.  URL   .       /tail?arg=1&args=2 .      . 
 
          X-Cocaine-Service, X-Cocaine-Event .      nginx . 
 
  ,       : 
 curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read" 
 
     
 
               .    ,               .           ,    .          .    .  ,       ,       (, 5%).     .        .        ,       ,       . 
 
    .       example ,  exampleGroup .     example   1000 .      .        
 service/locator: adding group 'exampleGroup' 
  
 
           exampleGroup .    ,    ,   app.py    hello: 
 @app.route('/') def hello(name=None): return "HELLO! I'm version #2" 
 
           ,   example2 . 
  
 
    
 curl "http://localhost:8080/exampleGroup/http/" 
 
   ,      .    example2  0 ,      HTTP-proxy     .   ,   HTTP-proxy    .   ,   . 
 
   
     ,     ,    .        ,     Cocaine   ,    c,   .      . 

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .

///tail?arg=1&args=2. URL . /tail?arg=1&args=2 . .

X-Cocaine-Service, X-Cocaine-Event . nginx .

, :
curl "http://localhost:8080/read" -H "X-Cocaine-Service: example" -H "X-Cocaine-Event: http" curl "http://localhost:8080/example/http/read"



. , . , . . . , , (, 5%). . . , , .

. example , exampleGroup . example 1000 . .
service/locator: adding group 'exampleGroup'


exampleGroup . , , app.py hello:
@app.route('/') def hello(name=None): return "HELLO! I'm version #2"

, example2 .



curl "http://localhost:8080/exampleGroup/http/"

, . example2 0 , HTTP-proxy . , HTTP-proxy . , .


, , . , Cocaine , c, . .