Mengonfigurasi ketersediaan tinggi lintas region elastis

Dokumen ini menunjukkan cara mengonfigurasi ketersediaan tinggi lintas region yang elastis untuk workload inferensi AI menggunakan Multi-Cluster Inference Gateway Google Kubernetes Engine (GKE) dan fitur Penskalaan Otomatis GKE. Penyiapan ini memungkinkan Anda melakukan load balancing workload secara cerdas di beberapa cluster GKE di region yang berbeda.

Untuk mengetahui informasi selengkapnya tentang GKE Multi-Cluster Inference Gateway, lihat Tentang GKE Multi-Cluster Inference Gateway.

Sebelum memulai

  1. Aktifkan Google Kubernetes Engine API.

    Mengaktifkan Google Kubernetes Engine API

  2. Instal dan lakukan inisialisasi Google Cloud CLI jika Anda berencana menggunakannya untuk tugas ini.

  3. Pastikan project Anda memiliki kuota yang cukup untuk GPU H100. Untuk mengetahui informasi selengkapnya, lihat kuota GPU dan alokasi resource.

  4. Gunakan GKE versi 1.34.1-gke.1127000 atau yang lebih baru.

  5. Gunakan gcloud CLI versi 480.0.0 atau yang lebih baru.

  6. Pastikan akun layanan yang digunakan oleh node Anda memiliki izin roles/monitoring.metricWriter dan roles/stackdriver.resourceMetadata.writer.

  7. Pastikan Anda memiliki peran Identity and Access Management (IAM) roles/container.admin dan roles/iam.serviceAccountAdmin di project.

  8. Selesaikan prasyarat Hugging Face berikut:

    1. Buat akun Hugging Face.
    2. Minta dan dapatkan persetujuan untuk akses ke model Llama 3.1 di Hugging Face.
    3. Tandatangani perjanjian izin lisensi di halaman model di Hugging Face.
    4. Buat token akses Hugging Face dengan minimal izin Baca.

Membuat cluster dan node pool

Untuk membuat dua cluster GKE di region yang berbeda dan mengonfigurasi kumpulan node-nya, ikuti langkah-langkah berikut:

  1. Buat cluster pertama:

    gcloud container clusters create gke-west --zone \
    CLUSTER_1_ZONE \
    --project=PROJECT_ID \
    --gateway-api=standard \
    --cluster-version=GKE_VERSION \
    --machine-type="MACHINE_TYPE" \
    --disk-type="DISK_TYPE" \
    --enable-managed-prometheus --monitoring=SYSTEM,DCGM \
    --hpa-profile=performance \
    --workload-pool=PROJECT_ID.s3ns.svc.id.goog \
    --async

    Ganti kode berikut:

    • PROJECT_ID: project ID Anda
    • CLUSTER_1_ZONE: zona untuk cluster pertama, misalnya europe-west3-c
    • GKE_VERSION: versi GKE yang akan digunakan, misalnya 1.34.1-gke.1127000
    • MACHINE_TYPE: jenis mesin untuk node cluster, misalnya c2-standard-16
    • DISK_TYPE: jenis disk untuk node cluster, misalnya pd-standard

  2. Buat node pool H100 di cluster pertama:

    gcloud container node-pools create h100 \
    --accelerator "type=nvidia-h100-80gb,count=2,gpu-driver-version=latest" \
    --project=PROJECT_ID \
    --location=CLUSTER_1_ZONE \
    --node-locations=CLUSTER_1_ZONE \
    --cluster=CLUSTER_1_NAME \
    --machine-type=NODE_POOL_MACHINE_TYPE \
    --num-nodes=NUM_NODES \
    --spot \
    --min-nodes=MIN_NUM_NODES \
    --max-nodes=MAX_NUM_NODES \
    --enable-autoscaling \
    --async

    Ganti kode berikut:

    • PROJECT_ID: project ID Anda
    • CLUSTER_1_ZONE: zona untuk cluster pertama, misalnya europe-west3-c
    • CLUSTER_1_NAME: nama cluster pertama, misalnya gke-west
    • NODE_POOL_MACHINE_TYPE: jenis mesin untuk node pool, misalnya a3-highgpu-2g
    • NUM_NODES: jumlah node dalam node pool, misalnya 3
    • MIN_NUM_NODES: jumlah minimum node untuk penskalaan otomatis di node pool, misalnya 1
    • MAX_NUM_NODES: jumlah node maksimum untuk penskalaan otomatis di node pool, misalnya 10

  3. Dapatkan kredensial dan buat rahasia token Hugging Face di cluster pertama:

    gcloud container clusters get-credentials CLUSTER_1_NAME \
    --location CLUSTER_1_ZONE \
    --project=PROJECT_ID

kubectl create secret generic hf-token \
    --from-literal=token=HF_TOKEN

    Ganti kode berikut:

    • PROJECT_ID: project ID Anda
    • CLUSTER_1_NAME: nama cluster pertama, misalnya gke-west
    • CLUSTER_1_ZONE: zona untuk cluster pertama, misalnya europe-west3-c
    • HF_TOKEN: token akses Hugging Face Anda

  4. Buat cluster kedua di region yang berbeda dari cluster pertama:

    gcloud container clusters create gke-east --zone CLUSTER_2_ZONE \
    --project=PROJECT_ID \
    --gateway-api=standard \
    --cluster-version=GKE_VERSION \
    --machine-type="MACHINE_TYPE" \
    --disk-type="DISK_TYPE" \
    --enable-managed-prometheus \
    --monitoring=SYSTEM,DCGM \
    --hpa-profile=performance \
    --workload-pool=PROJECT_ID.s3ns.svc.id.goog \
    --async

    Ganti CLUSTER_2_ZONE dengan zona untuk cluster kedua, misalnya us-east4-a.

  5. Buat node pool H100 untuk cluster kedua:

    gcloud container node-pools create h100 \
    --accelerator "type=nvidia-h100-80gb,count=2,gpu-driver-version=latest" \
    --project=PROJECT_ID \
    --location=CLUSTER_2_ZONE \
    --node-locations=CLUSTER_2_ZONE \
    --cluster=CLUSTER_2_NAME \
    --machine-type=NODE_POOL_MACHINE_TYPE \
    --num-nodes=NUM_NODES \
    --spot \
    --min-nodes=MIN_NUM_NODES \
    --max-nodes=MAX_NUM_NODES \
    --enable-autoscaling \
    --async

    Ganti kode berikut:

    • PROJECT_ID: project ID Anda
    • CLUSTER_2_ZONE: zona untuk cluster kedua, misalnya us-east4-a
    • CLUSTER_2_NAME: nama cluster kedua, misalnya gke-east
    • NODE_POOL_MACHINE_TYPE: jenis mesin untuk node pool, misalnya a3-highgpu-2g
    • NUM_NODES: jumlah node dalam node pool, misalnya 3
    • MIN_NUM_NODES: jumlah minimum node untuk penskalaan otomatis di node pool, misalnya 1
    • MAX_NUM_NODES: jumlah node maksimum untuk penskalaan otomatis di node pool, misalnya 10

  6. Dapatkan kredensial dan buat secret untuk token Hugging Face di cluster kedua:

    gcloud container clusters get-credentials CLUSTER_2_NAME \
    --location CLUSTER_2_ZONE \
    --project=PROJECT_ID
kubectl create secret generic hf-token --from-literal=token=HF_TOKEN

    Ganti kode berikut. Untuk definisi variabel lainnya, lihat langkah-langkah sebelumnya:

    • HF_TOKEN: token akses Hugging Face Anda

Mendaftarkan cluster ke fleet

  1. Daftarkan cluster Anda ke fleet project Anda:

    gcloud container fleet memberships register CLUSTER_1_NAME \
    --gke-cluster CLUSTER_1_ZONE/CLUSTER_1_NAME \
    --location=global \
    --project=PROJECT_ID

gcloud container fleet memberships register CLUSTER_2_NAME \
    --gke-cluster CLUSTER_2_ZONE/CLUSTER_2_NAME \
    --location=global \
    --project=PROJECT_ID

    Ganti yang berikut, dan lihat langkah-langkah sebelumnya untuk mengetahui definisi variabel lainnya:

    • CLUSTER_1_NAME: nama cluster pertama, misalnya gke-west
    • CLUSTER_2_NAME: nama cluster kedua, misalnya gke-east

  2. Aktifkan fitur Multi-Cluster Ingress dan tetapkan cluster konfigurasi:

    gcloud container fleet ingress enable \
    --config-membership=projects/PROJECT_ID/locations/global/memberships/CLUSTER_1_NAME

    Ganti kode berikut. Untuk definisi variabel lainnya, lihat langkah-langkah sebelumnya:

    • PROJECT_ID: project ID Anda
    • CLUSTER_1_NAME: nama cluster pertama, misalnya gke-west

Membuat subnet khusus proxy

Peringatan: Cloud de Confiance by S3NS memungkinkan setiap jaringan VPC hanya memiliki satu subnet khusus proxy per region. Jika region target sudah berisi subnet khusus proxy dengan setelan purpose=REGIONAL_MANAGED_PROXY, pembuatan subnet GLOBAL_MANAGED_PROXY akan gagal. Anda harus menghapus subnet khusus proxy regional yang ada terlebih dahulu. Menghapus subnet khusus proxy regional akan memengaruhi semua load balancer berbasis Envoy regional di region tersebut yang menggunakannya, jadi rencanakan perubahan dengan tepat.

  1. Buat subnet di region cluster pertama:

    gcloud compute networks subnets create CLUSTER_1_REGION-subnet \
    --purpose=GLOBAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=CLUSTER_1_REGION \
    --network=default \
    --range=SUBNET_RANGE_1 \
    --project=PROJECT_ID

    Ganti kode berikut:

    • PROJECT_ID: project ID Anda
    • CLUSTER_1_REGION: region untuk cluster pertama, misalnya europe-west3
    • SUBNET_RANGE_1: rentang IP subnet untuk subnet khusus proxy di region cluster pertama, misalnya 10.0.0.0/23

  2. Buat subnet di region cluster kedua:

    gcloud compute networks subnets create CLUSTER_2_REGION-subnet \
    --purpose=GLOBAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=CLUSTER_2_REGION \
    --network=default \
    --range=SUBNET_RANGE_2 \
    --project=PROJECT_ID

    Ganti kode berikut:

    • PROJECT_ID: project ID Anda
    • CLUSTER_2_REGION: region untuk cluster kedua, misalnya us-east4
    • SUBNET_RANGE_2: rentang IP subnet untuk subnet khusus proxy di region cluster kedua, misalnya 10.5.0.0/23

Menginstal resource kustom yang diperlukan

  1. Tentukan variabel konteks untuk cluster Anda:

    CLUSTER1_CONTEXT="gke_PROJECT_ID_CLUSTER_1_ZONE_CLUSTER_1_NAME"
CLUSTER2_CONTEXT="gke_PROJECT_ID_CLUSTER_2_ZONE_CLUSTER_2_NAME"

    Ganti kode berikut:

    • PROJECT_ID: project ID Anda
    • CLUSTER_1_ZONE: zona untuk cluster pertama, misalnya europe-west3-c
    • CLUSTER_1_NAME: nama cluster pertama, misalnya gke-west
    • CLUSTER_2_ZONE: zona untuk cluster kedua, misalnya us-east4-a
    • CLUSTER_2_NAME: nama cluster kedua, misalnya gke-east

  2. Instal resource kustom InferencePool dan InferenceObjective di kedua cluster:

    kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.0.1/manifests.yaml --context=$CLUSTER1_CONTEXT

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.0.1/manifests.yaml --context=$CLUSTER2_CONTEXT

Men-deploy resource ke cluster target

  1. Deploy server model ke kedua cluster:

    kubectl apply -f \
https://raw.githubusercontent.com/kubernetes-sigs/gateway-api-inference-extension/release-1.0/config/manifests/vllm/gpu-deployment.yaml \
--context=$CLUSTER1_CONTEXT

kubectl apply -f \
https://raw.githubusercontent.com/kubernetes-sigs/gateway-api-inference-extension/release-1.0/config/manifests/vllm/gpu-deployment.yaml \
--context=$CLUSTER2_CONTEXT

  2. Simpan manifes berikut ke file bernama inference-objective.yaml:

    apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceObjective
metadata:
  name: food-review
spec:
  priority: 10
  poolRef:
    name: llama3-8b-instruct
    group: "inference.networking.k8s.io"

  3. Terapkan manifes ke kedua cluster:

    kubectl apply -f inference-objective.yaml --context=$CLUSTER1_CONTEXT
kubectl apply -f inference-objective.yaml --context=$CLUSTER2_CONTEXT

  4. Deploy resource InferencePool ke kedua cluster menggunakan Helm:

    helm install vllm-llama3-8b-instruct \
  --kube-context $CLUSTER1_CONTEXT \
  --set inferencePool.modelServers.matchLabels.app=vllm-llama3-8b-instruct \
  --set provider.name=gke \
  --set inferenceExtension.monitoring.gke.enabled=true \
  --version v1.0.1 \
  oci://registry.k8s.io/gateway-api-inference-extension/charts/inferencepool

helm install vllm-llama3-8b-instruct \
  --kube-context $CLUSTER2_CONTEXT \
  --set inferencePool.modelServers.matchLabels.app=vllm-llama3-8b-instruct \
  --set provider.name=gke \
  --set inferenceExtension.monitoring.gke.enabled=true \
  --version v1.0.1 \
  oci://registry.k8s.io/gateway-api-inference-extension/charts/inferencepool

  5. Di kedua cluster, tandai resource InferencePool sebagai diekspor di kedua cluster:

    kubectl annotate inferencepool vllm-llama3-8b-instruct networking.gke.io/export="True" \
    --context=$CLUSTER1_CONTEXT

kubectl annotate inferencepool vllm-llama3-8b-instruct networking.gke.io/export="True" \
    --context=$CLUSTER2_CONTEXT

Men-deploy Inference Gateway lintas region

  1. Simpan manifes berikut sebagai mygateway.yaml:

    ---
kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: cross-region-gateway
  namespace: default
spec:
  gatewayClassName: gke-l7-cross-regional-internal-managed-mc
  addresses:
  -   type: networking.gke.io/ephemeral-ipv4-address/europe-west3
    value: "europe-west3"
  -   type: networking.gke.io/ephemeral-ipv4-address/us-east4
    value: "us-east4"
  listeners:
  -   name: http
    protocol: HTTP
    port: 80
    allowedRoutes:
      kinds:
      -   kind: HTTPRoute
      namespaces:
        from: All
---
apiVersion: gateway.networking.k8s.io/v1beta1
kind: HTTPRoute
metadata:
  name: vllm-llama3-8b-instruct-default
spec:
  parentRefs:
  -   name: cross-region-gateway
    kind: Gateway
  rules:
  -   backendRefs:
    -   group: networking.gke.io
      kind: GCPInferencePoolImport
      name: vllm-llama3-8b-instruct
---
kind: HealthCheckPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: health-check-policy
  namespace: default
spec:
  targetRef:
    group: "networking.gke.io"
    kind: GCPInferencePoolImport
    name: vllm-llama3-8b-instruct
  default:
    config:
      type: HTTP
      httpHealthCheck:
          requestPath: /health
          port: 8000

  2. Terapkan manifes ke cluster konfigurasi:

    kubectl apply -f mygateway.yaml --context=CLUSTER1_CONTEXT

    Ganti kode berikut:

    • CLUSTER1_CONTEXT: konteks untuk cluster pertama, misalnya gke_my-project_europe-west3-c_gke-west

Mengaktifkan pelaporan metrik kustom

  1. Buat file bernama metrics.yaml dengan konten berikut:

    apiVersion: autoscaling.gke.io/v1beta1
kind: AutoscalingMetric
metadata:
  name: gpu-cache
  namespace: default
spec:
  selector:
    matchLabels:
      app: vllm-llama3-8b-instruct
  endpoints:
  -   port: 8000
    path: /metrics
    metrics:
    -   name: vllm:kv_cache_usage_perc
      exportName: kv-cache
    -   name: vllm:gpu_cache_usage_perc
      exportName: kv-cache-old

  2. Untuk setiap cluster, terapkan konfigurasi metrik:

    kubectl apply -f metrics.yaml --context=CLUSTER1_CONTEXT
kubectl apply -f metrics.yaml --context=CLUSTER2_CONTEXT

    Untuk mengetahui definisi CLUSTER1_CONTEXT dan CLUSTER2_CONTEXT, lihat Menginstal resource kustom yang diperlukan.

Mengonfigurasi kebijakan load balancing

Bagian ini menjelaskan cara mengonfigurasi kebijakan load balancing. Kebijakan ini menentukan cara traffic didistribusikan di seluruh kumpulan inferensi Anda berdasarkan metrik kustom dan preferensi regional. Konfigurasi berikut menetapkan us-east4 sebagai region pilihan. Traffic meluas ke region lain hanya jika Metrik kustom gke.named_metrics.kv-cache di region us-east4 mencapai penggunaan 80%.

  • Untuk vLLM versi v0.10.2 dan yang lebih baru, gunakan metrik gke.named_metrics.kv-cache.
  • Untuk versi sebelumnya, gunakan metrik gke.named_metrics.kv-cache-old.

  1. Buat file bernama backend-policy.yaml dengan konten berikut:

    kind: GCPBackendPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: my-backend-policy
spec:
  targetRef:
    group: "networking.gke.io"
    kind: GCPInferencePoolImport
    name: vllm-llama3-8b-instruct
  default:
    timeoutSec: 600
    balancingMode: CUSTOM_METRICS
    trafficDuration: LONG
    customMetrics:
    -   name: gke.named_metrics.kv-cache
      maxUtilizationPercent: 80
      dryRun: false
    scopes:
    -   selector:
        gke.io/region: "us-east4"
      backendPreference: PREFERRED

  2. Terapkan kebijakan baru:

    kubectl apply -f backend-policy.yaml --context=CLUSTER1_CONTEXT

    Ganti CLUSTER1_CONTEXT dengan konteks untuk cluster pertama, misalnya gke_my-project_europe-west3-c_gke-west

Konfigurasi penskalaan otomatis

Untuk membantu memastikan bahwa setiap cluster dapat menangani peningkatan beban sebelum traffic meluas ke region lain, Anda perlu mengonfigurasi Horizontal-Pod-Autoscaler (HPA) untuk deployment server model Anda.

Prinsip konfigurasi utama

  • Gunakan metrik kustom yang sama: HPA harus dikonfigurasi untuk melakukan penskalaan berdasarkan metrik kustom yang sama dengan yang Anda gunakan di GCPBackendPolicy untuk Multi-Cluster Inference Gateway (misalnya, vllm:kv_cache_usage_perc). Pendekatan ini membantu memastikan bahwa keputusan load balancing dan penskalaan didorong oleh sinyal yang sama dari server inferensi Anda. Metrik yang Anda pilih harus memiliki nilai antara 0 dan 1 untuk menunjukkan pemanfaatan. Jika nilai metrik lebih besar dari 1, nilai tersebut ditafsirkan sebagai pemanfaatan 100% oleh load balancer, yang dapat menyebabkan perilaku perutean yang tidak terduga.

  • Tetapkan target HPA yang lebih rendah: nilai target untuk metrik dalam konfigurasi HPA harus ditetapkan lebih rendah daripada setelan maxUtilizationPercent yang ditentukan dalam GCPBackendPolicy. Dengan menetapkan target penggunaan HPA yang lebih rendah (misalnya, HPA melakukan penskalaan pada penggunaan rata-rata 50%), Anda memungkinkan cluster menambahkan lebih banyak replika sebelum batas load balancer (misalnya, penggunaan 80%) tercapai. Pendekatan ini membantu memaksimalkan kapasitas dalam Region pilihan. Target pemanfaatan yang lebih rendah juga membantu mencegah peluapan traffic prematur dengan mencadangkan ketersediaan tinggi lintas region yang elastis untuk saat region saat ini benar-benar mendekati batasnya.

  1. Beri pengguna kemampuan untuk membuat peran otorisasi yang diperlukan:

    kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)" --context=CLUSTER1_CONTEXT

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)" --context=CLUSTER2_CONTEXT

    Variabel CLUSTER1_CONTEXT dan CLUSTER2_CONTEXT ditentukan di bagian Instal resource kustom yang diperlukan.

  2. Untuk setiap cluster, terapkan manifes:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml --context=CLUSTER1_CONTEXT

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml --context=CLUSTER2_CONTEXT

  3. Izinkan akun layanan custom-metrics-stackdriver-adapter untuk membaca metrik Cloud Monitoring:

    PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")

gcloud projects add-iam-policy-binding projects/PROJECT_ID \
  --role roles/monitoring.viewer \
  --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.s3ns.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

    Ganti PROJECT_ID dengan project ID Anda

  4. Simpan manifes berikut ke file bernama pod-monitoring.yaml:

    apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: inference-server-podmon
spec:
  selector:
    matchLabels:
      app: vllm-llama3-8b-instruct
  endpoints:
  -   port: 8000
    path: /metrics
    interval: 5s

  5. Terapkan manifes ke kedua cluster:

    kubectl apply -f pod-monitoring.yaml --context=CLUSTER1_CONTEXT
kubectl apply -f pod-monitoring.yaml --context=CLUSTER2_CONTEXT

  6. Simpan manifes berikut ke file bernama hpa.yaml:

    apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: inference-server-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: vllm-llama3-8b-instruct
  minReplicas: 1
  maxReplicas: 10
  metrics:
  -   type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|vllm:gpu_cache_usage_perc|gauge
      target:
        type: AverageValue
        averageValue: "0.5"

  7. Terapkan manifes ke kedua cluster:

    kubectl apply -f hpa.yaml --context=CLUSTER1_CONTEXT
kubectl apply -f hpa.yaml --context=CLUSTER2_CONTEXT

Memverifikasi deployment

  1. Dapatkan alamat IP Gateway:

    export GW_IP=$(kubectl get gateway/cross-region-gateway -n default --context=CLUSTER1_CONTEXT -o jsonpath='{.status.addresses[0].value}')

echo ${GW_IP}

    Variabel CLUSTER1_CONTEXT ditentukan di bagian Instal resource kustom yang diperlukan.

  2. Mulai sesi sh interaktif di Pod sementara:

    kubectl run -it --rm --image=curlimages/curl curly --context=CLUSTER1_CONTEXT -- /bin/sh

    Variabel CLUSTER1_CONTEXT ditentukan di bagian Instal resource kustom yang diperlukan.

  3. Dari dalam Pod curly, kirim permintaan pengujian:

    curl -i -X POST <var>GW_IP</var>:80/v1/completions \
-H 'Content-Type: application/json' \
-d '{
  "model": "food-review-1",
  "prompt": "What is the best pizza in the world?",
  "max_tokens": 100,
  "temperature": 0
}'

    Ganti GW_IP dengan alamat IP gateway dari langkah sebelumnya.

Menguji beban gateway

  1. Terapkan beban berkelanjutan ke alamat IP Gateway menggunakan generator beban dalam jaringan VPC yang sama.

  2. Mulai dengan beban sedang yang Anda harapkan dapat ditangani oleh wilayah pilihan (us-east4).

  3. Tingkatkan rasio permintaan atau konkurensi pengujian beban Anda secara bertahap.

  4. Saat uji beban berjalan, pantau sistem di konsol Cloud de Confiance atau menggunakan kubectl:

    • Penskalaan Pod (HPA): periksa jumlah Pod di Deployment vllm-llama3-8b-instruct di kedua cluster.
    • Penskalaan node (autoscaler cluster): pantau jumlah node di node pool h100 di kedua cluster.
    • Metrik kustom: amati metrik vllm:kv_cache_usage_perc (untuk vllm versi v0.10.2 dan yang lebih tinggi) atau metrik vllm:gpu_cache_usage_perc (untuk vllm versi yang lebih rendah dari v.0.10.2) di Monitoring untuk deployment server model di kedua cluster.
    • Metrik Load Balancer: periksa metrik untuk Load Balancer yang terkait dengan cross-region-gateway di Monitoring.

Saat Anda meningkatkan beban, pemanfaatan di us-east4 akan meningkat. Saat HPA di cluster gke-east melakukan penskalaan horizontal dan penggunaan rata-rata mendekati nilai maxUtilization (80%) yang ditentukan dalam GCPBackendPolicy, load balancer akan mulai merutekan permintaan ke cluster gke-west di europe-west3.

Langkah berikutnya