Halaman ini diterjemahkan oleh Cloud Translation API.

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

Autopilot Standard

Tutorial ini menunjukkan cara menayangkan model bahasa besar (LLM) Gemma menggunakan unit pemrosesan grafis (GPU) di Google Kubernetes Engine (GKE), menggunakan stack penayangan Triton dan TensorRT-LLM NVIDIA untuk inferensi berbasis GPU yang efisien dengan orkestrasi Kubernetes. Dalam tutorial ini, Anda akan mendownload model Gemma yang disesuaikan dengan petunjuk parameter 2B dan 7B, lalu men-deploynya di cluster GKE Autopilot atau Standard menggunakan penampung yang menjalankan Triton dan TensorRT-LLM.

Panduan ini adalah titik awal yang baik jika Anda memerlukan kontrol terperinci, skalabilitas, ketahanan, portabilitas, dan efisiensi biaya Kubernetes terkelola saat men-deploy dan menayangkan beban kerja AI/ML. Jika Anda memerlukan platform AI terkelola terpadu untuk membuat dan menayangkan model ML dengan cepat dan hemat biaya, sebaiknya Anda mencoba solusi deployment Vertex AI kami.

Latar belakang

Dengan menayangkan Gemma menggunakan GPU di GKE dengan Triton dan TensorRT-LLM, Anda dapat menerapkan solusi penayangan inferensi yang andal 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 yang ringan dan tersedia secara terbuka yang dirilis dengan lisensi terbuka. Model AI ini tersedia untuk dijalankan 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, 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 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 mem-build mesin TensorRT yang melakukan inferensi secara efisien di GPU NVIDIA. TensorRT-LLM mencakup fitur seperti:

Implementasi transformer yang dioptimalkan dengan penggabungan lapisan, penyimpanan dalam cache aktivasi, penggunaan kembali buffering memori, dan PagedAttention
Pengelompokan berkelanjutan atau dalam proses untuk meningkatkan throughput penayangan secara keseluruhan
Paralelisme tensor dan paralelisme pipeline untuk penayangan terdistribusi di beberapa GPU
Kuantisasi (FP16, FP8, INT8)

Untuk mempelajari lebih lanjut, lihat 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 menyertakan fitur seperti:

Inferensi multi-GPU, multi-node
Eksekusi beberapa model serentak
Penggabungan atau penyambungan model
Pengelompokan permintaan prediksi yang statis, dinamis, dan berkelanjutan atau dalam proses

Untuk mempelajari lebih lanjut, lihat dokumentasi Triton.

Tujuan

Panduan ini ditujukan untuk pelanggan Generative AI yang menggunakan PyTorch, pengguna baru atau lama GKE, Engineer ML, engineer MLOps (DevOps), atau administrator platform yang tertarik untuk menggunakan kemampuan orkestrasi penampung Kubernetes untuk menayangkan LLM di hardware GPU H100, A100, dan L4.

Di akhir panduan ini, Anda akan 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 menayangkan model Gemma 2B atau 7B melalui curl.

Sebelum memulai

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.

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

Buka pemilih project

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

Aktifkan API yang diperlukan.

Mengaktifkan API

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

Buka pemilih project

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

Aktifkan API yang diperlukan.

Mengaktifkan API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.
Grant the roles
1. In the Google Cloud console, go to the IAM page.
  Buka IAM
2. Pilih project.
3. Klik Berikan akses.
4. Di kolom New principals, masukkan ID pengguna Anda. Ini biasanya adalah alamat email untuk Akun Google.
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 memadai untuk GPU. Untuk mempelajari lebih lanjut, lihat 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 telah diinstal dengan software 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 Aktifkan Cloud Shell di konsol Google Cloud. 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 Kaggle API.

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

Akses halaman izin model di Kaggle.com.
Login ke Kaggle jika Anda belum melakukannya.
Klik Minta Akses.
Di bagian Pilih Akun untuk Izin, pilih Verifikasi melalui Akun Kaggle untuk menggunakan akun Kaggle Anda untuk izin.
Setujui Persyaratan dan Ketentuan model.

Membuat token akses

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

Di browser, buka setelan Kaggle.
Di bagian API, klik Create New Token.

File bernama kaggle.json didownload.

Mengupload token akses ke Cloud Shell

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

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

Membuat dan mengonfigurasi resource Google Cloud

Ikuti petunjuk ini untuk membuat resource yang diperlukan.

Membuat cluster dan node pool GKE

Anda dapat menayangkan Gemma di GPU dalam cluster GKE Autopilot atau Standard. Sebaiknya gunakan cluster Autopilot untuk pengalaman Kubernetes yang dikelola sepenuhnya. Untuk memilih mode operasi GKE yang paling sesuai untuk workload 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.

Standard

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 mungkin memerlukan waktu beberapa menit.

Jalankan perintah berikut untuk membuat node pool 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 node pool yang berisi satu node GPU L4.

Membuat Secret Kubernetes untuk kredensial Kaggle

Dalam tutorial ini, Anda akan menggunakan Secret Kubernetes untuk 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 Secret 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

Mendownload file mesin TensorRT-LLM untuk Gemma

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

Gemma 2B-it

Mesin TensorRT-LLM dibuat dari checkpoint PyTorch Gemma 2B-it (instruction tuned) Gemma menggunakan aktivasi bfloat16, panjang urutan input=2048, dan panjang urutan output=1024 GPU L4 yang ditargetkan. Anda dapat men-deploy model di 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 Tugas:

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

Output dari log mirip dengan 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 Tugas 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

Pastikan Tugas berhasil diselesaikan (proses ini mungkin memerlukan 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 PyTorch Gemma 7B-it (instruction tuned) Gemma menggunakan aktivasi bfloat16, panjang urutan input=1024, dan panjang urutan output=512 GPU L4 yang ditargetkan. Anda dapat men-deploy model di 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 Tugas:

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

Output dari log mirip dengan 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 Tugas 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

Pastikan Tugas berhasil diselesaikan (proses ini mungkin memerlukan 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.

Men-deploy Triton

Di bagian ini, Anda akan men-deploy penampung yang menggunakan Triton dengan backend TensorRT-LLM untuk menayangkan model Gemma yang ingin Anda gunakan.

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 meluncurkan server Triton dan memuat data model. Proses ini dapat memerlukan waktu beberapa menit (hingga 20 menit atau lebih). 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

Menayangkan 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 pengujian smoke dasar untuk memverifikasi model pengaturan petunjuk yang di-deploy. Untuk memudahkan, bagian ini menjelaskan pendekatan pengujian hanya menggunakan model yang disesuaikan dengan petunjuk 2B.

Dalam 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, mungkin penampung 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 Anda aktif.

Pembersihan

Agar tidak perlu membayar 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.

Menghapus resource yang di-deploy

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang dibuat 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 di Autopilot.
Pelajari cara men-deploy workload GPU di Standard.
Pelajari repositori GitHub dan dokumentasi TensorRT-LLM.
Jelajahi Vertex AI Model Garden.
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

Check for the roles

Grant the roles

Menyiapkan lingkungan Anda

Mendapatkan akses ke model

Menandatangani perjanjian izin lisensi

Membuat token akses

Mengupload token akses ke Cloud Shell

Membuat dan mengonfigurasi resource Google Cloud

Membuat cluster dan node pool GKE

Autopilot

Standard

Membuat Secret Kubernetes untuk kredensial Kaggle

Membuat resource PersistentVolume untuk menyimpan checkpoint

Mendownload file mesin TensorRT-LLM untuk Gemma

Gemma 2B-it

Gemma 7B-it

Men-deploy Triton

Menayangkan model

Menyiapkan penerusan port

Berinteraksi dengan model menggunakan curl

Memecahkan masalah

Pembersihan

Menghapus resource yang di-deploy

Langkah selanjutnya