हुड के तहत ऐप इंजन एपीआई

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



यदि आप केवल सरल अनुप्रयोगों के लिए ऐप इंजन का उपयोग करते हैं, तो आगे पढ़ने से बचना सबसे अच्छा है। यदि आप निम्न स्तर के अनुकूलन में रुचि रखते हैं या ऐप इंजन के सबसे अंतरंग घटकों के साथ काम करने के लिए एक पुस्तकालय लिखना चाहते हैं, तो कृपया पढ़ें!

आम एपीआई

अंततः, प्रत्येक API कॉल 4 तर्कों के साथ एक सामान्य इंटरफ़ेस से गुजरती है: सेवा का नाम (उदाहरण के लिए, 'datastore_v3' या 'memcache'), विधि का नाम (उदाहरण के लिए, 'Get' या 'RunQuery'), अनुरोध और प्रतिक्रिया । अनुरोध और प्रतिक्रिया प्रोटोकॉल बफ़र हैं , एक बाइनरी प्रारूप जो व्यापक रूप से Google द्वारा प्रक्रियाओं के बीच संरचित डेटा का आदान-प्रदान करने के लिए उपयोग किया जाता है। प्रोटोकॉल बफ़र्स के विशिष्ट प्रकार के अनुरोध और प्रतिक्रिया को लागू विधि पर निर्भर करता है। जब API कॉल किया जाता है, तो अनुरोध प्रोटोकॉल बफर अनुरोध में भेजे गए डेटा से बनता है, और प्रतिक्रिया प्रोटोकॉल बफर खाली रहता है और बाद में एपीआई कॉल की प्रतिक्रिया से लौटाए गए डेटा से भर जाता है।



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



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



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



आइए एक उदाहरण देखें कि निम्न-स्तरीय भंडारण अनुरोध को निष्पादित करके यह सब कैसे काम करता है - कुंजी नाम से एक इकाई उदाहरण प्राप्त करना:

2. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
   
   
   
   
3. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
   
   
   
   
5. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
   
   
   
   
6. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
   
   
   
   
7. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
   
   
   
   
8. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
   
   
   
   
9. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
   
   
   
   
10. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
    
    
    
    
11. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
    
    
    
    
12. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
    
    
    
    
13. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
    
    
    
    
14. from google.appengine.datastore import datastore_pb from google.appengine.api import apiproxy_stub_map def do_get(): request = datastore_pb.GetRequest() key = request.add_key() key.set_app(os.environ['APPLICATION_ID']) pathel = key.mutable_path().add_element() pathel.set_type('TestKind') pathel.set_name('test') response = datastore_pb.GetResponse() apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Get', request, response) return str(response)
    
    
    
    

बहुत अच्छी तरह से, है ना? विशेष रूप से एक समान उच्च-स्तरीय विधि की तुलना में - TestKind.get_by_key_name ('परीक्षण')! आपको क्रियाओं के पूरे अनुक्रम को समझना होगा: प्रोटोकॉल बफ़र्स का अनुरोध और प्रतिक्रिया तैयार करना, प्रासंगिक जानकारी (इस मामले में, इकाई का नाम और प्रमुख नाम) के साथ अनुरोध को भरना, फिर एक दूरस्थ ऑब्जेक्ट (RPC) बनाने के लिए apiproxy_stub_map.MyncSyncCall पर कॉल करना। जब कॉल समाप्त हो जाती है, तो उत्तर को भर दिया जाता है, जिसे इसके स्ट्रिंग डिस्प्ले द्वारा देखा जा सकता है:

2. इकाई {
3. इकाई <
4. कुंजी <
5. एप्लिकेशन: "आस्थगित"
6. पथ <
7. तत्व {
8. प्रकार: "TestKind"
9. नाम: "परीक्षण"
10. }
11. >
12. >
13. Unit_group <
14. तत्व {
15. प्रकार: "TestKind"
16. नाम: "परीक्षण"
17. }
18. >
19. संपत्ति <
20. नाम: "परीक्षण"
21. मान <
22. stringValue: "फू"
23. >
24. एकाधिक: असत्य
25. >
26. >
27. }

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

अतुल्यकालिक कॉल

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



इस लेखन के समय, केवल कुछ एपीआई अतुल्यकालिक कॉल का समर्थन करते हैं, विशेष रूप से URL लाने वाले एपीआई , जो समानांतर में कई वेब संसाधनों को प्राप्त करने के लिए बेहद उपयोगी होते हैं। अतुल्यकालिक एपीआई के संचालन का सिद्धांत नियमित लोगों की तरह ही है - यह सिर्फ इस बात पर निर्भर करता है कि पुस्तकालय में अतुल्यकालिक कॉल लागू होते हैं या नहीं। Urlfetch जैसे API को अतुल्यकालिक संचालन के लिए अनुकूलित किया जाता है, लेकिन अन्य, अधिक जटिल APIs को अतुल्यकालिक रूप से काम करने के लिए बहुत कठिन होता है।

आइए एक उदाहरण देखें कि एक सिंक्रोनस कॉल को अतुल्यकालिक कॉल में कैसे परिवर्तित किया जाए। पिछले उदाहरण के अंतर बोल्ड में हाइलाइट किए गए हैं:

2. google.appengine.datastore से datastore_pb आयात करें
3. google.appengine.api आयात apiproxy_stub_map से
4. google.appengine.api से डेटास्टोर आयात करें
6. def do_ async _get ():
7. अनुरोध = datastore_pb.GetRequest ()
8. कुंजी = request.add_key ()
9. key.set_app (os.environ ['APPLICATION_ID'])
10. pathel = key.mutable_path ()। add_element ()
11. pathel.set_type ('TestKind')
12. pathel.set_name ('परीक्षण')
13. प्रतिक्रिया = datastore_pb.GetResponse ()
15. rpc = datastore.CreateRPC ()
    
    
16. rpc.make_call ('प्राप्त करें', अनुरोध, प्रतिक्रिया)
17. वापसी rpc, प्रतिक्रिया

अंतर यह है कि हम रिपॉजिटरी के लिए एक विशिष्ट कॉल के लिए एक RPC ऑब्जेक्ट बनाते हैं और MakeSyncCall () के बजाय इसके make_call () विधि को कॉल करते हैं। फिर हम ऑब्जेक्ट और प्रोटोकॉल बफर की प्रतिक्रिया लौटाते हैं।



चूंकि यह एक एसिंक्रोनस कॉल है, इसलिए यह पूरा नहीं हुआ जब हमने आरपीसी ऑब्जेक्ट वापस किया। अतुल्यकालिक प्रतिक्रिया को संभालने के कई तरीके हैं। उदाहरण के लिए, आप कॉलबैक फ़ंक्शन को CreateRPC () विधि से पास कर सकते हैं या कॉल को पूरा करने के लिए प्रतीक्षा करने के लिए RPC ऑब्जेक्ट की .check_success () विधि को कॉल कर सकते हैं। हम अंतिम विकल्प प्रदर्शित करते हैं, क्योंकि इसे लागू करना आसान है। यहाँ हमारे समारोह का एक सरल उदाहरण है:

2. TestKind (key_name = 'test', test = 'foo'))। Put ()
3. self.response.headers ['सामग्री-प्रकार'] = 'पाठ / सादा'
4. rpc, प्रतिक्रिया = do_async_get ()
5. self.response.out.write ("RPC स्थिति% s \ n"% rpc.state है)
6. rpc.check_success ()
7. self.response.out.write ("RPC स्थिति% s \ n"% rpc.state है)
8. self.response.out.write (str (प्रतिक्रिया))

आउटपुट डेटा:

2. RPC स्थिति 1 है
3. RPC स्थिति 2 है
4. इकाई {
5. इकाई <
6. कुंजी <
7. एप्लिकेशन: "आस्थगित"
8. पथ <
9. तत्व {
10. प्रकार: "TestKind"
11. नाम: "परीक्षण"
12. }
13. >
14. >
15. Unit_group <
16. तत्व {
17. प्रकार: "TestKind"
18. नाम: "परीक्षण"
19. }
20. >
21. संपत्ति <
22. नाम: "परीक्षण"
23. मान <
24. stringValue: "फू"
25. >
26. एकाधिक: असत्य
27. >
28. >
29. }

स्थिति स्थिरांक google.appengine.api.apiproxy_rpc मॉड्यूल में परिभाषित किए गए हैं - हमारे मामले में, 1 का अर्थ है "चल रहा है", 2 का अर्थ है "समाप्त", जिसका अर्थ है कि RPC वास्तव में अतुल्यकालिक रूप से निष्पादित होती है! इस क्वेरी का वास्तविक परिणाम, निश्चित रूप से, एक नियमित सिंक्रोनस के समान है।



अब जब आप जानते हैं कि निम्न स्तर का RPC कैसे काम करता है और अतुल्यकालिक कॉल कैसे करता है, तो प्रोग्रामर के रूप में आपकी संभावनाओं का बहुत विस्तार हुआ है। ट्विस्टेड जैसे ऐप इंजन एपीआई में एक नया एसिंक्रोनस इंटरफ़ेस लिखने वाला पहला व्यक्ति कौन होगा?