In dieser Anleitung wird gezeigt, wie Sie ein Large Language Model (LLM) mit Tensor Processing Units (TPUs) in der Google Kubernetes Engine (GKE) mit dem Ray Operator-Add-on und dem vLLM-Bereitstellungs-Framework bereitstellen.
In dieser Anleitung können Sie LLM-Modelle auf TPU v5e oder TPU Trillium (v6e) so bereitstellen:
- Llama 3 8B-Anleitung für eine TPU v5e mit einem einzelnen Host
- Mistral 7B instruct v0.3 auf einer TPU v5e mit einem einzelnen Host
- Llava 1.5 13b hf auf einer TPU v5e mit einem einzelnen Host.
- Llama 3.1 70B auf einer TPU Trillium (v6e) mit einem einzelnen Host
Dieser Leitfaden richtet sich an Kunden von generativer KI, neue und bestehende GKE-Nutzer, ML-Entwickler, MLOps-Entwickler (DevOps) oder Plattformadministratoren, die daran interessiert sind, Funktionen zur Kubernetes-Containerorchestrierung für die Bereitstellung von Modellen mit Ray auf TPUs mit vLLM zu nutzen.
Hintergrund
In diesem Abschnitt werden die in diesem Leitfaden verwendeten Schlüsseltechnologien beschrieben.
Verwalteter Kubernetes-Dienst von GKE
Google Cloud bietet eine breite Palette von Diensten, darunter GKE, das sich gut für die Bereitstellung und Verwaltung von KI-/ML-Arbeitslasten eignet. GKE ist ein verwalteter Kubernetes-Dienst, der das Bereitstellen, Skalieren und Verwalten von containerisierten Anwendungen vereinfacht. GKE bietet die erforderliche Infrastruktur, einschließlich skalierbarer Ressourcen, verteiltem Computing und effizientem Networking, um die Rechenanforderungen von LLMs zu erfüllen.
Weitere Informationen zu den wichtigsten Kubernetes-Konzepten finden Sie unter Einstieg in Kubernetes. Weitere Informationen zur GKE und dazu, wie Sie damit Kubernetes skalieren, automatisieren und verwalten können, finden Sie in der GKE-Übersicht.
Ray-Operator
Das Ray-Operator-Add-on in GKE bietet eine End-to-End-KI-/ML-Plattform für das Bereitstellen, Trainieren und Optimieren von ML-Arbeitslasten. In dieser Anleitung verwenden Sie Ray Serve, ein Framework in Ray, um beliebte LLMs von Hugging Face bereitzustellen.
TPUs
TPUs sind von Google speziell entwickelte anwendungsspezifische integrierte Schaltungen (Application-Specific Integrated Circuits, ASICs), die verwendet werden, um das maschinelle Lernen und die KI-Modelle zu beschleunigen, die mit Frameworks wie folgenden erstellt wurden:TensorFlow, PyTorch und JAX.
In dieser Anleitung erfahren Sie, wie Sie LLM-Modelle auf TPU v5e- oder TPU Trillium (v6e)-Knoten bereitstellen. Dabei werden TPU-Topologien basierend auf den Modellanforderungen für die Bereitstellung von Prompts mit niedriger Latenz konfiguriert.
vLLM
vLLM ist ein hoch optimiertes Open-Source-LLM-Bereitstellungs-Framework, das den Bereitstellungsdurchsatz auf TPUs über Funktionen wie die Folgenden beschleunigen kann:
- Optimierte Transformer-Implementierung mit PagedAttention
- Kontinuierliche Batchverarbeitung zur Verbesserung des allgemeinen Bereitstellungsdurchsatzes
- Tensor-Parallelität und verteilte Bereitstellung auf mehreren GPUs
Weitere Informationen finden Sie in der vLLM-Dokumentation.
Lernziele
Diese Anleitung umfasst die folgenden Schritte:
- Erstellen Sie einen GKE-Cluster mit einem TPU-Knotenpool.
- Stellen Sie eine benutzerdefinierte RayCluster-Ressource mit einem TPU-Slice mit einem einzelnen Host bereit. In GKE wird die benutzerdefinierte RayCluster-Ressource als Kubernetes-Pod bereitgestellt.
- LLM bereitstellen
- Mit den Modellen interagieren
Optional können Sie die folgenden vom Ray Serve-Framework unterstützten Ressourcen und Techniken für die Modellbereitstellung konfigurieren:
- Benutzerdefinierte RayService-Ressource bereitstellen
- Mehrere Modelle mit der Modellkomposition zusammenführen
Hinweise
Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:
- Aktivieren Sie die Google Kubernetes Engine API. Google Kubernetes Engine API aktivieren
- Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit
gcloud components updateab.
- Erstellen Sie ein Hugging Face-Konto, falls Sie noch keines haben.
- Sie benötigen ein Hugging Face-Token.
- Sie benötigen Zugriff auf das Hugging Face-Modell, das Sie verwenden möchten. Normalerweise erhalten Sie diesen Zugriff, indem Sie eine Vereinbarung unterzeichnen und den Modellinhaber auf der Hugging Face-Modellseite um Zugriff bitten.
Umgebung vorbereiten
Prüfen Sie, ob in Ihrem Google Cloud Projekt ein ausreichendes Kontingent für eine TPU v5e mit einem einzelnen Host oder eine TPU Trillium (v6e) mit einem einzelnen Host vorhanden ist. Informationen zum Verwalten Ihres Kontingents finden Sie unter TPU-Kontingente.
Starten Sie in der Google Cloud Console eine Cloud Shell-Instanz:
Cloud Shell öffnenKlonen Sie das Beispiel-Repository:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git cd kubernetes-engine-samplesWechseln Sie zum Arbeitsverzeichnis:
cd ai-ml/gke-ray/rayserve/llmLegen Sie die Standardumgebungsvariablen für die Erstellung des GKE-Clusters fest:
Llama-3-8B-Instruct
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="meta-llama/Meta-Llama-3-8B-Instruct" export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcErsetzen Sie Folgendes:
HUGGING_FACE_TOKEN: Ihr Hugging Face-Zugriffstoken.REGION: die Region, in der Sie ein TPU-Kontingent haben. Die gewünschte TPU-Version muss in dieser Region verfügbar sein. Weitere Informationen finden Sie unter TPU-Verfügbarkeit in GKE.ZONE: die Zone mit verfügbarem TPU-Kontingent.VLLM_IMAGE: das vLLM-TPU-Image. Sie können das öffentlichedocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1-Image verwenden oder ein eigenes TPU-Image erstellen.
Mistral-7B
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="mistralai/Mistral-7B-Instruct-v0.3" export TOKENIZER_MODE=mistral export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcErsetzen Sie Folgendes:
HUGGING_FACE_TOKEN: Ihr Hugging Face-Zugriffstoken.REGION: die Region, in der Sie ein TPU-Kontingent haben. Die gewünschte TPU-Version muss in dieser Region verfügbar sein. Weitere Informationen finden Sie unter TPU-Verfügbarkeit in GKE.ZONE: die Zone mit verfügbarem TPU-Kontingent.VLLM_IMAGE: das vLLM-TPU-Image. Sie können das öffentlichedocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1-Image verwenden oder ein eigenes TPU-Image erstellen.
Llava-1.5-13b-hf
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="llava-hf/llava-1.5-13b-hf" export DTYPE=bfloat16 export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcErsetzen Sie Folgendes:
HUGGING_FACE_TOKEN: Ihr Hugging Face-Zugriffstoken.REGION: die Region, in der Sie ein TPU-Kontingent haben. Die gewünschte TPU-Version muss in dieser Region verfügbar sein. Weitere Informationen finden Sie unter TPU-Verfügbarkeit in GKE.ZONE: die Zone mit verfügbarem TPU-Kontingent.VLLM_IMAGE: das vLLM-TPU-Image. Sie können das öffentlichedocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1-Image verwenden oder ein eigenes TPU-Image erstellen.
Llama 3.1 70B
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="meta-llama/Llama-3.1-70B" export MAX_MODEL_LEN=8192 export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcErsetzen Sie Folgendes:
HUGGING_FACE_TOKEN: Ihr Hugging Face-Zugriffstoken.REGION: die Region, in der Sie ein TPU-Kontingent haben. Die gewünschte TPU-Version muss in dieser Region verfügbar sein. Weitere Informationen finden Sie unter TPU-Verfügbarkeit in GKE.ZONE: die Zone mit verfügbarem TPU-Kontingent.VLLM_IMAGE: das vLLM-TPU-Image. Sie können das öffentlichedocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1-Image verwenden oder ein eigenes TPU-Image erstellen.
Rufen Sie das vLLM-Container-Image ab:
docker pull ${VLLM_IMAGE}
Cluster erstellen
Mit dem Ray Operator-Add-on können Sie eine LLM auf TPUs mit Ray in einem GKE Autopilot- oder Standardcluster bereitstellen.
Verwenden Sie einen Autopilot-Cluster für eine vollständig verwaltete Kubernetes-Umgebung. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.
So erstellen Sie mit Cloud Shell einen Autopilot- oder Standardcluster:
Autopilot
GKE Autopilot-Cluster mit aktiviertem Ray Operator-Add-on erstellen:
gcloud container clusters create-auto ${CLUSTER_NAME} \ --enable-ray-operator \ --release-channel=rapid \ --location=${COMPUTE_REGION}
Standard
Erstellen Sie einen Standardcluster mit aktiviertem Ray-Operator-Add-on:
gcloud container clusters create ${CLUSTER_NAME} \ --release-channel=rapid \ --location=${COMPUTE_ZONE} \ --workload-pool=${PROJECT_ID}.svc.id.goog \ --machine-type="n1-standard-4" \ --addons=RayOperator,GcsFuseCsiDriverSo erstellen Sie einen TPU-Slice-Knotenpool mit einem Host:
Llama-3-8B-Instruct
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-8t \ --num-nodes=1GKE erstellt einen TPU v5e-Knotenpool mit dem Maschinentyp
ct5lp-hightpu-8t.Mistral-7B
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-8t \ --num-nodes=1GKE erstellt einen TPU v5e-Knotenpool mit dem Maschinentyp
ct5lp-hightpu-8t.Llava-1.5-13b-hf
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-8t \ --num-nodes=1GKE erstellt einen TPU v5e-Knotenpool mit dem Maschinentyp
ct5lp-hightpu-8t.Llama 3.1 70B
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct6e-standard-8t \ --num-nodes=1GKE erstellt einen TPU v6e-Knotenpool mit dem Maschinentyp
ct6e-standard-8t.
Konfigurieren Sie kubectl für die Kommunikation mit Ihrem Cluster.
Führen Sie den folgenden Befehl aus, um kubectl für die Kommunikation mit Ihrem Cluster zu konfigurieren:
Autopilot
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_REGION}
Standard
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_ZONE}
Kubernetes-Secret für Hugging Face-Anmeldedaten erstellen
Führen Sie den folgenden Befehl aus, um ein Kubernetes-Secret zu erstellen, das das Hugging Face-Token enthält:
kubectl create secret generic hf-secret \
--from-literal=hf_api_token=${HF_TOKEN} \
--dry-run=client -o yaml | kubectl --namespace ${NAMESPACE} apply -f -
Cloud Storage-Bucket erstellen
Um die Startzeit der vLLM-Bereitstellung zu beschleunigen und den erforderlichen Speicherplatz pro Knoten zu minimieren, können Sie den Cloud Storage FUSE CSI-Treiber verwenden, um das heruntergeladene Modell und den Kompilierungscache auf den Ray-Knoten bereitzustellen.
Führen Sie in Cloud Shell den folgenden Befehl aus:
gcloud storage buckets create gs://${GSBUCKET} \
--uniform-bucket-level-access
Dadurch wird ein Cloud Storage-Bucket zum Speichern der Modelldateien erstellt, die Sie von Hugging Face herunterladen.
Kubernetes-Dienstkonto für den Zugriff auf den Bucket einrichten
Erstellen Sie das Kubernetes-Dienstkonto:
kubectl create serviceaccount ${KSA_NAME} \ --namespace ${NAMESPACE}Gewähren Sie dem Kubernetes-Dienstkonto Lese- und Schreibzugriff auf den Cloud Storage-Bucket:
gcloud storage buckets add-iam-policy-binding gs://${GSBUCKET} \ --member "principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/${NAMESPACE}/sa/${KSA_NAME}" \ --role "roles/storage.objectUser"GKE erstellt die folgenden Ressourcen für das LLM:
- Ein Cloud Storage-Bucket zum Speichern des heruntergeladenen Modells und des Kompilierungscaches. Ein CSI-Treiber für Cloud Storage FUSE liest den Inhalt des Buckets.
- Volumes mit aktiviertem Datei-Caching und die Funktion „Paralleler Download“ von Cloud Storage FUSE.
Best Practice: Verwenden Sie einen Dateicache, der von
tmpfsoderHyperdisk / Persistent Diskunterstützt wird, je nach erwarteter Größe des Modellinhalts, z. B. Gewichtsdateien. In dieser Anleitung verwenden Sie den Cloud Storage FUSE-Dateicache, der vom RAM unterstützt wird.
Benutzerdefinierte RayCluster-Ressource bereitstellen
Benutzerdefinierte RayCluster-Ressource bereitstellen, die in der Regel aus einem System-Pod und mehreren Worker-Pods besteht
Llama-3-8B-Instruct
Erstellen Sie die benutzerdefinierte RayCluster-Ressource, um das für Llama 3 optimierte Modell mit 8B-Anweisungen bereitzustellen. Gehen Sie dazu so vor:
Prüfen Sie das
ray-cluster.tpu-v5e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.
GKE erstellt eine benutzerdefinierte RayCluster-Ressource mit einer workergroup, die einen einzelnen TPU v5e-Host in einer 2x4-Topologie enthält.
Mistral-7B
Erstellen Sie die benutzerdefinierte RayCluster-Ressource, um das Mistral-7B-Modell bereitzustellen. Gehen Sie dazu so vor:
Prüfen Sie das
ray-cluster.tpu-v5e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.
GKE erstellt eine benutzerdefinierte RayCluster-Ressource mit einer workergroup, die einen einzelnen TPU v5e in einer 2x4-Topologie enthält.
Llava-1.5-13b-hf
Erstellen Sie die benutzerdefinierte RayCluster-Ressource, um das Llava-1.5-13b-hf-Modell bereitzustellen. Gehen Sie dazu so vor:
Prüfen Sie das
ray-cluster.tpu-v5e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.
GKE erstellt eine benutzerdefinierte RayCluster-Ressource mit einer workergroup, die einen einzelnen TPU v5e in einer 2x4-Topologie enthält.
Llama 3.1 70B
Erstellen Sie die benutzerdefinierte RayCluster-Ressource, um das Llama 3.1 70B-Modell bereitzustellen. Gehen Sie dazu so vor:
Prüfen Sie das
ray-cluster.tpu-v6e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-cluster.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.
GKE erstellt eine benutzerdefinierte RayCluster-Ressource mit einer workergroup, die einen einzelnen TPU v6e-Host in einer 2x4-Topologie enthält.
Verbindung zur benutzerdefinierten RayCluster-Ressource herstellen
Nachdem die benutzerdefinierte RayCluster-Ressource erstellt wurde, können Sie eine Verbindung zur RayCluster-Ressource herstellen und mit dem Bereitstellen des Modells beginnen.
Prüfen Sie, ob GKE den RayCluster-Dienst erstellt hat:
kubectl --namespace ${NAMESPACE} get raycluster/vllm-tpu \ --output wideDie Ausgabe sieht in etwa so aus:
NAME DESIRED WORKERS AVAILABLE WORKERS CPUS MEMORY GPUS TPUS STATUS AGE HEAD POD IP HEAD SERVICE IP vllm-tpu 1 1 ### ###G 0 8 ready ### ###.###.###.### ###.###.###.###Warten Sie, bis
STATUSden Wertreadyhat und die SpaltenHEAD POD IPundHEAD SERVICE IPeine IP-Adresse haben.Richten Sie
port-forwarding-Sitzungen zum Ray-Head ein:pkill -f "kubectl .* port-forward .* 8265:8265" pkill -f "kubectl .* port-forward .* 10001:10001" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8265:8265 2>&1 >/dev/null & kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 10001:10001 2>&1 >/dev/null &Prüfen Sie, ob der Ray-Client eine Verbindung zur Remote-RayCluster-Ressource herstellen kann:
docker run --net=host -it ${VLLM_IMAGE} \ ray list nodes --address http://localhost:8265Die Ausgabe sieht in etwa so aus:
======== List: YYYY-MM-DD HH:MM:SS.NNNNNN ======== Stats: ------------------------------ Total: 2 Table: ------------------------------ NODE_ID NODE_IP IS_HEAD_NODE STATE STATE_MESSAGE NODE_NAME RESOURCES_TOTAL LABELS 0 XXXXXXXXXX ###.###.###.### True ALIVE ###.###.###.### CPU: 2.0 ray.io/node_id: XXXXXXXXXX memory: #.### GiB node:###.###.###.###: 1.0 node:__internal_head__: 1.0 object_store_memory: #.### GiB 1 XXXXXXXXXX ###.###.###.### False ALIVE ###.###.###.### CPU: 100.0 ray.io/node_id: XXXXXXXXXX TPU: 8.0 TPU-v#e-8-head: 1.0 accelerator_type:TPU-V#E: 1.0 memory: ###.### GiB node:###.###.###.###: 1.0 object_store_memory: ##.### GiB tpu-group-0: 1.0
Modell mit vLLM bereitstellen
Modell mit vLLM bereitstellen:
Llama-3-8B-Instruct
docker run \
--env MODEL_ID=${MODEL_ID} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"MODEL_ID": "meta-llama/Meta-Llama-3-8B-Instruct"}}'
Mistral-7B
docker run \
--env MODEL_ID=${MODEL_ID} \
--env TOKENIZER_MODE=${TOKENIZER_MODE} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"MODEL_ID": "mistralai/Mistral-7B-Instruct-v0.3", "TOKENIZER_MODE": "mistral"}}'
Llava-1.5-13b-hf
docker run \
--env DTYPE=${DTYPE} \
--env MODEL_ID=${MODEL_ID} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"DTYPE": "bfloat16", "MODEL_ID": "llava-hf/llava-1.5-13b-hf"}}'
Llama 3.1 70B
docker run \
--env MAX_MODEL_LEN=${MAX_MODEL_LEN} \
--env MODEL_ID=${MODEL_ID} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"MAX_MODEL_LEN": "8192", "MODEL_ID": "meta-llama/Meta-Llama-3.1-70B"}}'
Ray-Dashboard aufrufen
Sie können Ihre Ray Serve-Bereitstellung und relevante Logs im Ray-Dashboard aufrufen.
- Klicken Sie oben rechts in der Cloud Shell-Taskleiste auf die Schaltfläche
Webvorschau. - Klicken Sie auf Port ändern und legen Sie die Portnummer auf
8265fest. - Klicken Sie auf Ändern und Vorschau.
- Klicken Sie im Ray-Dashboard auf den Tab Bereitstellen.
Sobald die Bereitstellung für die Bereitstellung den Status HEALTHY hat, kann das Modell mit der Verarbeitung von Eingaben beginnen.
Modell bereitstellen
In diesem Leitfaden werden Modelle vorgestellt, die die Textgenerierung unterstützen. Mit dieser Technik können Textinhalte anhand eines Prompts erstellt werden.
Llama-3-8B-Instruct
Richten Sie die Portweiterleitung an den Server ein:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Senden Sie einen Prompt an den Serve-Endpunkt:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Mistral-7B
Richten Sie die Portweiterleitung an den Server ein:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Senden Sie einen Prompt an den Serve-Endpunkt:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Llava-1.5-13b-hf
Richten Sie die Portweiterleitung an den Server ein:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Senden Sie einen Prompt an den Serve-Endpunkt:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Llama 3.1 70B
Richten Sie die Portweiterleitung an den Server ein:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Senden Sie einen Prompt an den Serve-Endpunkt:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Zusätzliche Konfiguration
Optional können Sie die folgenden vom Ray Serve-Framework unterstützten Ressourcen und Techniken für die Modellbereitstellung konfigurieren:
- Benutzerdefinierte RayService-Ressource bereitstellen In den vorherigen Schritten dieser Anleitung haben Sie RayCluster anstelle von RayService verwendet. Wir empfehlen RayService für Produktionsumgebungen.
- Mehrere Modelle mit der Modellkomposition zusammenführen Konfigurieren Sie das Multiplexverfahren und die Modellkomposition, die vom Ray Serve-Framework unterstützt werden. Mit der Modellkomposition können Sie Eingaben und Ausgaben über mehrere LLMs hinweg verketten und Ihre Modelle als einzelne Anwendung skalieren.
- Erstellen und bereitstellen eines eigenen TPU-Images Wir empfehlen diese Option, wenn Sie den Inhalt Ihres Docker-Images genauer steuern möchten.
RayService bereitstellen
Sie können dieselben Modelle aus dieser Anleitung mit einer benutzerdefinierten RayService-Ressource bereitstellen.
Löschen Sie die benutzerdefinierte RayCluster-Ressource, die Sie in dieser Anleitung erstellt haben:
kubectl --namespace ${NAMESPACE} delete raycluster/vllm-tpuErstellen Sie die benutzerdefinierte RayService-Ressource, um ein Modell bereitzustellen:
Llama-3-8B-Instruct
Prüfen Sie das
ray-service.tpu-v5e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.GKE erstellt einen RayService mit einer
workergroup, die einen einzelnen TPU v5e-Host in einer2x4-Topologie enthält.
Mistral-7B
Prüfen Sie das
ray-service.tpu-v5e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.GKE erstellt einen RayService mit einer
workergroup, die einen einzelnen TPU v5e-Host in einer2x4-Topologie enthält.
Llava-1.5-13b-hf
Prüfen Sie das
ray-service.tpu-v5e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.GKE erstellt einen RayService mit einer
workergroup, die einen einzelnen TPU v5e-Host in einer2x4-Topologie enthält.
Llama 3.1 70B
Prüfen Sie das
ray-service.tpu-v6e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < tpu/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Mit dem Befehl
envsubstwerden die Umgebungsvariablen im Manifest ersetzt.
GKE erstellt eine benutzerdefinierte RayCluster-Ressource, in der die Ray Serve-Anwendung bereitgestellt und die nachfolgende benutzerdefinierte RayService-Ressource erstellt wird.
Prüfen Sie den Status der RayService-Ressource:
kubectl --namespace ${NAMESPACE} get rayservices/vllm-tpuWarten Sie, bis sich der Dienststatus in
Runningändert:NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 1Rufen Sie den Namen des RayCluster-Leitungsdienstes ab:
SERVICE_NAME=$(kubectl --namespace=${NAMESPACE} get rayservices/vllm-tpu \ --template={{.status.activeServiceStatus.rayClusterStatus.head.serviceName}})Richten Sie
port-forwarding-Sitzungen zum Ray-Head ein, um das Ray-Dashboard aufzurufen:pkill -f "kubectl .* port-forward .* 8265:8265" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8265:8265 2>&1 >/dev/null &Bereinigen Sie die RayService-Ressource:
kubectl --namespace ${NAMESPACE} delete rayservice/vllm-tpu
Mehrere Modelle mit der Modellkomposition zusammenführen
Die Modellkomposition ist eine Methode, mit der mehrere Modelle in einer einzigen Anwendung kombiniert werden.
In diesem Abschnitt verwenden Sie einen GKE-Cluster, um zwei Modelle, Llama 3 8B IT und Gemma 7B IT, in einer einzigen Anwendung zusammenzuführen:
- Das erste Modell ist das Assistant-Modell, das Fragen beantwortet, die im Prompt gestellt werden.
- Das zweite Modell ist das Zusammenfassungsmodell. Die Ausgabe des Assistant-Modells wird an die Eingabe des Zusammenfassungsmodells angehängt. Das Endergebnis ist die zusammengefasste Version der Antwort des Assistant-Modells.
Richten Sie Ihre Umgebung ein:
export ASSIST_MODEL_ID=meta-llama/Meta-Llama-3-8B-Instruct export SUMMARIZER_MODEL_ID=google/gemma-7b-itErstellen Sie für Standardcluster einen zusätzlichen TPU-Slice-Knotenpool mit einem Host:
gcloud container node-pools create tpu-2 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=MACHINE_TYPE \ --num-nodes=1Ersetzen Sie
MACHINE_TYPEdurch einen der folgenden Maschinentypen:ct5lp-hightpu-8t, um TPU v5e zu provisionieren.ct6e-standard-8t, um TPU v6e zu provisionieren.
In Autopilot-Clustern werden die erforderlichen Knoten automatisch bereitgestellt.
Stellen Sie die RayService-Ressource entsprechend der TPU-Version bereit, die Sie verwenden möchten:
TPU v5e
Prüfen Sie das
ray-service.tpu-v5e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < model-composition/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
TPU v6e
Prüfen Sie das
ray-service.tpu-v6e-singlehost.yaml-Manifest:Wenden Sie das Manifest an:
envsubst < model-composition/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
Warten Sie, bis sich der Status der RayService-Ressource in
Runningändert:kubectl --namespace ${NAMESPACE} get rayservice/vllm-tpuDie Ausgabe sieht in etwa so aus:
NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 2In dieser Ausgabe gibt der Status
RUNNINGan, dass die RayService-Ressource bereit ist.Prüfen Sie, ob GKE den Dienst für die Ray Serve-Anwendung erstellt hat:
kubectl --namespace ${NAMESPACE} get service/vllm-tpu-serve-svcDie Ausgabe sieht in etwa so aus:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE vllm-tpu-serve-svc ClusterIP ###.###.###.### <none> 8000/TCP ###Richten Sie
port-forwarding-Sitzungen zum Ray-Head ein:pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/vllm-tpu-serve-svc 8000:8000 2>&1 >/dev/null &Senden Sie eine Anfrage an das Modell:
curl -X POST http://localhost:8000/ -H "Content-Type: application/json" -d '{"prompt": "What is the most popular programming language for machine learning and why?", "max_tokens": 1000}'Die Ausgabe sieht in etwa so aus:
{"text": [" used in various data science projects, including building machine learning models, preprocessing data, and visualizing results.\n\nSure, here is a single sentence summarizing the text:\n\nPython is the most popular programming language for machine learning and is widely used in data science projects, encompassing model building, data preprocessing, and visualization."]}
TPU-Image erstellen und bereitstellen
In dieser Anleitung werden gehostete TPU-Images von vLLM verwendet. vLLM stellt ein Dockerfile.tpu-Image bereit, das vLLM auf dem erforderlichen PyTorch XLA-Image mit TPU-Abhängigkeiten erstellt. Sie können jedoch auch ein eigenes TPU-Image erstellen und bereitstellen, um den Inhalt Ihres Docker-Images genauer zu steuern.
Erstellen Sie ein Docker-Repository zum Speichern der Container-Images für diesen Leitfaden:
gcloud artifacts repositories create vllm-tpu --repository-format=docker --location=${COMPUTE_REGION} && \ gcloud auth configure-docker ${COMPUTE_REGION}-docker.pkg.devKlonen Sie das vLLM-Repository:
git clone https://github.com/vllm-project/vllm.git cd vllmErstellen Sie das Image:
docker build -f Dockerfile.tpu . -t vllm-tpuTaggen Sie das TPU-Image mit dem Namen Ihrer Artifact Registry:
export VLLM_IMAGE=${COMPUTE_REGION}-docker.pkg.dev/${PROJECT_ID}/vllm-tpu/vllm-tpu:TAG docker tag vllm-tpu ${VLLM_IMAGE}Ersetzen Sie
TAGdurch den Namen des Tags, das Sie definieren möchten. Wenn Sie kein Tag angeben, verwendet Docker das Standard-Tag „latest“.Übertragen Sie das Image per Push an Artifact Registry.
docker push ${VLLM_IMAGE}
Einzelne Ressourcen löschen
Wenn Sie ein vorhandenes Projekt verwendet haben und es nicht löschen möchten, können Sie die einzelnen Ressourcen löschen.
Löschen Sie die benutzerdefinierte RayCluster-Ressource:
kubectl --namespace ${NAMESPACE} delete rayclusters vllm-tpuLöschen Sie den Cloud Storage-Bucket:
gcloud storage rm -r gs://${GSBUCKET}Löschen Sie das Artifact Registry-Repository:
gcloud artifacts repositories delete vllm-tpu \ --location=${COMPUTE_REGION}Löschen Sie den Cluster:
gcloud container clusters delete ${CLUSTER_NAME} \ --location=LOCATIONErsetzen Sie
LOCATIONdurch eine der folgenden Umgebungsvariablen:- Verwenden Sie für Autopilot-Cluster
COMPUTE_REGION. - Verwenden Sie für Standardcluster
COMPUTE_ZONE.
- Verwenden Sie für Autopilot-Cluster
Projekt löschen
Wenn Sie die Lösung in einem neuen Google Cloud Projekt bereitgestellt haben und das Projekt nicht mehr benötigen, löschen Sie es mit den folgenden Schritten:
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
Nächste Schritte
- Erfahren Sie, wie Sie optimierte KI-/ML-Arbeitslasten über Funktionen zur GKE-Plattformorchestrierung ausführen.
- Informationen zur Verwendung von Ray Serve in GKE finden Sie im Beispielcode auf GitHub.
- Informationen zum Erfassen und Ansehen von Messwerten für Ray-Cluster, die in GKE ausgeführt werden, finden Sie unter Protokolle und Messwerte für Ray-Cluster in GKE erfassen und ansehen.