全部产品
Search

搜索本产品

    Container Service for Kubernetes：Konfigurasikan kebijakan auto scaling untuk layanan menggunakan KServe

    文档中心

    Container Service for Kubernetes：Konfigurasikan kebijakan auto scaling untuk layanan menggunakan KServe

    更新时间：Dec 27, 2025

    Saat men-deploy dan mengelola layanan model KServe, Anda perlu menangani fluktuasi beban yang sangat dinamis pada layanan inferensi model. KServe mengintegrasikan Horizontal Pod Autoscaler (HPA) Kubernetes native dan controller penskalaan, sehingga memungkinkan penyesuaian jumlah pod layanan model secara otomatis berdasarkan pemanfaatan CPU, penggunaan memori, pemanfaatan GPU, serta metrik kinerja kustom guna memastikan kinerja dan stabilitas layanan. Topik ini menggunakan model Qwen-7B-Chat-Int8 dan GPU V100 untuk menunjukkan cara mengonfigurasi skalabilitas elastis untuk layanan menggunakan KServe.

    Prasyarat

    Konfigurasikan kebijakan auto scaling berdasarkan CPU atau memori

    Auto scaling dalam mode Raw Deployment mengandalkan mekanisme Horizontal Pod Autoscaler (HPA) Kubernetes. HPA merupakan metode auto scaling dasar yang secara dinamis menyesuaikan jumlah replika pod dalam ReplicaSet berdasarkan pemanfaatan CPU atau memori pod.

    Bagian ini menunjukkan cara mengonfigurasi auto scaling berdasarkan pemanfaatan CPU. Untuk informasi selengkapnya tentang mekanisme HPA, lihat dokumentasi Kubernetes tentang Horizontal Pod Autoscaling.

    1. Jalankan perintah berikut untuk mengirimkan layanan.

      arena serve kserve \
    --name=sklearn-iris \
    --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/ai-sample/kserve-sklearn-server:v0.12.0 \
    --cpu=1 \
    --memory=200Mi \
    --scale-metric=cpu \
    --scale-target=10 \
    --min-replicas=1 \
    --max-replicas=10 \
    "python -m sklearnserver --model_name=sklearn-iris --model_dir=/models --http_port=8080"

      Parameter-parameter tersebut adalah sebagai berikut:

      Parameter

      Deskripsi

      --scale-metric

      Metrik penskalaan. Nilai yang valid adalah cpu dan memory. Contoh ini menggunakan cpu.

      --scale-target

      Ambang batas penskalaan, dalam persentase.

      --min-replicas

      Jumlah minimum replika. Nilai ini harus berupa bilangan bulat lebih besar dari 0. Kebijakan HPA tidak mendukung penskalaan hingga 0.

      --max-replicas

      Jumlah maksimum replika. Nilai ini harus berupa bilangan bulat lebih besar dari nilai minReplicas.

      Output yang Diharapkan:

      inferenceservice.serving.kserve.io/sklearn-iris created
INFO[0002] The Job sklearn-iris has been submitted successfully 
INFO[0002] You can run `arena serve get sklearn-iris --type kserve -n default` to check the job status

      Output tersebut menunjukkan bahwa layanan sklearn-iris telah dibuat.

    2. Jalankan perintah berikut untuk menyiapkan permintaan input inferensi.

      Buat file bernama iris-input.json dan tambahkan konten JSON berikut. Konten ini merupakan data masukan untuk prediksi model.

      cat <<EOF > "./iris-input.json"
{
  "instances": [
    [6.8,  2.8,  4.8,  1.4],
    [6.0,  3.4,  4.5,  1.6]
  ]
}
EOF

    3. Jalankan perintah berikut untuk mengakses layanan dan melakukan inferensi.

      # Dapatkan alamat IP load balancer dari layanan bernama nginx-ingress-lb di namespace kube-system. Ini adalah titik masuk untuk akses eksternal.
NGINX_INGRESS_IP=`kubectl -n kube-system get svc nginx-ingress-lb -ojsonpath='{.status.loadBalancer.ingress[0].ip}'`
# Dapatkan URL Inference Service bernama sklearn-iris dan ekstrak hostname-nya untuk digunakan nanti.
SERVICE_HOSTNAME=$(kubectl get inferenceservice sklearn-iris -o jsonpath='{.status.url}' | cut -d "/" -f 3)
# Gunakan perintah curl untuk mengirim permintaan ke layanan model. Header permintaan menentukan hostname target (SERVICE_HOSTNAME yang diperoleh sebelumnya) dan tipe konten JSON. -d @./iris-input.json menentukan bahwa badan permintaan berasal dari file lokal iris-input.json, yang berisi data masukan yang diperlukan untuk prediksi model.
curl -H "Host: $SERVICE_HOSTNAME" -H "Content-Type: application/json" \
     http://$NGINX_INGRESS_IP:80/v1/models/sklearn-iris:predict -d @./iris-input.json

      Output yang Diharapkan:

      {"predictions":[1,1]}%

      Output tersebut menunjukkan bahwa dua inferensi telah dijalankan, dan tanggapannya konsisten.

    4. Jalankan perintah berikut untuk memulai uji stres.

      Catatan

      Untuk informasi selengkapnya tentang alat uji stres Hey, lihat Hey.

      hey -z 2m -c 20 -m POST -host $SERVICE_HOSTNAME -H "Content-Type: application/json" -D ./iris-input.json http://${NGINX_INGRESS_IP}:80/v1/models/sklearn-iris:predict

    5. Saat uji stres sedang berjalan, buka terminal lain dan jalankan perintah berikut untuk melihat status penskalaan layanan.

      kubectl describe hpa sklearn-iris-predictor

      Output yang Diharapkan:

      Perluas untuk melihat status penskalaan layanan

      Name:                                                  sklearn-iris-predictor
Namespace:                                             default
Labels:                                                app=isvc.sklearn-iris-predictor
                                                       arena.kubeflow.org/uid=3399d840e8b371ed7ca45dda29debeb1
                                                       chart=kserve-0.1.0
                                                       component=predictor
                                                       heritage=Helm
                                                       release=sklearn-iris
                                                       serving.kserve.io/inferenceservice=sklearn-iris
                                                       servingName=sklearn-iris
                                                       servingType=kserve
Annotations:                                           arena.kubeflow.org/username: kubecfg:certauth:admin
                                                       serving.kserve.io/deploymentMode: RawDeployment
CreationTimestamp:                                     Sat, 11 May 2024 17:15:47 +0800
Reference:                                             Deployment/sklearn-iris-predictor
Metrics:                                               ( current / target )
  resource cpu on pods  (as a percentage of request):  0% (2m) / 10%
Min replicas:                                          1
Max replicas:                                          10
Behavior:
  Scale Up:
    Stabilization Window: 0 seconds
    Select Policy: Max
    Policies:
      - Type: Pods     Value: 4    Period: 15 seconds
      - Type: Percent  Value: 100  Period: 15 seconds
  Scale Down:
    Select Policy: Max
    Policies:
      - Type: Percent  Value: 100  Period: 15 seconds
Deployment pods:       10 current / 10 desired
Conditions:
  Type            Status  Reason               Message
  ----            ------  ------               -------
  AbleToScale     True    ScaleDownStabilized  recent recommendations were higher than current one, applying the highest recent recommendation
  ScalingActive   True    ValidMetricFound     the HPA was able to successfully calculate a replica count from cpu resource utilization (percentage of request)
  ScalingLimited  False   DesiredWithinRange   the desired count is within the acceptable range
Events:
  Type    Reason             Age                  From                       Message
  ----    ------             ----                 ----                       -------
  Normal  SuccessfulRescale  38m                  horizontal-pod-autoscaler  New size: 8; reason: cpu resource utilization (percentage of request) above target
  Normal  SuccessfulRescale  28m                  horizontal-pod-autoscaler  New size: 7; reason: All metrics below target
  Normal  SuccessfulRescale  27m                  horizontal-pod-autoscaler  New size: 1; reason: All metrics below target

      Bagian Events pada output menunjukkan bahwa HPA secara otomatis menyesuaikan jumlah replika berdasarkan penggunaan CPU. Misalnya, jumlah replika berubah menjadi 8, 7, dan 1 pada waktu yang berbeda. Hal ini menunjukkan bahwa HPA dapat melakukan penskalaan otomatis berdasarkan penggunaan CPU.

    Konfigurasikan kebijakan skalabilitas elastis berbasis metrik kustom berdasarkan pemanfaatan GPU

    Auto scaling berbasis metrik kustom mengandalkan komponen ack-alibaba-cloud-metrics-adapter yang disediakan oleh ACK dan mekanisme HPA Kubernetes. Untuk informasi selengkapnya, lihat Horizontal pod autoscaling berdasarkan metrik Prometheus Alibaba Cloud.

    Contoh berikut menunjukkan cara mengonfigurasi auto scaling berbasis metrik kustom berdasarkan pemanfaatan GPU pod.

    1. Persiapkan data model Qwen-7B-Chat-Int8. Untuk informasi selengkapnya, lihat Deploy layanan inferensi vLLM.

    2. Konfigurasikan metrik GPU kustom. Untuk informasi selengkapnya, lihat Implementasikan skalabilitas elastis berdasarkan metrik GPU.

    3. Jalankan perintah berikut untuk men-deploy layanan vLLM.

      arena serve kserve \
    --name=qwen \
    --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:0.4.1 \
    --gpus=1 \
    --cpu=4 \
    --memory=12Gi \
    --scale-metric=DCGM_CUSTOM_PROCESS_SM_UTIL \
    --scale-target=50 \
    --min-replicas=1 \
    --max-replicas=2 \
    --data="llm-model:/mnt/models/Qwen-7B-Chat-Int8" \
    "python3 -m vllm.entrypoints.openai.api_server --port 8080 --trust-remote-code --served-model-name qwen --model /mnt/models/Qwen-7B-Chat-Int8 --gpu-memory-utilization 0.95 --quantization gptq --max-model-len=6144"

      Output yang Diharapkan:

      inferenceservice.serving.kserve.io/qwen created
INFO[0002] The Job qwen has been submitted successfully 
INFO[0002] You can run `arena serve get qwen --type kserve -n default` to check the job status

      Output tersebut menunjukkan bahwa layanan inferensi telah di-deploy.

    4. Jalankan perintah berikut untuk menggunakan alamat gerbang NGINX Ingress guna mengakses layanan inferensi dan menguji apakah layanan vLLM berjalan dengan benar.

      # Dapatkan alamat IP Nginx Ingress.
NGINX_INGRESS_IP=$(kubectl -n kube-system get svc nginx-ingress-lb -ojsonpath='{.status.loadBalancer.ingress[0].ip}')
# Dapatkan hostname Inference Service.
SERVICE_HOSTNAME=$(kubectl get inferenceservice qwen -o jsonpath='{.status.url}' | cut -d "/" -f 3)
# Kirim permintaan untuk mengakses layanan inferensi.
curl -H "Host: $SERVICE_HOSTNAME" -H "Content-Type: application/json" http://$NGINX_INGRESS_IP:80/v1/chat/completions -d '{"model": "qwen", "messages": [{"role": "user", "content": "Test"}], "max_tokens": 10, "temperature": 0.7, "top_p": 0.9, "seed": 10}'

      Output yang Diharapkan:

      {"id":"cmpl-77088b96abe744c89284efde2e779174","object":"chat.completion","created":1715590010,"model":"qwen","choices":[{"index":0,"message":{"role":"assistant","content":"OK, what do you need to test?<|im_end|>"},"logprobs":null,"finish_reason":"length","stop_reason":null}],"usage":{"prompt_tokens":10,"total_tokens":20,"completion_tokens":10}}%

      Output tersebut menunjukkan bahwa permintaan telah dikirim ke server dan server mengembalikan respons JSON yang diharapkan.

    5. Jalankan perintah berikut untuk melakukan uji stres pada layanan.

      Catatan

      Untuk informasi selengkapnya tentang alat uji stres Hey, lihat Hey.

      hey -z 2m -c 5 -m POST -host $SERVICE_HOSTNAME -H "Content-Type: application/json" -d '{"model": "qwen", "messages": [{"role": "user", "content": "Test"}], "max_tokens": 10, "temperature": 0.7, "top_p": 0.9, "seed": 10}' http://$NGINX_INGRESS_IP:80/v1/chat/completions

    6. Selama uji stres berlangsung, buka terminal baru dan jalankan perintah berikut untuk melihat status penskalaan layanan.

      kubectl describe hpa qwen-hpa

      Output yang Diharapkan:

      Perluas untuk melihat status penskalaan qwen-hpa

      Name:                                     qwen-hpa
Namespace:                                default
Labels:                                   <none>
Annotations:                              <none>
CreationTimestamp:                        Tue, 14 May 2024 14:57:03 +0800
Reference:                                Deployment/qwen-predictor
Metrics:                                  ( current / target )
  "DCGM_CUSTOM_PROCESS_SM_UTIL" on pods:  0 / 50
Min replicas:                             1
Max replicas:                             2
Deployment pods:                          1 current / 1 desired
Conditions:
  Type            Status  Reason            Message
  ----            ------  ------            -------
  AbleToScale     True    ReadyForNewScale  recommended size matches current size
  ScalingActive   True    ValidMetricFound  the HPA was able to successfully calculate a replica count from pods metric DCGM_CUSTOM_PROCESS_SM_UTIL
  ScalingLimited  True    TooFewReplicas    the desired replica count is less than the minimum replica count
Events:
  Type    Reason             Age   From                       Message
  ----    ------             ----  ----                       -------
  Normal  SuccessfulRescale  43m   horizontal-pod-autoscaler  New size: 2; reason: pods metric DCGM_CUSTOM_PROCESS_SM_UTIL above target
  Normal  SuccessfulRescale  34m   horizontal-pod-autoscaler  New size: 1; reason: All metrics below target

      Output tersebut menunjukkan bahwa jumlah pod bertambah menjadi 2 selama uji stres. Setelah pengujian berakhir, jumlah pod berkurang kembali menjadi 1 setelah sekitar 5 menit. Hal ini menunjukkan bahwa KServe dapat melakukan auto scaling berbasis metrik kustom berdasarkan pemanfaatan GPU pod.

    Konfigurasikan kebijakan auto scaling terjadwal

    Auto scaling terjadwal memerlukan komponen ack-kubernetes-cronhpa-controller yang disediakan oleh ACK. Komponen ini memungkinkan Anda mengubah jumlah replika aplikasi pada waktu atau interval tertentu untuk menangani perubahan beban yang dapat diprediksi.

    1. Instal komponen CronHPA. Untuk informasi selengkapnya, lihat Gunakan CronHPA untuk penskalaan horizontal terjadwal kontainer.

    2. Persiapkan data model Qwen-7B-Chat-Int8. Untuk informasi selengkapnya, lihat Deploy layanan inferensi vLLM.

    3. Jalankan perintah berikut untuk men-deploy layanan vLLM.

      arena serve kserve \
    --name=qwen-cronhpa \
    --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:0.4.1 \
    --gpus=1 \
    --cpu=4 \
    --memory=12Gi \
    --annotation="serving.kserve.io/autoscalerClass=external" \
    --data="llm-model:/mnt/models/Qwen-7B-Chat-Int8" \
   "python3 -m vllm.entrypoints.openai.api_server --port 8080 --trust-remote-code --served-model-name qwen --model /mnt/models/Qwen-7B-Chat-Int8 --gpu-memory-utilization 0.95 --quantization gptq --max-model-len=6144"

      Output yang Diharapkan:

      inferenceservice.serving.kserve.io/qwen-cronhpa created
INFO[0004] The Job qwen-cronhpa has been submitted successfully 
INFO[0004] You can run `arena serve get qwen-cronhpa --type kserve -n default` to check the job status

    4. Jalankan perintah berikut untuk menguji apakah layanan vLLM berjalan dengan benar.

      # Dapatkan alamat IP Nginx Ingress.
NGINX_INGRESS_IP=`kubectl -n kube-system get svc nginx-ingress-lb -ojsonpath='{.status.loadBalancer.ingress[0].ip}'`
# Dapatkan hostname Inference Service.
SERVICE_HOSTNAME=$(kubectl get inferenceservice qwen-cronhpa -o jsonpath='{.status.url}' | cut -d "/" -f 3)
# Kirim permintaan untuk mengakses layanan inferensi.
curl -H "Host: ${SERVICE_HOSTNAME}" -H "Content-Type: application/json" \
     http://$NGINX_INGRESS_IP:80/v1/chat/completions -X POST \
     -d '{"model": "qwen", "messages": [{"role": "user", "content": "Hello"}], "max_tokens": 512, "temperature": 0.7, "top_p": 0.9, "seed": 10, "stop":["<|endoftext|>", "<|im_end|>", "<|im_start|>"]}'

      Output yang Diharapkan:

      {"id":"cmpl-b7579597aa284f118718b22b83b726f8","object":"chat.completion","created":1715589652,"model":"qwen","choices":[{"index":0,"message":{"role":"assistant","content":"OK, what do you need to test?<|im_end|>"},"logprobs":null,"finish_reason":"length","stop_reason":null}],"usage":{"prompt_tokens":10,"total_tokens":20,"completion_tokens":10}}%

      Output tersebut menunjukkan bahwa permintaan telah dikirim ke layanan dan layanan mengembalikan respons JSON yang diharapkan.

    5. Jalankan perintah berikut untuk mengonfigurasi auto scaling terjadwal.

      Perluas untuk melihat perintah konfigurasi auto scaling terjadwal

      kubectl apply -f- <<EOF
apiVersion: autoscaling.alibabacloud.com/v1beta1
kind: CronHorizontalPodAutoscaler
metadata:
  name: qwen-cronhpa
  namespace: default 
spec:
   scaleTargetRef:
      apiVersion: apps/v1
      kind: Deployment
      name: qwen-cronhpa-predictor
   jobs:
   # Tambah skala setiap hari pukul 10:30.
   - name: "scale-up"
     schedule: "0 30 10 * * *"
     targetSize: 2
     runOnce: false
  # Kurangi skala setiap hari pukul 12:00.
   - name: "scale-down"
     schedule: "0 0 12 * * *"
     targetSize: 1
     runOnce: false
EOF

      Output yang Diharapkan:

      Perluas untuk melihat konfigurasi penskalaan yang telah ditetapkan

      Name:         qwen-cronhpa
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  autoscaling.alibabacloud.com/v1beta1
Kind:         CronHorizontalPodAutoscaler
Metadata:
  Creation Timestamp:  2024-05-12T14:06:49Z
  Generation:          2
  Resource Version:    9205625
  UID:                 b9e72da7-262e-4***-b***-26586b7****c
Spec:
  Jobs:
    Name:         scale-up
    Schedule:     0 30 10 * * *
    Target Size:  2
    Name:         scale-down
    Schedule:     0 0 12 * * *
    Target Size:  1
  Scale Target Ref:
    API Version:  apps/v1
    Kind:         Deployment
    Name:         qwen-cronhpa-predictor
Status:
  Conditions:
    Job Id:           3972f7cc-bab0-482e-8cbe-7c4*******5
    Last Probe Time:  2024-05-12T14:06:49Z
    Message:          
    Name:             scale-up
    Run Once:         false
    Schedule:         0 30 10 * * *
    State:            Submitted
    Target Size:      2
    Job Id:           36a04605-0233-4420-967c-ac2********6
    Last Probe Time:  2024-05-12T14:06:49Z
    Message:          
    Name:             scale-down
    Run Once:         false
    Schedule:         0 0 12 * * *
    State:            Submitted
    Target Size:      1
  Scale Target Ref:
    API Version:  apps/v1
    Kind:         Deployment
    Name:         qwen-cronhpa-predictor
Events:           <none>

      Output tersebut menunjukkan bahwa rencana auto scaling terjadwal telah dikonfigurasi untuk CRD qwen-cronhpa. Berdasarkan jadwal tersebut, jumlah pod dalam deployment qwen-cronhpa-predictor secara otomatis disesuaikan pada waktu-waktu tertentu setiap hari untuk memenuhi persyaratan penskalaan yang telah ditetapkan.

    Referensi

    Untuk informasi selengkapnya tentang skalabilitas elastis ACK, lihat Auto Scaling.