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
- 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, mit dem sich Containeranwendungen einfacher bereitstellen, skalieren und verwalten lassen. 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:
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.
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.
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:
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}
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:
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.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.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:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_REGION}
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
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.
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.
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:
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"}}'
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"}}'
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.
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}'
Maximieren Sie den folgenden Abschnitt, um ein Beispiel für die Ausgabe zu sehen.
{"prompt": "What
are the top 5 most popular programming languages? Be brief.", "text": " (Note:
This answer may change over time.)\n\nAccording to the TIOBE Index, a widely
followed measure of programming language popularity, the top 5 languages
are:\n\n1. JavaScript\n2. Python\n3. Java\n4. C++\n5. C#\n\nThese rankings are
based on a combination of search engine queries, web traffic, and online
courses. Keep in mind that other sources may have slightly different rankings.
(Source: TIOBE Index, August 2022)", "token_ids": [320, 9290, 25, 1115, 4320,
1253, 2349, 927, 892, 9456, 11439, 311, 279, 350, 3895, 11855, 8167, 11, 264,
13882, 8272, 6767, 315, 15840, 4221, 23354, 11, 279, 1948, 220, 20, 15823,
527, 1473, 16, 13, 13210, 198, 17, 13, 13325, 198, 18, 13, 8102, 198, 19, 13,
356, 23792, 20, 13, 356, 27585, 9673, 33407, 527, 3196, 389, 264, 10824, 315,
2778, 4817, 20126, 11, 3566, 9629, 11, 323, 2930, 14307, 13, 13969, 304, 4059,
430, 1023, 8336, 1253, 617, 10284, 2204, 33407, 13, 320, 3692, 25, 350, 3895,
11855, 8167, 11, 6287, 220, 2366, 17, 8, 128009]}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}'
Maximieren Sie den folgenden Abschnitt, um ein Beispiel für die Ausgabe zu sehen.
{"prompt": "What are the top 5 most popular programming languages? Be brief.",
"text": "\n\n1. JavaScript: Widely used for web development, particularly for
client-side scripting and building dynamic web page content.\n\n2. Python:
Known for its simplicity and readability, it's widely used for web
development, machine learning, data analysis, and scientific computing.\n\n3.
Java: A general-purpose programming language used in a wide range of
applications, including Android app development, web services, and
enterprise-level applications.\n\n4. C#: Developed by Microsoft, it's often
used for Windows desktop apps, game development (Unity), and web development
(ASP.NET).\n\n5. TypeScript: A superset of JavaScript that adds optional
static typing and other features for large-scale, maintainable JavaScript
applications.", "token_ids": [781, 781, 29508, 29491, 27049, 29515, 1162,
1081, 1491, 2075, 1122, 5454, 4867, 29493, 7079, 1122, 4466, 29501, 2973,
7535, 1056, 1072, 4435, 11384, 5454, 3652, 3804, 29491, 781, 781, 29518,
29491, 22134, 29515, 1292, 4444, 1122, 1639, 26001, 1072, 1988, 3205, 29493,
1146, 29510, 29481, 13343, 2075, 1122, 5454, 4867, 29493, 6367, 5936, 29493,
1946, 6411, 29493, 1072, 11237, 22031, 29491, 781, 781, 29538, 29491, 12407,
29515, 1098, 3720, 29501, 15460, 4664, 17060, 4610, 2075, 1065, 1032, 6103,
3587, 1070, 9197, 29493, 3258, 13422, 1722, 4867, 29493, 5454, 4113, 29493,
1072, 19123, 29501, 5172, 9197, 29491, 781, 781, 29549, 29491, 1102, 29539,
29515, 9355, 1054, 1254, 8670, 29493, 1146, 29510, 29481, 3376, 2075, 1122,
9723, 25470, 14189, 29493, 2807, 4867, 1093, 2501, 1240, 1325, 1072, 5454,
4867, 1093, 2877, 29521, 29491, 12466, 1377, 781, 781, 29550, 29491, 6475,
7554, 29515, 1098, 26434, 1067, 1070, 27049, 1137, 14401, 12052, 1830, 25460,
1072, 1567, 4958, 1122, 3243, 29501, 6473, 29493, 9855, 1290, 27049, 9197,
29491, 2]}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}'
Maximieren Sie den folgenden Abschnitt, um ein Beispiel für die Ausgabe zu sehen.
{"prompt": "What are
the top 5 most popular programming languages? Be brief.", "text": " This is a
very subjective question, but there are some general guidelines to follow when
selecting a language. For example, if you\u2019re looking for a language
that\u2019s easy to learn, you might want to consider Python. It\u2019s one of
the most popular languages in the world, and it\u2019s also relatively easy to
learn. If you\u2019re looking for a language that\u2019s more powerful, you
might want to consider Java. It\u2019s a more complex language, but it\u2019s
also very popular. Whichever language you choose, make sure you do your
research and pick one that\u2019s right for you.\nThe most popular programming
languages are:\nWhy is C++ so popular?\nC++ is a powerful and versatile
language that is used in many different types of software. It is also one of
the most popular programming languages, with a large community of developers
who are always creating new and innovative ways to use it. One of the reasons
why C++ is so popular is because it is a very efficient language. It allows
developers to write code that is both fast and reliable, which is essential
for many types of software. Additionally, C++ is very flexible, meaning that
it can be used for a wide range of different purposes. Finally, C++ is also
very popular because it is easy to learn. There are many resources available
online and in books that can help anyone get started with learning the
language.\nJava is a versatile language that can be used for a variety of
purposes. It is one of the most popular programming languages in the world and
is used by millions of people around the globe. Java is used for everything
from developing desktop applications to creating mobile apps and games. It is
also a popular choice for web development. One of the reasons why Java is so
popular is because it is a platform-independent language. This means that it
can be used on any type of computer or device, regardless of the operating
system. Java is also very versatile and can be used for a variety of different
purposes.", "token_ids": [1115, 374, 264, 1633, 44122, 3488, 11, 719, 1070,
527, 1063, 4689, 17959, 311, 1833, 994, 27397, 264, 4221, 13, 1789, 3187, 11,
422, 499, 3207, 3411, 369, 264, 4221, 430, 753, 4228, 311, 4048, 11, 499,
2643, 1390, 311, 2980, 13325, 13, 1102, 753, 832, 315, 279, 1455, 5526, 15823,
304, 279, 1917, 11, 323, 433, 753, 1101, 12309, 4228, 311, 4048, 13, 1442,
499, 3207, 3411, 369, 264, 4221, 430, 753, 810, 8147, 11, 499, 2643, 1390,
311, 2980, 8102, 13, 1102, 753, 264, 810, 6485, 4221, 11, 719, 433, 753, 1101,
1633, 5526, 13, 1254, 46669, 4221, 499, 5268, 11, 1304, 2771, 499, 656, 701,
3495, 323, 3820, 832, 430, 753, 1314, 369, 499, 627, 791, 1455, 5526, 15840,
15823, 527, 512, 10445, 374, 356, 1044, 779, 5526, 5380, 34, 1044, 374, 264,
8147, 323, 33045, 4221, 430, 374, 1511, 304, 1690, 2204, 4595, 315, 3241, 13,
1102, 374, 1101, 832, 315, 279, 1455, 5526, 15840, 15823, 11, 449, 264, 3544,
4029, 315, 13707, 889, 527, 2744, 6968, 502, 323, 18699, 5627, 311, 1005, 433,
13, 3861, 315, 279, 8125, 3249, 356, 1044, 374, 779, 5526, 374, 1606, 433,
374, 264, 1633, 11297, 4221, 13, 1102, 6276, 13707, 311, 3350, 2082, 430, 374,
2225, 5043, 323, 15062, 11, 902, 374, 7718, 369, 1690, 4595, 315, 3241, 13,
23212, 11, 356, 1044, 374, 1633, 19303, 11, 7438, 430, 433, 649, 387, 1511,
369, 264, 7029, 2134, 315, 2204, 10096, 13, 17830, 11, 356, 1044, 374, 1101,
1633, 5526, 1606, 433, 374, 4228, 311, 4048, 13, 2684, 527, 1690, 5070, 2561,
2930, 323, 304, 6603, 430, 649, 1520, 5606, 636, 3940, 449, 6975, 279, 4221,
627, 15391, 3S74, 264, 33045, 4221, 430, 649, 387, 1511, 369, 264, 8205, 315,
10096, 13, 1102, 374, 832, 315, 279, 1455, 5526, 15840, 15823, 304, 279, 1917,
323, 374, 1511, 555, 11990, 315, 1274, 2212, 279, 24867, 13, 8102, 374, 1511,
369, 4395, 505, 11469, 17963, 8522, 311, 6968, 6505, 10721, 323, 3953, 13,
1102, 374, 1101, 264, 5526, 5873, 369, 3566, 4500, 13, 3861, 315, 279, 8125,
3249, 8102, 374, 779, 5526, 374, 1606, 433, 374, 264, 5452, 98885, 4221, 13,
1115, 3445, 430, 433, 649, 387, 1511, 389, 904, 955, 315, 6500, 477, 3756, 11,
15851, 315, 279, 10565, 1887, 13, 8102, 374, 1101, 1633, 33045, 323, 649, 387,
1511, 369, 264, 8205, 315, 2204, 10096, 13, 128001]}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:
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.
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.
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 basierend auf der TPU-Version bereit, die Sie verwenden möchten:
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 -
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=LOCATION Ersetzen 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 Projekt bereitgestellt haben und das Projekt nicht mehr benötigen, löschen Sie es mit den folgenden Schritten: Google Cloud
- 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.