Esta página foi traduzida pela API Cloud Translation.

Exibir um modelo com uma única GPU no GKE

Autopilot Standard

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

Crie um cluster do GKE Autopilot ou Standard.
Configurar o bucket do Cloud Storage, onde fica o modelo pré-treinado.
Implante o framework de inferência on-line selecionado.
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

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.

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

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

Enable the GKE API.

Enable the API

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

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

Enable the GKE API.

Enable the API

Definir padrões para a Google Cloud CLI

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

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

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 Google Cloud ID do projeto.
- 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.

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

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.

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:

Crie uma Google Cloud conta de serviço.
Crie uma conta de serviço do Kubernetes no cluster.
Vincule a conta de serviço do Kubernetes à conta de serviço Google Cloud .

Crie uma Google Cloud conta de serviço

No console Google Cloud , acesse a página Criar conta de serviço:

Acesse "Criar conta de serviço"
No campo ID da conta de serviço, digite gke-ai-sa.
Clique em Criar e continuar.
Na lista Papel, selecione o papel Cloud Storage > Serviço de coletor do Insights.
Clique em Adicionar outro papel.
Na lista Selecionar um papel, selecione o papel Cloud Storage > Administrador de objetos do Storage.
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:

Crie um namespace do Kubernetes:

kubectl create namespace gke-ai-namespace

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:

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.

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

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

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

Implante os serviços para acessar a implantação:

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

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.

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

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

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

Implante os serviços para acessar a implantação:

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

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.

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

Criar um ambiente virtual do Python no Cloud Shell.

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

Instale os pacotes Python necessários.

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

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

Criar um ambiente virtual do Python no Cloud Shell.

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

Instale os pacotes Python necessários.

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

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

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

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

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

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.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Exibir um modelo com uma única GPU no GKE Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Objetivos

Custos

Antes de começar

Criar o projeto

Definir padrões para a Google Cloud CLI

Crie um cluster do GKE

Piloto automático

Standard

Criar um bucket do Cloud Storage

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

Crie uma Google Cloud conta de serviço

Criar uma conta de serviço do Kubernetes no cluster

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

Implantar o servidor de inferência on-line

Triton

Exibição de TF

Disponibilizar o modelo

Triton

Exibição de TF

Observar o desempenho do modelo

Triton

Exibição de TF

Limpar

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

Triton

Exibição de TF

Exclua o cluster do GKE e os recursos Google Cloud

Excluir o projeto

A seguir

Exibir um modelo com uma única GPU no GKE