Menskalakan hingga nol menggunakan KEDA

Menginstal KEDA

KEDA adalah komponen yang melengkapi Horizontal Pod Autoscaler Kubernetes. Dengan KEDA, Anda dapat menskalakan Deployment ke nol Pod dan dari nol Pod ke satu Pod. Deployment adalah objek Kubernetes API yang memungkinkan Anda menjalankan beberapa replika Pod yang didistribusikan di antara node dalam cluster. Algoritma Horizontal Pod Autoscaler standar diterapkan setelah GKE membuat setidaknya satu Pod.

Setelah GKE menskalakan Deployment ke nol Pod, karena tidak ada Pod yang berjalan, penskalaan otomatis tidak dapat mengandalkan metrik Pod seperti penggunaan CPU. Akibatnya, KEDA memungkinkan pengambilan metrik yang berasal dari luar cluster menggunakan penerapan External Metrics API Kubernetes. Anda dapat menggunakan API ini untuk melakukan penskalaan otomatis berdasarkan metrik seperti jumlah pesan yang belum diproses pada langganan Pub/Sub. Lihat dokumentasi KEDA untuk mengetahui daftar semua sumber metrik yang didukung.

Instal KEDA di cluster Anda dengan Helm atau dengan kubectl.

helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda --create-namespace --namespace keda

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}.svc.id.goog/subject/ns/keda/sa/keda-operator

kubectl apply --server-side  -f https://github.com/kedacore/keda/releases/download/v2.15.1/keda-2.15.1.yaml

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}.svc.id.goog/subject/ns/keda/sa/keda-operator

Pastikan semua resource KEDA muncul di namespace keda:

kubectl get all -n keda

Untuk mengetahui informasi selengkapnya tentang desain dan resource KEDA, lihat dokumentasi KEDA.

Menskalakan beban kerja Pub/Sub Anda ke nol

Bagian ini menjelaskan beban kerja yang memproses pesan dari langganan Pub/Sub, menangani setiap pesan, dan mengonfirmasi penyelesaiannya. Workload diskalakan secara dinamis: seiring bertambahnya jumlah pesan yang belum dikonfirmasi, penskalaan otomatis membuat lebih banyak Pod untuk memastikan pemrosesan tepat waktu.

Penskalaan ke nol memastikan bahwa tidak ada Pod yang di-instantiate saat tidak ada pesan yang diterima selama beberapa waktu. Hal ini menghemat resource karena tidak ada Pod yang tetap tidak aktif dalam jangka waktu yang lama.

Men-deploy workload Pub/Sub

Men-deploy sampel workload yang memproses pesan yang diantrekan di topik Pub/Sub. Untuk menyimulasikan workload yang realistis, program contoh ini menunggu tiga detik sebelum mengonfirmasi pesan. Beban kerja dikonfigurasi untuk berjalan di bawah akun layanan keda-pubsub-sa.

Jalankan perintah berikut untuk membuat topik dan langganan Pub/Sub, mengonfigurasi izinnya, dan membuat Deployment yang memulai workload di namespace keda-pubsub.

gcloud pubsub topics create keda-echo
gcloud pubsub subscriptions create keda-echo-read --topic=keda-echo
gcloud projects add-iam-policy-binding projects/${PROJECT_ID}  \
    --role=roles/pubsub.subscriber \
  --member=principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/keda-pubsub/sa/keda-pubsub-sa

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/cost-optimization/gke-keda/cloud-pubsub/deployment/keda-pubsub-with-workload-identity.yaml

Mengonfigurasi penskalaan hingga nol

Untuk mengonfigurasi workload Pub/Sub agar diskalakan ke nol, gunakan KEDA untuk menentukan resource ScaledObject guna menentukan cara deployment harus diskalakan. Kemudian, KEDA akan otomatis membuat dan mengelola objek HorizontalPodAutoscaler (HPA) yang mendasarinya.

1. Buat resource ScaledObject untuk menjelaskan perilaku penskalaan otomatis yang diharapkan:

   curl https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/cost-optimization/gke-keda/cloud-pubsub/deployment/keda-pubsub-scaledobject.yaml | envsubst | kubectl apply -f -
   

   Tindakan ini akan membuat objek berikut:

   apiVersion: keda.sh/v1alpha1
   kind: ScaledObject
   metadata:
     name: keda-pubsub
     namespace: keda-pubsub
   spec:
     maxReplicaCount: 5
     scaleTargetRef:
       name: keda-pubsub
     triggers:
       - type: gcp-pubsub
         authenticationRef:
           name: keda-auth
         metadata:
           subscriptionName: "projects/${PROJECT_ID}/subscriptions/keda-echo-read"
   

2. Periksa objek HorizontalPodAutoscaler (HPA) yang dibuat KEDA berdasarkan objek ScaledObject:

   kubectl get hpa keda-hpa-keda-pubsub -n keda-pubsub -o yaml
   

   Anda dapat membaca selengkapnya tentang penskalaan otomatis di dokumentasi Kubernetes.

3. Tunggu hingga KEDA mengonfirmasi bahwa langganan Pub/Sub kosong, dan menskalakan Deployment ke nol replika.

   Periksa penskalaan otomatis workload:

   kubectl describe hpa keda-hpa-keda-pubsub -n keda-pubsub
   

   Perhatikan bahwa dalam respons perintah, kondisi ScalingActive adalah salah (false). Pesan terkait menunjukkan bahwa Horizontal Pod Autoscaler mengakui bahwa KEDA menskalakan deployment menjadi nol, yang kemudian berhenti beroperasi hingga Deployment diskalakan kembali hingga satu Pod.

   Name:                                                  keda-hpa-keda-pubsub
   Namespace:                                             keda-pubsub
   Metrics:                                               ( current / target )
     "s0-gcp-ps-projects-[...]]" (target average value):  0 / 10
   Min replicas:                                          1
   Max replicas:                                          5
   Deployment pods:                                       5 current / 5 desired
   Conditions:
     Type            Status  Reason               Message
     ----            ------  ------               -------
     AbleToScale     True    ScaleDownStabilized  recent recommendations were higher than current one [...]
     ScalingActive   False   ScalingDisabled      scaling is disabled since the replica count of the target is zero
     ScalingLimited  True    TooManyReplicas      the desired replica count is more than the maximum replica count
   

Memicu peningkatan skala

Untuk memicu Deployment agar di-scale up:

1. Mengantrekan pesan di topik Pub/Sub:

   for num in {1..20}
   do
     gcloud pubsub topics publish keda-echo --project=${PROJECT_ID} --message="Test"
   done
   

2. Verifikasi bahwa Deployment sedang di-scaling up:

   kubectl get deployments -n keda-pubsub
   

   Dalam output, amati bahwa kolom 'Ready' menampilkan satu replika:

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   keda-pubsub   1/1     1            1           2d
   

KEDA meningkatkan skala Deployment setelah mengamati bahwa antrean tidak kosong.

Menskalakan workload LLM Anda ke nol

Bagian ini menjelaskan workload Model Bahasa Besar (LLM) yang men-deploy server Ollama dengan GPU terlampir. Ollama memungkinkan menjalankan LLM populer seperti Gemma dan Lamma 2, dan mengekspos fiturnya terutama melalui HTTP.

Instal add-on KEDA-HTTP

Menskalakan layanan HTTP ke nol Pod selama periode tidak ada aktivitas menyebabkan kegagalan permintaan, karena tidak ada backend untuk menangani permintaan.

Bagian ini menunjukkan cara menyelesaikan masalah ini menggunakan add-on KEDA-HTTP. KEDA-HTTP memulai proxy HTTP yang menerima permintaan pengguna dan meneruskannya ke Layanan yang dikonfigurasi untuk menskalakan ke nol. Jika Service tidak memiliki Pod, proxy akan memicu Service untuk melakukan penskalaan, dan melakukan buffering permintaan hingga Service telah melakukan penskalaan ke setidaknya satu Pod.

Instal add-on KEDA-HTTP menggunakan Helm. Untuk mengetahui informasi selengkapnya, lihat dokumentasi KEDA-HTTP.

helm repo add ollama-helm https://otwld.github.io/ollama-helm/
helm repo update

# Set the proxy timeout to 120s, giving Ollama time to start.
helm install http-add-on kedacore/keda-add-ons-http  \
  --create-namespace --namespace keda \
  --set interceptor.responseHeaderTimeout=120s

Men-deploy workload LLM Ollama

Untuk men-deploy workload LLM Ollama:

1. Buat node pool yang berisi g2-standard-4 node dengan GPU terpasang, dan konfigurasi penskalaan otomatis cluster untuk menyediakan antara nol dan dua node:

   gcloud container node-pools create gpu --machine-type=g2-standard-4 \
       --location=${LOCATION} --cluster=scale-to-zero \
       --min-nodes 0 --max-nodes 2 --num-nodes=1 --enable-autoscaling
   

2. Tambahkan repositori chart Helm Ollama resmi, dan perbarui repositori klien Helm lokal Anda:

   helm repo add ollama-helm https://otwld.github.io/ollama-helm/
   helm repo update
   

3. Deploy server Ollama menggunakan chart Helm:

   helm install ollama ollama-helm/ollama --create-namespace --namespace ollama \
     -f https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/cost-optimization/gke-keda/ollama/helm-values-ollama.yaml
   

   Konfigurasi helm-values-ollama.yaml menentukan model LLM yang akan dimuat, persyaratan GPU, dan port TCP untuk server Ollama.

Mengonfigurasi penskalaan hingga nol

Untuk mengonfigurasi workload Ollama agar diskalakan ke nol, KEDA-HTTP menggunakan HTTPScaledObject.

1. Buat resource HTTPScaledObject untuk menjelaskan perilaku penskalaan otomatis yang diharapkan:

   kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/cost-optimization/gke-keda/ollama/keda-ollama-httpscaledobject.yaml
   

   Tindakan ini akan membuat objek HTTPScaledObject yang menentukan kolom berikut:

   • scaleTargetRef: menentukan Layanan yang harus meneruskan permintaan KEDA-HTTP. Dalam contoh ini, semua permintaan dengan host ollama.ollama dirutekan ke server Ollama.
   • scaledownPeriod: menentukan (dalam detik) seberapa cepat penskalaan ke bawah saat tidak ada permintaan yang diterima.
   • replicas: menentukan jumlah minimum dan maksimum Pod yang akan dipertahankan untuk deployment Ollama.
   • scalingMetric: menentukan metrik yang digunakan untuk mendorong penskalaan otomatis, seperti tingkat permintaan dalam contoh ini. Untuk opsi metrik lainnya, lihat dokumentasi KEDA-HTTP.

   kind: HTTPScaledObject
   apiVersion: http.keda.sh/v1alpha1
   metadata:
       namespace: ollama
       name: ollama
   spec:
       hosts:
       - ollama.ollama
       scaleTargetRef:
           name: ollama
           kind: Deployment
           apiVersion: apps/v1
           service: ollama
           port: 11434
       replicas:
           min: 0
           max: 2
       scaledownPeriod: 3600
       scalingMetric:
           requestRate:
               targetValue: 20
   

2. Jalankan perintah berikut untuk memverifikasi bahwa KEDA-HTTP telah berhasil memproses HTTPScaledObject yang dibuat pada langkah sebelumnya:

   kubectl get hpa,scaledobject -n ollama
   

   Output menampilkan resource HorizontalPodAutoscaler (dibuat oleh KEDA), dan ScaledObject (dibuat oleh KEDA-HTTP):

   NAME                                                  REFERENCE           TARGETS       MINPODS   MAXPODS   REPLICAS   AGE
   horizontalpodautoscaler.autoscaling/keda-hpa-ollama   Deployment/ollama   0/100 (avg)   1         2         1          2d
   
   NAME                          SCALETARGETKIND      SCALETARGETNAME   MIN   MAX   TRIGGERS        AUTHENTICATION   READY   ACTIVE   FALLBACK   PAUSED    AGE
   scaledobject.keda.sh/ollama   apps/v1.Deployment   ollama            0     2     external-push                    True    False    False      Unknown   2d
   

3. Verifikasi bahwa Deployment diskalakan ke nol Pod.

   Tunggu jangka waktu yang ditetapkan di kolom scaledownPeriod dan jalankan perintah:

   kubectl get deployments -n ollama
   

   Output menunjukkan bahwa KEDA menurunkan skala deployment Ollama, dan tidak ada Pod yang berjalan:

   NAME     READY   UP-TO-DATE   AVAILABLE   AGE
   ollama   0/0     0            0           2d
   

Memicu peningkatan skala

Untuk memicu Penskalaan Deployment, panggil layanan Ollama menggunakan proxy yang disiapkan oleh add-on KEDA-HTTP. Hal ini menyebabkan nilai metrik kecepatan permintaan meningkat, dan memicu pembuatan Pod pertama.

Gunakan kemampuan penerusan port kubectl untuk mengakses proxy karena proxy tidak diekspos secara eksternal.

kubectl port-forward svc/keda-add-ons-http-interceptor-proxy -n keda 8080:8080 &

# Set the 'Host' HTTP header so that the proxy routes requests to the Ollama server.
curl -H "Host: ollama.ollama" \
  http://localhost:8080/api/generate \
  -d '{ "model": "gemma:7b", "prompt": "Hello!" }'

Perintah curl mengirimkan perintah "Halo!" ke model Gemma. Amati token jawaban yang ditampilkan dalam respons. Untuk mengetahui spesifikasi API, lihat panduan Ollama.