Skalakan beberapa aplikasi dengan metrik traffic Nginx Ingress - Container Service for Kubernetes

Menjalankan beberapa replika pod meningkatkan stabilitas aplikasi, tetapi sering kali menyisakan sumber daya menganggur di luar puncak traffic. Penskalaan manual lambat dan rentan kesalahan. Tutorial ini menunjukkan cara menggunakan metrik nginx_ingress_controller_requests—yang diekspos oleh NGINX Ingress Controller—untuk menggerakkan Horizontal Pod Autoscaler (HPA) bagi dua aplikasi secara bersamaan, sehingga setiap aplikasi diskalakan secara independen berdasarkan laju permintaannya sendiri.

NGINX Ingress Controller di kluster ACK merupakan versi yang ditingkatkan dari edisi komunitas.

Cara kerjanya

Alur metrik berjalan sebagai berikut: nginx_ingress_controller_requests → Alibaba Cloud Prometheus → ack-alibaba-cloud-metrics-adapter → External Metrics API → pengontrol HPA. Adapter mengonversi counter Prometheus mentah menjadi laju per detik. Setiap HPA kemudian memfilter metrik bersama tersebut berdasarkan nama layanan, sehingga sample-app dan test-app diskalakan secara independen dari sumber metrik yang sama.

nginx_ingress_controller_requests adalah metrik Counter (total kumulatif permintaan). Adapter menerapkan fungsi rate() dalam jendela 2 menit untuk mengonversinya menjadi jumlah permintaan per detik.

HPA menggunakan tipe metrik External—bukan Custom—karena nginx_ingress_controller_requests tidak terkait dengan objek Kubernetes tertentu (seperti Pod atau Deployment). Metrik eksternal merupakan tipe yang tepat untuk metrik tingkat infrastruktur yang diekspos di luar kluster.

Prasyarat

Sebelum memulai, pastikan Anda telah:

Layanan Terkelola untuk Prometheus Alibaba Cloud telah diterapkan di kluster ACK Anda. Untuk detailnya, lihat Gunakan Alibaba Cloud Prometheus untuk pemantauan.
Komponen ack-alibaba-cloud-metrics-adapter telah diterapkan dan bidang prometheus.url-nya telah dikonfigurasi. Konfigurasikan bidang `prometheus.url`
Cara mengonfigurasi prometheus.url
1. Pada halaman ACK Clusters, klik nama kluster target. Di panel navigasi kiri, pilih Applications > Helm.
2. Pada halaman Helm, temukan ack-alibaba-cloud-metrics-adapter dan klik Update di kolom Actions.
3. Pada panel Update Release, atur alibabaCloudMetricsAdapter.prometheus.url ke URL permintaan data Prometheus Anda, lalu klik OK.Note: Untuk detail cara mengambil URL permintaan data Prometheus, lihat Cara mengambil URL permintaan data Prometheus. Untuk daftar lengkap bidang konfigurasi adapter, lihat Deskripsi lengkap file konfigurasi komponen ack-alibaba-cloud-metrics-adapter.
Apache Benchmark (ab) telah diinstal untuk uji stres. Instal Apache Benchmark Setelah instalasi, verifikasi fungsinya:
Contoh perintah
- macOS: ``bash brew install httpd ``
- Ubuntu atau Debian: ``bash sudo apt update sudo apt install apache2-utils ``
- CentOS 8 atau RHEL: ``bash sudo yum install httpd-tools ``
- Windows: Unduh build Windows dari Apache Lounge. Buka folder bin hasil ekstraksi dan jalankan ab.exe.
```
ab -V
```

Langkah 1: Buat aplikasi dan layanan

Buat dua Deployment beserta Service-nya masing-masing. Ingress yang Anda buat pada langkah berikutnya akan mengarahkan traffic ke setiap Service melalui path URL yang berbeda.

Buat file nginx1.yaml dengan konten berikut.

Contoh YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-app
  namespace: default
  labels:
    app: test-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test-app
  template:
    metadata:
      labels:
        app: test-app
    spec:
      containers:
      - image: registry-cn-hangzhou.ack.aliyuncs.com/acs/sample-app:v1-b070784-aliyun
        name: metrics-provider
        ports:
        - name: http
          containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: test-app
  namespace: default
  labels:
    app: test-app
spec:
  ports:
    - port: 8080
      name: http
      protocol: TCP
      targetPort: 8080
  selector:
    app: test-app
  type: ClusterIP

Terapkan manifes:

kubectl apply -f nginx1.yaml

Buat file nginx2.yaml dengan konten berikut.

Contoh YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-app
  namespace: default
  labels:
    app: sample-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sample-app
  template:
    metadata:
      labels:
        app: sample-app
    spec:
      containers:
      - image: registry-cn-hangzhou.ack.aliyuncs.com/acs/sample-app:v1-b070784-aliyun
        name: metrics-provider
        ports:
        - name: http
          containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: sample-app
  namespace: default
  labels:
    app: sample-app
spec:
  ports:
    - port: 80
      name: http
      protocol: TCP
      targetPort: 8080
  selector:
    app: sample-app
  type: ClusterIP

Terapkan manifes:

kubectl apply -f nginx2.yaml

Langkah 2: Buat Ingress

Buat file ingress.yaml dengan konten berikut.

Field	Description
`host`	Nama domain untuk permintaan masuk. Contoh ini menggunakan `test.example.com`.
`path`	Path URL yang dicocokkan terhadap permintaan masuk. Setiap path meneruskan ke layanan `backend`-nya.
`backend`	Nama layanan dan port yang menerima traffic untuk path yang cocok.

Contoh YAML

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  namespace: default
spec:
  ingressClassName: nginx
  rules:
    - host: test.example.com
      http:
        paths:
          - backend:
              service:
                name: sample-app
                port:
                  number: 80
            path: /
            pathType: ImplementationSpecific
          - backend:
              service:
                name: test-app
                port:
                  number: 8080
            path: /home
            pathType: ImplementationSpecific

Field utama: Terapkan manifes:

kubectl apply -f ingress.yaml

Verifikasi bahwa Ingress telah diterapkan:
```
kubectl get ingress -o wide
```
Output yang diharapkan:
```
NAME           CLASS   HOSTS              ADDRESS       PORTS   AGE
test-ingress   nginx   test.example.com   10.XX.XX.10   80      55s
```
NGINX Ingress Controller sekarang mengarahkan test.example.com/ ke sample-app dan test.example.com/home ke test-app. Kedua path permintaan tersebut dilacak oleh metrik nginx_ingress_controller_requests di Alibaba Cloud Prometheus.

Langkah 3: Konversi metrik Prometheus menjadi metrik yang kompatibel dengan HPA

File adapter-config memberi tahu ack-alibaba-cloud-metrics-adapter cara mengubah deret Prometheus mentah menjadi format External Metrics API yang dapat dibaca oleh HPA.

Ubah file adapter-config

Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.
Pada halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, pilih Applications > Helm.
Pada halaman Helm, klik ack-alibaba-cloud-metrics-adapter. Di bagian Resource, klik adapter-config, lalu klik Edit YAML di pojok kanan atas.

Ganti konten yang ada dengan berikut ini, lalu klik OK.

Field	Nilai	Efek
`seriesQuery`	`nginx_ingress_controller_requests`	Memilih counter Prometheus mentah
`metricsQuery`	`sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m]))`	Mengonversi counter menjadi laju per detik selama 2 menit. `<<.LabelMatchers>>` diganti saat kueri oleh pemilih label dari HPA, seperti `{service="sample-app"}`.
`name.matches` + `name.as`	`^(.*)_requests` → `${1}_per_second`	Mengganti nama metrik: `nginx_ingress_controller_requests` menjadi `nginx_ingress_controller_per_second`.
`resources.namespaced`	`false`	Mengekspos metrik sebagai metrik eksternal tingkat kluster, tidak terikat pada namespace.

rules:
- metricsQuery: sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m]))
  name:
    as: ${1}_per_second
    matches: ^(.*)_requests
  resources:
    namespaced: false
  seriesQuery: nginx_ingress_controller_requests

Aturan ini melakukan hal berikut: Untuk detail konfigurasi, lihat Penyesuaian otomatis pod horizontal berdasarkan metrik Alibaba Cloud Prometheus.

Verifikasi metrik telah diekspos

Jalankan perintah berikut untuk memastikan adapter mengekspos metrik yang telah dikonversi:

kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1/namespaces/*/nginx_ingress_controller_per_second" | jq .

Output yang diharapkan:

{
  "kind": "ExternalMetricValueList",
  "apiVersion": "external.metrics.k8s.io/v1beta1",
  "metadata": {},
  "items": [
    {
      "metricName": "nginx_ingress_controller_per_second",
      "metricLabels": {},
      "timestamp": "2025-07-25T07:56:04Z",
      "value": "0"
    }
  ]
}

Nilai value sebesar 0 diharapkan saat tidak ada traffic. HPA akan menerima nilai bukan nol begitu permintaan mulai masuk.

Langkah 4: Buat HPA

Setiap HPA menargetkan satu Deployment dan memfilter metrik bersama berdasarkan nama layanan menggunakan selector.matchLabels. Saat adapter menjalankan kueri metrik, ia menyisipkan pemilih label—misalnya, {service="sample-app"}—ke placeholder <<.LabelMatchers>>, sehingga setiap HPA hanya melihat laju permintaan aplikasinya sendiri.

Target averageValue: 30 berarti setiap pod sebaiknya menangani tidak lebih dari 30 permintaan per detik. HPA menyesuaikan jumlah replika untuk mempertahankan rata-rata ini di seluruh semua pod yang berjalan.

Buat file hpa.yaml dengan konten berikut.

Contoh YAML

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: sample-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: sample-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: External
      external:
        metric:
          name: nginx_ingress_controller_per_second
          selector:
            matchLabels:
# Disisipkan ke <<.LabelMatchers>> saat kueri: memfilter metrik hanya untuk layanan ini.
              service: sample-app
# Metrik eksternal hanya mendukung tipe target Value dan AverageValue.
        target:
          type: AverageValue
          averageValue: 30  # Target: 30 permintaan/detik per pod
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: test-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: test-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: External
      external:
        metric:
          name: nginx_ingress_controller_per_second
          selector:
            matchLabels:
# Disisipkan ke <<.LabelMatchers>> saat kueri: memfilter metrik hanya untuk layanan ini.
              service: test-app
# Metrik eksternal hanya mendukung tipe target Value dan AverageValue.
        target:
          type: AverageValue
          averageValue: 30  # Target: 30 permintaan/detik per pod

Terapkan manifes:

kubectl apply -f hpa.yaml

Periksa status HPA:

kubectl get hpa

Output yang diharapkan:

NAME         REFERENCE               TARGETS       MINPODS   MAXPODS   REPLICAS   AGE
sample-hpa   Deployment/sample-app   0/30 (avg)   1         10        1          74s
test-hpa     Deployment/test-app     0/30 (avg)   1         10        1          59m

Kedua HPA menampilkan 0/30 (avg)—nilai metrik saat ini adalah 0 (tidak ada traffic) terhadap target 30 permintaan/detik per pod.

Langkah 5: Verifikasi hasil

Gunakan Apache Benchmark untuk mengirim traffic dan amati bagaimana setiap HPA merespons secara independen.

Setelah beban dimulai, beri waktu 1–2 menit agar jumlah replika mencerminkan keputusan skala keluar.

Kirim 5.000 permintaan ke path /home (diarahkan ke test-app):
```
ab -c 50 -n 5000 test.example.com/home
```

Periksa status HPA:

kubectl get hpa

Output yang diharapkan:

NAME         REFERENCE               TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
sample-hpa   Deployment/sample-app   0/30 (avg)        1         10        1          22m
test-hpa     Deployment/test-app     22096m/30 (avg)   1         10        3          80m

test-hpa memperluas kapasitas menjadi 3 replika karena laju permintaan untuk test-app melebihi ambang batas 30 req/detik per pod. sample-hpa tetap pada 1 replika karena tidak ada traffic yang mencapai sample-app.

Kirim 5.000 permintaan ke path root (diarahkan ke sample-app):
```
ab -c 50 -n 5000 test.example.com/
```
Periksa kembali status HPA:
```
kubectl get hpa
```
Output yang diharapkan:
```
NAME         REFERENCE               TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
sample-hpa   Deployment/sample-app   27778m/30 (avg)   1         10        2          38m
test-hpa     Deployment/test-app     0/30 (avg)        1         10        1          96m
```
sample-hpa memperluas kapasitas menjadi 2 replika sebagai respons terhadap traffic baru. Setelah uji stres berakhir, test-hpa kembali ke 1 replika. Hal ini mengonfirmasi bahwa kedua HPA melacak metrik aplikasinya masing-masing secara independen.

Langkah berikutnya

Untuk penerapan ketersediaan tinggi yang mencakup beberapa zona, lihat Implementasikan skalabilitas elastis cepat dan simultan di beberapa zona.
Untuk menyederhanakan skalabilitas elastis di lingkungan kompleks menggunakan citra OS kustom, lihat Optimalisasi elastis dengan gambar kustom.