איך משתמשים בתור המשימות של App Engine (משימות משיכה) באפליקציות Flask (מודול 18)

1. סקירה כללית

מטרת סדרת ה-codelabs של Serverless Migration Station (הדרכות מעשיות בקצב אישי) והסרטונים שקשורים אליה היא לעזור למפתחים של Google Cloud Serverless לחדש את האפליקציות שלהם. לשם כך, הם מקבלים הדרכה לגבי העברה אחת או יותר, בעיקר מעבר משירותים מדור קודם. כך האפליקציות שלכם יהיו ניידות יותר, ותקבלו יותר אפשרויות וגמישות. תוכלו לשלב את האפליקציות עם מגוון רחב יותר של מוצרי Cloud ולגשת אליהם, ולשדרג בקלות רבה יותר לגרסאות חדשות יותר של השפה. הסדרה הזו מתמקדת בהתחלה במשתמשי הענן הראשונים, בעיקר מפתחים של App Engine (סביבה רגילה), אבל היא רחבה מספיק כדי לכלול פלטפורמות אחרות של Serverless כמו Cloud Functions ו-Cloud Run, או במקומות אחרים אם רלוונטי.

ב-Codelab הזה נלמד איך לכלול ולהשתמש במשימות משיכה של תור משימות ב-App Engine באפליקציה לדוגמה מ-Codelab מודול 1. במדריך הזה, מודול 18, אנחנו מוסיפים את השימוש במשימות pull, ואז מעבירים את השימוש הזה ל-Cloud Pub/Sub במודול 19. משתמשים בתורי משימות למשימות push יבצעו מיגרציה ל-Cloud Tasks ויעיינו במודולים 7-9 במקום זאת.

לא משתמשים בתור משימות?

אם האפליקציה שלכם לא משתמשת בשירות Task Queue של App Engine, אפשר לדלג על מודולים 7-9 (משימות push) ו-18-19 (משימות pull), או לבצע את ה-codelab הזה כתרגיל כדי להכיר את ההעברה של Task Queue.

כאן אפשר להבין איך

• שימוש ב-App Engine Task Queue API/bundled service
• הוספת שימוש בתור משיכה לאפליקציית NDB בסיסית של Python 2 Flask App Engine

הדרישות

• פרויקט ב-Google Cloud Platform עם חשבון לחיוב פעיל ב-GCP
• מיומנויות בסיסיות ב-Python
• ידע מעשי בפקודות נפוצות של Linux
• ידע בסיסי בפיתוח ופריסה של אפליקציות App Engine
• אפליקציית App Engine פעילה במודול 1 (מומלץ להשלים את ה-codelab או להעתיק את האפליקציה מהמאגר)

סקר

איך תשתמשו במדריך הזה?

רק לקרוא לקרוא ולבצע את התרגילים

איך היית מדרג את חוויית השימוש שלך ב-Python?

מתחילים ביניים מומחים

איזה דירוג מתאים לדעתך לחוויית השימוש שלך בשירותי Google Cloud?

מתחילים ביניים מומחים

2. רקע

כדי לבצע מיגרציה ממשימות משיכה של App Engine Task Queue, מוסיפים את השימוש בה לאפליקציית Flask ו-App Engine NDB הקיימת שנוצרה מתוך Module 1 codelab. אפליקציית הדוגמה מציגה למשתמש הקצה את הביקורים האחרונים. זה בסדר, אבל יותר מעניין לעקוב גם אחרי המבקרים כדי לראות מי מבקר הכי הרבה.

אפשר להשתמש במשימות push כדי לספור את המבקרים, אבל אנחנו רוצים לחלק את האחריות בין אפליקציית הדוגמה, שתפקידה לרשום את הביקורים ולהגיב מיד למשתמשים, לבין 'עובד' ייעודי, שתפקידו לסכם את מספר המבקרים מחוץ לתהליך העבודה הרגיל של בקשה-תגובה.

כדי ליישם את העיצוב הזה, אנחנו מוסיפים שימוש בתורי משיכה לאפליקציה הראשית, וגם תמיכה בפונקציונליות של העובד. התהליך יכול לפעול כתהליך נפרד (כמו שרת עורפי (backend instance) או קוד שפועל ב-VM שתמיד פעילה), כמשימת cron או כבקשת HTTP בסיסית בשורת הפקודה באמצעות curl או wget. אחרי השילוב הזה, תוכלו להעביר את האפליקציה אל Cloud Pub/Sub בסדנת ה-codelab הבאה (מודול 19).

במדריך הזה נסביר איך:

1. הגדרה/עבודה מקדימה
2. עדכון ההגדרות
3. שינוי קוד האפליקציה

3. הגדרה/עבודה מקדימה

בקטע הזה נסביר איך:

1. הגדרת פרויקט בענן
2. קבלת אפליקציה לדוגמה של ערך בסיס
3. (Re)Deploy and validate baseline app

השלבים האלה מבטיחים שתתחילו עם קוד תקין.

1. הגדרת פרויקט

אם השלמתם את ה-Codelab של מודול 1, תוכלו להשתמש שוב באותו פרויקט (ובאותו קוד). אפשר גם ליצור פרויקט חדש לגמרי או להשתמש מחדש בפרויקט קיים אחר. צריך לוודא שלפרויקט יש חשבון לחיוב פעיל ואפליקציית App Engine מופעלת. צריך למצוא את מזהה הפרויקט, כי תצטרכו אותו כמה פעמים ב-codelab הזה, ולהשתמש בו בכל פעם שנתקלים במשתנה PROJECT_ID.

2. קבלת אפליקציה לדוגמה של ערך בסיס

אחד מהתנאים המוקדמים ל-codelab הזה הוא אפליקציית App Engine פעילה ממודול 1. מומלץ להשלים את ה-codelab של מודול 1 או להעתיק את האפליקציה של מודול 1 מהמאגר. בין אם משתמשים בקוד שלכם או בקוד שלנו, קוד מודול 1 הוא המקום שבו נתחיל. ב-codelab הזה מוסבר כל שלב, ובסופו מוצג קוד שדומה למה שמופיע בתיקיית המאגר Module 18 FINISH.

• התחלה: תיקיית מודול 1 (Python 2)
• סיום: תיקיית מודול 18 (Python 2)
• מאגר שלם (לשיבוט או להורדה של קובץ ZIP)

לא משנה באיזו אפליקציה של מודול 1 אתם משתמשים, התיקייה צריכה להיראות כמו הפלט שמוצג למטה, ואולי גם לכלול את התיקייה lib:

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

3. (Re)Deploy baseline app

כדי לפרוס את האפליקציה של מודול 1:

1. מוחקים את התיקייה lib אם היא קיימת ומריצים את הפקודה: pip install -t lib -r requirements.txt כדי לאכלס מחדש את lib. אם מותקנות אצלכם גם Python 2 וגם Python 3, יכול להיות שתצטרכו להשתמש בפקודה pip2.
2. חשוב לוודא שהתקנתם והפעלתם את כלי שורת הפקודה gcloud, וקראתם את הוראות השימוש בו.
3. מגדירים את פרויקט בענן באמצעות gcloud config set project PROJECT_ID אם לא רוצים להזין את PROJECT_ID בכל פקודת gcloud שמוציאים.
4. פריסת האפליקציה לדוגמה באמצעות gcloud app deploy
5. מוודאים שהאפליקציה של מודול 1 פועלת כמצופה ומציגה את הביקורים האחרונים (כפי שמוצג בהמשך)

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, אחרת המערכת יוצרת תור דחיפה (push queue) כברירת מחדל. מידע נוסף על יצירת תורים להעברת נתונים זמין במסמכי התיעוד. אפשר גם לעיין בדף העזר של 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 — add use of pull queues to the main application
• ‫templates/index.html — לעדכן את תבנית האינטרנט כדי להציג את הנתונים החדשים

ייבוא וקבועים

השלב הראשון הוא להוסיף ייבוא חדש וכמה קבועים כדי לתמוך בתורים של בקשות משיכה:

• מוסיפים ייבוא של ספריית Task Queue‏, google.appengine.api.taskqueue.
• מוסיפים שלוש קבועים כדי לתמוך בהשכרה של המספר המקסימלי של משימות משיכה (TASKS) למשך שעה (HOUR) מתור המשיכות (QUEUE).
• מוסיפים קבוע להצגת הביקורים האחרונים וגם המבקרים המובילים (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(). בנוסף לרישום הביקור, מוסיפים משימה לתור המשימות להעברה עם כתובת ה-IP של המבקר, כדי שהתהליך יוכל להגדיל את מונה המבקרים.

לפני:

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 למעקב אחרי מספר הביקורים. אחר כך מוסיפים פונקציה חדשה (אפשר גם להשתמש בפונקציית Python classmethod) בשם fetch_counts()כדי לשלוח שאילתה לגבי המבקרים המובילים ולהחזיר אותם בסדר יורד. מוסיפים את המחלקה והפונקציה מיד מתחת לגוף של 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)

הוספת קוד עובד

מוסיפים פונקציה חדשה log_visitors() כדי לרשום את המבקרים באמצעות בקשת GET אל /log. הוא משתמש במילון או בגיבוב (hash) כדי לעקוב אחרי ספירת המבקרים האחרונה, ומשכיר כמה שיותר משימות למשך שעה. בכל משימה, המערכת סופרת את כל הביקורים של אותו מבקר. לאחר מכן, האפליקציה מעדכנת את כל ישויות VisitorCount התואמות שכבר נמצאות ב-Datastore, או יוצרת ישויות חדשות אם צריך. בשלב האחרון מוחזרת הודעת טקסט פשוטה שמציינת כמה מבקרים נרשמו מתוך כמה משימות שעברו עיבוד. מוסיפים את הפונקציה הזו ל-main.py ממש מתחת ל-fetch_counts():

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

עדכון של ה-handler הראשי עם נתוני תצוגה חדשים

כדי להציג את המבקרים המובילים, מעדכנים את ה-handler הראשי 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:

עדכון תבנית אינטרנט עם נתונים חדשים של מודעות לרשת המדיה

צריך לעדכן את תבנית האינטרנט 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>

בשלב הזה סיימנו להוסיף את השינויים הנדרשים כדי להשתמש במשימות מסוג pull של תור המשימות של App Engine באפליקציית הדוגמה Module 1. עכשיו הספרייה מייצגת את אפליקציית הדוגמה Module 18, והיא אמורה להכיל את הקבצים הבאים:

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

6. סיכום/ניקוי

בקטע הזה מסכמים את ה-codelab הזה על ידי פריסת האפליקציה, אימות הפעולה שלה כמצופה ובכל פלט שמשתקף. מריצים את ה-worker בנפרד כדי לעבד את נתוני המבקרים. אחרי אימות האפליקציה, מבצעים את שלבי הניקוי ושוקלים את השלבים הבאים.

פריסה ואימות של האפליקציה

חשוב לוודא שכבר הגדרתם את תור המשיכה (pull queue) כמו שעשינו בחלק העליון של ה-Codelab הזה עם gcloud app deploy queue.yaml. אם סיימתם את השלב הזה ואפליקציית הדוגמה מוכנה, פורסים את האפליקציה באמצעות gcloud app deploy. הפלט צריך להיות זהה לאפליקציה של מודול 1, רק שעכשיו מופיעה בראש הטבלה 'מבקרים מובילים':

בממשק הקצה הקדמי המעודכן של האתר מוצגים המבקרים המובילים והביקורים האחרונים, אבל חשוב לדעת שמספר המבקרים לא כולל את הביקור הזה. האפליקציה מציגה את מספר המבקרים הקודם, ובמקביל מוסיפה למאגר המשימות משימה חדשה להגדלת מספר המבקרים של המשתמש הנוכחי בתור משיכה (pull queue). המשימה הזו ממתינה לעיבוד.

אפשר להריץ את המשימה על ידי קריאה ל-/log, במגוון דרכים:

• שירות לקצה העורפי ב-App Engine
• משרה cron
• דפדפן אינטרנט
• בקשת HTTP בשורת הפקודה (curl,‏ wget וכו')

לדוגמה, אם משתמשים ב-curl כדי לשלוח בקשת GET אל /log, הפלט ייראה כך, בהנחה שסיפקתם את PROJECT_ID:

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

המספר המעודכן ישתקף בביקור הבא באתר. זהו!

כל הכבוד, סיימתם את ה-Codelab הזה להוספת השימוש בשירות של תור משימות מסוג pull של App Engine לאפליקציית הדוגמה. עכשיו אפשר להעביר אותו אל Cloud Pub/Sub,‏ Cloud NDB ו-Python 3 במודול 19.

הסרת המשאבים

כללי

אם סיימתם לעכשיו, מומלץ להשבית את האפליקציה שלכם ב-App Engine כדי להימנע מחיובים. עם זאת, אם רוצים לבצע עוד בדיקות או ניסויים, בפלטפורמת App Engine יש מכסת שימוש בחינם, ולכן כל עוד לא חורגים מרמת השימוש הזו, לא אמורים לחייב אתכם. החישוב הזה מתייחס ל-Compute, אבל יכול להיות שיהיו גם חיובים על שירותים רלוונטיים של App Engine. לכן, כדאי לעיין בדף התמחור שלו כדי לקבל מידע נוסף. אם ההעברה הזו כוללת שירותי ענן אחרים, הם יחויבו בנפרד. בכל מקרה, אם רלוונטי, כדאי לעיין בקטע 'ספציפי ל-codelab הזה' שבהמשך.

חשוב לדעת: פריסה בפלטפורמת מחשוב ללא שרת של Google Cloud, כמו App Engine, כרוכה בעלויות קלות של בנייה ואחסון. ל-Cloud Build יש מכסת שימוש משלו בחינם, כמו גם ל-Cloud Storage. האחסון של התמונה הזו תופס חלק מהמכסה. עם זאת, יכול להיות שאתם גרים באזור שבו אין תוכנית בחינם כזו, ולכן חשוב לעקוב אחרי השימוש בנפח האחסון הנדרש כדי לצמצם את העלויות הפוטנציאליות. התיקיות הספציפיות ב-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*ation, לדוגמה, us אם האפליקציה מאוחסנת בארה"ב.

מצד שני, אם אתם לא מתכוונים להמשיך עם האפליקציה הזו או עם Codelabs אחרים שקשורים להעברה, ואתם רוצים למחוק הכול באופן סופי, אתם יכולים להשבית את הפרויקט.

ספציפי ל-Codelab הזה

השירותים שמופיעים בהמשך הם ייחודיים ל-codelab הזה. מידע נוסף זמין במסמכי התיעוד של כל מוצר:

• שירות תור המשימות של App Engine לא כרוך בחיובים נוספים, בהתאם לדף התמחור של שירותים חבילה מדור קודם כמו תור המשימות.
• שירות App Engine Datastore מסופק על ידי Cloud Datastore (Cloud Firestore במצב Datastore), שגם לו יש רמת שירות בחינם. מידע נוסף זמין במחירון שלו.

השלבים הבאים

ב'העברה' זו, הוספתם שימוש בתור דחיפה (push queue) של תור משימות לאפליקציה לדוגמה Module 1, על ידי הוספת תמיכה במעקב אחר מבקרים, וכך הטמעתם את האפליקציה לדוגמה Module 18. בהעברה הבאה תשדרגו משימות שליפת הודעות של App Engine ל-Cloud Pub/Sub. החל מסוף 2021, משתמשים כבר לא נדרשים לעבור ל-Cloud Pub/Sub כשהם משדרגים ל-Python 3. מידע נוסף על כך מופיע בקטע הבא.

למידע על מעבר ל-Cloud Pub/Sub, אפשר לעיין ב-codelab מודול 19. בנוסף, יש עוד העברות שכדאי לשקול, כמו Cloud Datastore, ‏ Cloud Memorystore, ‏ Cloud Storage או Cloud Tasks (תורים של הודעות Push). יש גם העברות בין מוצרים אל Cloud Run ו-Cloud Functions. אפשר לגשת לכל התוכן של Serverless Migration Station (סדנאות קוד, סרטונים, קוד מקור [כשהוא זמין]) במאגר הקוד הפתוח שלו.

7. העברה ל-Python 3

בסתיו 2021, צוות App Engine הרחיב את התמיכה ברבים מהשירותים בחבילה לזמני ריצה מדור שני (שיש להם זמן ריצה מדור ראשון). כתוצאה מכך, כשמניידים את האפליקציה ל-Python 3, כבר לא צריך לבצע מיגרציה משירותים בחבילה כמו App Engine Task Queue לשירותים עצמאיים של Cloud או של צד שלישי כמו Cloud Pub/Sub. במילים אחרות, אתם יכולים להמשיך להשתמש ב-Task Queue באפליקציות Python 3 App Engine, כל עוד אתם משנים את הקוד כך שתהיה לו גישה לשירותים בחבילה מזמני ריצה מהדור הבא.

מידע נוסף על העברת השימוש בשירותים בחבילה ל-Python 3 זמין ב-Module 17 codelab ובסרטון שמתאים לו. הנושא הזה לא נכלל בהיקף של מודול 18, אבל בהמשך מופיעות גרסאות Python 3 של האפליקציה במודול 1, שהועברו ל-Python 3 ועדיין משתמשות ב-App Engine NDB. (בשלב מסוים, תהיה זמינה גם גרסת Python 3 של אפליקציית מודול 18).

8. מקורות מידע נוספים

בהמשך מופיעים מקורות מידע נוספים למפתחים שרוצים לקבל מידע נוסף על מודול ההעברה הזה או על מודולים קשורים, וגם על מוצרים קשורים. הם כוללים מקומות שבהם אפשר לשלוח משוב על התוכן הזה, קישורים לקוד וקטעי תיעוד שונים שעשויים להיות שימושיים.

בעיות או משוב לגבי Codelab

אם נתקלתם בבעיות ב-codelab הזה, כדאי לחפש את הבעיה לפני ששולחים דיווח. קישורים לחיפוש וליצירה של בעיות חדשות:

• חיפוש בעיות
• דיווח על בעיה חדשה או משוב

מקורות מידע על העברת נתונים

בטבלה שלמטה מופיעים קישורים לתיקיות של מאגר המידע עבור מודול 1 (התחלה) ומודול 18 (סיום). אפשר גם לגשת אליהם ממאגר המידע של כל ההעברות של Codelab של App Engine, לשכפל אותו או להוריד קובץ ZIP.

Codelab	‫Python 2	‫Python 3
מודול 1	קוד	קוד (לא מוצג במדריך הזה)
מודול 18 (ה-Codelab הזה)	קוד	לא רלוונטי

מקורות אונליין

בהמשך מופיעים מקורות מידע שרלוונטיים למדריך הזה:

תור משימות ב-App Engine

• סקירה כללית בנושא תור המשימות של App Engine
• סקירה כללית על תורי משימות מסוג pull ב-App Engine
• אפליקציה לדוגמה מלאה של תור משימות מסוג pull ב-App Engine
• יצירת תורי משימות מסוג pull
• סרטון השקת תור המשימות של Google I/O 2011 ( אפליקציית הדוגמה Votelator)
• queue.yaml מידע נוסף
• ‫queue.yaml לעומת Cloud Tasks
• מדריך להעברת נתונים (מיגרציה) מתורי המתנה (pull queues) אל Pub/Sub
• דוגמה להעברה של תורי משיכה של App Engine Task Queue ל-Cloud Pub/Sub

פלטפורמת App Engine

מסמכי App Engine

זמן ריצה של Python 2 App Engine (סביבה סטנדרטית)

• שימוש בספריות מובנות של App Engine ב-Python 2 App Engine

זמן ריצה של Python 3 App Engine (סביבה רגילה)

ההבדלים בין סביבות זמן הריצה של Python 2 ו-Python 3 App Engine (סביבה סטנדרטית)

מדריך להעברה מ-Python 2 ל-Python 3 ב-App Engine (סביבה רגילה)

מידע על התמחור ועל המכסות ב-App Engine

השקת פלטפורמת App Engine מהדור השני (2018)

תמיכה לטווח ארוך בסביבות זמן ריצה מדור קודם

דוגמאות להעברת נתונים של מסמכים

• דוגמאות למיגרציה שנוצרו על ידי הקהילה

מידע אחר על Cloud

• ‫Python ב-Google Cloud Platform
• ספריות לקוח Python של Google Cloud
• רמת השימוש 'תמיד בחינם' ב-Google Cloud
• ‫Google Cloud SDK (כלי לשורת פקודה gcloud)
• כל מסמכי התיעוד של Google Cloud

סרטונים

• Serverless Migration Station
• מסעות ללא שרת
• הרשמה למינוי לערוץ Google Cloud Tech
• הרשמה לניוזלטר של Google Developers

רישיון

עבודה זו מורשית תחת רישיון Creative Commons שמותנה בייחוס 2.0 כללי.