פריסת GKE Inference Gateway שמבוסס על llm-d

במאמר הזה מוסבר איך לפרוס את GKE Inference Gateway.

המסמך הזה מיועד למומחי רשתות שאחראים לניהול התשתית של GKE, ולאדמינים של פלטפורמות שמנהלים עומסי עבודה של AI.

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

‫GKE Inference Gateway משפר את Google Kubernetes Engine (GKE) Gateway כדי לייעל את הצגת האפליקציות ועומסי העבודה של AI גנרטיבי ב-GKE. הוא מאפשר ניהול יעיל והרחבה של עומסי עבודה של AI, מאפשר יעדי ביצועים ספציפיים לעומסי עבודה כמו זמן אחזור, ומשפר את ניצול המשאבים, יכולת התצפית והבטיחות של ה-AI.

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

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

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

    עוברים אל הפעלת הגישה לממשקי API ופועלים לפי ההוראות.

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

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

  • אם עדיין אין לכם חשבון Hugging Face, אתם צריכים ליצור חשבון. תצטרכו את המזהה כדי לגשת למשאבי המודל במדריך הזה.

  • מבקשים גישה למודל Llama 3.1 ויוצרים טוקן גישה. כדי לגשת למודל הזה, צריך בקשה שאושרה ב-Hugging Face. אם לא תהיה גישה, הפריסה תיכשל.

    • חתימה על הסכם הרישיון: כדי להשתמש במודל Llama 3.1, צריך לחתום על הסכם הרישיון. עוברים לדף של המודל ב-Hugging Face, מאמתים את החשבון ומאשרים את התנאים.
    • יצירת טוקן גישה: כדי לגשת למודל, צריך טוקן של Hugging Face. בחשבון Hugging Face, עוברים אל Your Profile > Settings > Access Tokens, יוצרים טוקן חדש עם הרשאות קריאה לפחות ומעתיקים אותו ללוח.
  • מגדירים לרשת ה-VPC תת-רשת לשרת proxy בלבד. כדי להקצות את מאזן העומסים של האפליקציות, בקר ה-Gateway דורש תת-רשת פעילה של שרת proxy בלבד באזור.

הדרישות של GKE Gateway Controller

  • ‫GKE בגרסה 1.32.3 ואילך.
  • ‫Google Cloud CLI בגרסה 407.0.0 ואילך.
  • ‫Gateway API נתמך רק באשכולות המותאמים ל-VPC.
  • התוסף HttpLoadBalancing צריך להיות מופעל באשכול.
  • אם אתם משתמשים ב-Istio, אתם צריכים לשדרג את Istio לאחת מהגרסאות הבאות:
    • ‫1.15.2 ואילך
    • ‫1.14.5 ואילך
    • ‫1.13.9 ואילך
  • אם אתם משתמשים ב-VPC משותף, בפרויקט המארח אתם צריכים להקצות את התפקיד Compute Network User לחשבון השירות של GKE בפרויקט השירות.

הגבלות ומגבלות

ההגבלות הבאות חלות:

  • ‫GKE Inference Gateway נתמך רק במשאבי GatewayClass מסוג gke-l7-regional-external-managed ו-gke-l7-rilb.
  • אין תמיכה במאזני עומסים פנימיים של אפליקציות (ALB) באזורים שונים.
  • ב-InferencePool יכולים להיות עד שמונה targetPorts.

הגדרת GKE Inference Gateway

כדי להגדיר את GKE Inference Gateway, אפשר להשתמש בדוגמה הבאה. צוות מסוים מריץ מודלים של vLLM ו-Llama3, ומתנסה באופן פעיל בשני מתאמים שונים שעברו כוונון באמצעות LoRA: ‏food-review ו-cad-fabricator.

תהליך העבודה הכללי להגדרת GKE Inference Gateway:

  1. הכנת הסביבה: הגדרת התשתית והרכיבים הנדרשים.
  2. יצירת מאגר הסקות: מגדירים מאגר של שרתי מודלים באמצעות המשאב המותאם אישית InferencePool.
  3. הגדרת יעדי הסקה: מגדירים יעדי הסקה באמצעות המשאב בהתאמה אישית InferenceObjective
  4. יצירת השער: חשיפת שירות ההסקה באמצעות Gateway API.
  5. יוצרים את HTTPRoute: מגדירים איך תעבורת הנתונים ב-HTTP מנותבת לשירות ההסקה.
  6. שליחת בקשות להסקת מסקנות: שולחים בקשות למודל שנפרס.

יצירת השער

המשאב Gateway הוא נקודת הכניסה של תעבורת נתונים חיצונית לאשכול Kubernetes. הוא מגדיר את המאזינים שמקבלים חיבורים נכנסים.

‫GKE Inference Gateway פועל עם המחלקות הבאות של Gateway:

  • ‫gke-l7-rilb: למאזני עומסים פנימיים אזוריים של אפליקציות (ALB).
  • ‫gke-l7-regional-external-managed: למאזני עומסים חיצוניים אזוריים של אפליקציות (ALB).

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

כדי ליצור שער:

  1. שומרים את המניפסט לדוגמה הבא בתור gateway.yaml:

    apiVersion: gateway.networking.k8s.io/v1
    kind: Gateway
    metadata:
      name: GATEWAY_NAME
    spec:
      gatewayClassName: GATEWAY_CLASS
      listeners:
        - protocol: HTTP
          port: 80
          name: http
    

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

    • ‫GATEWAY_NAME: שם ייחודי למשאב Gateway. לדוגמה, inference-gateway.
    • ‫GATEWAY_CLASS: ה-Gateway Class שבו רוצים להשתמש. לדוגמה, gke-l7-regional-external-managed.
  2. מחילים את המניפסט על האשכול:

    kubectl apply -f gateway.yaml
    

הערה: למידע נוסף על הגדרת TLS לאבטחת השער באמצעות HTTPS, קראו את המאמר הגדרת TLS במסמכי התיעוד של GKE.

הכנת הסביבה

  1. מתקינים את Helm.

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

  3. מתקינים את הגדרות המשאבים בהתאמה אישית (CRD) הנדרשות באשכול GKE:

    • בגרסאות GKE 1.34.0-gke.1626000 ואילך, ה-CRD של InferencePool נכלל כברירת מחדל. לכן, צריך להתקין רק את ה-CRD של InferenceObjective בגרסת אלפא:

      kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/raw/v1.5.0/config/crd/bases/inference.networking.x-k8s.io_inferenceobjectives.yaml
      
    • בגרסאות GKE שקודמות ל-1.34.0-gke.1626000, צריך להתקין גם את ה-CRD של InferencePool בגרסה 1 וגם את ה-CRD של InferenceObjective בגרסת אלפא:

      kubectl apply -f  https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.5.0/manifests.yaml
      

      מידע נוסף זמין במטריצת התאימות.

  4. אם אתם משתמשים בגרסה של GKE שקודמת ל-v1.32.2-gke.1182001 ואתם רוצים להשתמש ב-Model Armor עם GKE Inference Gateway, אתם צריכים להתקין את ה-CRD של התוסף לתעבורת נתונים ולניתוב:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcptrafficextensions.yaml
    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcproutingextensions.yaml
    
  5. מגדירים את משתני הסביבה הבאים:

    export GAIE_VERSION=v1.5.0
    export GUIDE_NAME="optimized-baseline"
    export NAMESPACE=llm-d-optimized-baseline
    export INFRA_PROVIDER=gke   # gke | base
    
  6. מתקינים את הגדרות המשאבים בהתאמה אישית (CRD) של Gateway API Inference Extension שנדרשות לבורר נקודות הקצה (EPP) של llm-d:

    kubectl apply -k \
      "https://github.com/kubernetes-sigs/gateway-api-inference-extension/config/crd?ref=${GAIE_VERSION}"
    
  7. יוצרים את מרחב השמות לטירגוט:

    kubectl create namespace ${NAMESPACE}
    

יצירת שרת מודל ופריסת מודל

בקטע הזה מוסבר איך לפרוס שרת מודל ומודל. בדוגמה נעשה שימוש בשרת מודל של vLLM עם מודל של Llama3. הפריסה מסומנת בתווית app:vllm-llama3-8b-instruct. הפריסה הזו משתמשת גם בשני מתאמי LoRA בשם food-review ו-cad-fabricator מ-Hugging Face.

אתם יכולים להתאים את הדוגמה הזו למאגר התגים בצד השרת, למודל, ליציאת השירות ולשם הפריסה שלכם. אפשר גם להגדיר מתאמי LoRA בפריסה, או לפרוס את מודל הבסיס. בשלבים הבאים מוסבר איך ליצור את המשאבים הנדרשים ב-Kubernetes.

  1. יוצרים Kubernetes Secret כדי לאחסן את הטוקן של Hugging Face. הטוקן הזה משמש לגישה למודל הבסיסי ולמתאמי LoRA:

    kubectl create secret generic hf-token --from-literal=token=HF_TOKEN
    

    מחליפים את HF_TOKEN בטוקן של Hugging Face.

  2. פורסים את שרת המודל של vLLM באמצעות שכבת-העל של Kustomize הספציפית ל-GKE מהמדריך llm-d optimized-baseline. ההגדרה INFRA_PROVIDER=gke מחילה הגדרות ספציפיות ל-GKE, כולל שילוב עם Cloud Monitoring:

    kubectl apply -n ${NAMESPACE} \
      -k guides/${GUIDE_NAME}/modelserver/gpu/vllm/${INFRA_PROVIDER}/
    

הערה: כברירת מחדל, GKE מספק מעקב אוטומטי אחרי אפליקציות. מערך הכלים לניטור llm-d לא נדרש ב-GKE, אבל אפשר להשתמש בו אם רוצים.

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

דוגמה לפריסה עם כמה יציאות

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multiport-model-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: multiport-model-server
  template:
    metadata:
      labels:
        app: multiport-model-server
    spec:
      containers:
      - name: model-server
        image: your-model-server-image
        ports:
        - containerPort: 8080
        - containerPort: 8081
        - containerPort: 9000

יצירת מאגר הסקות

המשאב המותאם אישית InferencePool ב-Kubernetes מגדיר קבוצה של Pods עם מודל שפה גדול (LLM) בסיסי משותף והגדרת מחשוב משותפת. השדה selector מציין אילו Pods שייכים למאגר הזה. התוויות בבורר הזה חייבות להיות זהות לתוויות שהוחלו על Pods של שרת המודל. השדה targetPorts מגדיר את היציאות שבהן שרת המודל משתמש בתוך ה-Pods. אפשר לציין עד שמונה יציאות. השדה extensionRef מפנה לשירות תוסף שמספק יכולת נוספת למאגר ההסקה. ‫InferencePool מאפשר ל-GKE Inference Gateway לנתב תנועה לפודים של שרת המודל.

במניפסט הבא של InferencePool מצוינים כמה ערכי targetPorts שתואמים ליציאות שנחשפות על ידי פריסת שרת המודל:

דוגמה ל-InferencePool עם כמה יציאות

apiVersion: inference.networking.k8s.io/v1
kind: InferencePool
metadata:
  name: my-multiport-pool
  namespace: default
spec:
  selector:
    matchLabels:
      app: multiport-model-server
  targetPorts:
    - number: 8080
    - number: 8081
    - number: 9000

לפני שיוצרים את InferencePool, צריך לוודא שהפודים של שרת המודל שנבחרו על ידי InferencePool כבר פועלים.

משכפלים את המתכונים וההמלצות ל-InferencePool ממאגר llm-d ב-GitHub. זהו שלב חובה:

git clone https://github.com/llm-d/llm-d -b v0.7.0 && cd llm-d

כדי ליצור InferencePool ו-Endpoint Picker באמצעות Helm:

helm install ${GUIDE_NAME} \
  -f guides/recipes/scheduler/base.values.yaml \
  -f guides/${GUIDE_NAME}/scheduler/${GUIDE_NAME}.values.yaml \
  --set provider.name=gke \
  --set inferenceExtension.monitoring.gke.enabled=true \
  -n ${NAMESPACE} \
  --version ${GAIE_VERSION} \
  oci://LLM_D_REGISTRY_PATH

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

  • ‫GAIE_VERSION: הגרסה של תרשים Helm. לדוגמה, v1.5.0.
  • ‫LLM_D_REGISTRY_PATH: הנתיב של מרשם ה-OCI לתרשים Helm. לדוגמה, registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.

בקובץ guides/recipes/scheduler/base.values.yaml, משנים את השדה הבא כך שיתאים לתווית של ה-Deployment Pod של המודל:

  • ‫inferencePool.modelServers.matchLabels: המפתח והערך של התווית שמשמשת לבחירת ה-Pods של שרת המודל.

    הערה: המפתח והערך תואמים לדוגמה במדריך של optimized-baseline, אז אנחנו מחליפים אותם כדי שיתאימו לתוויות של ה-Deployment Pod.

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

  • כדי להשבית את התכונה הזו, מוסיפים את הדגל --set inferenceExtension.monitoring.prometheus.enabled=false לפקודה.
  • אם אתם משתמשים במעקב שמוגדר כברירת מחדל באשכול GKE Autopilot, אתם צריכים להוסיף גם את הדגל --set provider.gke.autopilot=true.

ההתקנה של Helm מתקינה באופן אוטומטי את מדיניות הזמן הקצוב לתפוגה, את בורר נקודות הקצה ואת ה-Pods שנדרשים לצורך ניראות.

כך נוצר אובייקט InferencePool: vllm-llama3-8b-instruct שמפנה לשירותי נקודות הקצה של המודל בתוך ה-Pods. היא גם יוצרת פריסה של בורר נקודות הקצה (Endpoint Picker) בשם app:vllm-llama3-8b-instruct-epp ל-InferencePool שנוצר.

פריסת Endpoint Picker עם זמינות גבוהה

פריסת Endpoint Picker ‏(EPP) עם רכיבי קצה עורפי מועדפים מאפשרת טופולוגיית ניתוב פעילה-פסיבית שמגובה על ידי Cloud Load Balancing.

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

  • עקביות במצב: מערכת Cloud Load Balancing מפנה 100% מתנועת הנתונים במצב יציב (ext_proc) לרפליקה הראשית של Endpoint Picker‏ (epp-0), וכך שומרת על מצב המטמון של מפתח/ערך (KV) ועל ההקשר של תזמון הבקשות.
  • יתירות כשל ללא זמן השבתה: אם ה-Pod הראשי של Endpoint Picker קורס או עובר תחזוקה, Cloud Load Balancing מזהה את הכשל באמצעות בדיקות תקינות פעילות של gRPC ומנתב מיד את התנועה לרפליקה במצב המתנה (epp-1).
  • המשך פעילות במקרה שגיאה: בשילוב עם failureMode: FailOpen, כשלים זמניים בניתוב עוקפים את Endpoint Picker ומאפשרים להעביר בקשות ישירות לשרתי המודלים בלי לבטל את בקשות המשתמשים.

כשמפעילים את ה-backend המועדף, GKE משנה את הארכיטקטורה ואת הניתוב באופן הבא:

  • ארכיטקטורת StatefulSet של Endpoint Picker: Endpoint Picker נפרס כ-StatefulSet במקום כ-Deployment. המספרים הסידוריים של ה-Pod מציינים את תפקידי הרפליקה: המספר הסידורי epp-0 משמש כרפליקה הראשית שמוצמדת לשכבת הקצה העורפי PREFERRED, והמספר הסידורי epp-1 משמש כרפליקה במצב המתנה שמוצמדת לשכבה DEFAULT.
  • מצב הניתוב נשאר ריכוזי: תנועת ext_proc במצב יציב מנותבת באופן בלעדי לרפליקה הראשית של Endpoint Picker‏ (epp-0) כדי לשמור על מעקב ריכוזי אחרי המטמון של מפתח/ערך (KV) ועל מצב תזמון הבקשות. אם epp-0 לא תקין, Cloud Load Balancing מעביר את התנועה לרפליקה במצב המתנה (epp-1).
  • ‫Dual-Service architecture: תרשים Helm יוצר שירות ראשי (Service/${GUIDE_NAME}-epp) ושירות גיבוי במצב המתנה (Service/${GUIDE_NAME}-epp-backup). המשאב InferencePool מטרגט באופן הצהרתי את שירות הגיבוי במצב המתנה. עיגון הבעלות על השער (Gateway) הדקלרטיבי לשירות הגיבוי מבטיח שלולאות ההתאמה של בקר השער של GKE לא ינתקו את קבוצות נקודות הקצה הראשיות ברשת (NEGs) שאתם מצרפים לשירות לקצה העורפי.

כדי ליצור InferencePool ו-Endpoint Picker עם זמינות גבוהה באמצעות Helm:

  1. פורסים את InferencePool ואת Endpoint Picker עם הקצוות העורפיים המועדפים באמצעות Helm:

    helm install ${GUIDE_NAME} \
      -f guides/recipes/scheduler/base.values.yaml \
      -f guides/${GUIDE_NAME}/scheduler/${GUIDE_NAME}.values.yaml \
      --set provider.name=gke \
      --set inferenceExtension.monitoring.gke.enabled=true \
      --set provider.gke.preferredBackends.enabled=true \
      --set provider.gke.preferredBackends.preferredReplicas=1 \
      --set provider.gke.preferredBackends.defaultReplicas=1 \
      -n ${NAMESPACE} \
      --version ${GAIE_VERSION} \
      oci://LLM_D_REGISTRY_PATH
    

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

    • ‫GAIE_VERSION: גרסת ה-Helm chart של Gateway API Inference Extension ‏(GAIE). לדוגמה, v1.5.0. כדי להשתמש בקצוות עורפיים מועדפים, צריך להשתמש ב-Helm chart בגרסה v1.5.0 ואילך.
    • ‫LLM_D_REGISTRY_PATH: הנתיב של מרשם ה-OCI לתרשים Helm. לדוגמה, registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.

    לרשימה המלאה של הפרמטרים: values.yaml.

  2. מצרפים את ה-NEG הראשי אל BackendService:

    export PROJECT_ID=PROJECT_ID
    export REGION=REGION
    
    export BACKEND_SERVICE=$(gcloud compute backend-services list --project=${PROJECT_ID} --format="value(name)" | grep "${GUIDE_NAME}-epp")
    
    export PRIMARY_NEG=$(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.network_endpoint_groups["9002"]')
    
    for ZONE in $(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.zones[]'); do
      gcloud compute backend-services add-backend ${BACKEND_SERVICE} \
        --network-endpoint-group=${PRIMARY_NEG} \
        --network-endpoint-group-zone=${ZONE} \
        --region=${REGION} \
        --project=${PROJECT_ID} \
        --balancing-mode=RATE \
        --max-rate-per-endpoint=100 \
        --preference=PREFERRED
      sleep 15
    done
    

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

    • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
    • ‫REGION: האזור של האשכול והשירות לקצה העורפי ב- Google Cloud .

אחרי שמצרפים קבוצות NEG אזוריות ל- Google Cloud BackendService, לא צריך להריץ שוב פקודות gcloud כדי לשנות את מספר הרפליקות (preferredReplicas או defaultReplicas) או להפעיל מחדש פודים. בקר ה-NEG של GKE מסנכרן באופן אוטומטי כתובות IP נפרדות של Pods עם קבוצות ה-NEG האזוריות הרשומות.

אם מוחקים ויוצרים מחדש את המשאב הראשי Gateway או InferencePool, בקר השער של GKE יוצר מחדש את Google CloudBackendService הבסיסי עם מזהה ענן חדש. במקרה כזה, צריך להפעיל את תהליך העבודה הקודם לצירוף כדי לצרף את קבוצות ה-NEG הראשיות ברמת האזור ל-BackendService החדש שנוצר.

יצירת HTTPRoute

המשאב HTTPRoute מגדיר איך GKE Gateway מנתב בקשות HTTP נכנסות לשירותים לקצה העורפי, כמו InferencePool. המשאב HTTPRoute מציין כללי התאמה (לדוגמה, כותרות או נתיבים) ואת הקצה העורפי שאליו צריך להעביר את התנועה.

  1. כדי ליצור HTTPRoute, שומרים את המניפסט לדוגמה הבא בתור httproute.yaml:

    apiVersion: gateway.networking.k8s.io/v1
    kind: HTTPRoute
    metadata:
      name: HTTPROUTE_NAME
    spec:
      parentRefs:
      - name: GATEWAY_NAME
      rules:
      - matches:
        - path:
            type: PathPrefix
            value: PATH_PREFIX
        backendRefs:
        - name: INFERENCE_POOL_NAME
          group: "inference.networking.k8s.io"
          kind: InferencePool
    

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

    • ‫HTTPROUTE_NAME: שם ייחודי למשאב HTTPRoute. לדוגמה, my-route.
    • ‫GATEWAY_NAME: השם של משאב Gateway שיצרתם. לדוגמה, inference-gateway.
    • ‫PATH_PREFIX: התחילית של הנתיב שמשמשת להתאמה לבקשות נכנסות. לדוגמה, / כדי להתאים לכולם.
    • ‫INFERENCE_POOL_NAME: השם של המשאב InferencePool שאליו רוצים לנתב את התנועה. לדוגמה, vllm-llama3-8b-instruct.
  2. מחילים את המניפסט על האשכול:

    kubectl apply -f httproute.yaml
    

הגדרת יעדי הסקה

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

השדה metadata.name של המשאב InferenceObjective מציין את שם יעד ההסקה, השדה Priority מציין את רמת הקריטיות של ההצגה שלו, והשדה poolRef מציין את ה-InferencePool שבו המודל מוצג.

apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceObjective
metadata:
  name: NAME
spec:
  priority: VALUE
  poolRef:
    name: INFERENCE_POOL_NAME
    group: "inference.networking.k8s.io"

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

  • ‫NAME: השם של יעד ההסקה. לדוגמה, food-review.
  • ‫VALUE: העדיפות של יעד ההסקה. זהו מספר שלם, שבו ערך גבוה יותר מציין בקשה קריטית יותר. לדוגמה, 10.
  • ‫INFERENCE_POOL_NAME: השם של InferencePool שיצרתם בשלב הקודם. לדוגמה, vllm-llama3-8b-instruct.

כדי ליצור InferenceObjective:

  1. שומרים את המניפסט הבא בתור inference-objectives.yaml. המניפסט הזה יוצר שני משאבי InferenceObjective. הראשונה מגדירה את יעד ההסקה food-review ב-vllm-llama3-8b-instruct InferencePool עם עדיפות 10. השני מגדיר את יעד ההסקה llama3-base-model כך שיוצג בעדיפות גבוהה יותר של 20.

    apiVersion: inference.networking.x-k8s.io/v1alpha2
    kind: InferenceObjective
    metadata:
      name: food-review
    spec:
      priority: 10
      poolRef:
        name: vllm-llama3-8b-instruct
        group: "inference.networking.k8s.io"
    ---
    apiVersion: inference.networking.x-k8s.io/v1alpha2
    kind: InferenceObjective
    metadata:
      name: llama3-base-model
    spec:
      priority: 20 # Higher priority
      poolRef:
        name: vllm-llama3-8b-instruct
    
  2. מחילים את המניפסט לדוגמה על האשכול:

    kubectl apply -f inference-objectives.yaml
    

אימות הפריסה

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

kubectl get inferencepool
kubectl get inferenceobjective
kubectl get pods -l app=vllm-llama3-8b-instruct-epp

שליחת בקשת הסקה

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

כדי לשלוח בקשות להסקת מסקנות:

  1. מגדירים את משתני הסביבה הבאים:

    export GATEWAY_NAME=GATEWAY_NAME
    export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTP
    

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

    • ‫GATEWAY_NAME: השם של משאב השער.
    • ‫PORT_NUMBER: מספר היציאה שהגדרתם בשער.
  2. כדי לקבל את נקודת הקצה של השער, מריצים את הפקודה הבאה:

    echo "Waiting for the Gateway IP address..."
    IP=""
    while [ -z "$IP" ]; do
      IP=$(kubectl get gateway/${GATEWAY_NAME} -o jsonpath='{.status.addresses[0].value}' 2>/dev/null)
      if [ -z "$IP" ]; then
        echo "Gateway IP not found, waiting 5 seconds..."
        sleep 5
      fi
    done
    
    echo "Gateway IP address is: $IP"
    PORT=${PORT_NUMBER}
    
  3. כדי לשלוח בקשה לנקודת הקצה (endpoint) של /v1/completions באמצעות curl, מריצים את הפקודה הבאה:

    curl -i -X POST ${IP}:${PORT}/v1/completions \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' \
    -d '{
        "model": "MODEL_NAME",
        "prompt": "PROMPT_TEXT",
        "max_tokens": MAX_TOKENS,
        "temperature": "TEMPERATURE"
    }'
    

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

    • ‫MODEL_NAME: שם המודל או מתאם ה-LoRA שרוצים להשתמש בו.
    • ‫PROMPT_TEXT: הנחיית הקלט למודל.
    • ‫MAX_TOKENS: המספר המקסימלי של טוקנים שייווצרו בתשובה.
    • ‫TEMPERATURE: קובע את מידת האקראיות של הפלט. כדי לקבל פלט דטרמיניסטי, משתמשים בערך 0. כדי לקבל פלט יצירתי יותר, משתמשים במספר גבוה יותר.

בדוגמה הבאה מוסבר איך לשלוח בקשה לדוגמה אל GKE Inference Gateway:

curl -i -X POST ${IP}:${PORT}/v1/completions -H 'Content-Type: application/json' -H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' -d '{
    "model": "food-review-1",
    "prompt": "What is the best pizza in the world?",
    "max_tokens": 2048,
    "temperature": 0
}'

חשוב לשים לב להתנהגויות הבאות:

  • גוף הבקשה: גוף הבקשה יכול לכלול פרמטרים נוספים כמו stop ו-top_p. רשימה מלאה של האפשרויות מופיעה במפרט של OpenAI API.
  • טיפול בשגיאות: מטמיעים טיפול מתאים בשגיאות בקוד הלקוח כדי לטפל בשגיאות פוטנציאליות בתגובה. לדוגמה, בודקים את קוד הסטטוס של HTTP בתגובה של curl. קוד סטטוס שהוא לא 200 בדרך כלל מציין שגיאה.
  • אימות והרשאה: בפריסות בסביבת ייצור, צריך לאבטח את נקודת הקצה ל-API באמצעות מנגנוני אימות והרשאה. כוללים את הכותרות המתאימות (לדוגמה, Authorization) בבקשות.

מטריצת תאימות

בטבלה הבאה מפורטת מטריצת התאימות והתמיכה של הגדרות המשאבים בהתאמה אישית (CRD) של Gateway API Inference Extension. הוא מפרט אילו גרסאות של CustomResourceDefinition נתמכות ב-GKE בהשוואה לפרויקט Gateway API Inference Extension בקוד פתוח (OSS), כולל דרישות ספציפיות לגרסאות והערות לגבי ההתקנה.

שם CustomResourceDefinition גרסת ה-API של CustomResourceDefinition תמיכה מנוהלת ב-GKE תמיכה ב-OSS (Gateway API Inference Extension)
‫V1 InferencePool inference.networking.k8s.io/v1 נתמך ב-GKE מגרסה 1.32.3 ואילך, ו-CustomResourceDefinition מותקן כברירת מחדל ב-GKE מגרסה 1.34.0-gke.1626000 ואילך נתמך החל מגרסה 1.0.0 של Gateway API Inference Extension
‫Alpha InferencePool (מומלץ למשתמשים להתחיל עם גרסה 1 של InferencePool כי גרסת האלפא של InferencePool הוצאה משימוש) inference.networking.x-k8s.io/v1alpha2 נתמך ב-GKE מגרסה 1.32.3 ואילך. עם זאת, CustomResourceDefinition לא מותקן כברירת מחדל ב-GKE. המשתמשים צריכים להתקין באופן ידני את CustomResourceDefinition מ-Gateway API Inference Extension. נתמך החל מגרסה 0.2.0 של Gateway API Inference Extension
Alpha InferenceObjective inference.networking.x-k8s.io/v1alpha2 ‫GKE לא מנהל את InferenceObjective נתמך החל מגרסה 1.0.0 של Gateway API Inference Extension
‫Alpha InferenceModel (מומלץ למשתמשים להתחיל עם InferenceObjective כי InferenceModel הוצא משימוש) inference.networking.x-k8s.io/v1alpha2 ‫GKE לא מנהל את InferenceModel נתמך החל מגרסה 0.2.0 של Gateway API Inference Extension.

אבטחת הקצה העורפי של ההסקה באמצעות TLS בקצה העורפי

פרוטוקול TLS לקצה העורפי מאפשר למאזן העומסים של GKE Gateway לאמת את הזהות של הקצוות העורפיים להסקת המסקנות שאליהם הוא מתחבר. פרוטוקול TLS לקצה העורפי מוסיף שלב אימות מפורש במהלך לחיצת היד בפרוטוקול TLS בין השער לבין ה-Pod של הקצה העורפי. האימות הזה עוזר לוודא שהשער מתקשר רק עם שרתי מודלים מהימנים ותוספי Endpoint Picker.

כדי להגדיר TLS לקצה העורפי של עומסי העבודה להסקת מסקנות, צריך לצרף BackendTLSPolicy למשאב InferencePool או GCPInferencePoolImport. כדי להגדיר את השער כך שיוכל לאמת את האישור של Endpoint Picker, צריך לצרף BackendTLSPolicy לשירות Endpoint Picker שאליו מפנה השדה spec.endpointPickerRef של InferencePool.

מידע נוסף זמין במאמר הגדרת TLS לקצה העורפי.

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