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 menayangkan model bahasa besar (LLM) Gemma menggunakan GPU di Google Kubernetes Engine (GKE) dengan stack penayangan Triton dan TensorRT-LLM NVIDIA. Hal ini memberikan dasar untuk memahami dan mempelajari deployment LLM praktis untuk inferensi di lingkungan Kubernetes terkelola. Anda men-deploy container yang telah dibuat sebelumnya 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 untuk spesialis Data dan AI yang tertarik menggunakan kemampuan orkestrasi penampung Kubernetes untuk menayangkan LLM di hardware GPU H100, A100, dan L4. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami referensikan dalam konten Google Cloud , lihat Peran dan tugas pengguna GKE Enterprise yang umum.

Jika Anda memerlukan platform AI terkelola terpadu untuk membuat 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, 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 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

Server Inferensi NVIDIA Triton 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 sedang berlangsung

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

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 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 diGoogle 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 CloudAnda.
- 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 Pilih File.
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

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

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 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 di Autopilot.
Pelajari cara men-deploy workload GPU di Standard.
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

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