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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2. את שאר הבחירות עושים על סמך מה שתואם לבחירה הראשונה.

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

    2. בקטע שנותר, בוחרים באפשרות Select the consumption option או באפשרות Select the GPU machine type, בהתאם.

בחירת סוג מכונת ה-GPU

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

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

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

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

    ‫GPUs for accelerator-optimized VMs: VMs with a סוג מכונה from the משפחת מכונות accelerator-optimized have a specific type and number of these GPUs automatically attached.

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

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

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

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

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

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

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

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

הזמנות

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

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

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

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

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

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

  • פרטים: לפני שיוצרים משרה, צריך לבקש או לזהות הזמנה במצב לוח שנה שאפשר להשתמש בה. אם Compute Engine ממלא בקשה למקום שמור לעתיד במצב 'לוח שנה', המקום השמור שנוצר אוטומטית במצב 'לוח שנה' כרוך באותה עלות כמו הפעלת המכונות הווירטואליות שצוינו למשך כל תקופת השמירה במחיר של Dynamic Workload Scheduler, שמציע הנחות של עד 53% ממחיר השימוש על פי דרישה. אחרי שמזהים הזמנה שנוצרה אוטומטית במצב יומן שאפשר להשתמש בה, יצירת משימה שצורכת הזמנה במצב יומן דומה מאוד ליצירת משימה שצורכת הזמנה.

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

‫Batch משתמש בהזמנות במצב יומן למשימות שמתקיימים בהן כל התנאים הבאים:

מכונות וירטואליות עם הפעלה גמישה

  • תרחיש לדוגמה: מומלץ להשתמש במכונות וירטואליות עם הפעלה גמישה אם העבודה יכולה לעמוד בזמינות של best-effort בתמורה למחירים מוזלים ועד 7 ימים לסיום ההפעלה.

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

  • פרטים: אם בקשה ליצירת משימה שמשתמשת במכונות וירטואליות מסוג Flex-start מתבצעת, המכונות הווירטואליות מחויבות לפי התמחור של Dynamic Workload Scheduler, שכולל הנחות של עד 53% ממחיר השימוש לפי דרישה.

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

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

על פי דרישה

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

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

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

‫1יוצא מן הכלל: במשימות שמשתמשות בסדרת מכונות A3, התנהגות ברירת המחדל היא ייחודית, ולא מומלץ להשתמש במכונות לפי דרישה או להשאיר את השדה provisioningModel ללא הגדרה. במקום זאת, מומלץ להשתמש בדרישות המשימה למכונות וירטואליות עם הפעלה גמישה. לא מומלץ להשתמש ב-on-demand בסדרת מכונות A3 בגלל זמינות נמוכה של משאבים. לכן, אם עבודה משתמשת בסדרת מכונות A3, חוסמת הזמנות והשדה provisioningModel לא מוגדר או מוגדר ל-STANDARD, אפשרות הצריכה שמוגדרת כברירת מחדל היא unique. ההתנהגות דומה למכונות וירטואליות עם הפעלה גמישה, שמגבילות את זמן הריצה ל-7 ימים. עם זאת, לא מומלץ להשתמש באפשרות הזו כי העבודות האלה לא מקבלות הנחות ממחירי Dynamic Workload Scheduler. אם העבודה שלכם עם מכונות וירטואליות מסוג A3 יכולה להתבצע במסגרת מגבלת זמן ריצה של 7 ימים, מומלץ להשתמש במכונות וירטואליות עם הפעלה גמישה במקום במכונות וירטואליות לפי דרישה. אחרת, לא תוכלו לוודא שעבודות עם מכונות וירטואליות מסוג A3 משתמשות בשיטת התשלום לפי דרישה, אלא אם תגדירו את provisioningModel ל-STANDARD ותוודאו באופן ידני שהעבודה לא יכולה לצרוך הזמנות, בלי להגדיר את השדה reservation ל-NO_RESERVATION.

Spot VMs

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

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

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

מערכת Batch משתמשת במכונות וירטואליות במודל Spot למשימות שעומדות בכל הקריטריונים הבאים:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

שימוש ביחידות GPU ובמכונות וירטואליות מסוג Flex-start

אתם יכולים ליצור משימה שמשתמשת ב-GPU למכונות וירטואליות מסוג A3 באמצעות Dynamic Workload Scheduler באמצעות ה-CLI של gcloud או Batch API.

gcloud

  1. יוצרים קובץ JSON שמתקין מנהלי התקנים של GPU, מציין סוג מכונת 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":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

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

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

    • ‫ALLOWED_LOCATIONS: אפשר להשתמש באפשרות allowedLocations[] כדי לציין אזור או אזורים ספציפיים באזור שבו מותר להפעיל את המכונות הווירטואליות של העבודה. לדוגמה, regions/us-central1 מאפשרת את כל האזורים באזור us-central1. חשוב לציין מיקומים שבהם זמין סוג מכונת ה-GPU שרוצים להשתמש בו בעבודה הזו. אחרת, אם לא מציינים את השדה הזה, צריך לוודא שבמיקום של המשרה מוצע סוג מכונת ה-GPU.

  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, מציינת סוג מכונת 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":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

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

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

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

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

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

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

  • ‫ALLOWED_LOCATIONS: אפשר להשתמש באפשרות allowedLocations[] כדי לציין אזור או אזורים ספציפיים באזור שבו מותר להפעיל את המכונות הווירטואליות של העבודה. לדוגמה, regions/us-central1 מאפשרת את כל האזורים באזור us-central1. חשוב לציין מיקומים שבהם זמין סוג מכונת ה-GPU שרוצים להשתמש בו בעבודה הזו. אחרת, אם לא מציינים את השדה הזה, צריך לוודא שבמיקום של המשרה מוצע סוג מכונת ה-GPU.

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

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

המסוף

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

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

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

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

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

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

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

    2. מגדירים את הקטע פרטי המשימה:

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

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

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

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

          echo Hello world from task ${BATCH_TASK_INDEX}.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    בדף פרטי המשרה מוצגת המשרה שיצרתם.

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: אם מגדירים את הערך true, Batch מאחזר את מנהלי ההתקנים שנדרשים לסוג ה-GPU שצוין בשדה policy ממיקום של צד שלישי, ומתקין אותם בשמכם. אם מגדירים את השדה הזה לערך false (ברירת מחדל), צריך להתקין מנהלי התקנים (דרייברים) של GPU באופן ידני כדי להשתמש ביחידות GPU בעבודה הזו.

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

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

    • ‫ALLOWED_LOCATIONS: אפשר להשתמש באפשרות allowedLocations[] כדי לציין אזור או אזורים ספציפיים באזור שבו מותר להפעיל את המכונות הווירטואליות של העבודה. לדוגמה, regions/us-central1 מאפשרת את כל האזורים באזור us-central1. חשוב לציין מיקומים שבהם זמין סוג מכונת ה-GPU שרוצים להשתמש בו בעבודה הזו. אחרת, אם לא מציינים את השדה הזה, צריך לוודא שבמיקום של העבודה מוצע סוג מכונת ה-GPU.

  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, מציינת סוג מכונה מתוך משפחת המכונות שעברו אופטימיזציה למאיצים ופועלת במיקום שבו יש סוג מכונת 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: אם מגדירים את הערך true, Batch מאחזר את מנהלי ההתקנים שנדרשים לסוג ה-GPU שצוין בשדה policy ממיקום של צד שלישי, ומתקין אותם בשמכם. אם מגדירים את השדה הזה לערך false (ברירת מחדל), צריך להתקין מנהלי התקנים (דרייברים) של GPU באופן ידני כדי להשתמש ב-GPU כלשהו לעבודה הזו.

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

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

  • ‫ALLOWED_LOCATIONS: אפשר להשתמש באפשרות allowedLocations[] כדי לציין אזור או אזורים ספציפיים באזור שבו מותר להפעיל את המכונות הווירטואליות של העבודה. לדוגמה, regions/us-central1 מאפשרת את כל האזורים באזור us-central1. חשוב לציין מיקומים שבהם זמין סוג מכונת ה-GPU שרוצים להשתמש בו בעבודה הזו. אחרת, אם לא מציינים את השדה הזה, צריך לוודא שבמיקום של המשרה מוצע סוג מכונת ה-GPU.

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

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

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

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

    2. מגדירים את הקטע פרטי המשימה:

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

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

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

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

          echo Hello world from task ${BATCH_TASK_INDEX}.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    בדף פרטי המשרה מוצגת המשרה שיצרתם.

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: אם מגדירים את הערך true, Batch מאחזר את מנהלי ההתקנים שנדרשים לסוג ה-GPU שצוין בשדה policy ממיקום של צד שלישי, ומתקין אותם בשמכם. אם מגדירים את השדה הזה לערך false (ברירת מחדל), צריך להתקין מנהלי התקנים (דרייברים) של GPU באופן ידני כדי להשתמש ביחידות GPU בעבודה הזו.

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

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

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

    • ‫ALLOWED_LOCATIONS: אפשר להשתמש באפשרות allowedLocations[] כדי לציין אזור או אזורים ספציפיים באזור שבו מותר להפעיל את המכונות הווירטואליות של העבודה. לדוגמה, regions/us-central1 מאפשרת את כל האזורים באזור us-central1. חשוב לציין מיקומים שבהם זמין סוג מכונת ה-GPU שרוצים להשתמש בו בעבודה הזו. אחרת, אם לא מציינים את השדה הזה, צריך לוודא שבמיקום של העבודה מוצע סוג מכונת ה-GPU.

  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: אם מגדירים את הערך true, Batch מאחזר את מנהלי ההתקנים שנדרשים לסוג ה-GPU שצוין בשדה policy ממיקום של צד שלישי, ומתקין אותם בשמכם. אם מגדירים את השדה הזה לערך false (ברירת מחדל), צריך להתקין מנהלי התקנים (דרייברים) של GPU באופן ידני כדי להשתמש ביחידות GPU בעבודה הזו.

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

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

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

  • ‫ALLOWED_LOCATIONS: אפשר להשתמש באפשרות allowedLocations[] כדי לציין אזור או אזורים ספציפיים באזור שבו מותר להפעיל את המכונות הווירטואליות של העבודה. לדוגמה, regions/us-central1 מאפשרת את כל האזורים באזור us-central1. חשוב לציין מיקומים שבהם זמין סוג מכונת ה-GPU שרוצים להשתמש בו בעבודה הזו. אחרת, אם לא מציינים את השדה הזה, צריך לוודא שבמיקום של המשרה מוצע סוג מכונת ה-GPU.

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)

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