यैंडेक्स क्लाउड प्लेटफ़ॉर्म: कोकीन इन एक्शन

हम आपको पहले ही बता चुके हैं कि कोकीन क्या है और इसे "घर पर" कैसे तैनात किया जाए । आज हम प्रोग्रामर स्तर पर इसके बुनियादी ढांचे का उपयोग करने के तरीके के बारे में बात करेंगे। वैसे, 26 अप्रैल को 14:00 बजे, यैंडेक्स मॉस्को कार्यालय में एक बैठक आयोजित की जाएगी जहां आप हमारे साथ लाइव चैट कर सकते हैं - जो टीम कोकेन बनाती है। आओ, लेकिन पंजीकरण करना न भूलें।







तो, आज की पोस्ट से आप सीखेंगे:

• आवेदन कैसे लिखें;
• प्रदान किए गए चौखटे का उपयोग करते हुए, मूल रूप से अनुप्रयोगों और सेवाओं का उपयोग कैसे करें;
• http के माध्यम से जवाब देने के लिए एप्लिकेशन को कैसे बदलना है, साथ ही कोकेन http प्रॉक्सी का उपयोग करके इन अनुप्रयोगों का परीक्षण कैसे करें;
• कैसे अपनी खुद की सेवा लिखने के लिए।

आइए हम प्रोग्रामर के "कोकीन" रोज़मर्रा के जीवन में अपना विसर्जन शुरू करें।



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

भाग 1. कोकीन के साथ काम करना

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

आवेदन कैसे डाउनलोड करें

लगभग पूरे लेख में, कोकेन-टूल कंसोल उपयोगिताओं का उपयोग किया जाएगा, जो स्वयं स्थापित कोकीन-फ्रेमवर्क-पायथन पर निर्भर करते हैं। पायथन की जादुई दुनिया में, इन पुस्तकालयों को कमांड के साथ स्थापित किया गया है:

pip install cocaine-tools
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आप एप्लिकेशन के साथ डायरेक्ट्री में जाकर क्लाउड पर एप्लिकेशन अपलोड कर सकते हैं और निम्नलिखित कमांड चला सकते हैं:

 cocaine-tool app upload
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह महत्वपूर्ण है: डाउनलोड करने से पहले, अपने आवेदन को निष्पादन योग्य में प्रवेश बिंदु बनाने के लिए मत भूलना। हमारे मामले में:

 chmod u+x echo.py
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम प्रदर्शित किया जाएगा:





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

 { "isolate": { "args": { "spool": "/var/spool/cocaine" }, "type": "process" } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आप उसी आदेश का उपयोग करके एक प्रोफ़ाइल अपलोड कर सकते हैं:

 cocaine-tool profile upload --name profile@test --profile ./profile.json
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम कुछ इस तरह होना चाहिए:



एक तैयार प्रोफ़ाइल होने के बाद, यह केवल हाल ही में डाउनलोड किए गए एप्लिकेशन को चलाने के लिए बना हुआ है:

 cocaine-tool app start --name echo --profile profile@test
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि कंसोल कुछ इस तरह प्रदर्शित करता है, तो सब कुछ सफलतापूर्वक किया गया था और हमारा आवेदन अब है

बादल का हिस्सा।



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

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

बहुत संदेश जो उसे भेजा गया था।



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

 from cocaine.futures import chain from cocaine.services import Service from tornado.ioloop import IOLoop # Alias for more readability. asynchronous = chain.source if __name__ == '__main__': io_loop = IOLoop.current() service = Service('echo') @asynchronous def invoke(message): result = yield service.enqueue('ping', message) print(result) invoke('Hello World!') invoke('Hello again!') io_loop.start()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आवश्यक पुस्तकालयों और कक्षाओं के आयात के बाद, हम बस एक कोकीन सेवा वस्तु बनाते हैं जो Service



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



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



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



कॉल का क्रम निम्नानुसार दर्शाया जा सकता है:





एप्लिकेशन इस तरह से क्लाउड पर जाएगा:









रहस्यमय @asynchronous



डेकोरेटर को सजाने के लिए फ़ंक्शन के साथ अतिरिक्त क्रियाएं @asynchronous



, अर्थात्:

• इवेंट लूप में इसकी कॉल जोड़ता है
• यदि फ़ंक्शन एक coroutine है, तो यह अपनी अतुल्यकालिक पदोन्नति प्रक्रिया को नियंत्रित करता है।

लिखित कोड की जाँच करें:



यह ध्यान देने योग्य है कि डायनेमिक भाषाओं के लिए फ्रेमवर्क में, जो पायथन है, Service



क्लास के ऑब्जेक्ट को कोकेन से कनेक्ट करते समय उपलब्ध तरीकों का सेट गतिशील रूप से प्राप्त होता है। अन्य भाषाओं में, आपको एक या एक अन्य स्टब लिखना होगा, जिसे बाद में दिखाया जाएगा।



निश्चित रूप से आपके पास तुरंत सवाल थे:

• इतनी मेहनत क्यों?
• अतुल्यकालिक मॉडल को क्यों चुना गया?

हम निश्चित रूप से नीचे कुछ पैराग्राफ में उनका जवाब देंगे, लेकिन अब देखते हैं कि कोकेन (और क्रमशः, क्रमशः) कैसे हैं

गलत अनुरोधों का जवाब देता है। उदाहरण के लिए, हम Service



ऑब्जेक्ट में दिए गए एप्लिकेशन के नाम के रूप में सेट करते हैं

प्रतिध्वनि , लेकिन एक नाममात्र अनुप्रयोग के कुछ नाम। 42 कहें, वह है:

 echo = Service('42')
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ईमानदारी से, मेरे पास क्लाउड में ऐसा कोई एप्लिकेशन नहीं है। इस मामले में, कोकीन एक त्रुटि लौटाएगा, और रूपरेखा फेंक देगा

एक अपवाद।



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



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

कोकीन प्रोटोकॉल

चलो एक पल के लिए रुकें और हमारे क्लाउड प्लेटफ़ॉर्म के हुड के नीचे एक नज़र डालें। कैसे कोकीन का पता चलता है

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



हर कॉल के लिए, कोकेन एक टाइप किया हुआ चैनल खोलता है जो आपको एप्लिकेशन के साथ संदेशों का आदान-प्रदान करने की अनुमति देता है। संदेश तीन प्रकार के हो सकते हैं:

 0, Chunk ::= <Tuple> 1, Error ::= (<Number>, <String>) 2, Choke ::= ()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



मैं ऐसा क्यों कर रहा हूं? हुड के तहत, प्रत्येक फ्रेमवर्क इस प्रोटोकॉल (और थोड़ा अधिक) को लागू करता है, इसे फ़ंक्शन कॉल के रूप में प्रच्छन्न करता है

या तरीके, एक संदेश के सामान्य गठन और, दूसरी ओर, शेड्यूलिंग, अनपैकिंग प्राप्त किया

संदेश और उन्हें ग्राहक को वापस भेज रहे हैं।



चूंकि प्रोटोकॉल एक धारा है, और अंतिम संदेश हमेशा Choke



, सख्ती से बोलना, आवेदन कर सकते हैं

Chunk



की अज्ञात संख्या लौटाएं, जिससे डेटा की वास्तविक स्ट्रीम प्रोसेसिंग और उनके एसिंक्रोनस को व्यवस्थित किया जा सके

वापसी।

उदाहरण के लिए वापस जा रहे हैं

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

 from cocaine.worker import Worker</python> def echo(request, response): message = yield request.read() response.write(message) response.close() W = Worker() W.run({ 'ping': echo, })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि आप देख सकते हैं, लगभग उसी प्रोसेसिंग पैटर्न को हमने क्लाइंट कोड में लिखा है। ping



नाम के साथ आने वाली प्रत्येक घटना के लिए, echo



फ़ंक्शन कहा जाता है, जो तर्क के रूप में तैयार अनुरोध और प्रतिक्रिया वस्तुओं को स्वीकार करता है। request.read()



विधि को कॉल करके, हम एसिंक्रोनस रूप से एक अनुरोध पढ़ते हैं प्रत्येक (हमारे मामले में, यह कड़ाई से एक है), और हम response.write(...)



विधि का उपयोग करके जवाब देते हैं।



तदनुसार, हमारे आवेदन के लिए कई चंक के साथ जवाब देने के लिए, बस इस विधि को फिर से कॉल करें। उदाहरण के लिए:

 def echo(request, response): message = yield request.read() response.write(message) response.write('Additional message') response.close()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसकी जांच कैसे करें? ठीक है, सबसे पहले, आवेदन को फिर से लोड किया जाना चाहिए और फिर से शुरू किया जाना चाहिए:

 cocaine-tool app upload && cocaine-tool app restart --name echo --profile profile@test
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह महत्वपूर्ण है: यदि संशोधित आवेदन हठपूर्वक अद्यतन नहीं करना चाहता है और पुनः लोड करने के बाद भी पहले की तरह काम करता है,

कोकीन-रनटाइम कॉन्फ़िगरेशन (कैश अनुभाग) में कैश सेटिंग्स की जांच करें।



फिर हम अपने ग्राहक को फिर से शुरू करेंगे, और वह जारी करेगा ... पहले जैसा ही। यह सामान्य व्यवहार है। मैं आपको याद दिला दूं कि हमारे पास एक स्ट्रीमिंग प्रोटोकॉल है, और हम चैनल से बिल्कुल एक चंक को घटाते हैं। इसे काम करने के लिए, invoke



फ़ंक्शन को निम्नानुसार बदलें:

 @asynchronous def invoke(message): result = yield service.enqueue('ping', message) another_result = yield print(result, another_result) io_loop.stop()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जब आप एक अन्य चंक को एक रूपरेखा के रूप में विचार करने का प्रयास करते हैं, तो एक विशेष चोकेंवेंट ChokeEvent



को फेंक दिया जाएगा, जो फिर से

यह ढांचा-निर्भर है (दूसरों में यह नहीं हो सकता है और एक बंद चैनल की अधिसूचना दूसरे तरीके से की जाती है)।

हर जगह असिंच

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



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



ऑब्जेक्ट से कुछ अनुरोध किया। उसके साथ क्या हो रहा है? संदेश को एन्कोडिंग और भेजने के बाद, वह इंतजार करता है। उत्तर की प्रतीक्षा में, त्रुटि की प्रतीक्षा में, समय समाप्ति की प्रतीक्षा में। ये सभी अपेक्षाएँ सामान्य IO ऑपरेशन हैं जो प्रोसेसर संसाधनों को बर्बाद नहीं करते हैं। तो अगर आप अधिक काम दे सकते हैं तो इसे फिर से ठंडा क्यों करें? कल्पना कीजिए कि आप क्लाइंट कोड से नहीं, बल्कि किसी अन्य एप्लिकेशन से कुछ एप्लिकेशन या सेवा के लिए अनुरोध कर रहे हैं। यह स्पष्ट है कि यदि यह एप्लिकेशन इस तरह के प्रत्येक अनुरोध पर दुनिया को रोक देता है, तो इससे ऐसे अनुप्रयोगों को त्वरित रूप से बढ़ावा मिलेगा, जो बाद में सिस्टम संसाधनों की बर्बादी होगी।



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



यही कारण है कि सभी कोकीन ढांचे मुख्य रूप से सेवाओं के साथ बातचीत का एक अतुल्यकालिक तरीका लागू करते हैं। इसके अलावा कुछ भी तुल्यकालिक विधि को लागू करते हैं, लेकिन सभी नहीं।

लेकिन अन्य भाषाओं के बारे में क्या?

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



हम विभिन्न भाषाओं में कई रूपरेखाओं के लिए क्लाइंट लिखकर इसका प्रदर्शन करेंगे। इस मामले में, हम इको एप्लिकेशन के प्रारंभिक संस्करण का परीक्षण करेंगे।

सी ++

C ++ में एक समान ग्राहक इस तरह दिखेगा:

 #include <cocaine/framework/services/app.hpp> #include <cocaine/framework/services/storage.hpp> #include <iostream> #include <condition_variable> #include <mutex> #include <atomic> namespace cf = cocaine::framework; int main(int argc, char** argv) { auto manager = cf::service_manager_t::create(cf::service_manager_t::endpoint_t("localhost", 10053)); // Get application service object. auto app = manager->get_service<cf::app_service_t>("echo"); std::atomic<int> counter(0); std::condition_variable cv; // Call application. auto g1 = app->enqueue("ping", "Hello from C++"); auto g2 = app->enqueue("ping", "Hello again!"); auto handler = [&counter, &cv](cf::generator<std::string>& g) { counter++; try { // Always packed data. std::cout << "result: " << g.next() << std::endl; } catch (const std::exception& e) { std::cout << "error: " << e.what() << std::endl; } cv.notify_all(); }; g1.then(handler); g2.then(handler); std::mutex m; std::unique_lock<std::mutex> guard(m); while (counter < 2) { cv.wait(guard); } return 0; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आपको इस प्रकार संकलित करने की आवश्यकता है (क्लैंग का उपयोग करने के मामले में):

 clang++ -std=c++11 -stdlib=libc++ -lcocaine-core -lcocaine-framework -lmsgpack -lboost_system -lev ../src/clients/echo-client.cpp
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि आप GCC का उपयोग करते हैं, तो बस cl ++ को g ++ से प्रतिस्थापित करें, और libstdc ++ के बजाय -stdlib=libc++



को हटाकर libc ++ का उपयोग करने की आवश्यकता को हटा दें।



मैंने कोड पर बहुत टिप्पणी नहीं की है; देशी ढांचे का उपयोग करने के बारे में अधिक जानकारी के लिए, यहां क्लिक करें ।

गहरे लाल रंग का

रूबी के मामले में, सब कुछ काफी सरल है। हम अद्भुत eventmachine



फ्रेमवर्क का उपयोग करते हैं, जो अवसर प्रदान करता है

रूबी फाइबर का उपयोग करें और अतुल्यकालिक कोड लिखें जैसे कि यह सिंक्रोनस था। कोई कॉलबैक या वायदा नहीं!

 require 'cocaine' require 'cocaine/synchrony/service' require 'em-synchrony' class EchoClient EM.synchrony do results = [] service = Cocaine::Synchrony::Service.new 'echo' channel = service.enqueue('ping', 'Hello from Ruby!') channel.each do |result| results.push result end puts results EM.stop end end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

भाग 2. श्रमिक

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



मौजूदा ढांचे में से प्रत्येक में सभी प्रकार के अनुप्रयोगों को लिखने के लिए सहायक उपकरण हैं जो कोकेन द्वारा लोड के तहत गुणा किए जाएंगे। हम गर्म करने के लिए फिर से अजगर एपीआई का उपयोग करेंगे।



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



सेवा में सबसे बड़ी छवियों को कैश भी करेगा।



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



हमारे उदाहरण पर लौटते हुए, हम अपने एप्लिकेशन को generate



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



यह महत्वपूर्ण है: इस उदाहरण को लिखते समय, हम qrcode python लाइब्रेरी का उपयोग करेंगे। यह प्रसिद्ध PIL



या pillow



पर निर्भर करता है, जिसके बदले में कई द्विआधारी निर्भरता की आवश्यकता होती है, जैसे कि libpng। सुनिश्चित करें कि आपके पास वे हैं, और फिर उसी pip



का उपयोग करके qrcode



:

 >pip install qrcode
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मैं आपको एक बार में पूरे आवेदन का कोड दूंगा, और फिर मैं प्रत्येक पंक्ति के बारे में विस्तार से विश्लेषण करूंगा जो सबसे छोटे प्रश्नों का कारण बन सकती है:

 #!/usr/bin/env python import StringIO import msgpack import qrcode from cocaine.exceptions import ServiceError from cocaine.decorators import http from cocaine.logging import Logger from cocaine.services import Service from cocaine.worker import Worker storage = Service('storage') def generate_qr(message, size=10): if size <= 0 or size >= 20: raise ValueError('size argument must fit in [0; 20]') out = StringIO.StringIO() img = qrcode.make(message, box_size=size) img.save(out, 'png') return out.getvalue() def generate(request, response): rq = yield request.read() message, size = msgpack.loads(rq) try: if size < 10: data = generate_qr(message, size) else: key = '{0}size={1}'.format(message, size) try: data = yield storage.read('qr-codes', key) except ServiceError: data = generate_qr(message, size) yield storage.write('qr-codes', key, data) response.write(data) except Exception as err: response.error(1, str(err)) finally: response.close() w = Worker() w.run({ 'generate': generate })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

storage = Service('storage')



हम कार्यकर्ता के लिए Storage



सेवा को वैश्विक घोषित करते हैं, जो मुझे याद है, हम

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



अब अंतिम लाइनों पर ध्यान दें:

 w = Worker() w.run({ 'generate': generate })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस कोड के साथ, हम एक कार्यकर्ता ऑब्जेक्ट बनाते हैं कि पर्दे के पीछे कोकेन के साथ एक संबंध स्थापित करेगा, साथ ही साथ कुछ अन्य क्रियाएं भी। फिर हम ईवेंट प्रोसेसिंग लूप शुरू करते हैं, साथ ही साथ generate



इवेंट हैंडलर को रजिस्टर करते generate



। अब सही मापदंडों के साथ किसी भी invoke



संदेश को निर्दिष्ट फ़ंक्शन पर पुनर्निर्देशित किया जाएगा। आइए इसे और अधिक विस्तार से विचार करें।



इस तरह के प्रत्येक कार्य के लिए दो पैरामीटर दिए गए हैं:

• तैयार क्वेरी ऑब्जेक्ट जिसमें भेजे गए डेटा के आस्थगित पढ़ने के लिए एक एकल read
  
  
  
  विधि है
  
  एक सॉकेट से;
• प्रतिक्रिया ऑब्जेक्ट, जो एक चैनल है जिसमें आप लिख सकते हैं (प्रोटोकॉल के विवरण को याद रखें) सभी
  
  सूचीबद्ध संदेश प्रकार ( Chunk
  
  
  
  , Error
  
  
  
  , Choke
  
  
  
  )।

वास्तव में, लाइनों:

 rq = yield request.read() message, size = msgpack.loads(rq)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम सॉकेट से डेटा पढ़ते हैं और इसे अनपैक करते हैं। अतिरिक्त पैकिंग क्यों करते हैं, आप तुरंत कुछ ऐसा क्यों नहीं लिख सकते हैं: message, size = yield request.read()



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



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



यह महत्वपूर्ण है: यदि हम खुद अपवाद को नहीं पकड़ते हैं, तो फ्रेमवर्क इसे करेगा।



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

 key = '{0}size={1}'.format(message, size) try: data = yield storage.read('qr-codes', key) except ServiceError: data = generate_qr(message, size) yield storage.write('qr-codes', key, data)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम एक कुंजी बनाते हैं और जांचते हैं कि क्या इस तरह की कुंजी का उपयोग करके हमारे भंडार में ऐसा कोई दस्तावेज है। यदि यह नहीं है, तो storage.read('qr-codes', key)



विधि एक अपवाद storage.read('qr-codes', key)



फेंक storage.read('qr-codes', key)



। इस मामले में, हम अभी भी एक चित्र बनाते हैं और इसे बचाते हैं।



यह महत्वपूर्ण है: read



और write



संचालन अतुल्यकालिक रूप से किया जाता है। हर बार जब हम अपने corutin में yield



कीवर्ड पर ठोकर खाते हैं, तो ईवेंट लूप पर रिटर्न नियंत्रित करते हैं। यह तभी वापस आता है

जब हमारी अपेक्षित घटना आ गई है। शेष घटनाओं को अभी भी संसाधित किया जा रहा है। इसलिए, अगर हम बहुत धीमे हैं

संग्रहण, read



विधि पर हजारों कोरटाइन की अपेक्षा करना काफी संभव है।संसाधनों की बचत स्पष्ट है।



किसी चित्र के साथ बाइट्स की एक सरणी प्राप्त करने के बाद, हम बस इसे चैनल पर लिखते हैं। यह finally



ब्लॉक में अपने आप बंद हो जाएगा । हालांकि, यदि आप इसे स्पष्ट रूप से बंद नहीं करते हैं, तो यह रूपरेखा द्वारा बंद कर दिया जाएगा, लेकिन लॉग को एक चेतावनी लिखी जाएगी।



इस बार कॉल का क्रम इस प्रकार होगा:





यदि हम उपयोगकर्ता से आवेदन के लिए अनुरोध का पूरा रास्ता मानते हैं, तो हमें यह मिलता है:











हमारे आवेदन की जांच कैसे करें? उसी तरह से जैसे echo



आवेदन की जाँच कर रहा है। कोकीन में हमारे कोड को पुनः लोड करें cocaine-tool



:

 cd src/qr && cocaine-tool app upload && cocaine-tool app start --name qr --profile profile@test
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

फिर हम एक छोटा ग्राहक कोड लिखते हैं। वास्तव में, यहां क्लाइंट echo



एप्लिकेशन सत्यापन कोड से अंतर न्यूनतम हैं:

 import StringIO import msgpack from PIL import Image from tornado.ioloop import IOLoop from cocaine.futures import chain from cocaine.services import Service # Alias for more readability. asynchronous = chain.source if __name__ == '__main__': io_loop = IOLoop.current() service = Service('qr') @asynchronous def invoke(message): try: result = yield service.enqueue('generate', msgpack.dumps([message, 10])) print('Result:', result) out = StringIO.StringIO() out.write(result) out.seek(0) img = Image.open(out) img.save('qr.png', 'png') except Exception as err: print('Error: ', err) finally: io_loop.stop() invoke('What is best in life? To crush your enemies, see them driven before you, and to hear the lamentation of ' 'their women.') io_loop.start()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

invoke



, . , , PIL



.



, . - , , HTTP.



: .



: @http



. ( ) request



response



. - read



, , , cocaine.decorators.http._HTTPRequest



, — , , .. ( response



) .



:

 >#!/usr/bin/env python import StringIO import msgpack import qrcode from cocaine.exceptions import ServiceError from cocaine.decorators import http from cocaine.logging import Logger from cocaine.services import Service from cocaine.worker import Worker storage = Service('storage') log = Logger() def generate_qr(message, size=10): if size <= 0 or size >= 20: raise ValueError('size argument must fit in [0; 20]') out = StringIO.StringIO() img = qrcode.make(message, box_size=size) img.save(out, 'png') return out.getvalue() @http def generate(request, response): request = yield request.read() try: message = request.request['message'] size = int(request.request.get('size', 10)) if size < 10: data = generate_qr(message, size) else: key = '{0}size={1}'.format(message, size) try: data = yield storage.read('qr-codes', key) except ServiceError: data = generate_qr(message, size) yield storage.write('qr-codes', key, data) response.write_head(200, [('Content-type', 'image/png')]) response.write(data) except KeyError: response.write_head(400, [('Content-type', 'text/plain')]) response.write('Query field "message" is required') except Exception as err: response.write_head(400, [('Content-type', 'text/plain')]) response.write(str(err)) finally: response.close() w = Worker() w.run({ 'generate-http': generate })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

API , .



: generate-http



— .



? , - , http-, . , , . cocaine-proxy — , HTTP, . cocaine-native-proxy



. , - , cocaine-tool



, , Python, :

 cocaine-tool proxy start --count=32
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

count



— , .



: production cocaine-native-proxy



. , .



, , . ? .



URI . : <APP>/<METHOD>[?<Args>]



.



X-Cocaine-Service



X-Cocaine-Event



.



. URI : /qr/generate-http?message=Hello%20World!&size=10



.



. , - :







: cocaine-proxy



(, Storage



) — .

, , , . , .



, Cocaine .



ab . : , , 100000 32 ( , ) , Cocaine .



, ,

. cocaine-runtime



,

:

 cocaine-tool info
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Cocaine , - :







, . . «state» . . «slaves» , , Cocaine ( ). «queue» ( , ) . , . , «sessions» , , . , , . — .



! , cocaine-runtime



cocaine-tool info



:

 ab -n 100000 -c 32 'localhost:8080/qr/generate-http?message=Hello%20World!&size=10'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

, , . 100000 32 . cocaine-runtime



, 6 QR-, cocaine-runtime



:

 [Tue Apr 8 15:36:18 2014] [INFO] app/qr: enlarging the pool from 5 to 6 slaves
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

cocaine-tool info



- :



, 6, 10. , 7 . , Cocaine , .



, , . - — SIGTERM



, .



Cocaine.

Python!

! , — ( ) , .



Go, , . , , . , , .



Go — . मजा आ गया!

 >package main import ( "net/http" "code.google.com/p/rsc/qr" "github.com/ugorji/go/codec" "github.com/cocaine/cocaine-framework-go/cocaine" ) //msgpack specific var ( mh codec.MsgpackHandle h = &mh ) var ( OkHeaders cocaine.Headers = cocaine.Headers{[2]string{"Content-type", "image/png"}} ErrorHeaders cocaine.Headers = cocaine.Headers{[2]string{"Content-type", "text/plain"}} storage *cocaine.Service ) const ( cacheNamepspace = "qr-code" cacheTag = "qr-tag" ) func qenerate(text string) (png []byte, err error) { res := <-storage.Call("read", cacheNamepspace, text) if res.Err() == nil { err = res.Extract(&png) return } c, err := qr.Encode(text, qr.L) if err != nil { return } png = c.PNG() <-storage.Call("write", cacheNamepspace, text, string(png), []string{cacheTag}) return } func on_generate(request *cocaine.Request, response *cocaine.Response) { defer response.Close() inc := <-request.Read() var task struct { Text string Size int } err := codec.NewDecoderBytes(inc, h).Decode(&task) if err != nil { response.ErrorMsg(-100, err.Error()) return } png, err := qenerate(task.Text) if err != nil { response.ErrorMsg(-200, err.Error()) return } response.Write(png) } func on_http_generate(request *cocaine.Request, response *cocaine.Response) { defer response.Close() r, err := cocaine.UnpackProxyRequest(<-request.Read()) if err != nil { response.ErrorMsg(-200, err.Error()) return } message := r.FormValue("message") if len(message) == 0 { response.Write(cocaine.WriteHead(http.StatusBadRequest, ErrorHeaders)) response.Write("Missing argument `message`") return } png, err := qenerate(message) if err != nil { response.Write(cocaine.WriteHead(http.StatusInternalServerError, ErrorHeaders)) response.Write("Unable to generate QR") return } response.Write(cocaine.WriteHead(http.StatusOK, OkHeaders)) response.Write(png) } func main() { binds := map[string]cocaine.EventHandler{ "generate": on_generate, "generate-http": on_http_generate, } Worker, err := cocaine.NewWorker() if err != nil { panic(err) } storage, err = cocaine.NewService("storage") if err != nil { panic(err) } Worker.Loop(binds) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

, ! Cocaine .

एक निष्कर्ष के बजाय

Cocaine , . , . , , Cocaine Runtime, . , , , . Cocaine.



, . Cocaine, , . , , , , .