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


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:

  1. Pelajari ketersediaan versi GPU saat ini
  2. 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:

  1. Siapkan lingkungan Anda dengan cluster GKE dalam mode Autopilot.
  2. Deploy container dengan Triton dan TritonRT-LLM ke cluster Anda.
  3. 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.

  • Aktifkan API yang diperlukan.

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

  • Aktifkan API yang diperlukan.

    Mengaktifkan 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:

  1. Di konsol Google Cloud, luncurkan sesi Cloud Shell dengan mengklik Ikon aktivasi Cloud Shell Activate Cloud Shell di Google Cloud Console. Tindakan ini akan meluncurkan sesi di panel bawah Konsol Google Cloud.

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

  1. Akses halaman izin model di Kaggle.com.
  2. Masuk ke Kaggle jika Anda belum melakukannya.
  3. Klik Minta Akses.
  4. Di bagian Choose Account for Consent, pilih Verify via Kaggle Account untuk menggunakan akun Kaggle Anda untuk mendapatkan izin.
  5. 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:

  1. Di browser, buka setelan Kaggle.
  2. 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:

  1. Di Cloud Shell, klik More > Upload.
  2. Pilih File dan klik Choose Files.
  3. Buka file kaggle.json.
  4. 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

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

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

  1. Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

    gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}
    
  2. 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.

  1. Buat manifes trtllm_checkpoint_pv.yaml berikut:

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: model-data
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 100G
  2. 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.

  1. 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"
  2. Terapkan manifes:

    kubectl apply -f job-download-gemma-2b.yaml
    
  3. 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'
    ...
    
  4. 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
    
  5. 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.

  1. 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"
  2. Terapkan manifes:

    kubectl apply -f job-download-gemma-7b.yaml
    
  3. 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'
    ...
    
  4. 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
    
  5. 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.

  1. 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
  2. Terapkan manifes:

    kubectl apply -f deploy-triton-server.yaml
    
  3. Tunggu hingga deployment tersedia:

    kubectl wait --for=condition=Available --timeout=900s deployment/triton-gemma-deployment
    
  4. 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