Skala beberapa aplikasi dengan metrik traffic NGINX Ingress - Container Service for Kubernetes

Penerapan multi-instans meningkatkan stabilitas aplikasi tetapi dapat menyebabkan sumber daya menganggur dan meningkatkan biaya kluster. Penskalaan manual bersifat padat karya dan lambat dalam merespons. Anda dapat menggunakan NGINX Ingress untuk menerapkan horizontal pod autoscaling (HPA) pada beberapa aplikasi, menyesuaikan jumlah replika Pod secara dinamis berdasarkan beban guna menjaga stabilitas dan responsivitas sekaligus mengoptimalkan penggunaan sumber daya dan biaya. Topik ini menjelaskan cara menerapkan HPA multi-aplikasi dengan NGINX Ingress.

Prasyarat

Pastikan Anda telah:

Alibaba Cloud Prometheus diterapkan di kluster Anda.
Add-on ack-alibaba-cloud-metrics-adapter diterapkan dengan prometheus.url dikonfigurasi.
Cara mengonfigurasi prometheus.url
1. Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.
2. Pada halaman Clusters, temukan kluster yang diinginkan lalu klik namanya. Di panel kiri, pilih Applications > Helm.
3. Pada halaman Helm, temukan ack-alibaba-cloud-metrics-adapter lalu klik Update di kolom Actions.
4. Pada panel Update Release, atur alibabaCloudMetricsAdapter.prometheus.url ke URL permintaan data Prometheus Anda, lalu klik OK.
Lihat Cara mengambil URL permintaan data Prometheus dan referensi konfigurasi ack-alibaba-cloud-metrics-adapter.
Apache Benchmark (ab) telah diinstal.
Contoh perintah
Instal ab menggunakan manajer paket OS Anda:
- macOS (Homebrew): bash brew install httpd
- Windows: Unduh build Windows dari Apache Lounge. Ekstrak arsipnya, buka folder bin, lalu jalankan ab.exe.
- Ubuntu atau Debian: shell sudo apt update sudo apt install apache2-utils
- CentOS 8 atau RHEL: shell sudo yum install httpd-tools
Verifikasi instalasi:
```
ab -V
```

Cara kerja

Ingress meneruskan permintaan eksternal ke Service, yang kemudian mengarahkannya ke Pod yang sesuai. NGINX Ingress Controller mencatat jumlah permintaan per-Service dalam metrik Prometheus nginx_ingress_controller_requests.

HPA tidak dapat langsung mengonsumsi metrik Prometheus — metrik tersebut harus diekspos melalui API external metrics Kubernetes. ack-alibaba-cloud-metrics-adapter menjembatani kesenjangan ini dengan memproses nginx_ingress_controller_requests dalam empat langkah:

Langkah	Field	Peran	Nilai yang digunakan di sini
1. Discovery	`seriesQuery`	Mengidentifikasi metrik Prometheus mana yang akan diekspos	`nginx_ingress_controller_requests`
2. Association	`resources`	Menentukan apakah metrik ini memiliki cakupan namespace	`namespaced: false`
3. Naming	`name`	Mengganti nama metrik dalam API eksternal	Menghapus `_requests`, menambahkan `_per_second` → `nginx_ingress_controller_per_second`
4. Querying	`metricsQuery`	Menentukan templat PromQL yang digunakan untuk menghitung nilai	`sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m]))`

Adapter mengisi variabel templat metricsQuery ini saat kueri dijalankan:

<<.Series>> — diganti dengan nama seri Prometheus yang cocok (nginx_ingress_controller_requests)
<<.LabelMatchers>> — diganti dengan pemilih label dari spesifikasi HPA (misalnya, service="sample-app")

Setiap HPA menggunakan selector.matchLabels.service untuk memfilter metrik ini ke satu aplikasi saja, sehingga penskalaan sample-app dan test-app tetap independen.

Langkah 1: Buat aplikasi dan layanan

Buat dua Deployment dan Service yang sesuai.

Buat 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 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 ingress.yaml dengan konten berikut:

Field	Deskripsi
`host`	Nama domain untuk akses Service. Diatur ke `test.example.com` dalam contoh ini.
`path`	Jalur URL. Permintaan yang cocok dengan jalur ini diarahkan ke Service yang sesuai.
`backend`	Nama Service dan port tujuan untuk setiap jalur. `/` diarahkan ke `sample-app`; `/home` diarahkan ke `test-app`.

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

Terapkan manifes:

kubectl apply -f ingress.yaml

Verifikasi Ingress sedang berjalan:
```
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 mengarahkan test.example.com/ ke sample-app dan test.example.com/home ke test-app. Kedua aliran permintaan tersebut dicatat dalam metrik Prometheus nginx_ingress_controller_requests, diberi label berdasarkan nama layanan.

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

HPA membaca metrik dari API external metrics Kubernetes, bukan langsung dari Prometheus. ack-alibaba-cloud-metrics-adapter menerjemahkan metrik Prometheus ke format ini melalui aturan dalam ConfigMap adapter-config.

Ubah file adapter-config

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

Ganti aturan yang ada dengan berikut ini, lalu klik OK:

Semua opsi konfigurasi adapter didokumentasikan dalam Horizontal pod autoscaling berdasarkan metrik Alibaba Cloud Prometheus.

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

Verifikasi metrik tersedia

Konfirmasi bahwa adapter menyediakan 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" adalah hal yang diharapkan — belum ada traffic.

Langkah 4: Buat HPA

Kedua HPA menggunakan metrik eksternal yang sama, yaitu nginx_ingress_controller_per_second, tetapi memfilternya ke layanan masing-masing menggunakan selector.matchLabels.service. Adapter meneruskan label-label ini sebagai <<.LabelMatchers>> ke dalam kueri PromQL, sehingga keputusan penskalaan setiap aplikasi tetap independen.

Buat 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:
# Memfilter metrik hanya untuk permintaan ke layanan ini.
# Label yang diatur di sini diteruskan ke <<.LabelMatchers>> dalam aturan adapter.
              service: sample-app
# Metrik eksternal hanya mendukung tipe target Value dan AverageValue.
        target:
          type: AverageValue
          averageValue: 30
---
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:
# Memfilter metrik hanya untuk permintaan ke layanan ini.
# Label yang diatur di sini diteruskan ke <<.LabelMatchers>> dalam aturan adapter.
              service: test-app
# Metrik eksternal hanya mendukung tipe target Value dan AverageValue.
        target:
          type: AverageValue
          averageValue: 30

Terapkan manifes:

kubectl apply -f hpa.yaml

Verifikasi kedua HPA siap:

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), artinya laju permintaan saat ini berada di bawah ambang batas skala keluar sebesar 30 permintaan per detik per Pod.

Langkah 5: Verifikasi autoscaling

Gunakan Apache Benchmark untuk menghasilkan traffic dan amati respons masing-masing HPA secara independen.

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

Amati status HPA secara real-time:

kubectl get hpa --watch

Setelah beban, test-hpa melakukan skala keluar sementara sample-hpa tetap pada satu replika:

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

Tekan Ctrl+C untuk menghentikan pengamatan.

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

Periksa status HPA lagi:

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 melakukan skala keluar saat dibebani, sementara test-hpa kembali ke satu replika setelah traffic ke /home berhenti. Setiap aplikasi diskala secara independen berdasarkan traffic-nya sendiri.

Langkah selanjutnya

Autoscaling multi-zona: Lakukan penskalaan di beberapa zona secara simultan untuk layanan intensif data dengan ketersediaan tinggi.
Citra OS kustom untuk skalabilitas elastis: Sederhanakan autoscaling di lingkungan dengan persyaratan node tertentu menggunakan gambar kustom.