יצירה של מכונות וירטואליות מסוג Spot ושימוש בהן

בדף הזה מוסבר איך ליצור ולנהל מכונות וירטואליות מסוג Spot, כולל:

  • איך יוצרים, מפעילים ומזהים מכונות וירטואליות מסוג Spot
  • איך לזהות, לטפל ולבדוק את ההפסקות של מכונות וירטואליות מסוג Spot
  • שיטות מומלצות לשימוש ב-VMs במודל Spot

מכונות וירטואליות מסוג Spot הן מופעים של מכונות וירטואליות (VM) שמשתמשים במודל הקצאת משאבים מסוג Spot. מכונות וירטואליות מסוג Spot זמינות בהנחה של עד 60% מהמחיר על פי דרישה של מכונות וירטואליות רגילות. מידע נוסף זמין בדף התמחור. עם זאת, יכול להיות ש-Compute Engine יחזיר לעצמו את המשאבים על ידי הפסקת השימוש במכונות וירטואליות מסוג Spot בכל שלב. מכונות וירטואליות זמניות מסוג Spot מומלצות רק לעומסי עבודה סובלניים לשגיאות שיכולים לעמוד בפני הפסקת פעולה של מכונות וירטואליות.

לפני שמתחילים

התפקידים הנדרשים

כדי לקבל את ההרשאות שנדרשות ליצירת מכונת Spot, צריך לבקש מהאדמין להקצות לכם ב-IAM את התפקיד אדמין מכונות של Compute ‏ (v1) (roles/compute.instanceAdmin.v1) בפרויקט. כדי לקרוא הסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

זהו תפקיד שמוגדר מראש וכולל את ההרשאות שנדרשות ליצירת VM במודל Spot. כדי לראות בדיוק אילו הרשאות נדרשות, אפשר להרחיב את הקטע ההרשאות הנדרשות:

ההרשאות הנדרשות

כדי ליצור VM במודל Spot, צריך את ההרשאות הבאות:

  • ‫compute.instances.create בפרויקט
  • כדי להשתמש באימג' בהתאמה אישית ליצירת המכונה הווירטואלית (VM)‏: ‫compute.images.useReadOnly בקובץ אימג'
  • כדי להשתמש ב-snapshot ליצירת המכונה הווירטואלית: ‫compute.snapshots.useReadOnly בקובץ snapshot
  • כדי להשתמש בתבנית של הגדרות מכונה ליצירת המכונה הווירטואלית: compute.instanceTemplates.useReadOnly בתבנית של הגדרות המכונה
  • כדי לציין רשת משנה למכונה הווירטואלית: ‫compute.subnetworks.use בפרויקט או ברשת המשנה שנבחרה
  • כדי לציין כתובת IP סטטית למכונה הווירטואלית: ‫compute.addresses.use בפרויקט
  • כדי להקצות כתובת IP חיצונית למכונה הווירטואלית כשמשתמשים ברשת VPC: ‫compute.subnetworks.useExternalIp בפרויקט או ברשת המשנה שנבחרה
  • כדי להקצות רשת מדור קודם למכונה הווירטואלית: ‫compute.networks.use בפרויקט
  • כדי להקצות כתובת IP חיצונית למכונה הווירטואלית כשמשתמשים ברשת מדור קודם: ‫compute.networks.useExternalIp בפרויקט
  • כדי להגדיר מטא-נתונים של המכונה הווירטואלית: ‫compute.instances.setMetadata בפרויקט
  • כדי להגדיר תגים למכונה הווירטואלית: ‫compute.instances.setTags במכונה הווירטואלית
  • כדי להגדיר תוויות למכונה הווירטואלית: ‫compute.instances.setLabels במכונה הווירטואלית
  • כדי להגדיר חשבון שירות לשימוש של המכונה הווירטואלית: ‫compute.instances.setServiceAccount במכונה הווירטואלית
  • כדי ליצור דיסק חדש למכונה הווירטואלית: ‫compute.disks.create בפרויקט
  • כדי לצרף דיסק קיים במצב קריאה-בלבד או במצב קריאה וכתיבה: ‫compute.disks.use בדיסק
  • כדי לצרף דיסק קיים במצב קריאה-בלבד: ‫compute.disks.useReadOnly בדיסק

יכול להיות שתקבלו את ההרשאות האלה באמצעות תפקידים בהתאמה אישית או תפקידים מוגדרים מראש אחרים.

הכנה ליצירת מכונות וירטואליות זמניות מסוג Spot

לפני שיוצרים מכונות וירטואליות זמניות מסוג Spot בשביל עומס עבודה, צריך לבצע את השלבים הבאים:

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

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

  3. בוחרים שיטה ליצירת מכונות וירטואליות מסוג Spot. מומלץ לבחור שיטה באופן הבא:

    מידע נוסף על המלצות ליצירת מכונות וירטואליות זמניות במודל Spot זמין בשיטות המומלצות.

יצירת VM במודל Spot

אחרי שמתכוננים ליצירת VM במודל Spot, אפשר ליצור VM במודל Spot באחת מהשיטות הבאות.

המסוף

  1. נכנסים לדף Create an instance במסוף Google Cloud .

    כניסה לדף Create an instance

  2. בחלונית Machine configuration (הגדרת המכונה), שפתוחה כברירת מחדל, מבצעים את השלבים הבאים:

    1. בקטע Provisioning model בוחרים באפשרות Spot מהרשימה VM provisioning model. הקטע VM provisioning model advanced settings (הגדרות מתקדמות של מודל הקצאת משאבים למכונה וירטואלית) יורחב.

    2. ברשימה Preemption notice duration, בוחרים אפשרות בהתאם לאופן שבו רוצים לטפל בהפסקת פעולה.

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

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

    3. אופציונלי: כדי לבחור את פעולת הסיום שתתבצע כש-Compute Engine יבצע הקצאה מראש של מכונת ה-VM, בוחרים אחת מהאפשרויות הבאות ברשימה On VM termination:

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

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

    1. בתפריט הניווט, לוחצים על מתקדם.
    2. בקטע Metadata (מטא נתונים), לוחצים על Add item (הוספת פריט).
    3. בשדה מפתח, מזינים shutdown-script כמפתח המטא-נתונים.
    4. בשדה ערך, מוסיפים את התוכן של סקריפט כיבוי שמטפל בהפסקת הפעולה. דוגמה לסקריפט כיבוי מופיעה בקטע דוגמה לטיפול בקדימות במסמך הזה.

  4. אופציונלי: מציינים אפשרויות הגדרה אחרות. מידע נוסף מופיע במאמר אפשרויות הגדרה במהלך יצירת מכונה.

  5. כדי ליצור את המכונה הווירטואלית ולהפעיל אותה, לוחצים על Create.

gcloud

כדי ליצור מכונה וירטואלית באמצעות ה-CLI של gcloud, משתמשים בפקודה gcloud compute instances create. בכל פעם שיוצרים מכונה וירטואלית, מומלץ לציין את סוג המכונה, המיקום ותמונת מערכת ההפעלה.

כדי ליצור VM במודל Spot, כוללים את הדגל --provisioning-model=SPOT. כדי לציין את משך ההתראה על הקצאת משאבים מראש, צריך לכלול את הדגל --preemption-notice-duration, ואם צריך, סקריפט כיבוי. אפשר גם לציין פעולת סיום למכונות וירטואליות מסוג Spot על ידי הוספת הדגל --instance-termination-action.

gcloud compute instances create VM_NAME \
    --machine-type=MACHINE_TYPE \
    --zone=ZONE \
    --image-family=IMAGE_FAMILY \
    --image-project=IMAGE_PROJECT \
    --provisioning-model=SPOT \
    --instance-termination-action=TERMINATION_ACTION \
    --preemption-notice-duration=PREEMPTION_NOTICE_DURATION \
    --metadata shutdown-script=SHUTDOWN_SCRIPT

מחליפים את מה שכתוב בשדות הבאים:

  • ‫VM_NAME: name of the new VM.

  • ‫MACHINE_TYPE: סוג המכונה מוגדר מראש או מותאם אישית של המכונה הווירטואלית החדשה.

  • ‫ZONE: האזור שבו רוצים ליצור את המכונה הווירטואלית. האזור צריך גם לתמוך בסוג המכונה שבה רוצים להשתמש עבור המכונה הווירטואלית החדשה.

  • ‫IMAGE_FAMILY: משפחת תמונות. התמונה הזו מציינת את תמונת מערכת ההפעלה העדכנית ביותר שלא הוצאה משימוש. לדוגמה, אם מציינים את הערך debian-13, נעשה שימוש בגרסה העדכנית ביותר במשפחת תמונות Debian 13. מידע נוסף על שימוש במשפחות תמונות זמין במאמר בנושא שיטות מומלצות לשימוש במשפחות תמונות.

  • ‫IMAGE_PROJECT: הפרויקט שמכיל את התמונה. לדוגמה, אם מציינים את debian-13 כמשפחת התמונות, מציינים את debian-cloud כפרויקט התמונות.

  • ‫TERMINATION_ACTION: אופציונלי: מציינים איזו פעולת סיום תתבצע כש-Compute Engine יבצע preempt למכונה הווירטואלית, או STOP (התנהגות ברירת המחדל) או DELETE.

  • ‫PREEMPTION_NOTICE_DURATION: האם להפעיל משך זמן להודעה על קדימות. ב-CLI של gcloud, הערך צריך להיות 120s או 0s.

    • אם מציינים 120s, צריך לטפל בהקדמה בעומס העבודה. (אופציונלי, אפשר גם לציין סקריפט כיבוי).

    • אם מציינים 0s (ברירת מחדל), צריך לטפל בהקדמה בסקריפט של כיבוי.

  • ‫SHUTDOWN_SCRIPT: סקריפט כיבוי.

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

    • אחרת, אם לא רוצים לציין סקריפט כיבוי, אפשר להסיר את הדגל --metadata shutdown-script.

Terraform

אפשר להשתמש במשאב Terraform כדי ליצור VM במודל Spot באמצעות הבלוק scheduling, כמו בדוגמה הבאה.

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


resource "google_compute_instance" "spot_vm_instance" {
  name         = "spot-instance-name"
  machine_type = "f1-micro"
  zone         = "us-central1-c"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-13"
    }
  }

  scheduling {
    preemptible                 = true
    automatic_restart           = false
    provisioning_model          = "SPOT"
    instance_termination_action = "STOP"
  }

  network_interface {
    # A default network is created for all GCP projects
    network = "default"
    access_config {
    }
  }
}

כדי ללמוד איך להחיל הגדרות ב-Terraform או להסיר אותן, ראו פקודות בסיסיות ב-Terraform.

REST

כדי ליצור מכונה וירטואלית באמצעות Compute Engine API, משתמשים ב-method ‏instances.insert. בכל פעם שיוצרים מכונה וירטואלית, מומלץ לציין את סוג המכונה, המיקום ותמונת מערכת ההפעלה.

כדי ליצור VM במודל Spot, צריך לכלול את השדה "provisioningModel": "SPOT". כדי לציין את משך ההודעה על הקצאת משאבים, צריך לכלול את השדה preemptionNoticeDuration. אופציונלי: אפשר גם לציין פעולת סיום למכונות וירטואליות מסוג Spot על ידי הוספת השדה instanceTerminationAction.

POST https://compute./compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
 "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
 "name": "VM_NAME",
 "disks": [
   {
     "initializeParams": {
       "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
     },
     "boot": true
   }
 ],
 "scheduling":
 {
     "provisioningModel": "SPOT",
     "instanceTerminationAction": "TERMINATION_ACTION",
     "preemptionNoticeDuration": { "seconds": PREEMPTION_NOTICE_DURATION }
 },
"metadata": {
    "items": [
      {
        "key": "shutdown-script",
        "value": "SHUTDOWN_SCRIPT"
      }
    ]
  }
}

מחליפים את מה שכתוב בשדות הבאים:

  • ‫PROJECT_ID: מזהה הפרויקט שבו רוצים ליצור את המכונה הווירטואלית.
  • ‫ZONE: האזור שבו רוצים ליצור את המכונה הווירטואלית. האזור צריך גם לתמוך בסוג המכונה שבה רוצים להשתמש עבור המכונה הווירטואלית החדשה.
  • ‫MACHINE_TYPE: סוג המכונה מוגדר מראש או מותאם אישית של המכונה הווירטואלית החדשה.
  • ‫VM_NAME: השם של המכונה הווירטואלית החדשה.
  • ‫IMAGE_PROJECT: הפרויקט שמכיל את התמונה. לדוגמה, אם מציינים את family/debian-13 כמשפחת התמונות, מציינים את debian-cloud כפרויקט התמונות.

  • ‫IMAGE: מציינים אחת מהאפשרויות הבאות:

    • גרסה ספציפית של תמונה ציבורית. לדוגמה, תמונה ספציפית היא "sourceImage": "projects/debian-cloud/global/images/debian-13-trixie-v20260908", כאשר debian-cloud הוא IMAGE_PROJECT.
    • משפחת תמונות. הפעולה הזו יוצרת את מכונת ה-VM מתמונת מערכת ההפעלה העדכנית ביותר שלא הוצאה משימוש. לדוגמה, אם מציינים "sourceImage": "projects/debian-cloud/global/images/family/debian-13", כאשר debian-cloud הוא IMAGE_PROJECT,‏ Compute Engine יוצר מכונה וירטואלית מהגרסה האחרונה של תמונת מערכת ההפעלה במשפחת התמונות Debian 13.

  • ‫TERMINATION_ACTION: אופציונלי: מציינים איזו פעולת סיום תתבצע כש-Compute Engine יבצע preempt למכונה הווירטואלית, או STOP (התנהגות ברירת המחדל) או DELETE.

  • ‫PREEMPTION_NOTICE_DURATION: האם להפעיל משך זמן להודעה על קדימות. ב-REST, הערך צריך להיות 120 או 0.

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

    • אם מציינים 0 (ברירת מחדל), צריך לטפל בהקדמה בסקריפט של כיבוי.

  • ‫SHUTDOWN_SCRIPT: סקריפט כיבוי.

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

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

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

הפעלת מכונות וירטואליות במודל Spot

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

אם Compute Engine מפסיק מכונה וירטואלית אחת או יותר מסוג Spot בקבוצת מופעי מכונה מנוהלים (MIG) עם התאמה אוטומטית לעומס או באשכול Google Kubernetes Engine‏ (GKE), הקבוצה מפעילה מחדש את המכונות הווירטואליות כשהמשאבים הופכים שוב לזמינים.

זיהוי מודל ההקצאה ופעולת הסיום של מכונה וירטואלית

כדי לראות אם מדובר במכונה וירטואלית רגילה, בVM במודל Spot או בVM זמני, צריך לזהות את מודל הקצאת המשאבים של המכונה הווירטואלית. במקרה של VM במודל Spot, אפשר גם לזהות את פעולת הסיום. אפשר לזהות את מודל ההקצאה של מכונה וירטואלית ואת פעולת הסיום שלה באמצעות מסוףGoogle Cloud , ה-CLI של gcloud או Compute Engine API.

המסוף

  1. נכנסים לדף VM instances.

    לדף VM instances

  2. לוחצים על Name (שם) של המכונה הווירטואלית שרוצים לזהות. ייפתח הדף פרטי המכונה הווירטואלית.

  3. עוברים לקטע ניהול בתחתית הדף. בקטע המשנה Availability policies (מדיניות זמינות), מסמנים את האפשרויות הבאות:

    • אם VM provisioning model מוגדר ל-Spot, המכונה הווירטואלית היא VM במודל Spot.
      • האפשרות On VM termination מציינת איזו פעולה תתבצע כש-Compute Engine יבצע דחיקה של המכונה הווירטואלית, כלומר Stop או Delete של המכונה הווירטואלית.
    • אחרת, אם מודל הקצאת המכונה הווירטואלית מוגדר כרגיל או כ—:
      • אם האפשרות יכולת הפסקה לפני הזמן מוגדרת למופעל, המכונה הווירטואלית היא VM זמני.
      • אחרת, המכונה הווירטואלית היא מכונה וירטואלית רגילה.

gcloud

כדי להוסיף תיאור למכונה וירטואלית באמצעות ה-CLI של gcloud, משתמשים בפקודה gcloud compute instances describe:

gcloud compute instances describe VM_NAME

כאשר VM_NAME הוא השם של המכונה הווירטואלית שרוצים לבדוק.

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

  • אם הפלט כולל את השדה provisioningModel עם הערך SPOT, כמו בדוגמה הבאה, המכונה הווירטואלית היא VM במודל Spot.

    ...
scheduling:
...
provisioningModel: SPOT
instanceTerminationAction: TERMINATION_ACTION
...

    הערך TERMINATION_ACTION מציין איזו פעולה תתבצע כש-Compute Engine יבצע דחיקה של המכונה הווירטואלית: עצירה (STOP) או מחיקה (DELETE) של המכונה הווירטואלית. אם השדה instanceTerminationAction חסר, ערך ברירת המחדל הוא STOP.

  • אחרת, אם הפלט כולל את השדה provisioningModel עם הערך standard או אם הפלט לא כולל את השדה provisioningModel:

    • אם הפלט כולל את השדה preemptible עם הערך true, המכונה הווירטואלית היא VM זמני.
    • אחרת, המכונה הווירטואלית היא מכונה וירטואלית רגילה.

REST

כדי לתאר מכונה וירטואלית מ-Compute Engine API, משתמשים בשיטה instances.get:

GET https://compute./compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME

מחליפים את מה שכתוב בשדות הבאים:

  • ‫PROJECT_ID: מזהה הפרויקט שבו נמצאת המכונה הווירטואלית.
  • ‫ZONE: האזור שבו נמצאת המכונה הווירטואלית.
  • ‫VM_NAME: השם של המכונה הווירטואלית שרוצים לבדוק.

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

  • אם הפלט כולל את השדה provisioningModel עם הערך SPOT, כמו בדוגמה הבאה, המכונה הווירטואלית היא VM במודל Spot.

    {
  ...
  "scheduling":
  {
     ...
     "provisioningModel": "SPOT",
     "instanceTerminationAction": "TERMINATION_ACTION"
     ...
  },
  ...
}

    הערך TERMINATION_ACTION מציין איזו פעולה תתבצע כש-Compute Engine יבצע דחיקה של המכונה הווירטואלית: עצירה (STOP) או מחיקה (DELETE) של המכונה הווירטואלית. אם השדה instanceTerminationAction חסר, ערך ברירת המחדל הוא STOP.

  • אחרת, אם הפלט כולל את השדה provisioningModel עם הערך standard או אם הפלט לא כולל את השדה provisioningModel:

    • אם הפלט כולל את השדה preemptible עם הערך true, המכונה הווירטואלית היא VM זמני.
    • אחרת, המכונה הווירטואלית היא מכונה וירטואלית רגילה.

המשך 


import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	"cloud.google.com/go/compute/apiv1/computepb"
)

// isSpotVM checks if a given instance is a Spot VM or not.
func isSpotVM(w io.Writer, projectID, zone, instanceName string) (bool, error) {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	ctx := context.Background()
	client, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return false, fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer client.Close()

	req := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := client.Get(ctx, req)
	if err != nil {
		return false, fmt.Errorf("GetInstance: %w", err)
	}

	isSpot := instance.GetScheduling().GetProvisioningModel() == computepb.Scheduling_SPOT.String()

	var isSpotMessage string
	if !isSpot {
		isSpotMessage = " not"
	}
	fmt.Fprintf(w, "Instance %s is%s spot\n", instanceName, isSpotMessage)

	return instance.GetScheduling().GetProvisioningModel() == computepb.Scheduling_SPOT.String(), nil
}

Java 


import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Scheduling;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

public class CheckIsSpotVm {
  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "your-project-id";
    // Name of the virtual machine to check.
    String instanceName = "your-route-name";
    // Name of the zone you want to use. For example: "us-west3-b"
    String zone = "your-zone";

    boolean isSpotVm = isSpotVm(projectId, instanceName, zone);
    System.out.printf("Is %s spot VM instance - %s", instanceName, isSpotVm);
  }

  // Check if a given instance is Spot VM or not.
  public static boolean isSpotVm(String projectId, String instanceName, String zone)
          throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient client = InstancesClient.create()) {
      Instance instance = client.get(projectId, zone, instanceName);

      return instance.getScheduling().getProvisioningModel()
              .equals(Scheduling.ProvisioningModel.SPOT.name());
    }
  }
}

Python 

from google.cloud import compute_v1


def is_spot_vm(project_id: str, zone: str, instance_name: str) -> bool:
    """
    Check if a given instance is Spot VM or not.
    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone you want to use. For example: "us-west3-b"
        instance_name: name of the virtual machine to check.
    Returns:
        The Spot VM status of the instance.
    """
    instance_client = compute_v1.InstancesClient()
    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )
    return (
        instance.scheduling.provisioning_model
        == compute_v1.Scheduling.ProvisioningModel.SPOT.name
    )

ניהול של הפסקת השימוש במכונות Spot VM

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

השתלטות על כינוי

כש-Compute Engine מתחיל להפסיק מכונת Spot VM, אפשר לנסות לבצע פעולות ניקוי לפני שהמכונה הווירטואלית מסיימת את ההשבתה. הטיפול בהקדמה יכול לכלול עצירה מסודרת של תהליך שפועל והעברה של מצב עומס העבודה.

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

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

דוגמה לטיפול בהקדמה

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

#!/bin/bash

MY_PROGRAM="PROGRAM_NAME" # For example, "apache2" or "nginx"
MY_USER="LOCAL_USER"
CHECKPOINT="/home/$MY_USER/checkpoint.out"
BUCKET_NAME="BUCKET_NAME" # For example, "my-checkpoint-files" (without gs://)

echo "Shutting down!  Seeing if ${MY_PROGRAM} is running."

# Find the newest copy of $MY_PROGRAM
PID="$(pgrep -n "$MY_PROGRAM")"

if [[ "$?" -ne 0 ]]; then
  echo "${MY_PROGRAM} not running, shutting down immediately."
  exit 0
fi

echo "Sending SIGINT to $PID"
kill -2 "$PID"

# Portable waitpid equivalent
while kill -0 "$PID"; do
   sleep 1
done

echo "$PID is done, copying ${CHECKPOINT} to gs://${BUCKET_NAME} as ${MY_USER}"

su "${MY_USER}" -c "gcloud storage cp $CHECKPOINT gs://${BUCKET_NAME}/"

echo "Done uploading, shutting down."

הסקריפט הזה יוצא מנקודת הנחה לגבי הדברים הבאים:

  • המכונה הווירטואלית נוצרה עם גישת קריאה או כתיבה לפחות ל-Cloud Storage. הוראות ליצירת מכונה וירטואלית עם ההיקפים המתאימים זמינות במסמכי האימות.

  • יש לכם קטגוריה של Cloud Storage קיימת והרשאה לכתוב בה.

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

  1. מעתיקים או מורידים את הסקריפט לדוגמה:

    • מעתיקים את הסקריפט הקודם אחרי שמחליפים את הערכים הבאים:

      • ‫PROGRAM_NAME: השם של התהליך או התוכנית שרוצים לסגור. לדוגמה, apache2 או nginx.
      • ‫LOCAL_USER: שם המשתמש שדרכו נכנסתם למכונה הווירטואלית.
      • ‫BUCKET_NAME: השם של הקטגוריה ב-Cloud Storage שבה רוצים לשמור את קובץ נקודת הבדיקה של התוכנית. שימו לב שבמקרה הזה שם הקטגוריה לא מתחיל ב-gs://.

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

      • ‫PROGRAM_NAME: השם של התהליך או התוכנית שרוצים לסגור. לדוגמה, apache2 או nginx.
      • ‫LOCAL_USER: שם המשתמש שדרכו נכנסתם למכונה הווירטואלית.
      • ‫BUCKET_NAME: השם של הקטגוריה ב-Cloud Storage שבה רוצים לשמור את קובץ נקודת הבדיקה של התוכנית. שימו לב שבמקרה הזה שם הקטגוריה לא מתחיל ב-gs://.

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

זיהוי של הפסקת פעולה של מכונות וירטואליות במודל Spot

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

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

זיהוי מצב עדיפות למניעה במכונה וירטואלית

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

  • אם אתם מטפלים בהפקעה בסקריפט כיבוי, בדקו את הערך הנוכחי של preempted. אתם יכולים להריץ את הפקודה הבאה של curl מתוך המכונה הווירטואלית כדי לקבל את הערך הנוכחי של preempted:

    curl "http://metadata.google.internal/computeMetadata/v1/instance/preempted" -H "Metadata-Flavor: Google"
TRUE

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

  • אם אתם מטפלים בהפקעה בעומס העבודה, צריך לחכות עד שהערך של preempted יהיה TRUE. כדי להמתין עד ש-preempted יהיה TRUE, אפשר לצרף את פרמטר השאילתה ?wait_for_change=true לכתובת ה-URL של הפקודה הקודמת. עם הפרמטר הזה של השאילתה, הפקודה מבצעת בקשת HTTP GET תלויה שמחזירה ערך רק כשהמטא-נתונים השתנו והמכונה הווירטואלית נדחקה.

    curl "http://metadata.google.internal/computeMetadata/v1/instance/preempted?wait_for_change=true" -H "Metadata-Flavor: Google"
TRUE

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

הצגת פעולות של קדימות

אפשר לראות את פעולות ההפקעה מ-Compute Engine באמצעותGoogle Cloud console,‏ ה-CLI של gcloud או Compute Engine API.

המסוף

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

  1. נכנסים לדף Logs במסוף Google Cloud .

    כניסה לדף Logs

  2. בוחרים פרויקט ולוחצים על המשך.

  3. מוסיפים compute.instances.preempted לשדה סינון לפי תווית או חיפוש טקסט.

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

  5. מקישים על Enter כדי להחיל את המסננים שצוינו. במסוף Google Cloud מתעדכנת רשימת היומנים ומוצגות רק הפעולות שבהן בוצעה קדימה למכונה וירטואלית.

  6. בוחרים פעולה ברשימה כדי לראות פרטים על מכונת ה-VM שנשללה ממנה זכות הקדימה.

gcloud

משתמשים בפקודה gcloud compute operations list עם פרמטר filter כדי לקבל רשימה של אירועי קדימות בפרויקט.

gcloud compute operations list \
    --filter="operationType=compute.instances.preempted"

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

gcloud compute operations list \
    --filter="operationType=compute.instances.preempted AND targetLink:instances/BASE_INSTANCE_NAME"

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

הפלט אמור להיראות כך:

NAME                  TYPE                         TARGET                                        HTTP_STATUS STATUS TIMESTAMP
systemevent-yyyyyyyy  compute.instances.preempted  us-central1-f/instances/example-instance-yyy  200         DONE   2015-04-02T12:12:10.881-07:00

סוג הפעולה compute.instances.preempted מציין שבוצעה קדימה למכונה הווירטואלית. אפשר להשתמש בפקודה gcloud compute operations describe כדי לקבל מידע נוסף על פעולת דחיקה ספציפית.

gcloud compute operations describe SYSTEM_EVENT \
    --zone=ZONE

מחליפים את מה שכתוב בשדות הבאים:

  • ‫SYSTEM_EVENT: אירוע המערכת מהפלט של הפקודה gcloud compute operations list. לדוגמה: systemevent-yyyyyyyy.
  • ‫ZONE: האזור של אירוע המערכת, לדוגמה: us-central1-f.

הפלט אמור להיראות כך:

...
operationType: compute.instances.preempted
progress: 100
selfLink: https://compute./compute/v1/projects/my-project/zones/us-central1-f/operations/systemevent-yyyyyyyy
startTime: '2015-04-02T12:12:10.881-07:00'
status: DONE
statusMessage: Instance was preempted.
...

REST

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

GET https://compute./compute/v1/projects/PROJECT_ID/zones/ZONE/operations

מחליפים את מה שכתוב בשדות הבאים:

אופציונלי: כדי לצמצם את היקף התגובה כך שיוצגו רק פעולות של קדימות, אפשר להוסיף מסנן לבקשת ה-API:

operationType="compute.instances.preempted"

לחלופין, כדי לראות פעולות של קדימות ל-VM ספציפי, מוסיפים פרמטר targetLink למסנן:

operationType="compute.instances.preempted" AND
targetLink="https://www./compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME

מחליפים את הערכים הבאים: + PROJECT_ID: מזהה הפרויקט. ‫+ ZONE: האזור. ‫+ VM_NAME: השם של מכונה וירטואלית ספציפית באזור ובפרויקט הזה.

התגובה מכילה רשימה של פעולות מהזמן האחרון. לדוגמה, דחיקה תיראה כך:

{
  "kind": "compute#operation",
  "id": "15041793718812375371",
  "name": "systemevent-yyyyyyyy",
  "zone": "https://www./compute/v1/projects/my-project/zones/us-central1-f",
  "operationType": "compute.instances.preempted",
  "targetLink": "https://www./compute/v1/projects/my-project/zones/us-central1-f/instances/example-instance",
  "targetId": "12820389800990687210",
  "status": "DONE",
  "statusMessage": "Instance was preempted.",
  ...
}

בדיקת הגדרות הקדימות

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

שיטות מומלצות

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

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

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

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

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

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

  • בוחרים סוגי מכונות קטנים יותר. המשאבים למכונות וירטואליות מסוג Spot מגיעים מקיבולת עודפת ומגיבוי Google Cloud . לרוב קל יותר להשיג קיבולת למכונות וירטואליות מסוג Spot עבור סוגי מכונות קטנים יותר, כלומר סוגי מכונות עם פחות משאבים כמו vCPU וזיכרון. יכול להיות שתמצאו יותר קיבולת למכונות וירטואליות מסוג Spot אם תבחרו סוג מכונה מותאם אישית קטן יותר, אבל סביר יותר שתמצאו קיבולת אם תבחרו סוג מכונה מוגדר מראש קטן יותר. לדוגמה, בהשוואה לקיבולת של מכונה עם קונפיגורציה מוגדרת (predefined) n2-standard-32, סביר יותר שתהיה קיבולת לסוג המכונה n2-custom-24-96 בהתאמה אישית, אבל סביר עוד יותר שתהיה קיבולת למכונה עם קונפיגורציה מוגדרת (predefined) n2-standard-16.

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

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

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

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

מה השלב הבא?