En este instructivo, se muestra cómo entregar un modelo de lenguaje grande (LLM) con unidades de procesamiento tensorial (TPU) en Google Kubernetes Engine (GKE) con el complemento Ray Operator y el framework de entrega de vLLM.
En este instructivo, puedes entregar modelos de LLM en TPU v5e o TPU Trillium (v6e) de la siguiente manera:
- Llama 3 8B instruct en una TPU v5e de host único
- Instrucción Mistral 7B v0.3 en una TPU v5e de host único.
- Llava 1.5 13b hf en una TPU v5e de host único
- Llama 3.1 70B en una TPU Trillium (v6e) de host único
Esta guía está dirigida a clientes de IA generativa, usuarios nuevos y existentes de GKE, Ingenieros de AA, Ingenieros de MLOps (DevOps) o administradores de plataformas que estén interesados en usar las capacidades de organización de contenedores de Kubernetes para entregar modelos con Ray, en TPUs con vLLM.
Fondo
En esta sección, se describen las tecnologías clave que se usan en este instructivo.
Servicio de Kubernetes administrado de GKE
Google Cloud ofrece una amplia variedad de servicios, incluido GKE, que es adecuado para implementar y administrar cargas de trabajo de IA/AA. GKE es un servicio administrado de Kubernetes que simplifica la implementación, el escalamiento y la administración de aplicaciones alojadas en contenedores. GKE proporciona la infraestructura necesaria, incluidos recursos escalables, procesamiento distribuido y redes eficientes, para controlar las demandas computacionales de los LLM.
Para obtener más información sobre los conceptos clave de Kubernetes, consulta Comienza a aprender sobre Kubernetes. Para obtener más información sobre GKE y cómo te ayuda a escalar, automatizar y administrar Kubernetes, consulta Descripción general de GKE.
Operador de Ray
El complemento Ray Operator en GKE proporciona una plataforma de IA/AA de extremo a extremo para la entrega, el entrenamiento y el perfeccionamiento de cargas de trabajo de aprendizaje automático. En este instructivo, usarás Ray Serve, un framework en Ray, para entregar LLM populares de Hugging Face.
TPU
Las TPU son circuitos integrados personalizados específicos de aplicaciones (ASIC) de Google que se usan para acelerar el aprendizaje automático y los modelos de IA compilados con frameworks como el siguiente:TensorFlow, PyTorch yJAX.
En este instructivo, se aborda la entrega de modelos de LLM en nodos TPU v5e o TPU Trillium (v6e) con topologías de TPU configuradas según los requisitos de cada modelo para entregar mensajes con baja latencia.
vLLM
vLLM es un framework de entrega de LLM de código abierto altamente optimizado que puede aumentar la capacidad de procesamiento de entrega en TPUs, con funciones como las siguientes:
- Implementación optimizada de transformadores con PagedAttention
- Agrupación en lotes continua para mejorar la capacidad de procesamiento general de la entrega
- Paralelismo de tensor y entrega distribuida en varias GPUs
Para obtener más información, consulta la documentación de vLLM.
Objetivos
En este instructivo, se abarcan los siguientes pasos:
- Crear un clúster de GKE con un grupo de nodos TPU
- Implementa un recurso personalizado de RayCluster con una porción de TPU de host único. GKE implementa el recurso personalizado RayCluster como pods de Kubernetes.
- Entrega un LLM.
- Interactuar con los modelos
De forma opcional, puedes configurar los siguientes recursos y técnicas de entrega de modelos que admite el framework de Ray Serve:
- Implementa un recurso personalizado de RayService.
- Crea varios modelos con la composición de modelos.
Antes de comenzar
Antes de comenzar, asegúrate de haber realizado las siguientes tareas:
- Habilita la API de Google Kubernetes Engine. Habilitar la API de Google Kubernetes Engine
- Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta
gcloud components updatepara obtener la versión más reciente.
- Crea una cuenta de Hugging Face, si todavía no la tienes.
- Asegúrate de tener un token de Hugging Face.
- Asegúrate de tener acceso al modelo de Hugging Face que deseas usar. Por lo general, se obtiene este acceso mediante la firma de un acuerdo y la solicitud de acceso al propietario del modelo en la página del modelo de Hugging Face.
Prepara el entorno
Asegúrate de tener suficiente cuota en tu Google Cloud proyecto para una TPU v5e de host único o una TPU Trillium (v6e) de host único. Para administrar tu cuota, consulta Cuotas de TPU.
En la consola de Google Cloud, inicia una instancia de Cloud Shell:
Abrir Cloud ShellClona el repositorio de ejemplo:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git cd kubernetes-engine-samplesNavega hasta el directorio de trabajo:
cd ai-ml/gke-ray/rayserve/llmConfigura las variables de entorno predeterminadas para la creación del clúster de GKE:
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-svcReemplaza lo siguiente:
HUGGING_FACE_TOKEN: Tu token de acceso de Hugging Face.REGION: Es la región en la que tienes la cuota de TPU. Asegúrate de que la versión de TPU que quieres usar esté disponible en esta región. Para obtener más información, consulta la disponibilidad de TPU en GKE.ZONE: La zona con la cuota de TPU disponible.VLLM_IMAGE: La imagen de TPU de vLLM. Puedes usar la imagen públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o crear tu propia imagen de TPU.
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-svcReemplaza lo siguiente:
HUGGING_FACE_TOKEN: Tu token de acceso de Hugging Face.REGION: Es la región en la que tienes la cuota de TPU. Asegúrate de que la versión de TPU que quieres usar esté disponible en esta región. Para obtener más información, consulta la disponibilidad de TPU en GKE.ZONE: La zona con la cuota de TPU disponible.VLLM_IMAGE: La imagen de TPU de vLLM. Puedes usar la imagen públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o crear tu propia imagen de TPU.
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-svcReemplaza lo siguiente:
HUGGING_FACE_TOKEN: Tu token de acceso de Hugging Face.REGION: Es la región en la que tienes la cuota de TPU. Asegúrate de que la versión de TPU que quieres usar esté disponible en esta región. Para obtener más información, consulta la disponibilidad de TPU en GKE.ZONE: La zona con la cuota de TPU disponible.VLLM_IMAGE: La imagen de TPU de vLLM. Puedes usar la imagen públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o crear tu propia imagen de TPU.
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-svcReemplaza lo siguiente:
HUGGING_FACE_TOKEN: Tu token de acceso de Hugging Face.REGION: Es la región en la que tienes la cuota de TPU. Asegúrate de que la versión de TPU que quieres usar esté disponible en esta región. Para obtener más información, consulta la disponibilidad de TPU en GKE.ZONE: La zona con la cuota de TPU disponible.VLLM_IMAGE: La imagen de TPU de vLLM. Puedes usar la imagen públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o crear tu propia imagen de TPU.
Extrae la imagen del contenedor de vLLM:
docker pull ${VLLM_IMAGE}
Crea un clúster
Puedes entregar un LLM en TPU con Ray en un clúster de GKE Autopilot o Standard con el complemento Ray Operator.
Usa un clúster de Autopilot para una experiencia de Kubernetes completamente administrada. Para elegir el modo de operación de GKE que se adapte mejor a tus cargas de trabajo, consulta Elige un modo de operación de GKE.
Usa Cloud Shell para crear un clúster de Autopilot o Standard:
Autopilot
Crea un clúster de GKE Autopilot con el complemento Ray Operator habilitado:
gcloud container clusters create-auto ${CLUSTER_NAME} \ --enable-ray-operator \ --release-channel=rapid \ --location=${COMPUTE_REGION}
Estándar
Crea un clúster estándar con el complemento Ray Operator habilitado:
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,GcsFuseCsiDriverCrea un grupo de nodos de porción de TPU de host único:
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 crea un grupo de nodos TPU v5e con un tipo de máquina
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 crea un grupo de nodos TPU v5e con un tipo de máquina
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 crea un grupo de nodos TPU v5e con un tipo de máquina
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 crea un grupo de nodos TPU v6e con un tipo de máquina
ct6e-standard-8t.
Configura kubectl para que se comunique con tu clúster
Para configurar kubectl para que se comunique con tu clúster, ejecuta el siguiente comando:
Autopilot
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_REGION}
Estándar
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_ZONE}
Crea un secreto de Kubernetes para las credenciales de Hugging Face
Para crear un Secret de Kubernetes que contenga el token de Hugging Face, ejecuta el siguiente comando:
kubectl create secret generic hf-secret \
--from-literal=hf_api_token=${HF_TOKEN} \
--dry-run=client -o yaml | kubectl --namespace ${NAMESPACE} apply -f -
Cree un bucket de Cloud Storage
Para acelerar el tiempo de inicio de la implementación de vLLM y minimizar el espacio en disco requerido por nodo, usa el controlador CSI de Cloud Storage FUSE para activar el modelo descargado y la caché de compilación en los nodos de Ray.
En Cloud Shell, ejecute el siguiente comando:
gcloud storage buckets create gs://${GSBUCKET} \
--uniform-bucket-level-access
Este comando crea un bucket de Cloud Storage para almacenar los archivos del modelo que descargas de Hugging Face.
Configura una cuenta de servicio de Kubernetes para acceder al bucket
Crea la ServiceAccount de Kubernetes:
kubectl create serviceaccount ${KSA_NAME} \ --namespace ${NAMESPACE}Otorga a la ServiceAccount de Kubernetes acceso de lectura y escritura al bucket de Cloud Storage:
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 crea los siguientes recursos para el LLM:
- Un bucket de Cloud Storage para almacenar el modelo descargado y la caché de compilación Un controlador CSI de Cloud Storage FUSE lee el contenido del bucket.
- Volumes con el almacenamiento en caché de archivos habilitado y la función de descarga en paralelo de Cloud Storage FUSE
Práctica recomendada: Usa una caché de archivos respaldada por
tmpfsoHyperdisk / Persistent Disksegún el tamaño esperado del contenido del modelo, por ejemplo, los archivos de pesos. En este instructivo, usarás el almacenamiento en caché de archivos de Cloud Storage FUSE respaldado por la RAM.
Implementa un recurso personalizado de RayCluster
Implementa un recurso personalizado de RayCluster, que suele constar de un pod del sistema y varios pods de trabajo.
Llama-3-8B-Instruct
Para crear el recurso personalizado RayCluster y, luego, implementar el modelo ajustado de instrucciones Llama 3 de 8B, completa los siguientes pasos:
Inspecciona el manifiesto
ray-cluster.tpu-v5e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.
GKE crea un recurso personalizado RayCluster con un workergroup que contiene un host único de TPU v5e en una topología 2x4.
Mistral-7B
Para crear el recurso personalizado RayCluster y, luego, implementar el modelo Mistral-7B, completa los siguientes pasos:
Inspecciona el manifiesto
ray-cluster.tpu-v5e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.
GKE crea un recurso personalizado RayCluster con un workergroup que contiene un host único de TPU v5e en una topología 2x4.
Llava-1.5-13b-hf
Para crear el recurso personalizado RayCluster y, luego, implementar el modelo Llava-1.5-13b-hf, completa los siguientes pasos:
Inspecciona el manifiesto
ray-cluster.tpu-v5e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.
GKE crea un recurso personalizado RayCluster con un workergroup que contiene un host único de TPU v5e en una topología 2x4.
Llama 3.1 70B
Para crear el recurso personalizado RayCluster y, luego, implementar el modelo Llama 3.1 70B, completa los siguientes pasos:
Inspecciona el manifiesto
ray-cluster.tpu-v6e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-cluster.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.
GKE crea un recurso personalizado RayCluster con un workergroup
que contiene un
host único de TPU v6e en una topología 2x4.
Conéctate al recurso personalizado de RayCluster
Después de crear el recurso personalizado de RayCluster, puedes conectarte al recurso de RayCluster y comenzar a entregar el modelo.
Verifica que GKE haya creado el Service de RayCluster:
kubectl --namespace ${NAMESPACE} get raycluster/vllm-tpu \ --output wideEl resultado es similar a este:
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 ### ###.###.###.### ###.###.###.###Espera hasta que
STATUSseareadyy las columnasHEAD POD IPyHEAD SERVICE IPtengan una dirección IP.Establece sesiones de
port-forwardingen el encabezado de Ray: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 &Verifica que el cliente de Ray pueda conectarse al recurso personalizado remoto de RayCluster:
docker run --net=host -it ${VLLM_IMAGE} \ ray list nodes --address http://localhost:8265El resultado es similar a este:
======== 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
Implementa el modelo con vLLM
Implementa el modelo con vLLM:
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"}}'
Consulta el panel de Ray
Puedes ver tu implementación de Ray Serve y los registros pertinentes desde el panel de Ray.
- Haz clic en el botón
Vista previa en la Web, que se encuentra en la parte superior derecha de la barra de tareas de Cloud Shell. - Haz clic en Cambiar puerto y establece el número de puerto en
8265. - Haz clic en Cambiar y obtener vista previa (Change and Preview).
- En el panel de Ray, haz clic en la pestaña Serve.
Una vez que la implementación de Serve tenga un estado HEALTHY, el modelo estará listo para comenzar a procesar las entradas.
Entrega el modelo
En esta guía, se destacan los modelos que admiten la generación de texto, una técnica que permite crear contenido de texto a partir de una instrucción.
Llama-3-8B-Instruct
Configura la redirección de puertos al servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envía un mensaje al extremo de Serve:
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
Configura la redirección de puertos al servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envía un mensaje al extremo de Serve:
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
Configura la redirección de puertos al servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envía un mensaje al extremo de Serve:
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
Configura la redirección de puertos al servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envía un mensaje al extremo de Serve:
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}'
Configuración adicional
De forma opcional, puedes configurar los siguientes recursos y técnicas de entrega de modelos que admite el framework de Ray Serve:
- Implementa un recurso personalizado de RayService. En los pasos anteriores de este instructivo, usaste RayCluster en lugar de RayService. Recomendamos RayService para entornos de producción.
- Crea varios modelos con la composición de modelos. Configura la multiplexación y la composición de modelos que son compatibles con el framework de Ray Serve. La composición de modelos te permite encadenar entradas y salidas en varios LLM y escalar tus modelos como una sola aplicación.
- Compila y, luego, implementa tu propia imagen de TPU. Te recomendamos esta opción si necesitas un control más detallado sobre el contenido de tu imagen de Docker.
Implementa un RayService
Puedes implementar los mismos modelos de este instructivo con un recurso personalizado de RayService.
Borra el recurso personalizado RayCluster que creaste en este instructivo:
kubectl --namespace ${NAMESPACE} delete raycluster/vllm-tpuCrea el recurso personalizado RayService para implementar un modelo:
Llama-3-8B-Instruct
Inspecciona el manifiesto
ray-service.tpu-v5e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.GKE crea un RayService con un
workergroupque contiene un TPU v5e de host único en una topología2x4.
Mistral-7B
Inspecciona el manifiesto
ray-service.tpu-v5e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.GKE crea un RayService con un
workergroupque contiene un TPU v5e de host único en una topología2x4.
Llava-1.5-13b-hf
Inspecciona el manifiesto
ray-service.tpu-v5e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.GKE crea un RayService con un
workergroupque contiene un TPU v5e de host único en una topología2x4.
Llama 3.1 70B
Inspecciona el manifiesto
ray-service.tpu-v6e-singlehost.yaml:Aplica el manifiesto
envsubst < tpu/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -El comando
envsubstreemplaza las variables de entorno en el manifiesto.
GKE crea un recurso personalizado de RayCluster en el que se implementa la aplicación Ray Serve y se crea el recurso personalizado de RayService posterior.
Verifica el estado del recurso de RayService:
kubectl --namespace ${NAMESPACE} get rayservices/vllm-tpuEspera a que el estado del servicio cambie a
Running:NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 1Recupera el nombre del servicio principal de RayCluster:
SERVICE_NAME=$(kubectl --namespace=${NAMESPACE} get rayservices/vllm-tpu \ --template={{.status.activeServiceStatus.rayClusterStatus.head.serviceName}})Establece sesiones de
port-forwardingen el encabezado de Ray para ver el panel de Ray:pkill -f "kubectl .* port-forward .* 8265:8265" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8265:8265 2>&1 >/dev/null &Limpia el recurso RayService:
kubectl --namespace ${NAMESPACE} delete rayservice/vllm-tpu
Cómo crear varios modelos con la composición de modelos
La composición de modelos es una técnica para componer varios modelos en una sola aplicación.
En esta sección, usarás un clúster de GKE para compilar dos modelos, Llama 3 8B IT y Gemma 7B IT, en una sola aplicación:
- El primer modelo es el modelo de asistente que responde las preguntas que se hacen en la instrucción.
- El segundo modelo es el de resumen. El resultado del modelo de asistente se encadena a la entrada del modelo de resumen. El resultado final es la versión resumida de la respuesta del modelo del asistente.
Configura tu entorno:
export ASSIST_MODEL_ID=meta-llama/Meta-Llama-3-8B-Instruct export SUMMARIZER_MODEL_ID=google/gemma-7b-itPara los clústeres estándar, crea un grupo de nodos de porción de TPU de host único adicional:
gcloud container node-pools create tpu-2 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=MACHINE_TYPE \ --num-nodes=1Reemplaza
MACHINE_TYPEpor cualquiera de los siguientes tipos de máquinas:ct5lp-hightpu-8tpara aprovisionar TPU v5e.ct6e-standard-8tpara aprovisionar TPU v6e.
Los clústeres de Autopilot aprovisionan automáticamente los nodos necesarios.
Implementa el recurso RayService según la versión de TPU que deseas usar:
TPU v5e
Inspecciona el manifiesto
ray-service.tpu-v5e-singlehost.yaml:Aplica el manifiesto
envsubst < model-composition/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
TPU v6e
Inspecciona el manifiesto
ray-service.tpu-v6e-singlehost.yaml:Aplica el manifiesto
envsubst < model-composition/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
Espera a que el estado del recurso de RayService cambie a
Running:kubectl --namespace ${NAMESPACE} get rayservice/vllm-tpuEl resultado es similar a este:
NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 2En este resultado, el estado
RUNNINGindica que el recurso de RayService está listo.Confirma que GKE haya creado el Service para la aplicación Ray Serve:
kubectl --namespace ${NAMESPACE} get service/vllm-tpu-serve-svcEl resultado es similar a este:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE vllm-tpu-serve-svc ClusterIP ###.###.###.### <none> 8000/TCP ###Establece sesiones de
port-forwardingen el encabezado de Ray:pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/vllm-tpu-serve-svc 8000:8000 2>&1 >/dev/null &Envía una solicitud al modelo:
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}'El resultado es similar a este:
{"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."]}
Compila y, luego, implementa la imagen de TPU
En este instructivo, se usan imágenes de TPU alojadas de vLLM. vLLM proporciona una imagen Dockerfile.tpu que compila vLLM sobre la imagen XLA de PyTorch requerida que incluye dependencias de TPU. Sin embargo, también puedes compilar e implementar tu propia imagen de TPU para obtener un control más detallado sobre el contenido de tu imagen de Docker.
Crea un repositorio de Docker para almacenar las imágenes de contenedor de esta guía:
gcloud artifacts repositories create vllm-tpu --repository-format=docker --location=${COMPUTE_REGION} && \ gcloud auth configure-docker ${COMPUTE_REGION}-docker.pkg.devClona el repositorio de vLLM:
git clone https://github.com/vllm-project/vllm.git cd vllmCompila la imagen:
docker build -f Dockerfile.tpu . -t vllm-tpuEtiqueta la imagen de la TPU con el nombre de Artifact Registry:
export VLLM_IMAGE=${COMPUTE_REGION}-docker.pkg.dev/${PROJECT_ID}/vllm-tpu/vllm-tpu:TAG docker tag vllm-tpu ${VLLM_IMAGE}Reemplaza
TAGpor el nombre de la etiqueta que deseas definir. Si no especificas una etiqueta, Docker aplica la etiqueta predeterminada más reciente.Envía la imagen a Artifact Registry:
docker push ${VLLM_IMAGE}
Borra los recursos individuales
Si usaste un proyecto existente y no quieres borrarlo, puedes borrar los recursos individuales.
Borra el recurso personalizado RayCluster:
kubectl --namespace ${NAMESPACE} delete rayclusters vllm-tpuBorra el bucket de Cloud Storage:
gcloud storage rm -r gs://${GSBUCKET}Borra el repositorio de Artifact Registry:
gcloud artifacts repositories delete vllm-tpu \ --location=${COMPUTE_REGION}Borra el clúster:
gcloud container clusters delete ${CLUSTER_NAME} \ --location=LOCATIONReemplaza
LOCATIONpor cualquiera de las siguientes variables de entorno:- Para los clústeres de Autopilot, usa
COMPUTE_REGION. - Para los clústeres de Standard, usa
COMPUTE_ZONE.
- Para los clústeres de Autopilot, usa
Borra el proyecto
Si implementaste el instructivo en un proyecto Google Cloud nuevo y ya no lo necesitas, sigue estos pasos para borrarlo:
- 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.
¿Qué sigue?
- Descubre cómo ejecutar cargas de trabajo de IA/AA optimizadas con las capacidades de organización de la plataforma de GKE.
- Consulta el código de muestra en GitHub para aprender a usar Ray Serve en GKE.
- Para obtener información sobre cómo recopilar y ver métricas de los clústeres de Ray que se ejecutan en GKE, completa los pasos que se indican en Recopila y consulta registros y métricas de los clústeres de Ray en GKE.