Disponibilizar um LLM usando TPUs no GKE com o KubeRay

Autopilot Standard

---

Este tutorial mostra 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 na TPU Trillium (v6e) da seguinte maneira:

• Llama 3 8B instruct em uma TPU v5e de host único.
• Mistral 7B instruct v0.3 em uma TPU v5e de host único.
• Llama 3.1 70B em uma TPU Trillium (v6e) de host único.

Observação: não recomendamos o uso de modelos de base como o Llama 3 8B para chatbots de produção devido a problemas de segurança. Para mais informações sobre práticas recomendadas, consulte Instruções do sistema para segurança.

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 disponibilizar modelos usando o Ray em TPUs com vLLM.

Contexto

Esta seção descreve as principais tecnologias usadas neste guia.

Serviço gerenciado do Kubernetes do GKE

Google Cloud oferece uma ampla variedade de serviços, incluindo o GKE, que é adequado para implantação e gerenciamento de 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 oferece a infraestrutura necessária, incluindo recursos escalonáveis, computação distribuída e rede eficiente, para lidar com as demandas computacionais dos LLMs.

Para saber mais sobre os principais conceitos do Kubernetes, consulte Começar a aprender sobre o Kubernetes. Para saber mais sobre o GKE e como ele ajuda você a escalonar, automatizar e gerenciar o Kubernetes, consulte a visão geral do GKE.

Operador do Ray

O complemento Ray Operator no GKE oferece uma plataforma completa de IA/ML para veiculação, treinamento e ajuste de cargas de trabalho de machine learning. Neste tutorial, você vai usar o Ray Serve, um framework do 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 de TPU v5e ou TPU Trillium (v6e) com topologias de TPU configuradas com base nos requisitos de cada modelo para disponibilizar prompts com baixa latência.

vLLM

O vLLM é um framework de exibição de LLM de código aberto altamente otimizado que pode aumentar a capacidade de exibiçã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:

1. Criar um cluster do GKE com um pool de nós de TPU.
2. Implante um recurso personalizado RayCluster com uma fração de TPU de host único. O GKE implanta o recurso personalizado RayCluster como pods do Kubernetes.
3. Disponibilizar um LLM.
4. Interagir com os modelos.

Também é possível configurar os seguintes recursos e técnicas de disponibilização de modelos compatíveis com o framework Ray Serve:

• Implante um recurso personalizado do RayService.
• Criar vários modelos com a composição de modelos.

Antes de começar

Antes de começar, verifique se você realizou as seguintes tarefas:

• Ativar 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.
  Observação:para instalações atuais da CLI gcloud, defina a propriedade compute/region. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, você evita erros na CLI gcloud como este: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

• 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. Normalmente, você ganha esse acesso ao assinar um contrato e solicitar acesso ao proprietário do modelo na página do modelo do Hugging Face.
• Verifique se você tem os seguintes papéis do IAM:
  • roles/container.admin
  • roles/iam.serviceAccountAdmin
  • roles/container.clusterAdmin
  • roles/artifactregistry.writer

Preparar o ambiente

1. Verifique se você tem cota suficiente no projeto Google Cloud para uma TPU v5e de host único ou uma TPU Trillium (v6e) de host único. Para gerenciar sua cota, consulte Cotas de TPU.

2. No Google Cloud console, inicie uma instância do Cloud Shell:
   Abrir o Cloud Shell

3. Clone o repositório de amostra:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   cd kubernetes-engine-samples
   

4. Navegue até o diretório de trabalho:

   cd ai-ml/gke-ray/rayserve/llm
   

5. Defina 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-svc
   

   Substitua:

   • 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 Disponibilidade da TPU no GKE.
   • ZONE: a zona com cota de TPU disponível.
   • VLLM_IMAGE: a imagem da TPU do vLLM. É possível usar a imagem pública docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 ou 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-svc
   

   Substitua:

   • 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 Disponibilidade da TPU no GKE.
   • ZONE: a zona com cota de TPU disponível.
   • VLLM_IMAGE: a imagem da TPU do vLLM. É possível usar a imagem pública docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 ou 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-svc
   

   Substitua:

   • 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 Disponibilidade da TPU no GKE.
   • ZONE: a zona com cota de TPU disponível.
   • VLLM_IMAGE: a imagem da TPU do vLLM. É possível usar a imagem pública docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 ou criar sua própria imagem de TPU.

6. Extraia a imagem do contêiner vLLM:

   sudo usermod -aG docker ${USER}
   newgrp docker
   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.

Práticas recomendadas:

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

1. 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

1. 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,GcsFuseCsiDriver
   

2. Crie 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=1
   

   O GKE cria um pool de nós 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=1
   

   O 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=1
   

   O GKE cria um pool de nós de TPU v6e com um tipo de máquina ct6e-standard-8t.

Configure o kubectl para se comunicar com o cluster

Para configurar o kubectl para se comunicar com o cluster, execute o comando a seguir:

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 baixado e o cache de compilação nos 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

1. Crie a conta de serviço do Kubernetes:

   kubectl create serviceaccount ${KSA_NAME} \
       --namespace ${NAMESPACE}
   

2. 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:

   1. Um bucket do Cloud Storage para armazenar o modelo baixado e o cache de compilação. Um driver CSI do Cloud Storage FUSE lê o conteúdo do bucket.
   2. Volumes com 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 tmpfs ou Hyperdisk / Persistent Disk dependendo do tamanho esperado do conteúdo do modelo, por exemplo, arquivos de peso. Neste tutorial, você vai usar o cache de arquivos do Cloud Storage FUSE com suporte de 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 Llama 3 8B ajustado por instruções concluindo as seguintes etapas:

1. Inspecione o manifesto ray-cluster.tpu-v5e-singlehost.yaml:

   apiVersion: ray.io/v1
   kind: RayCluster
   metadata:
     name: vllm-tpu
   spec:
     headGroupSpec:
       rayStartParams: {}
       template:
         metadata:
           annotations:
             gke-gcsfuse/volumes: "true"
             gke-gcsfuse/cpu-limit: "0"
             gke-gcsfuse/memory-limit: "0"
             gke-gcsfuse/ephemeral-storage-limit: "0"
         spec:
           serviceAccountName: $KSA_NAME
           containers:
             - name: ray-head
               image: $VLLM_IMAGE
               imagePullPolicy: IfNotPresent
               resources:
                 limits:
                   cpu: "2"
                   memory: 8G
                 requests:
                   cpu: "2"
                   memory: 8G
               env:
                 - name: HUGGING_FACE_HUB_TOKEN
                   valueFrom:
                     secretKeyRef:
                       name: hf-secret
                       key: hf_api_token
                 - name: VLLM_XLA_CACHE_PATH
                   value: "/data"
               ports:
                 - containerPort: 6379
                   name: gcs
                 - containerPort: 8265
                   name: dashboard
                 - containerPort: 10001
                   name: client
                 - containerPort: 8000
                   name: serve
                 - containerPort: 8471
                   name: slicebuilder
                 - containerPort: 8081
                   name: mxla
               volumeMounts:
               - name: gcs-fuse-csi-ephemeral
                 mountPath: /data
               - name: dshm
                 mountPath: /dev/shm
           volumes:
           - name: gke-gcsfuse-cache
             emptyDir:
               medium: Memory
           - name: dshm
             emptyDir:
               medium: Memory
           - name: gcs-fuse-csi-ephemeral
             csi:
               driver: gcsfuse.csi.storage.gke.io
               volumeAttributes:
                 bucketName: $GSBUCKET
                 mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
     workerGroupSpecs:
     - groupName: tpu-group
       replicas: 1
       minReplicas: 1
       maxReplicas: 1
       numOfHosts: 1
       rayStartParams: {}
       template:
         metadata:
           annotations:
             gke-gcsfuse/volumes: "true"
             gke-gcsfuse/cpu-limit: "0"
             gke-gcsfuse/memory-limit: "0"
             gke-gcsfuse/ephemeral-storage-limit: "0"
         spec:
           serviceAccountName: $KSA_NAME
           containers:
             - name: ray-worker
               image: $VLLM_IMAGE
               imagePullPolicy: IfNotPresent
               resources:
                 limits:
                   cpu: "100"
                   google.com/tpu: "8"
                   ephemeral-storage: 40G
                   memory: 200G
                 requests:
                   cpu: "100"
                   google.com/tpu: "8"
                   ephemeral-storage: 40G
                   memory: 200G
               env:
                 - name: VLLM_XLA_CACHE_PATH
                   value: "/data"
                 - name: HUGGING_FACE_HUB_TOKEN
                   valueFrom:
                     secretKeyRef:
                       name: hf-secret
                       key: hf_api_token
               volumeMounts:
               - name: gcs-fuse-csi-ephemeral
                 mountPath: /data
               - name: dshm
                 mountPath: /dev/shm
           volumes:
           - name: gke-gcsfuse-cache
             emptyDir:
               medium: Memory
           - name: dshm
             emptyDir:
               medium: Memory
           - name: gcs-fuse-csi-ephemeral
             csi:
               driver: gcsfuse.csi.storage.gke.io
               volumeAttributes:
                 bucketName: $GSBUCKET
                 mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
           nodeSelector:
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
             cloud.google.com/gke-tpu-topology: 2x4

2. Aplique o manifesto:

   envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
   

   O comando envsubst substitui as variáveis de ambiente no manifesto.

O GKE cria um recurso personalizado RayCluster com um workergroup que contém uma TPU v5e de host único em uma topologia 2x4.

Mistral 7B

Crie o recurso personalizado RayCluster para implantar o modelo Mistral-7B seguindo estas etapas:

1. Inspecione o manifesto ray-cluster.tpu-v5e-singlehost.yaml:

   apiVersion: ray.io/v1
   kind: RayCluster
   metadata:
     name: vllm-tpu
   spec:
     headGroupSpec:
       rayStartParams: {}
       template:
         metadata:
           annotations:
             gke-gcsfuse/volumes: "true"
             gke-gcsfuse/cpu-limit: "0"
             gke-gcsfuse/memory-limit: "0"
             gke-gcsfuse/ephemeral-storage-limit: "0"
         spec:
           serviceAccountName: $KSA_NAME
           containers:
             - name: ray-head
               image: $VLLM_IMAGE
               imagePullPolicy: IfNotPresent
               resources:
                 limits:
                   cpu: "2"
                   memory: 8G
                 requests:
                   cpu: "2"
                   memory: 8G
               env:
                 - name: HUGGING_FACE_HUB_TOKEN
                   valueFrom:
                     secretKeyRef:
                       name: hf-secret
                       key: hf_api_token
                 - name: VLLM_XLA_CACHE_PATH
                   value: "/data"
               ports:
                 - containerPort: 6379
                   name: gcs
                 - containerPort: 8265
                   name: dashboard
                 - containerPort: 10001
                   name: client
                 - containerPort: 8000
                   name: serve
                 - containerPort: 8471
                   name: slicebuilder
                 - containerPort: 8081
                   name: mxla
               volumeMounts:
               - name: gcs-fuse-csi-ephemeral
                 mountPath: /data
               - name: dshm
                 mountPath: /dev/shm
           volumes:
           - name: gke-gcsfuse-cache
             emptyDir:
               medium: Memory
           - name: dshm
             emptyDir:
               medium: Memory
           - name: gcs-fuse-csi-ephemeral
             csi:
               driver: gcsfuse.csi.storage.gke.io
               volumeAttributes:
                 bucketName: $GSBUCKET
                 mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
     workerGroupSpecs:
     - groupName: tpu-group
       replicas: 1
       minReplicas: 1
       maxReplicas: 1
       numOfHosts: 1
       rayStartParams: {}
       template:
         metadata:
           annotations:
             gke-gcsfuse/volumes: "true"
             gke-gcsfuse/cpu-limit: "0"
             gke-gcsfuse/memory-limit: "0"
             gke-gcsfuse/ephemeral-storage-limit: "0"
         spec:
           serviceAccountName: $KSA_NAME
           containers:
             - name: ray-worker
               image: $VLLM_IMAGE
               imagePullPolicy: IfNotPresent
               resources:
                 limits:
                   cpu: "100"
                   google.com/tpu: "8"
                   ephemeral-storage: 40G
                   memory: 200G
                 requests:
                   cpu: "100"
                   google.com/tpu: "8"
                   ephemeral-storage: 40G
                   memory: 200G
               env:
                 - name: VLLM_XLA_CACHE_PATH
                   value: "/data"
                 - name: HUGGING_FACE_HUB_TOKEN
                   valueFrom:
                     secretKeyRef:
                       name: hf-secret
                       key: hf_api_token
               volumeMounts:
               - name: gcs-fuse-csi-ephemeral
                 mountPath: /data
               - name: dshm
                 mountPath: /dev/shm
           volumes:
           - name: gke-gcsfuse-cache
             emptyDir:
               medium: Memory
           - name: dshm
             emptyDir:
               medium: Memory
           - name: gcs-fuse-csi-ephemeral
             csi:
               driver: gcsfuse.csi.storage.gke.io
               volumeAttributes:
                 bucketName: $GSBUCKET
                 mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
           nodeSelector:
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
             cloud.google.com/gke-tpu-topology: 2x4

2. Aplique o manifesto:

   envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
   

   O comando envsubst substitui as variáveis de ambiente no manifesto.

O GKE cria um recurso personalizado RayCluster com um workergroup que contém uma TPU v5e de host único em uma topologia 2x4.

Llama 3.1 70B

Crie o recurso personalizado RayCluster para implantar o modelo Llama 3.1 70B seguindo estas etapas:

1. Inspecione o manifesto ray-cluster.tpu-v6e-singlehost.yaml:

   apiVersion: ray.io/v1
   kind: RayCluster
   metadata:
     name: vllm-tpu
   spec:
     headGroupSpec:
       rayStartParams: {}
       template:
         metadata:
           annotations:
             gke-gcsfuse/volumes: "true"
             gke-gcsfuse/cpu-limit: "0"
             gke-gcsfuse/memory-limit: "0"
             gke-gcsfuse/ephemeral-storage-limit: "0"
         spec:
           serviceAccountName: $KSA_NAME
           containers:
             - name: ray-head
               image: $VLLM_IMAGE
               imagePullPolicy: IfNotPresent
               resources:
                 limits:
                   cpu: "2"
                   memory: 8G
                 requests:
                   cpu: "2"
                   memory: 8G
               env:
                 - name: HUGGING_FACE_HUB_TOKEN
                   valueFrom:
                     secretKeyRef:
                       name: hf-secret
                       key: hf_api_token
                 - name: VLLM_XLA_CACHE_PATH
                   value: "/data"
               ports:
                 - containerPort: 6379
                   name: gcs
                 - containerPort: 8265
                   name: dashboard
                 - containerPort: 10001
                   name: client
                 - containerPort: 8000
                   name: serve
                 - containerPort: 8471
                   name: slicebuilder
                 - containerPort: 8081
                   name: mxla
               volumeMounts:
               - name: gcs-fuse-csi-ephemeral
                 mountPath: /data
               - name: dshm
                 mountPath: /dev/shm
           volumes:
           - name: gke-gcsfuse-cache
             emptyDir:
               medium: Memory
           - name: dshm
             emptyDir:
               medium: Memory
           - name: gcs-fuse-csi-ephemeral
             csi:
               driver: gcsfuse.csi.storage.gke.io
               volumeAttributes:
                 bucketName: $GSBUCKET
                 mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
     workerGroupSpecs:
     - groupName: tpu-group
       replicas: 1
       minReplicas: 1
       maxReplicas: 1
       numOfHosts: 1
       rayStartParams: {}
       template:
         metadata:
           annotations:
             gke-gcsfuse/volumes: "true"
             gke-gcsfuse/cpu-limit: "0"
             gke-gcsfuse/memory-limit: "0"
             gke-gcsfuse/ephemeral-storage-limit: "0"
         spec:
           serviceAccountName: $KSA_NAME
           containers:
             - name: ray-worker
               image: $VLLM_IMAGE
               imagePullPolicy: IfNotPresent
               resources:
                 limits:
                   cpu: "100"
                   google.com/tpu: "8"
                   ephemeral-storage: 40G
                   memory: 200G
                 requests:
                   cpu: "100"
                   google.com/tpu: "8"
                   ephemeral-storage: 40G
                   memory: 200G
               env:
                 - name: HUGGING_FACE_HUB_TOKEN
                   valueFrom:
                     secretKeyRef:
                       name: hf-secret
                       key: hf_api_token
                 - name: VLLM_XLA_CACHE_PATH
                   value: "/data"
               volumeMounts:
               - name: gcs-fuse-csi-ephemeral
                 mountPath: /data
               - name: dshm
                 mountPath: /dev/shm
           volumes:
           - name: gke-gcsfuse-cache
             emptyDir:
               medium: Memory
           - name: dshm
             emptyDir:
               medium: Memory
           - name: gcs-fuse-csi-ephemeral
             csi:
               driver: gcsfuse.csi.storage.gke.io
               volumeAttributes:
                 bucketName: $GSBUCKET
                 mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
           nodeSelector:
             cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
             cloud.google.com/gke-tpu-topology: 2x4

2. Aplique o manifesto:

   envsubst < tpu/ray-cluster.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
   

   O comando envsubst substitui as variáveis de ambiente no manifesto.

O GKE cria um recurso personalizado RayCluster com um workergroup que contém uma TPU v6e de host único em uma topologia 2x4.

Conectar-se ao recurso personalizado RayCluster

Depois que o recurso personalizado do RayCluster for criado, você poderá se conectar a ele e começar a disponibilizar o modelo.

1. Verifique se o GKE criou o serviço RayCluster:

   kubectl --namespace ${NAMESPACE} get raycluster/vllm-tpu \
       --output wide
   

   O 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 STATUS seja ready e as colunas HEAD POD IP e HEAD SERVICE IP tenham um endereço IP.

2. Estabeleça sessões port-forwarding para o head 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 &
   

3. Verifique se o cliente Ray pode se conectar ao recurso personalizado RayCluster remoto:

   docker run --net=host -it ${VLLM_IMAGE} \
   ray list nodes --address http://localhost:8265
   

   O 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 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"}}'

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.

1. Clique no botão Visualização da Web, que fica no canto superior direito da barra de tarefas do Cloud Shell.
2. Clique em Alterar porta e defina o número da porta como 8265.
3. Clique em Alterar e visualizar.
4. No painel do Ray, clique na guia Exibir.

Quando a implantação do serviço tiver o 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 com base em um comando.

Llama-3-8B-Instruct

1. 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 &
   

2. Envie um comando para o endpoint de serviço:

   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}'
   

Expanda a seção a seguir para ver um exemplo da saída.

{"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]}

Mistral 7B

1. 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 &
   

2. Envie um comando para o endpoint de serviço:

   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}'
   

Expanda a seção a seguir para ver um exemplo da saída.

{"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]}

Llama 3.1 70B

1. 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 &
   

2. Envie um comando para o endpoint de serviço:

   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}'
   

Expanda a seção a seguir para ver um exemplo da saída.

{"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]}

Sucesso :você implantou um LLM com um recurso personalizado RayCluster em uma fatia de TPU de host único.

Configurações avançadas

Também é possível configurar os seguintes recursos e técnicas de disponibilização de modelos compatíveis com o framework Ray Serve:

• Implante um recurso personalizado do RayService. Nas etapas anteriores deste tutorial, você usou o RayCluster em vez do RayService. Recomendamos o RayService para ambientes de produção.
• Criar vários modelos com a composição de modelos. Configure a multiplexação e a composição de modelos 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.

1. Exclua o recurso personalizado RayCluster que você criou neste tutorial:

   kubectl --namespace ${NAMESPACE} delete raycluster/vllm-tpu
   

2. Crie o recurso personalizado RayService para implantar um modelo:

   Llama-3-8B-Instruct

   1. Inspecione o manifesto ray-service.tpu-v5e-singlehost.yaml:

      apiVersion: ray.io/v1
      kind: RayService
      metadata:
        name: vllm-tpu
      spec:
        serveConfigV2: |
          applications:
            - name: llm
              import_path: ai-ml.gke-ray.rayserve.llm.tpu.serve_tpu:model
              deployments:
              - name: VLLMDeployment
                num_replicas: 1
              runtime_env:
                working_dir: "https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/archive/main.zip"
                env_vars:
                  MODEL_ID: "$MODEL_ID"
                  MAX_MODEL_LEN: "$MAX_MODEL_LEN"
                  DTYPE: "$DTYPE"
                  TOKENIZER_MODE: "$TOKENIZER_MODE"
                  TPU_CHIPS: "8"
        rayClusterConfig:
          headGroupSpec:
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                - name: ray-head
                  image: $VLLM_IMAGE
                  imagePullPolicy: IfNotPresent
                  ports:
                  - containerPort: 6379
                    name: gcs
                  - containerPort: 8265
                    name: dashboard
                  - containerPort: 10001
                    name: client
                  - containerPort: 8000
                    name: serve
                  env:
                  - name: HUGGING_FACE_HUB_TOKEN
                    valueFrom:
                      secretKeyRef:
                        name: hf-secret
                        key: hf_api_token
                  - name: VLLM_XLA_CACHE_PATH
                    value: "/data"
                  resources:
                    limits:
                      cpu: "2"
                      memory: 8G
                    requests:
                      cpu: "2"
                      memory: 8G
                  volumeMounts:
                  - name: gcs-fuse-csi-ephemeral
                    mountPath: /data
                  - name: dshm
                    mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
          workerGroupSpecs:
          - groupName: tpu-group
            replicas: 1
            minReplicas: 1
            maxReplicas: 1
            numOfHosts: 1
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                  - name: ray-worker
                    image: $VLLM_IMAGE
                    imagePullPolicy: IfNotPresent
                    resources:
                      limits:
                        cpu: "100"
                        google.com/tpu: "8"
                        ephemeral-storage: 40G
                        memory: 200G
                      requests:
                        cpu: "100"
                        google.com/tpu: "8"
                        ephemeral-storage: 40G
                        memory: 200G
                    env:
                      - name: JAX_PLATFORMS
                        value: "tpu"
                      - name: HUGGING_FACE_HUB_TOKEN
                        valueFrom:
                          secretKeyRef:
                            name: hf-secret
                            key: hf_api_token
                      - name: VLLM_XLA_CACHE_PATH
                        value: "/data"
                    volumeMounts:
                    - name: gcs-fuse-csi-ephemeral
                      mountPath: /data
                    - name: dshm
                      mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
                nodeSelector:
                  cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                  cloud.google.com/gke-tpu-topology: 2x4

   2. Aplique o manifesto:

      envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
      

      O comando envsubst substitui as variáveis de ambiente no manifesto.

      O GKE cria um RayService com um workergroup que contém uma TPU v5e de host único em uma topologia 2x4.

   Mistral 7B

   1. Inspecione o manifesto ray-service.tpu-v5e-singlehost.yaml:

      apiVersion: ray.io/v1
      kind: RayService
      metadata:
        name: vllm-tpu
      spec:
        serveConfigV2: |
          applications:
            - name: llm
              import_path: ai-ml.gke-ray.rayserve.llm.tpu.serve_tpu:model
              deployments:
              - name: VLLMDeployment
                num_replicas: 1
              runtime_env:
                working_dir: "https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/archive/main.zip"
                env_vars:
                  MODEL_ID: "$MODEL_ID"
                  MAX_MODEL_LEN: "$MAX_MODEL_LEN"
                  DTYPE: "$DTYPE"
                  TOKENIZER_MODE: "$TOKENIZER_MODE"
                  TPU_CHIPS: "8"
        rayClusterConfig:
          headGroupSpec:
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                - name: ray-head
                  image: $VLLM_IMAGE
                  imagePullPolicy: IfNotPresent
                  ports:
                  - containerPort: 6379
                    name: gcs
                  - containerPort: 8265
                    name: dashboard
                  - containerPort: 10001
                    name: client
                  - containerPort: 8000
                    name: serve
                  env:
                  - name: HUGGING_FACE_HUB_TOKEN
                    valueFrom:
                      secretKeyRef:
                        name: hf-secret
                        key: hf_api_token
                  - name: VLLM_XLA_CACHE_PATH
                    value: "/data"
                  resources:
                    limits:
                      cpu: "2"
                      memory: 8G
                    requests:
                      cpu: "2"
                      memory: 8G
                  volumeMounts:
                  - name: gcs-fuse-csi-ephemeral
                    mountPath: /data
                  - name: dshm
                    mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
          workerGroupSpecs:
          - groupName: tpu-group
            replicas: 1
            minReplicas: 1
            maxReplicas: 1
            numOfHosts: 1
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                  - name: ray-worker
                    image: $VLLM_IMAGE
                    imagePullPolicy: IfNotPresent
                    resources:
                      limits:
                        cpu: "100"
                        google.com/tpu: "8"
                        ephemeral-storage: 40G
                        memory: 200G
                      requests:
                        cpu: "100"
                        google.com/tpu: "8"
                        ephemeral-storage: 40G
                        memory: 200G
                    env:
                      - name: JAX_PLATFORMS
                        value: "tpu"
                      - name: HUGGING_FACE_HUB_TOKEN
                        valueFrom:
                          secretKeyRef:
                            name: hf-secret
                            key: hf_api_token
                      - name: VLLM_XLA_CACHE_PATH
                        value: "/data"
                    volumeMounts:
                    - name: gcs-fuse-csi-ephemeral
                      mountPath: /data
                    - name: dshm
                      mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
                nodeSelector:
                  cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                  cloud.google.com/gke-tpu-topology: 2x4

   2. Aplique o manifesto:

      envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
      

      O comando envsubst substitui as variáveis de ambiente no manifesto.

      O GKE cria um RayService com um workergroup que contém uma TPU v5e de host único em uma topologia 2x4.

   Llama 3.1 70B

   1. Inspecione o manifesto ray-service.tpu-v6e-singlehost.yaml:

      apiVersion: ray.io/v1
      kind: RayService
      metadata:
        name: vllm-tpu
      spec:
        serveConfigV2: |
          applications:
            - name: llm
              import_path: ai-ml.gke-ray.rayserve.llm.tpu.serve_tpu:model
              deployments:
              - name: VLLMDeployment
                num_replicas: 1
              runtime_env:
                working_dir: "https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/archive/main.zip"
                env_vars:
                  MODEL_ID: "$MODEL_ID"
                  MAX_MODEL_LEN: "$MAX_MODEL_LEN"
                  DTYPE: "$DTYPE"
                  TOKENIZER_MODE: "$TOKENIZER_MODE"
                  TPU_CHIPS: "8"
        rayClusterConfig:
          headGroupSpec:
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                - name: ray-head
                  image: $VLLM_IMAGE
                  imagePullPolicy: IfNotPresent
                  ports:
                  - containerPort: 6379
                    name: gcs
                  - containerPort: 8265
                    name: dashboard
                  - containerPort: 10001
                    name: client
                  - containerPort: 8000
                    name: serve
                  env:
                  - name: HUGGING_FACE_HUB_TOKEN
                    valueFrom:
                      secretKeyRef:
                        name: hf-secret
                        key: hf_api_token
                  - name: VLLM_XLA_CACHE_PATH
                    value: "/data"
                  resources:
                    limits:
                      cpu: "2"
                      memory: 8G
                    requests:
                      cpu: "2"
                      memory: 8G
                  volumeMounts:
                  - name: gcs-fuse-csi-ephemeral
                    mountPath: /data
                  - name: dshm
                    mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
          workerGroupSpecs:
          - groupName: tpu-group
            replicas: 1
            minReplicas: 1
            maxReplicas: 1
            numOfHosts: 1
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                  - name: ray-worker
                    image: $VLLM_IMAGE
                    imagePullPolicy: IfNotPresent
                    resources:
                      limits:
                        cpu: "100"
                        google.com/tpu: "8"
                        ephemeral-storage: 40G
                        memory: 200G
                      requests:
                        cpu: "100"
                        google.com/tpu: "8"
                        ephemeral-storage: 40G
                        memory: 200G
                    env:
                      - name: JAX_PLATFORMS
                        value: "tpu"
                      - name: HUGGING_FACE_HUB_TOKEN
                        valueFrom:
                          secretKeyRef:
                            name: hf-secret
                            key: hf_api_token
                      - name: VLLM_XLA_CACHE_PATH
                        value: "/data"
                    volumeMounts:
                    - name: gcs-fuse-csi-ephemeral
                      mountPath: /data
                    - name: dshm
                      mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
                nodeSelector:
                  cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
                  cloud.google.com/gke-tpu-topology: 2x4

   2. Aplique o manifesto:

      envsubst < tpu/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
      

      O comando envsubst substitui 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 subsequente é criado.

3. Verifique o status do recurso RayService:

   kubectl --namespace ${NAMESPACE} get rayservices/vllm-tpu
   

   Aguarde até que o status do serviço mude para Running:

   NAME       SERVICE STATUS   NUM SERVE ENDPOINTS
   vllm-tpu   Running          1
   

4. Recupere o nome do serviço principal do RayCluster:

   SERVICE_NAME=$(kubectl --namespace=${NAMESPACE} get rayservices/vllm-tpu \
       --template={{.status.activeServiceStatus.rayClusterStatus.head.serviceName}})
   

   Observação: se o valor do serviço principal do RayCluster não for recuperado, atualize manualmente o valor SERVICE_NAME executando o comando kubectl get services --namespace ${NAMESPACE}.

5. Estabeleça sessões port-forwarding para o head do Ray e veja 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 &
   

6. Acessar o painel do Ray.

7. Disponibilize o modelo.

8. Limpe o recurso do 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 combinar 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 é o modelo de assistente que responde às perguntas feitas no comando.
• O segundo modelo é o de resumo. A saída do modelo de assistente é encadeada à entrada do modelo de resumo. O resultado final é a versão resumida da resposta do modelo de assistente.

1. Para ter acesso ao modelo Gemma, siga estas etapas:

   1. Faça login na plataforma Kaggle, assine o contrato de consentimento de licença e receba um token da API Kaggle. Neste tutorial, você usa um Secret do Kubernetes para as credenciais do Kaggle.
   2. Acesse a página de consentimento do modelo em Kaggle.com.
   3. Faça login no Kaggle, caso ainda não o tenha feito.
   4. Clique em Solicitar acesso.
   5. Na seção Escolher conta para consentimento, selecione Verificar via conta do Kaggle para usar sua conta do Kaggle para conceder permissão.
   6. Aceite os Termos e Condições do modelo.

2. Configure seu ambiente:

   export ASSIST_MODEL_ID=meta-llama/Meta-Llama-3-8B-Instruct
   export SUMMARIZER_MODEL_ID=google/gemma-7b-it
   

3. Para clusters Standard, crie outro 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=1
   

   Substitua MACHINE_TYPE por um dos seguintes tipos de máquina:

   • ct5lp-hightpu-8t para provisionar a TPU v5e.
   • ct6e-standard-8t para provisionar a TPU v6e.

   Os clusters do Autopilot provisionam automaticamente os nós necessários.

4. Implante o recurso RayService com base na versão da TPU que você quer usar:

   TPU v5e

   1. Inspecione o manifesto ray-service.tpu-v5e-singlehost.yaml:

      apiVersion: ray.io/v1
      kind: RayService
      metadata:
        name: vllm-tpu
      spec:
        serveConfigV2: |
          applications:
          - name: llm
            route_prefix: /
            import_path:  ai-ml.gke-ray.rayserve.llm.model-composition.serve_tpu:multi_model
            deployments:
            - name: MultiModelDeployment
              num_replicas: 1
            runtime_env:
              working_dir: "https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/archive/main.zip"
              env_vars:
                ASSIST_MODEL_ID: "$ASSIST_MODEL_ID"
                SUMMARIZER_MODEL_ID: "$SUMMARIZER_MODEL_ID"
                TPU_CHIPS: "16"
                TPU_HEADS: "2"
        rayClusterConfig:
          headGroupSpec:
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                - name: ray-head
                  image: $VLLM_IMAGE
                  resources:
                    limits:
                      cpu: "2"
                      memory: 8G
                    requests:
                      cpu: "2"
                      memory: 8G
                  ports:
                  - containerPort: 6379
                    name: gcs-server
                  - containerPort: 8265
                    name: dashboard
                  - containerPort: 10001
                    name: client
                  - containerPort: 8000
                    name: serve
                  env:
                    - name: HUGGING_FACE_HUB_TOKEN
                      valueFrom:
                        secretKeyRef:
                          name: hf-secret
                          key: hf_api_token
                    - name: VLLM_XLA_CACHE_PATH
                      value: "/data"
                  volumeMounts:
                  - name: gcs-fuse-csi-ephemeral
                    mountPath: /data
                  - name: dshm
                    mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
          workerGroupSpecs:
          - replicas: 2
            minReplicas: 1
            maxReplicas: 2
            numOfHosts: 1
            groupName: tpu-group
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                - name: llm
                  image: $VLLM_IMAGE
                  env:
                    - name: HUGGING_FACE_HUB_TOKEN
                      valueFrom:
                        secretKeyRef:
                          name: hf-secret
                          key: hf_api_token
                    - name: VLLM_XLA_CACHE_PATH
                      value: "/data"
                  resources:
                    limits:
                      cpu: "100"
                      google.com/tpu: "8"
                      ephemeral-storage: 40G
                      memory: 200G
                    requests:
                      cpu: "100"
                      google.com/tpu: "8"
                      ephemeral-storage: 40G
                      memory: 200G
                  volumeMounts:
                  - name: gcs-fuse-csi-ephemeral
                    mountPath: /data
                  - name: dshm
                    mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
                nodeSelector:
                  cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                  cloud.google.com/gke-tpu-topology: 2x4

   2. Aplique o manifesto:

      envsubst < model-composition/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
      

   TPU v6e

   1. Inspecione o manifesto ray-service.tpu-v6e-singlehost.yaml:

      apiVersion: ray.io/v1
      kind: RayService
      metadata:
        name: vllm-tpu
      spec:
        serveConfigV2: |
          applications:
          - name: llm
            route_prefix: /
            import_path:  ai-ml.gke-ray.rayserve.llm.model-composition.serve_tpu:multi_model
            deployments:
            - name: MultiModelDeployment
              num_replicas: 1
            runtime_env:
              working_dir: "https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/archive/main.zip"
              env_vars:
                ASSIST_MODEL_ID: "$ASSIST_MODEL_ID"
                SUMMARIZER_MODEL_ID: "$SUMMARIZER_MODEL_ID"
                TPU_CHIPS: "16"
                TPU_HEADS: "2"
        rayClusterConfig:
          headGroupSpec:
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                - name: ray-head
                  image: $VLLM_IMAGE
                  resources:
                    limits:
                      cpu: "2"
                      memory: 8G
                    requests:
                      cpu: "2"
                      memory: 8G
                  ports:
                  - containerPort: 6379
                    name: gcs-server
                  - containerPort: 8265
                    name: dashboard
                  - containerPort: 10001
                    name: client
                  - containerPort: 8000
                    name: serve
                  env:
                    - name: HUGGING_FACE_HUB_TOKEN
                      valueFrom:
                        secretKeyRef:
                          name: hf-secret
                          key: hf_api_token
                    - name: VLLM_XLA_CACHE_PATH
                      value: "/data"
                  volumeMounts:
                  - name: gcs-fuse-csi-ephemeral
                    mountPath: /data
                  - name: dshm
                    mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
          workerGroupSpecs:
          - replicas: 2
            minReplicas: 1
            maxReplicas: 2
            numOfHosts: 1
            groupName: tpu-group
            rayStartParams: {}
            template:
              metadata:
                annotations:
                  gke-gcsfuse/volumes: "true"
                  gke-gcsfuse/cpu-limit: "0"
                  gke-gcsfuse/memory-limit: "0"
                  gke-gcsfuse/ephemeral-storage-limit: "0"
              spec:
                serviceAccountName: $KSA_NAME
                containers:
                - name: llm
                  image: $VLLM_IMAGE
                  env:
                    - name: HUGGING_FACE_HUB_TOKEN
                      valueFrom:
                        secretKeyRef:
                          name: hf-secret
                          key: hf_api_token
                    - name: VLLM_XLA_CACHE_PATH
                      value: "/data"
                  resources:
                    limits:
                      cpu: "100"
                      google.com/tpu: "8"
                      ephemeral-storage: 40G
                      memory: 200G
                    requests:
                      cpu: "100"
                      google.com/tpu: "8"
                      ephemeral-storage: 40G
                      memory: 200G
                  volumeMounts:
                  - name: gcs-fuse-csi-ephemeral
                    mountPath: /data
                  - name: dshm
                    mountPath: /dev/shm
                volumes:
                - name: gke-gcsfuse-cache
                  emptyDir:
                    medium: Memory
                - name: dshm
                  emptyDir:
                    medium: Memory
                - name: gcs-fuse-csi-ephemeral
                  csi:
                    driver: gcsfuse.csi.storage.gke.io
                    volumeAttributes:
                      bucketName: $GSBUCKET
                      mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
                nodeSelector:
                  cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
                  cloud.google.com/gke-tpu-topology: 2x4

   2. Aplique o manifesto:

      envsubst < model-composition/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
      

5. Aguarde até que o status do recurso RayService mude para Running:

   kubectl --namespace ${NAMESPACE} get rayservice/vllm-tpu
   

   O resultado será assim:

   NAME       SERVICE STATUS   NUM SERVE ENDPOINTS
   vllm-tpu   Running          2
   

   Nesta saída, o status RUNNING indica que o recurso do RayService está pronto.

6. Confirme se o GKE criou o Serviço para o aplicativo Ray Serve:

   kubectl --namespace ${NAMESPACE} get service/vllm-tpu-serve-svc
   

   O resultado será assim:

   NAME                 TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)    AGE
   vllm-tpu-serve-svc   ClusterIP   ###.###.###.###   <none>        8000/TCP   ###
   

7. Estabeleça sessões port-forwarding para o head do Ray:

   pkill -f "kubectl .* port-forward .* 8265:8265"
   pkill -f "kubectl .* port-forward .* 8000:8000"
   kubectl --namespace ${NAMESPACE} port-forward service/vllm-tpu-serve-svc 8265:8265 2>&1 >/dev/null &
   kubectl --namespace ${NAMESPACE} port-forward service/vllm-tpu-serve-svc 8000:8000 2>&1 >/dev/null &
   

8. Envie uma solicitação ao 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, também é possível criar e implantar sua própria imagem de TPU para ter um controle mais refinado sobre o conteúdo da imagem do Docker.

Observação: você precisa receber o papel roles/artifactregistry.admin para criar e gerenciar repositórios do Artifact Registry.

1. 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.dev
   

2. Clone o repositório vLLM:

   git clone https://github.com/vllm-project/vllm.git
   cd vllm
   

3. Crie a imagem:

   docker build -f ./docker/Dockerfile.tpu . -t vllm-tpu
   

4. Marque 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 TAG pelo nome da tag que você quer definir. Se você não especificar uma tag, o Docker vai aplicar a tag padrão "latest".

5. 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.

1. Exclua o recurso personalizado RayCluster:

   kubectl --namespace ${NAMESPACE} delete rayclusters vllm-tpu
   

2. Exclua o bucket do Cloud Storage:

   gcloud storage rm -r gs://${GSBUCKET}
   

3. Exclua o repositório do Artifact Registry:

   gcloud artifacts repositories delete vllm-tpu \
       --location=${COMPUTE_REGION}
   

4. Exclua o cluster:

   gcloud container clusters delete ${CLUSTER_NAME} \
       --location=LOCATION
   

   Substitua LOCATION por qualquer uma das seguintes variáveis de ambiente:

   • Para clusters do Autopilot, use COMPUTE_REGION.
   • Para clusters Standard, use COMPUTE_ZONE.

Excluir o projeto

Se você implantou o tutorial em um novo projeto do Google Cloud e não precisa mais dele, exclua-o seguindo estas etapas:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. 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 conferindo 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.