הצגת מודלים מסוג LLM כמו DeepSeek-R1 671B או Llama 3.1 405B ב-GKE

סקירה כללית

במדריך הזה נסביר איך להכניס לשימוש בסביבת הייצור מודלי שפה גדולים (LLM) המתקדמים ביותר (SOTA) כמו DeepSeek-R1 671B או Llama 3.1 405B ב-Google Kubernetes Engine ‏(GKE) באמצעות יחידות עיבוד גרפי (GPU) בכמה צמתים.

במדריך הזה נדגים איך להשתמש בטכנולוגיות ניידות בקוד פתוח – Kubernetes,‏ vLLM ו-API‏ LeaderWorkerSet‏ (LWS) – כדי לפרוס ולפרסם עומסי עבודה של AI/ML ב-GKE, תוך ניצול היתרונות של GKE: שליטה גרנולרית, יכולת הרחבה, עמידות, ניידות וחסכוניות.

לפני שקוראים את הדף הזה, חשוב לוודא שמכירים את הנושאים הבאים:

רקע

בקטע הזה מתוארות הטכנולוגיות העיקריות שמוזכרות במדריך הזה, כולל שני מודלים גדולים של שפה (LLM) שמשמשים כדוגמאות במדריך – DeepSeek-R1 ו-Llama 3.1 405B.

DeepSeek-R1

‫DeepSeek-R1 הוא מודל שפה גדול עם 671 מיליארד פרמטרים של DeepSeek, והוא מיועד להסקת מסקנות לוגיות, לחשיבה מתמטית ולפתרון בעיות בזמן אמת במשימות שונות שמבוססות על טקסט. ‫GKE מטפל בדרישות החישוב של DeepSeek-R1, ותומך ביכולות שלו באמצעות משאבים ניתנים להרחבה, מחשוב מבוזר ורשתות יעילות.

מידע נוסף זמין במאמרי העזרה של DeepSeek.

Llama 3.1 405B

‫Llama 3.1 405B הוא מודל שפה גדול (LLM) של מטא שנועד לביצוע מגוון רחב של משימות עיבוד שפה טבעית (NLP), כולל יצירת טקסט, תרגום ומענה לשאלות. ‫GKE מציע את התשתית החזקה שנדרשת כדי לתמוך בצרכים של אימון מבוזר והפעלת מודלים בסדר גודל כזה.

מידע נוסף זמין במאמרי העזרה בנושא Llama.

שירות Kubernetes מנוהל של GKE

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

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

‫GPUs

מעבדים גרפיים (GPU) מאפשרים להאיץ עומסי עבודה ספציפיים, כמו למידת מכונה ועיבוד נתונים. ‫GKE מציע צמתים שמצוידים במעבדי GPU עוצמתיים כאלה, וכך מאפשר לכם להגדיר את האשכול כדי להשיג ביצועים אופטימליים במשימות של למידת מכונה ועיבוד נתונים. ‫GKE מספק מגוון אפשרויות של סוגי מכונות להגדרת צמתים, כולל סוגי מכונות עם GPU מסוג NVIDIA H100,‏ L4 ו-A100.

מידע נוסף זמין במאמר בנושא יחידות GPU ב-GKE.

LeaderWorkerSet (LWS)

‫LeaderWorkerSet (LWS) הוא API לפריסה של Kubernetes שמיועד לטיפול בדפוסי פריסה נפוצים של עומסי עבודה של מסקנות מבוססות-AI/ML מרובות צמתים. ההצגה משרתים מרובי צמתים מתבססת על כמה Pod, שכל אחד מהם יכול לפעול בצומת אחר, כדי לטפל בעומס העבודה המבוזר של ההסקות. LWS מאפשרת להתייחס לכמה תרמילים כאל קבוצה, וכך מפשטת את הניהול של מודלים מבוזרים.

‫vLLM והצגה במספר מארחים

כשמפעילים מודלי שפה גדולים (LLM) שדורשים הרבה משאבי מחשוב, מומלץ להשתמש ב-vLLM ולהריץ את עומסי העבודה על יחידות GPU.

‫vLLM הוא פריימוורק קוד פתוח עם אופטימיזציה גבוהה להצגת מודלים גדולים של שפה (LLM). הוא יכול לשפר את קצב העברת הנתונים (throughput) של הצגת המודלים ביחידות GPU, עם תכונות כמו:

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

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

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

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

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

  • מקביליות דו-כיוונית בצינורות (pipeline) כדי לפצל את המודל בין שני הצמתים
  • מקביליות טנסור שמונה-כיוונית כדי לפצל את המודל בין שמונה מעבדי GPU בכל צומת

מידע נוסף זמין במסמכי התיעוד של vLLM.

מטרות

  1. מכינים את הסביבה עם אשכול GKE במצב Autopilot או במצב Standard.
  2. פריסת vLLM בכמה צמתים באשכול.
  3. משתמשים ב-vLLM כדי להפעיל את המודל באמצעות curl.

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

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

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  • Verify that billing is enabled for your Google Cloud project.

  • Enable the required API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  • Verify that billing is enabled for your Google Cloud project.

  • Enable the required API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

    •

  • צריך לוודא שיש לכם בפרויקט את התפקיד או התפקידים הבאים: roles/container.admin, roles/iam.serviceAccountAdmin, roles/iam.securityAdmin

    בדיקת התפקידים

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

      כניסה לדף IAM
    2. בוחרים את הפרויקט.

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

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

    מתן התפקידים

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

      כניסה לדף IAM
    2. בוחרים את הפרויקט.
    3. לוחצים על Grant access.

    4. בשדה New principals, מזינים את מזהה המשתמש. ‫ בדרך כלל מזהה המשתמש הוא כתובת האימייל של חשבון Google.

      ‫
    5. לוחצים על Select a role ומחפשים את התפקיד.
    6. כדי לתת עוד תפקידים, לוחצים על Add another role ומוסיפים אותם.
    7. לוחצים על Save.
  • אם עדיין אין לכם חשבון Hugging Face, אתם צריכים ליצור חשבון.
  • כדאי לעיין בדגמי ה-GPU וסוגי המכונות הזמינים כדי להבין איזה סוג מכונה ואזור מתאימים לצרכים שלכם.
  • בודקים שלפרויקט יש מכסה מספקת ל-NVIDIA_H100_MEGA. במדריך הזה נעשה שימוש בa3-highgpu-8g סוג המכונה, שמצוידת ב-8 NVIDIA H100 80GB GPUs. מידע נוסף על יחידות GPU ועל ניהול מכסות זמין במאמרים תכנון מכסת GPU ומכסת GPU.

גישה למודל

אפשר להשתמש במודלים Llama 3.1 405B או DeepSeek-R1.

DeepSeek-R1

יצירת אסימון גישה

אם עדיין אין לכם טוקן, יוצרים טוקן חדש של Hugging Face:

  1. לוחצים על הפרופיל שלך > הגדרות > טוקנים של גישה.
  2. לוחצים על New Token (טוקן חדש).
  3. מציינים שם לבחירתכם ותפקיד ברמת Read לפחות.
  4. לוחצים על יצירת אסימון.

Llama 3.1 405B

יצירת אסימון גישה

אם עדיין אין לכם טוקן, יוצרים טוקן חדש של Hugging Face:

  1. לוחצים על הפרופיל שלך > הגדרות > טוקנים של גישה.
  2. לוחצים על New Token (טוקן חדש).
  3. מציינים שם לבחירתכם ותפקיד ברמת Read לפחות.
  4. לוחצים על יצירת אסימון.

הכנת הסביבה

במדריך הזה משתמשים ב-Cloud Shell כדי לנהל משאבים שמתארחים ב-Google Cloud. ב-Cloud Shell מותקן מראש התוכנה שצריך למדריך הזה, כולל kubectl ו- ה-CLI של gcloud.

כדי להגדיר את הסביבה באמצעות Cloud Shell:

  1. במסוף Google Cloud , לוחצים על Activate Cloud Shell בGoogle Cloud מסוף כדי להפעיל סשן של Cloud Shell. סמל ההפעלה של Cloud Shell ייפתח סשן בחלונית התחתונה של מסוף Google Cloud .

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

    gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME=CLUSTER_NAME
export REGION=REGION
export ZONE=ZONE
export HF_TOKEN=HUGGING_FACE_TOKEN
export CLUSTER_VERSION=CLUSTER_VERSION

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

    • ‫PROJECT_ID: Google Cloud מזהה הפרויקט.
    • ‫CLUSTER_NAME: השם של אשכול GKE.
    • ‫CLUSTER_VERSION: גרסת GKE. כדי לקבל תמיכה ב-Autopilot, צריך להשתמש בגרסה 1.33 ואילך.
    • ‫REGION: האזור של אשכול GKE.
    • ‫ZONE: אזור שתומך במעבדי GPU מסוג NVIDIA H100 Tensor Core.

יצירת אשכול GKE

אתם יכולים להפעיל מודלים באמצעות vLLM בכמה צומתי GPU באשכול GKE Autopilot או Standard. מומלץ להשתמש באשכול Autopilot כדי ליהנות מחוויית Kubernetes מנוהלת באופן מלא. כדי לבחור את מצב הפעולה של GKE שהכי מתאים לעומסי העבודה שלכם, אפשר לעיין במאמר בחירת מצב פעולה של GKE.

טייס אוטומטי

ב-Cloud Shell, מריצים את הפקודה הבאה:

  gcloud container clusters create-auto ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --location=${REGION} \
    --cluster-version=${CLUSTER_VERSION}

רגילה

  1. יוצרים אשכול GKE Standard עם שני צמתי CPU:

    gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --num-nodes=2 \
    --location=REGION \
    --machine-type=e2-standard-16

  2. יוצרים מאגר צמתים מסוג A3 עם שני צמתים, כל אחד עם שמונה כרטיסי H100:

    gcloud container node-pools create gpu-nodepool \
    --node-locations=ZONE \
    --num-nodes=2 \
    --machine-type=a3-highgpu-8g \
    --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=LATEST \
    --placement-type=COMPACT \
    --cluster=CLUSTER_NAME
    --location=${REGION}

הגדרה של kubectl לתקשורת עם האשכול

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

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

יצירת סוד של Kubernetes לפרטי הכניסה של Hugging Face

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

kubectl create secret generic hf-secret \
  --from-literal=hf_api_token=${HF_TOKEN} \
  --dry-run=client -o yaml | kubectl apply -f -

התקנת LeaderWorkerSet

כדי להתקין את LWS, מריצים את הפקודה הבאה:

kubectl apply --server-side -f https://github.com/kubernetes-sigs/lws/releases/latest/download/manifests.yaml

מריצים את הפקודה הבאה כדי לוודא שהבקר LeaderWorkerSet פועל במרחב השמות lws-system:

kubectl get pod -n lws-system

הפלט אמור להיראות כך:

NAME                                     READY   STATUS    RESTARTS   AGE
lws-controller-manager-546585777-crkpt   1/1     Running   0          4d21h
lws-controller-manager-546585777-zbt2l   1/1     Running   0          4d21h

פריסת שרת מודלים של vLLM

כדי לפרוס את שרת מודל vLLM, פועלים לפי השלבים הבאים:

  1. מחילים את קובץ המניפסט, בהתאם למודל ה-LLM שרוצים לפרוס.

    DeepSeek-R1

    1. בודקים את קובץ המניפסט vllm-deepseek-r1-A3.yaml.

      
apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: vllm
spec:
  replicas: 1
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          role: leader
      spec:
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-h100-80gb
        containers:
          - name: vllm-leader
            image: vllm/vllm-openai:v0.8.5
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh leader --ray_cluster_size=$(LWS_GROUP_SIZE);
                python3 -m vllm.entrypoints.openai.api_server --port 8080 --model deepseek-ai/DeepSeek-R1 --tensor-parallel-size 8 --pipeline-parallel-size 2 --trust-remote-code --max-model-len 4096"
            resources:
              limits:
                nvidia.com/gpu: "8"
            ports:
              - containerPort: 8080
            readinessProbe:
              tcpSocket:
                port: 8080
              initialDelaySeconds: 15
              periodSeconds: 10
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 15Gi
    workerTemplate:
      spec:
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-h100-80gb
        containers:
          - name: vllm-worker
            image: vllm/vllm-openai:v0.8.5
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh worker --ray_address=$(LWS_LEADER_ADDRESS)"
            resources:
              limits:
                nvidia.com/gpu: "8"
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm   
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 15Gi
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-leader
spec:
  ports:
    - name: http
      port: 8080
      protocol: TCP
      targetPort: 8080
  selector:
    leaderworkerset.sigs.k8s.io/name: vllm
    role: leader
  type: ClusterIP

    2. מריצים את הפקודה הבאה כדי להחיל את המניפסט:

      kubectl apply -f vllm-deepseek-r1-A3.yaml

    Llama 3.1 405B

    1. בודקים את קובץ המניפסט vllm-llama3-405b-A3.yaml.

      
apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: vllm
spec:
  replicas: 1
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          role: leader
      spec:
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-h100-80gb
        containers:
          - name: vllm-leader
            image: vllm/vllm-openai:v0.8.5
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh leader --ray_cluster_size=$(LWS_GROUP_SIZE);
                python3 -m vllm.entrypoints.openai.api_server --port 8080 --model meta-llama/Meta-Llama-3.1-405B-Instruct --tensor-parallel-size 8 --pipeline-parallel-size 2"
            resources:
              limits:
                nvidia.com/gpu: "8"
            ports:
              - containerPort: 8080
            readinessProbe:
              tcpSocket:
                port: 8080
              initialDelaySeconds: 15
              periodSeconds: 10
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 15Gi
    workerTemplate:
      spec:
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-h100-80gb
        containers:
          - name: vllm-worker
            image: vllm/vllm-openai:v0.8.5
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh worker --ray_address=$(LWS_LEADER_ADDRESS)"
            resources:
              limits:
                nvidia.com/gpu: "8"
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm   
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 15Gi
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-leader
spec:
  ports:
    - name: http
      port: 8080
      protocol: TCP
      targetPort: 8080
  selector:
    leaderworkerset.sigs.k8s.io/name: vllm
    role: leader
  type: ClusterIP

    2. מריצים את הפקודה הבאה כדי להחיל את המניפסט:

      kubectl apply -f vllm-llama3-405b-A3.yaml

  2. מחכים עד שהורדת נקודת הבדיקה של המודל תסתיים. יכול להיות שהפעולה הזו תימשך כמה דקות.

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

    kubectl logs vllm-0 -c vllm-leader

    הפלט אמור להיראות כך:

    INFO 08-09 21:01:34 api_server.py:297] Route: /detokenize, Methods: POST
INFO 08-09 21:01:34 api_server.py:297] Route: /v1/models, Methods: GET
INFO 08-09 21:01:34 api_server.py:297] Route: /version, Methods: GET
INFO 08-09 21:01:34 api_server.py:297] Route: /v1/chat/completions, Methods: POST
INFO 08-09 21:01:34 api_server.py:297] Route: /v1/completions, Methods: POST
INFO 08-09 21:01:34 api_server.py:297] Route: /v1/embeddings, Methods: POST
INFO:     Started server process [7428]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)

פרסום המודל

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

kubectl port-forward svc/vllm-leader 8080:8080

אינטראקציה עם המודל באמצעות curl

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

DeepSeek-R1

בטרמינל חדש, שולחים בקשה לשרת:

curl http://localhost:8080/v1/completions \
-H "Content-Type: application/json" \
-d '{
    "model": "deepseek-ai/DeepSeek-R1",
    "prompt": "I have four boxes. I put the red box on the bottom and put the blue box on top. Then I put the yellow box on top the blue. Then I take the blue box out and put it on top. And finally I put the green box on the top. Give me the final order of the boxes from bottom to top. Show your reasoning but be brief",
    "max_tokens": 1024,
    "temperature": 0
}'

הפלט אמור להיראות כך:

{
"id": "cmpl-f2222b5589d947419f59f6e9fe24c5bd",
"object": "text_completion",
"created": 1738269669,
"model": "deepseek-ai/DeepSeek-R1",
"choices": [
  {
    "index": 0,
    "text": ".\n\nOkay, let's see. The user has four boxes and is moving them around. Let me try to visualize each step. \n\nFirst, the red box is placed on the bottom. So the stack starts with red. Then the blue box is put on top of red. Now the order is red (bottom), blue. Next, the yellow box is added on top of blue. So now it's red, blue, yellow. \n\nThen the user takes the blue box out. Wait, blue is in the middle. If they remove blue, the stack would be red and yellow. But where do they put the blue box? The instruction says to put it on top. So after removing blue, the stack is red, yellow. Then blue is placed on top, making it red, yellow, blue. \n\nFinally, the green box is added on the top. So the final order should be red (bottom), yellow, blue, green. Let me double-check each step to make sure I didn't mix up any steps. Starting with red, then blue, then yellow. Remove blue from the middle, so yellow is now on top of red. Then place blue on top of that, so red, yellow, blue. Then green on top. Yes, that seems right. The key step is removing the blue box from the middle, which leaves yellow on red, then blue goes back on top, followed by green. So the final order from bottom to top is red, yellow, blue, green.\n\n**Final Answer**\nThe final order from bottom to top is \\boxed{red}, \\boxed{yellow}, \\boxed{blue}, \\boxed{green}.\n</think>\n\n1. Start with the red box at the bottom.\n2. Place the blue box on top of the red box. Order: red (bottom), blue.\n3. Place the yellow box on top of the blue box. Order: red, blue, yellow.\n4. Remove the blue box (from the middle) and place it on top. Order: red, yellow, blue.\n5. Place the green box on top. Final order: red, yellow, blue, green.\n\n\\boxed{red}, \\boxed{yellow}, \\boxed{blue}, \\boxed{green}",
    "logprobs": null,
    "finish_reason": "stop",
    "stop_reason": null,
    "prompt_logprobs": null
  }
],
"usage": {
  "prompt_tokens": 76,
  "total_tokens": 544,
  "completion_tokens": 468,
  "prompt_tokens_details": null
}
}

Llama 3.1 405B

במסוף חדש, שולחים בקשה לשרת:

curl http://localhost:8080/v1/completions \
-H "Content-Type: application/json" \
-d '{
    "model": "meta-llama/Meta-Llama-3.1-405B-Instruct",
    "prompt": "San Francisco is a",
    "max_tokens": 7,
    "temperature": 0
}'

הפלט אמור להיראות כך:

{"id":"cmpl-0a2310f30ac3454aa7f2c5bb6a292e6c",
"object":"text_completion","created":1723238375,"model":"meta-llama/Llama-3.1-405B-Instruct","choices":[{"index":0,"text":" top destination for foodies, with","logprobs":null,"finish_reason":"length","stop_reason":null}],"usage":{"prompt_tokens":5,"total_tokens":12,"completion_tokens":7}}

הגדרת קנה מידה אוטומטי בהתאמה אישית

בקטע הזה מגדירים את התכונה 'התאמה אופקית של קבוצות Pod לעומס' כך שתשתמש במדדים מותאמים אישית של Prometheus. אתם משתמשים במדדים של השירות המנוהל של Google Cloud ל-Prometheus משרת vLLM.

מידע נוסף זמין במאמר בנושא השירות המנוהל של Google Cloud ל-Prometheus. ההגדרה הזו אמורה להיות מופעלת כברירת מחדל באשכול GKE.

  1. מגדירים את Custom Metrics Stackdriver Adapter באשכול:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

  2. מוסיפים את התפקיד Monitoring Viewer לחשבון השירות שבו משתמש מתאם Stackdriver של מדדים בהתאמה אישית:

    gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role roles/monitoring.viewer \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

  3. שומרים את קובץ המניפסט הבא בשם vllm_pod_monitor.yaml:

    
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
 name: vllm-pod-monitoring
spec:
 selector:
   matchLabels:
    leaderworkerset.sigs.k8s.io/name: vllm
    role: leader
 endpoints:
 - path: /metrics
   port: 8080
   interval: 15s

  4. החלת המניפסט על האשכול:

    kubectl apply -f vllm_pod_monitor.yaml

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

יוצרים עומס על שרת vLLM כדי לבדוק איך GKE מבצע התאמה אוטומטית לעומס (autoscaling) באמצעות מדד vLLM מותאם אישית.

  1. מגדירים העברה ליציאה אחרת למודל:

    kubectl port-forward svc/vllm-leader 8080:8080

  2. מריצים סקריפט bash‏ (load.sh) כדי לשלוח N בקשות מקבילות לנקודת הקצה של vLLM:

    #!/bin/bash
# Set the number of parallel processes to run.
N=PARALLEL_PROCESSES
# Get the external IP address of the vLLM load balancer service.
export vllm_service=$(kubectl get service vllm-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
# Loop from 1 to N to start the parallel processes.
for i in $(seq 1 $N); do
  # Start an infinite loop to continuously send requests.
  while true; do
    # Use curl to send a completion request to the vLLM service.
    curl http://$vllm_service:8000/v1/completions -H "Content-Type: application/json" -d '{"model": "meta-llama/Llama-3.1-70B", "prompt": "Write a story about san francisco", "max_tokens": 100, "temperature": 0}'
  done &  # Run in the background
done
# Keep the script running until it is manually stopped.
wait

    מחליפים את PARALLEL_PROCESSES במספר התהליכים המקבילים שרוצים להריץ.

  3. מריצים את סקריפט ה-Bash:

    nohup ./load.sh &

אימות של קליטת המדדים בשירות המנוהל של Google Cloud ל-Prometheus

אחרי שהשירות המנוהל של Google Cloud ל-Prometheus סורק את המדדים ואתם מוסיפים עומס לנקודת הקצה של vLLM, תוכלו לראות את המדדים ב-Cloud Monitoring.

  1. נכנסים לדף Metrics explorer במסוף Google Cloud .

    כניסה ל-Metrics Explorer

  2. לוחצים על < > PromQL.

  3. מזינים את השאילתה הבאה כדי לראות את מדדי התנועה:

    vllm:gpu_cache_usage_perc{cluster='CLUSTER_NAME'}

בתמונה הבאה מוצגת דוגמה לתרשים אחרי הפעלת סקריפט הטעינה. הגרף הזה מראה שהשירות המנוהל של Google Cloud ל-Prometheus קולט את מדדי התנועה בתגובה לעומס שנוסף לנקודת הקצה של vLLM:

מדדי תנועת הגולשים שתועדו בשרת vLLM

פריסת ההגדרה של Horizontal Pod Autoscaler

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

  • ‫num_requests_waiting: המדד הזה מתייחס למספר הבקשות שממתינות בתור של שרת המודל. המספר הזה מתחיל לגדול באופן משמעותי כשהמטמון של kv מלא.

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

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

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

הסבר נוסף מופיע במאמר בנושא שיטות מומלצות להתאמת קנה מידה אוטומטית של עומסי עבודה (workloads) של הסקת מסקנות ממודלים גדולים של שפה (LLM) באמצעות מעבדי GPU.

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

כדי לפרוס את ההגדרה של Horizontal Pod Autoscaler (HPA) באמצעות num_requests_waiting, פועלים לפי השלבים הבאים:

  1. שומרים את קובץ המניפסט הבא בשם vllm-hpa.yaml:

    
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: lws-hpa
spec:
  minReplicas: 1
  maxReplicas: 2
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|vllm:num_requests_waiting|gauge
      target:
        type: AverageValue
        averageValue: 5
  scaleTargetRef:
    apiVersion: leaderworkerset.x-k8s.io/v1
    kind: LeaderWorkerSet
    name: vllm

    המדדים של vLLM בשירות המנוהל של Google Cloud ל-Prometheus הם בפורמט vllm:metric_name.

    שיטה מומלצת:

    משתמשים ב-num_requests_waiting כדי לשנות את קצב העברת הנתונים. מומלץ להשתמש ב-gpu_cache_usage_perc בתרחישי שימוש ב-GPU שרגישים לזמן הטעינה.

  2. פורסים את ההגדרה של Horizontal Pod Autoscaler:

    kubectl apply -f vllm-hpa.yaml

    מערכת GKE מתזמנת Pod נוסף לפריסה, מה שגורם למנגנון לשינוי גודל מאגר הצמתים להוסיף צומת שני לפני פריסת הרפליקה השנייה של vLLM.

  3. צופים בהתקדמות של ההתאמה האוטומטית של קבוצות ה-Pod לעומס:

    kubectl get hpa --watch

    הפלט אמור להיראות כך:

    NAME      REFERENCE              TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
lws-hpa   LeaderWorkerSet/vllm   0/1       1         2         1          6d1h
lws-hpa   LeaderWorkerSet/vllm   1/1       1         2         1          6d1h
lws-hpa   LeaderWorkerSet/vllm   0/1       1         2         1          6d1h
lws-hpa   LeaderWorkerSet/vllm   4/1       1         2         1          6d1h
lws-hpa   LeaderWorkerSet/vllm   0/1       1         2         2          6d1h

קיצור זמני הטעינה של מודלים באמצעות Google Cloud Hyperdisk ML

בסוגים האלה של מודלים גדולים של שפה, יכול לעבור הרבה זמן עד שמורידים, טוענים ומפעילים את vLLM בכל עותק חדש. לדוגמה, התהליך הזה יכול להימשך כ-90 דקות עם Llama 3.1 405B. אפשר לקצר את הזמן הזה (ל-20 דקות עם Llama 3.1 405B) על ידי הורדת המודל ישירות לנפח Hyperdisk ML והוספת הנפח הזה לכל Pod. כדי לבצע את הפעולה הזו, במדריך הזה נעשה שימוש בנפח Hyperdisk ML וב-Kubernetes Job. ב-Kubernetes, בקר משימות יוצר פוד אחד או יותר ועוזר לוודא שהם מבצעים בהצלחה משימה ספציפית.

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

  1. שומרים את קובץ המניפסט הבא בשם producer-pvc.yaml:

    kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: producer-pvc
spec:
  # Specifies the StorageClass to use. Hyperdisk ML is optimized for ML workloads.
  storageClassName: hyperdisk-ml
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 800Gi

  2. שומרים את קובץ המניפסט הבא בשם producer-job.yaml:

    DeepSeek-R1

    
apiVersion: batch/v1
kind: Job
metadata:
  name: producer-job
spec:
  template:  # Template for the Pods the Job will create
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: cloud.google.com/machine-family
                operator: In
                values:
                - "c3"
            - matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                - "ZONE"
      containers:
      - name: copy
        resources:
          requests:
            cpu: "32"
          limits:
            cpu: "32"
        image: python:3.11-alpine
        command:
        - sh
        - -c
        - "pip install 'huggingface_hub==0.24.6' && \
          huggingface-cli download deepseek-ai/DeepSeek-R1 --local-dir-use-symlinks=False --local-dir=/data/DeepSeek-R1 --include *.safetensors *.json *.py"
        env:
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
          - mountPath: "/data"
            name: volume
      restartPolicy: Never
      volumes:
        - name: volume
          persistentVolumeClaim:
            claimName: producer-pvc
  parallelism: 1         # Run 1 Pods concurrently
  completions: 1         # Once 1 Pods complete successfully, the Job is done
  backoffLimit: 4        # Max retries on failure

    Llama 3.1 405B

    
apiVersion: batch/v1
kind: Job
metadata:
  name: producer-job
spec:
  template:  # Template for the Pods the Job will create
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: cloud.google.com/machine-family
                operator: In
                values:
                - "c3"
            - matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                - "ZONE"
      containers:
      - name: copy
        resources:
          requests:
            cpu: "32"
          limits:
            cpu: "32"
        image: python:3.11-alpine
        command:
        - sh
        - -c
        - "pip install 'huggingface_hub==0.24.6' && \
          huggingface-cli download meta-llama/Meta-Llama-3.1-405B-Instruct --local-dir-use-symlinks=False --local-dir=/data/Meta-Llama-3.1-405B-Instruct --include *.safetensors *.json"
        env:
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
          - mountPath: "/data"
            name: volume
      restartPolicy: Never
      volumes:
        - name: volume
          persistentVolumeClaim:
            claimName: producer-pvc
  parallelism: 1         # Run 1 Pods concurrently
  completions: 1         # Once 1 Pods complete successfully, the Job is done
  backoffLimit: 4        # Max retries on failure

  3. פועלים לפי ההוראות במאמר טעינת נתונים מהירה ל-AI/ML באמצעות Hyperdisk ML, ומשתמשים בשני הקבצים שיצרתם בשלבים הקודמים.

    אחרי השלב הזה, נפח ה-ML של Hyperdisk נוצר ואוכלס בנתוני המודל.

  4. פורסים את הפריסה של שרת GPU מרובה צמתים של vLLM, שתשתמש בנפח Hyperdisk ML שנוצר לאחרונה לנתוני המודל.

    DeepSeek-R1

    

apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: vllm
spec:
  replicas: 1
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          role: leader
      spec:
        containers:
          - name: vllm-leader
            image: vllm/vllm-openai:v0.8.5
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh leader --ray_cluster_size=$(LWS_GROUP_SIZE);
                python3 -m vllm.entrypoints.openai.api_server --port 8080 --model /models/DeepSeek-R1 --tensor-parallel-size 8 --pipeline-parallel-size 2 --trust-remote-code --max-model-len 4096"
            resources:
              limits:
                nvidia.com/gpu: "8"
            ports:
              - containerPort: 8080
            readinessProbe:
              tcpSocket:
                port: 8080
              initialDelaySeconds: 15
              periodSeconds: 10
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
              - mountPath: /models
                name: deepseek-r1
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
        - name: deepseek-r1
          persistentVolumeClaim:
            claimName: hdml-static-pvc
    workerTemplate:
      spec:
        containers:
          - name: vllm-worker
            image: vllm/vllm-openai:v0.8.5
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh worker --ray_address=$(LWS_LEADER_ADDRESS)"
            resources:
              limits:
                nvidia.com/gpu: "8"
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
              - mountPath: /models
                name: deepseek-r1
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
        - name: deepseek-r1
          persistentVolumeClaim:
            claimName: hdml-static-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-leader
spec:
  ports:
    - name: http
      port: 8080
      protocol: TCP
      targetPort: 8080
  selector:
    leaderworkerset.sigs.k8s.io/name: vllm
    role: leader
  type: ClusterIP

    Llama 3.1 405B

    

apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: vllm
spec:
  replicas: 1
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          role: leader
      spec:
        containers:
          - name: vllm-leader
            image: vllm/vllm-openai:v0.8.5
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh leader --ray_cluster_size=$(LWS_GROUP_SIZE);
                python3 -m vllm.entrypoints.openai.api_server --port 8080 --model /models/Meta-Llama-3.1-405B-Instruct --tensor-parallel-size 8 --pipeline-parallel-size 2"
            resources:
              limits:
                nvidia.com/gpu: "8"
            ports:
              - containerPort: 8080
            readinessProbe:
              tcpSocket:
                port: 8080
              initialDelaySeconds: 15
              periodSeconds: 10
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
              - mountPath: /models
                name: llama3-405b
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
        - name: llama3-405b
          persistentVolumeClaim:
            claimName: hdml-static-pvc
    workerTemplate:
      spec:
        containers:
          - name: vllm-worker
            image: vllm/vllm-openai:v0.8.5
            command:
              - sh
              - -c
              - "bash /vllm-workspace/examples/online_serving/multi-node-serving.sh worker --ray_address=$(LWS_LEADER_ADDRESS)"
            resources:
              limits:
                nvidia.com/gpu: "8"
            env:
              - name: HUGGING_FACE_HUB_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
            volumeMounts:
              - mountPath: /dev/shm
                name: dshm
              - mountPath: /models
                name: llama3-405b
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
        - name: llama3-405b
          persistentVolumeClaim:
            claimName: hdml-static-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-leader
spec:
  ports:
    - name: http
      port: 8080
      protocol: TCP
      targetPort: 8080
  selector:
    leaderworkerset.sigs.k8s.io/name: vllm
    role: leader
  type: ClusterIP

הסרת המשאבים

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

מחיקת המשאבים שנפרסו

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

ps -ef | grep load.sh | awk '{print $2}' | xargs -n1 kill -9

gcloud container clusters delete CLUSTER_NAME \
  --location=ZONE

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