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

Questo tutorial mostra come eseguire il deployment e pubblicare un modello linguistico di grandi dimensioni (LLM) Gemma utilizzando le GPU su Google Kubernetes Engine (GKE) con lo stack di pubblicazione NVIDIA Triton e TensorRT-LLM. Ciò fornisce una base per comprendere ed esplorare il deployment pratico di LLM per l'inferenza in un ambiente Kubernetes gestito. Esegui il deployment di un container predefinito con Triton e TensorRT-LLM in GKE. Configura anche GKE per caricare i pesi di Gemma 2B e 7B.

Questo tutorial è rivolto a ingegneri di machine learning (ML), amministratori e operatori di piattaforme e a specialisti di dati e AI interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la gestione di LLM su hardware GPU H100, A100 e L4. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti, consulta Ruoli e attività comuni degli utenti di GKE Enterprise. Google Cloud

Se hai bisogno di una piattaforma di AI gestita unificata per creare e pubblicare rapidamente modelli ML in modo conveniente, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.

Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questa guida.

Gemma

Gemma è un insieme di modelli di intelligenza artificiale (AI) generativa, leggeri e disponibili pubblicamente rilasciati con una licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione nelle tue applicazioni, hardware, dispositivi mobili o servizi ospitati. 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 ti consentono di accelerare carichi di lavoro specifici in esecuzione sui tuoi nodi, come machine learning ed elaborazione di dati. GKE offre una gamma di opzioni di tipo di macchina per la configurazione dei nodi, inclusi i tipi di macchina con GPU NVIDIA H100, L4 e A100.

TensorRT-LLM

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

  • Implementazione ottimizzata del transformer con fusioni di livelli, memorizzazione nella cache dell'attivazione, riutilizzo del buffer di memoria e PagedAttention
  • Batching in volo o continuo per migliorare la velocità effettiva complessiva della pubblicazione
  • Parallelismo dei tensori e parallelismo della pipeline per la pubblicazione distribuita su più GPU
  • Quantizzazione (FP16, FP8, INT8)

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

Triton

NVIDIA Triton Inference Server è un server di inferenza open source per applicazioni AI/ML. Triton supporta l'inferenza ad alte prestazioni sia su GPU NVIDIA che su 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
  • Ensemble o concatenamento di modelli
  • Batch statici, dinamici e continui o in volo di richieste di previsione

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

Obiettivi

  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. Utilizza Triton e TensorRT-LLM per pubblicare il modello Gemma 2B o 7B tramite curl.

Prima di iniziare

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

    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.

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

      Vai a IAM
    2. Seleziona il progetto.
    3. Fai clic su Concedi l'accesso.

    4. Nel campo Nuove entità, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.

    5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
    6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
    7. Fai clic su Salva.

prepara l'ambiente

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

Per configurare l'ambiente con Cloud Shell:

  1. Nella console Google Cloud , avvia una sessione di Cloud Shell facendo clic su Icona di attivazione di Cloud Shell Attiva Cloud Shell nella consoleGoogle 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
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=CLUSTER_NAME

    Sostituisci i seguenti valori:

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

Ottenere l'accesso al modello

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

Per utilizzare Gemma devi firmare il contratto di consenso. Segui queste istruzioni:

  1. Accedi alla pagina del consenso del modello su Kaggle.com.
  2. Accedi a Kaggle, se non l'hai ancora fatto.
  3. Fai clic su Richiedi l'accesso.
  4. Nella sezione Scegli l'account per il consenso, seleziona Verifica tramite l'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, devi disporre di un token API Kaggle. Segui questi passaggi per generare un nuovo token se non ne hai già uno:

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

Viene scaricato un file denominato kaggle.json.

Carica il token di accesso su Cloud Shell

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

  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.

Creare e configurare risorse Google Cloud

Segui queste istruzioni per creare le risorse richieste.

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

Sostituisci i seguenti valori:

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

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

    Sostituisci i seguenti valori:

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

    La creazione del cluster potrebbe richiedere diversi minuti.

  2. Esegui questo comando per creare un node pool 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 un secret Kubernetes per le credenziali Kaggle

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

In Cloud Shell:

  1. Configura kubectl per comunicare con il cluster:

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

    Sostituisci i seguenti valori:

    • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
    • CLUSTER_NAME: il nome del tuo cluster.

  2. Crea un secret per archiviare le credenziali 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, crei 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, esegui un job Kubernetes per completare le seguenti attività:

  • Scarica i file del motore TensorRT-LLM e archiviali nel PersistentVolume che hai creato in precedenza.
  • Prepara i file di configurazione per il deployment del modello sul server Triton.

Un controller Job in Kubernetes crea uno o più pod e garantisce che eseguano correttamente un'attività specifica.

La seguente procedura può richiedere alcuni minuti.

Gemma 2B-it

Il motore TensorRT-LLM è creato a partire dal checkpoint PyTorch di Gemma 2B-it (ottimizzato per le istruzioni) di Gemma utilizzando l'attivazione bfloat16, la lunghezza della sequenza di input pari a 2048 e la lunghezza della sequenza di output pari a 1024, con GPU L4 come target. 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 del 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 (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 PyTorch di Gemma 7B-it (ottimizzato per le istruzioni) di Gemma che utilizza l'attivazione bfloat16, la lunghezza della sequenza di input pari a 1024 e la lunghezza della sequenza di output pari a 512, con GPU L4 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 del 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 (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 procedere alla sezione successiva.

Esegui il deployment di Triton

In questa sezione, esegui il deployment di un container che utilizza Triton con il backend TensorRT-LLM per pubblicare 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 manifest:

    kubectl logs -f -l app=gemma-server

    La risorsa di deployment avvia il server Triton e carica i dati del modello. Questa operazione 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.

Configurare 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 di fumo di base per verificare il modello ottimizzato per le istruzioni che hai implementato. Per semplicità, questa sezione descrive l'approccio di test utilizzando solo il modello ottimizzato con l'istruzione 2B.

In una nuova sessione del terminale, utilizza curl per chattare con il tuo 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"
}

Risoluzione dei problemi

  • Se visualizzi il messaggio Empty reply from server, è possibile che il container non abbia completato il download dei dati del modello. Controlla di nuovo i log del pod per il messaggio Connected che indica che il modello è pronto per essere pubblicato.
  • Se visualizzi Connection refused, verifica che l'inoltro delle porte 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 che hai creato in questa guida, esegui questo comando:

gcloud container clusters delete CLUSTER_NAME \
    --region=REGION

Sostituisci i seguenti valori:

  • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
  • CLUSTER_NAME: il nome del tuo cluster.

Passaggi successivi