Publique um MDG com TPUs no GKE com o KubeRay

Autopilot Padrão

---

Este tutorial mostra como publicar um modelo de linguagem (conteúdo extenso) (MDI/CE) usando unidades de processamento tensor (TPUs) no Google Kubernetes Engine (GKE) com o suplemento do operador Ray e a estrutura de publicação vLLM.

Neste tutorial, pode publicar modelos de MDIs em TPUs v5e ou TPUs Trillium (v6e) da seguinte forma:

• Llama 3 8B instruct numa TPU v5e de host único.
• Mistral 7B instruct v0.3 numa TPU v5e de anfitrião único.
• Llama 3.1 70B numa TPU Trillium (v6e) de host único.

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

Este guia destina-se a clientes de IA generativa, utilizadores novos e existentes do GKE, engenheiros de ML, engenheiros de MLOps (DevOps) ou administradores de plataformas interessados em usar capacidades de orquestração de contentores do Kubernetes para publicar modelos usando o Ray, em TPUs com o vLLM.

Contexto

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

Serviço Kubernetes gerido do GKE

AGoogle Cloud oferece uma vasta gama de serviços, incluindo o GKE, que é adequado para implementar e gerir cargas de trabalho de IA/AA. O GKE é um serviço Kubernetes gerido que simplifica a implementação, o dimensionamento e a gestão de aplicações contentorizadas. O GKE fornece a infraestrutura necessária, incluindo recursos escaláveis, computação distribuída e redes eficientes, para processar as exigências computacionais dos MDIs.

Para saber mais sobre os principais conceitos do Kubernetes, consulte o artigo Comece a saber mais sobre o Kubernetes. Para saber mais sobre o GKE e como este ajuda a dimensionar, automatizar e gerir o Kubernetes, consulte a vista geral do GKE.

Operador de raio

O suplemento Ray Operator no GKE oferece uma plataforma de IA/AA ponto a ponto para a apresentação, a preparação e o ajuste preciso de cargas de trabalho de aprendizagem automática. Neste tutorial, vai usar o Ray Serve, uma framework no Ray, para publicar LLMs populares do Hugging Face.

TPUs

As TPUs são circuitos integrados específicos da aplicação (ASICs) desenvolvidos pela Google e usados para acelerar a aprendizagem automática e os modelos de IA criados com frameworks como o TensorFlow, o PyTorch e o JAX.

Este tutorial aborda a publicação de modelos de MDIs em nós de TPU v5e ou TPU Trillium (v6e) com topologias de TPU configuradas com base nos requisitos de cada modelo para publicar comandos com baixa latência.

vLLM

O vLLM é uma framework de publicação de GML de código aberto altamente otimizada que pode aumentar a taxa de transferência de publicação em TPUs, com funcionalidades como:

• Implementação do transformador otimizada com PagedAttention
• Processamento em lote contínuo para melhorar o débito geral da publicação
• Paralelismo de tensores e publicação distribuída em várias GPUs

Para saber mais, consulte a documentação do vLLM.

Objetivos

Este tutorial abrange os seguintes passos:

1. Crie um cluster do GKE com um node pool de TPUs.
2. Implemente um recurso personalizado RayCluster com uma fatia de TPU de anfitrião único. O GKE implementa o recurso personalizado RayCluster como pods do Kubernetes.
3. Publicar um MDI/CE.
4. Interagir com os modelos.

Opcionalmente, pode configurar os seguintes recursos de publicação de modelos e técnicas suportadas pela framework Ray Serve:

• Implemente um recurso personalizado RayService.
• Componha vários modelos com a composição de modelos.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

• Ative a API Google Kubernetes Engine.
Ative a API Google Kubernetes Engine
• Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.
  Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

• Crie uma conta Hugging Face, se ainda não tiver uma.
• Certifique-se de que tem um token do Hugging Face.
• Certifique-se de que tem acesso ao modelo do Hugging Face que quer usar. Normalmente, obtém este acesso ao assinar um contrato e solicitar acesso ao proprietário do modelo na página do modelo do Hugging Face.
• Certifique-se de que tem as seguintes funções de IAM:
  • roles/container.admin
  • roles/iam.serviceAccountAdmin
  • roles/container.clusterAdmin
  • roles/artifactregistry.writer

Prepare o seu ambiente

1. Verifique se tem quota suficiente no seu Google Cloud projeto para uma TPU v5e de host único ou uma TPU Trillium (v6e) de host único. Para gerir a sua quota, consulte o artigo Quotas de TPU.

2. Na Google Cloud consola, inicie uma instância do Cloud Shell:
   Abrir Cloud Shell

3. Clone o repositório de exemplo:

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

4. Navegue para o diretório de trabalho:

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

5. Defina as variáveis de ambiente predefinidas 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 o seguinte:

   • HUGGING_FACE_TOKEN: o seu token de acesso do Hugging Face.
   • REGION: a região onde tem quota de TPUs. Certifique-se de que a versão da TPU que quer usar está disponível nesta região. Para saber mais, consulte o artigo Disponibilidade de TPUs no GKE.
   • ZONE: a zona com quota de TPUs disponível.
   • VLLM_IMAGE: a imagem da TPU vLLM. Pode usar a imagem docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1pública ou criar a 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 o seguinte:

   • HUGGING_FACE_TOKEN: o seu token de acesso do Hugging Face.
   • REGION: a região onde tem quota de TPUs. Certifique-se de que a versão da TPU que quer usar está disponível nesta região. Para saber mais, consulte o artigo Disponibilidade de TPUs no GKE.
   • ZONE: a zona com quota de TPUs disponível.
   • VLLM_IMAGE: a imagem da TPU vLLM. Pode usar a imagem docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1pública ou criar a 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 o seguinte:

   • HUGGING_FACE_TOKEN: o seu token de acesso do Hugging Face.
   • REGION: a região onde tem quota de TPUs. Certifique-se de que a versão da TPU que quer usar está disponível nesta região. Para saber mais, consulte o artigo Disponibilidade de TPUs no GKE.
   • ZONE: a zona com quota de TPUs disponível.
   • VLLM_IMAGE: a imagem da TPU vLLM. Pode usar a imagem docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1pública ou criar a sua própria imagem de TPU.

6. Puxe a imagem do contentor vLLM:

   sudo usermod -aG docker ${USER}
   newgrp docker
   docker pull ${VLLM_IMAGE}
   

Crie um cluster

Pode publicar um MDG em TPUs com o Ray num cluster do GKE Autopilot ou Standard usando o suplemento do operador do Ray.

Práticas recomendadas:

Use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.

Use o Cloud Shell para criar um cluster do Autopilot ou Standard:

Piloto automático

1. Crie um cluster do GKE Autopilot com o suplemento Ray Operator ativado:

   gcloud container clusters create-auto ${CLUSTER_NAME}  \
       --enable-ray-operator \
       --release-channel=rapid \
       --location=${COMPUTE_REGION}
   

Standard

1. Crie um cluster padrão com o suplemento do operador 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 node pool de fatia 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 node pool 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=1
   

   O GKE cria um node pool de 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 node pool de TPU v6e com um tipo de máquina ct6e-standard-8t.

Configure o kubectl para comunicar com o seu cluster

Para configurar o kubectl para comunicar com o cluster, execute o seguinte comando:

Piloto automático

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${COMPUTE_REGION}

Standard

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${COMPUTE_ZONE}

Crie um segredo do Kubernetes para as credenciais do Hugging Face

Para criar um segredo 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 -

Crie um contentor do Cloud Storage

Para acelerar o tempo de arranque da implementação de vLLM e minimizar o espaço em disco necessário por nó, use o controlador CSI FUSE do Cloud Storage para montar o modelo transferido e a cache de compilação nos nós do Ray.

No Cloud Shell, execute o seguinte comando:

gcloud storage buckets create gs://${GSBUCKET} \
    --uniform-bucket-level-access

Este comando cria um contentor do Cloud Storage para armazenar os ficheiros do modelo que transfere do Hugging Face.

Configure uma conta de serviço do Kubernetes para aceder ao contentor

1. Crie a ServiceAccount do Kubernetes:

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

2. Conceda à conta de serviço do Kubernetes acesso de leitura/escrita ao contentor 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 GML:

   1. Um contentor do Cloud Storage para armazenar o modelo transferido e a cache de compilação. Um controlador CSI FUSE do Cloud Storage lê o conteúdo do contentor.
   2. Volumes com o armazenamento em cache de ficheiros ativado e a funcionalidade de transferência paralela do Cloud Storage FUSE.
   Prática recomendada:

   Use uma cache de ficheiros suportada por tmpfs ou Hyperdisk / Persistent Disk consoante o tamanho esperado dos conteúdos do modelo, por exemplo, ficheiros de ponderação. Neste tutorial, usa a cache de ficheiros do FUSE do Cloud Storage suportada pela RAM.

Implemente um recurso personalizado RayCluster

Implemente um recurso personalizado RayCluster, que normalmente consiste num pod do sistema e em vários pods de trabalho.

Llama-3-8B-Instruct

Crie o recurso personalizado RayCluster para implementar o modelo Llama 3 8B otimizado para instruções concluindo os seguintes passos:

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 um host único de TPU v5e numa topologia 2x4.

Mistral-7B

Crie o recurso personalizado RayCluster para implementar o modelo Mistral-7B concluindo os seguintes passos:

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 um host único de TPU v5e numa topologia 2x4.

Llama 3.1 70B

Crie o recurso personalizado RayCluster para implementar o modelo Llama 3.1 70B concluindo os seguintes passos:

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 um TPU v6e de anfitrião único numa topologia 2x4.

Ligue-se ao recurso personalizado RayCluster

Depois de criar o recurso personalizado RayCluster, pode estabelecer ligação ao recurso RayCluster e começar a publicar o modelo.

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

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

   O resultado é semelhante ao seguinte:

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

2. Estabeleça port-forwarding sessões para o auricular 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. Confirme se o cliente do Ray consegue estabelecer ligação ao recurso personalizado do RayCluster remoto:

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

   O resultado é semelhante ao seguinte:

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

Implemente o modelo com o vLLM

Para implementar um modelo específico com o vLLM, siga estas instruções.

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

Veja o painel de controlo do Ray

Pode ver a implementação do Ray Serve e os registos relevantes no painel de controlo do Ray.

1. Clique no botão Pré-visualização Web, que se encontra na parte superior direita da barra de tarefas do Cloud Shell.
2. Clique em Alterar porta e defina o número da porta para 8265.
3. Clique em Alterar e pré-visualizar.
4. No painel de controlo do Ray, clique no separador Serve.

Depois de a implementação da publicação ter o estado HEALTHY, o modelo está pronto para começar a processar entradas.

Publique o modelo

Este guia realça os modelos que suportam a 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

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

Expanda a secção seguinte para ver um exemplo do resultado.

{"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 ponto final 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}'
   

Expanda a secção seguinte para ver um exemplo do resultado.

{"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 ponto final 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}'
   

Expanda a secção seguinte para ver um exemplo do resultado.

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

Êxito: implementou um MDG com um recurso personalizado RayCluster numa fatia de TPU de anfitrião único.

Configuração adicional

Opcionalmente, pode configurar os seguintes recursos de publicação de modelos e técnicas suportadas pela framework Ray Serve:

• Implemente um recurso personalizado do RayService. Nos passos anteriores deste tutorial, usa o RayCluster em vez do RayService. Recomendamos o RayService para ambientes de produção.
• Componha vários modelos com a composição de modelos. Configure a multiplexagem de modelos e a composição de modelos suportadas pela framework Ray Serve. A composição de modelos permite encadear entradas e saídas em vários MDIs e dimensionar os seus modelos como uma única aplicação.
• Crie e implemente a sua própria imagem de TPU. Recomendamos esta opção se precisar de um controlo mais detalhado sobre o conteúdo da sua imagem do Docker.

Implemente um RayService

Pode implementar os mesmos modelos deste tutorial usando um recurso personalizado RayService.

1. Elimine o recurso personalizado RayCluster que criou neste tutorial:

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

2. Crie o recurso personalizado RayService para implementar 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 um TPU v5e de anfitrião único numa 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 um TPU v5e de anfitrião único numa 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 RayCluster onde a aplicação Ray Serve é implementada e o recurso personalizado RayService subsequente é criado.

3. Verifique o estado do recurso RayService:

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

   Aguarde que o estado 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}})
   

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

5. Estabeleça port-forwardingsessões com o auricular Ray para ver o painel de controlo do Ray:

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

6. Veja o painel de controlo do Ray.

7. Publique o modelo.

8. Limpe o recurso RayService:

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

Componha vários modelos com a composição de modelos

A composição de modelos é uma técnica para compor vários modelos numa única aplicação.

Nesta secção, vai usar um cluster do GKE para compor dois modelos, o Llama 3 8B IT e o Gemma 7B IT, numa única aplicação:

• O primeiro modelo é o modelo de assistente que responde a perguntas feitas no comando.
• O segundo modelo é o modelo de resumo. A saída do modelo de assistente é encadeada na entrada do modelo de resumo. O resultado final é a versão resumida da resposta do modelo do assistente.

1. Aceda ao modelo Gemma concluindo os seguintes passos:

   1. Inicie sessão na plataforma Kaggle, assine o contrato de consentimento da licença e obtenha um token da API Kaggle. Neste tutorial, vai usar um segredo do Kubernetes para as credenciais do Kaggle.
   2. Aceda à página de consentimento do modelo em Kaggle.com.
   3. Inicie sessão no Kaggle, se ainda não o tiver feito.
   4. Clique em Pedir acesso.
   5. Na secção Escolher conta para consentimento, selecione Validar através da conta do Kaggle para usar a sua conta do Kaggle para conceder consentimento.
   6. Aceite os Termos de Utilização do modelo.

2. Configure o seu ambiente:

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

3. Para clusters padrão, crie um conjunto de nós de fatia de TPU de host único adicional:

   gcloud container node-pools create tpu-2 \
     --location=${COMPUTE_ZONE} \
     --cluster=${CLUSTER_NAME} \
     --machine-type=MACHINE_TYPE \
     --num-nodes=1
   

   Substitua MACHINE_TYPE por qualquer um dos seguintes tipos de máquinas:

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

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

4. Implemente o recurso RayService com base na versão da TPU que 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 que o estado do recurso RayService mude para Running:

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

   O resultado é semelhante ao seguinte:

   NAME       SERVICE STATUS   NUM SERVE ENDPOINTS
   vllm-tpu   Running          2
   

   Neste resultado, o estado RUNNING indica que o recurso RayService está pronto.

6. Confirme que o GKE criou o serviço para a aplicação Ray Serve:

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

   O resultado é semelhante ao seguinte:

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

7. Estabeleça port-forwarding sessões para o auricular 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 um pedido 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 é semelhante ao seguinte:

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

Crie e implemente a imagem da TPU

Este tutorial usa imagens de TPU alojadas a partir do vLLM. O vLLM fornece uma imagem Dockerfile.tpu que cria o vLLM com base na imagem PyTorch XLA necessária que inclui dependências da TPU. No entanto, também pode criar e implementar a sua própria imagem de TPU para um controlo mais detalhado sobre o conteúdo da sua imagem do Docker.

Nota: tem de lhe ser concedida a função roles/artifactregistry.admin para criar e gerir repositórios do Artifact Registry.

1. Crie um repositório Docker para armazenar as imagens de contentores para este 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. Etiquete 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 etiqueta que quer definir. Se não especificar uma etiqueta, o Docker aplica a etiqueta mais recente predefinida.

5. Envie a imagem para o Artifact Registry:

   docker push ${VLLM_IMAGE}
   

Elimine os recursos individuais

Se usou um projeto existente e não o quer eliminar, pode eliminar os recursos individuais.

1. Elimine o recurso personalizado RayCluster:

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

2. Elimine o contentor do Cloud Storage:

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

3. Elimine o repositório do Artifact Registry:

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

4. Elimine 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 padrão, use COMPUTE_ZONE.

Elimine o projeto

Se implementou o tutorial num novo Google Cloud projeto e já não precisa do projeto, elimine-o concluindo os seguintes passos:

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

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.

O que se segue?

• Descubra como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma do GKE.
• Saiba como usar o Ray Serve no GKE, consultando o código de exemplo no GitHub.
• Saiba como recolher e ver métricas para clusters do Ray executados no GKE, concluindo os passos em Recolha e veja registos e métricas para clusters do Ray no GKE.