Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan Hugging Face TGI

Autopilot Standard

---

Tutorial ini menunjukkan cara menayangkan keluarga model terbuka Gemma model bahasa besar (LLM), menggunakan unit pemrosesan grafis (GPU) di Google Kubernetes Engine (GKE) dengan framework penayangan Text Generation Inference (TGI) dari Hugging Face.

Dalam tutorial ini, Anda akan mendownload model yang disesuaikan dengan petunjuk Gemma 2 (parameter 2B, 9B, dan 27B) atau model CodeGemma dari Hugging Face. Kemudian, Anda men-deploy model di cluster GKE Autopilot atau Standard menggunakan penampung yang menjalankan TGI.

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

Dalam panduan ini, kami memperkenalkan model berikut:

• Gemma untuk pembuatan teks, Anda juga dapat menyesuaikan model ini agar berspesialisasi dalam melakukan tugas tertentu.
• CodeGemma adalah kumpulan model ringan yang canggih dan dapat melakukan berbagai tugas coding seperti penyelesaian kode isi bagian tengah, pembuatan kode, pemahaman bahasa alami, penalaran matematika, dan mengikuti petunjuk.

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:

1. Pelajari ketersediaan versi GPU saat ini
2. Pelajari GPU di GKE

Inferensi Pembuatan Teks (TGI)

TGI adalah toolkit Hugging Face untuk men-deploy dan menayangkan LLM. TGI memungkinkan pembuatan teks berperforma tinggi untuk LLM open source populer, termasuk Gemma. TGI mencakup fitur seperti:

• Implementasi transformer yang dioptimalkan dengan Flash Attention dan PagedAttention
• Pengelompokan berkelanjutan untuk meningkatkan throughput penayangan secara keseluruhan
• Paralelisme tensor untuk inferensi yang lebih cepat di beberapa GPU

Untuk mempelajari lebih lanjut, lihat dokumentasi TGI.

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:

1. Siapkan lingkungan Anda dengan cluster GKE dalam mode Autopilot.
2. Deploy TGI ke cluster Anda.
3. Gunakan TGI untuk menayangkan model Gemma 2 melalui curl dan antarmuka chat web.

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.

  Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

  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.

  Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

  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 Hugging Face, jika Anda belum memilikinya.
• Pastikan project Anda memiliki kuota yang memadai untuk GPU. Untuk mempelajari lebih lanjut, lihat Tentang GPU dan Kuota alokasi.

Mendapatkan akses ke model

Untuk mendapatkan akses ke model Gemma untuk di-deploy ke GKE, Anda harus menandatangani perjanjian izin lisensi terlebih dahulu, lalu membuat token akses Hugging Face.

Menandatangani perjanjian izin lisensi

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

1. Akses halaman izin model di Kaggle.com.
2. Verifikasi izin menggunakan akun Hugging Face Anda.
3. Setujui persyaratan model.

Membuat token akses

Untuk mengakses model melalui Hugging Face, Anda memerlukan token Hugging Face.

Ikuti langkah-langkah berikut untuk membuat token baru jika Anda belum memilikinya:

1. Klik Profil Anda > Setelan > Token Akses.
2. Pilih New Token.
3. Tentukan Nama pilihan Anda dan Peran minimal Read.
4. Pilih Buat token.
5. Salin token yang dihasilkan ke papan klip Anda.

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:

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

2. Tetapkan variabel lingkungan default:

   gcloud config set project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export REGION=REGION
   export CLUSTER_NAME=tgi
   export HF_TOKEN=HF_TOKEN
   

   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.
   • HF_TOKEN: Token Hugging Face yang Anda buat sebelumnya.

Membuat dan mengonfigurasi resource Google Cloud

Ikuti petunjuk ini untuk membuat resource yang diperlukan.

Catatan: Anda mungkin perlu membuat reservasi kapasitas untuk penggunaan beberapa akselerator. Untuk mempelajari cara mereservasi dan menggunakan resource yang direservasi, lihat Menggunakan resource zona yang direservasi.

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

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

Standard

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

   gcloud container clusters create ${CLUSTER_NAME} \
     --project=${PROJECT_ID} \
     --region=${REGION} \
     --workload-pool=${PROJECT_ID}.svc.id.goog \
     --release-channel=rapid \
     --num-nodes=1
   

   Pembuatan cluster mungkin memerlukan waktu beberapa menit.

2. Jalankan perintah berikut untuk membuat node pool untuk cluster Anda:

   Gemma 2 2B

   gcloud container node-pools create gpupool \
     --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
     --project=${PROJECT_ID} \
     --location=${REGION} \
     --node-locations=${REGION}-a \
     --cluster=${CLUSTER_NAME} \
     --machine-type=g2-standard-8 \
     --num-nodes=1
   

   GKE membuat satu node pool yang berisi GPU L4 untuk setiap node.

   Gemma 2 9B

   gcloud container node-pools create gpupool \
     --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
     --project=${PROJECT_ID} \
     --location=${REGION} \
     --node-locations=${REGION}-a \
     --cluster=${CLUSTER_NAME} \
     --machine-type=g2-standard-24 \
     --num-nodes=1
   

   GKE membuat satu node pool yang berisi dua GPU L4 untuk setiap node.

   Gemma 2 27B

   gcloud container node-pools create gpupool \
     --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \
     --project=${PROJECT_ID} \
     --location=${REGION} \
     --node-locations=${REGION}-a \
     --cluster=${CLUSTER_NAME} \
     --machine-type=g2-standard-48 \
     --num-nodes=1
   

   GKE membuat satu node pool yang berisi empat GPU L4 untuk setiap node.

Membuat secret Kubernetes untuk kredensial Hugging Face

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 Secret Kubernetes yang berisi token Hugging Face:

   kubectl create secret generic hf-secret \
     --from-literal=hf_api_token=${HF_TOKEN} \
     --dry-run=client -o yaml | kubectl apply -f -
   

Men-deploy TGI

Di bagian ini, Anda akan men-deploy penampung TGI untuk menayangkan model Gemma yang ingin Anda gunakan.

Gemma 2 2B-it

Ikuti petunjuk ini untuk men-deploy model yang disesuaikan dengan petunjuk Gemma 2B.

1. Buat manifes tgi-2-2b-it.yaml berikut:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-2b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "2"
               memory: "10Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: "1"
             limits:
               cpu: "2"
               memory: "10Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: "1"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '1'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-2b-it
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: hf-secret
                 key: hf_api_token
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
         volumes:
         - name: dshm
           emptyDir:
             medium: Memory
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 8000

2. Terapkan manifes:

   kubectl apply -f tgi-2-2b-it.yaml
   

Gemma 2 9B-it

Ikuti petunjuk ini untuk men-deploy model yang disesuaikan dengan petunjuk Gemma 9B.

1. Buat manifes tgi-2-9b-it.yaml berikut:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-9b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '2'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-9b-it
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: hf-secret
                 key: hf_api_token
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
         volumes:
         - name: dshm
           emptyDir:
             medium: Memory
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 8000

2. Terapkan manifes:

   kubectl apply -f tgi-2-9b-it.yaml
   

Gemma 2 27B-it

Ikuti petunjuk ini untuk men-deploy model yang disesuaikan dengan petunjuk instruksi Gemma 2 27B.

1. Buat manifes tgi-2-27b-it.yaml berikut:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-27b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
             limits:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '4'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-27b-it
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: hf-secret
                 key: hf_api_token
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
         volumes:
         - name: dshm
           emptyDir:
             medium: Memory
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 8000

2. Terapkan manifes:

   kubectl apply -f tgi-2-27b-it.yaml
   

CodeGemma 7B-it

Ikuti petunjuk ini untuk men-deploy model yang disesuaikan dengan petunjuk instruksi CodeGemma 7B.

1. Buat manifes tgi-codegemma-1.1-7b-it.yaml berikut:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: codegemma-1.1-7b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "2"
               memory: "25Gi"
               ephemeral-storage: "40Gi"
               nvidia.com/gpu: 2
             limits:
               cpu: "10"
               memory: "25Gi"
               ephemeral-storage: "40Gi"
               nvidia.com/gpu: 2
           args:
           - --model-id=$(MODEL_ID)
           - --num-shard=2
           env:
           - name: MODEL_ID
             value: google/codegemma-1.1-7b-it
           - name: PORT
             value: "8000"
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: hf-secret
                 key: hf_api_token
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
         volumes:
         - name: dshm
           emptyDir:
             medium: Memory
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
       - protocol: TCP
         port: 8000
         targetPort: 8000

2. Terapkan manifes:

   kubectl apply -f tgi-codegemma-1.1-7b-it.yaml
   

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/llm-service 8000:8000

Outputnya mirip dengan hal berikut ini:

Forwarding from 127.0.0.1:8000 -> 8000

Berinteraksi dengan model menggunakan curl

Bagian ini menunjukkan cara melakukan pengujian smoke dasar untuk memverifikasi model pretrained atau yang disesuaikan dengan petunjuk yang di-deploy. Untuk memudahkan, bagian ini menjelaskan pendekatan pengujian menggunakan model Gemma 2 yang disesuaikan dengan instruksi dan CodeGemma.

Gemma 2

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 http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

Output berikut menunjukkan contoh respons model:

{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

CodeGemma

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

USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

curl -s -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .generated_text
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 2000
    }
}
EOF

Output berikut menunjukkan contoh respons model:

def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

Berhasil: Anda telah berhasil menayangkan Gemma menggunakan GPU di GKE dengan TGI. Sekarang Anda dapat berinteraksi dengan model.

(Opsional) Berinteraksi dengan model melalui antarmuka chat Gradio

Di bagian ini, Anda akan mem-build aplikasi chat web yang memungkinkan Anda berinteraksi dengan model yang disesuaikan dengan petunjuk. Agar lebih mudah, bagian ini hanya menjelaskan pendekatan pengujian menggunakan model 2B-it.

Gradio adalah library Python yang memiliki wrapper ChatInterface yang membuat antarmuka pengguna untuk chatbot.

Men-deploy antarmuka chat

1. Di Cloud Shell, simpan manifes berikut sebagai gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gradio
     template:
       metadata:
         labels:
           app: gradio
       spec:
         containers:
         - name: gradio
           image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.3
           resources:
             requests:
               cpu: "250m"
               memory: "512Mi"
             limits:
               cpu: "500m"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service:8000"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "gemma"
           - name: USER_PROMPT
             value: "<start_of_turn>user\nprompt<end_of_turn>\n"
           - name: SYSTEM_PROMPT
             value: "<start_of_turn>model\nprompt<end_of_turn>\n"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio
   spec:
     selector:
       app: gradio
     ports:
       - protocol: TCP
         port: 8080
         targetPort: 7860
     type: ClusterIP

2. Terapkan manifes:

   kubectl apply -f gradio.yaml
   

3. Tunggu hingga deployment tersedia:

   kubectl wait --for=condition=Available --timeout=300s deployment/gradio
   

Menggunakan antarmuka chat

1. Jalankan perintah berikut di Cloud Shell:

   kubectl port-forward service/gradio 8080:8080
   

   Tindakan ini akan membuat penerusan port dari Cloud Shell ke layanan Gradio.

2. Klik tombol Web Preview yang dapat ditemukan di kanan atas taskbar Cloud Shell. Klik Pratinjau di Port 8080. Tab baru akan terbuka di browser Anda.

3. Berinteraksi dengan Gemma menggunakan antarmuka chat Gradio. Tambahkan perintah, lalu klik Kirim.

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 menggunakan Gemma dengan TGI di akselerator lain, termasuk GPU A100 dan H100, dengan melihat kode contoh di GitHub.
• Pelajari cara men-deploy workload GPU di Autopilot.
• Pelajari cara men-deploy workload GPU di Standard.
• Pelajari dokumentasi TGI.
• Jelajahi Vertex AI Model Garden.
• Temukan cara menjalankan workload AI/ML yang dioptimalkan dengan kemampuan orkestrasi platform GKE.