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 men-deploy dan menyajikan model bahasa besar (LLM) Gemma menggunakan GPU di Google Kubernetes Engine (GKE) dengan stack penyajian NVIDIA Triton dan TensorRT-LLM. Hal ini memberikan dasar untuk memahami dan menjelajahi deployment LLM praktis untuk inferensi di lingkungan Kubernetes terkelola. Anda men-deploy container siap pakai dengan Triton dan TensorRT-LLM ke GKE. Anda juga mengonfigurasi GKE untuk memuat bobot Gemma 2B dan 7B.

Tutorial ini ditujukan untuk Engineer machine learning (ML), Admin dan operator platform, serta Spesialis Data dan AI yang tertarik untuk menggunakan kemampuan orkestrasi container Kubernetes dalam menayangkan LLM di hardware GPU H100, A100, dan L4. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami referensikan dalam konten, lihat Peran dan tugas pengguna GKE Enterprise umum. Google Cloud

Jika Anda memerlukan platform AI terkelola terpadu untuk membangun dan menayangkan model ML dengan cepat dan hemat biaya, sebaiknya coba solusi deployment Vertex AI kami.

Sebelum membaca halaman ini, pastikan Anda memahami hal-hal berikut:

Latar belakang

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

TensorRT-LLM

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

Implementasi transformer yang dioptimalkan dengan fusi lapisan, caching aktivasi, penggunaan ulang buffer memori, dan PagedAttention
Batching dalam proses atau berkelanjutan untuk meningkatkan throughput penayangan secara keseluruhan
Paralelisme tensor dan paralelisme pipeline untuk inferensi terdistribusi pada 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 di GPU dan CPU NVIDIA dengan backend yang dioptimalkan, termasuk TensorRT dan TensorRT-LLM. Triton mencakup fitur seperti:

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

Untuk mempelajari lebih lanjut, lihat dokumentasi Triton.

Tujuan

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

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.
  Buka IAM
2. Pilih project.
3. Klik Berikan akses.
4. Di kolom Akun utama baru, masukkan ID pengguna Anda. Biasanya berupa 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 cukup untuk GPU L4. 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 Activate Cloud Shell di konsolGoogle Cloud . Tindakan ini akan meluncurkan sesi di panel bawah konsol Google Cloud .
Tetapkan variabel lingkungan default:
```
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
```
Ganti nilai berikut:
- PROJECT_ID: Google Cloud project ID Anda.
- REGION: region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
- CLUSTER_NAME: nama cluster Anda.

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.
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 memberikan izin.
Setujui Persyaratan dan Ketentuan model.

Membuat token akses

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

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

File bernama kaggle.json file akan didownload.

Upload 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 Pilih File.
Buka file kaggle.json.
Klik Upload.

Membuat dan mengonfigurasi resource Google Cloud

Ikuti petunjuk berikut 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 mendapatkan pengalaman Kubernetes yang terkelola 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

Ganti nilai berikut:

PROJECT_ID: Google Cloud project ID Anda.
REGION: region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
CLUSTER_NAME: nama cluster Anda.

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 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
```
Ganti nilai berikut:
- PROJECT_ID: Google Cloud project ID Anda.
- REGION: region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
- CLUSTER_NAME: nama cluster Anda.
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.

Buat 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
```
Ganti nilai berikut:
- REGION: region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
- CLUSTER_NAME: nama cluster Anda.

Buat Secret untuk menyimpan kredensial Kaggle:

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

Buat resource PersistentVolume untuk menyimpan titik pemeriksaan

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 Kubernetes untuk menyelesaikan tugas berikut:

Download file mesin TensorRT-LLM dan simpan file di PersistentVolume yang Anda buat sebelumnya.
Siapkan file konfigurasi untuk men-deploy model di server Triton.

Pengontrol Job di Kubernetes membuat satu atau beberapa Pod dan memastikan bahwa Pod tersebut berhasil menjalankan tugas tertentu.

Proses berikut dapat memerlukan waktu beberapa menit.

Gemma 2B-it

Mesin TensorRT-LLM dibangun dari checkpoint PyTorch Gemma 2B-it (yang disesuaikan untuk perintah) Gemma menggunakan aktivasi bfloat16, panjang urutan input=2048, dan panjang urutan output=1024 yang menargetkan GPU L4. 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

Verifikasi bahwa Job 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 dibangun dari checkpoint PyTorch Gemma 7B-it (yang disesuaikan untuk mengikuti perintah) Gemma menggunakan aktivasi bfloat16, panjang urutan input=1024, dan panjang urutan output=512 yang ditargetkan untuk GPU L4. 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

Verifikasi bahwa Job 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 container yang menggunakan Triton dengan backend TensorRT-LLM untuk menyajikan 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

Melihat 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

Menyajikan model

Di bagian ini, Anda 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 cepat dasar untuk memverifikasi model yang di-deploy dan disesuaikan dengan petunjuk Anda. Untuk mempermudah, bagian ini hanya menjelaskan pendekatan pengujian menggunakan model yang disesuaikan dengan petunjuk 2B.

Dalam sesi terminal baru, gunakan curl untuk memulai percakapan 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 melihat 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 Anda buat dalam panduan ini, jalankan perintah berikut:

gcloud container clusters delete CLUSTER_NAME \
    --region=REGION

Ganti nilai berikut:

REGION: region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
CLUSTER_NAME: nama cluster Anda.

Langkah berikutnya

Pelajari lebih lanjut GPU di GKE.
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.
Pelajari 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 Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

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

Upload token akses ke Cloud Shell

Membuat dan mengonfigurasi resource Google Cloud

Membuat cluster dan node pool GKE

Autopilot

Standar

Buat Secret Kubernetes untuk kredensial Kaggle

Buat resource PersistentVolume untuk menyimpan titik pemeriksaan

Download file mesin TensorRT-LLM untuk Gemma

Gemma 2B-it

Gemma 7B-it

Men-deploy Triton

Menyajikan model

Menyiapkan penerusan port

Berinteraksi dengan model menggunakan curl

Memecahkan masalah

Pembersihan

Menghapus resource yang di-deploy

Langkah berikutnya

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