הקצאת Managed Lustre ב-GKE באמצעות XPK

במאמר הזה מוסבר איך לשלב את Managed Lustre עם GKE כדי ליצור סביבה אופטימלית לעומסי עבודה תובעניים ועתירי נתונים, כמו בינה מלאכותית (AI), למידת מכונה (ML) ומחשוב עתיר ביצועים (HPC).

במסמך הזה אתם תספקו אשכול GKE עם XPK, תיצרו מופע מנוהל של Lustre ותצרפו אותו לאשכול. כדי לבדוק את ההגדרה הזו, מריצים עומס עבודה בצמתים שמוקצים באמצעות flex-start.

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

רקע

בקטע הזה מתוארות הטכנולוגיות העיקריות שמופיעות במסמך הזה:

XPK

‫XPK הוא כלי שמפשט את ההקצאה והניהול של אשכולות ועומסי עבודה ב-GKE, במיוחד למשימות AI/ML. ‫XPK עוזר ליצור תשתית שהוגדרה מראש ועברה אופטימיזציה לאימון, ולכן הוא מהווה אפשרות טובה להוכחת היתכנות ולסביבות בדיקה.

אפשר ליצור אשכול שמשתמש ב-TPU באמצעות Google Cloud CLI או חבילת עיבוד מואץ (XPK).

  • משתמשים ב-CLI של gcloud כדי ליצור באופן ידני את מופע אשכול GKE, כדי לבצע התאמה אישית מדויקת או כדי להרחיב סביבות GKE קיימות של ייצור.
  • אפשר להשתמש ב-XPK כדי ליצור במהירות אשכולות GKE ולהריץ עומסי עבודה לצורך הוכחת היתכנות ובדיקות. מידע נוסף מופיע בקובץ ה-README של XPK.

במסמך הזה אנחנו משתמשים ב-XPK באופן בלעדי להקצאה ולניהול של משאבים.

מידע נוסף זמין במאמר בנושא Accelerated Processing Kit (XPK).

Flex-start

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

בדוגמה הזו נעשה שימוש באפשרות flex-start, אבל אפשר להשתמש גם באפשרויות אחרות, למשל הזמנות או Spot. מידע נוסף זמין במאמר אפשרויות צריכת מאיצים לעומסי עבודה של AI/ML ב-GKE.

Managed Lustre

‫Managed Lustre הוא שירות מערכת קבצים מקבילית עם ביצועים גבוהים, שמיועד לעומסי עבודה תובעניים. מנהל ההתקן של ה-CSI של Managed Lustre מאפשר לשלב מופעים של Managed Lustre עם GKE, באמצעות טענות סטנדרטיות של Kubernetes לגבי נפח אחסון מתמיד (PVC) ונפחי אחסון מתמיד (PV). הדרייבר הזה שימושי במיוחד לעומסי עבודה של AI,‏ ML ו-HPC שדורשים אחסון מתמשך, ניתן להרחבה ובעל תפוקה גבוהה.

מידע נוסף זמין במאמר About the Managed Lustre CSI driver (מידע על מנהל ההתקן של Lustre CSI).

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

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

  • מפעילים את Google Cloud Managed Lustre API ואת Google Kubernetes Engine API.
    • הפעלת ממשקי API
  • כדי להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את gcloud CLI. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.

הכנת הסביבה

בקטע הזה מוסבר איך להכין את סביבת האשכול.

  1. בחלון המסוף החדש, יוצרים סביבה וירטואלית:

    VENV_DIR=~/venvp4;python3 -m venv $VENV_DIR;source $VENV_DIR/bin/activate

  2. כדי להתקין את XPK, פועלים לפי השלבים בקובץ XPK installation. במקום לשכפל ממקור, משתמשים ב-pip install.

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

    gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=CLUSTER_NAME
export GKE_VERSION=VERSION
export NETWORK_NAME=NETWORK_NAME
export IP_RANGE_NAME=IP_RANGE_NAME
export FIREWALL_RULE_NAME=FIREWALL_RULE_NAME
export ACCELERATOR_TYPE=v6e-16
export NUM_SLICES=1

    מחליפים את הערכים הבאים:

    הפקודות הקודמות מגדירות סוג של מאיץ v6e-16. ההגדרה הזו כוללת את המשתנים הבאים:

    • ‫ACCELERATOR_TYPE=v6e-16: מתאים ל-TPU Trillium עם טופולוגיה של 4x4. גרסת ה-TPU הזו מורה ל-GKE להקצות מאגר צמתים של פרוסת TPU עם כמה מארחים. ‫v6e-16 ממופה לסוג המכונה ct6e-standard-4t ב-GKE.
    • ‫NUM_SLICES=1: מספר מאגרי הצמתים של פרוסות TPU ש-XPK יוצר עבור ACCELERATOR_TYPE שבוחרים.

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

    • כדי לזהות את גרסת ה-TPU, סוג המכונה ל-GKE, הטופולוגיה והאזור הזמין שבו רוצים להשתמש, אפשר לעיין במאמר תכנון של TPUs ב-GKE.
    • כדי למפות את סוג המכונה ב-GKE לסוג המאיץ ב-Cloud TPU API, אפשר לעיין בתיעוד של TPU Trillium‏ (v6e).

הכנת רשת VPC

מכינים רשת בענן וירטואלי פרטי (VPC) למופע Managed Lustre ולאשכול GKE.

  1. מפעילים את Service Networking API:

    gcloud services enable servicenetworking.googleapis.com \
        --project=${PROJECT_ID}

  2. יוצרים רשת VPC:

    gcloud compute networks create ${NETWORK_NAME} \
        --subnet-mode=auto --project=${PROJECT_ID} \
        --mtu=8896

  3. יוצרים טווח כתובות IP עבור שירותי VPC Peering:

    gcloud compute addresses create ${IP_RANGE_NAME} \
        --global \
        --purpose=VPC_PEERING \
        --prefix-length=20 \
        --description="Managed Lustre VPC Peering" \
        --network=${NETWORK_NAME} \
        --project=${PROJECT_ID}

  4. מקבלים את טווח ה-CIDR של טווח כתובות ה-IP:

    CIDR_RANGE=$(
    gcloud compute addresses describe ${IP_RANGE_NAME} \
            --global  \
            --format="value[separator=/](address, prefixLength)" \
            --project=${PROJECT_ID}
)

  5. יוצרים כלל של חומת אש שמאפשר תעבורת נתוני TCP מטווח כתובות ה-IP:

    gcloud compute firewall-rules create ${FIREWALL_RULE_NAME} \
        --allow=tcp:988,tcp:6988 \
        --network=${NETWORK_NAME} \
        --source-ranges=${CIDR_RANGE} \
        --project=${PROJECT_ID}

  6. מחברים את הקישור בין רשתות ה-VPC.

    gcloud services vpc-peerings connect \
        --network=${NETWORK_NAME} \
        --project=${PROJECT_ID} \
        --ranges=${IP_RANGE_NAME} \
        --service=servicenetworking.googleapis.com

יצירת מכונת אחסון של Managed Lustre

יוצרים מכונת אחסון של Managed Lustre.

  1. מגדירים משתני מופע של אחסון:

    export STORAGE_NAME=STORAGE_NAME
export STORAGE_THROUGHPUT=STORAGE_THROUGHPUT
export STORAGE_CAPACITY=STORAGE_CAPACITY_GIB
export STORAGE_FS=lfs

    מחליפים את הערכים הבאים:

  2. יוצרים את מופע Managed Lustre:

    gcloud lustre instances create ${STORAGE_NAME} \
        --per-unit-storage-throughput=${STORAGE_THROUGHPUT} \
        --capacity-gib=${STORAGE_CAPACITY} \
        --filesystem=${STORAGE_FS} \
        --location=${LOCATION} \
        --network=projects/${PROJECT_ID}/global/networks/${NETWORK_NAME} \
        --project=${PROJECT_ID} \
        --async # Creates the instance asynchronously

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

  3. בודקים את סטטוס הפעולה:

    gcloud lustre operations describe OPERATION_ID  \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

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

    gcloud lustre operations list \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

    המופע מוכן כשהפלט של הפקודה מציג done: true.

שימוש ב-XPK ליצירת אשכול GKE

שימוש ב-XPK כדי ליצור אשכול GKE עם מאגר צמתים.

יוצרים אשכול GKE:

xpk cluster create --cluster ${CLUSTER_NAME} \
        --num-slices=${NUM_SLICES} \
        --tpu-type=${ACCELERATOR_TYPE} \
        --zone=${LOCATION} \
        --project=${PROJECT_ID} \
        --gke-version=${GKE_VERSION} \
        --custom-cluster-arguments="--network=${NETWORK_NAME}" \
        --enable-lustre-csi-driver \
        --flex

הפקודה הזו יוצרת אשכול GKE באמצעות XPK. האשכול מוגדר לשימוש בהפעלה גמישה להקצאת צמתים, ומנהל התקן ה-CSI של Lustre המנוהל מופעל.

צירוף מכונת האחסון לאשכול

כדי להגדיר את PersistentVolume ‏ (PV) ואת PersistentVolumeClaim ‏ (PVC), נעשה שימוש בקטע הזה בפקודת צירוף האחסון XPK ‏ (xpk storage attach) עם קובץ מניפסט. בקטע הזה נעשה שימוש במניפסט לדוגמה מקוד המקור של XPK.

כדי לצרף את מכונת האחסון של Managed Lustre לאשכול GKE, מבצעים את השלבים הבאים:

  1. מורידים את קובץ המניפסט לדוגמה לספריית העבודה הנוכחית ושומרים אותו בשם lustre-manifest-attach.yaml.

  2. מעדכנים את קובץ המניפסט בפרטים של מכונת Managed Lustre:

    1. בקטע PersistentVolume, מחליפים את הערכים הבאים:

      • ‫STORAGE_SIZE: הגודל של מכונת Managed Lustre, ב-GiB.
      • ‫PROJECT_ID/ZONE/INSTANCE_NAME: נתיב המשאב המלא של מכונת Managed Lustre.
      • ‫IP_ADDRESS: כתובת ה-IP של מכונת Managed Lustre.
      • ‫FILE_SYSTEM: סוג מערכת הקבצים, שהוא lfs.

    2. בקטע PersistentVolumeClaim, מחליפים את הערכים הבאים:

      • ‫STORAGE_SIZE: הגודל של PersistentVolumeClaim, ב-GiB.

  3. מצרפים את מופע האחסון לאשכול:

    xpk storage attach ${STORAGE_NAME} \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
        --type=lustre \
        --mount-point='/lustre-data' \
        --readonly=false \
        --auto-mount=true \
        --manifest='./lustre-manifest-attach.yaml'

  4. מוודאים שצירפתם את האחסון לאשכול:

    xpk storage list \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION}

הפעלת עומס עבודה

הפעלת עומס עבודה עם מכונת Managed Lustre המצורפת . הפקודה הבאה לדוגמה מציגה רשימה של הדיסקים הזמינים ויוצרת קובץ בשם hello בספרייה של מכונת Managed Lustre.

יוצרים ומריצים את עומס העבודה:

‫
xpk workload create --workload test-lustre \
--cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
--command="df -h && echo 'hello' > /lustre-data/hello.txt && cat /lustre-data/hello.txt" \
--tpu-type=${ACCELERATOR_TYPE} \
--num-slices=1 \
--flex

הסרת המשאבים

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

  xpk cluster delete --cluster ${CLUSTER_NAME} \
        --zone ${LOCATION} \
        --project ${PROJECT_ID}

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