मॉड्यूल 2: App Engine ndb से Cloud NDB पर माइग्रेट करना

1. खास जानकारी

कोडलैब की इस सीरीज़ में, Google App Engine (स्टैंडर्ड) डेवलपर को अपने ऐप्लिकेशन को बेहतर बनाने में मदद मिलेगी. इसके लिए, उन्हें माइग्रेशन की सीरीज़ के बारे में जानकारी दी जाएगी. ये कोडलैब, डेवलपर अपनी सुविधा के हिसाब से कभी भी ऐक्सेस कर सकते हैं. साथ ही, इनमें प्रैक्टिकल ट्यूटोरियल भी शामिल हैं. सबसे ज़रूरी कदम यह है कि ओरिजनल रनटाइम बंडल की गई सेवाओं को बंद कर दिया जाए. ऐसा इसलिए, क्योंकि अगली जनरेशन के रनटाइम ज़्यादा बेहतर होते हैं. इनसे उपयोगकर्ताओं को सेवा के ज़्यादा विकल्प मिलते हैं. नई जनरेशन के रनटाइम पर माइग्रेट करने से, Google Cloud के प्रॉडक्ट के साथ आसानी से इंटिग्रेट किया जा सकता है. साथ ही, ज़्यादा सेवाओं का इस्तेमाल किया जा सकता है और भाषा के मौजूदा वर्शन का इस्तेमाल किया जा सकता है.

इस ट्यूटोरियल में, App Engine में पहले से मौजूद ndb (Next Database) क्लाइंट लाइब्रेरी से Cloud NDB क्लाइंट लाइब्रेरी पर माइग्रेट करने का तरीका बताया गया है.

आपको इनके बारे में जानकारी मिलेगी

  • App Engine की ndb लाइब्रेरी का इस्तेमाल करें. अगर आपको इसके बारे में नहीं पता, तो इसके बारे में जानें
  • ndb से Cloud NDB पर माइग्रेट करना
  • अपने ऐप्लिकेशन को Python 3 पर माइग्रेट करना

आपको इन चीज़ों की ज़रूरत होगी

सर्वे

इस कोडलैब का इस्तेमाल कैसे किया जाएगा?

सिर्फ़ इसे पढ़ें इसे पढ़ें और एक्सरसाइज़ पूरी करें

2. बैकग्राउंड

पहले मॉड्यूल में, हमने वेब फ़्रेमवर्क को App Engine के बिल्ट-इन webapp2 से Flask पर माइग्रेट किया था. इस कोडलैब में, हम App Engine की बिल्ट-इन सेवाओं का इस्तेमाल बंद कर रहे हैं. इसके लिए, हम App Engine की ndb लाइब्रेरी से Google Cloud NDB पर स्विच कर रहे हैं.

इस माइग्रेशन को पूरा करने के बाद, ये काम किए जा सकते हैं:

  1. Python 3 पर माइग्रेट करना और अगली पीढ़ी के App Engine रनटाइम का इस्तेमाल करना
  2. Cloud Datastore पर माइग्रेट करना (App Engine के अलावा अन्य ऐप्लिकेशन के लिए क्लाइंट लाइब्रेरी)
  3. अपने Python 2 (या 3) ऐप्लिकेशन को कंटेनर में बदलें और Cloud Run पर माइग्रेट करें
  4. App Engine (पुश) टास्क कतारों का इस्तेमाल करें. इसके बाद, Cloud Tasks पर माइग्रेट करें

हालांकि, हम अभी तक वहां नहीं पहुंचे हैं. अगले चरणों पर विचार करने से पहले, इस कोडलैब को पूरा करें. इस ट्यूटोरियल में माइग्रेशन के ये मुख्य चरण शामिल हैं:

  1. सेटअप/प्रीवर्क
  2. Cloud NDB लाइब्रेरी जोड़ना
  3. ऐप्लिकेशन की फ़ाइलें अपडेट करना

3. सेटअप/प्रीवर्क

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

1. प्रोजेक्ट सेट अप करना

अगर आपने Module 1 codelab पूरा कर लिया है, तो हमारा सुझाव है कि आप उसी प्रोजेक्ट और कोड का फिर से इस्तेमाल करें. इसके अलावा, एक नया प्रोजेक्ट बनाया जा सकता है या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल किया जा सकता है. पक्का करें कि प्रोजेक्ट के लिए, बिलिंग चालू हो और App Engine चालू हो.

2. बेसलाइन सैंपल ऐप्लिकेशन पाना

ज़रूरी शर्तों में से एक यह है कि आपके पास मॉड्यूल 1 का सैंपल ऐप्लिकेशन होना चाहिए. अगर आपने वह ट्यूटोरियल पूरा कर लिया है, तो अपने समाधान का इस्तेमाल करें. इसे अभी पूरा किया जा सकता है (ऊपर दिया गया लिंक). अगर आपको इसे छोड़ना है, तो मॉड्यूल 1 की रेपो कॉपी करें (नीचे दिया गया लिंक).

चाहे आपने कोड बनाया हो या हमने, हम मॉड्यूल 1 के कोड से शुरुआत करेंगे. इस दूसरे मॉड्यूल के कोडलैब में, हर चरण के बारे में बताया गया है. इसे पूरा करने के बाद, यह कोड FINISH पॉइंट पर मौजूद कोड जैसा दिखना चाहिए. इसमें Python 2 से 3 में पोर्ट करने का "बोनस" भी शामिल है:

आपके STARTing Module 1 कोड फ़ोल्डर में यह कॉन्टेंट होना चाहिए:

$ ls
README.md               appengine_config.py     requirements.txt
app.yaml                main.py                 templates

अगर आपने मॉड्यूल 1 का ट्यूटोरियल पूरा कर लिया है, तो आपके पास Flask और उसकी डिपेंडेंसी वाला lib फ़ोल्डर भी होगा. अगर आपके पास lib फ़ोल्डर नहीं है, तो pip install -t lib -r requirements.txt कमांड का इस्तेमाल करके इसे बनाएं, ताकि हम अगले चरण में इस बेसलाइन ऐप्लिकेशन को डिप्लॉय कर सकें. अगर आपने Python 2 और 3, दोनों इंस्टॉल किए हैं, तो हमारा सुझाव है कि Python 3 के साथ भ्रम से बचने के लिए, pip के बजाय pip2 का इस्तेमाल करें.

3. मॉड्यूल 1 ऐप्लिकेशन को (फिर से) डिप्लॉय करना

अब आपको ये काम करने हैं:

  1. gcloud कमांड-लाइन टूल के बारे में फिर से जानें (अगर ज़रूरी हो)
  2. App Engine पर मॉड्यूल 1 कोड को (फिर से) डिप्लॉय करें (अगर ज़रूरी हो)

इन चरणों को पूरा करने और यह पुष्टि करने के बाद कि यह काम कर रहा है, हम इस ट्यूटोरियल में आगे बढ़ेंगे. हम कॉन्फ़िगरेशन फ़ाइलों से शुरुआत करेंगे.

4. कॉन्फ़िगरेशन फ़ाइलें अपडेट करना (Cloud NDB लाइब्रेरी जोड़ना)

App Engine में पहले से मौजूद कई सेवाओं को अब अलग-अलग प्रॉडक्ट के तौर पर उपलब्ध कराया जाता है. Datastore भी इनमें से एक है. आज App Engine के बाहर के ऐप्लिकेशन, Cloud Datastore का इस्तेमाल कर सकते हैं. ndb का लंबे समय से इस्तेमाल कर रहे लोगों के लिए, Google Cloud टीम ने Cloud NDB क्लाइंट लाइब्रेरी बनाई है. इससे Cloud Datastore से कम्यूनिकेट किया जा सकता है. यह Python 2 और 3, दोनों के लिए उपलब्ध है.

आइए, पुष्टि करने वाली फ़ाइलों को अपडेट करके App Engine ndb को Cloud NDB से बदलें. इसके बाद, अपने ऐप्लिकेशन में बदलाव करें.

1. requirements.txt को अपडेट करें

मॉड्यूल 1 में, हमारे ऐप्लिकेशन के लिए सिर्फ़ Flask बाहरी डिपेंडेंसी थी. अब हम Cloud NDB जोड़ेंगे. मॉड्यूल 1 के आखिर में आपकी requirements.txt फ़ाइल ऐसी दिख रही थी:

  • BEFORE:
Flask==1.1.2

App Engine ndb से माइग्रेट करने के लिए, Cloud NDB लाइब्रेरी (google-cloud-ndb) की ज़रूरत होती है. इसलिए, इसके पैकेज को requirements.txt में जोड़ें.

  • AFTER:
Flask==1.1.2
google-cloud-ndb==1.7.1

इस कोडलैब को लिखते समय, सुझाया गया नया वर्शन 1.7.1 है. हालांकि, ऐसा हो सकता है कि requirements.txt के रिपो में नया वर्शन उपलब्ध हो. हमारा सुझाव है कि आप हर लाइब्रेरी का नया वर्शन इस्तेमाल करें. हालांकि, अगर ये काम नहीं करते हैं, तो पुराने वर्शन पर वापस जाया जा सकता है.

अगर आपके पास lib फ़ोल्डर है और आपने उसे अभी-अभी नहीं बनाया है, तो उसे मिटा दें. अब pip install -t lib -r requirements.txt कमांड का इस्तेमाल करके, अपडेट की गई लाइब्रेरी को (फिर से) इंस्टॉल करें. इसके लिए, ज़रूरत के मुताबिक pip की जगह pip2 का इस्तेमाल करें.

2. app.yaml को अपडेट करें

google-cloud-ndb जैसी Google Cloud क्लाइंट लाइब्रेरी जोड़ने के लिए, कुछ ज़रूरी शर्तें पूरी करनी होती हैं. ये सभी शर्तें, "बिल्ट-इन" लाइब्रेरी और Google सर्वर पर पहले से उपलब्ध तीसरे पक्ष के पैकेज को शामिल करने से जुड़ी हैं. आपने उन्हें requirements.txt में शामिल नहीं किया है. साथ ही, आपने उन्हें pip install की मदद से कॉपी भी नहीं किया है. ज़रूरी शर्तें:

  1. app.yaml में पहले से मौजूद लाइब्रेरी के बारे में बताना
  2. उन्हें तीसरे पक्ष की उन लाइब्रेरी के बारे में बताएं जिन्हें कॉपी किया गया है और जिनके साथ वे काम कर सकते हैं (lib में)

मॉड्यूल 1 से app.yaml शुरू करने का तरीका यहां दिया गया है:

  • BEFORE:
runtime: python27
threadsafe: yes
api_version: 1

handlers:
- url: /.*
  script: main.app

अब app.yaml में ये लाइनें जोड़ें, ताकि तीसरे पक्ष के बंडल किए गए पैकेज के पेयर को रेफ़रंस दिया जा सके: नए libraries सेक्शन में grpcio और setuptools:

libraries:
- name: grpcio
  version: 1.0.0
- name: setuptools
  version: 36.6.0

इन बिल्ट-इन लाइब्रेरी का इस्तेमाल क्यों करें? gRPC एक ओपन आरपीसी फ़्रेमवर्क है. इसका इस्तेमाल google-cloud-ndb के साथ-साथ, Google Cloud की सभी क्लाइंट लाइब्रेरी करती हैं. grpcio लाइब्रेरी, Python gRPC अडैप्टर है. इसलिए, इसकी ज़रूरत होती है. setuptools शुरू होने वाला है, इसकी वजह.

  • AFTER:

ऊपर दिए गए बदलावों के बाद, आपका अपडेट किया गया app.yaml अब ऐसा दिखना चाहिए:

runtime: python27
threadsafe: yes
api_version: 1

handlers:
- url: /.*
  script: main.app

libraries:
- name: grpcio
  version: 1.0.0
- name: setuptools
  version: 36.6.0

3. appengine_config.py को अपडेट करें

setuptools लाइब्रेरी का हिस्सा pkg_resources टूल का इस्तेमाल, बंडल की गई लाइब्रेरी को ऐक्सेस करने के लिए पहले से मौजूद तीसरे पक्ष की लाइब्रेरी को अनुमति देने के लिए किया जाता है. appengine_config.py को अपडेट करें, ताकि pkg_resources का इस्तेमाल करके उन्हें lib में बंडल की गई लाइब्रेरी पर ले जाया जा सके. यह बदलाव करने के बाद, पूरी फ़ाइल ऐसी दिखनी चाहिए:

import pkg_resources
from google.appengine.ext import vendor

# Set PATH to your libraries folder.
PATH = 'lib'
# Add libraries installed in the PATH folder.
vendor.add(PATH)
# Add libraries to pkg_resources working set to find the distribution.
pkg_resources.working_set.add_entry(PATH)

5. ऐप्लिकेशन की फ़ाइलें अपडेट करना

कॉन्फ़िगरेशन फ़ाइल से जुड़ी ज़रूरी कार्रवाइयां पूरी करने के बाद, अब ndb से Cloud NDB पर माइग्रेट किया जा सकता है. माइग्रेशन पूरा करने के लिए, इंपोर्ट की गई लाइब्रेरी अपडेट करें. साथ ही, main.py में कॉन्टेक्स्ट मैनेजमेंट का इस्तेमाल करें.

1. आयात

main.py में, इंपोर्ट किए गए डेटा को इस तरह से स्वैप करें:

  • पहले
from google.appengine.ext import ndb
  • AFTER:
from google.cloud import ndb

App Engine लाइब्रेरी से Google Cloud लाइब्रेरी पर स्विच करने का तरीका, कभी-कभी इस उदाहरण की तरह आसान होता है. Google Cloud के प्रॉडक्ट के तौर पर उपलब्ध कराई जाने वाली इन सेवाओं के लिए, आपको google.cloud से एट्रिब्यूट इंपोर्ट करने होंगे, न कि google.appengine से.

2. Datastore का ऐक्सेस

Cloud NDB लाइब्रेरी का इस्तेमाल करने के लिए, आपके ऐप्लिकेशन को Python कॉन्टेक्स्ट मैनेजर का इस्तेमाल करना होगा. इनका मकसद, संसाधनों के ऐक्सेस को "गेट" करना है, ताकि उनका इस्तेमाल करने से पहले उन्हें हासिल किया जा सके. कॉन्टेक्स्ट मैनेजर, कंप्यूटर साइंस की कंट्रोल तकनीक पर आधारित होते हैं. इसे संसाधन आवंटन, इनिशियलाइज़ेशन (या RAII) कहा जाता है. कॉन्टेक्स्ट मैनेजर का इस्तेमाल Python फ़ाइलों के साथ किया जाता है. इन फ़ाइलों को ऐक्सेस करने से पहले खोलना ज़रूरी है. साथ ही, "स्पिन लॉक" को "क्रिटिकल सेक्शन" में कोड को एक्ज़ीक्यूट करने से पहले हासिल करना होगा.

इसी तरह, Cloud NDB को क्लाइंट के कॉन्टेक्स्ट की ज़रूरत होती है, ताकि वह Datastore से कम्यूनिकेट कर सके. ऐसा तब होता है, जब Datastore के किसी भी कमांड को लागू किया जाता है. सबसे पहले, main.py Flask को शुरू करने के तुरंत बाद ds_client = ndb.Client() जोड़कर, एक क्लाइंट (ndb.Client()) बनाएं:

app = Flask(__name__)
ds_client = ndb.Client()

Pythonwith कमांड का इस्तेमाल सिर्फ़ किसी ऑब्जेक्ट का कॉन्टेक्स्ट पाने के लिए किया जाता है. Datastore को ऐक्सेस करने वाले किसी भी कोड ब्लॉक को with स्टेटमेंट के साथ रैप करें.

Datastore में नई इकाई लिखने और हाल ही में जोड़ी गई इकाइयों को दिखाने के लिए, मॉड्यूल 1 के ये फ़ंक्शन इस्तेमाल किए जाते हैं:

  • BEFORE:

यहां कॉन्टेक्स्ट मैनेजमेंट के बिना ओरिजनल कोड दिया गया है:

def store_visit(remote_addr, user_agent):
    'create new Visit entity in Datastore'
    Visit(visitor='{}: {}'.format(remote_addr, user_agent)).put()

def fetch_visits(limit):
    'get most recent visits'
    return (v.to_dict() for v in Visit.query().order(
            -Visit.timestamp).fetch(limit))
  • AFTER:

अब with ds_client.context(): जोड़ें और अपने Datastore ऐक्सेस कोड को with ब्लॉक में ले जाएं:

def store_visit(remote_addr, user_agent):
    'create new Visit entity in Datastore'
    with ds_client.context():
        Visit(visitor='{}: {}'.format(remote_addr, user_agent)).put()

def fetch_visits(limit):
    'get most recent visits'
    with ds_client.context():
        return (v.to_dict() for v in Visit.query().order(
                -Visit.timestamp).fetch(limit))

मुख्य ड्राइवर ऐप्लिकेशन, मॉड्यूल 1 में मौजूद ऐप्लिकेशन जैसा ही रहता है, क्योंकि यहां न तो ndb है और न ही Cloud NDB का कोड है:

@app.route('/')
def root():
    'main application (GET) handler'
    store_visit(request.remote_addr, request.user_agent)
    visits = fetch_visits(10)
    return render_template('index.html', visits=visits)

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

6. खास जानकारी/सफ़ाई

ऐप्लिकेशन डिप्लॉय करना

gcloud app deploy की मदद से, अपने ऐप्लिकेशन को फिर से डिप्लॉय करें. साथ ही, पुष्टि करें कि ऐप्लिकेशन काम कर रहा है. आपका कोड अब Module 2 repo में मौजूद कोड से मेल खाना चाहिए.

अगर आपने इस सीरीज़ में, पहले के किसी भी कोडलैब को पूरा किए बिना हिस्सा लिया है, तो ऐप्लिकेशन में कोई बदलाव नहीं होता. यह मुख्य वेब पेज (/) पर आने वाले सभी लोगों को रजिस्टर करता है. साइट पर कई बार जाने के बाद, यह इस तरह दिखता है:

visitme ऐप्लिकेशन

इस मॉड्यूल 2 कोडलैब को पूरा करने के लिए बधाई. आपने इस सीरीज़ का आखिरी माइग्रेशन पूरा कर लिया है. Datastore के लिए, इस सीरीज़ में बेहद ज़रूरी माइग्रेशन यही था.

ज़रूरी नहीं: साफ़ करना

जब तक आप माइग्रेशन के अगले कोडलैब पर जाने के लिए तैयार नहीं हो जाते, तब तक बिलिंग से बचने के लिए क्या किया जा सकता है? मौजूदा डेवलपर के तौर पर, आपको App Engine की कीमत से जुड़ी जानकारी के बारे में पहले से ही पता होगा.

ज़रूरी नहीं: ऐप्लिकेशन बंद करना

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

दूसरी ओर, अगर आपको माइग्रेशन जारी नहीं रखना है और आपको सब कुछ पूरी तरह से मिटाना है, तो अपना प्रोजेक्ट बंद करें.

अगले चरण

यहां से, आपके पास आगे बढ़ने के कई विकल्प होते हैं. इनमें से कोई विकल्प चुनें:

  • मॉड्यूल 2 का बोनस: Python 3 पर पोर्ट करने और अगली जनरेशन के App Engine रनटाइम के बारे में जानने के लिए, इस ट्यूटोरियल के बोनस सेक्शन पर जाएं.
  • मॉड्यूल 7: App Engine की पुश टास्क कतारें (अगर [push] टास्क कतारों का इस्तेमाल किया जाता है, तो यह ज़रूरी है)
    • App Engine taskqueue पुश टास्क को Module 1 ऐप्लिकेशन में जोड़ता है
    • यह मॉड्यूल, उपयोगकर्ताओं को मॉड्यूल 8 में Cloud Tasks पर माइग्रेट करने के लिए तैयार करता है
  • मॉड्यूल 4: Docker का इस्तेमाल करके Cloud Run पर माइग्रेट करना
    • Docker की मदद से, अपने ऐप्लिकेशन को कंटेनर में बदलें, ताकि उसे Cloud Run पर चलाया जा सके
    • इससे Python 2 पर बने रहने की अनुमति मिलती है
  • पांचवां मॉड्यूल: Cloud Buildpacks की मदद से Cloud Run पर माइग्रेट करना
    • Cloud Buildpacks की मदद से, अपने ऐप्लिकेशन को कंटेनर में बदलें, ताकि उसे Cloud Run पर चलाया जा सके
    • आपको Docker, कंटेनर या Dockerfile के बारे में कुछ भी जानने की ज़रूरत नहीं है
    • इसके लिए, यह ज़रूरी है कि आपने अपने ऐप्लिकेशन को पहले ही Python 3 पर माइग्रेट कर लिया हो
  • तीसरा मॉड्यूल:
    • Cloud NDB से Cloud Datastore में डेटा ऐक्सेस करने की सुविधा को अपग्रेड करना
    • इस लाइब्रेरी का इस्तेमाल, Python 3 App Engine ऐप्लिकेशन और गैर-App Engine ऐप्लिकेशन के लिए किया जाता है

7. बोनस: Python 3 पर माइग्रेट करना

हमारा सुझाव है कि App Engine के नए रनटाइम और सुविधाओं का ऐक्सेस पाने के लिए, Python 3 पर माइग्रेट करें. हमारे सैंपल ऐप्लिकेशन में, हमने सिर्फ़ Datastore का इस्तेमाल किया था. यह एक बिल्ट-इन सेवा है. अब हम ndb से Cloud NDB पर माइग्रेट हो गए हैं. इसलिए, अब हम App Engine के Python 3 रनटाइम पर पोर्ट कर सकते हैं.

खास जानकारी

Python 3 में पोर्ट करने का तरीका, Google Cloud के ट्यूटोरियल में शामिल नहीं है. हालांकि, इस कोडलैब के इस हिस्से से डेवलपर को यह पता चलता है कि Python 3 App Engine रनटाइम, Python 2 App Engine रनटाइम से किस तरह अलग है. अगली जनरेशन के रनटाइम की एक खास सुविधा यह है कि तीसरे पक्ष के पैकेज को आसानी से ऐक्सेस किया जा सकता है. app.yaml में बिल्ट-इन पैकेज के बारे में बताने की ज़रूरत नहीं है. साथ ही, नॉन-बिल्ट-इन लाइब्रेरी को कॉपी या अपलोड करने की भी ज़रूरत नहीं है. requirements.txt में लिस्ट होने पर, ये अपने-आप इंस्टॉल हो जाती हैं.

हमारा सैंपल बहुत बुनियादी है और Cloud NDB, Python 2-3 के साथ काम करता है. इसलिए, ऐप्लिकेशन के कोड को 3.x में पोर्ट करने की ज़रूरत नहीं है. ऐप्लिकेशन, 2.x और 3.x पर बिना किसी बदलाव के चलता है. इसका मतलब है कि इस मामले में, सिर्फ़ कॉन्फ़िगरेशन में बदलाव करने की ज़रूरत है:

  1. Python 3 को रेफ़रंस करने के लिए, app.yaml को आसान बनाएं और तीसरे पक्ष की लाइब्रेरी हटाएं.
  2. appengine_config.py और lib फ़ोल्डर को मिटा दें, क्योंकि अब इनकी ज़रूरत नहीं है.

main.py के अलावा, requirements.txt और templates/index.html फ़ाइलों में कोई बदलाव नहीं होता.

app.yaml को आसान बनाएं

BEFORE:

इस सैंपल ऐप्लिकेशन में सिर्फ़ एक बदलाव किया गया है. इसमें app.yaml को छोटा किया गया है. आपको याद दिलाने के लिए, app.yaml मॉड्यूल 2 के आखिर में हमने यह तय किया था:

runtime: python27
threadsafe: yes
api_version: 1

handlers:
- url: /.*
  script: main.app

libraries:
- name: grpcio
  version: 1.0.0
- name: setuptools
  version: 36.6.0

AFTER:

Python 3 में, threadsafe, api_version, और libraries डायरेक्टिव अब काम नहीं करते. सभी ऐप्लिकेशन को थ्रेडसेफ़ माना जाता है और Python 3 में api_version का इस्तेमाल नहीं किया जाता. App Engine की सेवाओं पर, तीसरे पक्ष के पहले से इंस्टॉल किए गए पैकेज अब उपलब्ध नहीं हैं. इसलिए, libraries को भी बंद कर दिया गया है. इन बदलावों के बारे में ज़्यादा जानने के लिए, app.yaml में हुए बदलावों के बारे में जानकारी देने वाला दस्तावेज़ देखें. इसलिए, आपको app.yaml से इन तीनों को मिटा देना चाहिए. साथ ही, Python 3 के ऐसे वर्शन पर अपडेट करना चाहिए जिस पर यह सुविधा काम करती है. इसके बारे में यहां बताया गया है.

ज़रूरी नहीं: handlers डायरेक्टिव का इस्तेमाल करना

इसके अलावा, handlers डायरेक्टिव को भी बंद कर दिया गया है. यह डायरेक्टिव, App Engine ऐप्लिकेशन पर ट्रैफ़िक को रीडायरेक्ट करता है. नेक्स्ट-जनरेशन रनटाइम को वेब फ़्रेमवर्क से ऐप्लिकेशन राउटिंग मैनेज करने की उम्मीद होती है. इसलिए, सभी "हैंडलर स्क्रिप्ट" को "auto" में बदलना होगा. ऊपर दिए गए बदलावों को मिलाकर, आपको यह app.yaml मिलता है:

runtime: python38

handlers:
- url: /.*
  script: auto

इसके दस्तावेज़ पेज पर जाकर, script: auto के बारे में ज़्यादा जानें.

handlers डायरेक्टिव हटाया जा रहा है

handlers का इस्तेमाल अब नहीं किया जा सकता. इसलिए, पूरे सेक्शन को भी हटाया जा सकता है. इसके बाद, सिर्फ़ एक लाइन वाला app.yaml दिखेगा:

runtime: python38

डिफ़ॉल्ट रूप से, इससे Gunicorn WSGI वेब सर्वर लॉन्च होगा. यह सभी ऐप्लिकेशन के लिए उपलब्ध है. अगर आपको gunicorn के बारे में पता है, तो यह कमांड तब लागू होती है, जब इसे डिफ़ॉल्ट रूप से app.yaml के साथ शुरू किया जाता है:

gunicorn main:app --workers 2 -c /config/gunicorn.py

ज़रूरी नहीं: entrypoint डायरेक्टिव का इस्तेमाल करना

हालांकि, अगर आपके ऐप्लिकेशन को शुरू करने के लिए किसी खास कमांड की ज़रूरत है, तो उसे entrypoint डायरेक्टिव के साथ बताया जा सकता है. इसमें आपका app.yaml इस तरह दिखेगा:

runtime: python38
entrypoint: python main.py

इस उदाहरण में, खास तौर पर gunicorn के बजाय Flask डेवलपमेंट सर्वर का इस्तेमाल करने का अनुरोध किया गया है. डेवलपमेंट सर्वर को शुरू करने वाले कोड को भी आपके ऐप्लिकेशन में जोड़ा जाना चाहिए, ताकि इसे पोर्ट 8080 पर 0.0.0.0 इंटरफ़ेस पर लॉन्च किया जा सके. इसके लिए, main.py के सबसे नीचे यह छोटा सेक्शन जोड़ें:

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080, debug=True)

इसके दस्तावेज़ पेज पर जाकर, entrypoint के बारे में ज़्यादा जानें. ज़्यादा उदाहरण और सबसे सही तरीके, App Engine Standard के स्टार्टअप से जुड़े दस्तावेज़ और App Engine Flexible के स्टार्टअप से जुड़े दस्तावेज़ में देखे जा सकते हैं.

appengine_config.py और lib मिटाएं

appengine_config.py फ़ाइल और lib फ़ोल्डर मिटाएं. Python 3 पर माइग्रेट करते समय, App Engine, requirements.txt में दिए गए पैकेज को हासिल करता है और उन्हें इंस्टॉल करता है.

appengine_config.py कॉन्फ़िगरेशन फ़ाइल का इस्तेमाल, तीसरे पक्ष की लाइब्रेरी/पैकेज की पहचान करने के लिए किया जाता है. भले ही, आपने उन्हें खुद कॉपी किया हो या App Engine सर्वर पर पहले से उपलब्ध (बिल्ट-इन) लाइब्रेरी/पैकेज का इस्तेमाल किया हो. Python 3 पर माइग्रेट करते समय, मुख्य बदलावों की खास जानकारी यहां दी गई है:

  1. कॉपी की गई तीसरे पक्ष की लाइब्रेरी (requirements.txt में दी गई) को बंडल नहीं किया गया हो
  2. pip install को lib फ़ोल्डर में नहीं ले जाया जा सकता. इसका मतलब है कि lib फ़ोल्डर नहीं बनाया जा सकता
  3. app.yaml में, तीसरे पक्ष की कोई भी लाइब्रेरी शामिल नहीं है
  4. ऐप्लिकेशन को तीसरे पक्ष की लाइब्रेरी से जोड़ने की ज़रूरत नहीं है. इसलिए, कोई appengine_config.py फ़ाइल नहीं है

requirements.txt में तीसरे पक्ष की सभी ज़रूरी लाइब्रेरी की सूची देना ही काफ़ी है.

ऐप्लिकेशन डिप्लॉय करना

अपने ऐप्लिकेशन को फिर से डिप्लॉय करें, ताकि यह पक्का किया जा सके कि वह काम कर रहा है. यह भी पुष्टि की जा सकती है कि आपका समाधान, मॉड्यूल 2 के सैंपल Python 3 कोड के कितना करीब है. Python 2 के साथ अंतर देखने के लिए, कोड की तुलना इसके Python 2 वर्शन से करें.

मॉड्यूल 2 में बोनस चरण पूरा करने के लिए बधाई! Python 3 रनटाइम के लिए कॉन्फ़िगरेशन फ़ाइलें तैयार करने से जुड़े दस्तावेज़ पढ़ें. आखिर में, अगले चरणों और मैलवेयर हटाने के लिए, खास जानकारी/मैलवेयर हटाने वाला (पिछला) पेज देखें.

आपके आवेदन को तैयार किया जा रहा है

जब आपके ऐप्लिकेशन को माइग्रेट करने का समय आएगा, तब आपको अपनी main.py और अन्य ऐप्लिकेशन फ़ाइलों को 3.x पर पोर्ट करना होगा. इसलिए, सबसे सही तरीका यह है कि आप अपने 2.x ऐप्लिकेशन को ज़्यादा से ज़्यादा "फ़ॉरवर्ड-कंपैटिबल" बनाने की पूरी कोशिश करें.

इंटरनेट पर ऐसे कई संसाधन उपलब्ध हैं जिनसे आपको यह काम पूरा करने में मदद मिल सकती है. हालांकि, यहां कुछ अहम सलाह दी गई हैं:

  1. पक्का करें कि ऐप्लिकेशन की सभी डिपेंडेंसी, 3.x वर्शन के साथ पूरी तरह से काम करती हों
  2. पक्का करें कि आपका ऐप्लिकेशन कम से कम 2.6 (बेहतर होगा कि 2.7) पर काम करता हो
  3. पक्का करें कि ऐप्लिकेशन, टेस्ट के सभी चरणों को पूरा करता हो. साथ ही, कम से कम 80% कवरेज देता हो
  4. six, Future, और/या Modernize जैसी कंपैटिबिलिटी लाइब्रेरी का इस्तेमाल करें
  5. 2.x और 3.x वर्शन के बीच के मुख्य अंतरों के बारे में जानें
  6. किसी भी I/O से, यूनिकोड बनाम बाइट स्ट्रिंग से जुड़ी समस्याएं हो सकती हैं

इस सैंपल ऐप्लिकेशन को इन सभी बातों को ध्यान में रखकर डिज़ाइन किया गया है. इसलिए, यह ऐप्लिकेशन 2.x और 3.x पर तुरंत काम करता है, ताकि हम आपको यह दिखा सकें कि अगली जनरेशन के प्लैटफ़ॉर्म का इस्तेमाल करने के लिए, क्या बदलाव करने होंगे.

8. अन्य संसाधन

App Engine माइग्रेशन मॉड्यूल कोडलैब से जुड़ी समस्याएं/सुझाव/राय

अगर आपको इस कोडलैब में कोई समस्या मिलती है, तो कृपया शिकायत दर्ज करने से पहले अपनी समस्या खोजें. नई समस्याएं खोजने और बनाने के लिए लिंक:

माइग्रेशन के लिए उपलब्ध संसाधन

मॉड्यूल 1 (START) और मॉड्यूल 2 (FINISH) के लिए, रेपो फ़ोल्डर के लिंक यहां दी गई टेबल में देखे जा सकते हैं. इन्हें App Engine के सभी कोडलैब माइग्रेशन के लिए बने रेपो से भी ऐक्सेस किया जा सकता है. इसे क्लोन किया जा सकता है या इसकी ZIP फ़ाइल डाउनलोड की जा सकती है.

कोडलैब

Python 2

Python 3

Module 1

code

(लागू नहीं)

Module 2

code

code

App Engine के संसाधन

इस माइग्रेशन के बारे में ज़्यादा जानकारी के लिए, यहां दिए गए संसाधन देखें: