Disponibilizar modelos abertos do Gemma usando GPUs no GKE com Triton e TensorRT-LLM

Autopilot Standard

---

Neste tutorial, mostramos como disponibilizar o modelo de linguagem grande (LLM, na sigla em inglês) Gemma, usando unidades de processamento gráfico (GPUs) no Google Kubernetes Engine (GKE), usando a NVIDIA Triton e TensorRT-LLM (em inglês), a pilha de disponibilização para inferências baseadas em GPU eficientes com o Kubernetes e orquestração. Neste tutorial, faça o download dos modelos Gemma ajustados para instruções de parâmetros 2B e 7B e os implante em um cluster do GKE Autopilot ou Standard usando um contêiner que executa o Triton e o TensorRT. LLM.

Este guia é um bom ponto de partida se você precisar do controle granular, da escalonabilidade, da resiliência, da portabilidade e da economia do Kubernetes gerenciado ao implantar e disponibilizar suas cargas de trabalho de IA/ML. Se você precisa de uma plataforma de IA gerenciada unificada para criar e disponibilizar modelos de ML rapidamente e de maneira econômica, recomendamos testar nossa solução de implantação da Vertex AI.

Contexto

Ao disponibilizar o Gemma usando GPUs no GKE com o Triton e o TensorRT-LLM, é possível implementar uma solução de veiculação de inferência robusta e pronta para produção com todos os benefícios do Kubernetes gerenciado, incluindo escalonabilidade eficiente e maior disponibilidade. Esta seção descreve as principais tecnologias usadas neste guia.

Gemma

O Gemma é um conjunto de modelos de inteligência artificial (IA) generativa, leve e abertamente lançados sob licença aberta. Esses modelos de IA estão disponíveis para execução em aplicativos, hardware, dispositivos móveis ou serviços hospedados. É possível usar os modelos Gemma para geração de texto, mas também é possível ajustá-los para tarefas especializadas.

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

GPUs

As GPUs permitem acelerar cargas de trabalho específicas em execução nos nós, como machine learning e processamento de dados. O GKE oferece uma gama de opções de tipos de máquina para configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H100, L4 e A100.

Antes de usar GPUs no GKE, recomendamos que você conclua o seguinte programa de aprendizado:

1. Saiba mais sobre a disponibilidade atual da versão da GPU.
2. Saiba mais sobre GPUs no GKE.

TensorRT-LLM

O NVIDIA TensorRT-LLM (TRT-LLM) é um kit de ferramentas com uma API Python para montar soluções otimizadas para definir LLMs e criar mecanismos TensorRT que executam inferência de maneira eficiente em GPUs NVIDIA. O TensorRT-LLM inclui recursos como:

• Otimização da implementação de transformador com fusões de camada, armazenamento em cache de ativação, reutilização de buffer de memória e PagedAttention.
• Lotes contínuos ou em trânsito para melhorar a capacidade de processamento geral de disponibilização
• Paralelismo de tensor e pipeline para exibição distribuída em várias GPUs
• Quantização (FP16, FP8, INT8)

Para saber mais, consulte a documentação do TensorRT-LLM.

Triton

O NVIDIA Triton Inference Server é um servidor de inferência de código aberto para aplicativos de IA/ML. O Triton oferece suporte à inferência de alto desempenho em GPUs e CPUs NVIDIA com back-ends otimizados, incluindo TensorRT e TensorRT-LLM. O Triton inclui recursos como:

• Inferência com várias GPUs e vários nós
• Execução simultânea de vários modelos
• Ensembling ou encadeamento de modelos
• Lotes estáticos, dinâmicos e contínuos ou em trânsito de solicitações de previsão

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

Objetivos

Este guia é destinado a clientes de IA generativa que usam PyTorch, usuários novos ou antigos do GKE, engenheiros de ML, engenheiros de MLOps (DevOps) ou administradores de plataformas interessados no uso dos recursos de orquestração de contêineres do Kubernetes para disponibilizar LLMs em hardwares de GPU H100, A100 e L4.

Ao final deste guia, você será capaz de realizar as seguintes etapas:

1. Prepare seu ambiente com um cluster do GKE no modo Autopilot.
2. Implante um contêiner com o Triton e o TritonRT-LLM no seu cluster.
3. Use o Triton e o TensorRT-LLM para disponibilizar o modelo Gemma 2B ou 7B por meio de curl.

Antes de começar

• 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, select or create a Google Cloud project.

  Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

  Go to project selector

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

• Enable the required API.

  Enable the API

• In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

  Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

  Go to project selector

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

• Enable the required API.

  Enable the API

• Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

  Check for the roles

  1. In the Google Cloud console, go to the IAM page.

     Go to IAM
  2. Select the project.

  3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

  4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

  Grant the roles

  1. In the Google Cloud console, go to the IAM page.

     Acessar o IAM
  2. Selecionar um projeto.
  3. Clique em CONCEDER ACESSO.

  4. No campo Novos principais, insira seu identificador de usuário. Normalmente, é o endereço de e-mail de uma Conta do Google.

  5. Na lista Selecionar um papel, escolha um.
  6. Para conceder outros papéis, clique em Adicionar outro papel e adicione cada papel adicional.
  7. Clique em Salvar.

• Crie uma conta da Kaggle, caso ainda não tenha uma.
• Verifique se o projeto tem cota suficiente para GPUs. Para saber mais, consulte Sobre GPUs e Cotas de alocação.

Prepare o ambiente

Neste tutorial, você usará o Cloud Shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo kubectl e gcloud CLI.

Para configurar o ambiente com o Cloud Shell, siga estas etapas:

1. No console do Google Cloud, inicie uma sessão do Cloud Shell clicando em Ativar o Cloud Shell no console do Google Cloud. Isso inicia uma sessão no painel inferior do console do Google Cloud.

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

   gcloud config set project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export REGION=REGION
   export CLUSTER_NAME=triton
   

   Substitua os seguintes valores:

   • PROJECT_ID: seu ID do projeto no Google Cloud.
   • REGION: uma região compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.

Receber acesso ao modelo

Para ter acesso aos modelos Gemma, você deve fazer login na plataforma Kaggle e obter um token da API Kaggle.

Assinar o contrato de consentimento de licença

É necessário assinar o contrato de consentimento para usar o Gemma. Siga estas instruções:

1. Acesse a página de consentimento do modelo em Kaggle.com.
2. Faça login no Kaggle se ainda não tiver feito isso.
3. Clique em Solicitar acesso.
4. Na seção Escolher conta para consentimento, selecione Verificar via conta do Kaggle para usar sua conta do Kaggle para consentimento.
5. Aceite os Termos e Condições do modelo.

Gerar um token de acesso

Para acessar o modelo pelo Kaggle, você precisa de um token da API do Kaggle. Siga as etapas abaixo para gerar um novo token, caso ainda não tenha um:

1. No navegador, acesse as configurações da Kaggle.
2. Na seção "API", clique em Criar novo token.

Um arquivo chamado kaggle.json é transferido por download.

Fazer upload do token de acesso no Cloud Shell

No Cloud Shell, faça upload do token da API Kaggle para seu projeto do Google Cloud:

1. No Cloud Shell, clique em Mais > Fazer upload.
2. Selecione "Arquivo" e clique em Escolher arquivos.
3. Abra o arquivo kaggle.json.
4. Clique em Fazer upload.

Criar e configurar recursos do Google Cloud

Siga estas instruções para criar os recursos necessários.

Observação: pode ser necessário criar uma reserva de capacidade para o uso de alguns aceleradores. Para saber como reservar e consumir recursos reservados, consulte Como consumir recursos por zona reservados.

Criar um cluster do GKE e um pool de nós

É possível disponibilizar o Gemma em GPUs 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. 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

No Cloud Shell, execute este comando:

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

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

Padrão

1. No Cloud Shell, execute o seguinte comando para criar um cluster Standard:

   gcloud container clusters create ${CLUSTER_NAME} \
       --project=${PROJECT_ID} \
       --location=${REGION}-a \
       --workload-pool=${PROJECT_ID}.svc.id.goog \
       --release-channel=rapid \
       --machine-type=e2-standard-4 \
       --num-nodes=1
   

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

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

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

   O GKE cria um único pool de nós contendo um nó da GPU L4.

Criar um secret do Kubernetes para credenciais do Kaggle

Neste tutorial, você usa um Secret do Kubernetes para as credenciais do Kaggle.

No Cloud Shell, faça o seguinte:

1. Configure kubectl para se comunicar com o cluster:

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

2. Crie um Secret para armazenar as credenciais do Kaggle:

   kubectl create secret generic kaggle-secret \
       --from-file=kaggle.json \
       --dry-run=client -o yaml | kubectl apply -f -
   

Criar um recurso PersistentVolume para armazenar checkpoints

Nesta seção, você vai criar um PersistentVolume com um disco permanente para armazenar os checkpoints do modelo.

1. Crie o seguinte manifesto trtllm_checkpoint_pv.yaml:

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: model-data
   spec:
     accessModes:
     - ReadWriteOnce
     resources:
       requests:
         storage: 100G

2. Aplique o manifesto:

   kubectl apply -f trtllm_checkpoint_pv.yaml
   

Fazer o download dos arquivos do mecanismo TensorRT-LLM para o Gemma

Nesta seção, você executa um job para fazer o download dos arquivos do mecanismo TensorRT-LLM e armazenar os arquivos no PersistentVolume criado anteriormente. O job também prepara arquivos de configuração para implantar o modelo no servidor Triton na próxima etapa. O processo pode levar alguns minutos.

Gemma 2B-it

O mecanismo TensorRT-LLM é criado a partir do checkpoint PyTorch do Gemma 2B-it (ajustado por instruções) do Gemma usando a ativação bfloat16, o comprimento da sequência de entrada=2048 e o comprimento da sequência de saída=1024 GPUs L4 segmentadas. É possível implantar o modelo em uma única GPU L4.

1. Crie o seguinte manifesto job-download-gemma-2b.yaml:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: fetch-model-scripts
   data:
     fetch_model.sh: |-
       #!/usr/bin/bash -x
       pip install kaggle --break-system-packages && \
   
       MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
       VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
       ACTIVATION_DTYPE=bfloat16 && \
   
       TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
       ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
       TRITON_MODEL_REPO=/data/triton/model_repository && \
   
       mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
       mkdir -p ${ENGINE_PATH} && \
       mkdir -p ${TRITON_MODEL_REPO} && \
   
       kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
       rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
       find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
       find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \
   
       # copying configuration files
       echo -e "\nCreating configuration files" && \
       cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \
   
       # updating configuration files
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \
   
       echo -e "\nCompleted extraction to ${ENGINE_PATH}"
   ---
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: data-loader-gemma-2b
     labels:
       app: data-loader-gemma-2b
   spec:
     ttlSecondsAfterFinished: 120
     template:
       metadata:
         labels:
           app: data-loader-gemma-2b
       spec:
         restartPolicy: OnFailure
         containers:
         - name: gcloud
           image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
           command:
           - /scripts/fetch_model.sh
           env:
           - name: KAGGLE_CONFIG_DIR
             value: /kaggle
           - name: MODEL_PATH
             value: "google/gemma/tensorrtllm/2b-it/2"
           - name: WORLD_SIZE
             value: "1"
           volumeMounts:
           - mountPath: "/kaggle/"
             name: kaggle-credentials
             readOnly: true
           - mountPath: "/scripts/"
             name: scripts-volume
             readOnly: true
           - mountPath: "/data"
             name: data
         volumes:
         - name: kaggle-credentials
           secret:
             defaultMode: 0400
             secretName: kaggle-secret
         - name: scripts-volume
           configMap:
             defaultMode: 0700
             name: fetch-model-scripts
         - name: data
           persistentVolumeClaim:
             claimName: model-data
         tolerations:
         - key: "key"
           operator: "Exists"
           effect: "NoSchedule"

2. Aplique o manifesto:

   kubectl apply -f job-download-gemma-2b.yaml
   

3. Visualize os registros do job:

   kubectl logs -f job/data-loader-gemma-2b
   

   A saída destes registros terá esta aparência:

   ...
   Creating configuration files
   + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/2b/bfloat16/1-gpu/'
   + echo -e '\nCreating configuration files'
   ...
   

4. Aguarde a conclusão do job:

   kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-2b
   

   O resultado será assim:

   job.batch/data-loader-gemma-2b condition met
   

5. Verifique se o job foi concluído (isso pode levar alguns minutos):

   kubectl get job/data-loader-gemma-2b
   

   O resultado será assim:

   NAME             COMPLETIONS   DURATION   AGE
   data-loader-gemma-2b   1/1           ##s        #m##s
   

Gemma 7B-it

O mecanismo TensorRT-LLM é criado a partir do checkpoint PyTorch do Gemma 7B-it (ajustado por instruções) do Gemma usando a ativação bfloat16, o comprimento da sequência de entrada=1024 e o comprimento da sequência de saída=512 GPUs L4 segmentadas. É possível implantar o modelo em uma única GPU L4.

1. Crie o seguinte manifesto job-download-gemma-7b.yaml:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: fetch-model-scripts
   data:
     fetch_model.sh: |-
       #!/usr/bin/bash -x
       pip install kaggle --break-system-packages && \
   
       MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
       VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
       ACTIVATION_DTYPE=bfloat16 && \
   
       TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
       ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
       TRITON_MODEL_REPO=/data/triton/model_repository && \
   
       mkdir -p ${ENGINE_PATH} && \
       mkdir -p ${TRITON_MODEL_REPO} && \
   
       kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
       rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
       find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
       find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \
   
       # copying configuration files
       echo -e "\nCreating configuration files" && \
       cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \
   
       # updating configuration files
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
       python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \
   
       echo -e "\nCompleted extraction to ${ENGINE_PATH}"
   ---
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: data-loader-gemma-7b
     labels:
       app: data-loader-gemma-7b
   spec:
     ttlSecondsAfterFinished: 120
     template:
       metadata:
         labels:
           app: data-loader-gemma-7b
       spec:
         restartPolicy: OnFailure
         containers:
         - name: gcloud
           image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
           command:
           - /scripts/fetch_model.sh
           env:
           - name: KAGGLE_CONFIG_DIR
             value: /kaggle
           - name: MODEL_PATH
             value: "google/gemma/tensorrtllm/7b-it/2"
           - name: WORLD_SIZE
             value: "1"
           volumeMounts:
           - mountPath: "/kaggle/"
             name: kaggle-credentials
             readOnly: true
           - mountPath: "/scripts/"
             name: scripts-volume
             readOnly: true
           - mountPath: "/data"
             name: data
         volumes:
         - name: kaggle-credentials
           secret:
             defaultMode: 0400
             secretName: kaggle-secret
         - name: scripts-volume
           configMap:
             defaultMode: 0700
             name: fetch-model-scripts
         - name: data
           persistentVolumeClaim:
             claimName: model-data
         tolerations:
         - key: "key"
           operator: "Exists"
           effect: "NoSchedule"

2. Aplique o manifesto:

   kubectl apply -f job-download-gemma-7b.yaml
   

3. Visualize os registros do job:

   kubectl logs -f job/data-loader-gemma-7b
   

   A saída destes registros terá esta aparência:

   ...
   Creating configuration files
   + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/7b/bfloat16/1-gpu/'
   + echo -e '\nCreating configuration files'
   ...
   

4. Aguarde a conclusão do job:

   kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-7b
   

   O resultado será assim:

   job.batch/data-loader-gemma-7b condition met
   

5. Verifique se o job foi concluído (isso pode levar alguns minutos):

   kubectl get job/data-loader-gemma-7b
   

   O resultado será assim:

   NAME             COMPLETIONS   DURATION   AGE
   data-loader-gemma-7b   1/1           ##s        #m##s
   

Verifique se o job foi concluído antes de prosseguir para a próxima seção.

Implantar o Triton

Nesta seção, você implanta um contêiner que usa o Triton com o back-end TensorRT-LLM para exibir o modelo Gemma que você quer usar.

1. Crie o seguinte manifesto deploy-triton-server.yaml:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: launch-tritonserver
   data:
     entrypoint.sh: |-
       #!/usr/bin/bash -x
       # Launch Triton Inference server
   
       WORLD_SIZE=1
       TRITON_MODEL_REPO=/data/triton/model_repository
   
       python3 /tensorrtllm_backend/scripts/launch_triton_server.py \
         --world_size ${WORLD_SIZE} \
         --model_repo ${TRITON_MODEL_REPO}
   
       tail -f /dev/null
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: triton-gemma-deployment
     labels:
       app: gemma-server
       version: v1 
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server 
         version: v1
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma
           ai.gke.io/inference-server: triton
           examples.ai.gke.io/source: user-guide
           version: v1
       spec:
         containers:
         - name: inference-server 
           image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
           imagePullPolicy: IfNotPresent
           resources:
             requests:
               ephemeral-storage: "40Gi"
               memory: "40Gi"
               nvidia.com/gpu: 1
             limits:
               ephemeral-storage: "40Gi"
               memory: "40Gi"
               nvidia.com/gpu: 1
           command:
           - /scripts/entrypoint.sh
           volumeMounts:
           - mountPath: "/scripts/"
             name: scripts-volume
             readOnly: true
           - mountPath: "/data"
             name: data
           ports:
             - containerPort: 8000
               name: http
             - containerPort: 8001
               name: grpc
             - containerPort: 8002
               name: metrics
           livenessProbe:
             failureThreshold: 60
             initialDelaySeconds: 600
             periodSeconds: 5
             httpGet:
               path: /v2/health/live
               port: http
           readinessProbe:
             failureThreshold: 60
             initialDelaySeconds: 600
             periodSeconds: 5
             httpGet:
               path: /v2/health/ready
               port: http
         securityContext:
           runAsUser: 1000
           fsGroup: 1000
         volumes:
         - name: scripts-volume
           configMap:
             defaultMode: 0700
             name: launch-tritonserver
         - name: data
           persistentVolumeClaim:
             claimName: model-data
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
         tolerations:
         - key: "key"
           operator: "Exists"
           effect: "NoSchedule"
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: triton-server
     labels:
       app: gemma-server 
   spec:
     type: ClusterIP
     ports:
       - port: 8000
         targetPort: http
         name: http-inference-server
       - port: 8001
         targetPort: grpc
         name: grpc-inference-server
       - port: 8002
         targetPort: metrics
         name: http-metrics
     selector:
       app: gemma-server

2. Aplique o manifesto:

   kubectl apply -f deploy-triton-server.yaml
   

3. Aguarde até que a implantação esteja disponível:

   kubectl wait --for=condition=Available --timeout=900s deployment/triton-gemma-deployment
   

4. Veja os registros do manifesto:

   kubectl logs -f -l app=gemma-server
   

   O recurso de implantação inicia o servidor Triton e carrega os dados do modelo. Esse processo pode levar alguns minutos (até 20 minutos ou mais). A resposta será semelhante a:

   I0216 03:24:57.387420 29 server.cc:676]
   +------------------+---------+--------+
   | Model            | Version | Status |
   +------------------+---------+--------+
   | ensemble         | 1       | READY  |
   | postprocessing   | 1       | READY  |
   | preprocessing    | 1       | READY  |
   | tensorrt_llm     | 1       | READY  |
   | tensorrt_llm_bls | 1       | READY  |
   +------------------+---------+--------+
   
   ....
   ....
   ....
   
   I0216 03:24:57.425104 29 grpc_server.cc:2519] Started GRPCInferenceService at 0.0.0.0:8001
   I0216 03:24:57.425418 29 http_server.cc:4623] Started HTTPService at 0.0.0.0:8000
   I0216 03:24:57.466646 29 http_server.cc:315] Started Metrics Service at 0.0.0.0:8002
   

Disponibilizar o modelo

Nesta seção, você vai interagir com o modelo.

Configurar o encaminhamento de portas

Execute o seguinte comando para configurar o encaminhamento de portas para o modelo:

kubectl port-forward service/triton-server 8000:8000

O resultado será assim:

Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
Handling connection for 8000

Interagir com o modelo usando curl

Nesta seção, mostramos como executar um teste preliminar básico para verificar o modelo ajustado por instruções implantado. Para simplificar, nesta seção, descrevemos a abordagem de teste usando apenas o modelo ajustado por instrução 2B.

Em uma nova sessão do terminal, use curl para conversar com seu modelo:

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST localhost:8000/v2/models/ensemble/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "text_input": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "temperature": 0.9,
    "max_tokens": 128
}
EOF

A saída a seguir mostra um exemplo da resposta do modelo:

{
  "context_logits": 0,
  "cum_log_probs": 0,
  "generation_logits": 0,
  "model_name": "ensemble",
  "model_version": "1",
  "output_log_probs": [0.0,0.0,...],
  "sequence_end": false,
  "sequence_id": 0,
  "sequence_start": false,
  "text_output":"Python.\n\nPython is an excellent choice for beginners due to its simplicity, readability, and extensive documentation. Its syntax is close to natural language, making it easier for beginners to understand and write code. Python also has a vast collection of libraries and tools that make it versatile for various projects. Additionally, Python's dynamic nature allows for easier learning and experimentation, making it a perfect choice for newcomers to get started.Here are some specific reasons why Python is a good choice for beginners:\n\n- Simple and Easy to Read: Python's syntax is designed to be close to natural language, making it easier for"
}

Sucesso: você veiculou com sucesso o Gemma usando GPUs no GKE com Triton e TensorRT-LLM.

Resolver problemas

• Se você receber a mensagem Empty reply from server, é possível que o contêiner não tenha concluído o download dos dados do modelo. Verifique os registros do pod novamente para ver a mensagem Connected, que indica que o modelo está pronto para ser disponibilizado.
• Se você vir Connection refused, verifique se o encaminhamento de portas está ativo.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir os recursos implantados

Para evitar cobranças na sua conta do Google Cloud pelos recursos criados neste guia, execute o seguinte comando:

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

A seguir

• Saiba mais sobre GPUs no GKE.
• Saiba mais como implantar cargas de trabalho de GPU no Autopilot.
• Aprenda a implantar cargas de trabalho de GPU no Standard.
• Conheça o repositório e a documentação do GitHub do TensorRT-LLM.
• Conhecer o Model Garden da Vertex AI.
• Descubra como executar cargas de trabalho de IA/ML otimizadas com os recursos de orquestração da plataforma GKE.