फ़्लास्क ऐप्लिकेशन में App Engine टास्क सूची (टास्क पुल करने) का इस्तेमाल कैसे करें (मॉड्यूल 18)

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

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

यह कोडलैब आपको मॉड्यूल 1 कोडलैब से सैंपल ऐप्लिकेशन में, App Engine टास्क सूची के पुल टास्क को शामिल करने और इस्तेमाल करने का तरीका सिखाता है. हमने इस मॉड्यूल 18 ट्यूटोरियल में, पुल टास्क का इस्तेमाल शामिल किया है. इसके बाद, हमने मॉड्यूल 19 में इस इस्तेमाल को Cloud Pub/Sub पर माइग्रेट कर दिया है. जो लोग पुश टास्क के लिए, टास्क सूचियों का इस्तेमाल करते हैं वे Cloud Tasks पर माइग्रेट हो जाएंगे. इसके लिए, उन्हें मॉड्यूल 7-9 का इस्तेमाल करना चाहिए.

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

  • App Engine Tasks क्यू एपीआई/बंडल की गई सेवा का इस्तेमाल करना
  • बेसिक Python 2 Flask App Engine NDB ऐप्लिकेशन में, पुल क्यू की सुविधा का इस्तेमाल जोड़ें

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

सर्वे

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

इसे सिर्फ़ पढ़ें इसे पढ़ें और कसरतों को पूरा करें

Python के साथ अपने अनुभव को आप कितनी रेटिंग देंगे?

शुरुआती इंटरमीडिएट कुशल

Google Cloud की सेवाएं इस्तेमाल करने का आपका अनुभव कैसा रहा?

शुरुआती इंटरमीडिएट कुशल

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

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

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

इस डिज़ाइन को लागू करने के लिए, हम मुख्य ऐप्लिकेशन में पुल लिस्ट का इस्तेमाल कर रहे हैं. साथ ही, इससे कर्मचारियों के काम करने के तरीके में भी मदद मिलेगी. curl या wget का इस्तेमाल करके, वर्कर एक अलग प्रोसेस (जैसे, हमेशा चालू रहने वाली वीएम पर चल रहे बैकएंड इंस्टेंस या कोड), क्रॉन जॉब या बेसिक कमांड-लाइन एचटीटीपी अनुरोध के तौर पर काम कर सकता है. इस इंटिग्रेशन के बाद, अगले (मॉड्यूल 19) कोडलैब (कोड बनाना सीखना) में इस ऐप्लिकेशन को Cloud Pub/Sub पर माइग्रेट किया जा सकता है.

इस ट्यूटोरियल में ये चरण बताए गए हैं:

  1. सेटअप/प्रीवर्क
  2. कॉन्फ़िगरेशन अपडेट करें
  3. ऐप्लिकेशन कोड बदलें

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

इस सेक्शन में, इन कामों को करने का तरीका बताया गया है:

  1. अपना क्लाउड प्रोजेक्ट सेट अप करें
  2. बेसलाइन ऐप्लिकेशन का नमूना डाउनलोड करें
  3. (फिर से) बेसलाइन ऐप्लिकेशन डिप्लॉय करना और उसकी पुष्टि करना

इन चरणों से यह पक्का होता है कि आपने सही कोड डाला है.

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

अगर आपने मॉड्यूल 1 कोडलैब पूरा कर लिया है, तो उसी प्रोजेक्ट (और कोड) का फिर से इस्तेमाल करें. इसके अलावा, नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. पक्का करें कि प्रोजेक्ट में एक चालू बिलिंग खाता और चालू App Engine ऐप्लिकेशन हो. अपना प्रोजेक्ट आईडी ढूंढें, क्योंकि आपको इसे इस कोडलैब में कई बार डालने की ज़रूरत पड़ेगी. साथ ही, जब भी आपको PROJECT_ID वैरिएबल मिले, तो इसका इस्तेमाल करें.

2. बेसलाइन ऐप्लिकेशन का नमूना डाउनलोड करें

इस कोडलैब के लिए एक ज़रूरी शर्त, काम करने वाला मॉड्यूल 1 App Engine ऐप्लिकेशन होना है. मॉड्यूल 1 कोडलैब को पूरा करें (इसका सुझाव दिया जाता है) या रेपो से मॉड्यूल 1 ऐप्लिकेशन को कॉपी करें. आप अपना या हमारा, दोनों में से किसी का भी इस्तेमाल करें, मॉड्यूल 1 कोड पर हम "शुरू" करेंगे. यह कोडलैब आपको हर चरण पर ले जाता है. इससे आपको एक कोड मिलता है, जो मॉड्यूल 18 रेपो फ़ोल्डर "FINISH" में मौजूद कोड से मिलता-जुलता है.

आप चाहे किसी भी मॉड्यूल 1 ऐप्लिकेशन का इस्तेमाल करें, फ़ोल्डर यहां दिए गए आउटपुट की तरह दिखना चाहिए. इसके अलावा, यह lib फ़ोल्डर के साथ भी दिख सकता है:

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

3. (फिर से) बेसलाइन ऐप्लिकेशन डिप्लॉय करें

मॉड्यूल 1 ऐप्लिकेशन को डिप्लॉय करने के लिए, यह तरीका अपनाएं:

  1. अगर lib फ़ोल्डर मौजूद है, तो उसे मिटाएं और lib को फिर से पॉप्युलेट करने के लिए, pip install -t lib -r requirements.txt को चलाएं. अगर आपने Python 2 और 3 दोनों इंस्टॉल किए हैं, तो आपको इसके बजाय pip2 कमांड का इस्तेमाल करना पड़ सकता है.
  2. पक्का करें कि आपने gcloud कमांड-लाइन टूल इंस्टॉल किया हो और उसे शुरू किया हो. साथ ही, इसके इस्तेमाल की समीक्षा की हो.
  3. अगर आपको हर gcloud निर्देश के साथ अपना PROJECT_ID डालना नहीं है, तो अपने क्लाउड प्रोजेक्ट को gcloud config set project PROJECT_ID के साथ सेट करें.
  4. gcloud app deploy के साथ सैंपल ऐप्लिकेशन डिप्लॉय करें
  5. पुष्टि करें कि मॉड्यूल 1 ऐप्लिकेशन उम्मीद के मुताबिक काम करता है और हाल ही में हुई विज़िट की जानकारी दिखाता है. इसका उदाहरण नीचे दिया गया है

a7a9d2b80d706a2b.png

4. कॉन्फ़िगरेशन अपडेट करें

मानक App Engine कॉन्फ़िगरेशन फ़ाइलों (app.yaml, requirements.txt, appengine_config.py) में किसी बदलाव की ज़रूरत नहीं है. इसके बजाय, एक नई कॉन्फ़िगरेशन फ़ाइल, queue.yaml को निम्न सामग्री के साथ, उसे समान शीर्ष-स्तरीय निर्देशिका में रखते हुए जोड़ें:

queue:
- name: pullq
  mode: pull

queue.yaml फ़ाइल आपके ऐप्लिकेशन के लिए मौजूद सभी टास्क की सूचियों के बारे में बताती है (इसमें default [push] क्यू शामिल नहीं है जो App Engine से अपने-आप बनती है). इस मामले में, pullq नाम की पुल क्यू सिर्फ़ एक होती है. App Engine के लिए यह ज़रूरी है कि mode डायरेक्टिव को pull के तौर पर बताया गया हो. ऐसा न होने पर, यह डिफ़ॉल्ट रूप से पुश क्यू बना देता है. दस्तावेज़ में, पुल क्यू बनाने के बारे में ज़्यादा जानें. अन्य विकल्पों के लिए queue.yaml का रेफ़रंस पेज भी देखें.

इस फ़ाइल को अपने ऐप्लिकेशन से अलग डिप्लॉय करें. आप अब भी gcloud app deploy का इस्तेमाल करेंगे, लेकिन कमांड लाइन पर queue.yaml भी देंगे:

$ gcloud app deploy queue.yaml
Configurations to update:

descriptor:      [/tmp/mod18-gaepull/queue.yaml]
type:            [task queues]
target project:  [my-project]

WARNING: Caution: You are updating queue configuration. This will override any changes performed using 'gcloud tasks'. More details at
https://cloud.google.com/tasks/docs/queue-yaml

Do you want to continue (Y/n)?

Updating config [queue]...⠹WARNING: We are using the App Engine app location (us-central1) as the default location. Please use the "--location" flag if you want to use a different location.
Updating config [queue]...done.

Task queues have been updated.

Visit the Cloud Platform Console Task Queues page to view your queues and cron jobs.
$

5. ऐप्लिकेशन कोड बदलें

इस सेक्शन में, नीचे दी गई फ़ाइलों के बारे में अपडेट मिलते हैं:

  • main.py — मुख्य ऐप्लिकेशन में पुल क्यू की सुविधा जोड़ें
  • templates/index.html — नया डेटा दिखाने के लिए वेब टेंप्लेट को अपडेट करें

इंपोर्ट और कॉन्सटेंट

सबसे पहले, पुल की सूची के साथ काम करने के लिए एक नया इंपोर्ट और कई कॉन्सटेंट जोड़ें:

  • टास्क सूची लाइब्रेरी, google.appengine.api.taskqueue का इंपोर्ट जोड़ें.
  • हमारी पुल क्यू (QUEUE) से एक घंटे के लिए (HOUR) ज़्यादा से ज़्यादा पुल टास्क (TASKS) लीज़ पर देने के लिए तीन कॉन्सटेंट जोड़ें.
  • सबसे हाल में वेबसाइट पर आने वालों के साथ-साथ, वेबसाइट पर आने वाले सबसे ज़्यादा लोगों (LIMIT) को दिखाने के लिए कोई कॉन्सटेंट जोड़ें.

नीचे ओरिजनल कोड दिया गया है. साथ ही, यह भी बताया गया है कि बदलाव करने के बाद, यह कैसा दिखेगा:

पहले:

from flask import Flask, render_template, request
from google.appengine.ext import ndb

app = Flask(__name__)

बाद में:

from flask import Flask, render_template, request
from google.appengine.api import taskqueue
from google.appengine.ext import ndb

HOUR = 3600
LIMIT = 10
TASKS = 1000
QNAME = 'pullq'
QUEUE = taskqueue.Queue(QNAME)
app = Flask(__name__)

पुल टास्क जोड़ना (टास्क के लिए डेटा इकट्ठा करना और पुल की सूची में टास्क बनाना)

डेटा मॉडल Visit और fetch_visits() में दिखाने के लिए विज़िट से जुड़ी क्वेरी में कोई बदलाव नहीं होता है. कोड के इस हिस्से में सिर्फ़ store_visit() में बदलाव करने की ज़रूरत है. विज़िट को रजिस्टर करने के अलावा, विज़िटर के आईपी पते के साथ पुल की सूची में कोई टास्क जोड़ें, ताकि वर्कर विज़िटर काउंटर को बढ़ा सके.

पहले:

class Visit(ndb.Model):
    'Visit entity registers visitor IP address & timestamp'
    visitor   = ndb.StringProperty()
    timestamp = ndb.DateTimeProperty(auto_now_add=True)

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 Visit.query().order(-Visit.timestamp).fetch(limit)

बाद में:

class Visit(ndb.Model):
    'Visit entity registers visitor IP address & timestamp'
    visitor   = ndb.StringProperty()
    timestamp = ndb.DateTimeProperty(auto_now_add=True)

def store_visit(remote_addr, user_agent):
    'create new Visit in Datastore and queue request to bump visitor count'
    Visit(visitor='{}: {}'.format(remote_addr, user_agent)).put()
    QUEUE.add(taskqueue.Task(payload=remote_addr, method='PULL'))

def fetch_visits(limit):
    'get most recent visits'
    return Visit.query().order(-Visit.timestamp).fetch(limit)

विज़िटर ट्रैकिंग के लिए डेटा मॉडल और क्वेरी फ़ंक्शन बनाएं

वेबसाइट पर आने वाले लोगों को ट्रैक करने के लिए डेटा मॉडल VisitorCount जोड़ें; इसमें visitor के लिए फ़ील्ड और विज़िट की संख्या ट्रैक करने के लिए एक पूर्णांक counter होना चाहिए. इसके बाद, क्वेरी करने और साइट पर सबसे ज़्यादा आने वाले लोगों को सबसे कम क्रम में वापस करने के लिए, fetch_counts() नाम का एक नया फ़ंक्शन (इसे Python classmethod के तौर पर भी इस्तेमाल किया जा सकता है) जोड़ें. fetch_visits() के मुख्य भाग के ठीक नीचे क्लास और फ़ंक्शन जोड़ें:

class VisitorCount(ndb.Model):
    visitor = ndb.StringProperty(repeated=False, required=True)
    counter = ndb.IntegerProperty()

def fetch_counts(limit):
    'get top visitors'
    return VisitCount.query().order(-VisitCount.counter).fetch(limit)

वर्कर कोड जोड़ें

वेबसाइट पर आने वाले लोगों को GET अनुरोध की मदद से /log पर लॉग करने के लिए, log_visitors() नया फ़ंक्शन जोड़ें. यह शब्दकोश/हैश का इस्तेमाल सबसे हाल ही में आने वाले लोगों की संख्या को ट्रैक करने के लिए करता है और एक घंटे के लिए ज़्यादा से ज़्यादा काम लीज़ पर करता है. हर टास्क के लिए, यह वेबसाइट पर आने वाले एक ही व्यक्ति की सभी विज़िट का मिलान करता है. टैली को जोड़ने के बाद, यह ऐप्लिकेशन Datastore में पहले से मौजूद सभी VisitorCount इकाइयों को अपडेट करता है या ज़रूरत पड़ने पर नई इकाइयां बनाता है. आखिरी चरण में एक सादा टेक्स्ट मैसेज दिखता है. इसमें यह बताया जाता है कि प्रोसेस किए गए टास्क की संख्या में से कितने लोगों ने रजिस्टर किया. fetch_counts() के ठीक नीचे main.py में यह फ़ंक्शन जोड़ें:

@app.route('/log')
def log_visitors():
    'worker processes recent visitor counts and updates them in Datastore'
    # tally recent visitor counts from queue then delete those tasks
    tallies = {}
    tasks = QUEUE.lease_tasks(HOUR, TASKS)
    for task in tasks:
        visitor = task.payload
        tallies[visitor] = tallies.get(visitor, 0) + 1
    if tasks:
        QUEUE.delete_tasks(tasks)

    # increment those counts in Datastore and return
    for visitor in tallies:
        counter = VisitorCount.query(VisitorCount.visitor == visitor).get()
        if not counter:
            counter = VisitorCount(visitor=visitor, counter=0)
            counter.put()
        counter.counter += tallies[visitor]
        counter.put()
    return 'DONE (with %d task[s] logging %d visitor[s])\r\n' % (
            len(tasks), len(tallies))

नए डिसप्ले डेटा से मुख्य हैंडलर को अपडेट करें

वेबसाइट पर सबसे ज़्यादा आने वाले लोगों की जानकारी देखने के लिए, मुख्य हैंडलर root() को अपडेट करें, ताकि fetch_counts() को शुरू किया जा सके. इसके अलावा, शीर्ष विज़िटर और सबसे हाल की विज़िट की संख्या दिखाने के लिए टेम्प्लेट को अपडेट किया जाएगा. fetch_visits() पर कॉल करने के बाद, वेबसाइट पर आने वाले लोगों की संख्या और कॉल को सबसे हाल में हुई विज़िट के साथ पैकेज करें. इसके बाद, उन्हें वेब टेंप्लेट पर भेजने के लिए, उन्हें एक context में छोड़ें. बदलाव लागू होने से पहले और बाद में, कोड नीचे दिए गए हैं:

पहले:

@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)

बाद में:

@app.route('/')
def root():
    'main application (GET) handler'
    store_visit(request.remote_addr, request.user_agent)
    context = {
        'limit':  LIMIT,
        'visits': fetch_visits(LIMIT),
        'counts': fetch_counts(LIMIT),
    }
    return render_template('index.html', **context)

ये सभी बदलाव, main.py के लिए ज़रूरी हैं. यहां उन अपडेट की तस्वीरों के ज़रिए जानकारी दी गई है, ताकि आपको main.py में किए जाने वाले बदलावों के बारे में पूरी जानकारी मिल सके:

ad5fd3345efc13d0.png

नए डिसप्ले डेटा का इस्तेमाल करके वेब टेंप्लेट को अपडेट करें

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

पहले:

<!doctype html>
<html>
<head>
<title>VisitMe Example</title>
<body>

<h1>VisitMe example</h1>
<h3>Last 10 visits</h3>
<ul>
{% for visit in visits %}
    <li>{{ visit.timestamp.ctime() }} from {{ visit.visitor }}</li>
{% endfor %}
</ul>

बाद में:

<!doctype html>
<html>
<head>
<title>VisitMe Example</title>
<body>

<h1>VisitMe example</h1>

<h3>Top {{ limit }} visitors</h3>
<table border=1 cellspacing=0 cellpadding=2>
    <tr><th>Visitor</th><th>Visits</th></tr>
{% for count in counts %}
    <tr><td>{{ count.visitor|e }}</td><td align="center">{{ count.counter }}</td></tr>
{% endfor %}
</table>

<h3>Last {{ limit }} visits</h3>
<ul>
{% for visit in visits %}
    <li>{{ visit.timestamp.ctime() }} from {{ visit.visitor }}</li>
{% endfor %}
</ul>

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

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

6. खास जानकारी/क्लीनअप

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

ऐप्लिकेशन डिप्लॉय करें और उसकी पुष्टि करें

पक्का करें कि आपने पहले ही अपनी पुल की सूची सेट अप कर ली है, जैसा कि हमने gcloud app deploy queue.yaml के साथ इस कोडलैब के सबसे ऊपरी हिस्से के पास किया था. अगर यह प्रोसेस पूरी हो गई है और सैंपल के तौर पर आपका ऐप्लिकेशन इस्तेमाल के लिए तैयार है, तो अपने ऐप्लिकेशन को gcloud app deploy के साथ डिप्लॉय करें. आउटपुट, मॉड्यूल 1 ऐप्लिकेशन के जैसा होना चाहिए. हालांकि, अब इसमें "पहली बार ऐप्लिकेशन पर आने वाले लोग" शामिल हैं टेबल पर रखें:

b667551dcbab1a09.png

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

आप /log को कॉल करके कई तरीकों से टास्क पूरा कर सकते हैं:

उदाहरण के लिए, अगर /log को जीईटी अनुरोध भेजने के लिए curl का इस्तेमाल किया जाता है, तो आपका आउटपुट कुछ ऐसा दिखेगा, बशर्ते आपने अपना PROJECT_ID दिया हो:

$ curl https://PROJECT_ID.appspot.com/log
DONE (with 1 task[s] logging 1 visitor[s])

इसके बाद, अपडेट की गई संख्या, अगली वेबसाइट विज़िट पर दिखेगी. हो गया!

इस कोडलैब को पूरा करने के लिए बधाई. सैंपल के तौर पर दिए गए ऐप्लिकेशन में, App Engine टास्क सूची में शामिल करने के लिए, पुल सूची सेवा का इस्तेमाल किया जा रहा है. अब यह मॉड्यूल 19 में Cloud Pub/Sub, Cloud NDB, और Python 3 पर माइग्रेट किए जाने के लिए तैयार है.

व्यवस्थित करें

सामान्य

अगर आपका काम अभी हो गया है, तो हमारा सुझाव है कि आप बिलिंग से बचने के लिए अपना App Engine ऐप्लिकेशन बंद कर दें. हालांकि, अगर आपको कुछ और टेस्ट या एक्सपेरिमेंट करना है, तो App Engine प्लैटफ़ॉर्म का एक मुफ़्त कोटा है. अगर इस्तेमाल के टीयर को पार नहीं किया जा रहा है, तो आपसे शुल्क नहीं लिया जाएगा. यह कंप्यूट के लिए है. हालांकि, काम के App Engine की सेवाओं के लिए भी शुल्क लिया जा सकता है. इसलिए, ज़्यादा जानकारी के लिए इसका कीमत पेज देखें. अगर इस माइग्रेशन में क्लाउड की अन्य सेवाएं शामिल हैं, तो उनका बिल अलग से भेजा जाता है. दोनों ही मामलों में, अगर लागू हो, तो "इस कोडलैब के लिए खास" सेक्शन देखें सेक्शन देखें.

अगर आपको पूरी जानकारी देनी है, तो App Engine जैसे Google Cloud के बिना सर्वर वाले कंप्यूट प्लैटफ़ॉर्म पर डिप्लॉय करने पर, मामूली बनाने और स्टोरेज का खर्च उठाना पड़ता है. Cloud Storage की तरह Cloud Build का अपना अलग कोटा होता है. उस इमेज का स्टोरेज, उसके कुछ हिस्से का इस्तेमाल करता है. हालांकि, हो सकता है कि आप किसी ऐसे क्षेत्र में हों जहां ऐसा कोई फ़्री टीयर उपलब्ध न हो. इसलिए, संभावित लागत को कम करने के लिए, अपने स्टोरेज के इस्तेमाल को ध्यान में रखें. Cloud Storage के लिए तय किए गए "फ़ोल्डर" तो आपको इन चीज़ों की समीक्षा करनी चाहिए:

  • console.cloud.google.com/storage/browser/LOC.artifacts.PROJECT_ID.appspot.com/containers/images
  • console.cloud.google.com/storage/browser/staging.PROJECT_ID.appspot.com
  • ऊपर दिए गए स्टोरेज लिंक, आपके PROJECT_ID और *LOC*ेशन के हिसाब से होते हैं. जैसे, "us" अगर आपका ऐप्लिकेशन अमेरिका में होस्ट किया जाता है.

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

इस कोडलैब के लिए खास

नीचे दी गई सेवाएं, इस कोडलैब के लिए यूनीक हैं. ज़्यादा जानकारी के लिए हर प्रॉडक्ट के दस्तावेज़ देखें:

अगले चरण

इस "माइग्रेशन" में, आपने वेबसाइट पर आने वाले लोगों को ट्रैक करने के लिए सहायता जोड़कर, मॉड्यूल 1 सैंपल ऐप्लिकेशन में टास्क सूची पुश सूची के इस्तेमाल को जोड़ा है. इससे मॉड्यूल 18 सैंपल ऐप्लिकेशन लागू हो जाएगा. अगले माइग्रेशन में, App Engine पुल टास्क को Cloud Pub/Sub में अपग्रेड किया जाएगा. साल 2021 के आखिर में, Python 3 में अपग्रेड करते समय, उपयोगकर्ताओं को Cloud Pub/Sub पर माइग्रेट करने की ज़रूरी नहीं होगी. अगले सेक्शन में इसके बारे में ज़्यादा पढ़ें.

Cloud Pub/Sub पर माइग्रेट करने के लिए, मॉड्यूल 19 कोडलैब देखें. इसके अलावा, अतिरिक्त माइग्रेशन पर विचार करना ज़रूरी है. जैसे, Cloud Datastore, Cloud Memorystore, Cloud Storage या Cloud Tasks (पुश क्यू). Cloud Run और Cloud Functions के लिए, क्रॉस-प्रॉडक्ट माइग्रेशन भी उपलब्ध हैं. सर्वरलेस माइग्रेशन स्टेशन का कॉन्टेंट (कोडलैब, वीडियो, सोर्स कोड [जब उपलब्ध हो]) इसके ओपन सोर्स रेपो से ऐक्सेस किया जा सकता है.

7. Python 3 पर माइग्रेशन

साल 2021 के आखिर में, App Engine की टीम ने दूसरी जनरेशन के रनटाइम (जिसमें पहली जनरेशन का रनटाइम होता है) को बंडल की गई कई सेवाओं के लिए उपलब्ध कराया. इस वजह से, अब आपको अपने ऐप्लिकेशन को Python 3 पर पोर्ट करते समय, ऐप्लिकेशन इंजन टास्क की सूची जैसी बंडल की गई सेवाओं से स्टैंडअलोन क्लाउड या तीसरे पक्ष की सेवाओं, जैसे कि Cloud Pub/Sub पर माइग्रेट करने की ज़रूरत नहीं पड़ेगी. दूसरे शब्दों में कहें, तो Python 3 App Engine ऐप्लिकेशन में टास्क सूची का इस्तेमाल तब तक किया जा सकता है, जब तक कि अगली-पीढ़ी की टेक्नोलॉजी के रनटाइम से बंडल की गई सेवाओं को ऐक्सेस करने के लिए, कोड में फिर से बदलाव किया जाता है.

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

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

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

कोडलैब (कोड बनाना सीखना) से जुड़ी समस्याएं/सुझाव/राय/शिकायत

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

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

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

Codelab

Python 2

Python 3

मॉड्यूल 1

कोड

कोड (इस ट्यूटोरियल में नहीं दिया गया है)

मॉड्यूल 18 (यह कोडलैब)

कोड

लागू नहीं

ऑनलाइन रेफ़रंस

इस ट्यूटोरियल के लिए काम के संसाधन नीचे दिए गए हैं:

App Engine टास्क सूची

App Engine प्लैटफ़ॉर्म

App Engine दस्तावेज़

Python 2 App Engine (स्टैंडर्ड एनवायरमेंट) रनटाइम

Python 3 App Engine (स्टैंडर्ड एनवायरमेंट) रनटाइम

Python 2 और Python 2 के बीच अंतर तीन App Engine (स्टैंडर्ड एनवायरमेंट) रनटाइम

Python 2 से 3 App Engine (स्टैंडर्ड एनवायरमेंट) माइग्रेशन गाइड

App Engine की कीमत और कोटा की जानकारी

दूसरी पीढ़ी का App Engine प्लैटफ़ॉर्म लॉन्च (2018)

लेगसी रनटाइम के लिए लंबे समय तक सहायता

दस्तावेज़ माइग्रेट करने के सैंपल

क्लाउड से जुड़ी अन्य जानकारी

वीडियो

लाइसेंस

इस काम को क्रिएटिव कॉमंस एट्रिब्यूशन 2.0 जेनरिक लाइसेंस के तहत लाइसेंस मिला है.