יצירה והפעלה של משימה שמשתמשת במעבדים גרפיים

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

כשיוצרים משימה ב-Batch, אפשר להשתמש במעבדי GPU כדי להאיץ עומסי עבודה ספציפיים. תרחישי שימוש נפוצים למשימות שמשתמשות במעבדי GPU כוללים עיבוד נתונים אינטנסיבי ועומסי עבודה של בינה מלאכותית (AI) כמו למידת מכונה (ML). לחלופין, אתם יכולים להאיץ עומסי עבודה של AI ו-ML באמצעות שימוש ביחידות TPU.

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

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

  2. כדי לקבל את ההרשאות שדרושות ליצירת משימה, צריך לבקש מהאדמין להקצות לכם את התפקידים הבאים ב-IAM:

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

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

יצירת משימה שמשתמשת ב-GPU

כדי ליצור משימה שמשתמשת ב-GPU:

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

תכנון ההגדרות של משימה שמשתמשת במעבדים גרפיים

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

  1. בחירת סוג המכונה של ה-GPU ואפשרות הצריכה
  2. התקנת מנהלי ההתקנים של ה-GPU
  3. הגדרת משאבי VM תואמים

שלב 1: בוחרים את סוג המכונה של ה-GPU ואת אפשרות הצריכה

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

כדי לבחור את סוג המכונה של ה-GPU ואת אפשרות הצריכה של המשימה:

  1. מזהים ובוחרים את רמת העדיפות:

  2. בוחרים את האפשרות השנייה בהתאם למה שתואם לבחירה הראשונה.

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

    2. בהתאמה, עיינו בקטע בחירת אפשרות הצריכה או בקטע בחירת סוג המכונה של ה-GPU.

בוחרים את סוג המכונה של ה-GPU

כדי לבחור את סוג מכונת ה-GPU למשימה ולהבין את הדרישות שלה, בצעו את השלבים הבאים:

  1. בחירת סוג מכונה עם GPU: כדי לבדוק את סוגי המכונות עם GPU שזמינים (השילובים התקינים של סוג GPU, מספר יחידות ה-GPU וסוג המכונה (vCPUs וזיכרון)) ואת התרחישים לדוגמה שמומלצים להם, קראו את המאמרים סוגי מכונות עם GPU ומשפחת מכונות עם אופטימיזציה למאיצים במסמכי התיעוד של Compute Engine.

  2. הבנת הדרישות של המשימה לסוג מכונת ה-GPU: השדות שנדרשים למשימה כדי לציין סוג מכונת GPU משתנים בהתאם לקטגוריות בטבלה הבאה:

    סוגי מכונות GPU והדרישות שלהן לעבודה

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

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

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

    מעבדי GPU למכונות וירטואליות מסוג N1: במעבדי ה-GPU האלה צריך לציין את הסוג והכמות שרוצים לצרף לכל מכונה וירטואלית, וצריך לצרף אותם למכונות וירטואליות עם סוג מכונה מסדרת המכונות N1.

    כדי להשתמש במעבדי GPU למכונות וירטואליות מסוג N1, מומלץ לציין לפחות את סוג מעבדי ה-GPU ואת מספר מעבדי ה-GPU. חשוב לוודא ששילוב הערכים תואם לאחת מאפשרויות ה-GPU החוקיות לסוגי המכונות N1. אפשרויות ה-vCPU והזיכרון למכונות וירטואליות מסוג N1 שמשתמשות בסוג ובמספר ספציפיים של מעבדי GPU הן גמישות למדי. אם לא יוצרים את המשימה באמצעות מסוף Google Cloud , אפשר לאפשר ל-Batch לבחור באופן אוטומטי סוג מכונה שעומד בדרישות המשימה.
בוחרים את אפשרות הצריכה

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

בטבלה הבאה מוסברות אפשרויות הצריכה הזמינות ל-Batch והדרישות שלהן למשימות. בטבלה הבאה מפורטות אפשרויות הצריכה לפי תרחישי השימוש שלהן, מהאפשרות הכי זמינה ועד לאפשרות הכי פחות זמינה. חשוב לוודא שאפשרות הצריכה שבוחרים עומדת גם בדרישות שלכם לגבי תמחור, זמן ריצה ותמיכה בסוגי מכונות. למידע נוסף על בחירת אפשרות צריכה, קראו את המאמרים שיפור הזמינות של משאבים, הקצאת מודלים ב-Compute Engine ואפשרויות צריכה ב-AI Hypercomputer.

אפשרויות צריכה ודרישות התפקיד שלהן

הזמנות

  • תרחיש לדוגמה: מומלץ להשתמש בהזמנות למשימות אם אתם רוצים רמה גבוהה מאוד של ודאות לגבי זמינות המשאבים, ואתם לא יכולים להשתמש בהזמנות במצב תזמון, או אם כבר יש לכם הזמנות קיימות שאולי לא בשימוש.

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

    מידע נוסף על הזמנות במאמרי העזרה של Compute Engine.

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

הזמנות במצב תזמון

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

  • פרטים: לפני שיוצרים משימה, צריך לבקש או לזהות הזמנה במצב תזמון שאפשר להשתמש בה. אם Compute Engine ממלא בקשה למקום שמור לעתיד במצב תזמון, העלות של המקום השמור שנוצר אוטומטית במצב תזמון זהה לעלות של הפעלת המכונות הווירטואליות שצוינו לכל תקופת השמירה, לפי התמחור של מתזמן המשימות לפריסת workload דינמית (DWS), שמציע הנחות של עד 53% מהתמחור על פי דרישה. אחרי שזיהיתם הקצאה שנוצרה באופן אוטומטי במצב תזמון, אתם יכולים ליצור משימה שמשתמשת בהקצאה במצב תזמון, בדומה ליצירת משימה שמשתמשת בהקצאה.

    מידע נוסף על הקצאת מקום במצב תזמון במאמרי העזרה של Compute Engine.

ב-Batch, המערכת משתמשת בהזמנות במצב תזמון למשימות שעומדות בכל התנאים הבאים:

מכונות וירטואליות מסוג Flex-start

  • תרחיש לדוגמה: מומלץ להשתמש ב-Flex-start VM אם המשימה יכולה לעמוד בזמינות על בסיס מאמץ סביר (best-effort) בתמורה למחיר מוזל, ועד 7 ימים להשלמת ההרצה.

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

  • פרטים: אם בקשה ליצירת משימה שמשתמשת ב-Flex-start VM מתמלאת, המכונות הווירטואליות מחויבות לפי התמחור של מתזמן משימות לפריסת workload דינמית (DWS), שמציע הנחות של עד 53% מהתמחור על פי דרישה.

    מידע נוסף על מכונות וירטואליות מסוג Flex-start במאמרי העזרה של Compute Engine.

ב-Batch, משתמשים ב-Flex-start VM למשימות שעומדות בכל התנאים הבאים:

על פי דרישה

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

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

כברירת מחדל, ב-Batch נעשה שימוש במשאבים על פי דרישה ברוב המשימות. כדי לוודא שהמשימה משתמשת בתמחור על פי דרישה, צריך לבצע את כל הפעולות הבאות:1

‫1חריג: במשימות שמשתמשות בסדרת המכונות A3, פעולת ברירת המחדל היא ייחודית, ואנחנו ממליצים לא להשתמש במכונות על פי דרישה ולא להשאיר את השדה provisioningModel לא מוגדר. במקום זאת, השתמשו בדרישות המשימה למכונות וירטואליות מסוג Flex-start. לא מומלץ להשתמש במכונות מסדרת A3 על פי דרישה, כי זמינות המשאבים נמוכה. לכן, אם במשימה משתמשים בסדרת המכונות A3, חוסמים מקום שמור והשדה provisioningModel לא מוגדר או מוגדר כ-STANDARD, אפשרות ברירת המחדל לצריכה היא ייחודית: ההתנהגות דומה למכונות וירטואליות מסוג Flex-start VM, שמגבילות את זמן הריצה ל-7 ימים. עם זאת, לא מומלץ להשתמש באפשרות הזו כי המשימות האלה לא מקבלות הנחות מהתמחור של מתזמן משימות לפריסת workload דינמית (DWS). אם המשימה שלכם עם מכונות וירטואליות מסוג A3 יכולה לפעול עד 7 ימים, מומלץ להשתמש במכונות וירטואליות מסוג Flex-start במקום במכונות וירטואליות על פי דרישה. אחרת, אי אפשר להבטיח שמשימות עם מכונות וירטואליות מסוג A3 ישתמשו במשאבים על פי דרישה, אלא אם מגדירים את provisioningModel לערך STANDARD ומוודאים באופן ידני שהמשימה לא יכולה לצרוך מקומות שמורים, בלי להגדיר את השדה reservation לערך NO_RESERVATION.

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

  • תרחיש שימוש: מומלץ להשתמש ב-VM במודל Spot כדי להפחית את העלויות של עומסי עבודה עמידים בכשלים.

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

    מידע נוסף על VM במודל Spot והמלצות למשימות עם VM במודל Spot.

Batch משתמש ב-VM במודל Spot למשימות שעומדות בכל התנאים הבאים:

שלב 2: מתקינים את מנהלי ההתקנים של ה-GPU

כדי להשתמש במעבדי GPU למשימה, צריך להתקין את מנהלי ההתקנים של ה-GPU. כדי להתקין מנהלי התקנים של GPU, בוחרים באחת מהשיטות הבאות:

שלב 3: הגדרת משאבים תואמים של מכונות וירטואליות

במאמר משאבי משימה מוסבר על הדרישות והאפשרויות להגדרת משאבי ה-VM של משימה.

לסיכום, כשמגדירים את משאבי ה-VM למשימה שמשתמשת במעבדי GPU, צריך לבצע את כל הפעולות הבאות:

  • מוודאים שסוג המכונה של ה-GPU זמין במיקום של המכונות הווירטואליות של המשימה.

    כדי לדעת איפה אפשר להשתמש בסוגי מכונות עם GPU, קראו את המאמר מיקומי GPU במאמרי העזרה של Compute Engine.

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

  • חשוב להגדיר את משאבי ה-VM של המשימה באמצעות שיטה תקינה:

    • להגדיר את משאבי ה-VM ישירות באמצעות השדה instances[].policy (מומלץ אם אפשר). השיטה הזו מוצגת בדוגמאות.
    • הגדרת משאבי VM באמצעות תבנית, בעזרת השדה instances[].instanceTemplate. השיטה הזו נדרשת כדי להתקין באופן ידני מנהלי התקנים של GPU באמצעות קובץ אימג' בהתאמה אישית. מידע נוסף זמין במאמר הגדרת משאבי משימה באמצעות תבנית של הגדרות מכונה של VM.

יצירת משימה שמשתמשת ב-GPU

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

אפשרות צריכה הוראות לדוגמה למשימה
הזמנות או הזמנות במצב תזמון

איך מוודאים שיהיו משאבים זמינים באמצעות שמירת מקום למכונות וירטואליות
מכונות וירטואליות מסוג Flex-start

שימוש ב-GPU וב-Flex-start VM
מכונות וירטואליות על פי דרישה או מכונות וירטואליות במודל Spot

בוחרים באחת מהאפשרויות הבאות, בהתאם לסוג המכונה של ה-GPU:

שימוש ב-GPU וב-Flex-start VM

אתם יכולים ליצור משימה שמשתמשת ב-GPUs למכונות וירטואליות מסוג A3 באמצעות מתזמן משימות לפריסת workload דינמית (DWS), דרך ה-CLI של gcloud או Batch API.

gcloud

  1. יוצרים קובץ JSON שמתקין מנהלי התקנים של GPU, מציין סוג מכונה של GPU שתומך ב-Flex-start VM, חוסם הזמנות ופועל במיקום שתומך בסוג המכונה של ה-GPU.

    לדוגמה, כדי ליצור משימת סקריפט בסיסית שמשתמשת ב-Flex-start VM ובמעבדי GPU למכונות וירטואליות עם אופטימיזציה למאיצים, יוצרים קובץ JSON עם התוכן הבא.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

    • ‫INSTALL_GPU_DRIVERS: אם להתקין באופן אוטומטי מנהלי התקנים של GPU. אם הערך הוא true, המערכת של Batch מאחזרת את מנהלי ההתקנים שנדרשים לסוג ה-GPU שציינתם בשדה policy ממיקום של צד שלישי, ומתקינה אותם בשבילכם. אם מגדירים את השדה הזה לערך false (ברירת המחדל), צריך להתקין את מנהלי ההתקנים של ה-GPU באופן ידני כדי להשתמש ב-GPU כלשהו במשימה הזו.

    • ‫MACHINE_TYPE: סוג מכונה עם GPU שתומך ב-Flex-start VM. למידע נוסף, קראו את המאמר זמינות של אפשרויות צריכה לפי סוג מכונה במשאבי העזרה של Compute Engine.

    • ‫ALLOWED_LOCATIONS: המיקומים המותרים למשימה. מוודאים שבמיקום של משאבי Compute Engine של המשימה יש את סוג המכונה עם ה-GPU שרוצים להשתמש בו במשימה, באחת מהדרכים הבאות:

      • כברירת מחדל, אם משמיטים את השדה allowedLocations[], המשימה פועלת במשאבי Compute Engine שנוצרו באזור של מיקום המשימה (LOCATION).
      • אם כוללים את השדה allowedLocations[], אפשר להריץ את המשימה רק במשאבי Compute Engine שנוצרו במיקומים שצוינו.

  2. כדי ליצור ולהריץ את המשימה, משתמשים בפקודה gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

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

    • ‫JOB_NAME: שם המשימה.

    • ‫LOCATION: המיקום של המשימה.

    • ‫JSON_CONFIGURATION_FILE: הנתיב לקובץ JSON עם פרטי ההגדרות של המשימה.

API

שולחים בקשת POST לmethod jobs.create שמתקינה מנהלי התקנים של GPU, מציינת סוג מכונה של GPU שתומך במכונות Flex-start VM, חוסמת הזמנות ופועלת במיקום שתומך בסוג המכונה של ה-GPU.

לדוגמה, כדי ליצור משימת סקריפט בסיסית שמשתמשת במכונות וירטואליות מסוג Flex-start ובמעבדי GPU למכונות וירטואליות עם אופטימיזציה למאיצים, שולחים את הבקשה הבאה:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

  • ‫PROJECT_ID: מזהה הפרויקט שלכם.

  • ‫LOCATION: המיקום של המשימה.

  • ‫JOB_NAME: שם המשימה.

  • ‫INSTALL_GPU_DRIVERS: אם להתקין באופן אוטומטי מנהלי התקנים של GPU. אם הערך הוא true, המערכת של Batch מאחזרת את מנהלי ההתקנים שנדרשים לסוג ה-GPU שציינתם בשדה policy ממיקום של צד שלישי, ומתקינה אותם בשבילכם. אם מגדירים את השדה הזה לערך false (ברירת המחדל), צריך להתקין את מנהלי ההתקנים של ה-GPU באופן ידני כדי להשתמש במעבדי GPU במשימה הזו.

  • ‫MACHINE_TYPE: סוג מכונה עם GPU שתומך ב-Flex-start VM. למידע נוסף, קראו את המאמר זמינות של אפשרויות צריכה לפי סוג מכונה במשאבי העזרה של Compute Engine.

  • ‫ALLOWED_LOCATIONS: המיקומים המותרים למשימה. מוודאים שבמיקום של משאבי Compute Engine של המשימה יש את סוג המכונה עם ה-GPU שרוצים להשתמש בו במשימה, באחת מהדרכים הבאות:

    • כברירת מחדל, אם משמיטים את השדה allowedLocations[], המשימה פועלת במשאבי Compute Engine שנוצרו באזור של מיקום המשימה (LOCATION).
    • אם כוללים את השדה allowedLocations[], אפשר להריץ את המשימה רק במשאבי Compute Engine שנוצרו במיקומים שצוינו.

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

אתם יכולים ליצור משימה שמשתמשת ב-GPU למכונות וירטואליות עם אופטימיזציה למאיצים באמצעות מסוףGoogle Cloud , ה-CLI של gcloud,‏ Batch API,‏ Java,‏ Node.js או Python.

המסוף

כדי ליצור משימה שמשתמשת ב-GPU באמצעות מסוף Google Cloud :

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

    מעבר לרשימת המשימות

  2. לוחצים על Create. נפתח הדף Create batch job. בחלונית הימנית, הדף Job details נבחר.

  3. מגדירים את הדף Job details:

    1. אופציונלי: בשדה Job name, משנים את שם המשימה.

      לדוגמה, מזינים example-gpu-job.

    2. מגדירים את הקטע Task details:

      1. בחלון New runnable, מוסיפים לפחות סקריפט או קונטיינר אחד כדי להריץ את המשימה.

        לדוגמה, כדי ליצור משימת סקריפט בסיסית:

        1. מסמנים את התיבה סקריפט. מופיע שדה.

        2. בשדה, מזינים את הסקריפט הבא:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. לוחצים על סיום.

      2. בשדה Task count, מזינים את מספר המשימות של המשימה הזו.

        לדוגמה, מזינים 3.

      3. אופציונלי: בשדה Parallelism, מזינים את מספר המשימות שרוצים להריץ בו-זמנית.

        לדוגמה, מזינים 1 (ברירת המחדל).

  4. מגדירים את הדף Resource specifications:

    1. בחלונית הימנית, לוחצים על מפרטי משאבים. הדף מפרט המשאבים ייפתח.

    2. בקטע VM provisioning model, בוחרים אחת מהאפשרויות הבאות לאפשרות הצריכה של המכונות הווירטואליות של המשימה:

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

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

    3. בוחרים את המיקום של המשימה.

      1. בשדה Region, בוחרים אזור.

      2. בשדה Zone, מבצעים אחת מהפעולות הבאות:

        • אם רוצים להגביל את המשימה כך שתרוץ רק באזור ספציפי, בוחרים אזור.

        • אחרת, בוחרים באפשרות כלשהו (ברירת המחדל).

    4. בוחרים את סוג המכונה של ה-GPU למכונות הווירטואליות של המשימה:

      1. באפשרויות של משפחת המכונות, לוחצים על GPUs.

      2. בשדה GPU type, בוחרים את סוג ה-GPU. אחר כך, בשדה Number of GPUs, בוחרים את מספר יחידות ה-GPU לכל מכונה וירטואלית.

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

      3. כדי להתקין באופן אוטומטי מנהלי התקנים של GPU, בוחרים באפשרות GPU driver installation (ברירת המחדל).

    5. מגדירים את כמות המשאבים של המכונה הווירטואלית שנדרשים לכל משימה:

      1. בשדה Cores, מזינים את מספר ה-vCPUs לכל משימה.

        לדוגמה, מזינים 1 (ברירת המחדל).

      2. בשדה Memory, מזינים את כמות ה-RAM ב-GB לכל משימה.

        לדוגמה, מזינים 0.5 (ברירת המחדל).

    6. לוחצים על סיום.

  5. אופציונלי: מגדירים את השדות האחרים של המשימה.

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

  7. לוחצים על יצירה.

    בדף Job details מוצגת המשימה שיצרתם.

gcloud

  1. יוצרים קובץ JSON שמתקין מנהלי התקנים של GPU, מציין סוג מכונה ממשפחת המכונות שמותאמות למאיצים ופועל במיקום שבו יש סוג מכונה עם GPU.

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

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

    • ‫INSTALL_GPU_DRIVERS: אם להתקין באופן אוטומטי מנהלי התקנים של GPU. אם הערך הוא true, המערכת של Batch מאחזרת את מנהלי ההתקנים שנדרשים לסוג ה-GPU שציינתם בשדה policy ממיקום של צד שלישי, ומתקינה אותם בשבילכם. אם מגדירים את השדה הזה לערך false (ברירת המחדל), צריך להתקין את מנהלי ההתקנים של ה-GPU באופן ידני כדי להשתמש ב-GPU כלשהו במשימה הזו.

    • ‫PROVISIONING_MODEL: מודל ההקצאה של אפשרות הצריכה: STANDARD לפי דרישה או SPOT למכונות וירטואליות במודל Spot.

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

    • ‫ALLOWED_LOCATIONS: המיקומים המותרים למשימה. מוודאים שבמיקום של משאבי Compute Engine של המשימה יש את סוג המכונה עם ה-GPU שרוצים להשתמש בו במשימה, באחת מהדרכים הבאות:

      • כברירת מחדל, אם משמיטים את השדה allowedLocations[], המשימה פועלת במשאבי Compute Engine שנוצרו באזור של מיקום המשימה (LOCATION).
      • אם כוללים את השדה allowedLocations[], אפשר להריץ את המשימה רק במשאבי Compute Engine שנוצרו במיקומים שצוינו.

  2. כדי ליצור ולהריץ את המשימה, משתמשים בפקודה gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

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

    • ‫JOB_NAME: שם המשימה.

    • ‫LOCATION: המיקום של המשימה.

    • ‫JSON_CONFIGURATION_FILE: הנתיב לקובץ JSON עם פרטי ההגדרות של המשימה.

API

שולחים בקשת POST ל-method jobs.create שמתקינה מנהלי התקנים של GPU, מציינת סוג מכונה ממשפחת המכונות שעברו אופטימיזציה למאיצים, ופועלת במיקום שבו נמצא סוג המכונה של ה-GPU.

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

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

  • ‫PROJECT_ID: מזהה הפרויקט שלכם.

  • ‫LOCATION: המיקום של המשימה.

  • ‫JOB_NAME: שם המשימה.

  • ‫INSTALL_GPU_DRIVERS: אם להתקין באופן אוטומטי מנהלי התקנים של GPU. אם הערך הוא true, המערכת של Batch מאחזרת את מנהלי ההתקנים שנדרשים לסוג ה-GPU שציינתם בשדה policy ממיקום של צד שלישי, ומתקינה אותם בשבילכם. אם מגדירים את השדה הזה לערך false (ברירת המחדל), צריך להתקין את מנהלי ההתקנים של ה-GPU באופן ידני כדי להשתמש ב-GPU כלשהו במשימה הזו.

  • ‫PROVISIONING_MODEL: מודל ההקצאה של אפשרות הצריכה: STANDARD לפי דרישה או SPOT למכונות וירטואליות במודל Spot.

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

  • ‫ALLOWED_LOCATIONS: המיקומים המותרים למשימה. מוודאים שבמיקום של משאבי Compute Engine של המשימה יש את סוג המכונה עם ה-GPU שרוצים להשתמש בו במשימה, באחת מהדרכים הבאות:

    • כברירת מחדל, אם משמיטים את השדה allowedLocations[], המשימה פועלת במשאבי Compute Engine שנוצרו באזור של מיקום המשימה (LOCATION).
    • אם כוללים את השדה allowedLocations[], אפשר להריץ את המשימה רק במשאבי Compute Engine שנוצרו במיקומים שצוינו.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJob {

  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 region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // Accelerator-optimized machine types are available to Batch jobs. See the list
    // of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
    String machineType = "g2-standard-4";

    createGpuJob(projectId, region, jobName, installGpuDrivers, machineType);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String machineType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType(machineType).build();  

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(instancePolicy)
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-l4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'g2-standard-4';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJob();

Python 

from google.cloud import batch_v1


def create_gpu_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "g2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "g2-standard-4"

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

שימוש ב-GPU במכונות וירטואליות מסוג N1

אתם יכולים ליצור משימה שמשתמשת ב-GPU למכונות וירטואליות מסוג N1 באמצעות מסוף Google Cloud , ה-CLI של gcloud,‏ Batch API,‏ Java,‏ Node.js או Python.

המסוף

כדי ליצור משימה שמשתמשת ב-GPU באמצעות מסוף Google Cloud :

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

    מעבר לרשימת המשימות

  2. לוחצים על Create. נפתח הדף Create batch job. בחלונית הימנית, הדף Job details נבחר.

  3. מגדירים את הדף Job details:

    1. אופציונלי: בשדה Job name, משנים את שם המשימה.

      לדוגמה, מזינים example-gpu-job.

    2. מגדירים את הקטע Task details:

      1. בחלון New runnable, מוסיפים לפחות סקריפט או קונטיינר אחד כדי להריץ את המשימה.

        לדוגמה, כדי ליצור משימת סקריפט בסיסית:

        1. מסמנים את התיבה סקריפט. מופיע שדה.

        2. בשדה, מזינים את הסקריפט הבא:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. לוחצים על סיום.

      2. בשדה Task count, מזינים את מספר המשימות של המשימה הזו.

        לדוגמה, מזינים 3.

      3. אופציונלי: בשדה Parallelism, מזינים את מספר המשימות שרוצים להריץ בו-זמנית.

        לדוגמה, מזינים 1 (ברירת המחדל).

  4. מגדירים את הדף Resource specifications:

    1. בחלונית הימנית, לוחצים על מפרטי משאבים. הדף מפרט המשאבים ייפתח.

    2. בקטע VM provisioning model, בוחרים אחת מהאפשרויות הבאות לאפשרות הצריכה של המכונות הווירטואליות של המשימה:

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

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

    3. בוחרים את המיקום של המשימה.

      1. בשדה Region, בוחרים אזור.

      2. בשדה Zone, מבצעים אחת מהפעולות הבאות:

        • אם רוצים להגביל את המשימה כך שתרוץ רק באזור ספציפי, בוחרים אזור.

        • אחרת, בוחרים באפשרות כלשהו (ברירת המחדל).

    4. בוחרים את סוג המכונה של ה-GPU למכונות הווירטואליות של המשימה:

      1. באפשרויות של משפחת המכונות, לוחצים על GPUs.

      2. בשדה GPU type, בוחרים את סוג ה-GPU.

        אם בחרתם באחד מסוגי ה-GPU למכונות וירטואליות מסוג N1, השדה Series מוגדר ל-N1.

      3. בשדה Number of GPUs, בוחרים את מספר יחידות ה-GPU לכל VM.

      4. בשדה Machine type, בוחרים את סוג המכונה.

      5. כדי להתקין באופן אוטומטי מנהלי התקנים של GPU, בוחרים באפשרות GPU driver installation (ברירת המחדל).

    5. מגדירים את כמות המשאבים של המכונה הווירטואלית שנדרשים לכל משימה:

      1. בשדה Cores, מזינים את מספר ה-vCPUs לכל משימה.

        לדוגמה, מזינים 1 (ברירת המחדל).

      2. בשדה Memory, מזינים את כמות ה-RAM ב-GB לכל משימה.

        לדוגמה, מזינים 0.5 (ברירת המחדל).

    6. לוחצים על סיום.

  5. אופציונלי: מגדירים את השדות האחרים של המשימה.

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

  7. לוחצים על יצירה.

    בדף Job details מוצגת המשימה שיצרתם.

gcloud

  1. יוצרים קובץ JSON שמתקין את מנהלי ההתקנים של ה-GPU, מגדיר את שדות המשנה type ו-count של השדה accelerators[], ופועל במיקום שבו נמצא סוג המכונה של ה-GPU.

    לדוגמה, כדי ליצור משימת סקריפט בסיסית שמשתמשת במעבדי GPU למכונות וירטואליות מסוג N1 ומאפשרת ל-Batch לבחור את סוג המכונה המדויק של N1, יוצרים קובץ JSON עם התוכן הבא:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

    • ‫INSTALL_GPU_DRIVERS: אם להתקין באופן אוטומטי מנהלי התקנים של GPU. אם הערך הוא true, המערכת של Batch מאחזרת את מנהלי ההתקנים שנדרשים לסוג ה-GPU שציינתם בשדה policy ממיקום של צד שלישי, ומתקינה אותם בשבילכם. אם מגדירים את השדה הזה לערך false (ברירת המחדל), צריך להתקין את מנהלי ההתקנים של ה-GPU באופן ידני כדי להשתמש ב-GPU כלשהו במשימה הזו.

    • ‫PROVISIONING_MODEL: מודל ההקצאה של אפשרות הצריכה: STANDARD לפי דרישה או SPOT למכונות וירטואליות במודל Spot.

    • ‫GPU_TYPE: סוג ה-GPU. אפשר להציג רשימה של סוגי ה-GPU הזמינים באמצעות הפקודה gcloud compute accelerator-types list. השדה הזה מיועד רק ל-GPUs למכונות וירטואליות מסוג N1.

    • ‫GPU_COUNT: מספר יחידות ה-GPU מהסוג שצוין. למידע נוסף על האפשרויות החוקיות, ראו סוגי מכונות GPU לסדרת המכונות N1. השדה הזה מיועד רק ל-GPUs למכונות וירטואליות מסוג N1.

    • ‫ALLOWED_LOCATIONS: המיקומים המותרים למשימה. מוודאים שבמיקום של משאבי Compute Engine של המשימה יש את סוג המכונה עם ה-GPU שרוצים להשתמש בו במשימה, באחת מהדרכים הבאות:

      • כברירת מחדל, אם משמיטים את השדה allowedLocations[], המשימה פועלת במשאבי Compute Engine שנוצרו באזור של מיקום המשימה (LOCATION).
      • אם כוללים את השדה allowedLocations[], אפשר להריץ את המשימה רק במשאבי Compute Engine שנוצרו במיקומים שצוינו.

  2. כדי ליצור ולהריץ את המשימה, משתמשים בפקודה gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

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

    • ‫JOB_NAME: שם המשימה.

    • ‫LOCATION: המיקום של המשימה.

    • ‫JSON_CONFIGURATION_FILE: הנתיב לקובץ JSON עם פרטי ההגדרות של המשימה.

API

שולחים בקשת POST לשיטה jobs.create שמתקינה מנהלי התקנים של GPU, מגדירה את שדות המשנה type ו-count של השדה accelerators[] ומשתמשת במיקום שבו נמצא סוג המכונה של ה-GPU.

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

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

  • ‫PROJECT_ID: מזהה הפרויקט שלכם.

  • ‫LOCATION: המיקום של המשימה.

  • ‫JOB_NAME: שם המשימה.

  • ‫INSTALL_GPU_DRIVERS: אם להתקין באופן אוטומטי מנהלי התקנים של GPU. אם הערך הוא true, המערכת של Batch מאחזרת את מנהלי ההתקנים שנדרשים לסוג ה-GPU שציינתם בשדה policy ממיקום של צד שלישי, ומתקינה אותם בשבילכם. אם מגדירים את השדה הזה לערך false (ברירת המחדל), צריך להתקין את מנהלי ההתקנים של ה-GPU באופן ידני כדי להשתמש ב-GPU כלשהו במשימה הזו.

  • ‫PROVISIONING_MODEL: מודל ההקצאה של אפשרות הצריכה: STANDARD לפי דרישה או SPOT למכונות וירטואליות במודל Spot.

  • ‫GPU_TYPE: סוג ה-GPU. אפשר להציג רשימה של סוגי ה-GPU הזמינים באמצעות הפקודה gcloud compute accelerator-types list. השדה הזה מיועד רק ל-GPUs למכונות וירטואליות מסוג N1.

  • ‫GPU_COUNT: מספר יחידות ה-GPU מהסוג שצוין. מידע נוסף על האפשרויות התקינות זמין במאמר סוגי מכונות GPU לסדרת המכונות N1. השדה הזה מיועד רק ל-GPUs למכונות וירטואליות מסוג N1.

  • ‫ALLOWED_LOCATIONS: המיקומים המותרים למשימה. מוודאים שבמיקום של משאבי Compute Engine של המשימה יש את סוג המכונה עם ה-GPU שרוצים להשתמש בו במשימה, באחת מהדרכים הבאות:

    • כברירת מחדל, אם משמיטים את השדה allowedLocations[], המשימה פועלת במשאבי Compute Engine שנוצרו באזור של מיקום המשימה (LOCATION).
    • אם כוללים את השדה allowedLocations[], אפשר להריץ את המשימה רק במשאבי Compute Engine שנוצרו במיקומים שצוינו.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJobN1 {

  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 region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // The GPU type. You can view a list of the available GPU types
    // by using the `gcloud compute accelerator-types list` command.
    String gpuType = "nvidia-tesla-t4";
    // The number of GPUs of the specified type.
    int gpuCount = 2;

    createGpuJob(projectId, region, jobName, installGpuDrivers, gpuType, gpuCount);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String gpuType, int gpuCount)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Accelerator describes Compute Engine accelerators to be attached to the VM.
      Accelerator accelerator = Accelerator.newBuilder()
          .setType(gpuType)
          .setCount(gpuCount)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(InstancePolicy.newBuilder().addAccelerators(accelerator))
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job-n1';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-tesla-t4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'n1-standard-16';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJobN1() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJobN1();

Python 

from google.cloud import batch_v1


def create_gpu_job(
    project_id: str, region: str, zone: str, job_name: str
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        zone: name of the zone you want to use to run the job. Important in regard to GPUs availability.
            GPUs availability can be found here: https://cloud.google.com/compute/docs/gpus/gpu-regions-zones
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-16"

    accelerator = batch_v1.AllocationPolicy.Accelerator()
    # Note: not every accelerator is compatible with instance type
    # Read more here: https://cloud.google.com/compute/docs/gpus#t4-gpus
    accelerator.type_ = "nvidia-tesla-t4"
    accelerator.count = 1

    policy.accelerators = [accelerator]
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = ["zones/us-central1-b"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

המאמרים הבאים