Scale ACK Workloads with ASM Metrics and HPA for Optimal Performance-Container Service for Kubernetes-Alibaba Cloud

Service Mesh (ASM) mengumpulkan data telemetri secara non-intrusif untuk kluster Container Service for Kubernetes (ACK) dan kluster Container Compute Service (ACS), sehingga komunikasi layanan dalam kluster menjadi teramati. Fitur ini memungkinkan perilaku layanan diamati dan membantu staf O&M menangani masalah, memelihara, serta mengoptimalkan aplikasi tanpa meningkatkan biaya pemeliharaan. Berdasarkan empat metrik utama—latensi, lalu lintas, kesalahan, dan saturasi—ASM menghasilkan serangkaian metrik untuk layanan yang dikelolanya. Topik ini menjelaskan cara mengimplementasikan penskalaan otomatis untuk beban kerja menggunakan metrik ASM.

Prasyarat

Sebuah kluster ACK atau ACS telah dibuat. Untuk informasi lebih lanjut, lihat Buat Kluster ACK yang Dikelola atau Buat Kluster ACS.
Sebuah instance ASM telah dibuat. Untuk informasi lebih lanjut, lihat Buat Instance ASM.
Sebuah instance Prometheus dan sebuah instance Grafana telah diterapkan di dalam kluster. Untuk informasi lebih lanjut, lihat Gunakan Prometheus Sumber Terbuka untuk Memantau Kluster ACK.
Sebuah instance Prometheus telah diterapkan untuk memantau instance ASM. Untuk informasi lebih lanjut, lihat Pantau Instance ASM Menggunakan Instance Prometheus yang Dikelola Sendiri.

Latar Belakang

ASM menghasilkan serangkaian metrik untuk layanan yang dikelolanya. Untuk informasi lebih lanjut, lihat Metrik Standar Istio.

Penskalaan otomatis adalah pendekatan untuk secara otomatis menambah atau mengurangi beban kerja berdasarkan penggunaan sumber daya. Di Kubernetes, dua autoscaler digunakan untuk mengimplementasikan penskalaan otomatis:

Cluster Autoscaler (CA): Digunakan untuk menambah atau mengurangi jumlah node dalam kluster.
Horizontal Pod Autoscaler (HPA): Digunakan untuk menambah atau mengurangi jumlah pod yang digunakan untuk menerapkan aplikasi.

Lapisan agregasi Kubernetes memungkinkan aplikasi pihak ketiga memperluas API Kubernetes dengan mendaftarkan diri sebagai add-on API. Add-on ini dapat digunakan untuk mengimplementasikan API metrik kustom dan memungkinkan HPA untuk menanyakan metrik apa pun. HPA secara berkala menanyakan metrik inti seperti utilisasi CPU dan penggunaan memori melalui API metrik sumber daya. Selain itu, HPA menggunakan API metrik kustom untuk menanyakan metrik spesifik aplikasi, seperti metrik observabilitas yang disediakan oleh ASM.

Langkah 1: Aktifkan pemantauan Prometheus untuk instance ASM

Untuk informasi lebih lanjut, lihat Kumpulkan Metrik ke Managed Service for Prometheus.

Langkah 2: Terapkan adapter untuk API metrik kustom

Jalankan perintah berikut untuk mengunduh paket instalasi adapter. Kemudian, instal dan terapkan adapter untuk API metrik kustom di dalam kluster.
Untuk informasi lebih lanjut, kunjungi kube-metrics-adapter.
```
## Gunakan Helm 3.
helm -n kube-system install asm-custom-metrics ./kube-metrics-adapter  --set prometheus.url=http://prometheus.istio-system.svc:9090
```
Setelah instalasi selesai, jalankan perintah berikut untuk memeriksa apakah kube-metrics-adapter telah diaktifkan.
- Jalankan perintah berikut untuk memverifikasi bahwa autoscaling/v2beta ada:
```
kubectl api-versions |grep "autoscaling/v2beta"
```
  Output yang diharapkan:
```
autoscaling/v2beta
```
- Jalankan perintah berikut untuk memeriksa status pod dari kube-metrics-adapter:
```
kubectl get po -n kube-system |grep metrics-adapter
```
  Output yang diharapkan:
```
asm-custom-metrics-kube-metrics-adapter-85c6d5d865-2****          1/1     Running   0          19s
```
- Jalankan perintah berikut untuk menanyakan metrik kustom yang disediakan oleh kube-metrics-adapter:
```
kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1" | jq .
```
  Output yang diharapkan:
```
{
  "kind": "APIResourceList",
  "apiVersion": "v1",
  "groupVersion": "external.metrics.k8s.io/v1beta1",
  "resources": []
}
```

Langkah 3: Terapkan aplikasi sampel

Buat namespace bernama test. Untuk informasi lebih lanjut, lihat Kelola Namespace dan Kuota Sumber Daya.
Aktifkan injeksi proxy sidecar otomatis. Untuk informasi lebih lanjut, lihat Aktifkan Injeksi Proxy Sidecar Otomatis.

Terapkan aplikasi sampel.

Buat file bernama podinfo.yaml dan salin konten berikut ke dalam file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: podinfo
  namespace: test
  labels:
    app: podinfo
spec:
  minReadySeconds: 5
  strategy:
    rollingUpdate:
      maxUnavailable: 0
    type: RollingUpdate
  selector:
    matchLabels:
      app: podinfo
  template:
    metadata:
      annotations:
        prometheus.io/scrape: "true"
      labels:
        app: podinfo
    spec:
      containers:
      - name: podinfod
        image: stefanprodan/podinfo:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 9898
          name: http
          protocol: TCP
        command:
        - ./podinfo
        - --port=9898
        - --level=info
        livenessProbe:
          exec:
            command:
            - podcli
            - check
            - http
            - localhost:9898/healthz
          initialDelaySeconds: 5
          timeoutSeconds: 5
        readinessProbe:
          exec:
            command:
            - podcli
            - check
            - http
            - localhost:9898/readyz
          initialDelaySeconds: 5
          timeoutSeconds: 5
        resources:
          limits:
            cpu: 2000m
            memory: 512Mi
          requests:
            cpu: 100m
            memory: 64Mi
---
apiVersion: v1
kind: Service
metadata:
  name: podinfo
  namespace: test
  labels:
    app: podinfo
spec:
  type: ClusterIP
  ports:
    - name: http
      port: 9898
      targetPort: 9898
      protocol: TCP
  selector:
    app: podinfo

Jalankan perintah berikut untuk menerapkan aplikasi podinfo:
```
kubectl apply -n test -f podinfo.yaml
```

Untuk memicu penskalaan otomatis, Anda harus menerapkan layanan pengujian beban di namespace test untuk memicu permintaan.

Buat file bernama loadtester.yaml dan salin konten berikut ke dalam file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadtester
  namespace: test
  labels:
    app: loadtester
spec:
  selector:
    matchLabels:
      app: loadtester
  template:
    metadata:
      labels:
        app: loadtester
      annotations:
        prometheus.io/scrape: "true"
    spec:
      containers:
        - name: loadtester
          image: weaveworks/flagger-loadtester:0.18.0
          imagePullPolicy: IfNotPresent
          ports:
            - name: http
              containerPort: 8080
          command:
            - ./loadtester
            - -port=8080
            - -log-level=info
            - -timeout=1h
          livenessProbe:
            exec:
              command:
                - wget
                - --quiet
                - --tries=1
                - --timeout=4
                - --spider
                - http://localhost:8080/healthz
            timeoutSeconds: 5
          readinessProbe:
            exec:
              command:
                - wget
                - --quiet
                - --tries=1
                - --timeout=4
                - --spider
                - http://localhost:8080/healthz
            timeoutSeconds: 5
          resources:
            limits:
              memory: "512Mi"
              cpu: "1000m"
            requests:
              memory: "32Mi"
              cpu: "10m"
          securityContext:
            readOnlyRootFilesystem: true
            runAsUser: 10001
---
apiVersion: v1
kind: Service
metadata:
  name: loadtester
  namespace: test
  labels:
    app: loadtester
spec:
  type: ClusterIP
  selector:
    app: loadtester
  ports:
    - name: http
      port: 80
      protocol: TCP
      targetPort: http

Jalankan perintah berikut untuk menerapkan layanan pengujian beban:
```
kubectl apply -n test -f loadtester.yaml
```

Periksa apakah aplikasi sampel dan layanan pengujian beban telah diterapkan.

Jalankan perintah berikut untuk memeriksa status pod:

kubectl get pod -n test

Output yang diharapkan:

NAME                          READY   STATUS    RESTARTS   AGE
loadtester-64df4846b9-nxhvv   2/2     Running   0          2m8s
podinfo-6d845cc8fc-26xbq      2/2     Running   0          11m

Jalankan perintah berikut untuk masuk ke dalam container untuk pengujian beban dan jalankan perintah hey untuk menghasilkan beban:
```
export loadtester=$(kubectl -n test get pod -l "app=loadtester" -o jsonpath='{.items[0].metadata.name}')
kubectl -n test exec -it ${loadtester} -c loadtester -- hey -z 5s -c 10 -q 2 http://podinfo.test:9898
```
Beban dihasilkan, yang menunjukkan bahwa aplikasi sampel dan layanan pengujian beban telah diterapkan.

Langkah 4: Konfigurasikan HPA menggunakan metrik ASM

Definisikan HPA untuk menskalakan beban kerja aplikasi podinfo berdasarkan jumlah permintaan yang diterima aplikasi podinfo per detik. Ketika rata-rata lebih dari 10 permintaan diterima per detik, HPA akan meningkatkan jumlah replika.

Buat file bernama hpa.yaml dan salin kode berikut ke dalam file:

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: podinfo
  namespace: test
  annotations:
    metric-config.external.prometheus-query.prometheus/processed-requests-per-second: |
      sum(
          rate(
              istio_requests_total{
                destination_workload="podinfo",
                destination_workload_namespace="test",
                reporter="destination"
              }[1m]
          )
      ) 
spec:
  maxReplicas: 10
  minReplicas: 1
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: podinfo
  metrics:
    - type: External
      external:
        metric:
          name: prometheus-query
          selector:
            matchLabels:
              query-name: processed-requests-per-second
        target:
          type: AverageValue
          averageValue: "10"

Jalankan perintah berikut untuk menerapkan HPA:
```
kubectl apply -f hpa.yaml
```

Jalankan perintah berikut untuk memeriksa apakah HPA telah diterapkan.

Jalankan perintah berikut untuk menanyakan metrik kustom yang disediakan oleh kube-metrics-adapter:

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

Output yang diharapkan:

{
  "kind": "APIResourceList",
  "apiVersion": "v1",
  "groupVersion": "external.metrics.k8s.io/v1beta1",
  "resources": [
    {
      "name": "prometheus-query",
      "singularName": "",
      "namespaced": true,
      "kind": "ExternalMetricValueList",
      "verbs": [
        "get"
      ]
    }
  ]
}

Output tersebut berisi daftar metrik ASM kustom, yang menunjukkan bahwa HPA telah diterapkan.

Verifikasi penskalaan otomatis

Jalankan perintah berikut untuk masuk ke dalam container untuk pengujian beban dan jalankan perintah hey untuk menghasilkan beban:
```
kubectl -n test exec -it ${loadtester} -c loadtester -- sh
~ $ hey -z 5m -c 10 -q 5 http://podinfo.test:9898
```
Jalankan perintah berikut untuk memeriksa efek penskalaan otomatis.
Catatan
Metrik disinkronkan setiap 30 detik secara default. Container hanya dapat diskalakan sekali setiap 3 hingga 5 menit. Dengan cara ini, HPA dapat menyisihkan waktu untuk penskalaan otomatis sebelum strategi konflik dieksekusi.
```
watch kubectl -n test get hpa/podinfo
```
Output yang diharapkan:
```
NAME      REFERENCE            TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
podinfo   Deployment/podinfo   8308m/10 (avg)   1         10        6          124m
```
HPA mulai menambah beban kerja dalam 1 menit hingga jumlah permintaan per detik turun di bawah ambang batas tertentu. Setelah pengujian beban selesai, jumlah permintaan per detik turun menjadi nol. Lalu, HPA mulai mengurangi jumlah pod. Beberapa menit kemudian, jumlah replika turun dari nilai pada output sebelumnya menjadi satu.