Disponibilizar LLMs escalonáveis no GKE com o TorchServe

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

prepare o ambiente

Clone o repositório de exemplo e abra o diretório do tutorial:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving

Crie o cluster

Execute este comando:

gcloud container clusters create-auto ml-cluster \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=CLUSTER_VERSION \
    --location=us-central1

Substitua:

• RELEASE_CHANNEL: o canal de lançamento do cluster. Precisa ser rapid, regular ou stable. Escolha um canal que tenha a versão 1.28.3-gke.1203000 ou posterior do GKE para usar GPUs L4. Para conferir as versões disponíveis em um canal específico, consulte Visualizar as versões padrão e disponíveis para canais de lançamento.
• CLUSTER_VERSION: a versão do GKE a ser usada. Precisa ser 1.28.3-gke.1203000 ou mais recente.

A operação leva alguns minutos para ser concluída.

Crie um repositório do Artifact Registry

1. Crie um novo repositório padrão do Artifact Registry com o formato Docker na mesma região do cluster:

   gcloud artifacts repositories create models \
       --repository-format=docker \
       --location=us-central1 \
       --description="Repo for T5 serving image"
   

2. Verifique o nome do repositório:

   gcloud artifacts repositories describe models \
       --location=us-central1
   

   O resultado será assim:

   Encryption: Google-managed key
   Repository Size: 0.000MB
   createTime: '2023-06-14T15:48:35.267196Z'
   description: Repo for T5 serving image
   format: DOCKER
   mode: STANDARD_REPOSITORY
   name: projects/PROJECT_ID/locations/us-central1/repositories/models
   updateTime: '2023-06-14T15:48:35.267196Z'
   

Empacotar o modelo

Nesta seção, você empacota o modelo e o framework de exibição em uma única imagem de contêiner usando o Cloud Build e envia a imagem resultante para o repositório do Artifact Registry.

1. Revise o Dockerfile para a imagem do contêiner:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ARG BASE_IMAGE=pytorch/torchserve:0.12.0-cpu
   
   FROM alpine/git
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_REPO=https://huggingface.co/${MODEL_NAME}
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   RUN git clone "${MODEL_REPO}" /model
   
   FROM ${BASE_IMAGE}
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_VERSION=1.0
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   COPY --from=0 /model/. /home/model-server/
   COPY handler.py \
        model.py \
        requirements.txt \
        setup_config.json /home/model-server/
   
   RUN  torch-model-archiver \
        --model-name="${MODEL_NAME}" \
        --version="${MODEL_VERSION}" \
        --model-file="model.py" \
        --serialized-file="pytorch_model.bin" \
        --handler="handler.py" \
        --extra-files="config.json,spiece.model,tokenizer.json,setup_config.json" \
        --runtime="python" \
        --export-path="model-store" \
        --requirements-file="requirements.txt"
   
   FROM ${BASE_IMAGE}
   
   ENV PATH /home/model-server/.local/bin:$PATH
   ENV TS_CONFIG_FILE /home/model-server/config.properties
   # CPU inference will throw a warning cuda warning (not error)
   # Could not load dynamic library 'libnvinfer_plugin.so.7'
   # This is expected behaviour. see: https://stackoverflow.com/a/61137388
   ENV TF_CPP_MIN_LOG_LEVEL 2
   
   COPY --from=1 /home/model-server/model-store/ /home/model-server/model-store
   COPY config.properties /home/model-server/
   

   Esse Dockerfile define o seguinte processo de compilação em várias etapas:

   1. Faça o download dos artefatos do modelo no repositório de rosto abraçado.
   2. Empacote o modelo usando a ferramenta Arquivo de exibição PyTorch. Isso cria um arquivo de modelo (.mar) que o servidor de inferência usa para carregar o modelo.
   3. Crie a imagem final com o PyTorch Serve.

2. Crie e envie a imagem usando o Cloud Build:

   gcloud builds submit model/ \
       --region=us-central1 \
       --config=model/cloudbuild.yaml \
       --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0
   

   O processo de implantação leva vários minutos para ser concluído. Se você usar um tamanho de modelo maior que t5-small, o processo de compilação poderá levar bastante mais tempo.

3. Verifique se a imagem está no repositório:

   gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models
   

   Substitua PROJECT_ID pelo ID do projeto Google Cloud.

   O resultado será assim:

   IMAGE                                                     DIGEST         CREATE_TIME          UPDATE_TIME
   us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small     sha256:0cd...  2023-06-14T12:06:38  2023-06-14T12:06:38
   

Implantar o modelo empacotado no GKE

Para implantar a imagem, este tutorial usa implantações do Kubernetes. Uma implantação é um objeto da API do Kubernetes que permite executar várias réplicas de pods distribuídos entre os nós de um cluster.

Modifique o manifesto do Kubernetes no repositório de exemplo para corresponder ao seu ambiente.

1. Revise o manifesto da carga de trabalho de inferência:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     replicas: 1
     selector:
       matchLabels:
         model: t5
         version: v1.0
         machine: gpu
     template:
       metadata:
         labels:
           model: t5
           version: v1.0
           machine: gpu
       spec:
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
         securityContext:
           fsGroup: 1000
           runAsUser: 1000
           runAsGroup: 1000
         containers:
           - name: inference
             image: us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small:1.0-gpu
             imagePullPolicy: IfNotPresent
             args: ["torchserve", "--start", "--foreground"]
             resources:
               limits:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
               requests:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
             ports:
               - containerPort: 8080
                 name: http
               - containerPort: 8081
                 name: management
               - containerPort: 8082
                 name: metrics
             readinessProbe:
               httpGet:
                 path: /ping
                 port: http
               initialDelaySeconds: 120
               failureThreshold: 10
             livenessProbe:
               httpGet:
                 path: /models/t5-small
                 port: management
               initialDelaySeconds: 150
               periodSeconds: 5
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     type: ClusterIP
     selector:
       model: t5
       version: v1.0
       machine: gpu
     ports:
       - port: 8080
         name: http
         targetPort: http
       - port: 8081
         name: management
         targetPort: management
       - port: 8082
         name: metrics
         targetPort: metrics
   

2. Substitua PROJECT_ID pelo ID do projeto Google Cloud:

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"
   

   Isso garante que o caminho da imagem do contêiner na especificação da implantação corresponda ao caminho para a imagem do modelo T5 no Artifact Registry.

3. Crie os recursos do Kubernetes:

   kubectl create -f kubernetes/serving-gpu.yaml
   

Para verificar se o modelo foi implantado, faça o seguinte:

1. Confira o status da implantação e do serviço:

   kubectl get -f kubernetes/serving-gpu.yaml
   

   Aguarde até que a resposta mostre pods prontos, como no exemplo a seguir. Dependendo do tamanho da imagem, a primeira extração pode levar vários minutos.

   NAME                            READY   UP-TO-DATE    AVAILABLE   AGE
   deployment.apps/t5-inference    1/1     1             0           66s
   
   NAME                    TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)                       AGE
   service/t5-inference    ClusterIP   10.48.131.86    <none>        8080/TCP,8081/TCP,8082/TCP    66s
   

2. Abra uma porta local para o serviço t5-inference:

   kubectl port-forward svc/t5-inference 8080
   

3. Abra uma nova janela do terminal e envie uma solicitação de teste para o serviço:

   curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"
   

   Se a solicitação de teste falhar e a conexão do pod for encerrada, verifique os registros:

   kubectl logs deployments/t5-inference
   

   Se a saída for semelhante a esta, o TorchServe não conseguiu instalar algumas dependências de modelo:

   org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small
   

   Para resolver esse problema, reinicie a implantação:

   kubectl rollout restart deployment t5-inference
   

   Esse controlador cria um novo pod. Repita as etapas anteriores para abrir uma porta no novo pod.

Acesse o modelo implantado usando o aplicativo da Web

Para acessar o modelo implantado com o aplicativo da Web do Fast Dash, siga estas etapas:

1. Crie e envie o aplicativo da Web da Fast Dash como uma imagem de contêiner no Artifact Registry:

   gcloud builds submit client-app/ \
       --region=us-central1 \
       --config=client-app/cloudbuild.yaml
   

2. Abra kubernetes/application.yaml em um editor de texto e substitua PROJECT_ID no campo image: pelo ID do projeto. Como alternativa, execute o seguinte comando:

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"
   

3. Crie os recursos do Kubernetes:

   kubectl create -f kubernetes/application.yaml
   

   A implantação e o serviço podem levar algum tempo para serem totalmente provisionados.

4. Para verificar o status, execute o comando a seguir.

   kubectl get -f kubernetes/application.yaml
   

   Aguarde até que a saída mostre pods prontos, como no exemplo a seguir:

   NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/fastdash   1/1     1            0           1m
   
   NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   service/fastdash   NodePort   203.0.113.12    <none>        8050/TCP         1m
   

5. O aplicativo da Web agora está em execução, embora não esteja exposto em um endereço IP externo. Para acessar o aplicativo da Web, abra uma porta local:

   kubectl port-forward service/fastdash 8050
   

6. Em um navegador, abra a interface da Web:

   • Se você estiver usando um shell local, abra um navegador e acesse http://127.0.0.1:8050.
   • Se você estiver usando o Cloud Shell, clique em Visualização na Web e, em seguida, em Alterar porta. Especifique a porta 8050.

7. Para enviar uma solicitação ao modelo T5, especifique os valores nos campos TEXT, FROM Lang e TO melhor na interface da Web. e clique em Enviar. Para ver uma lista de idiomas disponíveis, consulte a documentação T5.

Ativar o escalonamento automático do modelo

Nesta seção, mostramos como ativar o escalonamento automático para o modelo com base em métricas do Google Cloud Managed Service para Prometheus fazendo o seguinte:

1. Instalar o adaptador de métricas personalizadas do Stackdriver
2. Aplicar configurações de PodMonitoring e HorizontalPodAutoscaling

O Google Cloud Managed Service para Prometheus é ativado por padrão nos clusters do Autopilot que executam a versão 1.25 e mais recentes.

Instalar o adaptador de métricas personalizadas do Stackdriver

Esse adaptador permite que o cluster use métricas do Prometheus para tomar decisões de escalonamento automático do Kubernetes.

1. Implante o adaptador:

   kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
   

2. Crie uma conta de serviço do IAM para o adaptador usar:

   gcloud iam service-accounts create monitoring-viewer
   

3. Conceda à conta de serviço do IAM o papel monitoring.viewer no projeto e o papel iam.workloadIdentityUser:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
       --role roles/monitoring.viewer
   gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
   

   Substitua PROJECT_ID pelo ID do projeto Google Cloud.

4. Anote a ServiceAccount do Kubernetes do adaptador para permitir que ele represente a conta de serviço do IAM:

   kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
       --namespace custom-metrics \
       iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com
   

5. Reinicie a implantação do adaptador para propagar as alterações:

   kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
       --namespace=custom-metrics
   

Aplicar configurações de PodMonitoring e HorizontalPodAutoscaling

O PodMonitoring é um recurso personalizado do Google Cloud Managed Service para Prometheus que permite a ingestão de métricas e a extração de destino em um namespace específico.

1. Implante o recurso do PodMonitoring no mesmo namespace que a Implantação do TorchServe:

   kubectl apply -f kubernetes/pod-monitoring.yaml
   

2. Consulte o manifesto HorizontalPodAutoscaler:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: t5-inference
   spec:
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: t5-inference
     minReplicas: 1
     maxReplicas: 5
     metrics:
     - type: Pods
       pods:
         metric:
           name: prometheus.googleapis.com|ts_queue_latency_microseconds|counter
         target:
           type: AverageValue
           averageValue: "30000"
   

   O HorizontalPodAutoscaler escalona a quantidade de pods do modelo T5 com base na duração cumulativa da fila de solicitações. O escalonamento automático é baseado na métrica ts_queue_latency_microseconds, que mostra a duração cumulativa da fila em microssegundos.

3. Crie o HorizontalPodAutoscaler:

   kubectl apply -f kubernetes/hpa.yaml
   

Verificar o escalonamento automático usando um gerador de carga

Para testar a configuração de escalonamento automático, gere carga para o aplicativo de exibição. Neste tutorial, um gerador de carga do Locust é usado para enviar solicitações ao endpoint de previsão do modelo.

1. Crie o gerador de carga:

   kubectl apply -f kubernetes/loadgenerator.yaml
   

   Aguarde até que os pods do gerador de carga fiquem prontos.

2. Exponha a interface da Web do gerador de carga localmente:

   kubectl port-forward svc/loadgenerator 8080
   

   Se uma mensagem de erro for exibida, tente novamente quando o pod estiver em execução.

3. Em um navegador, abra a interface da Web do gerador de carga.

   • Se você estiver usando um shell local, abra um navegador e acesse http://127.0.0.1:8080.
   • Se você estiver usando o Cloud Shell, clique em Visualização na Web e, em seguida, em Alterar porta. Digite a porta 8080.

4. Clique na guia Gráficos para observar o desempenho ao longo do tempo.

5. Abra uma nova janela do terminal e observe a contagem de réplicas dos seus escalonadores automáticos de pods horizontais:

   kubectl get hpa -w
   

   O número de réplicas aumenta conforme a carga aumenta. O escalonamento pode levar aproximadamente dez minutos. À medida que novas réplicas são iniciadas, o número de solicitações bem-sucedidas no gráfico do Locust aumenta.

   NAME           REFERENCE                 TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
   t5-inference   Deployment/t5-inference   71352001470m/7M   1         5        1           2m11s
   

Recomendações

• Crie o modelo com a mesma versão da imagem base do Docker que você usará para disponibilização.
• Se o modelo tiver dependências de pacote especiais ou se o tamanho das dependências for grande, crie uma versão personalizada da imagem base do Docker.
• Observe a versão em árvore dos pacotes de dependência do modelo. Verifique se as dependências de pacote são compatíveis com as versões umas das outras. Por exemplo, o Panda versão 2.0.3 oferece suporte ao NumPy versão 1.20.3 e posterior.
• Execute modelos com uso intensivo de GPU em nós de GPU e modelos com uso intensivo de CPU na CPU. Isso pode melhorar a estabilidade da disponibilização do modelo e garante o consumo eficiente dos recursos do nó.

Observar o desempenho do modelo

Para observar a performance do modelo, use a integração do painel do TorchServe no Cloud Monitoring. Com esse painel, você pode conferir métricas de desempenho críticas, como taxa de transferência de token, latência de solicitação e taxas de erro.

Para usar o painel do TorchServe, ative o Google Cloud Managed Service para Prometheus, que coleta as métricas do TorchServe, no cluster do GKE. O TorchServe expõe métricas no formato do Prometheus por padrão. Não é necessário instalar um exportador adicional.