Alibaba Cloud Service Mesh:Penyeimbangan beban berdasarkan latensi beban kerja menggunakan EWMA

Deskripsi

Dalam contoh ini, aplikasi simple-server adalah server. Aplikasi sleep berfungsi sebagai klien untuk mengirim trafik uji dan layanan simple-server.default.svc.cluster.local berdasarkan aplikasi simple-server berfungsi sebagai server. Layanan ini memiliki dua deployment dengan konfigurasi berbeda:

• simple-server-normal: Latensi respons deployment ini berkisar antara 50 ms hingga 100 ms.

• simple-server-high-latency: Latensi respons deployment ini berkisar antara 500 ms hingga 2000 ms. Deployment ini digunakan untuk mensimulasikan peningkatan latensi beberapa beban kerja layanan.

Langkah 1: Aktifkan pemantauan metrik untuk instance ASM

Untuk menunjukkan manfaat algoritma penyeimbangan beban peak EWMA secara visual, kami mengaktifkan pemantauan metrik untuk instance ASM dalam contoh ini untuk mengamati perubahan latensi respons keseluruhan layanan sebelum dan sesudah algoritma penyeimbangan beban peak EWMA diaktifkan. Untuk informasi lebih lanjut tentang cara mengaktifkan pemantauan metrik dan mengumpulkan metrik ke Application Real-Time Monitoring Service (ARMS), lihat Kumpulkan Metrik ke Managed Service for Prometheus.

Langkah 2: Terapkan lingkungan yang diperlukan

1. Gunakan kubectl untuk terhubung ke cluster ACK berdasarkan informasi dalam file kubeconfig, dan buat file sleep.yaml yang berisi konten berikut:

   Tampilkan File YAML

   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: sleep
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: sleep
     labels:
       app: sleep
       service: sleep
   spec:
     ports:
     - port: 80
       name: http
     selector:
       app: sleep
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: sleep
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: sleep
     template:
       metadata:
         labels:
           app: sleep
       spec:
         terminationGracePeriodSeconds: 0
         serviceAccountName: sleep
         containers:
         - name: sleep
           image: curlimages/curl
           command: ["/bin/sleep", "infinity"]
           imagePullPolicy: IfNotPresent
           volumeMounts:
           - mountPath: /etc/sleep/tls
             name: secret-volume
         volumes:
         - name: secret-volume
           secret:
             secretName: sleep-secret
             optional: true
   ---

   Jalankan perintah berikut untuk menerapkan aplikasi sleep:

   kubectl apply -f sleep.yaml

2. Buat file simple.yaml yang berisi konten berikut:

   Tampilkan File YAML

   apiVersion: v1
   kind: Service
   metadata:
     name: simple-server
     labels:
       app: simple-server
       service: simple-server
   spec:
     ports:
     - port: 8080
       name: http
     selector:
       app: simple-server
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       app: simple-server
     name: simple-server-normal
     namespace: default
   spec:
     progressDeadlineSeconds: 600
     replicas: 1
     revisionHistoryLimit: 10
     selector:
       matchLabels:
         app: simple-server
     strategy:
       rollingUpdate:
         maxSurge: 25%
         maxUnavailable: 25%
       type: RollingUpdate
     template:
       metadata:
         creationTimestamp: null
         labels:
           app: simple-server
       spec:
         containers:
         - args:
           - --delayMin
           - "50"
           - --delayMax
           - "100"
           image: registry-cn-hangzhou.ack.aliyuncs.com/test-public/simple-server:v1.0.0.0-g88293ca-aliyun
           imagePullPolicy: IfNotPresent
           name: simple-server
           ports:
           - containerPort: 80
             protocol: TCP
           resources:
             limits:
               cpu: 500m
           terminationMessagePath: /dev/termination-log
           terminationMessagePolicy: File
         dnsPolicy: ClusterFirst
         restartPolicy: Always
         schedulerName: default-scheduler
         securityContext: {}
         terminationGracePeriodSeconds: 30
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       app: simple-server
     name: simple-server-high-latency
     namespace: default
   spec:
     progressDeadlineSeconds: 600
     replicas: 1
     revisionHistoryLimit: 10
     selector:
       matchLabels:
         app: simple-server
     strategy:
       rollingUpdate:
         maxSurge: 25%
         maxUnavailable: 25%
       type: RollingUpdate
     template:
       metadata:
         creationTimestamp: null
         labels:
           app: simple-server
       spec:
         containers:
         - args:
           - --delayMin
           - "500"
           - --delayMax
           - "2000"
           image: registry-cn-hangzhou.ack.aliyuncs.com/test-public/simple-server:v1.0.0.0-g88293ca-aliyun
           imagePullPolicy: IfNotPresent
           name: simple-server
           ports:
           - containerPort: 80
             protocol: TCP
           resources:
             limits:
               cpu: 500m
           terminationMessagePath: /dev/termination-log
           terminationMessagePolicy: File
         dnsPolicy: ClusterFirst
         restartPolicy: Always
         schedulerName: default-scheduler
         securityContext: {}
         terminationGracePeriodSeconds: 30
   ---

   Jalankan perintah berikut untuk menerapkan aplikasi simple-server-normal dan simple-server-high-latency:

   kubectl apply -f simple.yaml

Langkah 3: Mulai pengujian dengan algoritma penyeimbangan beban default

Algoritma penyeimbangan beban default LEAST_REQUEST digunakan dalam pengujian ini untuk menghasilkan data dasar.

1. Jalankan perintah berikut untuk memulai pengujian. 100 permintaan dikirim untuk mengunjungi path /hello dari layanan simple-server:

   kubectl exec -it deploy/sleep -c sleep --  sh -c 'for i in $(seq 1 100); do time curl simple-server:8080/hello; echo "request $i done"; done'

   Output yang Diharapkan:

   hello
    this is port: 8080real 0m 0.06s
   user    0m 0.00s
   sys     0m 0.00s
   request 1 done
   hello
    this is port: 8080real 0m 0.09s
   user    0m 0.00s
   sys     0m 0.00s
   request 2 done
   
   ......
   
   hello
    this is port: 8080real 0m 1.72s
   user    0m 0.00s
   sys     0m 0.00s
   request 100 done

2. Setelah perintah dijalankan, klik nama instance ASM yang diinginkan di halaman Mesh Management. Di panel navigasi di sebelah kiri, pilih Observability Management Center > Monitoring metrics. Klik tab Cloud ASM Istio Service dan konfigurasikan kondisi filter berikut:

   • Namespace: default

   • Service: simple-server.default.svc.cluster.local

   • Reporter: destination

   • Client Workload Namespace: default

   • Client Workload: sleep

   • Service Workload Namespace: default

   • Service Workload: simple-server-normal + simple-server-high-latency

3. Klik Client Workloads untuk melihat bagian Incoming Request Duration By Source.

   

   Ini menunjukkan bahwa latensi respons P50 dari permintaan dari aplikasi sleep ke layanan simple-server adalah 87,5 ms, dan latensi respons P95 meningkat secara signifikan menjadi 2,05 detik. Hal ini karena latensi respons aplikasi simple-server-high-latency lebih tinggi, yang meningkatkan waktu respons keseluruhan layanan simple-server.

   Penting

   Hasil pengujian sebelumnya adalah nilai teoretis yang diperoleh dalam lingkungan eksperimental terkontrol. Hasil aktual mungkin bervariasi tergantung pada lingkungan bisnis Anda.

Langkah 4: Konfigurasikan algoritma penyeimbangan beban peak EWMA dan lakukan pengujian lagi

Buat aturan tujuan untuk mengonfigurasi algoritma penyeimbangan beban peak EWMA untuk layanan simple-server.

1. Gunakan konten YAML berikut untuk membuat aturan tujuan dengan mengacu pada langkah-langkah di Gunakan Peak EWMA:

   apiVersion: networking.istio.io/v1beta1
   kind: DestinationRule
   metadata:
     name: simple-server
     namespace: default
   spec:
     host: simple-server.default.svc.cluster.local
     trafficPolicy:
       loadBalancer:
         simple: PEAK_EWMA

2. Gunakan kubectl untuk terhubung ke cluster ACK berdasarkan informasi dalam file kubeconfig, dan jalankan perintah berikut untuk memulai pengujian lagi:

   kubectl exec -it deploy/sleep -c sleep --  sh -c 'for i in $(seq 1 100); do time curl simple-server:8080/hello; echo "request $i done"; done'

3. Amati hasil pengujian dengan mengacu pada Langkah 3. Hasilnya menunjukkan bahwa latensi P90, P95, dan P99 berkurang secara signifikan. Hal ini karena algoritma penyeimbangan beban peak EWMA menemukan bahwa latensi beban kerja simple-server-high-latency tinggi dan mengurangi bobot penyeimbangan bebannya. Akibatnya, lebih banyak permintaan diarahkan ke simple-server-normal dengan latensi lebih rendah. Dari sudut pandang layanan simple-server, latensi keseluruhan permintaan berkurang secara signifikan.