Implemente modelos abertos Gemma com GPUs no GKE com o Triton e o TensorRT-LLM

Este tutorial demonstra como implementar e publicar um modelo de linguagem (conteúdo extenso) (MDI/CE) Gemma usando GPUs no Google Kubernetes Engine (GKE) com a pilha de publicação da Triton e do TensorRT-LLM. Isto fornece uma base para compreender e explorar a implementação prática de MDIs/CEs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado com o Triton e o TensorRT-LLM no GKE. Também configura o GKE para carregar as ponderações do Gemma 2B e 7B.

Sugestão: para implementações de produção no GKE, recomendamos vivamente que use o Inference Quickstart para receber práticas recomendadas personalizadas e configurações para a inferência do seu modelo.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, e especialistas em dados e IA interessados em usar capacidades de orquestração de contentores do Kubernetes para publicar GMLs em hardware de GPU H100, A100 e L4. Para saber mais sobre as funções comuns e exemplos de tarefas que referimos no conteúdo, consulte o artigo Funções e tarefas comuns do utilizador do GKE. Google Cloud

Se precisar de uma plataforma de IA gerida unificada para criar e apresentar rapidamente modelos de ML de forma económica, recomendamos que experimente a nossa solução de implementação do Vertex AI.

Antes de ler esta página, certifique-se de que conhece o seguinte:

• Modo automático e modo padrão
• Disponibilidade da versão atual da GPU
• GPUs no GKE

Contexto

Esta secção descreve as principais tecnologias usadas neste guia.

Gemma

O Gemma é um conjunto de modelos de inteligência artificial (IA) generativa, leves e disponíveis abertamente, lançados ao abrigo de uma licença aberta. Estes modelos de IA estão disponíveis para execução nas suas aplicações, hardware, dispositivos móveis ou serviços alojados. Pode usar os modelos Gemma para a geração de texto. No entanto, também pode ajustar estes modelos para tarefas especializadas.

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

GPUs

As GPUs permitem-lhe acelerar cargas de trabalho específicas executadas nos seus nós, como a aprendizagem automática e o processamento de dados. O GKE oferece uma variedade de opções de tipos de máquinas para a configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H100, L4 e A100.

TensorRT-LLM

O NVIDIA TensorRT-LLM (TRT-LLM) é um conjunto de ferramentas com uma API Python para montar soluções otimizadas para definir MDIs/CEs e criar motores TensorRT que realizam inferências de forma eficiente em GPUs NVIDIA. O TensorRT-LLM inclui funcionalidades como:

• Implementação otimizada do transformador com fusões de camadas, colocação em cache de ativação, reutilização do buffer de memória e PagedAttention
• Processamento em lote contínuo ou em curso para melhorar o débito geral da publicação
• Paralelismo de tensores e paralelismo de pipelines para serviço distribuído em várias GPUs
• Quantização (FP16, FP8 e 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 aplicações de IA/ML. O Triton suporta a inferência de alto desempenho em GPUs NVIDIA e CPUs com backends otimizados, incluindo o TensorRT e o TensorRT-LLM. O Triton inclui funcionalidades como:

• Inferência com várias GPUs e vários nós
• Execução simultânea de vários modelos
• Encadeamento ou combinação de modelos
• Agrupamento estático, dinâmico e contínuo ou em curso de pedidos de previsão

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

Prepare o seu ambiente

Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Google Cloud. O Cloud Shell vem pré-instalado com o software de que precisa para este tutorial, incluindo o kubectl e a CLI gcloud.

Para configurar o seu ambiente com o Cloud Shell, siga estes passos:

1. Na Google Cloud consola, inicie uma sessão do Cloud Shell clicando em Ativar Cloud Shell na Google Cloud consola. Esta ação inicia uma sessão no painel inferior da consola. Google Cloud

2. Defina as variáveis de ambiente predefinidas:

   gcloud config set project PROJECT_ID
   gcloud config set billing/quota_project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
   export CLUSTER_NAME=CLUSTER_NAME
   

   Substitua os seguintes valores:

   • PROJECT_ID: o seu Google Cloud ID do projeto.
   • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
   • CLUSTER_NAME: o nome do cluster.

Aceda ao modelo

Para aceder aos modelos Gemma, tem de iniciar sessão na plataforma Kaggle e obter uma chave da API Kaggle.

Assine o contrato de consentimento de licença

Tem de assinar o contrato de consentimento para usar o Gemma. Siga estas instruções:

1. Aceda à página de consentimento do modelo em Kaggle.com.
2. Inicie sessão no Kaggle, se ainda não o tiver feito.
3. Clique em Pedir acesso.
4. Na secção Escolher conta para consentimento, selecione Validar através da conta do Kaggle para usar a sua conta do Kaggle para consentimento.
5. Aceite os Termos de Utilização do modelo.

Gere um token de acesso

Para aceder ao modelo através do Kaggle, precisa de um token da API Kaggle. Siga estes passos para gerar um novo token se ainda não tiver um:

1. No navegador, aceda às definições do Kaggle.
2. Na secção API, clique em Criar novo token.

É transferido um ficheiro com o nome kaggle.json.

Carregue o token de acesso para o Cloud Shell

No Cloud Shell, carregue o token da API Kaggle para o seu Google Cloud projeto:

1. No Cloud Shell, clique em Mais > Carregar.
2. Selecione Ficheiro e clique em Escolher ficheiros.
3. Abra o ficheiro kaggle.json.
4. Clique em Carregar.

Crie e configure Google Cloud recursos

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

Nota: pode ter de criar uma reserva de capacidade para a utilização de alguns aceleradores. Para saber como reservar e consumir recursos reservados, consulte o artigo Consumir recursos zonais reservados.

Crie um cluster e um node pool do GKE

Pode publicar o Gemma em GPUs num cluster do GKE Autopilot ou Standard. Recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.

Piloto automático

No Cloud Shell, execute o seguinte comando:

gcloud container clusters create-auto CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=CONTROL_PLANE_LOCATION \
  --release-channel=rapid \
  --cluster-version=1.28

Substitua os seguintes valores:

• PROJECT_ID: o seu Google Cloud ID do projeto.
• CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
• CLUSTER_NAME: o nome do cluster.

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

Standard

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

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

   Substitua os seguintes valores:

   • PROJECT_ID: o seu Google Cloud ID do projeto.
   • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
   • CLUSTER_NAME: o nome do cluster.

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

2. Execute o seguinte comando para criar um node pool para o cluster:

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

   O GKE cria um único node pool que contém um nó de GPU L4.

Crie um segredo do Kubernetes para as credenciais da Kaggle

Neste tutorial, usa um segredo do Kubernetes para as credenciais do Kaggle.

No Cloud Shell, faça o seguinte:

1. Configure kubectl para comunicar com o cluster:

   gcloud container clusters get-credentials CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION
   

   Substitua os seguintes valores:

   • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
   • CLUSTER_NAME: o nome do cluster.

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 -
   

Crie um recurso PersistentVolume para armazenar pontos de verificação

Nesta secção, cria um PersistentVolume suportado por um disco persistente para armazenar os pontos de verificação 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
   

Transfira os ficheiros do motor TensorRT-LLM para o Gemma

Nesta secção, executa um trabalho do Kubernetes para concluir as seguintes tarefas:

• Transfira os ficheiros do motor TensorRT-LLM e armazene-os no PersistentVolume que criou anteriormente.
• Prepare os ficheiros de configuração para implementar o modelo no servidor Triton.

Um controlador de tarefas no Kubernetes cria um ou mais pods e garante que executam com êxito uma tarefa específica.

O processo seguinte pode demorar alguns minutos.

Gemma 2B-it

O motor TensorRT-LLM é criado a partir do ponto de verificação do PyTorch de 2 mil milhões de parâmetros do Gemma (ajustado por instruções) com ativação bfloat16, comprimento da sequência de entrada=2048 e comprimento da sequência de saída=1024 GPUs L4 direcionadas. Pode implementar o modelo numa ú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. Veja os registos da tarefa:

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

   A saída dos registos é semelhante à seguinte:

   ...
   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 da tarefa:

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

   O resultado é semelhante ao seguinte:

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

5. Valide se a tarefa foi concluída com êxito (este processo pode demorar alguns minutos):

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

   O resultado é semelhante ao seguinte:

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

Gemma 7B-it

O motor TensorRT-LLM é criado a partir do ponto de verificação do PyTorch de 7 mil milhões de bits (ajustado por instruções) do Gemma com ativação bfloat16, comprimento da sequência de entrada=1024 e comprimento da sequência de saída=512 direcionados para GPUs L4. Pode implementar o modelo numa ú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. Veja os registos da tarefa:

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

   A saída dos registos é semelhante à seguinte:

   ...
   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 da tarefa:

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

   O resultado é semelhante ao seguinte:

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

5. Valide se a tarefa foi concluída com êxito (este processo pode demorar alguns minutos):

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

   O resultado é semelhante ao seguinte:

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

Certifique-se de que a tarefa é concluída com êxito antes de avançar para a secção seguinte.

Implemente o Triton

Nesta secção, implementa um contentor que usa o Triton com o back-end TensorRT-LLM para publicar o modelo Gemma que 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 implementação esteja disponível:

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

4. Veja os registos do manifesto:

   kubectl logs -f -l app=gemma-server
   

   O recurso de implementação inicia o servidor Triton e carrega os dados do modelo. Este processo pode demorar alguns minutos (até 20 minutos ou mais). O resultado é semelhante ao seguinte:

   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
   

Publique o modelo

Nesta secção, interage com o modelo.

Configure 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 é semelhante ao seguinte:

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

Interaja com o modelo através do curl

Esta secção mostra como pode realizar um teste rápido básico para validar o modelo ajustado com instruções implementado. Para simplificar, esta secção descreve a abordagem de testes apenas com o modelo preparado de instruções de 2B.

Numa nova sessão de terminal, use curl para conversar com o 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 seguinte 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"
}

Êxito: publicou o Gemma com êxito usando GPUs no GKE com o Triton e o TensorRT-LLM.

Resolver problemas

• Se receber a mensagem Empty reply from server, é possível que o contentor não tenha terminado de transferir os dados do modelo. Verifique novamente os registos do Pod para ver a mensagem Connected, que indica que o modelo está pronto para publicação.
• Se vir Connection refused, verifique se o encaminhamento de portas está ativo.