Implementasi auto scaling untuk workload menggunakan metrik ASM - Alibaba Cloud Service Mesh

Service Mesh (ASM) menyediakan metode non-intrusif untuk menghasilkan data telemetri komunikasi layanan dalam kluster Alibaba Cloud Container Service for Kubernetes (ACK) dan Alibaba Cloud Container Service (ACS). Fitur telemetri ini memberikan observabilitas terhadap perilaku layanan, membantu insinyur operasi dan maintenance (O&M) dalam menangani masalah, melakukan pemeliharaan, serta mengoptimalkan aplikasi tanpa perlu mengubah kode aplikasi. Berdasarkan empat sinyal emas pemantauan—latensi, traffic, error, dan saturasi—ASM menghasilkan serangkaian metrik untuk layanan yang dikelolanya. Topik ini menjelaskan cara menggunakan metrik ASM untuk mengimplementasikan penskalaan otomatis pada workload.

Prasyarat

Kluster ACK atau kluster ACS telah dibuat. Untuk informasi selengkapnya, lihat Buat kluster ACK yang dikelola atau Buat kluster ACS.
Instans ASM telah dibuat. Untuk informasi selengkapnya, lihat Buat instans ASM.
Instans Prometheus dan instans Grafana telah dibuat di kluster. Untuk informasi selengkapnya, lihat Pemantauan Prometheus open source.
Prometheus telah diintegrasikan untuk pemantauan mesh. Untuk informasi selengkapnya, lihat Integrasikan instans Prometheus self-managed untuk pemantauan mesh.

Informasi latar belakang

Service Mesh menghasilkan serangkaian metrik untuk layanan yang dikelolanya. Untuk informasi selengkapnya, lihat Metrik standar Istio.

Auto scaling adalah metode untuk secara otomatis menambah atau mengurangi jumlah workload berdasarkan penggunaan resource. Kubernetes menyediakan dua mekanisme auto scaling:

Cluster Autoscaler (CA): menangani penskalaan node dengan menambah atau mengurangi jumlah node.
Horizontal Pod Autoscaler (HPA): secara otomatis menskalakan jumlah Pod dalam suatu Penyebaran.

Lapisan agregasi di Kubernetes memungkinkan aplikasi pihak ketiga memperluas API Kubernetes dengan mendaftarkan diri sebagai komponen add-on API. Komponen add-on ini dapat mengimplementasikan Custom Metrics API dan memungkinkan HPA mengakses berbagai metrik. HPA secara berkala mengkueri metrik inti, seperti CPU atau memori, melalui Resource Metrics API, serta mengambil metrik spesifik aplikasi—termasuk metrik observabilitas yang disediakan oleh ASM—melalui Custom Metrics API.

Langkah 1: Aktifkan pengumpulan metrik pemantauan Prometheus

Untuk informasi selengkapnya, lihat Kumpulkan metrik pemantauan di Managed Service for Prometheus.

Langkah 2: Deploy adapter Custom Metrics API

Unduh dan instal kube-metrics-adapter ke kluster ACK.

helm -n kube-system install asm-custom-metrics ./kube-metrics-adapter  --set prometheus.url=http://prometheus.istio-system.svc:9090

Konfirmasi bahwa kube-metrics-adapter telah diaktifkan.

Konfirmasi bahwa autoscaling/v2 tersedia.
```
kubectl api-versions | grep "autoscaling/v2"
```
Output yang diharapkan:
```
autoscaling/v2
```

Periksa status Pod 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

Tampilkan daftar metrik eksternal kustom yang disediakan oleh adapter Prometheus.

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: Deploy aplikasi contoh

Buat namespace test dan aktifkan injeksi sidecar otomatis. Untuk informasi selengkapnya, lihat Kelola namespace dan kuota dan Aktifkan injeksi otomatis.

Deploy aplikasi contoh.

Buat file bernama podinfo.yaml dengan konten berikut.

Klik untuk melihat konten YAML

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

Deploy podinfo.
```
kubectl apply -n test -f podinfo.yaml
```

Deploy layanan pengujian beban di namespace test untuk memicu auto scaling.

Buat file bernama loadtester.yaml.

Klik untuk melihat konten YAML

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

Sebarkan layanan pengujian beban.

kubectl apply -n test -f loadtester.yaml

Verifikasi bahwa aplikasi contoh dan layanan pengujian beban telah dideploy.

Periksa 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

Masuk ke kontainer load tester dan hasilkan 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

Respons sukses menunjukkan bahwa beban telah dihasilkan dan aplikasi contoh beserta layanan pengujian beban telah dideploy.

Langkah 4: Konfigurasikan HPA menggunakan metrik ASM

Definisikan HPA yang menskalakan workload podinfo berdasarkan jumlah permintaan per detik. Saat rata-rata beban traffic melebihi 10 permintaan per detik, HPA akan menambah jumlah replika deployment.

Catatan

Catatan: Contoh ini menggunakan versi API HPA autoscaling/v2, yang berlaku untuk Kubernetes 1.23 ke atas. Untuk kluster yang menjalankan Kubernetes 1.26 atau lebih baru, gunakan versi v2. Versi v2beta2 telah dihapus di Kubernetes 1.26.

Buat file bernama hpa.yaml.

apiVersion: autoscaling/v2
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"

Deploy HPA.
```
kubectl apply -f hpa.yaml
```

Verifikasi bahwa HPA telah dideploy.

Tampilkan daftar metrik eksternal kustom yang disediakan oleh adapter Prometheus.

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 berisi daftar resource metrik ASM kustom. Hal ini menunjukkan bahwa HPA berhasil dideploy.

Verifikasi auto scaling

Masuk ke kontainer load tester untuk menghasilkan permintaan workload.

kubectl -n test exec -it ${loadtester} -c loadtester -- hey -z 5m -c 10 -q 5 http://podinfo.test:9898

Periksa status auto scaling.
Catatan
Secara default, metrik disinkronkan setiap 30 detik. Operasi penskalaan hanya dapat terjadi jika workload belum diskalakan ulang dalam 3 hingga 5 menit terakhir. Hal ini mencegah HPA membuat keputusan yang cepat dan bertentangan serta memberikan waktu bagi Cluster Autoscaler untuk beroperasi.
```
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
```
Setelah satu menit, HPA mulai menambah jumlah workload hingga jumlah permintaan per detik turun di bawah nilai target. Setelah pengujian beban selesai, jumlah permintaan per detik turun menjadi nol, dan HPA mulai mengurangi jumlah Pod workload. Setelah beberapa menit, jumlah replika pada output perintah kembali menjadi satu.