במאמר הזה מוסבר איך לפרוס את GKE Inference Gateway.
המסמך הזה מיועד למומחי רשתות שאחראים לניהול התשתית של GKE, ולאדמינים של פלטפורמות שמנהלים עומסי עבודה של AI.
לפני שאתם קוראים את הדף הזה, חשוב שתכירו את המושגים הבאים:
- מידע על GKE Inference Gateway
- תזמור של AI/ML ב-GKE.
- מילון מונחים של AI גנרטיבי
- איזון עומסים ב-Google Cloud, ובמיוחד האינטראקציה בין מאזני העומסים לבין GKE.
- תוספי שירות של GKE. מידע נוסף זמין במאמרי העזרה בנושא GKE Gateway controller.
- התאמה אישית של תנועה ב-GKE Gateway באמצעות Service Extensions.
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:
- הכנת הסביבה: הגדרת התשתית והרכיבים הנדרשים.
- יצירת מאגר הסקות: מגדירים מאגר של שרתי מודלים באמצעות המשאב המותאם אישית InferencePool.
- הגדרת יעדי הסקה: מגדירים יעדי הסקה באמצעות המשאב בהתאמה אישית
InferenceObjective - יצירת השער: חשיפת שירות ההסקה באמצעות Gateway API.
- יוצרים את
HTTPRoute: מגדירים איך תעבורת הנתונים ב-HTTP מנותבת לשירות ההסקה. - שליחת בקשות להסקת מסקנות: שולחים בקשות למודל שנפרס.
יצירת השער
המשאב Gateway הוא נקודת הכניסה של תעבורת נתונים חיצונית לאשכול Kubernetes. הוא מגדיר את המאזינים שמקבלים חיבורים נכנסים.
GKE Inference Gateway פועל עם המחלקות הבאות של Gateway:
-
gke-l7-rilb: למאזני עומסים פנימיים אזוריים של אפליקציות (ALB). -
gke-l7-regional-external-managed: למאזני עומסים חיצוניים אזוריים של אפליקציות (ALB).
מידע נוסף זמין במאמרי העזרה בנושא Gateway Classes.
כדי ליצור שער:
שומרים את המניפסט לדוגמה הבא בתור
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.
-
מחילים את המניפסט על האשכול:
kubectl apply -f gateway.yaml
הערה: למידע נוסף על הגדרת TLS לאבטחת השער באמצעות HTTPS, קראו את המאמר הגדרת TLS במסמכי התיעוד של GKE.
הכנת הסביבה
מתקינים את Helm.
יוצרים אשכול GKE:
- יוצרים אשכול GKE Autopilot או Standard בגרסה 1.32.3 ואילך. בדוגמה הזו של
cluster-toolkit gke-a3-highgpuתוכלו לראות איך פורסים בלחיצה אחת. - מגדירים את הצמתים עם משפחת המחשוב והמאיץ המועדפים.
- כדאי להשתמש במדריך למתחילים בנושא הסקת מסקנות ב-GKE כדי לקבל מניפסטים של פריסה שהוגדרו ונבדקו מראש, על סמך המאיץ, המודל וצורכי הביצועים שבחרתם.
- יוצרים אשכול GKE Autopilot או Standard בגרסה 1.32.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מידע נוסף זמין במטריצת התאימות.
אם אתם משתמשים בגרסה של 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מגדירים את משתני הסביבה הבאים:
export GAIE_VERSION=v1.5.0 export GUIDE_NAME="optimized-baseline" export NAMESPACE=llm-d-optimized-baseline export INFRA_PROVIDER=gke # gke | baseמתקינים את הגדרות המשאבים בהתאמה אישית (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}"יוצרים את מרחב השמות לטירגוט:
kubectl create namespace ${NAMESPACE}
יצירת שרת מודל ופריסת מודל
בקטע הזה מוסבר איך לפרוס שרת מודל ומודל. בדוגמה נעשה שימוש בשרת מודל של vLLM עם מודל של Llama3. הפריסה מסומנת בתווית app:vllm-llama3-8b-instruct. הפריסה הזו משתמשת גם בשני מתאמי LoRA בשם food-review ו-cad-fabricator מ-Hugging Face.
אתם יכולים להתאים את הדוגמה הזו למאגר התגים בצד השרת, למודל, ליציאת השירות ולשם הפריסה שלכם. אפשר גם להגדיר מתאמי LoRA בפריסה, או לפרוס את מודל הבסיס. בשלבים הבאים מוסבר איך ליצור את המשאבים הנדרשים ב-Kubernetes.
יוצרים Kubernetes Secret כדי לאחסן את הטוקן של Hugging Face. הטוקן הזה משמש לגישה למודל הבסיסי ולמתאמי LoRA:
kubectl create secret generic hf-token --from-literal=token=HF_TOKENמחליפים את
HF_TOKENבטוקן של Hugging Face.פורסים את שרת המודל של 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:
פורסים את 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.-
מצרפים את ה-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 מציין כללי התאמה (לדוגמה, כותרות או נתיבים) ואת הקצה העורפי שאליו צריך להעביר את התנועה.
כדי ליצור
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.
-
מחילים את המניפסט על האשכול:
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:
שומרים את המניפסט הבא בתור
inference-objectives.yaml. המניפסט הזה יוצר שני משאביInferenceObjective. הראשונה מגדירה את יעד ההסקהfood-reviewב-vllm-llama3-8b-instructInferencePool עם עדיפות 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מחילים את המניפסט לדוגמה על האשכול:
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, אפשר לשלוח בקשות להסקת מסקנות למודל שנפרס. כך אפשר ליצור טקסט על סמך הנחיה שהזנתם ופרמטרים שציינתם.
כדי לשלוח בקשות להסקת מסקנות:
מגדירים את משתני הסביבה הבאים:
export GATEWAY_NAME=GATEWAY_NAME export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTPמחליפים את מה שכתוב בשדות הבאים:
-
GATEWAY_NAME: השם של משאב השער. -
PORT_NUMBER: מספר היציאה שהגדרתם בשער.
-
כדי לקבל את נקודת הקצה של השער, מריצים את הפקודה הבאה:
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}כדי לשלוח בקשה לנקודת הקצה (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 לקצה העורפי.
המאמרים הבאים
- התאמה אישית של ההגדרות האישיות של GKE Inference Gateway
- הגדרת ניתוב מבוסס-גוף
- הצגת LLM באמצעות GKE Inference Gateway
- שימוש בניתוב מבוסס-זמן אחזור חזוי באמצעות GKE Inference Gateway