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

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

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

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

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

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

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

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

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

התפקידים הנדרשים

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

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

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

קבלת קיבולת

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

כדי לקבל קיבולת באמצעות מקום שמור לעתיד, אפשר לעיין בשורה Future reservations in AI Hypercomputer בטבלה שבמאמר How to obtain capacity.

דרישות

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

  • ב-A4X Max, צריך להשתמש באחת מהגרסאות הבאות:

    • לגרסה 1.35 ואילך, צריך להשתמש בגרסה ‎1.35.0-gke.2745000 ואילך של GKE.
    • בגרסה 1.34, צריך להשתמש בגרסה ‎1.34.3-gke.1318000 ואילך של GKE.

    הגרסאות האלה עוזרות לוודא ש-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 יחיד. כמה Pods לא יכולים לחלוק RDMA בצומת GKE יחיד.

  • כדי ליצור אשכולות עם A4X Max, צריך להשתמש במודל הקצאת משאבים שמבוסס על הזמנה. מודלים אחרים של הקצאת משאבים לא נתמכים.

  • בהוראות האלה נעשה שימוש ב-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 בשם של תת-הבלוק.

יצירת אשכול 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, צריך לבצע את השלבים שמתוארים בקטעים הבאים:

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

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

יצירת אשכול GKE

  1. יוצרים אשכול 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.

  2. כדי להריץ את הפקודות kubectl בקטעים הבאים, צריך להתחבר לאשכול:

    gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

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

    • ‫CLUSTER_NAME: השם של האשכול.
    • ‫COMPUTE_REGION: השם של אזור ה-Compute.

    מידע נוסף מופיע במאמר בנושא התקנה של kubectl והגדרת גישה לאשכול.

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

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

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

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

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

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

export NODE_CUSTOM=node_custom.yaml

  2. יוצרים מאגר צמתים של 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 asapd-lite לא תקין מצביע על כך שאין קישוריות RDMA.

  1. מתקינים את 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

  2. מאמתים את העותקים ב-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 ל-GPU.

  1. מוודאים ש-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

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

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

  3. יוצרים אובייקט ResourceQuota עבור מנהל ההתקן של DRA:

    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 לפחות.

  4. מתקינים את ה-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

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

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

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

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

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

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

  5. יוצרים 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

  6. מציינים את 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

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

    ‫Debian 12+‎/Ubuntu 20.04+‎ (חבילת ‎.deb)

    apt update
apt install curl

# Fetch DOCA OFED userspace libraries
export DOCA_URL="https://linux.mellanox.com/public/repo/doca/latest/ubuntu22.04/arm64-sbsa/"
export BASE_URL="https://linux.mellanox.com/public/repo/doca"
curl "${BASE_URL}/GPG-KEY-Mellanox.pub" | gpg --dearmor -o /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub
echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] ${DOCA_URL} ./" | tee /etc/apt/sources.list.d/doca.list

apt update
apt install doca-ofed-userspace

# Upgrade to latest NCCL for best compatibility
apt install --only-upgrade --allow-change-held-packages 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.

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