Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Menyajikan LLM di TPU multi-host dengan Ray dan TorchTPU

Autopilot Standard

Tutorial ini menunjukkan cara menyajikan model bahasa besar (LLM) Mixture-of-Experts (MoE) Gemma 4 26B-A4B-it dengan paralelisme tensor dan paralelisme pakar pada slice Cloud TPU multi-host di Google Kubernetes Engine (GKE) menggunakan Ray Serve LLM, vLLM, dan vLLM-TorchTPU.

Tutorial ini ditujukan untuk engineer machine learning (ML), admin dan operator platform, serta pakar data dan AI yang menggunakan orkestrasi container Kubernetes untuk menyajikan workload AI dan ML di slice TPU multi-host terdistribusi. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang dirujuk dalam konten Google Cloud , lihat Peran dan tugas pengguna GKE umum.

Sebelum memulai tutorial ini, pastikan Anda memahami hal-hal berikut:

Latar belakang

Bagian ini menjelaskan teknologi utama yang digunakan dalam tutorial ini.

TPU

Tensor Processing Unit (TPU) adalah akselerator yang dirancang khusus oleh Google untuk workload machine learning. Tutorial ini mendukung TPU Trillium (v6e) dan Ironwood (TPU7x). Dalam slice TPU multi-host, beberapa host TPU berkomunikasi langsung melalui jaringan Inter-Chip Interconnect (ICI) berkecepatan tinggi, yang menyediakan High Bandwidth Memory (HBM) gabungan dan komunikasi kolektif latensi rendah yang diperlukan untuk menyajikan model yang melebihi kapasitas memori satu chip atau host TPU.

vLLM dan TorchTPU

vLLM adalah mesin inferensi dan penyajian open source untuk LLM. TorchTPU adalah backend PyTorch open source untuk Cloud TPU yang menyediakan pengelolaan perangkat dan komunikasi kolektif melalui ICI.

vLLM-TorchTPU mendaftarkan plugin platform TPU dengan vLLM dan mengompilasi forward pass model PyTorch untuk Cloud TPU melalui TorchTPU dan compiler Accelerated Linear Algebra (XLA). Framework ini mendukung paralelisme tensor terdistribusi dan paralelisme pakar di seluruh slice TPU multi-host menggunakan Ray.

Ray Serve LLM di GKE

Ray Serve LLM menyediakan ingress HTTP yang kompatibel dengan OpenAI untuk endpoint /v1/chat/completions, /v1/completions, dan /v1/models serta mengorkestrasi deployment vLLM terdistribusi di GKE. Saat Anda mengaktifkan add-on Ray di GKE, operator KubeRay dan webhook TPU-nya akan memasukkan metadata topologi slice, nama host worker, dan variabel koordinasi TorchTPU ke setiap Pod worker TPU multi-host.

Ray Serve LLM menyediakan kemampuan berikut untuk inferensi TPU multi-host:

Penempatan slice berbasis topologi mencadangkan slice TPU multi-host yang utuh untuk setiap replika model saat Anda menentukan topologi TPU di kolom accelerator_config, yang menjadwalkan satu worker vLLM per perangkat TPU di seluruh slice.
Perutean yang peka terhadap awalan mengarahkan permintaan dengan perintah sistem bersama atau histori percakapan multi-turn ke replika yang sudah meng-cache blok key-value (KV) awalan tersebut di HBM TPU saat menyajikan di beberapa replika slice TPU.
Streaming token langsung mengelompokkan streaming token keluar di seluruh permintaan serentak dan melakukan streaming respons langsung dari replika model untuk mengurangi waktu hingga token pertama (TTFT) dan latensi antartoken (ITL).
Penskalaan otomatis replika berbasis konkurensi menskalakan replika model dalam penambahan slice utuh berdasarkan konkurensi permintaan yang sedang berlangsung.

Tujuan

Tutorial ini menunjukkan kepada Anda cara melakukan hal berikut:

Bangun image container yang melapisi Ray Serve di atas image dasar vLLM-TorchTPU bawaan dan kirim ke Artifact Registry.
Buat cluster GKE di Autopilot atau Standard di TPU Trillium (v6e) atau Ironwood (TPU7x).
Deploy resource kustom RayCluster multi-host dan verifikasi konfigurasi topologi TPU.
Deploy aplikasi LLM Ray Serve untuk menyajikan model google/gemma-4-26B-A4B-it dengan paralelisme tensor dan paralelisme pakar di seluruh slice TPU multi-host, atau deploy cluster dan aplikasi secara deklaratif dengan resource kustom RayService.
Kirim permintaan penemuan model dan penyelesaian chat yang kompatibel dengan OpenAI ke model yang disajikan.

Biaya

Dalam tutorial ini, Anda akan menggunakan komponen Google Cloudyang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga.

Setelah menyelesaikan tugas yang dijelaskan dalam tutorial ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

Mengaktifkan Artifact Registry API dan Google Kubernetes Engine API.

Mengaktifkan API

Untuk menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda menggunakan cluster zona, tetapkan compute/zone. Dengan menetapkan lokasi default, Anda dapat menghindari error di gcloud CLI seperti berikut: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan default yang Anda tetapkan.

Pastikan project Anda memiliki kuota yang cukup untuk kapasitas TPU Trillium (v6e) atau Ironwood (TPU7x) di zona yang Anda pilih. Untuk mengetahui informasi selengkapnya, lihat Kuota Cloud TPU.
Pastikan Anda memiliki akun Hugging Face, setujui persyaratan lisensi di halaman model google/gemma-4-26B-A4B-it, dan buat token akses Hugging Face dengan izin Read.
Pastikan akun Anda memiliki peran IAM berikut:
- Kubernetes Engine Admin (roles/container.admin)
- Artifact Registry Administrator (roles/artifactregistry.admin)

Menyiapkan lingkungan Anda

Dalam tutorial ini, Anda akan menggunakan Cloud Shell atau workstation lokal untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell telah diinstal dengan alat command line yang digunakan dalam tutorial ini, termasuk kubectl, docker, python3, dan gcloud CLI.

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, ikuti langkah-langkah berikut:

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 .

Buat clone repositori kubernetes-engine-samples dan ubah ke direktori contoh untuk tutorial ini:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/gke-ray/rayserve/llm/torchtpu

Buat dan aktifkan lingkungan virtual Python lokal dengan Ray CLI yang terinstal:

python3 -m venv ~/ray-env
source ~/ray-env/bin/activate
pip install "ray[default]==2.58.0"

Tetapkan variabel lingkungan untuk project dan cluster Google Cloud Anda:
```
export PROJECT_ID=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export REGION=REGION
export ZONE=ZONE
export ARTIFACT_REGISTRY=ARTIFACT_REGISTRY
export HF_TOKEN=HF_TOKEN
export IMAGE_URI=${REGION}-docker.pkg.dev/${PROJECT_ID}/${ARTIFACT_REGISTRY}/ray-torchtpu-vllm:latest
gcloud config set project ${PROJECT_ID}
```
Ganti kode berikut:
- PROJECT_ID: Project ID Google Cloud Anda.
- CLUSTER_NAME: nama cluster GKE Anda, seperti ray-serve-torchtpu-cluster.
- REGION: region tempat repositori Artifact Registry dan kapasitas TPU Anda berada, seperti us-east5.
- ZONE: zona tempat kapasitas TPU Anda tersedia, seperti us-east5-b. Untuk mengetahui informasi selengkapnya, lihat Memvalidasi ketersediaan TPU di GKE.
- ARTIFACT_REGISTRY: nama repositori Docker Artifact Registry Anda, seperti ray-torchtpu.
- HF_TOKEN: token akses Hugging Face Anda dengan izin Read.

Membangun image container kustom

Bangun image container yang menginstal paket ray[default,serve] di atas image dasar vLLM-TorchTPU bawaan, yang mencakup TorchTPU, vLLM, dan plugin vLLM-TorchTPU.

Tinjau Dockerfile di direktori kubernetes-engine-samples/ai-ml/gke-ray/rayserve/llm/torchtpu:

FROM vllm/vllm-torchtpu:v0.29.0

ENV HF_HOME=/dev/shm/huggingface
ENV RAY_SERVE_DEFAULT_HTTP_HOST=0.0.0.0

# Install wget for KubeRay health probes and pin Ray Serve and transformers
# versions compatible with vLLM 0.29.0 and multi-host TPUs.
RUN apt-get update && apt-get install -y --no-install-recommends wget \
    && rm -rf /var/lib/apt/lists/* \
    && pip install --no-cache-dir \
       "ray[default,serve] @ https://s3-us-west-2.amazonaws.com/ray-wheels/master/6b2b414bb7a5b4e2705ed9f4fdab9787b92f3b08/ray-3.0.0.dev0-cp312-cp312-manylinux2014_x86_64.whl" \
       "transformers>=5.18.0"

Penyajian TPU multi-host dengan Ray Serve LLM memerlukan Ray versi 2.56.0 atau yang lebih baru di TPU Trillium (v6e) dan Ray versi 2.58.0 atau yang lebih baru untuk penjadwalan per chiplet di Ironwood (TPU7x).

Buat repositori Docker Artifact Registry, bangun image container, dan kirim ke Artifact Registry:

gcloud artifacts repositories create ${ARTIFACT_REGISTRY} \
    --repository-format=docker \
    --location=${REGION} \
    --description="Ray and vLLM-TorchTPU container images"

gcloud auth configure-docker ${REGION}-docker.pkg.dev,us-docker.pkg.dev
docker build -t ${IMAGE_URI} .
docker push ${IMAGE_URI}

Membuat cluster GKE

Anda dapat menyajikan LLM di slice TPU multi-host dalam cluster GKE Autopilot atau Standard dengan add-on operator Ray terkelola yang diaktifkan.

Buat cluster GKE dan konfigurasikan kredensial untuk alat command line kubectl:
Autopilot
1. Buat cluster GKE Autopilot regional dengan add-on operator Ray yang diaktifkan:
  
  gcloud container clusters create-auto ${CLUSTER_NAME} \ --project=${PROJECT_ID} \ --region=${REGION} \ --cluster-version=1.36 \ --enable-ray-operator
  
  Saat Anda men-deploy resource kustom RayCluster atau RayService di langkah berikutnya, GKE Autopilot akan otomatis menyediakan node head CPU dan slice TPU multi-host yang sesuai dengan permintaan resource Pod dan pemilih node Anda.
2. Konfigurasi alat command line kubectl untuk berkomunikasi dengan cluster Anda:
  
  gcloud container clusters get-credentials ${CLUSTER_NAME} \ --project=${PROJECT_ID} \ --region=${REGION}
Standar
1. Buat cluster GKE Standard zona dengan node pool CPU untuk menghosting Pod head Ray, Streaming image, dan GKE Dataplane V2 yang diaktifkan:
  
  gcloud container clusters create ${CLUSTER_NAME} \ --project=${PROJECT_ID} \ --zone=${ZONE} \ --cluster-version=1.36 \ --machine-type=n2-standard-8 \ --num-nodes=1 \ --addons=RayOperator \ --enable-image-streaming \ --enable-dataplane-v2
  Catatan: Jika Anda mengelola sendiri KubeRay open source, bukan menggunakan add-on RayOperator GKE, instal KubeRay dan webhook TPU KubeRay versi 1.4.0 atau yang lebih baru untuk injeksi variabel lingkungan TorchTPU.
2. Konfigurasi alat command line kubectl untuk berkomunikasi dengan cluster Anda:
  
  gcloud container clusters get-credentials ${CLUSTER_NAME} \ --project=${PROJECT_ID} \ --zone=${ZONE}
3. Buat node pool slice TPU multi-host 16 perangkat dengan topologi 4x4 di empat host pada TPU Trillium (v6e) atau topologi 2x2x2 di dua host pada Ironwood (TPU7x):
  
  Trillium (v6e)
  gcloud container node-pools create tpu-multi-host-pool \ --project=${PROJECT_ID} \ --cluster=${CLUSTER_NAME} \ --zone=${ZONE} \ --machine-type=ct6e-standard-4t \ --tpu-topology=4x4 \ --num-nodes=4
  
  Ironwood (TPU7x)
  gcloud container node-pools create tpu-multi-host-pool \ --project=${PROJECT_ID} \ --cluster=${CLUSTER_NAME} \ --zone=${ZONE} \ --machine-type=tpu7x-standard-4t \ --tpu-topology=2x2x2 \ --num-nodes=2
  
  Tips: Untuk menggunakan pemesanan TPU tertentu, tambahkan flag --reservation-affinity=specific dan --reservation=RESERVATION_NAME ke perintah node-pools create, dengan RESERVATION_NAME adalah nama pemesanan TPU Anda. Untuk menggunakan Spot VM, tambahkan flag --spot.
Buat Secret Kubernetes dengan token Hugging Face Anda agar Pod Ray dapat melakukan autentikasi dengan Hugging Face saat mendownload bobot model:
```
kubectl create secret generic hf-secret \
    --from-literal=hf_api_token=${HF_TOKEN}
```

Men-deploy resource kustom RayCluster multi-host

Men-deploy resource kustom RayCluster yang menyediakan Pod head CPU, volume /dev/shm dalam memori untuk penyimpanan objek memori bersama Ray, dan grup worker TPU multi-host.

Tinjau manifes RayCluster untuk versi TPU Anda di repositori contoh:

Trillium (v6e)

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: ray-serve-torchtpu
spec:
  headGroupSpec:
    rayStartParams:
      num-cpus: "0"
    template:
      spec:
        containers:
        - name: ray-head
          image: ${IMAGE_URI}
          env:
          - name: HF_TOKEN
            valueFrom:
              secretKeyRef:
                name: hf-secret
                key: hf_api_token
          ports:
          - containerPort: 6379
            name: gcs
          - containerPort: 8265
            name: dashboard
          - containerPort: 10001
            name: client
          - containerPort: 8000
            name: serve
          resources:
            limits:
              cpu: "4"
              memory: "16Gi"
            requests:
              cpu: "4"
              memory: "16Gi"
  workerGroupSpecs:
  - groupName: v6e-16
    replicas: 1
    numOfHosts: 4
    template:
      spec:
        containers:
        - name: ray-worker
          image: ${IMAGE_URI}
          env:
          - name: HF_TOKEN
            valueFrom:
              secretKeyRef:
                name: hf-secret
                key: hf_api_token
          resources:
            limits:
              cpu: "64"
              memory: "200Gi"
              google.com/tpu: "4"
            requests:
              cpu: "64"
              memory: "200Gi"
              google.com/tpu: "4"
          volumeMounts:
          - mountPath: /dev/shm
            name: dshm
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 100Gi
        nodeSelector:
          cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
          cloud.google.com/gke-tpu-topology: 4x4

Ironwood (TPU7x)

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: ray-serve-torchtpu
spec:
  headGroupSpec:
    rayStartParams:
      num-cpus: "0"
    template:
      spec:
        containers:
        - name: ray-head
          image: ${IMAGE_URI}
          env:
          - name: HF_TOKEN
            valueFrom:
              secretKeyRef:
                name: hf-secret
                key: hf_api_token
          - name: RAY_TPU_RESOURCE_PER_CHIP
            value: "2"
          ports:
          - containerPort: 6379
            name: gcs
          - containerPort: 8265
            name: dashboard
          - containerPort: 10001
            name: client
          - containerPort: 8000
            name: serve
          resources:
            limits:
              cpu: "4"
              memory: "16Gi"
            requests:
              cpu: "4"
              memory: "16Gi"
  workerGroupSpecs:
  - groupName: tpu7x-16
    replicas: 1
    numOfHosts: 2
    resources:
      # Advertises 8 logical TPU cores (2 chiplets per physical chip) per host.
      TPU: "8"
    template:
      spec:
        containers:
        - name: ray-worker
          image: ${IMAGE_URI}
          env:
          - name: HF_TOKEN
            valueFrom:
              secretKeyRef:
                name: hf-secret
                key: hf_api_token
          - name: RAY_TPU_RESOURCE_PER_CHIP
            value: "2"
          resources:
            limits:
              cpu: "64"
              memory: "250Gi"
              google.com/tpu: "4"
            requests:
              cpu: "64"
              memory: "250Gi"
              google.com/tpu: "4"
          volumeMounts:
          - mountPath: /dev/shm
            name: dshm
        volumes:
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 128Gi
        nodeSelector:
          cloud.google.com/gke-tpu-accelerator: tpu7x
          cloud.google.com/gke-tpu-topology: 2x2x2

Di Ironwood (TPU7x), setiap chip fisik berisi dua chiplet, yang menyediakan delapan core TPU logis per host empat chip. Manifes menetapkan nilai kolom TPU ke "8" di bagian resources dan menetapkan variabel lingkungan RAY_TPU_RESOURCE_PER_CHIP ke "2" untuk memberitahukan dan menjadwalkan delapan resource TPU logis per host.

Terapkan manifes untuk membuat resource kustom RayCluster:

Trillium (v6e)

envsubst < ray-cluster.tpu-v6e-multihost.yaml | kubectl apply -f -

Ironwood (TPU7x)

envsubst < ray-cluster.tpu-v7x-multihost.yaml | kubectl apply -f -

Tunggu hingga head Pod dan semua Pod worker TPU mencapai status Running dan 1/1 READY:

kubectl get pods -l ray.io/cluster=ray-serve-torchtpu

Outputnya mirip dengan hal berikut ini:

Trillium (v6e)

NAME                                     READY   STATUS    RESTARTS   AGE
ray-serve-torchtpu-head-5cj7g            1/1     Running   0          35s
ray-serve-torchtpu-v6e-16-worker-6x8cg   1/1     Running   0          35s
ray-serve-torchtpu-v6e-16-worker-79j5l   1/1     Running   0          35s
ray-serve-torchtpu-v6e-16-worker-psxbl   1/1     Running   0          35s
ray-serve-torchtpu-v6e-16-worker-rz7dv   1/1     Running   0          35s

Ironwood (TPU7x)

NAME                                       READY   STATUS    RESTARTS   AGE
ray-serve-torchtpu-head-w7b2v              1/1     Running   0          2m30s
ray-serve-torchtpu-tpu7x-16-worker-6zlnj   1/1     Running   0          2m30s
ray-serve-torchtpu-tpu7x-16-worker-cb4zz   1/1     Running   0          2m30s

Pastikan webhook TPU KubeRay memasukkan slice multi-host, koordinasi worker, dan variabel lingkungan TorchTPU ke dalam Pod worker:

kubectl get pods -l ray.io/node-type=worker \
    -o=jsonpath='{range .items[0].spec.containers[0].env[*]}{.name}={.value}{"\n"}{end}' \
    | grep -E "TPU_WORKER_ID|TPU_WORKER_HOSTNAMES|TPU_NAME|TORCH_TPU_TOPOLOGY|TORCH_TPU_SLICEBUILDER_ADDRESSES"

Outputnya mirip dengan hal berikut ini:

Trillium (v6e)

TPU_WORKER_HOSTNAMES=v6e-16-0-0.ray-serve-torchtpu-headless,v6e-16-0-1.ray-serve-torchtpu-headless,v6e-16-0-2.ray-serve-torchtpu-headless,v6e-16-0-3.ray-serve-torchtpu-headless
TORCH_TPU_TOPOLOGY=4,4,1
TORCH_TPU_SLICEBUILDER_ADDRESSES=v6e-16-0-0.ray-serve-torchtpu-headless:8471,v6e-16-0-0.ray-serve-torchtpu-headless:8472,v6e-16-0-0.ray-serve-torchtpu-headless:8473,v6e-16-0-0.ray-serve-torchtpu-headless:8474,v6e-16-0-1.ray-serve-torchtpu-headless:8471,v6e-16-0-1.ray-serve-torchtpu-headless:8472,v6e-16-0-1.ray-serve-torchtpu-headless:8473,v6e-16-0-1.ray-serve-torchtpu-headless:8474,v6e-16-0-2.ray-serve-torchtpu-headless:8471,v6e-16-0-2.ray-serve-torchtpu-headless:8472,v6e-16-0-2.ray-serve-torchtpu-headless:8473,v6e-16-0-2.ray-serve-torchtpu-headless:8474,v6e-16-0-3.ray-serve-torchtpu-headless:8471,v6e-16-0-3.ray-serve-torchtpu-headless:8472,v6e-16-0-3.ray-serve-torchtpu-headless:8473,v6e-16-0-3.ray-serve-torchtpu-headless:8474
TPU_WORKER_ID=1
TPU_NAME=v6e-16-0

Ironwood (TPU7x)

TPU_WORKER_HOSTNAMES=tpu7x-16-0-0.ray-serve-torchtpu-headless,tpu7x-16-0-1.ray-serve-torchtpu-headless
TORCH_TPU_TOPOLOGY=2,2,2,2
TORCH_TPU_SLICEBUILDER_ADDRESSES=tpu7x-16-0-0.ray-serve-torchtpu-headless:8471,tpu7x-16-0-0.ray-serve-torchtpu-headless:8472,tpu7x-16-0-0.ray-serve-torchtpu-headless:8473,tpu7x-16-0-0.ray-serve-torchtpu-headless:8474,tpu7x-16-0-0.ray-serve-torchtpu-headless:8475,tpu7x-16-0-0.ray-serve-torchtpu-headless:8476,tpu7x-16-0-0.ray-serve-torchtpu-headless:8477,tpu7x-16-0-0.ray-serve-torchtpu-headless:8478,tpu7x-16-0-1.ray-serve-torchtpu-headless:8471,tpu7x-16-0-1.ray-serve-torchtpu-headless:8472,tpu7x-16-0-1.ray-serve-torchtpu-headless:8473,tpu7x-16-0-1.ray-serve-torchtpu-headless:8474,tpu7x-16-0-1.ray-serve-torchtpu-headless:8475,tpu7x-16-0-1.ray-serve-torchtpu-headless:8476,tpu7x-16-0-1.ray-serve-torchtpu-headless:8477,tpu7x-16-0-1.ray-serve-torchtpu-headless:8478
TPU_WORKER_ID=1
TPU_NAME=tpu7x-16-0

Anda dapat memeriksa node worker TPU dan label ray.io/tpu-* yang terdeteksi otomatis di tab Cluster di Ray Dashboard.

Teruskan port lokal ke Dasbor Ray di port 8265 dan endpoint HTTP Ray Serve di port 8000:

kubectl port-forward svc/ray-serve-torchtpu-head-svc 8265:8265 8000:8000 >/dev/null 2>&1 &

Membuat dan men-deploy aplikasi LLM Ray Serve

Deploy aplikasi LLM Ray Serve di resource kustom RayCluster Anda untuk menyajikan model google/gemma-4-26B-A4B-it di seluruh slice TPU multi-host.

Tinjau skrip serve_vllm_torchtpu.py di repositori contoh:

from ray.serve.deployment import Application
from ray.serve.llm import (
    LLMConfig,
    LLMServingArgs,
    ModelLoadingConfig,
    build_openai_app,
)


def app(args: dict[str, str]) -> Application:
    llm_config = LLMConfig(
        model_loading_config=ModelLoadingConfig(
            model_id=args.get("model_id", "google/gemma-4-26B-A4B-it"),
        ),
        accelerator_type=args.get("accelerator_type", "TPU-V6E"),
        accelerator_config={
            "kind": "tpu",
            "topology": args.get("topology", "4x4"),
        },
        placement_group_config={
            "bundle_per_worker": {"TPU": 1},
        },
        engine_kwargs={
            "tensor_parallel_size": int(args.get("tensor_parallel_size", "16")),
            "enable_expert_parallel": True,
            "enable_prefix_caching": True,
            "language_model_only": True,
            "disable_hybrid_kv_cache_manager": True,
            "max_model_len": int(args.get("max_model_len", "8192")),
            "max_num_batched_tokens": int(
                args.get("max_num_batched_tokens", "4096")
            ),
        },
        experimental_configs={
            "stream_batching_interval_ms": 10,
        },
        runtime_env={
            "env_vars": {
                "TPU_MULTIHOST_BACKEND": "ray",
                # Execute Gemma 4 routed expert layers on TPU TensorCores instead of SparseCore.
                "USE_MOE_SPARSE_CORE": "0",
                "VLLM_RAY_EXTRA_ENV_VARS_TO_COPY": "USE_MOE_SPARSE_CORE",
            }
        },
    )
    return build_openai_app(LLMServingArgs(llm_configs=[llm_config]))

Skrip ini mengonfigurasi objek LLMConfig dengan setelan berikut untuk penyaluran TPU multi-host:

Kolom accelerator_config dan placement_group_config mencadangkan grup penempatan pada satu slice TPU dan mengalokasikan satu TPU core per worker vLLM di seluruh slice.
Kolom engine_kwargs melakukan sharding model di 16 core TPU menggunakan paralelisme tensor dan paralelisme pakar, serta mengaktifkan penyimpanan cache awalan. Konfigurasi ini juga menonaktifkan input multimodal untuk mencadangkan HBM TPU untuk inferensi teks, menggunakan tata letak cache KV terpadu untuk 4 lapisan perhatian Gemma, serta membatasi jendela konteks pada 8.192 token dan ukuran batch prefill pada 4.096 token.
Kolom experimental_configs mengelompokkan streaming token keluar setiap 10 md untuk mengurangi overhead streaming di seluruh permintaan serentak.
Kolom runtime_env mengaktifkan backend multi-host Ray untuk vLLM-TorchTPU (TPU_MULTIHOST_BACKEND: "ray"), menjalankan lapisan pakar Gemma 4 MoE di TPU TensorCore, bukan SparseCore, dan menerapkan setelan tersebut ke semua 16 aktor worker.

Deploy aplikasi Ray Serve di resource kustom RayCluster menggunakan perintah serve run. Perintah ini men-streaming log deployment hingga bobot model selesai dimuat, kompilasi grafik XLA selesai di semua 16 perangkat TPU, dan aplikasi Serve mencapai status RUNNING:

Trillium (v6e)

ray job submit \
    --address http://localhost:8265 \
    --working-dir . \
    --runtime-env-json '{"excludes": ["ray-env", ".git", "*.whl"]}' \
    -- serve run --non-blocking serve_vllm_torchtpu:app accelerator_type=TPU-V6E topology=4x4

Ironwood (TPU7x)

ray job submit \
    --address http://localhost:8265 \
    --working-dir . \
    --runtime-env-json '{"excludes": ["ray-env", ".git", "*.whl"]}' \
    -- serve run --non-blocking serve_vllm_torchtpu:app accelerator_type=TPU-V7X topology=2x2x2

Outputnya mirip dengan hal berikut ini:

Trillium (v6e)

(ServeController pid=1637) INFO 2026-10-13 10:23:05,160 controller 1637 -- Deploying new version of Deployment(name='LLMServer:google--gemma-4-26B-A4B-it', app='default') (initial target replicas: 1).
(ServeController pid=1637) INFO 2026-10-13 10:23:05,161 controller 1637 -- Deploying new version of Deployment(name='OpenAiIngress', app='default') (initial target replicas: 1).
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) INFO 10-13 10:24:06 [__init__.py:318] TPU info: node_name=v6e-16-0 | tpu_type=v6e-16 | worker_id=1 | num_chips=4 | num_cores_per_chip=1
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) INFO 10-13 10:24:06 [__init__.py:238] Platform plugin torchtpu is activated
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) (EngineCore pid=1041) INFO 10-13 10:24:08 [core.py:112] Initializing a V1 LLM engine (v0.22.1) with config: model='google/gemma-4-26B-A4B-it', speculative_config=None, tokenizer='google/gemma-4-26B-A4B-it', skip_tokenizer_init=False, tokenizer_mode=auto, revision=None, tokenizer_revision=None, trust_remote_code=False, dtype=torch.bfloat16, max_seq_len=8192, download_dir=None, load_format=auto, tensor_parallel_size=16, pipeline_parallel_size=1, data_parallel_size=1, decode_context_parallel_size=1, dcp_comm_backend=ag_rs, disable_custom_all_reduce=True, quantization=None, quantization_config=None, enforce_eager=False, enable_return_routed_experts=False, kv_cache_dtype=auto, device_config=tpu, ...
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) (EngineCore pid=1041) (RayWorkerWrapper pid=1017, ip=10.72.14.21) INFO 10-13 10:24:30 [expert_map_manager.py:245] [EP Rank 4/16] Expert parallelism is enabled. Expert placement strategy: linear. Local/global number of experts: 8/128. Experts local to global index map: 0->32, 1->33, 2->34, 3->35, 4->36, 5->37, 6->38, 7->39.
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) (EngineCore pid=1041) (RayWorkerWrapper pid=856, ip=10.72.6.21) INFO 10-13 10:27:55 [default_loader.py:397] Loading weights took 12.76 seconds
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) (EngineCore pid=1041) (RayWorkerWrapper pid=856, ip=10.72.6.21) INFO 10-13 10:32:53 [tpu_worker.py:376] Memory statistics | total_hbm_limit_gb=31.25GiB | total_hbm_limit_cap_gb=28.75GiB | total_hbm_used_gb=3.69GiB | kv_cache_headroom_gb=5.0GiB | kv_connector_hbm_reserve_gb=0.0GiB | total_hbm_avail_gb=20.06GiB
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) (EngineCore pid=1041) INFO 10-13 10:32:54 [kv_cache_utils.py:1733] GPU KV cache size: 600,832 tokens
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) (EngineCore pid=1041) INFO 10-13 10:32:54 [kv_cache_utils.py:1734] Maximum concurrency for 8,192 tokens per request: 73.34x
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=515, ip=10.72.3.21) INFO 2026-10-13 10:36:59,851 default_LLMServer:google--gemma-4-26B-A4B-it b2grwv9c -- Started vLLM engine.
INFO 2026-10-13 10:37:05,997 serve 1456 -- Application 'default' is ready at http://127.0.0.1:8000/.
2026-10-13 10:37:11,447 SUCC cli.py:66 -- ------------------------------------------
2026-10-13 10:37:11,447 SUCC cli.py:67 -- Job 'raysubmit_94DTwVzR2pvGQVwR' succeeded
2026-10-13 10:37:11,447 SUCC cli.py:68 -- ------------------------------------------

Ironwood (TPU7x)

(ServeController pid=2042) INFO 2026-10-13 10:24:38,092 controller 2042 -- Deploying new version of Deployment(name='LLMServer:google--gemma-4-26B-A4B-it', app='default') (initial target replicas: 1).
(ServeController pid=2042) INFO 2026-10-13 10:24:38,093 controller 2042 -- Deploying new version of Deployment(name='OpenAiIngress', app='default') (initial target replicas: 1).
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) INFO 10-13 10:24:49 [__init__.py:318] TPU info: node_name=tpu7x-16-0 | tpu_type=tpu7x-16 | worker_id=0 | num_chips=8 | num_cores_per_chip=2
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) INFO 10-13 10:24:49 [__init__.py:238] Platform plugin torchtpu is activated
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) (EngineCore pid=719) INFO 10-13 10:25:23 [core.py:112] Initializing a V1 LLM engine (v0.22.1) with config: model='google/gemma-4-26B-A4B-it', speculative_config=None, tokenizer='google/gemma-4-26B-A4B-it', skip_tokenizer_init=False, tokenizer_mode=auto, revision=None, tokenizer_revision=None, trust_remote_code=False, dtype=torch.bfloat16, max_seq_len=8192, download_dir=None, load_format=auto, tensor_parallel_size=16, pipeline_parallel_size=1, data_parallel_size=1, decode_context_parallel_size=1, dcp_comm_backend=ag_rs, disable_custom_all_reduce=True, quantization=None, quantization_config=None, enforce_eager=False, enable_return_routed_experts=False, kv_cache_dtype=auto, device_config=tpu, ...
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) (EngineCore pid=719) (RayWorkerWrapper pid=602, ip=172.16.10.6) INFO 10-13 10:25:44 [expert_map_manager.py:245] [EP Rank 8/16] Expert parallelism is enabled. Expert placement strategy: linear. Local/global number of experts: 8/128. Experts local to global index map: 0->64, 1->65, 2->66, 3->67, 4->68, 5->69, 6->70, 7->71.
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) (EngineCore pid=719) (RayWorkerWrapper pid=762) INFO 10-13 10:29:06 [default_loader.py:397] Loading weights took 11.69 seconds
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) (EngineCore pid=719) (RayWorkerWrapper pid=604, ip=172.16.10.6) INFO 10-13 10:34:51 [tpu_worker.py:376] Memory statistics | total_hbm_limit_gb=94.75GiB | total_hbm_limit_cap_gb=87.17GiB | total_hbm_used_gb=3.74GiB | kv_cache_headroom_gb=5.0GiB | kv_connector_hbm_reserve_gb=0.0GiB | total_hbm_avail_gb=78.43GiB
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) (EngineCore pid=719) INFO 10-13 10:34:58 [kv_cache_utils.py:1733] GPU KV cache size: 2,349,568 tokens
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) (EngineCore pid=719) INFO 10-13 10:34:58 [kv_cache_utils.py:1734] Maximum concurrency for 8,192 tokens per request: 286.81x
(ServeReplica:default:LLMServer:google--gemma-4-26B-A4B-it pid=316, ip=172.16.7.5) INFO 2026-10-13 10:40:13,586 default_LLMServer:google--gemma-4-26B-A4B-it a15k5cv3 -- Started vLLM engine.
INFO 2026-10-13 10:40:18,415 serve 1953 -- Application 'default' is ready at http://127.0.0.1:8000/.
2026-10-13 10:40:24,372 SUCC cli.py:66 -- ------------------------------------------
2026-10-13 10:40:24,372 SUCC cli.py:67 -- Job 'raysubmit_mzWQDQGDM9QSgcMN' succeeded
2026-10-13 10:40:24,372 SUCC cli.py:68 -- ------------------------------------------

Mengkueri model yang disajikan

Setelah aplikasi Ray Serve mencapai status RUNNING, verifikasi endpoint model yang terdaftar, kirim permintaan /v1/chat/completions yang kompatibel dengan OpenAI melalui port 8000, dan secara opsional lakukan tolok ukur throughput dan latensi.

Pastikan model terdaftar di endpoint /v1/models:

curl http://localhost:8000/v1/models

Outputnya mirip dengan hal berikut ini:

{"data":[{"id":"google/gemma-4-26B-A4B-it","object":"model","owned_by":"organization-owner","permission":[],"metadata":{"model_id":"google/gemma-4-26B-A4B-it","input_modality":"text","max_request_context_length":8192}}],"object":"list"}

Kirim perintah penyelesaian chat ke endpoint /v1/chat/completions:

curl -X POST http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "google/gemma-4-26B-A4B-it",
        "messages": [
            {"role": "system", "content": "You are a helpful AI assistant."},
            {"role": "user", "content": "Explain in one sentence how tensor parallelism and expert parallelism accelerate Mixture-of-Experts LLM inference on TPUs."}
        ],
        "max_tokens": 128,
        "temperature": 0.0
    }'

Output di Ironwood (TPU7x) mirip dengan berikut ini:

{"id":"chatcmpl-ec30e61c-011d-49cd-989a-9ae9f59448a8","object":"chat.completion","created":1791887860,"model":"google/gemma-4-26B-A4B-it","choices":[{"index":0,"message":{"role":"assistant","content":"Tensor parallelism accelerates inference by partitioning large weight matrices across TPU cores to reduce per-device memory and computation, while expert parallelism distributes the specialized MoE layers across different devices to enable massive model scaling and parallelize the processing of different tokens through different experts.","refusal":null,"annotations":null,"audio":null,"function_call":null,"tool_calls":[],"reasoning":null},"logprobs":null,"finish_reason":"stop","stop_reason":106,"token_ids":null,"routed_experts":null}],"service_tier":null,"system_fingerprint":"vllm-0.22.1-tp16-ep-aaf76e1a","usage":{"prompt_tokens":49,"total_tokens":100,"completion_tokens":51,"prompt_tokens_details":null},"prompt_logprobs":null,"prompt_token_ids":null,"prompt_text":null,"kv_transfer_params":null}

Opsional: Lakukan tolok ukur throughput dan latensi inferensi menggunakan perintah vllm bench serve. Perintah berikut menjalankan klien generator beban HTTP vllm bench serve dari Pod worker TPU Ray dan mengirimkan 64 permintaan serentak ke proxy HTTP Ray Serve di port 8000:

WORKER_POD=$(kubectl get pods -l ray.io/node-type=worker -o jsonpath='{.items[0].metadata.name}')
kubectl exec -it ${WORKER_POD} -- vllm bench serve \
    --backend openai-chat \
    --endpoint /v1/chat/completions \
    --model google/gemma-4-26B-A4B-it \
    --dataset-name random \
    --random-input-len 1024 \
    --random-output-len 512 \
    --max-concurrency 32 \
    --num-prompts 64 \
    --num-warmups 4 \
    --temperature 0.0 \
    --ignore-eos \
    --host ray-serve-torchtpu-head-svc \
    --port 8000

Outputnya mirip dengan hal berikut ini:

Trillium (v6e)

============ Serving Benchmark Result ============
Successful requests:                     64
Failed requests:                         0
Maximum request concurrency:             32
Benchmark duration (s):                  8.41
Total input tokens:                      66392
Total generated tokens:                  32768
Request throughput (req/s):              7.61
Output token throughput (tok/s):         3894.26
Peak output token throughput (tok/s):    4409.00
Peak concurrent requests:                64.00
Total token throughput (tok/s):          11784.50
---------------Time to First Token----------------
Mean TTFT (ms):                          414.57
Median TTFT (ms):                        348.94
P99 TTFT (ms):                           640.26
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          7.37
Median TPOT (ms):                        7.29
P99 TPOT (ms):                           8.24
---------------Inter-token Latency----------------
Mean ITL (ms):                           7.37
Median ITL (ms):                         0.00
P99 ITL (ms):                            25.94
==================================================

Ironwood (TPU7x)

============ Serving Benchmark Result ============
Successful requests:                     64
Failed requests:                         0
Maximum request concurrency:             32
Benchmark duration (s):                  9.65
Total input tokens:                      66392
Total generated tokens:                  32768
Request throughput (req/s):              6.64
Output token throughput (tok/s):         3397.33
Peak output token throughput (tok/s):    4574.00
Peak concurrent requests:                64.00
Total token throughput (tok/s):          10280.73
---------------Time to First Token----------------
Mean TTFT (ms):                          654.11
Median TTFT (ms):                        522.30
P99 TTFT (ms):                           1288.23
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          8.13
Median TPOT (ms):                        8.08
P99 TPOT (ms):                           9.69
---------------Inter-token Latency----------------
Mean ITL (ms):                           8.12
Median ITL (ms):                         9.31
P99 ITL (ms):                            26.85
==================================================

Men-deploy secara deklaratif dengan resource kustom RayService

Untuk deployment produksi, Anda dapat mengelola cluster Ray multi-host dan aplikasi LLM Ray Serve sebagai satu resource kustom RayService deklaratif, bukan mengirimkan tugas secara manual. Karena builder LLM Ray Serve menerima konfigurasi model langsung di konfigurasi Serve, Anda tidak memerlukan skrip Python terpisah. KubeRay menyediakan cluster, men-deploy aplikasi Serve, memantau kondisi replika, dan membuat Service ClusterIP Kubernetes di port 8000 saat aplikasi siap menyalurkan traffic.

Jika resource kustom RayCluster dari bagian sebelumnya masih berjalan, hentikan penerusan port dan hapus resource kustom RayCluster untuk merilis slice TPU:
```
pkill -f "kubectl port-forward" || true
kubectl delete raycluster ray-serve-torchtpu --ignore-not-found
```

Tinjau manifes RayService untuk versi TPU Anda di repositori contoh:

Trillium (v6e)

apiVersion: ray.io/v1
kind: RayService
metadata:
  name: ray-serve-torchtpu
spec:
  serveConfigV2: |
    applications:
    - name: default
      route_prefix: /
      import_path: ray.serve.llm:build_openai_app
      args:
        llm_configs:
        - model_loading_config:
            model_id: google/gemma-4-26B-A4B-it
          accelerator_type: TPU-V6E
          accelerator_config:
            kind: tpu
            topology: 4x4
          placement_group_config:
            bundle_per_worker:
              TPU: 1
          engine_kwargs:
            tensor_parallel_size: 16
            enable_expert_parallel: true
            enable_prefix_caching: true
            language_model_only: true
            disable_hybrid_kv_cache_manager: true
            max_model_len: 8192
            max_num_batched_tokens: 4096
          experimental_configs:
            stream_batching_interval_ms: 10
          runtime_env:
            env_vars:
              TPU_MULTIHOST_BACKEND: "ray"
              # Execute Gemma 4 routed expert layers on TPU TensorCores instead of SparseCore.
              USE_MOE_SPARSE_CORE: "0"
              VLLM_RAY_EXTRA_ENV_VARS_TO_COPY: "USE_MOE_SPARSE_CORE"
  rayClusterConfig:
    headGroupSpec:
      rayStartParams:
        num-cpus: "0"
      template:
        spec:
          containers:
          - name: ray-head
            image: ${IMAGE_URI}
            env:
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            ports:
            - containerPort: 6379
              name: gcs
            - containerPort: 8265
              name: dashboard
            - containerPort: 10001
              name: client
            - containerPort: 8000
              name: serve
            resources:
              limits:
                cpu: "4"
                memory: "16Gi"
              requests:
                cpu: "4"
                memory: "16Gi"
    workerGroupSpecs:
    - groupName: v6e-16
      replicas: 1
      numOfHosts: 4
      template:
        spec:
          containers:
          - name: ray-worker
            image: ${IMAGE_URI}
            env:
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            resources:
              limits:
                cpu: "64"
                memory: "200Gi"
                google.com/tpu: "4"
              requests:
                cpu: "64"
                memory: "200Gi"
                google.com/tpu: "4"
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
              medium: Memory
              sizeLimit: 100Gi
          nodeSelector:
            cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
            cloud.google.com/gke-tpu-topology: 4x4

Ironwood (TPU7x)

apiVersion: ray.io/v1
kind: RayService
metadata:
  name: ray-serve-torchtpu
spec:
  serveConfigV2: |
    applications:
    - name: default
      route_prefix: /
      import_path: ray.serve.llm:build_openai_app
      args:
        llm_configs:
        - model_loading_config:
            model_id: google/gemma-4-26B-A4B-it
          accelerator_type: TPU-V7X
          accelerator_config:
            kind: tpu
            topology: 2x2x2
          placement_group_config:
            bundle_per_worker:
              TPU: 1
          engine_kwargs:
            tensor_parallel_size: 16
            enable_expert_parallel: true
            enable_prefix_caching: true
            language_model_only: true
            disable_hybrid_kv_cache_manager: true
            max_model_len: 8192
            max_num_batched_tokens: 4096
          experimental_configs:
            stream_batching_interval_ms: 10
          runtime_env:
            env_vars:
              TPU_MULTIHOST_BACKEND: "ray"
              # Execute Gemma 4 routed expert layers on TPU TensorCores instead of SparseCore.
              USE_MOE_SPARSE_CORE: "0"
              VLLM_RAY_EXTRA_ENV_VARS_TO_COPY: "USE_MOE_SPARSE_CORE"
  rayClusterConfig:
    headGroupSpec:
      rayStartParams:
        num-cpus: "0"
      template:
        spec:
          containers:
          - name: ray-head
            image: ${IMAGE_URI}
            env:
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            - name: RAY_TPU_RESOURCE_PER_CHIP
              value: "2"
            ports:
            - containerPort: 6379
              name: gcs
            - containerPort: 8265
              name: dashboard
            - containerPort: 10001
              name: client
            - containerPort: 8000
              name: serve
            resources:
              limits:
                cpu: "4"
                memory: "16Gi"
              requests:
                cpu: "4"
                memory: "16Gi"
    workerGroupSpecs:
    - groupName: tpu7x-16
      replicas: 1
      numOfHosts: 2
      resources:
        # Advertises 8 logical TPU cores (2 chiplets per physical chip) per host.
        TPU: "8"
      template:
        spec:
          containers:
          - name: ray-worker
            image: ${IMAGE_URI}
            env:
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            - name: RAY_TPU_RESOURCE_PER_CHIP
              value: "2"
            resources:
              limits:
                cpu: "64"
                memory: "250Gi"
                google.com/tpu: "4"
              requests:
                cpu: "64"
                memory: "250Gi"
                google.com/tpu: "4"
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
              medium: Memory
              sizeLimit: 128Gi
          nodeSelector:
            cloud.google.com/gke-tpu-accelerator: tpu7x
            cloud.google.com/gke-tpu-topology: 2x2x2

Terapkan manifes RayService:

Trillium (v6e)

envsubst < ray-service.tpu-v6e-multihost.yaml | kubectl apply -f -

Ironwood (TPU7x)

envsubst < ray-service.tpu-v7x-multihost.yaml | kubectl apply -f -

Tunggu hingga resource kustom RayService selesai memuat bobot model dan mengompilasi grafik XLA di seluruh slice TPU dan mencapai status Running:

kubectl get rayservice ray-serve-torchtpu
kubectl get svc ray-serve-torchtpu-serve-svc

Outputnya mirip dengan hal berikut ini:

NAME                 SERVICE STATUS   NUM SERVE ENDPOINTS
ray-serve-torchtpu   Running          3
NAME                           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
ray-serve-torchtpu-serve-svc   ClusterIP   34.118.239.213   <none>        8000/TCP   29s

Teruskan port lokal 8000 ke Layanan ray-serve-torchtpu-serve-svc dan buat kueri model menggunakan perintah curl di Membuat kueri model inferensi:
```
kubectl port-forward svc/ray-serve-torchtpu-serve-svc 8000:8000 >/dev/null 2>&1 &
```

Mengamati performa model

Untuk memantau pemakaian TPU TensorCore, penggunaan HBM, dan metrik cluster Ray di Cloud Monitoring, lihat Mengumpulkan dan melihat log serta metrik untuk cluster Ray di GKE dan Melihat metrik TPU di Dasbor Ray.

Mengakses Dasbor Ray

Untuk memeriksa status deployment Ray Serve, aktor replika, label node, dan latensi kueri di Dasbor Ray bawaan, ikuti langkah-langkah berikut:

Jika penerusan port ke layanan head Ray belum berjalan, mulai di latar belakang:

kubectl port-forward svc/ray-serve-torchtpu-head-svc 8265:8265 8000:8000 >/dev/null 2>&1 &

Di Cloud Shell, klik Web Preview dan pilih Preview on port 8265, atau buka http://localhost:8265 di browser lokal Anda.
Klik tab Serve, Cluster, dan Metrics untuk melihat deployment vLLM, kondisi replika, label node ray.io/tpu-* yang terdeteksi otomatis, metrik latensi permintaan, dan grafik TPU Utilization by Node.

Pembersihan

Agar akun Google Cloud Anda tidak dikenai biaya untuk resource yang digunakan dalam tutorial ini, hapus resource kustom RayService atau RayCluster, cluster GKE, dan repositori Artifact Registry:

Hentikan proses penerusan port latar belakang dan hapus resource kustom Ray dan Secret Kubernetes:

pkill -f "kubectl port-forward" || true
kubectl delete rayservice ray-serve-torchtpu --ignore-not-found
kubectl delete raycluster ray-serve-torchtpu --ignore-not-found
kubectl delete secret hf-secret --ignore-not-found

Hapus cluster GKE:

Autopilot

gcloud container clusters delete ${CLUSTER_NAME} \
    --region=${REGION}

Standar

gcloud container clusters delete ${CLUSTER_NAME} \
    --zone=${ZONE}

Hapus repositori Artifact Registry:

gcloud artifacts repositories delete ${ARTIFACT_REGISTRY} \
    --location=${REGION}

Langkah berikutnya

Pelajari lebih lanjut PyTorch di Cloud TPU.
Pelajari dokumentasi TorchTPU.
Pelajari cara melakukan fine-tuning pada model di TPU multi-host dengan Ray dan TorchTPU.
Pelajari cara menyajikan model terbuka Gemma menggunakan TPU multi-host di GKE dengan Ray.
Pelajari cara mengelola deployment Ray Serve secara deklaratif dengan resource kustom KubeRay RayService.
Baca Tentang TPU di GKE.
Pelajari dokumentasi Ray Serve LLM.

Menyajikan LLM di TPU multi-host dengan Ray dan TorchTPU Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Latar belakang

TPU

vLLM dan TorchTPU

Ray Serve LLM di GKE

Tujuan

Biaya

Sebelum memulai

Menyiapkan lingkungan Anda

Membangun image container kustom

Membuat cluster GKE

Autopilot

Standar

Trillium (v6e)

Ironwood (TPU7x)

Men-deploy resource kustom RayCluster multi-host

Trillium (v6e)

Ironwood (TPU7x)

Trillium (v6e)

Ironwood (TPU7x)

Trillium (v6e)

Ironwood (TPU7x)

Trillium (v6e)

Ironwood (TPU7x)

Membuat dan men-deploy aplikasi LLM Ray Serve

Trillium (v6e)

Ironwood (TPU7x)

Trillium (v6e)

Ironwood (TPU7x)

Mengkueri model yang disajikan

Trillium (v6e)

Ironwood (TPU7x)

Men-deploy secara deklaratif dengan resource kustom RayService

Trillium (v6e)

Ironwood (TPU7x)

Trillium (v6e)

Ironwood (TPU7x)

Mengamati performa model

Mengakses Dasbor Ray

Pembersihan

Autopilot

Standar

Langkah berikutnya

Menyajikan LLM di TPU multi-host dengan Ray dan TorchTPU