Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan Triton dan TensorRT-LLM

Autopilot Standard

Tutorial ini menunjukkan cara menyajikan model bahasa besar (LLM) Gemma menggunakan unit pemrosesan grafis (GPU) di Google Kubernetes Engine (GKE) dengan stack penayangan NVIDIA Triton dan TensorRT-LLM. Dalam tutorial ini, Anda mendownload petunjuk parameter 2B dan 7B yang disesuaikan dengan model Gemma dan men-deploy-nya di cluster GKE Autopilot atau Standard menggunakan container yang menjalankan Triton dan TensorRT-LLM.

Panduan ini adalah titik awal yang bagus jika Anda membutuhkan kontrol terperinci, skalabilitas, ketahanan, portabilitas, dan efektivitas biaya Kubernetes terkelola saat men-deploy dan menyalurkan workload AI/ML Anda. Jika Anda memerlukan platform AI terkelola terpadu untuk membangun dan menyajikan model ML dengan cepat dan hemat biaya, sebaiknya coba solusi deployment Vertex AI kami.

Latar belakang

Dengan menyajikan Gemma menggunakan GPU di GKE bersama Triton dan TensorRT-LLM, Anda dapat menerapkan solusi layanan inferensi yang tangguh dan siap produksi dengan semua manfaat Kubernetes terkelola, termasuk skalabilitas yang efisien dan ketersediaan yang lebih tinggi. Bagian ini menjelaskan teknologi utama yang digunakan dalam panduan ini.

Gemma

Gemma adalah serangkaian model kecerdasan buatan (AI) generatif dan ringan yang tersedia secara terbuka yang dirilis dengan lisensi terbuka. Model AI ini tersedia untuk berjalan di aplikasi, hardware, perangkat seluler, atau layanan yang dihosting. Anda dapat menggunakan model Gemma untuk pembuatan teks, tetapi Anda juga dapat menyesuaikan model ini untuk tugas khusus.

Untuk mempelajari lebih lanjut, lihat dokumentasi Gemma.

GPU

GPU memungkinkan Anda mempercepat workload tertentu yang berjalan di node Anda, seperti machine learning dan pemrosesan data. GKE menyediakan berbagai opsi jenis mesin untuk konfigurasi node, termasuk jenis mesin dengan GPU NVIDIA H100, L4, dan A100.

Sebelum Anda menggunakan GPU di GKE, sebaiknya selesaikan jalur pembelajaran berikut:

Pelajari ketersediaan versi GPU saat ini
Pelajari GPU di GKE

TensorRT-LLM

NVIDIA TensorRT-LLM (TRT-LLM) adalah toolkit dengan Python API untuk menyusun solusi yang dioptimalkan guna menentukan LLM dan membangun mesin TensorRT yang melakukan inferensi secara efisien pada GPU NVIDIA. TensorRT-LLM mencakup fitur seperti:

Implementasi transformator yang dioptimalkan dengan fusi lapisan, caching aktivasi, penggunaan kembali buffer memori, dan PagedAttention
Pengelompokan berkelanjutan atau sedang berlangsung untuk meningkatkan throughput penayangan secara keseluruhan
Paralelisme tensor dan paralelisme pipeline untuk inferensi terdistribusi di beberapa GPU
kuantisasi (FP16, FP8, INT8)

Untuk mempelajari lebih lanjut, baca dokumentasi TensorRT-LLM.

Triton

NVIDIA Triton Inference Server adalah server inferensi open source untuk aplikasi AI/ML. Triton mendukung inferensi berperforma tinggi pada GPU dan CPU NVIDIA dengan backend yang dioptimalkan, termasuk TensorRT dan TensorRT-LLM. Triton mencakup fitur seperti:

Inferensi multi-node, multi-GPU
Eksekusi beberapa model serentak
Peranan atau perantaian model
Pengelompokan permintaan prediksi statis, dinamis, dan berkelanjutan atau sedang berlangsung

Untuk mempelajari lebih lanjut, baca dokumentasi Triton.

Tujuan

Panduan ini ditujukan bagi pelanggan AI Generatif yang menggunakan PyTorch, pengguna baru atau lama dari GKE, ML Engineers, engineer MLOps (DevOps), atau administrator platform yang tertarik menggunakan kemampuan orkestrasi container Kubernetes untuk menyalurkan LLM pada hardware GPU H100, A100, dan L4.

Di akhir panduan ini, Anda seharusnya dapat melakukan langkah-langkah berikut:

Siapkan lingkungan Anda dengan cluster GKE dalam mode Autopilot.
Deploy container dengan Triton dan TritonRT-LLM ke cluster Anda.
Gunakan Triton dan TensorRT-LLM untuk menyalurkan model Gemma 2B atau 7B melalui curl.

Sebelum memulai

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Enable the required API.

Enable the API

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Enable the required API.

Enable the API

Pastikan Anda memiliki peran berikut di project: roles/container.admin, roles/iam.serviceAccountAdmin
Memeriksa peran
1. Di konsol Google Cloud, buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Di kolom Akun utama, cari baris yang berisi alamat email Anda.
  
  Jika alamat email Anda tidak ada di kolom tersebut, berarti Anda tidak memiliki peran apa pun.
4. Di kolom Peran untuk baris yang berisi alamat email Anda, periksa apakah daftar peran menyertakan peran yang diperlukan.
Memberikan peran
1. Di konsol Google Cloud, buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Klik Berikan akses.
4. Di kolom Akun utama baru, masukkan alamat email Anda.
5. Di daftar Pilih peran, pilih peran.
6. Untuk memberikan peran tambahan, klik Tambahkan peran lain, lalu tambahkan setiap peran tambahan.
7. Klik Simpan.

Buat akun Kaggle, jika Anda belum memilikinya.
Pastikan project Anda memiliki kuota yang cukup untuk GPU. Untuk mempelajari lebih lanjut, lihat artikel Tentang GPU dan Kuota alokasi.

Menyiapkan lingkungan Anda

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell dilengkapi dengan software bawaan yang akan Anda perlukan untuk tutorial ini, termasuk kubectl dan gcloud CLI.

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, ikuti langkah-langkah berikut:

Di konsol Google Cloud, luncurkan sesi Cloud Shell dengan mengklik Activate Cloud Shell di Google Cloud Console. Tindakan ini akan meluncurkan sesi di panel bawah Konsol Google Cloud.
Tetapkan variabel lingkungan default:
```
gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=triton
```
Ganti nilai berikut:
- PROJECT_ID: Project ID Google Cloud Anda.
- REGION: Region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.

Mendapatkan akses ke model

Untuk mendapatkan akses ke model Gemma, Anda harus login ke platform Kaggle, dan mendapatkan token API Kaggle.

Anda harus menandatangani perjanjian izin untuk menggunakan Gemma. Ikuti petunjuk berikut:

Akses halaman izin model di Kaggle.com.
Masuk ke Kaggle jika Anda belum melakukannya.
Klik Minta Akses.
Di bagian Choose Account for Consent, pilih Verify via Kaggle Account untuk menggunakan akun Kaggle Anda untuk mendapatkan izin.
Setujui Persyaratan dan Ketentuan model.

Membuat token akses

Untuk mengakses model melalui Kaggle, Anda memerlukan token API Kaggle. Ikuti langkah-langkah berikut untuk membuat token baru jika Anda belum memilikinya:

Di browser, buka setelan Kaggle.
Di bagian API, klik Buat Token Baru.

File bernama kaggle.json telah didownload.

Mengupload token akses ke Cloud Shell

Di Cloud Shell, upload token API Kaggle ke project Google Cloud Anda:

Di Cloud Shell, klik More > Upload.
Pilih File dan klik Choose Files.
Buka file kaggle.json.
Klik Upload.

Membuat dan mengonfigurasi resource Google Cloud

Ikuti petunjuk berikut untuk membuat materi yang diperlukan.

Membuat cluster GKE dan node pool

Anda dapat menyalurkan Gemma pada GPU dalam GKE Autopilot atau cluster Standar. Sebaiknya gunakan cluster Autopilot untuk mendapatkan pengalaman Kubernetes yang terkelola sepenuhnya. Untuk memilih mode operasi GKE yang paling sesuai dengan beban kerja Anda, lihat Memilih mode operasi GKE.

Autopilot

Jalankan perintah berikut di Cloud Shell:

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

GKE membuat cluster Autopilot dengan node CPU dan GPU seperti yang diminta oleh beban kerja yang di-deploy.

Standar

Di Cloud Shell, jalankan perintah berikut untuk membuat cluster Standar:

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

Pembuatan cluster memerlukan waktu beberapa menit.

Jalankan perintah berikut guna membuat kumpulan node untuk cluster Anda:

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 membuat satu kumpulan node yang berisi satu node GPU L4.

Membuat Rahasia Kubernetes untuk kredensial Kaggle

Dalam tutorial ini, Anda menggunakan Secret Kubernetes sebagai kredensial Kaggle.

Di Cloud Shell, lakukan hal berikut:

Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

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

Buat Rahasia untuk menyimpan kredensial Kaggle:

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

Membuat resource PersistentVolume untuk menyimpan checkpoint

Di bagian ini, Anda akan membuat PersistentVolume yang didukung oleh persistent disk untuk menyimpan checkpoint model.

Buat manifes trtllm_checkpoint_pv.yaml berikut:

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

Terapkan manifes:

kubectl apply -f trtllm_checkpoint_pv.yaml

Download file mesin TensorRT-LLM untuk Gemma

Di bagian ini, Anda akan menjalankan Job untuk mendownload file mesin TensorRT-LLM dan menyimpan file di PersistentVolume yang Anda buat sebelumnya. Tugas ini juga menyiapkan file konfigurasi untuk men-deploy model di server Triton pada langkah berikutnya. Proses ini bisa memakan waktu beberapa menit.

Gemma 2B-it

Mesin TensorRT-LLM dibuat dari checkpoint PyTorch Gemma 2B-it (instruksi disesuaikan) Gemma menggunakan aktivasi bfloat16, panjang urutan input=2048, dan panjang urutan output=1024 GPU L4 yang ditargetkan. Anda dapat men-deploy model pada satu GPU L4.

Buat manifes job-download-gemma-2b.yaml berikut:

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"

Terapkan manifes:

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

Lihat log untuk Pekerjaan:

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

Output dari log mirip dengan yang berikut ini:

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

Tunggu hingga Pekerjaan selesai:

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

Outputnya mirip dengan hal berikut ini:

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

Verifikasi Pekerjaan ini berhasil diselesaikan (proses ini mungkin membutuhkan waktu beberapa menit):
```
kubectl get job/data-loader-gemma-2b
```
Outputnya mirip dengan hal berikut ini:
```
NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-2b   1/1           ##s        #m##s
```

Gemma 7B-it

Mesin TensorRT-LLM dibuat dari checkpoint Gemma 7B-it (instruksi disesuaikan) PyTorch checkpoint Gemma menggunakan aktivasi bfloat16, panjang urutan input=1024, dan panjang urutan output=512 GPU L4 yang ditargetkan. Anda dapat men-deploy model pada satu GPU L4.

Buat manifes job-download-gemma-7b.yaml berikut:

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"

Terapkan manifes:

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

Lihat log untuk Pekerjaan:

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

Output dari log mirip dengan yang berikut ini:

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

Tunggu hingga Pekerjaan selesai:

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

Outputnya mirip dengan hal berikut ini:

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

Verifikasi Pekerjaan ini berhasil diselesaikan (proses ini mungkin membutuhkan waktu beberapa menit):
```
kubectl get job/data-loader-gemma-7b
```
Outputnya mirip dengan hal berikut ini:
```
NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-7b   1/1           ##s        #m##s
```

Pastikan Tugas berhasil diselesaikan sebelum melanjutkan ke bagian berikutnya.

Deploy Triton

Di bagian ini, Anda akan men-deploy container yang menggunakan Triton dengan backend TensorRT-LLM untuk menyalurkan model Gemma yang ingin digunakan.

Buat manifes deploy-triton-server.yaml berikut:

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

Terapkan manifes:

kubectl apply -f deploy-triton-server.yaml

Tunggu hingga deployment tersedia:

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

Lihat log dari manifes:

kubectl logs -f -l app=gemma-server

Resource deployment akan meluncurkan server Triton dan memuat data model. Proses ini memerlukan waktu beberapa menit (hingga 20 menit atau lebih lama). Outputnya mirip dengan yang berikut ini:

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

Menyalurkan model

Di bagian ini, Anda akan berinteraksi dengan model.

Menyiapkan penerusan port

Jalankan perintah berikut untuk menyiapkan penerusan port ke model:

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

Outputnya mirip dengan hal berikut ini:

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

Berinteraksi dengan model menggunakan curl

Bagian ini menunjukkan cara melakukan uji asap dasar untuk memverifikasi model yang telah disesuaikan dalam petunjuk yang di-deploy. Untuk mempermudah, bagian ini menjelaskan pendekatan pengujian hanya menggunakan model yang disesuaikan dengan instruksi 2B.

Pada sesi terminal baru, gunakan curl untuk melakukan chat dengan model Anda:

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

Output berikut menunjukkan contoh respons model:

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

Memecahkan masalah

Jika Anda mendapatkan pesan Empty reply from server, penampung mungkin belum selesai mendownload data model. Periksa log Pod lagi untuk menemukan pesan Connected yang menunjukkan bahwa model siap ditayangkan.
Jika Anda melihat Connection refused, pastikan penerusan port aktif.

Pembersihan

Agar tidak dikenakan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource-nya.

Menghapus resource yang di-deploy

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang Anda buat dalam panduan ini, jalankan perintah berikut:

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

Langkah selanjutnya

Pelajari GPU di GKE lebih lanjut.
Pelajari cara men-deploy workload GPU dalam mode Autopilot.
Pelajari cara men-deploy workload GPU dalam Standar.
Pelajari repositori GitHub dan dokumentasi TensorRT-LLM.
Jelajahi Model Garden Vertex AI.
Temukan cara menjalankan workload AI/ML yang dioptimalkan dengan kemampuan orkestrasi platform GKE.

Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan Triton dan TensorRT-LLM

Latar belakang

Gemma

GPU

TensorRT-LLM

Triton

Tujuan

Sebelum memulai

Memeriksa peran

Memberikan peran

Menyiapkan lingkungan Anda

Mendapatkan akses ke model

Tanda tangani perjanjian izin lisensi

Membuat token akses

Mengupload token akses ke Cloud Shell

Membuat dan mengonfigurasi resource Google Cloud

Membuat cluster GKE dan node pool

Autopilot

Standar

Membuat Rahasia Kubernetes untuk kredensial Kaggle

Membuat resource PersistentVolume untuk menyimpan checkpoint

Download file mesin TensorRT-LLM untuk Gemma

Gemma 2B-it

Gemma 7B-it

Deploy Triton

Menyalurkan model

Menyiapkan penerusan port

Berinteraksi dengan model menggunakan curl

Memecahkan masalah

Pembersihan

Menghapus resource yang di-deploy

Langkah selanjutnya