Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

יצירת אשכול GKE מותאם אישית שעבר אופטימיזציה באמצעות AI ומשתמש ב-A4X Max

במאמר הזה נסביר איך ליצור אשכול Google Kubernetes Engine ‏ (GKE) שעבר אופטימיזציה ל-AI, ומשתמש במכונות Compute Engine מסוג A4X Max כדי לתמוך בעומסי העבודה של AI ו-ML.

סדרת A4X ו-A4X Max מאפשרת להריץ אשכולות AI/ML בקנה מידה גדול באמצעות מערכת NVIDIA Multi-Node NVLink (MNNVL), פתרון בקנה מידה של מתלה שמאפשר עוצמה וביצועים גבוהים יותר של GPU. המכונות האלה מציעות תכונות כמו מיקום ממוקד של עומסי עבודה, תזמון שמודע לטופולוגיה ואמצעי בקרה מתקדמים לתחזוקת אשכולות. מידע נוסף מופיע במאמר בנושא יכולות ניהול של אשכולות. ב-GKE, באמצעות A4X Max, יש גם הגדרה אוטומטית של הרשת, שמפשטת את הגדרת האשכול.

עומסי עבודה של AI ו-ML, כמו אימון מבוזר, דורשים האצה חזקה כדי לשפר את הביצועים על ידי קיצור הזמן שנדרש להשלמת המשימות. ‫GKE מספק פלטפורמה יחידה להרצת מגוון רחב של עומסי עבודה בארגון, וכך מצמצם את העומס התפעולי הכרוך בניהול של פלטפורמות מרובות. אתם יכולים להריץ עומסי עבודה כמו אימון מוקדם מבוזר עם ביצועים גבוהים, כוונון עדין של מודלים, הסקת מסקנות לגבי מודלים, מילוי בקשות של אפליקציות ושירותים תומכים. עבור עומסי עבודה שדורשים ביצועים גבוהים, קצב העברת נתונים גבוה וזמן אחזור נמוך,‏ GPUDirect RDMA מפחית את מספר הקפיצות ברשת שנדרשות להעברת נתוני payload אל וממעבדי GPU. הגישה הזו מאפשרת שימוש יעיל יותר ברוחב הפס הזמין ברשת. מידע נוסף זמין במאמר בנושא ערימות של רשתות GPU.

במסמך הזה תלמדו איך ליצור אשכול GKE באמצעות Google Cloud CLI, כדי להגדיר את האשכול בצורה הכי גמישה בהתאם לצרכים של עומס העבודה. כדי להשתמש ב-CLI של gcloud כדי ליצור אשכולות עם סוגי מכונות אחרים, אפשר לעיין במאמרים הבאים:

‫A4X: יצירת אשכול GKE מותאם אישית שעבר אופטימיזציה ל-AI ומשתמש ב-A4X.
‫A4 או A3 Ultra: כדי ליצור אשכול שמשתמש ב-A4 או ב-A3 Ultra, אפשר לעיין במאמר בנושא יצירת אשכול GKE מותאם אישית שעבר אופטימיזציה ל-AI ומשתמש ב-A4 או ב-A3 Ultra. אתם יכולים להשתמש בסדרות המכונות האלה כדי להריץ עומסי עבודה עם או בלי GPUDirect RDMA.

אפשר גם להשתמש ב-Cluster Toolkit כדי לפרוס במהירות את האשכול עם הגדרות ברירת מחדל שמשקפות שיטות מומלצות לתרחישי שימוש רבים. מידע נוסף זמין במאמר בנושא יצירת אשכול GKE שעבר אופטימיזציה ל-AI עם הגדרת ברירת מחדל.

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

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

מפעילים את ממשק Google Kubernetes Engine API.

הפעלת Google Kubernetes Engine API

אם רוצים להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את ה-CLI של gcloud. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.
הערה: אם כבר התקנתם את ה-CLI של gcloud, הקפידו להגדיר את compute/region המאפיין. אם אתם משתמשים בעיקר באשכולות אזוריים, עליכם להגדיר את compute/zone במקום זאת. אם מגדירים מיקום ברירת מחדל, אפשר להימנע משגיאות ב-CLI של gcloud כמו השגיאה הבאה: One of [--zone, --region] must be supplied: Please specify location. יכול להיות שתצטרכו לציין את המיקום בפקודות מסוימות אם המיקום של האשכול שונה מברירת המחדל שהגדרתם.

קבלת קיבולת

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

כדי לקבל קיבולת באמצעות מקום שמור לעתיד, אפשר לעיין בשורה מקום שמור לעתיד ב-AI Hypercomputer בטבלה שבמאמר איך מקבלים קיבולת.

דרישות

הדרישות הבאות חלות על אשכול GKE שעבר אופטימיזציה ל-AI עם מופעי מחשוב של A4X Max:

ב-A4X Max, צריך להשתמש באחת מהגרסאות הבאות:
- בגרסה 1.35 ואילך, צריך להשתמש ב-GKE בגרסה ‎1.35.0-gke.2745000 ואילך.
- בגרסה 1.34, צריך להשתמש ב-GKE בגרסה ‎1.34.3-gke.1318000 ואילך.
הגרסאות האלה עוזרות לוודא שמכשיר A4X Max משתמש ב:
- ‫R580.95.05, הגרסה המינימלית של מנהל ההתקן של GPU ל-A4X Max, שמופעלת כברירת מחדל.
- ניהול זיכרון עקבי שמבוסס על מנהלי התקנים (CDMM), שמופעל כברירת מחדל. ‫NVIDIA ממליצה להפעיל את המצב הזה באשכולות Kubernetes כדי לפתור בעיות של דיווח יתר על זיכרון. ‫CDMM מאפשר לנהל את זיכרון ה-GPU דרך הדרייבר במקום דרך מערכת ההפעלה (OS). הגישה הזו עוזרת לכם להימנע מהעברת זיכרון GPU למצב אונליין במערכת ההפעלה, ומציגה את זיכרון ה-GPU כצומת Non-Uniform Memory Access ‏ (NUMA) למערכת ההפעלה. אין תמיכה ב-GPU מרובה מופעים כש-CDMM מופעל. מידע נוסף על CDMM זמין במאמר תמיכה בציוד ובתוכנה.
- ‫GPUDirect RDMA ו-MNNVL, שמומלץ להפעיל כדי שמאגרי הצמתים של A4X Max יוכלו להשתמש ביכולות הרשת של A4X Max.
הצמתים של GKE צריכים להשתמש בתמונת צומת של מערכת הפעלה שמותאמת לקונטיינרים. אין תמיכה בתמונות של צמתים ב-Ubuntu וב-Windows.
עומס העבודה ב-GKE צריך להשתמש בכל יחידות ה-GPU הזמינות, וה-Pod צריך להשתמש בכל כרטיסי ה-NIC המשניים הזמינים בצומת GKE יחיד. אי אפשר לשתף RDMA בין כמה Pods באותו צומת GKE.
כדי ליצור אשכולות עם A4X Max, צריך להשתמש במודל הקצאת המשאבים reservation-bound. אין תמיכה במודלים אחרים של הקצאת משאבים.
בהוראות האלה נעשה שימוש ב-DRANET כדי להגדיר אשכול GKE שעבר אופטימיזציה ל-AI עם A4X Max. לא ניתן להשתמש בריבוי רשתות בסוג המכונה a4x-maxgpu-4g-metal.

שיקולים ליצירת אשכול

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

בוחרים מיקום של אשכול:
- מוודאים שאתם משתמשים במיקום שבו יש זמינות לסוג המכונה שבחרתם. מידע נוסף זמין במאמר בנושא זמינות של מאיצים.
- כשיוצרים מאגרי צמתים באשכול אזורי – מומלץ להשתמש באשכולות כאלה לעומסי עבודה של ייצור – אפשר להשתמש בדגל --node-locations כדי לציין את האזורים לצמתים של GKE.
בוחרים גרסת מנהל התקן:
- גרסת הדרייבר יכולה להיות אחת מהאפשרויות הבאות:
  - ‫default: התקנת גרסת ברירת המחדל של מנהל ההתקן לגרסת הצומת של GKE. מידע נוסף על הדרישות לגבי גרסאות ברירת מחדל של מנהלי התקנים זמין בקטע דרישות.
  - ‫latest: התקנת הגרסה האחרונה של מנהל ההתקן שזמינה לגרסת GKE שלכם. האפשרות הזו זמינה רק לצמתים שמשתמשים במערכת הפעלה שמותאמת לקונטיינרים.
  - ‫disabled: דילוג על התקנה אוטומטית של מנהל התקן. צריך להתקין מנהל התקן באופן ידני אחרי שיוצרים את מאגר הצמתים.
- מידע נוסף על הגרסאות של מנהלי ההתקנים (דרייברים) של GPU שמוגדרות כברירת מחדל ועל הגרסאות העדכניות של מנהלי ההתקנים (דרייברים) של GPU לגרסאות של צומתי GKE זמין בטבלה שבקטע התקנה ידנית של מנהלי ההתקנים (דרייברים) של NVIDIA GPU.
בחירת שיוך להזמנה:
- תוכלו למצוא מידע על ההזמנה, כמו שם ההזמנה או שם של בלוק ספציפי בהזמנה. כדי למצוא את הערכים האלה, אפשר לעיין במאמר בנושא צפייה במקומות שמורים לעתיד.
- הדגל --reservation-affinity יכול לקבל את הערכים specific או any. עם זאת, כדי להשיג ביצועים גבוהים בעומסי עבודה מבוססי-AI מבוזרים, מומלץ להשתמש בהזמנה ספציפית.
- כשמשתמשים בהזמנה ספציפית, כולל הזמנות משותפות, צריך לציין את הערך של הדגל --reservation בפורמט הבא:
```
projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME
```
  מחליפים את הערכים הבאים:
  - ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
  - ‫RESERVATION_NAME: השם של ההזמנה.
  - ‫BLOCK_NAME: השם של בלוק ספציפי בהזמנה.
  מומלץ גם להשתמש בהזמנה ממוקדת של תת-בלוק, כדי שמופעי המחשוב יוצבו בתת-בלוק יחיד בתוך BLOCK_NAME. מוסיפים את הטקסט הבא לסוף הנתיב:
```
/reservationSubBlocks/SUB_BLOCK_NAME
```
  מחליפים את SUB_BLOCK_NAME בשם של תת-הבלוק.
  
  הערה: אם ההזמנה נמצאת בפרויקט הנוכחי, אפשר להשמיט את projects/PROJECT_ID/reservations/ מערך ההזמנה.

יצירת אשכול GKE שעבר אופטימיזציה ל-AI ומשתמש ב-A4X Max וב-GPUDirect RDMA

במקרים של עומסי עבודה מבוזרים של AI, לעיתים קרובות מקשרים בין כמה צמתים של GPU כדי שיפעלו כמחשב אחד. ‫A4X Max היא פלטפורמה בקנה מידה אקססקייל שמבוססת על ארכיטקטורת NVIDIA GB300 NVL72 בקנה מידה של מתלה. מופעי מחשוב של A4X Max משתמשים בארכיטקטורת רשת היררכית רב-שכבתית עם ארכיטקטורת rail-aligned, כדי לייעל את הביצועים עבור סוגים שונים של תקשורת. סוג המכונה הזה מאפשר הרחבה ושיתוף פעולה בין כמה יחידות GPU, ומספק חוויית ענן עם ביצועים גבוהים לעומסי עבודה של AI. מידע נוסף על ארכיטקטורת הרשת של A4X Max, כולל רוחב הפס של הרשת והסידור של כרטיס הרשת, זמין במאמר סוג המכונה A4X Max (bare metal).

כדי ליצור אשכול GKE Standard עם A4X Max שמשתמש ב-GPUDirect RDMA וב-MNNVL, צריך לבצע את השלבים שמתוארים בקטעים הבאים:

יצירת אשכול GKE
יצירת מדיניות של עומס עבודה
יצירת מאגר צמתים עם A4X Max
הגדרת כרטיסי ה-NIC של MRDMA באמצעות asapd-lite
התקנת ה-CRD של NVIDIA Compute Domain והדרייבר של DRA
הגדרת מניפסט של עומס עבודה עבור RDMA ודומיין IMEX

בהוראות האלה נעשה שימוש בפרופילים של רשתות מאיצים כדי להגדיר באופן אוטומטי רשתות VPC ורשתות משנה עבור צמתי A4X Max. אפשר גם לציין במפורש את רשת ה-VPC ואת רשתות המשנה.

יצירת אשכול GKE

יצירת אשכול GKE Standard:
```
gcloud container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 \
  --enable-ip-alias \
  --location=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION \
  --no-enable-shielded-nodes [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR \
  --addons=GcpFilestoreCsiDriver=ENABLED]
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫CLUSTER_NAME: השם של האשכול.
- ‫CLUSTER_VERSION: הגרסה של האשכול החדש. מידע נוסף על הגרסה של GKE שתומכת בהגדרה שלכם זמין בקטע דרישות במאמר הזה.
- ‫COMPUTE_REGION: השם של אזור ה-Compute.
- אופציונלי: אפשר לציין במפורש את טווחי ה-CIDR המשניים לשירותים ול-Pods. אם משתמשים בדגלים האופציונליים האלה, צריך להחליף את המשתנים הבאים:
  - ‫SERVICE_CIDR: טווח ה-CIDR המשני לשירותים.
  - ‫POD_CIDR: טווח ה-CIDR המשני של ה-Pods.
  כשמשתמשים בדגלים האלה, צריך לוודא שטווח ה-CIDR לא חופף לטווח של רשתות משנה ברשתות צמתים נוספות. לדוגמה, נניח שיש לכם את המשאבים SERVICE_CIDR=10.65.0.0/19 ו-POD_CIDR=10.64.0.0/19. מידע נוסף מופיע במאמר בנושא הוספת טווחי כתובות IPv4 של Pod.
כדי להריץ את הפקודות kubectl בקטעים הבאים, צריך להתחבר לאשכול:
```
gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫CLUSTER_NAME: השם של האשכול.
- ‫COMPUTE_REGION: השם של אזור ה-Compute.
מידע נוסף מופיע במאמר התקנה של kubectl והגדרת גישה לאשכול.

יצירת מדיניות של עומס עבודה

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

יוצרים מדיניות של עומס עבודה עם השדה accelerator_topology שמוגדר לערך 1x72.HIGH_THROUGHPUT

gcloud beta compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type HIGH_THROUGHPUT \
    --accelerator-topology 1x72 \
    --project PROJECT \
    --region COMPUTE_REGION

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

‫WORKLOAD_POLICY_NAME: השם של מדיניות עומסי העבודה.
‫PROJECT: שם הפרויקט.
‫COMPUTE_REGION: השם של אזור ה-Compute.

יצירת מאגר צמתים עם A4X Max

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

cat > node_custom.yaml <<EOF
linuxConfig:
  hugepageConfig:
    hugepage_size2m: 4096
EOF

export NODE_CUSTOM=node_custom.yaml

יצירת מאגר צמתים של A4X Max:
```
gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=COMPUTE_REGION \
    --node-locations=COMPUTE_ZONE \
    --num-nodes=NODE_COUNT \
    --placement-policy=WORKLOAD_POLICY_NAME \
    --machine-type=a4x-maxgpu-4g-metal \
    --accelerator=type=nvidia-gb300,count=4,gpu-driver-version=latest \
    --system-config-from-file=${NODE_CUSTOM} \
    --accelerator-network-profile=auto \
    --node-labels=cloud.google.com/gke-networking-dra-driver=true,cloud.google.com/gke-dpv2-unified-cni=cni-migration \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUB_BLOCK_NAME
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫NODE_POOL_NAME: שם מאגר הצמתים.
- ‫CLUSTER_NAME: השם של האשכול.
- ‫COMPUTE_REGION: האזור של שירותי ה-Compute של האשכול.
- ‫COMPUTE_ZONE: האזור של מאגר הצמתים.
- ‫NODE_COUNT: מספר הצמתים במאגר הצמתים, שחייב להיות 18 צמתים או פחות. מומלץ להשתמש ב-18 צמתים כדי לקבל את טופולוגיית ה-GPU של 1x72 בתת-בלוק אחד באמצעות דומיין NVLink.
- ‫WORKLOAD_POLICY_NAME: השם של מדיניות העומס שיצרתם קודם.
- ‫RESERVATION_NAME: השם של ההזמנה. כדי למצוא את הערך הזה, אפשר לעיין במאמר בנושא צפייה במקום שמור לעתיד.
- ‫BLOCK_NAME: השם של בלוק ספציפי בהזמנה. כדי למצוא את הערך הזה, אפשר לעיין במאמר בנושא צפייה במקום שמור לעתיד.
הפקודה הזו יוצרת באופן אוטומטי רשת שמקשרת את כל הצמתים של A4X Max באזור יחיד באמצעות auto פרופיל רשת המאיץ. כשיוצרים מאגר צמתים עם הדגל --accelerator-network-profile=auto, ‏ GKE מוסיף באופן אוטומטי את התווית gke.networks.io/accelerator-network-profile: auto לצמתים. כדי לתזמן עומסי עבודה בצמתים האלה, צריך לכלול את התווית הזו בשדה nodeSelector של עומס העבודה.

מגדירים את כרטיסי ה-NIC של MRDMA באמצעות `asapd-lite`

ה-DaemonSet‏ asapd-lite מגדיר את כרטיסי ה-NIC של MRDMA. יכול להיות ש-DaemonSet לא תקין מצביע על כך שאין קישוריות RDMA.asapd-lite

מתקינים את DaemonSet:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/asapd-lite-installer/asapd-lite-installer-a4x-max-bm-cos.yaml

מאמתים את העותקים הזהים ב-asapd-lite DaemonSet:
```
kubectl get daemonset -n kube-system asapd-lite
```
הפלט אמור להיראות כך:
```
NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
asapd-lite   18        18        18      18           18          <none>          5m
```
מספר העותקים של READY צריך להיות זהה למספר הצמתים שנוצרו ופועלים במאגר הצמתים.

התקנה של NVIDIA Compute Domain CRD ושל דרייבר DRA

בשלבים הבאים מוסבר איך להתקין את ה-CRD של NVIDIA Compute Domain ואת הדרייבר של DRA כדי להשתמש ב-MNNVL. מידע נוסף זמין במאמר בנושא NVIDIA DRA Driver for GPUs.

מוודאים ש-Helm מותקן בסביבת הפיתוח. ‫Helm מותקן מראש ב-Cloud Shell.

אין דרישה ספציפית לגרסת Helm, אבל אפשר להשתמש בפקודה הבאה כדי לוודא ש-Helm מותקן.
```
helm version
```
אם הפלט דומה ל-Command helm not found, אפשר להתקין את Helm CLI:
```
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh
```

מוסיפים את מאגר NVIDIA Helm:

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

יוצרים אובייקט ResourceQuota עבור DRA Driver:

export POD_QUOTA=POD_QUOTA

kubectl create ns nvidia-dra-driver-gpu

kubectl apply -n nvidia-dra-driver-gpu -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: nvidia-dra-driver-gpu-quota
spec:
  hard:
    pods: ${POD_QUOTA}
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

מחליפים את POD_QUOTA במספר שהוא לפחות פי 2 ממספר הצמתים של A4X Max באשכול ועוד 1. לדוגמה, אם יש לכם 18 צמתים של A4X Max באשכול, אתם צריכים להגדיר את המשתנה ל-37 לפחות.

מתקינים את ה-CRD של ComputeDomain ואת מנהל ה-DRA:

helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --set controller.args.v=4 --set kubeletPlugin.args.v=4 \
    --version="25.8.0" \
    --create-namespace \
    --namespace nvidia-dra-driver-gpu \
    -f <(cat <<EOF
nvidiaDriverRoot: /home/kubernetes/bin/nvidia
resources:
  gpus:
    enabled: false

controller:
  affinity:
      nodeAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          nodeSelectorTerms:
          - matchExpressions:
            - key: "nvidia.com/gpu"
              operator: "DoesNotExist"

kubeletPlugin:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: cloud.google.com/gke-accelerator
                operator: In
                values:
                  - nvidia-gb300
              - key: kubernetes.io/arch
                operator: In
                values:
                  - arm64

  tolerations:
    - key: nvidia.com/gpu
      operator: Equal
      value: present
      effect: NoSchedule
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule
EOF
)

הגדרת מניפסט עומס העבודה עבור RDMA ודומיין IMEX

מוסיפים כלל של שיוך צומת כדי לתזמן את עומס העבודה בצמתי Arm:

spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        -   matchExpressions:
          -   key: kubernetes.io/arch
            operator: In
            values:
            -   arm64

מוסיפים את נפח האחסון הבא למפרט של ה-Pod:

spec:
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia

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

containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia

    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 4

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

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel

מחליפים את NUM_NODES במספר הצמתים שנדרשים לעומס העבודה.

יוצרים ResourceClaimTemplate כדי להקצות משאבי רשת באמצעות DRANET ומבקשים מכשירי RDMA בשביל ה-Pod:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-mrdma
spec:
  spec:
    devices:
      requests:
      - name: req-mrdma
        exactly:
          deviceClassName: mrdma.google.com
          allocationMode: ExactCount
          count: 8

מציינים את ResourceClaimTemplate שבו משתמש ה-Pod:

spec:
  ...
  volumes:
    ...
  containers:
    - name: my-container
      ...
      resources:
        limits:
          nvidia.com/gpu: 4
  claims:
          - name: compute-domain-channel
          - name: rdma
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-max-compute-domain-channel
  - name: rdma
    resourceClaimTemplateName: all-mrdma

מוודאים שספריות מרחב המשתמש וחבילות libnccl מותקנות בקובץ האימג' של קונטיינר המשתמש:

apt update -y
apt install -y curl
export DOCA_URL="https://linux.mellanox.com/public/repo/doca/3.1.0/ubuntu22.04/arm64-sbsa/"
BASE_URL=$([ "${DOCA_PREPUBLISH:-false}" = "true" ] && echo https://doca-repo-prod.nvidia.com/public/repo/doca || echo https://linux.mellanox.com/public/repo/doca)
DOCA_SUFFIX=${DOCA_URL#*public/repo/doca/}; DOCA_URL="$BASE_URL/$DOCA_SUFFIX"
curl $BASE_URL/GPG-KEY-Mellanox.pub | gpg --dearmor > /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub
echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] $DOCA_URL ./" > /etc/apt/sources.list.d/doca.list
apt update
apt -y install doca-ofed-userspace
# The installed libnccl2 is 2.27.7, to upgrade to 2.28.9 as we recommend
apt install --only-upgrade --allow-change-held-packages -y libnccl2 libnccl-dev

מפרט Pod מלא נראה כך:

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes:  NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
spec:
  ...
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: kubernetes.io/arch
            operator: In
            values:
            - arm64
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
  hostNetwork: true
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 4
        claims:
          - name: compute-domain-channel
          - name: rdma
        ...
  resourceClaims:
    - name: compute-domain-channel
      resourceClaimTemplateName: a4x-max-compute-domain-channel
    - name: rdma
      resourceClaimTemplateName: all-mrdma

בדיקת ביצועי הרשת

מומלץ לאמת את הפונקציונליות של האשכולות שהוקצו. כדי לעשות זאת, משתמשים בבדיקות NCCL/gIB, שהן בדיקות של NVIDIA Collective Communications Library ‏(NCCL) שעברו אופטימיזציה לסביבת Google.

מידע נוסף זמין במאמר בנושא הרצת NCCL באשכולות GKE בהתאמה אישית שמשתמשים ב-A4X Max.

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

כדי לקבל מידע על תזמון עומסי עבודה באשכולות GKE באמצעות TAS ו-Kueue, אפשר לקרוא את המאמר תזמון עומסי עבודה ב-GKE באמצעות תזמון שמודע לטופולוגיה.
כדי לקבל מידע על ניהול אירועים נפוצים שרלוונטיים לאשכולות GKE ולעומסי עבודה של AI, אפשר לעיין במאמר ניהול אשכולות GKE שעברו אופטימיזציה ל-AI.