Implementasikan auto scaling berdasarkan metrik GPU - Container Service for Kubernetes

Kubernetes menyediakan mekanisme Custom Metrics yang terintegrasi dengan Managed Service for Prometheus untuk mengumpulkan metrik GPU. Topik ini menjelaskan cara menerapkan Managed Service for Prometheus dan memberikan contoh penggunaan Managed Service for Prometheus untuk memantau metrik GPU serta mengimplementasikan auto scaling untuk container.

Prasyarat

Anda telah menambahkan node GPU ke kluster Anda atau membuat kluster GPU khusus.

Ikhtisar

Dalam skenario komputasi kinerja tinggi (HPC), seperti pelatihan model pembelajaran mendalam dan inferensi, GPU sering digunakan untuk mempercepat komputasi. Untuk menghemat biaya, Anda dapat menerapkan auto scaling berdasarkan metrik GPU, seperti pemanfaatan GPU dan penggunaan memori GPU.

Secara default, Kubernetes menggunakan CPU dan memori sebagai metrik untuk Horizontal Pod Autoscaler (HPA). Untuk skenario yang lebih kompleks—misalnya, auto scaling berdasarkan metrik GPU—gunakan Prometheus Adapter untuk menyesuaikan metrik GPU yang dikumpulkan oleh Prometheus, lalu perluas metrik HPA melalui Custom Metrics API. Alur kerja ini memungkinkan Anda mengimplementasikan auto scaling berdasarkan metrik seperti pemanfaatan GPU dan penggunaan memori GPU. Gambar berikut menunjukkan cara kerja auto scaling GPU.

Langkah 1: Terapkan Managed Service for Prometheus dan Metrics Adapter

Aktifkan pemantauan Prometheus.
Catatan
Jika Anda telah menginstal Prometheus saat membuat kluster, Anda tidak perlu menginstalnya lagi.
Instal dan konfigurasikan ack-alibaba-cloud-metrics-adapter.
1. Obtain the HTTP API address
1. Masuk ke ARMS console.
2. Di panel navigasi kiri, pilih Managed Service for Prometheus > Instances.
3. Di bagian atas halaman, pilih wilayah tempat kluster Container Service for Kubernetes (ACK) Anda berada, lalu klik nama instans target.
4. Pada halaman Settings, klik tab Settings. Di bagian HTTP API URL (Grafana Read Address), salin alamat jaringan internal.
2. Configure the Prometheus URL
1. Masuk ke ACK console. Di panel navigasi kiri, pilih Marketplace > Marketplace.
2. Pada halaman App Marketplace, klik tab App Catalog. Cari dan klik ack-alibaba-cloud-metrics-adapter.
3. Pada halaman ack-alibaba-cloud-metrics-adapter, klik Deploy.
4. Pada wizard Basic Information, pilih kluster dan namespace, lalu klik Next.
5. Pada wizard Parameters, pilih Chart Version. Di bagian Parameters, atur nilai parameter url Prometheus ke alamat HTTP API yang telah Anda peroleh, lalu klik OK.

Langkah 2: Konfigurasikan Aturan Adapter untuk metrik GPU

1. Kueri metrik GPU

Anda dapat melakukan kueri terhadap metrik GPU. Untuk informasi selengkapnya, lihat Deskripsi metrik pemantauan.

2. Konfigurasikan Aturan Adapter

Masuk ke ACK console. Di panel navigasi kiri, klik Clusters.
Pada halaman Clusters, temukan kluster yang diinginkan dan klik namanya. Di panel navigasi kiri, pilih Applications > Helm.

Pada kolom Actions rilis Helm, klik Update untuk ack-alibaba-cloud-metrics-adapter. Tambahkan rules berikut ke dalam bidang custom.

Aturan lengkap

- metricsQuery: avg(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>)
  resources:
    overrides:
      NodeName:
        resource: node
  seriesQuery: DCGM_FI_DEV_GPU_UTIL{} # GPU utilization
- metricsQuery: avg(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>)
  resources:
    overrides:
      NamespaceName:
        resource: namespace
      NodeName:
        resource: node
      PodName:
        resource: pod
  seriesQuery: DCGM_CUSTOM_PROCESS_SM_UTIL{} # Container GPU utilization.
- metricsQuery: sum(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>)
  resources:
    overrides:
      NodeName:
        resource: node
  seriesQuery: DCGM_FI_DEV_FB_USED{} # GPU memory usage.
- metricsQuery: sum(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>)
  resources:
    overrides:
      NamespaceName:
        resource: namespace
      NodeName:
        resource: node
      PodName:
        resource: pod
  seriesQuery: DCGM_CUSTOM_PROCESS_MEM_USED{} # Container GPU memory usage.
- metricsQuery: sum(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>) / sum(DCGM_CUSTOM_CONTAINER_MEM_ALLOCATED{}) by (<<.GroupBy>>)
  name:
    as: ${1}_GPU_MEM_USED_RATIO
    matches: ^(.*)_MEM_USED
  resources:
    overrides:
      NamespaceName:
        resource: namespace
      PodName:
        resource: pod
  seriesQuery: DCGM_CUSTOM_PROCESS_MEM_USED{NamespaceName!="",PodName!=""}  # Container GPU memory utilization.

Setelah menambahkan aturan tersebut, konfigurasi akan ditampilkan seperti pada gambar berikut.

Jalankan perintah berikut. Jika output berisi metrik yang dapat dikenali oleh HPA, seperti DCGM_FI_DEV_GPU_UTIL, DCGM_CUSTOM_PROCESS_SM_UTIL, DCGM_FI_DEV_FB_USED, dan DCGM_CUSTOM_PROCESS_MEM_USED, konfigurasi telah selesai. Contoh ini menggunakan DCGM_CUSTOM_PROCESS_SM_UTIL. Output aktual dapat berbeda.

Contoh output

kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1"

Output yang diharapkan (bagian resources berisi metrik terkait DCGM_CUSTOM_PROCESS_SM_UTIL):

{
  "kind": "APIResourceList",
  "apiVersion": "v1",
  "groupVersion": "custom.metrics.k8s.io/v1beta1",
  "resources": [
    {
      "name": "nodes/DCGM_CUSTOM_PROCESS_SM_UTIL",
      "singularName": "",
      "namespaced": false,
      "kind": "MetricValueList",
      "verbs": [
        "get"
      ]
    },
    {
      "name": "pods/DCGM_CUSTOM_PROCESS_SM_UTIL",
      "singularName": "",
      "namespaced": true,
      "kind": "MetricValueList",
      "verbs": [
        "get"
      ]
    },
    {
      "name": "namespaces/DCGM_CUSTOM_PROCESS_SM_UTIL",
      "singularName": "",
      "namespaced": false,
      "kind": "MetricValueList",
      "verbs": [
        "get"
      ]
    },
    {
      "name": "DCGM_CUSTOM_PROCESS_GPU_MEM_USED_RATIO",
      "singularName": "",
      "namespaced": false,
      "kind": "MetricValueList",
      "verbs": [
        "get"
      ]
    }
  ]
}

Langkah 3: Implementasikan auto scaling berdasarkan metrik GPU

Contoh ini menerapkan layanan inferensi model pada GPU, lalu menjalankan uji stres pada layanan tersebut untuk menguji auto scaling berdasarkan pemanfaatan GPU.

1. Terapkan layanan inferensi

Jalankan perintah berikut untuk menerapkan layanan inferensi.

Detail perintah

cat <<EOF | kubectl create -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bert-intent-detection
spec:
  replicas: 1
  selector:
    matchLabels:
      app: bert-intent-detection
  template:
    metadata:
      labels:
        app: bert-intent-detection
    spec:
      containers:
      - name: bert-container
        image: registry.cn-hangzhou.aliyuncs.com/ai-samples/bert-intent-detection:1.0.1
        ports:
        - containerPort: 80
        resources:
          limits:
            nvidia.com/gpu: 1
---
apiVersion: v1
kind: Service
metadata:
  name: bert-intent-detection-svc
  labels:
    app: bert-intent-detection
spec:
  selector:
    app: bert-intent-detection
  ports:
  - protocol: TCP
    name: http
    port: 80
    targetPort: 80
  type: LoadBalancer
EOF

Periksa status pod dan layanan.

Jalankan perintah berikut untuk memeriksa status pod.

kubectl get pods -o wide

Output yang diharapkan:

NAME                                    READY   STATUS    RESTARTS   AGE     IP           NODE                        NOMINATED NODE   READINESS GATES
bert-intent-detection-7b486f6bf-f****   1/1     Running   0          3m24s   10.15.1.17   cn-beijing.192.168.94.107   <none>           <none>

Output yang diharapkan menunjukkan bahwa hanya satu pod diterapkan pada node GPU 192.168.94.107.

Jalankan perintah berikut untuk memeriksa status layanan.

kubectl get svc bert-intent-detection-svc

Output yang diharapkan:

NAME                        TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
bert-intent-detection-svc   LoadBalancer   172.16.186.159   47.95.XX.XX   80:30118/TCP   5m1s

Nama layanan dalam output yang diharapkan menunjukkan bahwa layanan telah diterapkan.

Masuk ke node GPU 192.168.94.107 menggunakan Secure Shell (SSH), lalu jalankan perintah berikut untuk memeriksa penggunaan GPU.

nvidia-smi

Output yang diharapkan:

Wed Feb 16 11:48:07 2022
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 450.102.04   Driver Version: 450.102.04   CUDA Version: 11.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  Tesla V100-SXM2...  On   | 00000000:00:07.0 Off |                    0 |
| N/A   32C    P0    55W / 300W |  15345MiB / 16160MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|    0   N/A  N/A   2305118      C   python                          15343MiB |
+-----------------------------------------------------------------------------+

Output yang diharapkan menunjukkan bahwa proses layanan inferensi sedang berjalan pada GPU. Karena belum ada permintaan yang dikirim, pemanfaatan GPU saat ini adalah 0.

Jalankan perintah berikut untuk memanggil layanan inferensi dan memverifikasi penerapan.

curl -v  "http://47.95.XX.XX/predict?query=Music"

Output yang diharapkan:

*   Trying 47.95.XX.XX...
* TCP_NODELAY set
* Connected to 47.95.XX.XX (47.95.XX.XX) port 80 (#0)
> GET /predict?query=Music HTTP/1.1
> Host: 47.95.XX.XX
> User-Agent: curl/7.64.1
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Content-Type: text/html; charset=utf-8
< Content-Length: 9
< Server: Werkzeug/1.0.1 Python/3.6.9
< Date: Wed, 16 Feb 2022 03:52:11 GMT
<
* Closing connection 0
PlayMusic # Intent recognition result.

Permintaan HTTP mengembalikan kode status 200 dan hasil pengenalan maksud. Hal ini menunjukkan bahwa layanan inferensi telah diterapkan.

2. Konfigurasikan HPA

Contoh ini menggunakan pemanfaatan GPU. Saat pemanfaatan GPU sebuah pod melebihi 20%, skala keluar dipicu. HPA mendukung metrik berikut.

Metrik	Deskripsi	Unit
DCGM_FI_DEV_GPU_UTIL	Pemanfaatan kartu GPU. Metrik ini hanya berlaku untuk penjadwalan GPU khusus. Penting Untuk GPU bersama, kartu GPU yang sama dialokasikan ke beberapa pod. NVIDIA hanya menyediakan pemanfaatan tingkat kartu, bukan pemanfaatan tingkat aplikasi. Oleh karena itu, pemanfaatan yang ditampilkan saat Anda menjalankan `nvidia-smi` di dalam pod adalah pemanfaatan seluruh kartu.	%
DCGM_FI_DEV_FB_USED	Penggunaan memori kartu GPU. Metrik ini hanya berlaku untuk penjadwalan GPU khusus.	MiB
DCGM_CUSTOM_PROCESS_SM_UTIL	Pemanfaatan GPU container.	%
DCGM_CUSTOM_PROCESS_MEM_USED	Penggunaan memori GPU container.	MiB
DCGM_CUSTOM_PROCESS_GPU_MEM_USED_RATIO	Pemanfaatan memori GPU container. `Pemanfaatan memori GPU container = Penggunaan memori GPU aktual container pod saat ini (Used) / Memori GPU yang dialokasikan untuk container pod saat ini (Allocated)`	%

Jalankan perintah berikut untuk menerapkan HPA.

v1.23 atau yang lebih baru

cat <<EOF | kubectl create -f -
apiVersion: autoscaling/v2  # Gunakan versi autoscaling/v2 untuk konfigurasi HPA.
kind: HorizontalPodAutoscaler
metadata:
  name: gpu-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: bert-intent-detection
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Pods
    pods:
      metric:
        name: DCGM_CUSTOM_PROCESS_SM_UTIL
      target:
        type: Utilization
        averageValue: 20 # Skala keluar dipicu ketika pemanfaatan GPU container melebihi 20%.
EOF

Sebelum v1.23

cat <<EOF | kubectl create -f -
apiVersion: autoscaling/v2beta1  # Gunakan versi autoscaling/v2beta1 untuk konfigurasi HPA.
kind: HorizontalPodAutoscaler
metadata:
  name: gpu-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: bert-intent-detection
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Pods
    pods:
      metricName: DCGM_CUSTOM_PROCESS_SM_UTIL # Pemanfaatan GPU pod.
      targetAverageValue: 20 # Skala keluar dipicu ketika pemanfaatan GPU container melebihi 20%.
EOF

Jalankan perintah berikut untuk memeriksa status HPA.
```
kubectl get hpa
```
Output yang diharapkan:
```
NAME      REFERENCE                          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
gpu-hpa   Deployment/bert-intent-detection   0/20      1         10        1          74s
```
Output yang diharapkan menunjukkan bahwa TARGETS bernilai 0/20. Hal ini menunjukkan bahwa pemanfaatan GPU saat ini adalah 0. Skala keluar akan dipicu ketika pemanfaatan GPU melebihi 20%.

3. Uji auto scaling untuk layanan inferensi

Scale-out

Jalankan perintah berikut untuk melakukan uji stres.
```
hey -n 10000 -c 200 "http://47.95.XX.XX/predict?query=music"
```
Catatan
Rumus untuk menghitung jumlah replika yang diinginkan saat skala keluar HPA adalah: Replika yang Diinginkan = ceil[Jumlah Replika Saat Ini × (Metrik Saat Ini / Metrik yang Diinginkan)]. Misalnya, jumlah replika saat ini adalah 1, metrik saat ini adalah 23, dan metrik yang diinginkan adalah 20; rumus menghitung jumlah replika yang diinginkan menjadi 2.
Selama uji stres, pantau status HPA dan pod.
1. Jalankan perintah berikut untuk memeriksa status HPA.
```
kubectl get hpa
```
  Output yang diharapkan:
```
NAME      REFERENCE                          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
gpu-hpa   Deployment/bert-intent-detection   23/20     1         10        2          7m56s
```
  Output menunjukkan bahwa nilai TARGETS adalah 23/20. Nilai ini menunjukkan bahwa pemanfaatan GPU saat ini melebihi 20%, sehingga memicu auto scaling dan menyebabkan kluster melakukan skala keluar.
2. Jalankan perintah berikut untuk memeriksa status pod.
```
kubectl get pods
```
  Output yang diharapkan:
```
NAME                                    READY   STATUS    RESTARTS   AGE
bert-intent-detection-7b486f6bf-f****   1/1     Running   0          44m
bert-intent-detection-7b486f6bf-m****   1/1     Running   0          14s
```
  Output yang diharapkan menunjukkan bahwa terdapat dua pod. Rumus menghitung bahwa jumlah total pod harus 2. Hal ini sesuai dengan output aktual.
Output yang diharapkan untuk HPA dan pod menunjukkan bahwa pod berhasil melakukan skala keluar.

Scale-in

Saat uji stres berhenti, pemanfaatan GPU turun di bawah 20%. Sistem kemudian mulai melakukan skala-masuk.

Jalankan perintah berikut untuk memeriksa status HPA.
```
kubectl get hpa
```
Output yang diharapkan:
```
NAME      REFERENCE                          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
gpu-hpa   Deployment/bert-intent-detection   0/20      1         10        1          15m
```
Output yang diharapkan menunjukkan bahwa TARGETS bernilai 0/20 . Hal ini menunjukkan bahwa pemanfaatan GPU saat ini adalah 0. Setelah sekitar lima menit, sistem mulai melakukan skala-masuk.
Jalankan perintah berikut untuk memeriksa status pod.
```
kubectl get pods
```
Output yang diharapkan:
```
NAME                                    READY   STATUS    RESTARTS   AGE
bert-intent-detection-7b486f6bf-f****   1/1     Running   0          52m
```
Output yang diharapkan menunjukkan bahwa jumlah pod adalah 1. Hal ini menunjukkan bahwa skala-masuk berhasil.

FAQ

Bagaimana cara menentukan apakah kartu GPU sedang digunakan?

Anda dapat memeriksa tab GPU Monitoring untuk mengamati fluktuasi pemanfaatan kartu GPU guna menentukan apakah kartu GPU sedang digunakan. Jika pemanfaatan meningkat, kartu GPU sedang digunakan. Jika pemanfaatan tidak berubah, kartu tersebut tidak digunakan. Untuk melakukannya, ikuti langkah-langkah berikut:

Masuk ke ACK console. Di panel navigasi kiri, klik Clusters.
Pada halaman Clusters, temukan kluster yang diinginkan dan klik namanya. Di panel navigasi kiri, pilih Operations > Prometheus Monitoring.
Pada halaman Prometheus Monitoring, klik tab GPU Monitoring. Amati fluktuasi pemanfaatan kartu GPU.