בעזרת Workflows אפשר לתאם שירותים ולהפוך אותם לאוטומטיים ב-Google Cloud. יישום שיטות מומלצות לארכיטקטורה עוזר לשפר את האמינות, להוזיל את עלויות הביצוע ולבנות תזמורים עמידים וקלים לתחזוקה.
זו רשימה חלקית של המלצות, והיא לא מלמדת את העקרונות הבסיסיים של השימוש ב-Workflows. ההנחה במאמר הזה היא שכבר יש לכם הבנה כללית של Google Cloud ושל Workflows. מידע נוסף זמין במאמר Google Cloud Well-Architected Framework ובסקירה הכללית על Workflows.
בחירת דפוס תקשורת אופטימלי
כשמתכננים ארכיטקטורת מיקרו-שירותים לפריסה של כמה שירותים, אפשר לבחור מבין דפוסי התקשורת הבאים:
תקשורת ישירה בין שירותים
תקשורת עקיפה מבוססת-אירועים (נקראת גם כוריאוגרפיה)
הגדרה, תיאום וניהול אוטומטיים (נקראים גם תזמור)
חשוב לשקול את היתרונות והחסרונות של כל אחת מהאפשרויות הקודמות ולבחור את התבנית האופטימלית לתרחיש לדוגמה שלכם. לדוגמה, יכול להיות שיהיה קל יותר להטמיע תקשורת ישירה בין שירותים מאשר אפשרויות אחרות, אבל היא יוצרת צימוד חזק בין השירותים. לעומת זאת, ארכיטקטורה מבוססת-אירועים מאפשרת לכם ליצור צימוד חלש בין השירותים, אבל יכול להיות שהמעקב וניפוי הבאגים יהיו מורכבים יותר. ולבסוף, כלי תזמור מרכזי כמו Workflows, למרות שהוא פחות גמיש, מאפשר לתאם את התקשורת בין השירותים בלי הצימוד החזק של תקשורת ישירה בין שירותים, או המורכבות של אירועים מתוזמרים.
אפשר גם לשלב בין דפוסי תקשורת. לדוגמה, בתזמור מבוסס-אירועים, שירותים שקשורים זה לזה מנוהלים בתזמור שמופעל על ידי אירוע. באופן דומה, אפשר לתכנן מערכת שבה תזמור אחד מוביל להודעת Pub/Sub למערכת מתזמרת אחרת.
טיפים כלליים
אחרי שתחליטו להשתמש ב-Workflows בתור מתזמר השירותים, כדאי לזכור את הטיפים הבאים.
הימנעו מקידוד קשיח של כתובות URL
כדי לתמוך בתהליכי עבודה שניתן להעביר בין כמה סביבות וקל יותר לתחזק, כדאי להימנע מכתובות URL בתוך הקוד. אפשר לעשות זאת בדרכים הבאות:
מגדירים את כתובות ה-URL כארגומנטים של זמן ריצה.
זה יכול להיות שימושי כשמפעילים את תהליך העבודה באמצעות ספריית לקוח או ה-API. (עם זאת, זה לא יעבוד אם תהליך העבודה מופעל על ידי אירוע מ-Eventarc, והארגומנט היחיד שאפשר להעביר הוא המטען הייעודי (payload) של האירוע).
דוגמה
main: params: [args] steps: - init: assign: - url1: ${args.urls.url1} - url2: ${args.urls.url2}
כשמריצים את תהליך העבודה, אפשר לציין את כתובות ה-URL. לדוגמה:
gcloud workflows run multi-env --data='{"urls":{"url1": "URL_ONE", "url2": "URL_TWO"}}'
משתמשים במשתני סביבה ויוצרים תהליך עבודה שמוגדר באופן דינמי בהתאם לסביבה שבה הוא נפרס. אפשר גם ליצור תהליך עבודה שאפשר להשתמש בו שוב כתבנית, ולהגדיר אותו בהתאם למשתני סביבה שמנוהלים בנפרד.
להשתמש בטכניקת החלפה שמאפשרת ליצור קובץ הגדרה אחד של תהליך עבודה, אבל לפרוס וריאציות באמצעות כלי שמחליף את ה-placeholders בתהליך העבודה. לדוגמה, אתם יכולים להשתמש ב-Cloud Build כדי לפרוס תהליך עבודה, ובקובץ התצורה של Cloud Build להוסיף שלב להחלפת כתובות ה-URL של ה-placeholder בתהליך העבודה.
דוגמה
steps: ‐ id: 'replace-urls' name: 'gcr.io/cloud-builders/gcloud' entrypoint: bash args: - -c - | sed -i -e "s~REPLACE_url1~$_URL1~" workflow.yaml sed -i -e "s~REPLACE_url2~$_URL2~" workflow.yaml ‐ id: 'deploy-workflow' name: 'gcr.io/cloud-builders/gcloud' args: ['workflows', 'deploy', 'multi-env-$_ENV', '--source', 'workflow.yaml']
לאחר מכן תוכלו להחליף את ערכי המשתנים בזמן ה-build. לדוגמה:
gcloud builds submit --config cloudbuild.yaml \ --substitutions=_ENV=staging,_URL1="URL_ONE",_URL2="URL_TWO"
למידע נוסף, ראו שליחת גרסה דרך CLI ו-API.
אפשר גם להשתמש ב-Terraform כדי להקצות את התשתית ולהגדיר קובץ תצורה שיוצר תהליכי עבודה לכל סביבה באמצעות משתני קלט.
דוגמה
variable "project_id" { type = string } variable "url1" { type = string } variable "url2" { type = string } locals { env = ["staging", "prod"] } # Define and deploy staging and production workflows resource "google_workflows_workflow" "multi-env-workflows" { for_each = toset(local.env) name = "multi-env-${each.key}" project = var.project_id region = "us-central1" source_contents = templatefile("${path.module}/workflow.yaml", { url1 : "${var.url1}-${each.key}", url2 : "${var.url2}-${each.key}" }) }
כשמצהירים על משתנים במודול הבסיסי של ההגדרות, אפשר להקצות להם ערכים בכמה דרכים. לדוגמה:
terraform apply -var="project_id=PROJECT_ID" -var="url1=URL_ONE" -var="url2=URL_TWO"
משתמשים במחבר של Secret Manager כדי לאחסן כתובות URL בצורה מאובטחת ב-Secret Manager ולאחזר אותן.
שימוש בשלבים בתצוגת עץ
כל תהליך עבודה חייב לכלול לפחות שלב אחד.
כברירת מחדל, Workflows מתייחס לשלבים כאילו הם ברשימה מסודרת ומבצע אותם אחד אחרי השני עד שכל השלבים מופעלים. מבחינה לוגית,
צריך לקבץ כמה שלבים ביחד, ואפשר להשתמש בבלוק steps כדי להטמיע
סדרה של שלבים. זה נוח כי זה מאפשר להפנות לשלב האטומי הנכון כדי לעבד קבוצת שלבים.
דוגמה
main: params: [input] steps: - callWikipedia: steps: - checkSearchTermInInput: switch: - condition: ${"searchTerm" in input} assign: - searchTerm: ${input.searchTerm} next: readWikipedia - getCurrentDate: call: http.get args: url: https://timeapi.io/api/Time/current/zone?timeZone=Europe/Amsterdam result: currentDate - setFromCallResult: assign: - searchTerm: ${currentDate.body.dayOfWeek} - readWikipedia: call: http.get args: url: https://en.wikipedia.org/w/api.php query: action: opensearch search: ${searchTerm} result: wikiResult - returnOutput: return: ${wikiResult.body[1]}
ביטויים של גלישת טקסט
כל הביטויים חייבים להתחיל ב-$ ולהיות מוקפים בסוגריים מסולסלים:
${EXPRESSION}כדי למנוע בעיות בניתוח של YAML, אפשר להוסיף מירכאות לביטויים. לדוגמה, ביטויים שמכילים נקודתיים יכולים לגרום להתנהגות לא צפויה כשהנקודתיים מפורשות כהגדרה של מפה. כדי לפתור את הבעיה, אפשר להקיף את הביטוי ב-YAML במירכאות בודדות:
'${"Name: " + myVar}'
אפשר גם להשתמש בביטויים שמתפרסים על פני כמה שורות. לדוגמה, יכול להיות שתצטרכו להקיף שאילתת SQL במירכאות כשאתם משתמשים במחבר של Workflows ל-BigQuery.
דוגמה
- runQuery: call: googleapis.bigquery.v2.jobs.query args: projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")} body: useLegacySql: false useQueryCache: false timeoutMs: 30000 # Find top 100 titles with most views on Wikipedia query: ${ "SELECT TITLE, SUM(views) FROM `bigquery-samples.wikipedia_pageviews." + table + "` WHERE LENGTH(TITLE) > 10 GROUP BY TITLE ORDER BY SUM(VIEWS) DESC LIMIT 100" } result: queryResult
להגדרה המלאה של תהליך העבודה, ראו הרצת כמה משימות BigQuery במקביל.
שימוש בקריאות הצהרתיות
אתם יכולים להשתמש ב-Workflows כדי להפעיל שירותים מתוך תהליך העבודה עצמו, לטפל בתוצאות ולבצע משימות פשוטות כמו ביצוע קריאת HTTP. ב-Workflows אפשר להפעיל שירותים, לנתח תשובות וליצור קלט לשירותים מקושרים אחרים. קריאה לשירות מאפשרת לכם להימנע מהסיבוכים של הפעלות נוספות, יחסי תלות נוספים ושירותים שקוראים לשירותים אחרים. כדאי להחליף שירותים שאין בהם לוגיקה עסקית בקריאות ל-API הצהרתיות, ולהשתמש ב-Workflows כדי להפחית את המורכבות.
עם זאת, כדאי ליצור שירותים לביצוע כל עבודה שהיא מורכבת מדי ל-Workflows, למשל הטמעת לוגיקה עסקית לשימוש חוזר, חישובים מורכבים או טרנספורמציות שלא נתמכות על ידי ביטויים של Workflows והספרייה הרגילה שלו. בדרך כלל קל יותר להטמיע מקרה מורכב בקוד, במקום להשתמש ב-YAML או ב-JSON ובתחביר של Workflows.
שומרים רק את מה שצריך
חשוב לשלוט בצריכת הזיכרון כדי לא להגיע למגבלות המשאבים או לשגיאה שמעידה על כך, כמו ResourceLimitError, MemoryLimitExceededError או ResultSizeLimitExceededError.
היו סלקטיביים לגבי מה שאתם מאחסנים במשתנים, סננו ואחסנו רק את מה שאתם צריכים. אם שירות מחזיר מטען ייעודי (payload) גדול מדי, השתמשו בפונקציה נפרדת כדי לבצע את הקריאה ולהחזיר רק את מה שנדרש.
כדי לפנות זיכרון, אפשר לנקות משתנים. לדוגמה, יכול להיות שתרצו לפנות זיכרון שנדרש לשלבים הבאים. יכול להיות גם שיש קריאות עם תוצאות שלא מעניינות אתכם, ואתם יכולים להשמיט את התוצאות האלה לגמרי.
כדי לנקות משתנה, אפשר להקצות את הערך null. ב-YAML, אפשר גם להקצות ערך ריק או ~ למשתנה. כך אפשר לזהות זיכרון שאפשר לפנות בבטחה.
דוגמה
- step: assign: - bigVar:
שימוש בתהליכי עבודה משניים ובתהליכי עבודה חיצוניים
אתם יכולים להשתמש בתהליכי עבודה משניים כדי להגדיר לוגיקה או קבוצת שלבים שאתם רוצים להפעיל כמה פעמים, וכך לפשט את הגדרת תהליך העבודה. תהליכי עבודה משניים דומים לפונקציה או לשגרה בשפת תכנות. הם יכולים לקבל פרמטרים ולהחזיר ערכים, וכך אתם יכולים ליצור תהליכי עבודה מורכבים יותר עם מגוון רחב יותר של אפליקציות.
שימו לב שתהליכי עבודה משניים הם מקומיים להגדרת תהליך העבודה שלכם, ואי אפשר להשתמש בהם שוב בתהליכי עבודה אחרים. עם זאת, אפשר להפעיל תהליכי עבודה מתהליכי עבודה אחרים. המחברים של Workflows יכולים לעזור לכם בזה. מידע נוסף זמין בסקירות הכלליות על המחברים של Workflow Executions API ושל Workflows API.
שימוש במחברים של Workflows
ב-Workflows יש כמה מחברים שמאפשרים גישה קלה יותר למוצרים אחרים של Google Cloud בתוך תהליך עבודה. מחברים מפשטים את הקריאה לשירותים כי הם מטפלים בפורמט של הבקשות בשבילכם, ומספקים שיטות וארגומנטים כדי שלא תצטרכו להכיר את הפרטים של ממשק API שלGoogle Cloud . למחברים יש גם התנהגות מובנית לטיפול בניסיונות חוזרים ובפעולות ארוכות, כדי שתוכלו להימנע מחזרה על קריאות ומהמתנה להשלמתן. המחברים מטפלים בזה בשבילכם.
אם אתם צריכים לקרוא ל-API של Google Cloud , קודם בדקו אם יש לו מחבר של Workflows. אם אתם לא רואים מחבר למוצר של Google Cloud , אתם יכולים לבקש אותו.
איך משתמשים במחבר, והפניית מחברים לקבלת מידע מפורט על המחברים הזמינים.
הרצת שלבים בתהליך העבודה במקביל
ב-Workflows אפשר להריץ שלבים ברצף, אבל גם להריץ שלבים עצמאיים במקביל. במקרים מסוימים, זה יכול להאיץ באופן משמעותי את הפעלת תהליך העבודה. מידע נוסף זמין במאמר ביצוע שלבי תהליך עבודה במקביל.
החלת ניסיונות חוזרים ותבנית הסאגה
תכננו תהליכי עבודה גמישים שיכולים להתמודד עם כשלים זמניים וקבועים בשירות. שגיאות ב-Workflows יכולות להתרחש, למשל, בגלל בקשות HTTP, פונקציות או מחברים שנכשלו, או בגלל קוד של תהליך העבודה שלכם. הוסיפו טיפול בשגיאות וניסיונות חוזרים כדי שכשל בשלב אחד לא יגרום לכל תהליך העבודה להיכשל.
- אפשר להעלות שגיאות בהתאמה אישית באמצעות התחביר
raise. - אפשר לתפוס שגיאות באמצעות בלוק
try/except. - אפשר לנסות שוב את השלבים באמצעות בלוק
try/retryולהגדיר את המספר המקסימלי של ניסיונות חוזרים.
חלק מהטרנזקציות העסקיות כוללות כמה שירותים, ולכן צריך מנגנון להטמעת טרנזקציות שכוללות שירותים. תבנית העיצוב של סאגה היא דרך לנהל את עקביות הנתונים בין מיקרו-שירותים בתרחישים של טרנזקציות מבוזרות. סאגה היא רצף של טרנזקציות שמפרסמות אירוע לכל טרנזקציה, ומפעילות את הטרנזקציה הבאה. אם טרנזקציה נכשלת, הסאגה מבצעת טרנזקציות פיצוי שמבטלות את הכשלונות הקודמים ברצף. במדריך הזה ב-GitHub מוסבר איך להשתמש בתבנית Saga ובניסיונות חוזרים ב-Workflows.
שימוש בקריאות חוזרות (callbacks) כדי להמתין
קריאות חוזרות (callbacks) מאפשרות להפעלות של תהליכי עבודה להמתין לשירות אחר שישלח בקשה לנקודת הקצה של הקריאה החוזרת. הבקשה הזו מחדשת את ההפעלה של תהליך העבודה.
באמצעות קריאות חוזרות, אתם יכולים לאותת לתהליך העבודה שאירוע מסוים התרחש, ולהמתין לאירוע הזה בלי סקר. לדוגמה, אתם יכולים ליצור תהליך עבודה ששולח לכם התראה כשמוצר חוזר למלאי או כשפריט נשלח, או תהליך עבודה שממתין לאינטראקציה אנושית כמו בדיקת הזמנה או אימות תרגום. אפשר גם להמתין לאירועים באמצעות קריאות חוזרות (callbacks) וטריגרים של Eventarc.
תזמור של משימות ממושכות
אם אתם צריכים להריץ עומסי עבודה של עיבוד ברצף (batch processing) שנמשכים זמן רב, אתם יכולים להשתמש ב-Batch או במשימות של Cloud Run, ולהשתמש ב-Workflows כדי לנהל את השירותים. כך תוכלו לשלב את היתרונות של שתי הגישות, ולהקצות משאבים ולתזמר את התהליך כולו בצורה יעילה.
Batch הוא שירות מנוהל שמאפשר לתזמן עומסי עבודה באצווה, להוסיף אותם לתור ולהפעיל אותם במכונות וירטואליות (VM) של Compute Engine. אתם יכולים להשתמש במחבר של Workflows ל-Batch כדי לתזמן ולהריץ משימה באצווה. לפרטים נוספים, כדאי לעיין במדריך.
משימות ב-Cloud Run משמשות להרצת קוד שמבצע עבודה (משימה) ומפסיק כשהעבודה מסתיימת. בעזרת Workflows אפשר להריץ משימות של Cloud Run כחלק מתהליך עבודה, כדי לבצע עיבוד נתונים מורכב יותר או לתזמר מערכת של משימות קיימות. במדריך הזה מוסבר איך להשתמש ב-Workflows כדי להריץ משימה ב-Cloud Run.
התאמה של זמני הקצובות לתפוגה וגודלי המטען הייעודי (payload) בשירותים השונים
כש-Workflows קורא לשירותי Google Cloud במורד הזרם, הבדלים בזמן הקצוב לתפוגה של בקשות, במגבלות של תגובות HTTP ובמגבלות הזיכרון יכולים לגרום לכשלים מסוג TimeoutError, ValueError או MemoryLimitExceededError.
השוו בין מגבלות המשאבים של Workflows לבין המגבלות של שירות היעד, ובחרו דפוס שילוב שתואם למשך הזמן ולגודל המטען הייעודי (payload) של עומס העבודה. לדוגמה:
| תרחיש שילוב | מגבלות של Workflows | מגבלות שירות היעד | התבנית המומלצת |
|---|---|---|---|
קריאות HTTP סינכרוניות (http.get, http.post, http.request) לשירותי Cloud Run או לפונקציות Cloud Run
|
|
אפשר לקרוא מידע נוסף במאמרים הגדרת זמן קצוב לתפוגה של בקשות לשירותים ומגבלות משאבים ב-Cloud Run. |
לעומסי עבודה שנמשכים יותר מ-30 דקות, אל תשתמשו בקריאות סינכרוניות של במקום זאת, צריך להריץ משימות ב-Cloud Run באמצעות המחבר של Cloud Run Admin API, או להשתמש בנקודת קצה (endpoint) אסינכרונית של קריאה חוזרת (callback) ב-Workflows. המחבר של Cloud Run Admin API תומך בדגימה של פעולות ממושכות (LRO), שזמן הקצוב שלהן לתפוגה הוא 30 דקות (1,800 שניות) כברירת מחדל. במשימות שנמשכות יותר מ-30 דקות, צריך להגדיר גם את זמן הקצוב לתפוגה של המשימה ב-Cloud Run (ברירת המחדל היא 10 דקות, ואפשר להגדיר עד 168 שעות או 7 ימים) וגם את |
שאילתות BigQuery ומטענים ייעודיים (payloads) גדולים של API
(googleapis.
ותגובות REST)
|
|
תוצאות של שאילתות ב-BigQuery ומטענים ייעודיים (payloads) של API בארכיטקטורת REST יכולים להיות בגודל של כמה מגה-בייטים או ג'יגה-בייטים. |
אל תמשכו קבוצות גדולות של תוצאות למשתנים של תהליך העבודה. משתמשים בחלוקה לדפים של |
הפעלת משימות ארוכות בקונטיינרים
אתם יכולים להפוך את ההפעלה של קונטיינר שפועל לאורך זמן לאוטומטית באמצעות Workflows ו-Compute Engine. לדוגמה, אתם יכולים להכיל בקונטיינר משימה שפועלת לאורך זמן כדי שתוכל לפעול בכל מקום, ואז להריץ את הקונטיינר במכונה וירטואלית של Compute Engine למשך הזמן המקסימלי של הרצת תהליך עבודה (שנה אחת).
באמצעות Workflows, אתם יכולים להפוך את יצירת ה-VM, את הפעלת הקונטיינר ב-VM ואת מחיקת ה-VM לאוטומטיות. כך אתם יכולים להשתמש בשרת ולהריץ קונטיינר, אבל בלי המורכבות של ניהול שניהם. זה יכול להיות שימושי אם אתם נתקלים במגבלות זמן כשאתם משתמשים בשירות כמו פונקציות Cloud Run או Cloud Run. נסו את המדריך קונטיינרים שפועלים לאורך זמן באמצעות Workflows ו-Compute Engine ב-GitHub.
הפעלת כלי שורת הפקודה מ-Workflows
Cloud Build הוא שירות שמפעיל את גרסאות ה-build שפיתחתם ב- Google Cloud כסדרה של שלבי פיתוח, כשכל שלב פיתוח מופעל בקונטיינר של Docker. ביצוע שלבי build דומה לביצוע פקודות בסקריפט.
Google Cloud CLI כולל את כלי שורת הפקודה gcloud, bq ו-kubectl, אבל אין דרך ישירה להריץ פקודות של ה-CLI של gcloud מ-Workflows. עם זאת, ב-Cloud Build יש קובצי אימג' של קונטיינרים שכוללים את ה-CLI של gcloud. אתם יכולים להריץ פקודות של ה-CLI של gcloud בקונטיינרים האלה משלב של Cloud Build, וליצור את השלב הזה ב-Workflows באמצעות המחבר של Cloud Build.
דוגמה
הפעלת gcloud בתהליך עבודה:
Run kubectl in a workflow:
איך משתמשים ב-Terraform כדי ליצור את תהליך העבודה
Terraform הוא כלי מסוג תשתית כקוד (IaC) שמאפשר ליצור, לשנות ולשפר בצורה חזויה את תשתית הענן באמצעות קוד.
אתם יכולים להגדיר ולפרוס תהליך עבודה באמצעות המשאב google_workflows_workflow של Terraform. מידע נוסף זמין במאמר יצירת תהליך עבודה באמצעות Terraform.
כדי לנהל ולתחזק תהליכי עבודה גדולים, אתם יכולים ליצור את תהליך העבודה בקובץ YAML נפרד ולייבא את הקובץ הזה ל-Terraform באמצעות הפונקציה templatefile, שקוראת קובץ בנתיב נתון ומציגה את התוכן שלו כתבנית.
דוגמה
# Define a workflow resource "google_workflows_workflow" "workflows_example" { name = "sample-workflow" region = var.region description = "A sample workflow" service_account = google_service_account.workflows_service_account.id # Import main workflow YAML file source_contents = templatefile("${path.module}/workflow.yaml",{}) }
באופן דומה, אם יש לכם תהליך עבודה ראשי שקורא לכמה תהליכי עבודה משניים, אתם יכולים להגדיר את תהליך העבודה הראשי ואת תהליכי העבודה המשניים בקבצים נפרדים, ולהשתמש בפונקציה templatefile כדי לייבא אותם.
דוגמה
# Define a workflow resource "google_workflows_workflow" "workflows_example" { name = "sample-workflow" region = var.region description = "A sample workflow" service_account = google_service_account.workflows_service_account.id # Import main workflow and subworkflow YAML files source_contents = join("", [ templatefile( "${path.module}/workflow.yaml",{} ), templatefile( "${path.module}/subworkflow.yaml",{} )]) }
שימו לב: אם אתם מתייחסים למספרי שורות כשאתם מנפים באגים בתהליך עבודה, כל קובצי ה-YAML שיובאו דרך קובץ התצורה של Terraform מוזגו ונפרסו כתהליך עבודה אחד.
פריסת תהליך עבודה ממאגר Git
ב-Cloud Build משתמשים בטריגרים לפיתוח גרסת Build כדי להפעיל אוטומציה של CI/CD. אתם יכולים להגדיר טריגרים שיאזינו לאירועים נכנסים, כמו דחיפה של commit חדש למאגר או הפעלה של בקשת משיכה, ואז להפעיל build באופן אוטומטי כשמגיעים אירועים חדשים.
אתם יכולים להשתמש בטריגר לפיתוח גרסת Build של Cloud Build כדי להתחיל באופן אוטומטי פיתוח של גרסת Build ולפרוס תהליך עבודה ממאגר Git. אפשר להגדיר את הטריגר כך שיפרוס את תהליך העבודה בכל שינוי במאגר המקור, או רק כשהשינוי תואם לקריטריונים ספציפיים.
הגישה הזו יכולה לעזור לכם לנהל את מחזור החיים של הפריסה. לדוגמה, אתם יכולים לפרוס שינויים בתהליך עבודה בסביבת Staging, להריץ בדיקות בסביבה הזו ואז להשיק את השינויים האלה בהדרגה בסביבת הייצור. מידע נוסף זמין במאמר פריסת תהליך עבודה ממאגר Git באמצעות Cloud Build.
אופטימיזציה של השימוש
העלות של הפעלת תהליך עבודה היא מינימלית. עם זאת, אם אתם משתמשים בנפח גבוה, כדאי לפעול לפי ההנחיות הבאות כדי לייעל את השימוש ולהפחית את העלות:
במקום להשתמש בדומיינים בהתאמה אישית, ודאו שכל הקריאות לשירותי Google Cloudמשתמשות ב-
*.appspot.com, ב-*.cloud.goog, ב-*.cloudfunctions.netאו ב-*.run.app, כדי שתחויבו על שלבים פנימיים ולא חיצוניים.להחיל מדיניות ניסיונות חוזרים בהתאמה אישית שמאזנת בין צורכי זמן האחזור והאמינות לבין העלויות. ניסיונות חוזרים בתדירות גבוהה יותר מקצרים את זמן האחזור ומגבירים את האמינות, אבל גם יכולים להגדיל את העלויות.
כשמשתמשים במחברים שממתינים לפעולות ממושכות, צריך להגדיר מדיניות דגימה בהתאמה אישית שמבצעת אופטימיזציה של זמן האחזור בהתאם לעלות. לדוגמה, אם אתם מצפים שפעולה תימשך יותר משעה, יכול להיות שתרצו מדיניות שבה הסקר הראשוני יתבצע אחרי דקה, למקרה של כשל מיידי, ואחר כך כל 15 דקות.
לשלב מטלות בשלב אחד.
הימנעו משימוש מופרז בשלבי
sys.log. במקום זאת, כדאי להשתמש בתיעוד שיחות.הסבר על הפעולות שנחשבות לשלב. פעולות שלא נספרות כשלבים בפני עצמן נספרות כשהן משמשות כחלק משלב רלוונטי. לדוגמה, הפעולה הבאה נחשבת כשלב אחד:
- type_check: return: if(get_type((int("6"))) == integer, 1, 2)בטבלה הבאה מפורטות פעולות עיקריות שנכללות ולא נכללות במגבלת השלבים המקסימלית:
קטגוריה פעולה נחשב כצעד - פעולות בנתונים: הקצאה, החזרת ערכים
- בקרת זרימה: קפיצות (
next), מתגים, התחלת לולאתforוכל איטרציה של לולאתfor - קריאות: הפעלת
sys.get_envאו פונקציה אחרת של ספרייה רגילה, תהליך עבודה אחר או מחבר - בו-זמניות: יצירת שרשורים והרצה במקביל
- טיפול בשגיאות: כל בלוק של
raise,try,retryו-exceptנספר כשלב נפרד, גם אם פעולות אחרות הן חלק מאותו שלב גדול יותר.לדוגמה, שלב שכולל בלוק
tryעם פעולת קריאה נספר כשלושה שלבים: אחד לשלב הראשי, אחד לניסיון ואחד לקריאה. הוספת בלוקretryמוסיפה עוד שלושה שלבים (אחד לכל אחד מהשלבים: ניסיון חוזר, ניסיון וקריאה), כך שיש בסך הכול שישה שלבים.
לא נספר כצעד - קריאה וכתיבה של רשימות, מפות ומשתנים
למרות שחיפוש בודד לא מוסיף שלב, שלב שמכיל את החיפוש, למשל שלב
assign, נחשב לשלב אחד. - פונקציות עזר ספציפיות מובנות של ביטויים:
len(),int()ו-get_type() - פעולות השוואה ופעולות אריתמטיות
- שרשור מחרוזות
- פעולות בוליאניות
סיכום של השיטות המומלצות
בטבלה הבאה ריכזנו את הטיפים הכלליים והשיטות המומלצות שמופיעים במאמר הזה.