Halaman ini diterjemahkan oleh Cloud Translation API.

Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan vLLM

Autopilot Standard

Tutorial ini menunjukkan cara menayangkan model bahasa besar (LLM) Gemma menggunakan unit pemrosesan grafis (GPU) di Google Kubernetes Engine (GKE) dengan framework penayangan vLLM.

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

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

Sebelum menggunakan GPU di GKE, sebaiknya selesaikan jalur pembelajaran berikut:

Pelajari ketersediaan versi GPU saat ini
Pelajari GPU di GKE

vLLM

vLLM adalah framework penayangan LLM open source yang dioptimalkan secara maksimal dan dapat meningkatkan throughput penayangan di GPU, dengan fitur seperti:

Penerapan transformer yang dioptimalkan dengan PagedAttention
Pengelompokan berkelanjutan untuk meningkatkan throughput penayangan secara keseluruhan
Paralelisme tensor dan penayangan terdistribusi di beberapa GPU

Untuk mempelajari lebih lanjut, lihat dokumentasi vLLM.

Tujuan

Panduan ini ditujukan untuk pelanggan AI Generatif 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:

Siapkan lingkungan Anda dengan cluster GKE dalam mode Autopilot atau Standard.
Deploy penampung vLLM ke cluster Anda.
Gunakan vLLM 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.

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

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

Akses halaman izin model di Kaggle.com.
Verifikasi izin menggunakan akun Hugging Face Anda.
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:

Klik Profil Anda > Setelan > Token Akses.
Pilih New Token.
Tentukan Nama pilihan Anda dan Peran minimal `Baca.
Pilih Buat token.
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:

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

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

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.

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:

Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}

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 vLLM

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

Gemma 2 2B-it

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

Buat manifes vllm-2-2b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-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: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20240930_0945_RC00
        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"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        env:
        - 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
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Terapkan manifes:
```
kubectl apply -f vllm-2-2b-it.yaml
```

Gemma 2 9B-it

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

Buat manifes vllm-2-9b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-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: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20240930_0945_RC00
        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"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=2
        env:
        - 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
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Terapkan manifes:
```
kubectl apply -f vllm-2-9b-it.yaml
```

Gemma 2 27B-it

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

Buat manifes vllm-2-27b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-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: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20240930_0945_RC00
        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"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=4
        env:
        - 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
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Terapkan manifes:
```
kubectl apply -f vllm-2-27b-it.yaml
```

Pod di cluster mendownload bobot model dari Hugging Face dan memulai mesin penayangan.

Tunggu hingga Deployment tersedia:

kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment

Lihat log dari Deployment yang sedang berjalan:

kubectl logs -f -l app=gemma-server

Resource Deployment mendownload data model. Proses ini dapat memerlukan waktu beberapa menit. Outputnya mirip dengan hal berikut ini:

INFO 01-26 19:02:54 model_runner.py:689] Graph capturing finished in 4 secs.
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)

Pastikan model didownload sepenuhnya sebelum melanjutkan ke bagian berikutnya.

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 yang telah dilatih sebelumnya atau disesuaikan dengan petunjuk yang di-deploy. Agar lebih mudah, bagian ini menjelaskan pendekatan pengujian hanya menggunakan model Gemma 2 yang disesuaikan dengan instruksi (2-2B-it).

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
{
    "prompt": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "temperature": 0.90,
    "top_p": 1.0,
    "max_tokens": 128
}
EOF

Output berikut menunjukkan contoh respons model:

{"predictions":["Prompt:\n<start_of_turn>user\nI'm new to coding. If you could only recommend one programming language to start with, what would it be and why?<end_of_turn>\nOutput:\n**Python** is an excellent choice for beginners due to the following reasons:\n\n* **Clear and simple syntax:** Python boasts a simple and straightforward syntax that makes it easy to learn the fundamentals of programming.\n* **Extensive libraries and modules:** Python comes with a vast collection of libraries and modules that address various programming tasks, including data manipulation, machine learning, and web development.\n* **Large and supportive community:** Python has a vibrant and active community that offers resources, tutorials, and support to help you along your journey.\n* **Cross-platform compatibility:** Python can be run on various platforms, including Windows, macOS, and"]}

(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

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: "vllm"
        - 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

Terapkan manifes:
```
kubectl apply -f gradio.yaml
```

Tunggu hingga deployment tersedia:

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

Menggunakan antarmuka chat

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.
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.
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 vLLM 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 repositori GitHub dan dokumentasi vLLM.
Jelajahi Vertex AI Model Garden.
Temukan cara menjalankan workload AI/ML yang dioptimalkan dengan kemampuan orkestrasi platform GKE.

Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan vLLM

Latar belakang

Gemma

GPU

vLLM

Tujuan

Sebelum memulai

Check for the roles

Grant the roles

Mendapatkan akses ke model

Menandatangani perjanjian izin lisensi

Membuat token akses

Menyiapkan lingkungan Anda

Membuat dan mengonfigurasi resource Google Cloud

Membuat cluster dan node pool GKE

Autopilot

Standard

Gemma 2 2B

Gemma 2 9B

Gemma 2 27B

Membuat secret Kubernetes untuk kredensial Hugging Face

Men-deploy vLLM

Gemma 2 2B-it

Gemma 2 9B-it

Gemma 2 27B-it

Menayangkan model

Menyiapkan penerusan port

Berinteraksi dengan model menggunakan curl

(Opsional) Berinteraksi dengan model melalui antarmuka chat Gradio

Men-deploy antarmuka chat

Menggunakan antarmuka chat

Memecahkan masalah

Pembersihan

Menghapus resource yang di-deploy

Langkah selanjutnya