Gestisci modelli aperti Gemma utilizzando GPU su GKE con Triton e TensorRT-LLM

Autopilot Standard

---

Questo tutorial mostra come gestire un modello linguistico di grandi dimensioni (LLM) Gemma utilizzando GPU (Graphic Processing Unit) su Google Kubernetes Engine (GKE) con gli stack di gestione NVIDIA Triton e TensorRT-LLM. In questo tutorial, scaricherai i modelli Gemma ottimizzati per l'istruzione con parametri 2B e 7B e ne eseguirai il deployment su un cluster GKE Autopilot o Standard utilizzando un container che esegue Triton e TensorRT-LLM.

Questa guida è un buon punto di partenza se hai bisogno del controllo granulare, della scalabilità, della resilienza, della portabilità e della convenienza di Kubernetes gestito quando esegui il deployment e la gestione dei tuoi carichi di lavoro AI/ML. Se hai bisogno di una piattaforma IA gestita e unificata per creare e pubblicare rapidamente modelli ML a costi contenuti, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.

Contesto

Utilizzando Gemma tramite GPU su GKE con Triton e TensorRT-LLM, puoi implementare una solida soluzione di servizio di inferenza pronta per la produzione con tutti i vantaggi di Kubernetes gestito, tra cui scalabilità efficiente e disponibilità superiore. In questa sezione vengono descritte le tecnologie principali utilizzate in questa guida.

Gemma

Gemma è un insieme di modelli di intelligenza artificiale generativa (AI), leggeri e a disponibilità aperta, rilasciati con licenza aperta. Questi modelli di IA possono essere eseguiti in applicazioni, hardware, dispositivi mobili o servizi in hosting. Puoi utilizzare i modelli Gemma per la generazione di testo, ma puoi anche ottimizzarli per attività specializzate.

Per saperne di più, consulta la documentazione di Gemma.

GPU

Le GPU consentono di accelerare carichi di lavoro specifici in esecuzione sui nodi, come il machine learning e l'elaborazione di dati. GKE offre una gamma di opzioni per i tipi di macchina per la configurazione dei nodi, inclusi i tipi di macchina con GPU NVIDIA H100, L4 e A100.

Prima di utilizzare le GPU in GKE, ti consigliamo di completare il seguente percorso di apprendimento:

1. Scopri di più sulla disponibilità attuale delle versioni GPU
2. Scopri di più sulle GPU in GKE

TensorRT-LLM

NVIDIA TensorRT-LLM (TRT-LLM) è un toolkit con un'API Python per l'assemblaggio di soluzioni ottimizzate per definire gli LLM e creare motori TensorRT che offrono inferenza in modo efficiente sulle GPU NVIDIA. TensorRT-LLM include funzionalità come:

• Implementazione del trasformatore ottimizzata con fusioni di livelli, memorizzazione nella cache di attivazione, riutilizzo del buffer della memoria e PagedAttention
• Batch in corso o continuo per migliorare la velocità effettiva complessiva di pubblicazione
• Parallelismo tensore e parallelismo delle pipeline per la pubblicazione distribuita su più GPU
• Quantizzazione (FP16, FP8, INT8)

Per saperne di più, consulta la documentazione di TensorRT-LLM.

Tritone

NVIDIA Triton Inference Server è un server di inferenza open source per le applicazioni AI/ML. Triton supporta l'inferenza ad alte prestazioni sia su GPU NVIDIA che CPU con backend ottimizzati, tra cui TensorRT e TensorRT-LLM. Triton include funzionalità come:

• Inferenza multi-GPU e multi-nodo
• Esecuzione simultanea di più modelli
• ensembling o concatenamento di modelli
• Batch statico, dinamico, continuo o in corso di elaborazione delle richieste di previsione

Per scoprire di più, consulta la documentazione di Triton.

Obiettivi

Questa guida è rivolta ai clienti di IA generativa che utilizzano PyTorch, agli utenti nuovi o esistenti di GKE, ML Engineer, MLOps (DevOps) ingegneri o amministratori di piattaforma interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la gestione di LLM su hardware GPU H100, A100 ed L4.

Al termine di questa guida, dovresti essere in grado di eseguire le seguenti operazioni:

1. Prepara l'ambiente con un cluster GKE in modalità Autopilot.
2. Esegui il deployment di un container con Triton e TritonRT-LLM nel cluster.
3. Usare Triton e TensorRT-LLM per servire il modello Gemma 2B o 7B tramite curl.

Prima di iniziare

• Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

• 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

• Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

• Attiva l'API richiesta.

  Abilita l'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

• Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

• Attiva l'API richiesta.

  Abilita l'API

• Assicurati di disporre dei seguenti ruoli nel progetto: roles/container.admin, roles/iam.serviceAccountAdmin

  Verifica i ruoli

  1. Nella console Google Cloud, vai alla pagina IAM.

     Vai a IAM
  2. Seleziona il progetto.

  3. Nella colonna Entità, individua la riga contenente il tuo indirizzo email.

     Se il tuo indirizzo email non è in questa colonna, significa che non disponi di alcun ruolo.

  4. Nella colonna Ruolo per la riga contenente il tuo indirizzo email, controlla se l'elenco dei ruoli include quelli richiesti.

  Concedi i ruoli

  1. Nella console Google Cloud, vai alla pagina IAM.

     Vai a IAM
  2. Seleziona il progetto.
  3. Fai clic su Concedi l'accesso.
  4. Nel campo Nuove entità, inserisci il tuo indirizzo email.
  5. Nell'elenco Seleziona un ruolo, scegli un ruolo.
  6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ciascun ruolo aggiuntivo.
  7. Fai clic su Salva.

• Crea un account Kaggle, se non ne hai già uno.
• Assicurati che il tuo progetto abbia una quota sufficiente per le GPU. Per saperne di più, consulta Informazioni sulle GPU e Quote di allocazione.

prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Il software necessario per questo tutorial è preinstallato in Cloud Shell, tra cui kubectl e gcloud CLI.

Per configurare il tuo ambiente con Cloud Shell, segui questi passaggi:

1. Nella console Google Cloud, avvia una sessione di Cloud Shell facendo clic su Attiva Cloud Shell nella console Google Cloud. Viene avviata una sessione nel riquadro inferiore della console Google Cloud.

2. Imposta le variabili di ambiente predefinite:

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

   Sostituisci i seguenti valori:

   • PROJECT_ID: il tuo ID progetto Google Cloud.
   • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.

Accedi al modello

Per ottenere l'accesso ai modelli Gemma, devi accedere alla piattaforma Kaggle e ottenere un token dell'API Kaggle.

Firma il contratto di consenso per la licenza

Devi firmare il contratto di consenso per utilizzare Gemma. Segui queste istruzioni:

1. Accedi alla pagina relativa al consenso del modello su Kaggle.com.
2. Se non l'hai ancora fatto, accedi a Kaggle.
3. Fai clic su Richiedi accesso.
4. Nella sezione Scegli account per il consenso, seleziona Verifica tramite account Kaggle per utilizzare il tuo account Kaggle per il consenso.
5. Accetta i Termini e condizioni del modello.

Generare un token di accesso

Per accedere al modello tramite Kaggle, è necessario un token API di Kaggle. Se non ne hai già uno, segui questi passaggi per generare un nuovo token:

1. Nel browser, vai alle impostazioni di Kaggle.
2. Nella sezione API, fai clic su Create New Token (Crea nuovo token).

È stato scaricato un file denominato kaggle.json.

Carica il token di accesso su Cloud Shell

In Cloud Shell, carica il token dell'API Kaggle nel tuo progetto Google Cloud:

1. In Cloud Shell, fai clic su Altro > Carica.
2. Seleziona File e fai clic su Scegli file.
3. Apri il file kaggle.json.
4. Fai clic su Carica.

crea e configura risorse Google Cloud

Segui queste istruzioni per creare le risorse richieste.

Nota: potrebbe essere necessario creare una prenotazione di capacità per l'utilizzo di alcuni acceleratori. Per scoprire come prenotare e utilizzare risorse riservate, consulta Utilizzo di risorse di zona riservate.

Crea un cluster GKE e un pool di nodi

Puoi gestire Gemma su GPU in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi carichi di lavoro, consulta Scegliere una modalità operativa GKE.

Autopilot

In Cloud Shell, esegui questo comando:

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

GKE crea un cluster Autopilot con nodi CPU e GPU, come richiesto dai carichi di lavoro di cui è stato eseguito il deployment.

Standard

1. In Cloud Shell, esegui questo comando per creare un 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
   

   La creazione del cluster potrebbe richiedere diversi minuti.

2. Esegui questo comando per creare un pool di nodi per il tuo 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
   

   GKE crea un singolo pool di nodi contenente un nodo GPU L4.

Crea il secret di Kubernetes per le credenziali di Kaggle

In questo tutorial utilizzerai un secret di Kubernetes per le credenziali di Kaggle.

In Cloud Shell, segui questi passaggi:

1. Configura kubectl per comunicare con il cluster:

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

2. Crea un secret per archiviare le credenziali di Kaggle:

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

Crea una risorsa PersistentVolume per archiviare i checkpoint

In questa sezione creerai un PersistentVolume supportato da un disco permanente per archiviare i checkpoint del modello.

1. Crea il seguente manifest trtllm_checkpoint_pv.yaml:

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

2. Applica il manifest:

   kubectl apply -f trtllm_checkpoint_pv.yaml
   

Scarica i file del motore TensorRT-LLM per Gemma

In questa sezione eseguirai un job per scaricare i file del motore TensorRT-LLM e archiviare i file nell'oggetto PersistentVolume hai creato in precedenza. Il job prepara anche i file di configurazione per il deployment del modello sul server Triton nel passaggio successivo. Questa procedura può richiedere alcuni minuti.

Gemma 2Bit

Il motore TensorRT-LLM è basato sul checkpoint Gemma 2B-it (ottimizzato per le istruzioni) di Gemma utilizzando l'attivazione bfloat16, la lunghezza della sequenza di input=2048 e la lunghezza della sequenza di output=1024 GPU L4 mirate. Puoi eseguire il deployment del modello su una singola GPU L4.

1. Crea il seguente manifest 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. Applica il manifest:

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

3. Visualizza i log per il job:

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

   L'output dei log è simile al seguente:

   ...
   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. Attendi il completamento del job:

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

   L'output è simile al seguente:

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

5. Verifica che il job sia stato completato correttamente (l'operazione potrebbe richiedere alcuni minuti):

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

   L'output è simile al seguente:

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

Gemma 7B-it

Il motore TensorRT-LLM è basato sul checkpoint Gemma 7B-it (ottimizzato per le istruzioni) di Gemma utilizzando l'attivazione bfloat16, la lunghezza della sequenza di input=1024 e la lunghezza della sequenza di output=512 GPU L4 scelte come target. Puoi eseguire il deployment del modello su una singola GPU L4.

1. Crea il seguente manifest 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. Applica il manifest:

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

3. Visualizza i log per il job:

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

   L'output dei log è simile al seguente:

   ...
   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. Attendi il completamento del job:

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

   L'output è simile al seguente:

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

5. Verifica che il job sia stato completato correttamente (l'operazione potrebbe richiedere alcuni minuti):

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

   L'output è simile al seguente:

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

Assicurati che il job sia stato completato correttamente prima di passare alla sezione successiva.

Esegui il deployment di Triton

In questa sezione eseguirai il deployment di un container che utilizza Triton con il backend TensorRT-LLM per gestire il modello Gemma che vuoi utilizzare.

1. Crea il seguente manifest 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. Applica il manifest:

   kubectl apply -f deploy-triton-server.yaml
   

3. Attendi che il deployment sia disponibile:

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

4. Visualizza i log dal file manifest:

   kubectl logs -f -l app=gemma-server
   

   La risorsa di deployment avvia il server Triton e carica i dati del modello. Questa procedura può richiedere alcuni minuti (fino a 20 minuti o più). L'output è simile al seguente:

   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
   

Pubblica il modello

In questa sezione interagisci con il modello.

Configura il port forwarding

Esegui questo comando per configurare il port forwarding al modello:

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

L'output è simile al seguente:

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

Interagisci con il modello utilizzando curl

Questa sezione mostra come eseguire un test del fumo di base per verificare il modello ottimizzato per l'istruzione di cui è stato eseguito il deployment. Per semplicità, questa sezione descrive l'approccio di test utilizzando solo il modello ottimizzato per le istruzioni 2B.

In una nuova sessione del terminale, utilizza curl per chattare con il modello:

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

L'output seguente mostra un esempio di risposta del modello:

{
  "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"
}

Operazione riuscita: hai gestito correttamente Gemma utilizzando le GPU su GKE con Triton e TensorRT-LLM.

Risoluzione dei problemi

• Se ricevi il messaggio Empty reply from server, è possibile che il container non abbia completato il download dei dati del modello. Controlla di nuovo nei log del pod il messaggio Connected che indica che il modello è pronto per essere pubblicato.
• Se vedi Connection refused, verifica che il port forwarding sia attivo.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina le risorse di cui è stato eseguito il deployment

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse create in questa guida, esegui questo comando:

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

Passaggi successivi

• Scopri di più sulle GPU in GKE.
• Scopri come eseguire il deployment dei carichi di lavoro GPU in Autopilot.
• Scopri come eseguire il deployment dei carichi di lavoro delle GPU in Standard.
• Esplora il repository GitHub e la documentazione di TensorRT-LLM.
• Esplora Vertex AI Model Garden.
• Scopri come eseguire carichi di lavoro AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.