Exibir um modelo com uma única GPU no GKE


Este tutorial mostra como implantar e disponibilizar um modelo de linguagem grande (LLM) usando GPUs no Google Kubernetes Engine (GKE) com o Servidor de inferência Triton da NVIDIA e o TensorFlow Serving. Isso fornece uma base para entender e explorar a implantação prática de LLM para inferência em um ambiente Kubernetes gerenciado. Você implanta um contêiner pré-criado em um cluster do GKE com uma única GPU do Tensor Core L4 e prepara a infraestrutura do GKE para fazer inferências on-line.

Este tutorial é destinado a engenheiros de machine learning (ML), administradores e operadores de plataforma e especialistas em dados e IA que querem hospedar um modelo de machine learning (ML) pré-treinado em um cluster do GKE. Para saber mais sobre papéis comuns e exemplos de tarefas referenciados no conteúdo Google Cloud, consulte Tarefas e funções de usuário comuns do GKE Enterprise.

Antes de ler esta página, confira se você conhece os seguintes conceitos:

Objetivos

  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.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis 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

Criar o projeto

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the GKE API.

    Enable the API

  5. In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the GKE API.

    Enable the API

  8. Definir padrões para a Google Cloud CLI

    1. No Google Cloud console, 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:

    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.

    Piloto automático

    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
    

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

Criar 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 Google Cloud conta de serviço.
  2. Crie uma conta de serviço do Kubernetes no cluster.
  3. Vincule a conta de serviço do Kubernetes à conta de serviço Google Cloud .

Crie uma Google Cloud conta de serviço

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

Vincule a conta de serviço do Kubernetes à conta de serviço Google Cloud .

No Cloud Shell, execute estes comandos:

  1. Adicione uma vinculação do IAM à conta de serviço 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 flag --member fornece a identidade completa da conta de serviço do Kubernetes em 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:

    gcloud storage cp src/triton-model-repository gs://$GSBUCKET --recursive
    
  2. Implante o framework usando uma implantação. 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:

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

    gcloud storage cp src/tfserve-model-repository gs://$GSBUCKET --recursive
    
  2. Implante o framework usando uma implantação. 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:

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

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

Observar o desempenho do modelo

Triton

Para observar a performance do modelo, use a integração do painel do Triton 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 Triton, ative o Google Cloud Managed Service para Prometheus, que coleta as métricas do Triton, no cluster do GKE. O Triton expõe métricas no formato do Prometheus por padrão. Não é necessário instalar um exportador adicional.

Depois, é possível conferir as métricas usando o painel do Triton. Para informações sobre como usar o Google Cloud Managed Service para Prometheus para coletar métricas do seu modelo, consulte as orientações de observabilidade do Triton na documentação do Cloud Monitoring.

Exibição de TF

Para observar o desempenho do modelo, use a integração do painel do TF Serving 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 TF Serving, ative o Google Cloud Managed Service para Prometheus, que coleta as métricas do TF Serving, no cluster do GKE.

Em seguida, use o painel de métricas do TF Serving para conferir as métricas. Para saber como usar o Google Cloud Managed Service para Prometheus para coletar métricas do seu modelo, consulte as orientações de observabilidade do TF Serving na documentação do Cloud Monitoring.

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 Google Cloud recursos.
  • Manter o projeto Google Cloud :exclua o cluster do GKE e os recursos Google Cloud .
  • Excluir o projeto

Excluir os recursos do Kubernetes no cluster e os recursos 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. Exclua a conta de serviço 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.

Exclua o cluster do GKE e os recursos 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. Exclua a conta de serviço 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

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

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

A seguir