Exibir um modelo com uma única GPU no GKE

Autopilot Padrão

---

Neste tutorial, mostramos como exibir um modelo simples com GPUs no modo Google Kubernetes Engine (GKE). Neste tutorial, criamos um cluster do GKE que usa uma única GPU do Tensor Core L4 e prepara a infraestrutura do GKE para fazer inferências on-line. Este tutorial usa duas das estruturas mais usadas para disponibilização on-line:

• Servidor de inferência NVIDIA Triton
• TensorFlow Serving

Objetivos

Este tutorial é destinado a engenheiros de infraestrutura, engenheiros de MLOps, engenheiros de DevOps ou administradores de cluster que querem hospedar um modelo de machine learning (ML) pré-treinado em um cluster do GKE.

Este tutorial abrange as etapas a seguir:

1. Crie um cluster do GKE Autopilot ou Standard.
2. Configurar o bucket do Cloud Storage, onde fica o modelo pré-treinado.
3. Implante o framework de inferência on-line selecionado.
4. Faça uma solicitação de teste para o serviço implantado.

Observação: este tutorial é uma base para a disponibilização on-line. Outros elementos, como balanceadores de carga, precisam ser considerados, dependendo do caso de uso.

Custos

Neste tutorial, usamos o seguinte componente faturável do Google Cloud:

• GKE
• Cloud Storage
• Aceleradores com GPU L4
• Tráfego de saída

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Limpeza.

Antes de começar

Crie o projeto

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, clique em Criar projeto para começar a criar um novo projeto do Google Cloud.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. Ative a API GKE.

   Ative a API

5. No console do Google Cloud, na página do seletor de projetos, clique em Criar projeto para começar a criar um novo projeto do Google Cloud.

   Acessar o seletor de projetos

6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

7. Ative a API GKE.

   Ative a API

Definir padrões para a Google Cloud CLI

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

2. Faça o download do código-fonte para este app de amostra:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/ai-ml/gke-online-serving-single-gpu
   

3. Defina as variáveis de ambiente padrão:

   gcloud config set project PROJECT_ID
   gcloud config set compute/region COMPUTE_REGION
   

   Substitua os seguintes valores:

   • PROJECT_ID: é o ID do projeto do Google Cloud.
   • COMPUTE_REGION: a região do Compute Engine compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.

4. No Cloud Shell, crie as seguintes variáveis de ambiente:

   export PROJECT_ID=$(gcloud config get project)
   export REGION=$(gcloud config get compute/region)
   export K8S_SA_NAME=gpu-k8s-sa
   export GSBUCKET=$PROJECT_ID-gke-bucket
   export MODEL_NAME=mnist
   export CLUSTER_NAME=online-serving-cluster
   

Crie um cluster do GKE

É possível exibir modelos em uma única GPU em um cluster do GKE Autopilot ou Standard. Recomendamos que você use um cluster do Autopilot para ter uma experiência totalmente gerenciada do Kubernetes. No GKE Autopilot, os recursos são escalonados automaticamente com base nas solicitações do modelo.

Para escolher o modo de operação do GKE mais adequado para suas cargas de trabalho, consulte Escolher um modo de operação do GKE.

Autopilot

Execute o seguinte comando para criar um cluster do GKE Autopilot:

  gcloud container clusters create-auto ${CLUSTER_NAME} \
      --region=${REGION} \
      --project=${PROJECT_ID} \
      --release-channel=rapid

Observação: esta etapa pode levar até cinco minutos para ser concluída.

O GKE cria um cluster do Autopilot com nós de CPU e GPU conforme solicitado pelas cargas de trabalho implantadas.

Standard

1. Execute o seguinte comando para criar um cluster do GKE Standard:

     gcloud container clusters create ${CLUSTER_NAME} \
       --project=${PROJECT_ID}  \
       --region=${REGION}  \
       --workload-pool=${PROJECT_ID}.svc.id.goog \
       --addons GcsFuseCsiDriver \
       --release-channel=rapid \
       --num-nodes=1
   

   A criação do cluster pode levar vários minutos.

2. Execute o seguinte comando para criar o pool de nós:

     gcloud container node-pools create gpupool \
       --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
       --project=${PROJECT_ID} \
       --location=${REGION} \
       --node-locations=${REGION}-a \
       --cluster=${CLUSTER_NAME} \
       --machine-type=g2-standard-8 \
       --num-nodes=1
   

   O GKE cria um único pool de nós contendo uma GPU L4 para cada nó.

crie um bucket do Cloud Storage

Crie um bucket do Cloud Storage para armazenar o modelo pré-treinado que será exibido.

No Cloud Shell, execute o seguinte:

gcloud storage buckets create gs://$GSBUCKET

Configurar o cluster para acessar o bucket usando a federação de identidade da carga de trabalho do GKE

Para permitir que o cluster acesse o bucket do Cloud Storage, faça o seguinte:

1. Crie uma conta de serviço do Google Cloud.
2. Crie uma conta de serviço do Kubernetes no cluster.
3. Vincular a conta de serviço do Kubernetes à conta de serviço do Google Cloud.

Criar uma conta de serviço do Google Cloud.

1. No Console do Google Cloud, acesse a página Criar conta de serviço.

   Acesse "Criar conta de serviço"

2. No campo ID da conta de serviço, digite gke-ai-sa.

3. Clique em Criar e continuar.

4. Na lista Papel, selecione o papel Cloud Storage > Serviço de coletor do Insights.

5. Clique em Adicionar outro papel.

6. Na lista Selecionar um papel, selecione o papel Cloud Storage > Administrador de objetos do Storage.

7. Clique em Continuar e depois em Concluído.

Criar uma conta de serviço do Kubernetes no cluster

No Cloud Shell, faça o seguinte:

1. Crie um namespace do Kubernetes:

   kubectl create namespace gke-ai-namespace
   

2. Crie uma conta de serviço do Kubernetes no namespace:

   kubectl create serviceaccount gpu-k8s-sa --namespace=gke-ai-namespace
   

Vincular a conta de serviço do Kubernetes à conta de serviço do Google Cloud

No Cloud Shell, execute os seguintes comandos:

1. Adicione uma vinculação do IAM à conta de serviço do Google Cloud:

   gcloud iam service-accounts add-iam-policy-binding gke-ai-sa@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[gke-ai-namespace/gpu-k8s-sa]"
   

   A sinalização --member fornece a identidade completa da conta de serviço do Kubernetes no Google Cloud.

2. Anote a conta de serviço do Kubernetes:

   kubectl annotate serviceaccount gpu-k8s-sa \
       --namespace gke-ai-namespace \
       iam.gke.io/gcp-service-account=gke-ai-sa@PROJECT_ID.iam.gserviceaccount.com
   

Implantar o servidor de inferência on-line

Cada framework de inferência on-line espera encontrar o modelo de ML pré-treinado em um formato específico. A seção a seguir mostra como implantar o servidor de inferência dependendo do framework que você quer usar:

Triton

1. No Cloud Shell, copie o modelo de ML pré-treinado para o bucket do Cloud Storage:

   gsutil cp -r src/triton-model-repository gs://$GSBUCKET
   

2. Implante o framework no Kubernetes:

   envsubst < src/gke-config/deployment-triton.yaml | kubectl --namespace=gke-ai-namespace apply -f -
   

3. Valide se o GKE implantou o framework:

   kubectl get deployments --namespace=gke-ai-namespace
   

   Quando o framework estiver pronto, a saída será semelhante a esta:

   NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
   triton-deployment    1/1     1            1           5m29s
   

4. Implantar os serviços para acessar a implantação

   kubectl apply --namespace=gke-ai-namespace -f src/gke-config/service-triton.yaml
   

5. Verifique se o IP externo está atribuído:

   kubectl get services --namespace=gke-ai-namespace
   

   O resultado será assim:

   NAME            TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                                        AGE
   kubernetes      ClusterIP      34.118.224.1     <none>          443/TCP                                        60m
   triton-server   LoadBalancer   34.118.227.176   35.239.54.228   8000:30866/TCP,8001:31035/TCP,8002:30516/TCP   5m14s
   

   Anote o endereço IP de triton-server na coluna EXTERNAL-IP.

6. Verifique se o serviço e a implantação estão funcionando corretamente:

   curl -v EXTERNAL_IP:8000/v2/health/ready
   

   O resultado será assim:

   ...
   < HTTP/1.1 200 OK
   < Content-Length: 0
   < Content-Type: text/plain
   ...
   

Exibição de TF

1. No Cloud Shell, copie o modelo de ML pré-treinado para o bucket do Cloud Storage:

   gsutil cp -r src/tfserve-model-repository gs://$GSBUCKET
   

2. Implante o framework no Kubernetes:

   envsubst < src/gke-config/deployment-tfserve.yaml | kubectl --namespace=gke-ai-namespace apply -f -
   

3. Valide se o GKE implantou o framework:

   kubectl get deployments --namespace=gke-ai-namespace
   

   Quando o framework estiver pronto, a saída será semelhante a esta:

   NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
   tfserve-deployment   1/1     1            1           5m29s
   

4. Implantar os serviços para acessar a implantação

   kubectl apply --namespace=gke-ai-namespace -f src/gke-config/service-tfserve.yaml
   

5. Verifique se o IP externo está atribuído:

   kubectl get services --namespace=gke-ai-namespace
   

   O resultado será assim:

   NAME            TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                                        AGE
   kubernetes      ClusterIP      34.118.224.1     <none>          443/TCP                                        60m
   tfserve-server  LoadBalancer   34.118.227.176   35.239.54.228   8500:30003/TCP,8000:32194/TCP                  5m14s
   

   Anote o endereço IP de tfserve-server na coluna EXTERNAL-IP.

6. Verifique se o serviço e a implantação estão funcionando corretamente:

   curl -v EXTERNAL_IP:8000/v1/models/mnist
   

   Substitua EXTERNAL_IP pelo endereço IP externo.

   O resultado será assim:

   ...
   < HTTP/1.1 200 OK
   < Content-Type: application/json
   < Date: Thu, 12 Oct 2023 19:01:19 GMT
   < Content-Length: 154
   <
   {
     "model_version_status": [
           {
           "version": "1",
           "state": "AVAILABLE",
           "status": {
             "error_code": "OK",
             "error_message": ""
           }
         }
       ]
   }
   

Disponibilizar o modelo

Triton

1. Criar um ambiente virtual do Python no Cloud Shell.

   python -m venv ./mnist_client
   source ./mnist_client/bin/activate
   

2. Instale os pacotes Python necessários.

   pip install -r src/client/triton-requirements.txt
   

3. Teste o servidor de inferência do Triton carregando uma imagem:

   cd src/client
   python triton_mnist_client.py -i EXTERNAL_IP -m mnist -p ./images/TEST_IMAGE.png
   

   Substitua:

   • EXTERNAL_IP: o endereço IP externo.
   • TEST_IMAGE: o nome do arquivo que corresponde à imagem que você quer testar. É possível usar as imagens armazenadas em src/client/images.

   Dependendo da imagem usada, a saída será semelhante a esta:

   Calling Triton HTTP Service      ->      Prediction result: 7
   

Observação: é possível criar clientes que executam inferência no servidor do Triton Inference. Para saber mais, consulte os exemplos e bibliotecas da NVIDIA.

Exibição de TF

1. Criar um ambiente virtual do Python no Cloud Shell.

   python -m venv ./mnist_client
   source ./mnist_client/bin/activate
   

2. Instale os pacotes Python necessários.

   pip install -r src/client/tfserve-requirements.txt
   

3. Testar o TensorFlow Serving com algumas imagens.

   cd src/client
   python tfserve_mnist_client.py -i EXTERNAL_IP -m mnist -p ./images/TEST_IMAGE.png
   

Substitua:

• EXTERNAL_IP: o endereço IP externo.
• TEST_IMAGE: um valor de 0 a 9. Use as imagens armazenadas no app src/client/images.

Dependendo da imagem usada, você terá uma saída semelhante a esta:

  Calling TensorFlow Serve HTTP Service    ->      Prediction result: 5

Observação: é possível criar clientes que executam inferência no servidor do TensorFlow. Para saber mais, consulte a API TensorFlow.

Sucesso: você implantou com sucesso um framework de veiculação on-line para um modelo de ML pré-treinado.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos criados neste guia, siga um destes procedimentos:

• Manter o cluster do GKE: exclua os recursos do Kubernetes no cluster e os recursos do Google Cloud.
• Manter o projeto do Google Cloud: exclua o cluster do GKE e os recursos do Google Cloud.
• Excluir o projeto

Excluir os recursos do Kubernetes no cluster e os recursos do Google Cloud

1. Exclua o namespace do Kubernetes e as cargas de trabalho implantadas:

Triton

kubectl -n gke-ai-namespace delete -f src/gke-config/service-triton.yaml
kubectl -n gke-ai-namespace delete -f src/gke-config/deployment-triton.yaml
kubectl delete namespace gke-ai-namespace

Exibição de TF

kubectl -n gke-ai-namespace delete -f src/gke-config/service-tfserve.yaml
kubectl -n gke-ai-namespace delete -f src/gke-config/deployment-tfserve.yaml
kubectl delete namespace gke-ai-namespace

1. Exclua o bucket do Cloud Storage:

   1. Acessar a página Buckets:

      Acessar buckets

   2. Marque a caixa de seleção de PROJECT_ID-gke-bucket.

   3. Clique em Excluir.

   4. Para confirmar a exclusão, digite DELETE e clique em Excluir.

2. Excluir a conta de serviço do Google Cloud:

   1. Acessar a página Contas de serviço

      Acesse as Contas de serviço

   2. Selecione o projeto.

   3. Marque a caixa de seleção de gke-gpu-sa@PROJECT_ID.iam.gserviceaccount.com.

   4. Clique em Excluir.

   5. Para confirmar a exclusão, clique em Excluir.

Excluir o cluster do GKE e os recursos do Google Cloud

1. Exclua o cluster do GKE:

   1. Acessar a página de clusters:

      Acessar Clusters

   2. Marque a caixa de seleção de online-serving-cluster.

   3. Clique em Excluir.

   4. Para confirmar a exclusão, digite online-serving-cluster e clique em Excluir.

2. Exclua o bucket do Cloud Storage:

   1. Acessar a página Buckets:

      Acessar buckets

   2. Marque a caixa de seleção de PROJECT_ID-gke-bucket.

   3. Clique em Excluir.

   4. Para confirmar a exclusão, digite DELETE e clique em Excluir.

3. Excluir a conta de serviço do Google Cloud:

   1. Acessar a página Contas de serviço

      Acesse as Contas de serviço

   2. Selecione o projeto.

   3. Marque a caixa de seleção de gke-gpu-sa@PROJECT_ID.iam.gserviceaccount.com.

   4. Clique em Excluir.

   5. Para confirmar a exclusão, clique em Excluir.

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

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

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

1. No Console do Google Cloud, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

• Disponibilizar um LLM com várias GPUs no GKE
• Disponibilizar um LLM usando TPUs de vários hosts no GKE com o Saxml