איך משתמשים ב-Memcache של App Engine באפליקציות Flask (מודול 12)

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

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

ב-Codelab הזה תלמדו איך לכלול את App Engine Memcache ואיך להשתמש בו באפליקציה לדוגמה מ-Codelab מודול 1. במדריך הזה, מודול 12, אנחנו מוסיפים שימוש ב-Memcache ואז עוברים ל-Cloud Memorystore במודול 13.

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

  • שימוש ב-App Engine Memcache API/library
  • הוספת שמירה במטמון לאפליקציית Python 2 Flask App Engine NDB בסיסית

הדרישות

סקר

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

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

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

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

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

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

2. רקע

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

אם אותו מבקר נכנס לדף, הביקורים האלה מוחזרים מהמטמון. אם משתמש חדש מבקר באתר או אם חלפה שעה, המטמון מתרוקן ומוחלף ברשומות האחרונות (בנוסף לרישום של ביקור חדש). אחרי שנשלים את ההטמעה של השילוב הזה של App Engine Memcache, נוכל להעביר אותו אל Cloud Memorystore ב-Codelab הבא (מודול 13).

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

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

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

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

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

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

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

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

בין אם אתם משתמשים בקוד שלכם או בקוד שלנו, נתחיל עם קוד מודול 1. ב-Codelab הזה מוסבר כל שלב, ובסופו מוצג קוד שדומה למה שמופיע בתיקיית המאגר של מודול 11 (FINISH).

הספרייה של קבצי ההתחלה של מודול 1 (שלכם או שלנו) צריכה להיראות כך:

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

3. (Re)Deploy baseline app

השלבים הנותרים שצריך לבצע עכשיו:

  1. כדאי להכיר מחדש את כלי שורת הפקודה gcloud
  2. פריסה מחדש של האפליקציה לדוגמה עם gcloud app deploy
  3. אישור שהאפליקציה פועלת ב-App Engine ללא בעיות

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

a7a9d2b80d706a2b.png

4. עדכון ההגדרות

אין צורך לבצע שינויים בקובצי התצורה הסטנדרטיים של App Engine ‏ (app.yaml, ‏requirements.txt, ‏appengine_config.py).

5. שינוי קבצים של אפליקציות

מכיוון שאנחנו מוסיפים רק App Engine API, לא מעורבים חבילות חיצוניות, כלומר אין צורך לעדכן קובצי הגדרה (app.yaml, ‏ requirements.txt, ‏ appengine_config.py). יש רק קובץ בקשה אחד, main.py, ולכן כל השינויים בקטע הזה משפיעים רק על הקובץ הזה.

יבוא

השלב הכי חשוב הוא לייבא את ספריית Memcache, ‏ google.appengine.api.memcache. מכיוון שאנחנו הולכים לשמור במטמון את הביקורים האחרונים למשך שעה, כדאי להוסיף גם קבוע למספר השניות בשעה. כך נראה הקוד לפני השינוי:

לפני:

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 memcache
from google.appengine.ext import ndb

app = Flask(__name__)
HOUR = 3600

הוספת שמירת נתונים במטמון עם תמיכה ב-Memcache

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

  1. הגדרת הביקור הנוכחי וקריאה לו visitor
  2. ניסיון לאחזר את visits האחרון מהמטמון
  3. אם המטמון ריק או שהמבקר האחרון (visits[0]['visitor']) שונה מהמבקר הנוכחי (visitor): המערכת שומרת את הביקור החדש, מאחזרת את הביקורים האחרונים ומאחסנת אותם במטמון למשך שעה.
  4. הצגת visits למשתמש דרך תבנית האינטרנט

כך נראו הדברים לפני העדכונים ואחריהם:

לפני:

@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'
    # check for (hour-)cached visits
    ip_addr, usr_agt = request.remote_addr, request.user_agent
    visitor = '{}: {}'.format(ip_addr, usr_agt)
    visits = memcache.get('visits')

    # register visit & run DB query if cache empty or new visitor
    if not visits or visits[0]['visitor'] != visitor:
        store_visit(ip_addr, usr_agt)
        visits = list(fetch_visits(10))
        memcache.set('visits', visits, HOUR)  # set() not add()

    return render_template('index.html', visits=visits)

לפניכם איור שמציג את השינויים שבוצעו:

b1242503602f7bf0.png

כאן מסתיימים כל השינויים שצריך לבצע כדי להוסיף את השימוש ב-App Engine memcache לאפליקציה לדוגמה של מודול 1. עכשיו נבנה ונפרוס את האפליקציה כדי לראות שהיא פועלת.

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

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

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

מבצעים פריסה מחדש של האפליקציה באמצעות gcloud app deploy ומאשרים שהאפליקציה פועלת. הקוד שלכם צריך להיות זהה לקוד שמופיע בתיקייה FINISH, Module 12 folder. הפלט צריך להיות זהה לאפליקציה Module 1 שפרסתם קודם:

a7a9d2b80d706a2b.png

כל מה שעשינו הוא להאיץ את חוויית המשתמש עבור אותו משתמש. כשמרעננים, התוצאות אמורות להתקבל ישירות מהמטמון, בלי ליצור ביקור חדש או לבצע אחזור מ-Datastore.

כל הכבוד, סיימתם את מודול 12 של ה-Codelab להוספת השימוש בשירות App Engine memcache לאפליקציה לדוגמה שלנו. בשלב הבונוס יש לכם עכשיו אפשרות להעביר את אפליקציית Python 2 הזו ל-Python 3.

הסרת המשאבים

כללי

אם סיימתם לעכשיו, מומלץ להשבית את האפליקציה שלכם ב-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 הזה. מידע נוסף זמין במסמכי התיעוד של כל מוצר:

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

השלבים הבאים

המעבר הבא שכדאי לשקול מוסבר במודול 13, שבו מוסבר למפתחים איך לעבור משירות memcache של App Engine אל Cloud Memorystore. המיגרציות האלה הן אופציונליות וזמינות למשתמשים שרוצים לבצע שלבים שונים כדי לחדש את האפליקציות שלהם. שירות Cloud Memorystore הוא שדרוג משמעותי ל-memcache של App Engine, מכמה סיבות:

  • ‫Cloud Memorystore הוא לא שירות ללא שרת. המשמעות היא שצריך להקצות שרת למטמון. בנוסף, אין מסלול חינמי ב-Cloud Memorystore. לשני הגורמים האלה יכולה להיות השפעה משמעותית על העלות.
  • ‫Cloud Memorystore תומך בשני מנגנוני אחסון בסיסיים שונים (מנועי שמירה במטמון), ‏ Redis ו-Memcached.
  • ל-Cloud Memorystore (for Redis) יש הרבה יותר תכונות מתקדמות ומפורטות מאשר ל-App Engine Memcache.
  • כדי להשתמש ב-Cloud Memorystore, צריך להגדיר שרת Cloud Memorystore, להוסיף אותו לרשת Google Cloud VPC, ואז להגדיר את אפליקציית App Engine כך שתשתמש ברשת הזו כדי לתקשר עם שרת Memorystore.

אם אתם לא חושבים שאתם צריכים את כל התכונות שזמינות ב-Cloud Memorystore או שאתם מודאגים מההשפעות שלו על העלויות, אתם יכולים להמשיך להשתמש ב-App Engine Memcache.

מעבר למודול 13 יש עוד הרבה אפשרויות להעברה, כמו Cloud NDB,‏ Cloud Datastore או Cloud Tasks. יש גם העברות בין מוצרים אל Cloud Run ו-Cloud Functions. אפשר למצוא את כולם במאגר ההעברה.

שלב אפשרי נוסף הוא העברה ל-Python 3, שמוסבר בקטע הבא כשלב אופציונלי.

7. בונוס: העברה ל-Python 3

סקירה כללית

החלק הזה כולל תוכן בונוס אופציונלי שמעביר את האפליקציה של מודול 12 שסיימנו לעבוד איתה למעלה אל Python 3. מתחילים בהגדרה ואז עוברים לאפליקציה.

פישוט של קובץ app.yaml

אחד היתרונות של זמן הריצה של Python 3 הוא שאפשר לפשט משמעותית את app.yaml.

לפני:

בהמשך מופיע תוכן app.yaml בסיום מודול 12:

runtime: python27
threadsafe: yes
api_version: 1

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

מכיוון שזמן הריצה של Python 3 מחייב מסגרות אינטרנט לבצע ניתוב משלהן, צריך לשנות את כל מטפלי המסלולים ב-app.yaml ל-auto. אם אין קבצים סטטיים שמוצגים, המשתמשים יכולים פשוט להסיר את כל הקטע handlers:. בנוסף, הוצאנו משימוש את threadsafe ואת api_version.

אחרי:

אחרי השינויים הנדרשים שמתוארים כאן, זו ההחלפה app.yaml ל-Python 3:

runtime: python39
app_engine_apis: true

השורה היחידה שצריך להסביר היא app_engine_apis: true. כששירותי App Engine מדור קודם הפכו לזמינים בסביבות זמן ריצה מדור שני בשנת 2021, חלק מסביבות זמן הריצה, כולל Python 3, דרשו אתחול נוסף כדי לגשת לממשקי ה-API האלה, כמו ndb, ‏ taskqueue ו-memcache. השורה הזו בהגדרה מיועדת למטרה הזו.

עדכון של הקובץ requirements.txt

נדרש עוד bootstrapping של ממשקי ה-API המקוריים ב-requirements.txt: צריך לכלול גישה ל-SDK החדש של App Engine.

לפני:

בהמשך מופיע תוכן app.yaml בסיום מודול 12:

flask

אחרי:

פשוט מוסיפים את App Engine Python SDK, ואלה הקבצים שצריכים להיות לכם:

flask
appengine-python-standard

מחיקת הקובץ appengine_config.py והספרייה lib

הדור הבא של סביבות זמן ריצה ב-App Engine משפר את השימוש בחבילות צד שלישי:

  • ספריות מובנות הן ספריות שנבדקו על ידי Google והועמדו לרשותכם בשרתי App Engine, כנראה כי הן מכילות קוד C/C++ שמפתחים לא יכולים לפרוס בענן – הן כבר לא זמינות בסביבות זמן הריצה מהדור השני.
  • אין יותר צורך להעתיק ספריות שאינן מוכללות (לפעמים נקראות 'יצירת עותק מקוד של צד שלישי (vendoring)' או 'איגוד עצמי') בסביבות זמן ריצה מהדור השני. במקום זאת, צריך לפרט אותם ב-requirements.txt, שם מערכת ה-Build מתקינה אותם באופן אוטומטי בשמכם בזמן הפריסה.

בעקבות השינויים האלה בניהול חבילות של צד שלישי, אין יותר צורך בקובץ appengine_config.py או בתיקייה lib, ולכן צריך למחוק אותם. בזמן ריצה מהדור השני, App Engine מתקין באופן אוטומטי חבילות של צד שלישי שמופיעות ב-requirements.txt. סיכום:

  1. אין ספריות של צד שלישי שצורפו או הועתקו; יש לציין אותן ב-requirements.txt
  2. אין pip install בתיקייה lib, כלומר אין תיקייה lib בכלל
  3. אין ספריות מובנות של צד שלישי (ולכן אין קטע libraries) ב-app.yaml; צריך לפרט אותן ב-requirements.txt
  4. אם אין ספריות של צד שלישי שאפשר להפנות אליהן מהאפליקציה, לא יהיה קובץ appengine_config.py

הדרישה היחידה למפתחים היא לפרט את כל הספריות הרצויות של צד שלישי ב-requirements.txt.

עדכון האפליקציה לשימוש ב-App Engine SDK

כמו שצוין למעלה, כדי לגשת לשירותים בחבילה של App Engine באפליקציות Python 3, צריך לבצע שינויים מסוימים:

  1. חבילת App Engine SDK (ב-requirements.txt)
  2. הפעלת App Engine SDK (ב-app.yaml)
  3. עטיפת אובייקט WSGI (ב-main.py)

השלמנו את הזוג הראשון למעלה, אז הדרישה האחרונה היא לעדכן את main.py.

לפני:

בהמשך מוצג קוד Python 2 main.py בסיום מודול 12:

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

app = Flask(__name__)
HOUR = 3600

אחרי:

ב-Python 3 port, מייבאים את ה-SDK ועוטפים איתו את אובייקט אפליקציית Flask (העטיפה של ה-SDK), וכך מקבלים את התוצאה הבאה:

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

app = Flask(__name__)
app.wsgi_app = wrap_wsgi_app(app.wsgi_app)
HOUR = 3600

מפתחים צריכים לבצע את השינויים האלה באפליקציות Python שלהם כשמבצעים העברה מגרסה 2.x לגרסה 3.x כדי לגשת לשירותים בחבילה. אם אתם לא משתמשים ב-Flask, יש גם דוגמאות ל-Django ול-Pyramid במסמכים. אם קוד Python 2 שלכם לא שייך לאפליקציית אינטרנט, מספיק לכלול את חבילת ה-SDK כשמעבירים אותו ל-Python 3. קוד האפליקציה שלנו נוצר במקור כדי לפעול ב-Python 2 וב-Python 3, כך שלא נדרשים שינויים נוספים לצורך תאימות.

פריסת אפליקציה

אחרי שמבצעים את השינויים שלמעלה, אפשר לפרוס את האפליקציה לדוגמה המעודכנת. (אין בעיה כשפורסים גרסת Python 3 של האפליקציה על גרסת Python 2 מקורית באותו פרויקט GCP). ההתנהגות של האפליקציה צריכה להישאר ללא שינוי. אם אתם רוצים להשוות את האפליקציה המעודכנת שלכם לאפליקציה שלנו, תוכלו לעיין בתיקייה Module 12b במאגר ההעברה. למידע נוסף על התמיכה בשירותים בחבילה של App Engine בסביבות זמן הריצה העדכניות כמו Python 3, אפשר לעיין בהודעה על השקת התכונה ובמדריך Codelab מודול 17.

כל הכבוד, סיימת את שלב הבונוס במודול 12! אפשר גם לעיין במסמכים בנושא הכנת קובצי הגדרה לסביבת זמן הריצה של Python 3. בקטע 'סיכום/ניקוי' שלמעלה מפורטים השלבים הבאים ופעולות הניקוי.

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

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

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

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

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

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

Codelab

‫Python 2

‫Python 3

מודול 1

קוד

קוד (לא מוצג במדריך הזה)

יחידת לימוד 12 (ה-Codelab הזה)

קוד

קוד

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

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

App Engine

Cloud Memorystore ו-Cloud Datastore

מידע אחר על Cloud

סרטונים

רישיון

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