Menyajikan Gemma menggunakan TPU di GKE dengan JetStream

Tutorial ini menunjukkan cara menayangkan model bahasa besar (LLM) Gemma menggunakan Unit Pemrosesan Tensor (TPU) di Google Kubernetes Engine (GKE). Anda men-deploy container siap pakai dengan JetStream dan MaxText ke GKE. Anda juga mengonfigurasi GKE untuk memuat bobot Gemma 7B dari Cloud Storage saat runtime

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. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami referensikan dalam Google Cloud konten, lihat Peran dan tugas pengguna GKE umum.

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

• Mode Autopilot dan mode Standard
• Ketersediaan versi TPU saat ini dengan arsitektur sistem Cloud TPU
• TPU di GKE

Latar belakang

Bagian ini menjelaskan teknologi utama yang digunakan dalam tutorial 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.

TPU

TPU adalah sirkuit terintegrasi khusus aplikasi (ASIC) yang dikembangkan khusus oleh Google dan digunakan untuk mempercepat model machine learning dan AI yang dibuat menggunakan framework seperti TensorFlow, PyTorch, dan JAX.

Tutorial ini membahas cara menayangkan model Gemma 7B. GKE men-deploy model pada node TPUv5e host tunggal dengan topologi TPU yang dikonfigurasi berdasarkan persyaratan model untuk menyajikan perintah dengan latensi rendah.

JetStream

JetStream adalah framework penayangan inferensi open source yang dikembangkan oleh Google. JetStream memungkinkan inferensi berperforma tinggi, throughput tinggi, dan dioptimalkan untuk memori di TPU dan GPU. Framework ini menyediakan pengoptimalan performa lanjutan, termasuk teknik pengelompokan berkelanjutan dan kuantisasi, untuk memfasilitasi deployment LLM. JetStream memungkinkan penayangan PyTorch/XLA dan JAX TPU untuk mencapai performa yang optimal.

Untuk mempelajari lebih lanjut pengoptimalan ini, lihat repositori project JetStream PyTorch dan JetStream MaxText.

MaxText

MaxText adalah implementasi LLM JAX yang berperforma tinggi, skalabel, dan dapat disesuaikan, yang dibangun di atas library JAX open source seperti Flax, Orbax, dan Optax. Implementasi LLM khusus dekoder MaxText ditulis dalam Python. Hal ini memanfaatkan compiler XLA secara intensif untuk mencapai performa tinggi tanpa perlu membuat kernel kustom.

Untuk mempelajari lebih lanjut model dan ukuran parameter terbaru yang didukung MaxText, lihat repositori project MaxText.

Tujuan

1. Siapkan cluster GKE Autopilot atau Standard dengan topologi TPU yang direkomendasikan berdasarkan karakteristik model.
2. Deploy komponen JetStream di GKE.
3. Dapatkan dan publikasikan model yang disesuaikan dengan instruksi Gemma 7B.
4. Menyajikan dan berinteraksi dengan model yang dipublikasikan.

Arsitektur

Bagian ini menjelaskan arsitektur GKE yang digunakan dalam tutorial ini. Arsitektur ini terdiri dari cluster GKE Autopilot atau Standard yang menyediakan TPU dan menghosting komponen JetStream untuk men-deploy dan menyajikan model.

Diagram berikut menunjukkan komponen arsitektur ini:

Arsitektur ini mencakup komponen berikut:

• Cluster regional GKE Autopilot atau Standard.
• Dua node pool slice TPU host tunggal yang menghosting deployment JetStream.
• Komponen Service menyebarkan traffic masuk ke semua replika JetStream HTTP.
• JetStream HTTP adalah server HTTP yang menerima permintaan sebagai wrapper ke format yang diperlukan JetStream dan mengirimkannya ke klien GRPC JetStream.
• Maxengine adalah server JetStream yang melakukan inferensi dengan batch berkelanjutan.

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

Verify 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

Verify 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, roles/resourcemanager.projectIamAdmin

  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 person_add 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 add Tambahkan peran lain, lalu tambahkan setiap peran tambahan.
  7. Klik Simpan.
  • Pastikan Anda memiliki kuota yang cukup untuk delapan chip TPU v5e PodSlice Lite. Dalam tutorial ini, Anda akan menggunakan instance sesuai permintaan.
  • Buat akun Kaggle, jika Anda belum memilikinya.

  Mendapatkan akses ke model

  Untuk mendapatkan akses ke model Gemma untuk deployment ke GKE, Anda harus menandatangani perjanjian izin lisensi terlebih dahulu.

  Menandatangani perjanjian izin lisensi

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

  1. Akses halaman izin model Gemma di Kaggle.com.
  2. Login ke Kaggle jika Anda belum melakukannya.
  3. Klik Minta Akses.
  4. Di bagian Pilih Akun untuk Izin, pilih Verifikasi melalui Akun Kaggle untuk menggunakan akun Kaggle Anda untuk izin.
  5. 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:

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

  File bernama kaggle.json akan didownload.

  Menyiapkan lingkungan

  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 Activate Cloud Shell di konsolGoogle Cloud . Tindakan ini akan meluncurkan sesi di panel bawah konsol Google Cloud .

  2. 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 CLUSTER_NAME=CLUSTER_NAME
     export BUCKET_NAME=BUCKET_NAME
     export REGION=REGION
     export LOCATION=LOCATION
     export CLUSTER_VERSION=CLUSTER_VERSION
     

     Ganti nilai berikut:

     • PROJECT_ID: Google Cloud project ID Anda.
     • CLUSTER_NAME: nama cluster GKE Anda.
     • BUCKET_NAME: nama bucket Cloud Storage Anda. Anda tidak perlu menentukan awalan gs://.
     • REGION: region tempat cluster GKE, bucket Cloud Storage, dan node TPU Anda berada. Region ini berisi zona tempat jenis mesin TPU v5e tersedia (misalnya, us-west1, us-west4, us-central1, us-east1, us-east5, atau europe-west4). Untuk cluster Autopilot, pastikan Anda memiliki resource TPU v5e per zona yang memadai untuk region pilihan Anda.
     • (Khusus cluster Standard) LOCATION: zona tempat resource TPU tersedia (misalnya, us-west4-a). Untuk cluster Autopilot, Anda tidak perlu menentukan zona, hanya region.
     • CLUSTER_VERSION: versi GKE, yang harus mendukung jenis mesin yang ingin Anda gunakan. Perhatikan bahwa versi GKE default mungkin tidak tersedia untuk TPU target Anda. Untuk mengetahui daftar versi GKE minimum yang tersedia menurut jenis mesin TPU, lihat Ketersediaan TPU di GKE.

  Membuat dan mengonfigurasi resource Google Cloud

  Ikuti petunjuk berikut untuk membuat resource yang diperlukan.

  Membuat cluster GKE

  Anda dapat menyajikan Gemma di TPU 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} \
    --cluster-version=${CLUSTER_VERSION}
  

  Standar

  1. Buat cluster Standar GKE regional yang menggunakan Workload Identity Federation untuk GKE.

     gcloud container clusters create ${CLUSTER_NAME} \
         --enable-ip-alias \
         --machine-type=e2-standard-4 \
         --num-nodes=2 \
         --cluster-version=${CLUSTER_VERSION} \
         --workload-pool=${PROJECT_ID}.svc.id.goog \
         --location=${REGION}
     

     Pembuatan cluster mungkin memerlukan waktu beberapa menit.

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

     gcloud container node-pools create gemma-7b-tpu-nodepool \
       --cluster=${CLUSTER_NAME} \
       --machine-type=ct5lp-hightpu-8t \
       --project=${PROJECT_ID} \
       --num-nodes=2 \
       --region=${REGION} \
       --node-locations=${LOCATION}
     

     GKE membuat node pool TPU v5e dengan topologi 2x4 dan dua node.

  Membuat bucket Cloud Storage

  Jalankan perintah berikut di Cloud Shell:

  gcloud storage buckets create gs://${BUCKET_NAME} --location=${REGION}
  

  Tindakan ini akan membuat bucket Cloud Storage untuk menyimpan file model yang Anda download dari Kaggle.

  Upload token akses ke Cloud Shell

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

  1. Di Cloud Shell, klik more_vert Lainnya > Upload.
  2. Pilih File, lalu klik Pilih File.
  3. Buka file kaggle.json.
  4. Klik Upload.

  Buat Secret Kubernetes untuk 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 Secret untuk menyimpan kredensial Kaggle:

     kubectl create secret generic kaggle-secret \
         --from-file=kaggle.json
     

  Mengonfigurasi akses workload Anda menggunakan Workload Identity Federation for GKE

  Tetapkan ServiceAccount Kubernetes ke aplikasi dan konfigurasi ServiceAccount Kubernetes tersebut untuk bertindak sebagai akun layanan IAM.

  1. Buat akun layanan IAM untuk aplikasi Anda:

     gcloud iam service-accounts create wi-jetstream
     

  2. Tambahkan binding kebijakan IAM untuk akun layanan IAM Anda agar dapat mengelola Cloud Storage:

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role roles/storage.objectUser
     
     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role roles/storage.insightsCollectorService
     

  3. Izinkan ServiceAccount Kubernetes untuk meniru identitas akun layanan IAM dengan menambahkan binding kebijakan IAM antara kedua akun layanan tersebut. Dengan binding ini, ServiceAccount Kubernetes dapat bertindak sebagai akun layanan IAM:

     gcloud iam service-accounts add-iam-policy-binding wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
     

  4. Beri anotasi pada akun layanan Kubernetes dengan alamat email akun layanan IAM:

     kubectl annotate serviceaccount default \
         iam.gke.io/gcp-service-account=wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com
     

  Mengonversi checkpoint model

  Di bagian ini, Anda akan membuat Job untuk melakukan hal berikut:

  1. Download checkpoint Orbax dasar dari Kaggle.
  2. Upload titik pemeriksaan ke bucket Cloud Storage.
  3. Konversi checkpoint ke checkpoint yang kompatibel dengan MaxText.
  4. Batalkan pemindaian checkpoint yang akan digunakan untuk penayangan.

  Men-deploy Tugas konversi checkpoint model

  Ikuti petunjuk berikut untuk mendownload dan mengonversi file checkpoint model Gemma 7B. Tutorial ini menggunakan Tugas Kubernetes. Pengontrol Job di Kubernetes membuat satu atau beberapa Pod dan memastikan bahwa Pod tersebut berhasil menjalankan tugas tertentu.

  1. Buat manifes berikut sebagai job-7b.yaml.

     apiVersion: batch/v1
     kind: Job
     metadata:
       name: data-loader-7b
     spec:
       ttlSecondsAfterFinished: 30
       template:
         spec:
           restartPolicy: Never
           containers:
           - name: inference-checkpoint
             image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.4
             args:
             - -b=BUCKET_NAME
             - -m=google/gemma/maxtext/7b-it/2
             volumeMounts:
             - mountPath: "/kaggle/"
               name: kaggle-credentials
               readOnly: true
             resources:
               requests:
                 google.com/tpu: 8
               limits:
                 google.com/tpu: 8
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 2x4
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           volumes:
           - name: kaggle-credentials
             secret:
               defaultMode: 0400
               secretName: kaggle-secret
     

  2. Terapkan manifes:

     kubectl apply -f job-7b.yaml
     

  3. Tunggu hingga Pod yang menjadwalkan Tugas mulai berjalan:

     kubectl get pod -w
     

     Outputnya akan mirip dengan berikut ini, proses ini mungkin memerlukan waktu beberapa menit:

     NAME                  READY   STATUS              RESTARTS   AGE
     data-loader-7b-abcd   0/1     ContainerCreating   0          28s
     data-loader-7b-abcd   1/1     Running             0          51s
     

     Untuk cluster Autopilot, mungkin perlu waktu beberapa menit untuk menyediakan resource TPU yang diperlukan.

  4. Lihat log dari Job:

     kubectl logs -f jobs/data-loader-7b
     

     Setelah Tugas selesai, output-nya akan mirip dengan berikut ini:

     Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
     + echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items'
     
     Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
     

  Men-deploy JetStream

  Di bagian ini, Anda akan men-deploy container JetStream untuk menayangkan model Gemma.

  Ikuti petunjuk ini untuk men-deploy model yang di-tune untuk mengikuti perintah Gemma 7B. Tutorial ini menggunakan Deployment Kubernetes. Deployment adalah objek Kubernetes API yang memungkinkan Anda menjalankan beberapa replika Pod yang didistribusikan di antara node dalam cluster.

  1. Simpan manifes Deployment berikut sebagai jetstream-gemma-deployment.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: maxengine-server
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: maxengine-server
       template:
         metadata:
           labels:
             app: maxengine-server
         spec:
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 2x4
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           containers:
           - name: maxengine-server
             image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.2
             args:
             - model_name=gemma-7b
             - tokenizer_path=assets/tokenizer.gemma
             - per_device_batch_size=4
             - max_prefill_predict_length=1024
             - max_target_length=2048
             - async_checkpointing=false
             - ici_fsdp_parallelism=1
             - ici_autoregressive_parallelism=-1
             - ici_tensor_parallelism=1
             - scan_layers=false
             - weight_dtype=bfloat16
             - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
             - prometheus_port=PROMETHEUS_PORT
             ports:
             - containerPort: 9000
             resources:
               requests:
                 google.com/tpu: 8
               limits:
                 google.com/tpu: 8
           - name: jetstream-http
             image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
             ports:
             - containerPort: 8000
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: jetstream-svc
     spec:
       selector:
         app: maxengine-server
       ports:
       - protocol: TCP
         name: jetstream-http
         port: 8000
         targetPort: 8000
       - protocol: TCP
         name: jetstream-grpc
         port: 9000
         targetPort: 9000
     

     Manifes menetapkan properti utama berikut:

     • tokenizer_path: jalur ke tokenizer model Anda.
     • load_parameters_path: jalur di bucket Cloud Storage tempat checkpoint Anda disimpan.
     • per_device_batch_size: ukuran batch decoding per perangkat, dengan satu chip TPU sama dengan satu perangkat.
     • max_prefill_predict_length: panjang maksimum untuk pengisian otomatis saat melakukan autoregresi.
     • max_target_length: panjang urutan maksimum.
     • model_name: nama model (gemma-7b).
     • ici_fsdp_parallelism: jumlah shard untuk paralelisme data yang sepenuhnya di-shard (FSDP).
     • ici_tensor_parallelism: jumlah partisi untuk paralelisme tensor.
     • ici_autoregressive_parallelism: jumlah shard untuk paralelisme autoregresif.
     • prometheus_port: port untuk mengekspos metrik prometheus. Hapus argumen ini jika metrik tidak diperlukan.
     • scan_layers: flag boolean lapisan pemindaian (boolean).
     • weight_dtype: jenis data bobot (bfloat16).

  2. Terapkan manifes:

     kubectl apply -f jetstream-gemma-deployment.yaml
     

  3. Verifikasi Deployment:

     kubectl get deployment
     

     Outputnya mirip dengan hal berikut ini:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     maxengine-server                  2/2     2            2           ##s
     

     Untuk cluster Autopilot, mungkin perlu waktu beberapa menit untuk menyediakan resource TPU yang diperlukan.

  4. Lihat log server HTTP untuk memeriksa apakah model telah dimuat dan dikompilasi. Server mungkin memerlukan waktu beberapa menit untuk menyelesaikan operasi ini.

     kubectl logs deploy/maxengine-server -f -c jetstream-http
     

     Outputnya mirip dengan hal berikut ini:

     kubectl logs deploy/maxengine-server -f -c jetstream-http
     
     INFO:     Started server process [1]
     INFO:     Waiting for application startup.
     INFO:     Application startup complete.
     INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
     

  5. Lihat log MaxEngine dan verifikasi bahwa kompilasi telah selesai.

     kubectl logs deploy/maxengine-server -f -c maxengine-server
     

     Outputnya mirip dengan hal berikut ini:

     2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec
     2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------
     

  Menyajikan model

  Di bagian ini, Anda berinteraksi dengan model.

  Menyiapkan penerusan port

  Anda dapat mengakses Deployment JetStream melalui ClusterIP Service yang Anda buat pada langkah sebelumnya. Layanan ClusterIP hanya dapat dijangkau dari dalam cluster. Oleh karena itu, untuk mengakses Layanan dari luar cluster, selesaikan langkah-langkah berikut:

  Untuk membuat sesi penerusan port, jalankan perintah berikut:

  kubectl port-forward svc/jetstream-svc 8000:8000
  

  Berinteraksi dengan model menggunakan curl

  1. Pastikan Anda dapat mengakses server HTTP JetStream dengan membuka terminal baru dan menjalankan perintah berikut:

     curl --request POST \
     --header "Content-type: application/json" \
     -s \
     localhost:8000/generate \
     --data \
     '{
         "prompt": "What are the top 5 programming languages",
         "max_tokens": 200
     }'
     

     Permintaan awal dapat memerlukan waktu beberapa detik untuk diselesaikan karena pemanasan model. Outputnya mirip dengan hal berikut ini:

     {
         "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools"
     }
     

  (Opsional) Berinteraksi dengan model melalui antarmuka chat Gradio

  Di bagian ini, Anda akan membuat aplikasi chat web yang memungkinkan Anda berinteraksi dengan model yang dioptimalkan untuk perintah Anda.

  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: "512m"
                 memory: "512Mi"
               limits:
                 cpu: "1"
                 memory: "512Mi"
             env:
             - name: CONTEXT_PATH
               value: "/generate"
             - name: HOST
               value: "http://jetstream-svc:8000"
             - name: LLM_ENGINE
               value: "max"
             - 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 Preview on 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 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 dan ikuti perintahnya:

  gcloud container clusters delete ${CLUSTER_NAME} --region=${REGION}
  
  gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com
  
  gcloud storage rm --recursive gs://BUCKET_NAME
  

  Langkah berikutnya

  • Pelajari cara menjalankan model Gemma di GKE dan cara menjalankan workload AI/ML yang dioptimalkan dengan kemampuan orkestrasi platform GKE.
  • Pelajari lebih lanjut TPU di GKE.
  • Jelajahi repositori GitHub JetStream.
  • Jelajahi Vertex AI Model Garden.