Neste tutorial, mostramos como disponibilizar um modelo de linguagem grande (LLM) usando Unidades de Processamento de Tensor (TPUs) no Google Kubernetes Engine (GKE) com o complemento Ray Operator e o framework de disponibilização vLLM.
Neste tutorial, você pode disponibilizar modelos de LLM na TPU v5e ou TPU Trillium (v6e) da seguinte maneira:
- Instrução Llama 3 8B em uma TPU v5e de host único.
- Mistral 7B instruct v0.3 em uma TPU v5e de host único.
- Llava 1.5 13b hf em uma TPU v5e de host único.
- Llama 3.1 70B em um TPU Trillium (v6e) de host único.
Este guia é destinado a clientes de IA generativa, usuários novos e atuais do GKE, engenheiros de ML, engenheiros de MLOps (DevOps) ou administradores de plataformas interessados em usar os recursos de orquestração de contêineres do Kubernetes para veicular modelos usando o Ray em TPUs com vLLM.
Contexto
Esta seção descreve as principais tecnologias usadas neste guia.
Serviço do Kubernetes gerenciado pelo GKE
OGoogle Cloud oferece uma ampla gama de serviços, incluindo o GKE, que é adequado para implantar e gerenciar cargas de trabalho de IA/ML. O GKE é um serviço gerenciado do Kubernetes que simplifica a implantação, o escalonamento e o gerenciamento de aplicativos conteinerizados. O GKE fornece a infraestrutura necessária, incluindo recursos escalonáveis, computação distribuída e rede eficiente, para lidar com as demandas computacionais de LLMs.
Para saber mais sobre os principais conceitos do Kubernetes, consulte Comece a aprender sobre o Kubernetes. Para saber mais sobre o GKE e como ele ajuda a escalonar, automatizar e gerenciar o Kubernetes, consulte a Visão geral do GKE.
Operador do Ray
O complemento Ray Operator no GKE fornece uma plataforma completa de IA/ML para servir, treinar e ajustar cargas de trabalho de machine learning. Neste tutorial, você vai usar o Ray Serve, um framework no Ray, para disponibilizar LLMs conhecidos da Hugging Face.
TPUs
TPUs são circuitos integrados de aplicação específica (ASICs, na sigla em inglês) desenvolvidos especialmente pelo Google. Eles são usados para acelerar modelos de machine learning e de IA criados com o uso de frameworks comoTensorFlow , PyTorch eJAX.
Este tutorial aborda a disponibilização de modelos de LLM em nós TPU v5e ou TPU Trillium (v6e) com topologias de TPU configuradas com base nos requisitos de cada modelo para exibir comandos com baixa latência.
vLLM
O vLLM é um framework de disponibilização de LLM de código aberto altamente otimizado que pode aumentar a capacidade de disponibilização em TPUs, com recursos como:
- Otimização da implementação do transformador com PagedAttention
- Lotes contínuos para melhorar a capacidade geral de exibição
- Paralelismo de tensor e exibição distribuída em várias GPUs
Para saber mais, consulte a documentação do vLLM.
Objetivos
Este tutorial inclui as etapas a seguir:
- Criar um cluster do GKE com um pool de nós de TPU.
- Implante um recurso personalizado do RayCluster com uma fatia de TPU de host único. O GKE implanta o recurso personalizado RayCluster como pods do Kubernetes.
- Disponibilizar um LLM.
- Interagir com os modelos.
Também é possível configurar os seguintes recursos e técnicas de disponibilização de modelos com suporte do framework Ray Serve:
- Implante um recurso personalizado do RayService.
- Crie vários modelos com a composição de modelos.
Antes de começar
Antes de começar, veja se você realizou as seguintes tarefas:
- Ative a API Google Kubernetes Engine. Ativar a API Google Kubernetes Engine
- Se você quiser usar a CLI do Google Cloud para essa tarefa,
instale e, em seguida,
inicialize a
CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão
mais recente executando
gcloud components update.
- Crie uma conta do Hugging Face caso ainda não tenha uma.
- Verifique se você tem um token do Hugging Face.
- Verifique se você tem acesso ao modelo do Hugging Face que quer usar. Geralmente, você ganha esse acesso assinando um contrato e solicitando acesso ao proprietário do modelo na página do modelo do Hugging Face.
Preparar o ambiente
Verifique se você tem cota suficiente no projeto Google Cloud para um TPU v5e de host único ou um TPU Trillium (v6e) de host único. Para gerenciar sua cota, consulte Cotas de TPU.
No console do Google Cloud, inicie uma instância do Cloud Shell:
Abrir o Cloud ShellClone o repositório de amostra:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git cd kubernetes-engine-samplesNavegue até o diretório de trabalho:
cd ai-ml/gke-ray/rayserve/llmDefina as variáveis de ambiente padrão para a criação do cluster do 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-svcSubstitua:
HUGGING_FACE_TOKEN: seu token de acesso do Hugging Face.REGION: a região em que você tem cota de TPU. Verifique se a versão da TPU que você quer usar está disponível nessa região. Para saber mais, consulte a disponibilidade da TPU no GKE.ZONE: a zona com cota de TPU disponível.VLLM_IMAGE: a imagem da TPU do vLLM. Você pode usar a imagem públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1ou criar sua própria imagem 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-svcSubstitua:
HUGGING_FACE_TOKEN: seu token de acesso do Hugging Face.REGION: a região em que você tem cota de TPU. Verifique se a versão da TPU que você quer usar está disponível nessa região. Para saber mais, consulte a disponibilidade da TPU no GKE.ZONE: a zona com cota de TPU disponível.VLLM_IMAGE: a imagem da TPU do vLLM. Você pode usar a imagem públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1ou criar sua própria imagem 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-svcSubstitua:
HUGGING_FACE_TOKEN: seu token de acesso do Hugging Face.REGION: a região em que você tem cota de TPU. Verifique se a versão da TPU que você quer usar está disponível nessa região. Para saber mais, consulte a disponibilidade da TPU no GKE.ZONE: a zona com cota de TPU disponível.VLLM_IMAGE: a imagem da TPU do vLLM. Você pode usar a imagem públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1ou criar sua própria imagem 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-svcSubstitua:
HUGGING_FACE_TOKEN: seu token de acesso do Hugging Face.REGION: a região em que você tem cota de TPU. Verifique se a versão da TPU que você quer usar está disponível nessa região. Para saber mais, consulte a disponibilidade da TPU no GKE.ZONE: a zona com cota de TPU disponível.VLLM_IMAGE: a imagem da TPU do vLLM. Você pode usar a imagem públicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1ou criar sua própria imagem de TPU.
Extraia a imagem do contêiner vLLM:
docker pull ${VLLM_IMAGE}
Criar um cluster
É possível disponibilizar um LLM em TPUs com Ray em um cluster do GKE Autopilot ou Standard usando o complemento do Operador do Ray.
Use um cluster do Autopilot para ter uma experiência totalmente gerenciada do Kubernetes. Para escolher o modo de operação do GKE mais adequado para suas cargas de trabalho, consulte Escolher um modo de operação do GKE.
Use o Cloud Shell para criar um cluster Autopilot ou Standard:
Piloto automático
Crie um cluster do GKE Autopilot com o complemento do operador do Ray ativado:
gcloud container clusters create-auto ${CLUSTER_NAME} \ --enable-ray-operator \ --release-channel=rapid \ --location=${COMPUTE_REGION}
Padrão
Crie um cluster Standard com o complemento do Operador do Ray ativado:
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,GcsFuseCsiDriverCrie um pool de nós de fração 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=1O GKE cria um pool de nós de TPU v5e com um 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=1O GKE cria um pool de nós TPU v5e com um 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=1O GKE cria um pool de nós TPU v5e com um 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=1O GKE cria um pool de nós TPU v6e com um tipo de máquina
ct6e-standard-8t.
Configurar o kubectl para se comunicar com o cluster
Para configurar o kubectl para se comunicar com o cluster, execute o seguinte comando:
Piloto automático
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_REGION}
Padrão
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_ZONE}
Criar um Secret do Kubernetes para as credenciais do Hugging Face
Para criar um secret do Kubernetes que contenha o token do Hugging Face, execute o seguinte comando:
kubectl create secret generic hf-secret \
--from-literal=hf_api_token=${HF_TOKEN} \
--dry-run=client -o yaml | kubectl --namespace ${NAMESPACE} apply -f -
Criar um bucket do Cloud Storage
Para acelerar o tempo de inicialização da implantação do vLLM e minimizar o espaço em disco necessário por nó, use o driver CSI do Cloud Storage FUSE para montar o modelo e o cache de compilação transferidos aos nós do Ray.
No Cloud Shell, execute este comando:
gcloud storage buckets create gs://${GSBUCKET} \
--uniform-bucket-level-access
Esse comando cria um bucket do Cloud Storage para armazenar os arquivos de modelo transferidos por download do Hugging Face.
Configurar uma conta de serviço do Kubernetes para acessar o bucket
Crie a conta de serviço do Kubernetes:
kubectl create serviceaccount ${KSA_NAME} \ --namespace ${NAMESPACE}Conceda à ServiceAccount do Kubernetes acesso de leitura e gravação ao bucket do 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"O GKE cria os seguintes recursos para o LLM:
- Um bucket do Cloud Storage para armazenar o modelo transferido por download e o cache de compilação. Um driver CSI do Cloud Storage FUSE lê o conteúdo do bucket.
- Volumes com armazenamento em cache de arquivos ativado e o recurso de download paralelo do Cloud Storage FUSE.
Prática recomendada: Use um cache de arquivos com suporte de
tmpfsouHyperdisk / Persistent Disk, dependendo do tamanho esperado do conteúdo do modelo, por exemplo, arquivos de peso. Neste tutorial, você vai usar o armazenamento em cache de arquivos do Cloud Storage FUSE com suporte da RAM.
Implantar um recurso personalizado do RayCluster
Implante um recurso personalizado do RayCluster, que geralmente consiste em um pod do sistema e vários pods de worker.
Llama-3-8B-Instruct
Crie o recurso personalizado RayCluster para implantar o modelo ajustado de instrução Llama 3 8B concluindo as etapas a seguir:
Inspecione o manifesto
ray-cluster.tpu-v5e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.
O GKE cria um recurso personalizado do RayCluster com um workergroup que contém um host único da TPU v5e em uma topologia 2x4.
Mistral 7B
Crie o recurso personalizado RayCluster para implantar o modelo Mistral-7B seguindo estas etapas:
Inspecione o manifesto
ray-cluster.tpu-v5e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.
O GKE cria um recurso personalizado do RayCluster com um workergroup que contém um host único da TPU v5e em uma topologia 2x4.
Llava-1.5-13b-hf
Crie o recurso personalizado do RayCluster para implantar o modelo Llava-1.5-13b-hf seguindo estas etapas:
Inspecione o manifesto
ray-cluster.tpu-v5e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.
O GKE cria um recurso personalizado do RayCluster com um workergroup
que contém um host único da TPU
v5e em uma topologia 2x4.
Llama 3.1 70B
Crie o recurso personalizado RayCluster para implantar o modelo Llama 3.1 70B seguindo estas etapas:
Inspecione o manifesto
ray-cluster.tpu-v6e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-cluster.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.
O GKE cria um recurso personalizado do RayCluster com um workergroup
que contém um
host único da TPU v6e em uma topologia 2x4.
Conectar-se ao recurso personalizado RayCluster
Depois que o recurso personalizado do RayCluster é criado, você pode se conectar a ele e começar a disponibilizar o modelo.
Verifique se o GKE criou o serviço RayCluster:
kubectl --namespace ${NAMESPACE} get raycluster/vllm-tpu \ --output wideO resultado será assim:
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 ### ###.###.###.### ###.###.###.###Aguarde até que o
STATUSsejareadye as colunasHEAD POD IPeHEAD SERVICE IPtenham um endereço IP.Estabeleça sessões
port-forwardingpara o cabeçalho do 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 &Verifique se o cliente Ray pode se conectar ao recurso personalizado remoto do RayCluster:
docker run --net=host -it ${VLLM_IMAGE} \ ray list nodes --address http://localhost:8265O resultado será assim:
======== 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
Implantar o modelo com o vLLM
Implante o modelo com o 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"}}'
Acessar o painel do Ray
É possível visualizar a implantação do Ray Serve e os registros relevantes no painel do Ray.
- Clique no botão
Visualização da Web, que fica no canto superior direito da barra de tarefas do Cloud Shell. - Clique em Change port e defina o número da porta como
8265. - Clique em Alterar e visualizar.
- No painel do Ray, clique na guia Exibir.
Depois que a implantação do Serve tiver um status HEALTHY, o modelo estará pronto para começar a processar entradas.
Disponibilizar o modelo
Este guia destaca modelos que oferecem suporte à geração de texto, uma técnica que permite a criação de conteúdo de texto a partir de um comando.
Llama-3-8B-Instruct
Configure o encaminhamento de portas para o servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envie uma solicitação para o endpoint do 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
Configure o encaminhamento de portas para o servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envie uma solicitação para o endpoint do 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
Configure o encaminhamento de portas para o servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envie uma solicitação para o endpoint do 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
Configure o encaminhamento de portas para o servidor:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Envie uma solicitação para o endpoint do 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}'
Configurações avançadas
Também é possível configurar os seguintes recursos e técnicas de disponibilização de modelos com suporte do framework Ray Serve:
- Implantar um recurso personalizado do RayService. Nas etapas anteriores deste tutorial, você usa o RayCluster em vez do RayService. Recomendamos o RayService para ambientes de produção.
- Crie vários modelos com a composição de modelos. Configure a multiplexação e a composição de modelos que são compatíveis com o framework Ray Serve. A composição de modelos permite encadear entradas e saídas em vários LLMs e dimensionar seus modelos como um único aplicativo.
- Crie e implante sua própria imagem de TPU. Recomendamos essa opção se você precisar de um controle mais refinado sobre o conteúdo da sua imagem do Docker.
Implantar um RayService
É possível implantar os mesmos modelos deste tutorial usando um recurso personalizado do RayService.
Exclua o recurso personalizado RayCluster que você criou neste tutorial:
kubectl --namespace ${NAMESPACE} delete raycluster/vllm-tpuCrie o recurso personalizado do RayService para implantar um modelo:
Llama-3-8B-Instruct
Inspecione o manifesto
ray-service.tpu-v5e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.O GKE cria um RayService com um
workergroupque contém um host único de TPU v5e em uma topologia2x4.
Mistral 7B
Inspecione o manifesto
ray-service.tpu-v5e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.O GKE cria um RayService com um
workergroupcontendo um host único de TPU v5e em uma topologia2x4.
Llava-1.5-13b-hf
Inspecione o manifesto
ray-service.tpu-v5e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.O GKE cria um RayService com um
workergroupcontendo um host único de TPU v5e em uma topologia2x4.
Llama 3.1 70B
Inspecione o manifesto
ray-service.tpu-v6e-singlehost.yaml:Aplique o manifesto:
envsubst < tpu/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -O comando
envsubstsubstitui as variáveis de ambiente no manifesto.
O GKE cria um recurso personalizado do RayCluster, em que o aplicativo Ray Serve é implantado e o recurso personalizado do RayService é criado.
Verifique o status do recurso RayService:
kubectl --namespace ${NAMESPACE} get rayservices/vllm-tpuAguarde o status do serviço mudar para
Running:NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 1Extraia o nome do serviço principal do RayCluster:
SERVICE_NAME=$(kubectl --namespace=${NAMESPACE} get rayservices/vllm-tpu \ --template={{.status.activeServiceStatus.rayClusterStatus.head.serviceName}})Estabeleça sessões
port-forwardingpara o cabeçalho do Ray para acessar o painel do Ray:pkill -f "kubectl .* port-forward .* 8265:8265" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8265:8265 2>&1 >/dev/null &Limpe o recurso RayService:
kubectl --namespace ${NAMESPACE} delete rayservice/vllm-tpu
Criar vários modelos com a composição de modelos
A composição de modelos é uma técnica para compor vários modelos em um único aplicativo.
Nesta seção, você vai usar um cluster do GKE para compor dois modelos, Llama 3 8B IT e Gemma 7B IT, em um único aplicativo:
- O primeiro modelo é o do assistente que responde às perguntas feitas no comando.
- O segundo modelo é o de resumo. A saída do modelo do assistente é encadeada na entrada do modelo de resumo. O resultado final é a versão resumida da resposta do modelo do assistente.
Configure o ambiente:
export ASSIST_MODEL_ID=meta-llama/Meta-Llama-3-8B-Instruct export SUMMARIZER_MODEL_ID=google/gemma-7b-itPara clusters padrão, crie um pool de nós de fração de TPU de host único:
gcloud container node-pools create tpu-2 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=MACHINE_TYPE \ --num-nodes=1Substitua
MACHINE_TYPEpor qualquer um dos seguintes tipos de máquina:ct5lp-hightpu-8tpara provisionar a TPU v5e.ct6e-standard-8tpara provisionar a TPU v6e.
Os clusters do Autopilot provisionam automaticamente os nós necessários.
Implante o recurso RayService com base na versão da TPU que você quer usar:
TPU v5e
Inspecione o manifesto
ray-service.tpu-v5e-singlehost.yaml:Aplique o manifesto:
envsubst < model-composition/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
TPU v6e
Inspecione o manifesto
ray-service.tpu-v6e-singlehost.yaml:Aplique o manifesto:
envsubst < model-composition/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
Aguarde até que o status do recurso RayService mude para
Running:kubectl --namespace ${NAMESPACE} get rayservice/vllm-tpuO resultado será assim:
NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 2Nesta saída, o status
RUNNINGindica que o recurso do RayService está pronto.Confirme se o GKE criou o Serviço para o aplicativo Ray Serve:
kubectl --namespace ${NAMESPACE} get service/vllm-tpu-serve-svcO resultado será assim:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE vllm-tpu-serve-svc ClusterIP ###.###.###.### <none> 8000/TCP ###Estabeleça sessões
port-forwardingpara o cabeçalho do Ray:pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/vllm-tpu-serve-svc 8000:8000 2>&1 >/dev/null &Envie uma solicitação para o 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}'O resultado será assim:
{"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."]}
Criar e implantar a imagem da TPU
Este tutorial usa imagens de TPU hospedadas do
vLLM. O vLLM fornece uma
imagem Dockerfile.tpu que cria o vLLM sobre a imagem PyTorch XLA necessária
que inclui dependências de TPU. No entanto, você também pode criar e implantar sua própria
imagem de TPU para ter um controle mais preciso sobre o conteúdo da imagem do Docker.
Crie um repositório do Docker para armazenar as imagens do contêiner deste guia:
gcloud artifacts repositories create vllm-tpu --repository-format=docker --location=${COMPUTE_REGION} && \ gcloud auth configure-docker ${COMPUTE_REGION}-docker.pkg.devClone o repositório vLLM:
git clone https://github.com/vllm-project/vllm.git cd vllmCrie a imagem:
docker build -f Dockerfile.tpu . -t vllm-tpuMarque a imagem da TPU com o nome do Artifact Registry:
export VLLM_IMAGE=${COMPUTE_REGION}-docker.pkg.dev/${PROJECT_ID}/vllm-tpu/vllm-tpu:TAG docker tag vllm-tpu ${VLLM_IMAGE}Substitua
TAGpelo nome da tag que você quer definir. Se você não especificar uma tag, o Docker vai aplicar a tag padrão mais recente.Envie a imagem para o Artifact Registry:
docker push ${VLLM_IMAGE}
Excluir recursos individuais
Se você usou um projeto existente e não quer excluí-lo, exclua os recursos individuais.
Exclua o recurso personalizado RayCluster:
kubectl --namespace ${NAMESPACE} delete rayclusters vllm-tpuExclua o bucket do Cloud Storage:
gcloud storage rm -r gs://${GSBUCKET}Exclua o repositório do Artifact Registry:
gcloud artifacts repositories delete vllm-tpu \ --location=${COMPUTE_REGION}Exclua o cluster:
gcloud container clusters delete ${CLUSTER_NAME} \ --location=LOCATIONSubstitua
LOCATIONpor qualquer uma das seguintes variáveis de ambiente:- Para clusters do Autopilot, use
COMPUTE_REGION. - Para clusters padrão, use
COMPUTE_ZONE.
- Para clusters do Autopilot, use
Excluir o projeto
Se você implantou o tutorial em um novo projeto Google Cloud e não precisa mais dele, exclua-o seguindo estas etapas:
- 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.
A seguir
- Descubra como executar cargas de trabalho de IA/ML otimizadas com os recursos de orquestração da plataforma GKE.
- Aprenda a usar o Ray Serve no GKE, acessando o exemplo de código no GitHub.
- Saiba como coletar e visualizar métricas para clusters do Ray em execução no GKE seguindo as etapas em Coletar e visualizar registros e métricas para clusters do Ray no GKE.