פריסת אשכול HPC עם התאמה אוטומטית לעומס (auto-scaling) באמצעות Slurm

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

ברוכים הבאים ל-Codelab של Google להרצת אשכול Slurm ב-Google Cloud Platform! בסיום ה-Codelab הזה, תהיה לכם הבנה טובה של הקלות שבה אפשר להקצות ולתפעל אשכול Slurm עם התאמה אוטומטית לעומס.

‫Google Cloud שיתפה פעולה עם SchedMD כדי להשיק חבילת כלים שמקלה על הפעלת מנהל עומסי העבודה של Slurm ב-Compute Engine, ועל הרחבה דינמית של האשכול הקיים כשצריך משאבים נוספים. השילוב הזה נוצר על ידי המומחים ב-SchedMD בהתאם לשיטות המומלצות לשימוש ב-Slurm.

אם אתם מתכננים להשתמש בשילובים של Slurm ב-Google Cloud Platform או אם יש לכם שאלות, כדאי להצטרף לקבוצת הדיון של קהילת Google Cloud ו-Slurm.

מידע על Slurm

תרשים ארכיטקטורה בסיסי של אשכול Slurm עצמאי ב-Google Cloud Platform.

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

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

מה תלמדו

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

דרישות מוקדמות

חשבון ב-Google Cloud Platform ופרויקט עם חיוב
חוויית Linux בסיסית

2. הגדרה

הגדרת סביבה בקצב אישי

איך יוצרים פרויקט

אם עדיין אין לכם חשבון Google (Gmail או G Suite), אתם צריכים ליצור חשבון. נכנסים אל Google Cloud Platform Console ( console.cloud.google.com) ופותחים את הדף Manage resources (ניהול משאבים):

לוחצים על Create Project.

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

בשלב הבא צריך להפעיל את החיוב ב-Developers Console כדי להשתמש במשאבים של Google Cloud.

העלות של ה-Codelab הזה לא אמורה להיות גבוהה, אבל היא יכולה להיות גבוהה יותר אם תחליטו להשתמש ביותר משאבים או אם תשאירו אותם פועלים (ראו את הקטע 'מסקנה' בסוף המסמך הזה). מחשבון התמחור של Google Cloud Platform זמין כאן.

משתמשים חדשים ב-Google Cloud Platform זכאים לתקופת ניסיון בחינם בשווי 300$.

Google Cloud Shell

אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-codelab הזה נשתמש ב-Google Cloud Shell, סביבת שורת פקודה שפועלת בענן.

הפעלת Google Cloud Shell

ב-GCP Console, לוחצים על סמל Cloud Shell בסרגל הכלים שבפינה הימנית העליונה:

לאחר מכן לוחצים על הפעלת Cloud Shell:

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

המכונה הווירטואלית הזו כוללת את כל הכלים שדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר מאוד את ביצועי הרשת ומפשט את האימות. את רוב העבודה במעבדה הזו, אם לא את כולה, אפשר לבצע באמצעות דפדפן אינטרנט או Google Chromebook.

אחרי שמתחברים ל-Cloud Shell, אמור להופיע אימות שכבר בוצע ושהפרויקט כבר הוגדר לפי PROJECT_ID:

$ gcloud auth list

פלט הפקודה:

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

$ gcloud config list project

פלט הפקודה:

[core]
project = <PROJECT_ID>

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

$ gcloud config set project <PROJECT_ID>

פלט הפקודה:

Updated property [core/project].

3. הכנה ובדיקה של הגדרות Terraform של Slurm

הורדת ההגדרות של Slurm Terraform

בסשן של Cloud Shell, מריצים את הפקודה הבאה כדי לשכפל (להוריד) את מאגר ה-Git שמכיל את קובצי ה-Terraform של Slurm for Google Cloud Platform:

git clone https://github.com/SchedMD/slurm-gcp.git

עוברים לספריית התצורה של פריסת Slurm על ידי הפעלת הפקודה הבאה:

cd slurm-gcp

הגדרת Slurm Terraform tfvars

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

cd tf/example/basic
cp basic.tfvars.example basic.tfvars

בסשן של Cloud Shell, פותחים את קובץ ה-tfvars‏ basic.tfvars. אפשר להשתמש בעורך שורת הפקודה המועדף (vi,‏ nano,‏ emacs וכו') או בעורך הקוד של Cloud Console כדי לראות את תוכן הקובץ:

בודקים את התוכן של קובץ ה-tfvars.

cluster_name = "g1"
project      = "<project>"
zone         = "us-west1-b"

# network_name            = "<existing network name>"
# subnetwork_name         = "<existing subnetwork name>"
# shared_vpc_host_project = "<vpc host project>"

# disable_controller_public_ips = true
# disable_login_public_ips      = true
# disable_compute_public_ips    = true

# suspend_time  = 300

controller_machine_type = "n1-standard-2"
controller_image        = "projects/schedmd-slurm-public/global/images/family/schedmd-slurm-20-11-4-hpc-centos-7"
controller_disk_type    = "pd-standard"
controller_disk_size_gb = 50
# controller_labels = {
#   key1 = "val1"
#   key2 = "val2"
# }
# controller_service_account = "default"
# controller_scopes          = ["https://www.googleapis.com/auth/cloud-platform"]
# cloudsql = {
#   server_ip = "<cloudsql ip>"
#   user      = "slurm"
#   password  = "verysecure"
#   db_name   = "slurm_accounting"
# }
# controller_secondary_disk      = false
# controller_secondary_disk_size = 100
# controller_secondary_disk_type = "pd-ssd"
#
# When specifying an instance template, specified controller fields will
# override the template properites.
# controller_instance_template = null

login_machine_type = "n1-standard-2"
login_image        = "projects/schedmd-slurm-public/global/images/family/schedmd-slurm-20-11-4-hpc-centos-7"
login_disk_type    = "pd-standard"
login_disk_size_gb = 20
# login_labels = {
#   key1 = "val1"
#   key2 = "val2"
# }
# login_node_count = 1
# login_node_service_account = "default"
# login_node_scopes          = [
#   "https://www.googleapis.com/auth/monitoring.write",
#   "https://www.googleapis.com/auth/logging.write"
# ]
#
# When specifying an instance template, specified login fields will
# override the template properties.
# login_instance_template = null

# Optional network storage fields
# network_storage is mounted on all instances
# login_network_storage is mounted on controller and login instances
# network_storage = [{
#   server_ip     = "<storage host>"
#   remote_mount  = "/home"
#   local_mount   = "/home"
#   fs_type       = "nfs"
#   mount_options = null
# }]
#
# login_network_storage = [{
#   server_ip     = "<storage host>"
#   remote_mount  = "/net_storage"
#   local_mount   = "/shared"
#   fs_type       = "nfs"
#   mount_options = null
# }]

# compute_node_service_account = "default"
# compute_node_scopes          = [
#   "https://www.googleapis.com/auth/monitoring.write",
#   "https://www.googleapis.com/auth/logging.write"
# ]

partitions = [
  { name                 = "debug"
    machine_type         = "n1-standard-2"
    static_node_count    = 0
    max_node_count       = 10
    zone                 = "us-west1-b"
    image                ="projects/schedmd-slurm-public/global/images/family/schedmd-slurm-20-11-4-hpc-centos-7"
    image_hyperthreads   = false
    compute_disk_type    = "pd-standard"
    compute_disk_size_gb = 20
    compute_labels       = {}
    cpu_platform         = null
    gpu_count            = 0
    gpu_type             = null
    network_storage      = []
    preemptible_bursting = false
    vpc_subnet           = null
    exclusive            = false
    enable_placement     = false
    regional_capacity    = false
    regional_policy      = {}
    instance_template    = null
  },
  #  { name                 = "partition2"
  #    machine_type         = "n1-standard-16"
  #    static_node_count    = 0
  #    max_node_count       = 20
  #    zone                 = "us-west1-b"
  #    image                = "projects/schedmd-slurm-public/global/images/family/schedmd-slurm-20-11-4-hpc-centos-7"
  #    image_hyperthreads   = false
  #
  #    compute_disk_type    = "pd-ssd"
  #    compute_disk_size_gb = 20
  #    compute_labels       = {
  #      key1 = "val1"
  #      key2 = "val2"
  #    }
  #    cpu_platform         = "Intel Skylake"
  #    gpu_count            = 8
  #    gpu_type             = "nvidia-tesla-v100"
  #    network_storage      = [{
  #      server_ip     = "none"
  #      remote_mount  = "<gcs bucket name>"
  #      local_mount   = "/data"
  #      fs_type       = "gcsfuse"
  #      mount_options = "file_mode=664,dir_mode=775,allow_other"
  #    }]
  #    preemptible_bursting = true
  #    vpc_subnet           = null
  #    exclusive            = false
  #    enable_placement     = false
  #
  #    ### NOTE ####
  #    # regional_capacity is under development. You may see slowness in
  #    # deleting lots of instances.
  #    #
  #    # With regional_capacity : True, the region can be specified in the zone.
  #    # Otherwise the region will be inferred from the zone.
  #    zone = "us-west1"
  #    regional_capacity    = True
  #    # Optional
  #    regional_policy      = {
  #        locations = {
  #            "zones/us-west1-a" = {
  #                preference = "DENY"
  #            }
  #        }
  #    }
  #
  #    When specifying an instance template, specified compute fields will
  #    override the template properties.
  #    instance_template = "my-template"
]

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

‫cluster_name: השם של אשכול Slurm
‫project: מזהה הפרויקט ב-Google Cloud שבו ייפרסו המשאבים
‫zone: אזור Google Cloud שיכיל את בקר המערכת ואת מופעי הכניסה של האשכול הזה – מידע נוסף
‫network_name: רשת של ענן וירטואלי פרטי (VPC) לפריסת אשכול Slurm
‫subnetwork_name: רשת משנה של ענן וירטואלי פרטי (VPC) לפריסת אשכול Slurm
‫shared_vpc_host_project: רשת VPC משותפת לפריסת אשכול Slurm
‫disable_controller_public_ips: האם להקצות כתובת IP חיצונית לבקר Slurm?
‫disable_login_public_ips: האם להקצות כתובת IP חיצונית לצומת הכניסה של Slurm?
‫disable_compute_login_ips: האם להקצות כתובת IP חיצונית לצומת הכניסה של Slurm?
‫suspend_time: הזמן להמתנה אחרי שצומת בלי פעילות לפני השהיית הצומת
‫controller_machine_type: Controller node instance type
‫controller_image: קובץ אימג' של GCP שמשמש ליצירת מכונת הבקרה של Slurm
‫controller_disk_type: סוג דיסק האתחול של מופע הבקר
‫controller_disk_size_gb: גודל דיסק האתחול של מופע של בקר
‫controller_labels: תוויות לצירוף למופע של בקר
‫controller_service_account: חשבון שירות לשימוש במופע של בקר
controller_scopes: היקף גישה של מופע בקר
‫cloudsql: שרת Google CloudSQL לשימוש כמסד הנתונים של Slurm במקום לארח מסד נתונים במכונת הבקרה
‫server_ip: כתובת ה-IP של שרת CloudSQL
user: שם המשתמש ב-CloudSQL
password: סיסמת CloudSQL
‫db_name: שם מסד הנתונים ב-CloudSQL
‫controller_secondary_disk: להוסיף דיסק משני לאחסון בשרת NFS?
‫controller_secondary_disk_type: סוג הדיסק המשני של הבקר
‫controller_secondary_disk_size_gb: גודל הכונן המשני של הבקר
‫controller_instance_template: תבנית של הגדרות מכונה ב-GCP שבה רוצים להשתמש עבור מכונת הבקרה. כל שדה חישוב שצוין יחליף את מאפייני התבנית. לדוגמה, אם מציינים controller_image, הוא יחליף את התמונה בתבנית של הגדרות מכונה.
‫login_machine_type: צומת כניסה (עם גישה ל-SSH) סוג מכונה
‫login_image: תמונת GCP שמשמשת ליצירת מכונת הכניסה של Slurm
‫login_disk_type: סוג דיסק האתחול של מופע ההתחברות
‫login_disk_size_gb: גודל דיסק האתחול של מופע הכניסה
‫login_labels: תוויות לצירוף למופע הכניסה
login_node_count: מספר צמתי הכניסה שייווצרו
‫login_node_service_account: חשבון שירות לשימוש במופעי הכניסה
login_node_scopes: היקף הגישה של מופע ההתחברות
‫login_instance_template: תבנית של הגדרות מכונה של GCP לשימוש במכונת הכניסה. כל שדה חישוב שצוין יחליף את מאפייני התבנית. לדוגמה, אם מציינים את login_image, הוא יחליף את התמונה בתבנית של הגדרות מכונה.
‫network_storage: אחסון ברשת להרכבה בכל הצמתים. השדות יתווספו ישירות ל-fstab. אפשר לחזור על הפעולה הזו כדי להוסיף עוד תושבות.
‫server_ip: כתובת ה-IP של שרת האחסון
‫remote_mount: שם הנקודה לחיבור האחסון (שם מערכת הקבצים)
local_mount: ספריית הטעינה המקומית
‫fs_type: סוג מערכת הקבצים (NFS, ‏ CIFS, ‏ Lustre, ‏ GCSFuse מותקן אוטומטית)
‫mount_options: אפשרויות טעינה (למשל: defaults,_netdev)
‫login_network_storage: אחסון ברשת לטעינה בצמתים של התחברות ובצמתים של בקרה. מערכות NFS,‏ CIFS,‏ Lustre ו-GCSFuse יותקנו באופן אוטומטי. אפשר לחזור על הפעולה הזו כדי להוסיף עוד תושבות.
‫server_ip: כתובת ה-IP של שרת האחסון
‫remote_mount: שם הנקודה לחיבור האחסון (שם מערכת הקבצים)
local_mount: ספריית הטעינה המקומית
‫fs_type: סוג מערכת הקבצים (NFS, ‏ CIFS, ‏ Lustre, ‏ GCSFuse מותקן אוטומטית)
‫mount_options: אפשרויות טעינה (למשל: defaults,_netdev)
‫compute_node_service_account: חשבון שירות לשימוש במכונות לחישובים
‫compute_node_scopes: היקף גישה של מכונות ה-compute
‫partitions: הגדרת מחיצות ב-Slurm. אפשר לחזור על הפעולה כדי ליצור מחיצות נוספות.
‫name: שם המחיצה
‫machine_type: צומתי מחשוב סוג מכונה
‫static_node_count: מספר צמתי מחשוב עם זמינות תמידית
‫max_node_count: המספר המקסימלי של צמתי מחשוב כוללים שמותרים – 64 אלף לכל היותר
‫zone: אזור Google Cloud שיכיל את המשאבים של החלוקה הזו – מידע נוסף
‫image: סוג המכונה של צומת תמונת Compute
‫image_hyperthreads: הפעלה או השבתה של Hyperthreading במופע
‫compute_disk_type: סוג דיסק האתחול של מכונת Compute (pd-standard, ‏ pd-ssd)
‫compute_disk_size_gb: גודל דיסק האתחול של מכונת Compute
‫compute_labels: תוויות לצירוף למופע של Compute
‫cpu_platform: פלטפורמת המעבד המינימלית שנדרשת לכל צמתי החישוב
‫gpu_count: מספר יחידות ה-GPU לצירוף לכל מופע במחיצה
‫gpu_type: סוג ה-GPU לצירוף למכונות של המחיצה
‫network_storage: אחסון ברשת להרכבה בכל צמתי המחשוב במחיצה. השדות יתווספו ישירות ל-fstab. אפשר לחזור על הפעולה הזו כדי להוסיף עוד תושבות.
‫server_ip: כתובת ה-IP של שרת האחסון
‫remote_mount: שם הנקודה לחיבור האחסון (שם מערכת הקבצים)
local_mount: ספריית הטעינה המקומית
‫fs_type: סוג מערכת הקבצים (NFS, ‏ CIFS, ‏ Lustre, ‏ GCSFuse מותקן אוטומטית)
‫mount_options: אפשרות טעינה
‫preemptible_bursting: האם המופעים יהיו מופעים זמניים שניתנים להפסקה?
‫vpc_subnet: רשת משנה של ענן וירטואלי פרטי לפריסת מחיצת Slurm
בלעדי: מאפשר ל-Slurm להקצות צמתים שלמים למשימות
‫enable_placement: הפעלה של מדיניות מיקום שבה המכונות ימוקמו קרוב זה לזה כדי להקטין את זמן הטעינה ברשת בין המכונות.
‫regional_capacity: מאפשר להציב מופע בכל אזור באזור על סמך הזמינות
‫regional_policy: אם regional_capacity הוא true, המדיניות הזו קובעת באיזה אזור להשתמש ואילו אזורים באזור הזה לא להשתמש
‫Instance_template: תבנית של הגדרות מכונה של GCP שבה רוצים להשתמש עבור מכונות לחישוב. כל שדה חישוב שצוין יחליף את מאפייני התבנית. לדוגמה, אם מציינים תמונה, היא תחליף את התמונה בתבנית של הגדרות מכונה.

הגדרה מתקדמת

אם רוצים, אפשר להתקין חבילות ותוכנות נוספות כחלק מתהליך הפריסה של האשכול. אפשר להתקין תוכנה באשכול Slurm בכמה דרכים שמפורטות במאמר בנושא התקנת אפליקציות באשכול Slurm ב-Compute Engine, או על ידי התאמה אישית של התמונה שנפרסה על ידי Slurm. בשלב הזה, Slurm פורס קובץ אימג' של מכונה וירטואלית שסופק על ידי SchedMD ומבוסס על קובץ אימג' של מכונה וירטואלית ל-HPC ב-Google Cloud, עם Slurm שמותקן מעליו.

כדי להשתמש באימג' משלכם, צריך ליצור אימג' עם הגדרה משלכם על סמך אימג' ציבורי של VM של SchedMD שמופיע בקובץ tfvars. לאחר מכן, מחליפים את ה-URI של התמונה שצוין בקובץ tfvars בתמונה שלכם, ובודקים את השינוי.

פתרון בעיות

במהלך ה-Codelab הזה, מומלץ לעיין בקטע פתרון הבעיות בקובץ ה-README של מאגר Slurm-GCP.

הבעיות הנפוצות ביותר הן טעויות בהגדרת קובץ tfvars והגבלות מכסה. ה-codelab הזה מיועד להרצה במסגרת הקצאת המכסה הרגילה של משתמש חדש ובמסגרת הקרדיט החינמי בסך 300 $‎ שמשתמש חדש מקבל. אם ניסיון ליצור מכונות VM נכשל, בודקים את הקובץ ‎ /var/log/slurm/resume.log בצומת הבקרה כדי לראות אם יש שגיאות ב-API.

4. פריסה ואימות של ההגדרה

פריסת ההגדרות האישיות

בסשן של Cloud Shell, מריצים את הפקודה הבאה מהתיקייה slurm-gcp/tf/example:

terraform init
terraform apply -var-file=basic.tfvars

תתבקשו לאשר את הפעולות שמתוארות בהודעה, בהתאם להגדרות שנקבעו. מזינים yes כדי להתחיל את הפריסה. אפשר גם להריץ את הפקודה terraform plan כדי לראות את ההגדרה שתיפרס.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

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

אחרי שהפריסה תושלם, יוצג פלט שדומה לזה:

Apply complete! Resources: 8 added, 0 changed, 0 destroyed.

Outputs:

controller_network_ips = [
  [
    "10.0.0.2",
  ],
]
login_network_ips = [
  [
    "10.0.0.3",
  ],
]

אימות של יצירת מופע של VM

פותחים את תפריט הניווט ובוחרים באפשרות Compute Engine > VM Instances.

צריכים להופיע ברשימה בקר ומכונת VM לכניסה:

בקטע VM instances (מכונות וירטואליות) בודקים את שתי המכונות הווירטואליות שנוצרו על ידי Terraform.

השמות יהיו שונים אם שיניתם את השדה cluster_name.

g1-controller
g1-login0

5. התחברות אל Slurm Cluster

גישה לאשכול Slurm

חוזרים לכרטיסייה של עורך הקוד או Cloud Shell. מריצים את הפקודה הבאה כדי להיכנס למופע, ומחליפים את <ZONE> באזור של הצומת g1-login0 (צריך להיות us-central1-b):

gcloud compute ssh g1-login0 --zone=<ZONE>

הפקודה הזו תגרום לכניסה למכונה הווירטואלית g1-login0.

שיטה נוספת לגישה קלה לצומת הכניסה היא ללחוץ על הלחצן SSH לצד מכונת ה-VM g1-login0 בדף VM Instances (מכונות VM) כדי לפתוח כרטיסייה חדשה עם חיבור SSH.

אם זו הפעם הראשונה שאתם משתמשים ב-Cloud Shell, יכול להיות שתופיע הודעה כמו זו שבהמשך, שמבקשת מכם ליצור מפתח SSH:

WARNING: The public SSH key file for gcloud does not exist.
WARNING: The private SSH key file for gcloud does not exist.
WARNING: You do not have an SSH key for gcloud.
WARNING: SSH keygen will be executed to generate a key.
This tool needs to create the directory [/home/user/.ssh] before being
 able to generate SSH keys.

Do you want to continue (Y/n)?

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

אם ההודעה הבאה מופיעה כשנכנסים לחשבון:

*** Slurm is currently being configured in the background. ***
A terminal broadcast will announce when installation and configuration is
complete.

צריך לחכות ולא להמשיך עם ה-Lab עד שמוצגת ההודעה הזו (כ-5 דקות):

*** Slurm login setup complete ***

אחרי שתראו את ההודעה שלמעלה, תצטרכו לצאת מ-g1-login0 ולהיכנס אליו שוב כדי להמשיך את ה-Lab. כדי לעשות זאת, מקישים על CTRL + C כדי לסיים את המשימה.

לאחר מכן מריצים את הפקודה הבאה כדי להתנתק מהמופע:

exit

עכשיו מתחברים מחדש למכונה הווירטואלית להתחברות. מריצים את הפקודה הבאה כדי להתחבר למופע, ומחליפים את <ZONE> באזור של הצומת g1-login0:

gcloud compute ssh g1-login0 --zone=<ZONE>

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

סיור בכלים של Slurm CLI

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

נריץ כמה פקודות כדי להכיר לכם את שורת הפקודות של Slurm.

מריצים את הפקודה sinfo כדי לראות את הסטטוס של המשאבים באשכול:

sinfo

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

PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
debug*       up   infinite     10  idle~ g1-compute-0-[0-9]

אפשר לראות ש-10 הצמתים שלנו, שנקבעו על ידי הערך 10 של max_node_count במחיצת הניפוי באגים, מסומנים כ-idle~ (הצומת במצב בלי פעילות ולא מוקצה, ומוכן להפעלה).

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

squeue

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

JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)

הפקודות srun ו-sbatch של Slurm משמשות להרצת משימות שמוצבות בתור. הפקודה srun מריצה עבודות מקבילות, ואפשר להשתמש בה כעטיפה של mpirun. הפקודה sbatch משמשת לשליחת משימה באצווה ל-Slurm, ויכולה לקרוא לפקודה srun פעם אחת או כמה פעמים בהגדרות שונות. אפשר להשתמש בפקודה sbatch עם סקריפטים של אצווה, או עם האפשרות ‎–wrap כדי להריץ את כל העבודה משורת הפקודה.

בואו נריץ עבודה כדי לראות את Slurm בפעולה ולהוסיף עבודה לתור שלנו.

6. הרצת משימת Slurm והרחבת האשכול

הרצת משימת Slurm והרחבת האשכול

עכשיו כשהאשכול Slurm שלנו פועל, נריץ עבודה ונגדיל את האשכול.

הפקודה sbatch משמשת להרצת פקודות ותסריטים של Slurm batch. נריץ סקריפט sbatch פשוט שיריץ את הפקודה hostname במכונות הווירטואליות שלנו עם שינוי גודל אוטומטי.

כשמחוברים אל g1-login0, מריצים את הפקודה הבאה:

sbatch -N2 --wrap="srun hostname"

הפקודה הזו מריצה את פקודת האצווה של Slurm. האפשרות הזו מציינת ש-sbatch יפעיל 2 צמתים עם האפשרות ‎-N. הוא גם מציין שכל אחד מהצמתים האלה יריץ פקודה של 'srun hostname' באפשרות '‎–wrap'.

כברירת מחדל, הפקודה sbatch כותבת את הפלט שלה לקובץ slurm-%j.out בספריית העבודה שממנה מריצים את הפקודה, כאשר %j מוחלף במזהה המשימה בהתאם לתבניות של שמות קבצים ב-Slurm. בדוגמה שלנו, הפקודה sbatch מופעלת מתיקיית /home של המשתמש, שהיא מערכת קבצים משותפת מבוססת-NFS שמארח בקר כברירת מחדל. כך צמתי מחשוב יכולים לשתף נתוני קלט ופלט אם רוצים. בסביבת ייצור, האחסון הפעיל צריך להיות נפרד מהאחסון בתיקייה ‎ /home כדי למנוע השפעה על הביצועים של פעולות האשכול. אפשר לציין נקודות חיבור נפרדות לאחסון בקובץ tfvars באפשרויות network_storage.

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

Submitted batch job 2

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

squeue

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

JOBID PARTITION               NAME     USER ST       TIME  NODES   NODELIST(REASON)
    2     debug g1-compute-0-[0-1] username  R       0:10      2 g1-compute-0-[0-1]

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

כדי לראות את אשכול Slurm מתחיל לפעול, מריצים את הפקודה sinfo:

sinfo

הפקודה הזו תציג את הצמתים שמופיעים ב-squeue במצב alloc#, כלומר הצמתים מוקצים:

PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
debug*       up   infinite      8  idle~ g1-compute-0-[2-9]
debug*       up   infinite      2 alloc#  g1-compute-0-[0-1]

אפשר גם לבדוק את הקטע VM instances במסוף Google Cloud כדי לראות את הצמתים החדשים שהוקצו. יחלפו כמה דקות עד שהצמתים יופעלו ועד שמערכת Slurm תפעל לפני שהעבודה תשובץ לצמתים שהוקצו לאחרונה. רשימת מכונות ה-VM תיראה בקרוב כך:

אחרי שהצמתים יפעילו את המשימה, המופעים יעברו למצב alloc, כלומר המשימות יוקצו למשימה:

PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
debug*       up   infinite      8  idle~ g1-compute-0-[2-9]
debug*       up   infinite      2  alloc g1-compute-0-[0-1]

אחרי שסיימתם עבודה, היא לא תופיע יותר ב-squeue, והצמתים של alloc ב-sinfo יחזרו למצב idle. מריצים את הפקודה squeue מעת לעת עד שהעבודה מסתיימת, אחרי דקה או שתיים.

קובץ הפלט slurm-%j.out ייכתב לתיקייה /home שמשותפת ב-NFS, ויכיל את שמות המארחים. פותחים את קובץ הפלט (בדרך כלל slurm-2.out) או מציגים את התוכן שלו באמצעות הפקודה cat. התוכן של קובץ הפלט יכלול:

g1-compute-0-0
g1-compute-0-1

כל הכבוד, הפעלת עבודה והרחבת את אשכול Slurm!

7. הפעלת משימת MPI

עכשיו נריץ עבודת MPI בצמתים שלנו. כשמחוברים ל-g1-login0, משתמשים ב-wget כדי להוריד תוכנית MPI שנכתבה בשפת התכנות C:

wget https://raw.githubusercontent.com/mpitutorial/mpitutorial/gh-pages/tutorials/mpi-hello-world/code/mpi_hello_world.c

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

module load openmpi

נשתמש בכלי mpicc כדי לקמפל את קוד ה-MPI C. מריצים את הפקודה הבאה:

mpicc mpi_hello_world.c -o mpi_hello_world

הקוד הזה מבצע קומפילציה של קוד C לשפת מכונה, כדי שנוכל להריץ את הקוד באשכול באמצעות Slurm.

לאחר מכן, משתמשים בכלי המועדף לעריכת טקסט כדי ליצור סקריפט sbatch בשם helloworld_batch:

vi helloworld_batch

מקלידים i כדי להיכנס למצב ההוספה של vi.

מעתיקים ומדביקים את הטקסט הבא בקובץ כדי ליצור סקריפט sbatch פשוט:

#!/bin/bash
#
#SBATCH --job-name=hello_world
#SBATCH --output=hello_world-%j.out
#
#SBATCH --nodes=2

srun mpi_hello_world

כדי לשמור ולצאת מעורך הקוד, לוחצים על Escape ומקלידים ‎ ":wq"‎ בלי מרכאות.

הסקריפט הזה מגדיר את סביבת ההפעלה ואת המשימות של Slurm batch. קודם כל, סביבת ההפעלה מוגדרת כ-bash. לאחר מכן, הסקריפט מגדיר את האפשרויות של Slurm באמצעות השורות #SBATCH. שם המשימה מוגדר כ-hello_world.

קובץ הפלט מוגדר כ-hello_world_%j.out, כאשר %j מוחלף במזהה המשימה בהתאם לתבניות של שמות קבצים ב-Slurm. קובץ הפלט הזה נכתב בספרייה שממנה מריצים את סקריפט ה-sbatch. בדוגמה שלנו, זו התיקייה /home של המשתמש, שהיא מערכת קבצים משותפת מבוססת-NFS. כך צמתי מחשוב יכולים לשתף נתוני קלט ופלט אם רוצים. בסביבת ייצור, האחסון הפעיל צריך להיות נפרד מהאחסון בתיקייה ‎ /home כדי למנוע השפעה על הביצועים של פעולות האשכול.

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

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

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

sbatch helloworld_batch

הפעלת הפקודה sbatch תחזיר מזהה משימה למשימה המתוזמנת, לדוגמה:

Submitted batch job 3

הפקודה hostname תופעל ב-2 צמתים, עם משימה אחת לכל צומת, והפלט יודפס בקובץ hello_world-3.out.

מכיוון שכבר הקצנו 2 צמתים, העבודה הזו תפעל במהירות.

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

squeue

אחרי שהפעולה מסתיימת, פותחים את הקובץ hello_world-3.out או מריצים עליו את הפקודה cat, ומוודאים שהוא פעל ב-g1-compute-0-[0-1]:

Hello world from processor g1-compute-0-0, rank 0 out of 2 processors
Hello world from processor g1-compute-0-1, rank 1 out of 2 processors

אחרי 5 דקות של חוסר פעילות (אפשר להגדיר את משך הזמן הזה בשדה suspend_time ב-YAML או בשדה SuspendTime ב-slurm.conf), הצמתים של המחשוב שהוקצו באופן דינמי יבוטלו כדי לשחרר משאבים. כדי לוודא זאת, אפשר להריץ את הפקודה sinfo מדי פעם ולראות שגודל האשכול חוזר ל-0:

PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
debug*       up   infinite     10  idle~ g1-compute-0-[0-9]

אפשר לנסות להפעיל עוד מכונות, עד למכסת המכונות המותרת באזור שבו פרסתם את האשכול, ולהריץ אפליקציות MPI שונות.

8. סיכום

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

אם רוצים להמשיך ללמוד איך להשתמש ב-Slurm ב-GCP, כדאי להמשיך עם ה-codelab‏ Building Federated HPC Clusters with Slurm (יצירת אשכולות HPC מאוחדים באמצעות Slurm). ב-Codelab הזה נסביר איך להגדיר שני אשכולות Slurm מאוחדים בענן, כדי להמחיש איך אפשר להשיג איחוד של כמה אשכולות, בין אם מדובר באשכולות מקומיים או באשכולות בענן.

האם אתם בונים משהו מגניב באמצעות הפונקציונליות החדשה של Slurm שמותאמת ל-GCP? יש לך שאלות? יש לך הצעה לתכונה? אפשר לפנות לצוות Google Cloud דרך האתר של פתרונות מחשוב בעל ביצועים גבוהים (HPC) של Google Cloud, או לשוחח איתנו בצ'אט בקבוצת הדיון בנושא Google Cloud ו-Slurm.

ניקוי הפריסה של Terraform

מתנתקים מצומת slurm:

exit

לפני שמוחקים את הפריסה, מאפשרים לכל הצמתים ששינו את הגודל שלהם באופן אוטומטי להקטין את הגודל שלהם. אפשר גם למחוק את הצמתים האלה באופן ידני על ידי הפעלת הפקודה gcloud compute instances delete <Instance Name> לכל מופע, או באמצעות ממשק המשתמש הגרפי של Console כדי לבחור כמה צמתים וללחוץ על Delete (מחיקה).

אחרי שמסיימים, אפשר לנקות בקלות את הפריסה של Terraform על ידי הרצת הפקודה הבאה מ-Google Cloud Shell, אחרי שמתנתקים מ-g1-login0:

cd ~/slurm-gcp/tf/examples/basic
terraform destroy -var-file=basic.tfvars

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

מחיקת הפרויקט

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

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

מה נכלל

איך פורסים את Slurm ב-GCP באמצעות Terraform.
איך מריצים עבודה באמצעות Slurm ב-GCP.
איך מריצים שאילתות לגבי מידע על אשכולות ומנטרים משימות שפועלות ב-Slurm.
איך משתמשים ב-Slurm ב-GCP כדי להגדיל או להקטין באופן אוטומטי את מספר הצמתים בהתאם לפרמטרים ולדרישות ספציפיים של עבודות.
איך קומפילציה והרצה של אפליקציות MPI ב-Slurm ב-GCP.

מקורות תמיכה ב-Slurm

אם אתם צריכים תמיכה בשימוש בשילובים האלה בסביבות בדיקה או בסביבות ייצור, אתם יכולים ליצור קשר ישירות עם SchedMD באמצעות דף יצירת הקשר שלהם כאן: https://www.schedmd.com/contact.php

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

מדריך לפתרון בעיות ב-Slurm ב-GCP: https://github.com/SchedMD/slurm-gcp#troubleshooting
מדריך לפתרון בעיות של SchedMD: https://slurm.schedmd.com/troubleshoot.html

בנוסף, אפשר לפרסם את השאלה בקבוצת הדיון בנושא Google Cloud ו-Slurm בכתובת: https://groups.google.com/g/google-cloud-slurm-discuss

מידע נוסף

משוב

נשמח לקבל משוב על ה-Codelab הזה באמצעות הקישור הזה. מילוי טופס המשוב יימשך פחות מ-5 דקות. תודה!