Clever Geek Handbook

Autoscaling aplikasi Kubernetes dengan Prometheus dan KEDA

Balloon Man by Cimuanos



Scalability adalah persyaratan utama untuk aplikasi cloud. Dengan Kubernetes, menskalakan aplikasi semudah menambah jumlah replika untuk penerapan yang sesuai, atauReplicaSet- tetapi ini adalah proses manual.



Kubernetes memungkinkan aplikasi untuk melakukan penskalaan otomatis (yaitu Pod dalam penerapan atauReplicaSet) secara deklaratif menggunakan spesifikasi Horizontal Pod Autoscaler. Kriteria default untuk penskalaan otomatis adalah metrik penggunaan CPU (metrik sumber daya), tetapi metrik khusus dan metrik yang disediakan secara eksternal dapat diintegrasikan.



Tim Kubernetes aaS dari Mail.rumenerjemahkan artikel tentang Cara Menggunakan Metrik Eksternal untuk Menskalakan Aplikasi Kubernetes Anda Secara Otomatis. Untuk menunjukkan bagaimana semuanya bekerja, penulis menggunakan metrik permintaan akses HTTP, mereka dikumpulkan menggunakan Prometheus.



Alih-alih penskalaan otomatis pod secara horizontal, Kubernetes Event Driven Autoscaling (KEDA) adalah operator Kubernetes open source. Ini terintegrasi secara native dengan Horizontal Pod Autoscaler untuk menyediakan penskalaan otomatis yang lancar (termasuk ke / dari nol) untuk beban kerja yang digerakkan oleh peristiwa. Kode tersebut tersedia di GitHub .



Penjelasan Pengoperasian Sistem







Diagram menunjukkan deskripsi singkat tentang bagaimana semuanya bekerja:



  1. Aplikasi ini menyediakan metrik untuk jumlah permintaan HTTP dalam format Prometheus.
  2. Prometheus diatur untuk mengumpulkan metrik ini.
  3. Scaler Prometheus di KEDA dikonfigurasi untuk secara otomatis menskalakan aplikasi berdasarkan jumlah permintaan HTTP.


Sekarang saya akan memberi tahu Anda secara detail tentang setiap elemen.



KEDA dan Prometheus



Prometheus adalah alat pemantauan dan peringatan sistem open source, bagian dari Cloud Native Computing Foundation . Mengumpulkan metrik dari berbagai sumber dan menyimpannya sebagai data deret waktu. Untuk memvisualisasikan data, Anda dapat menggunakan Grafana atau alat visualisasi lainnya yang bekerja dengan API Kubernetes.



KEDA mendukung konsep scaler - ini bertindak sebagai jembatan antara KEDA dan sistem eksternal. Implementasi scaler khusus untuk setiap sistem target dan mengekstrak data darinya. KEDA kemudian menggunakannya untuk mengontrol penskalaan otomatis.



Scalers mendukung berbagai sumber data seperti Kafka, Redis, Prometheus. Artinya, KEDA dapat digunakan untuk menskalakan penerapan Kubernetes secara otomatis menggunakan metrik Prometheus sebagai kriteria.



Uji aplikasi



Aplikasi uji Golang menyediakan akses HTTP dan memiliki dua fungsi penting:



  1. Menggunakan pustaka klien Prometheus Go untuk melengkapi aplikasi dan menyediakan metrik http_requests yang berisi penghitung hit. Titik akhir tempat metrik Prometheus tersedia terletak di URI /metrics. 



    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
  2. Menanggapi permintaan tersebut, GETaplikasi menambahkan nilai key ( access_count) di Redis. Ini adalah cara mudah untuk menyelesaikan pekerjaan sebagai bagian dari penangan HTTP dan juga memeriksa metrik Prometheus. Nilai metrik harus sama dengan nilai access_countdi Redis. 



    func main() {
       http.Handle("/metrics", promhttp.Handler())
       http.HandleFunc("/test", func(w http.ResponseWriter, r 
*http.Request) {
           defer httpRequestsCounter.Inc()
           count, err := client.Incr(redisCounterName).Result()
           if err != nil {
               fmt.Println("Unable to increment redis counter", err)
               os.Exit(1)
           }
           resp := "Accessed on " + time.Now().String() + "\nAccess count " + strconv.Itoa(int(count))
           w.Write([]byte(resp))
       })
       http.ListenAndServe(":8080", nil)
   }


Aplikasi ini di-deploy ke Kubernetes melalui Deployment. Layanan juga dibuat ClusterIPyang memungkinkan server Prometheus menerima metrik aplikasi.



Berikut adalah manifes penerapan untuk aplikasi .



Server Prometheus



Manifes penerapan Prometheus terdiri dari:



  • ConfigMap - untuk mentransfer konfigurasi Prometheus;
  • Deployment - untuk menerapkan Prometheus di cluster Kubernetes;
  • ClusterIP - layanan untuk mengakses UI Prometheus;
  • ClusterRole, ClusterRoleBindingdan ServiceAccount- untuk deteksi otomatis layanan di Kubernetes (Penemuan otomatis).


Ini adalah manifestasi untuk menjalankan Prometheus .



KEDA Prometheus ScaledObject



Scaler bertindak sebagai jembatan antara KEDA dan sistem eksternal dari mana metrik perlu diperoleh. ScaledObjectMerupakan sumber daya khusus, ia perlu diterapkan untuk menyinkronkan penerapan dengan sumber peristiwa, dalam hal ini Prometheus.



ScaledObjectberisi informasi penskalaan penyebaran, metadata sumber peristiwa (seperti rahasia koneksi, nama antrian), interval polling, periode pemulihan, dan informasi lainnya. Ini menghasilkan sumber penskalaan otomatis yang sesuai (definisi HPA) untuk menskalakan penerapan.



Saat sebuah objek ScaledObjectdihapus, definisi HPA terkaitnya dihapus.



Berikut adalah definisi ScaledObjectuntuk contoh kami, menggunakan scaler Prometheus: 



apiVersion: keda.k8s.io/v1alpha1
kind: ScaledObject
metadata:
 name: prometheus-scaledobject
 namespace: default
 labels:
   deploymentName: go-prom-app
spec:
 scaleTargetRef:
   deploymentName: go-prom-app
 pollingInterval: 15
 cooldownPeriod:  30
 minReplicaCount: 1
 maxReplicaCount: 10
 triggers:
 - type: prometheus
   metadata:
     serverAddress: 
http://prometheus-service.default.svc.cluster.local:9090
     metricName: access_frequency
     threshold: '3'
     query: sum(rate(http_requests[2m]))


Perhatikan poin-poin berikut:



  1. Dia menunjuk Deploymentdengan sebuah nama go-prom-app.
  2. Jenis pemicu - Prometheus. Alamat server Prometheus disebutkan bersama dengan nama metrik, ambang batas, dan permintaan PromQL yang akan digunakan. Permintaan PromQL - sum(rate(http_requests[2m])).
  3. Menurut pollingIntervalKEDA, ia meminta target dari Prometheus setiap lima belas detik. Setidaknya satu pod ( minReplicaCount) didukung , dan jumlah maksimum pod tidak melebihi maxReplicaCount(dalam contoh ini, sepuluh).


Dapat disetel minReplicaCountke nol. Dalam kasus ini, KEDA mengaktifkan penerapan zero-to-one dan kemudian menyediakan HPA untuk penskalaan otomatis lebih lanjut. Urutan sebaliknya juga dimungkinkan, yaitu penskalaan dari satu ke nol. Dalam contoh, kami tidak memilih nol karena ini adalah layanan HTTP dan bukan sistem berdasarkan permintaan.



Keajaiban di dalam penskalaan otomatis



Ambang batas digunakan sebagai pemicu untuk menskalakan penerapan. Dalam contoh kami, kueri PromQL sum(rate (http_requests [2m]))mengembalikan nilai agregat dari tingkat permintaan HTTP (permintaan per detik), diukur selama dua menit terakhir.



Karena ambangnya tiga, akan ada satu di bawah selama nilainya sum(rate (http_requests [2m]))kurang dari tiga. Jika nilainya meningkat, tambahan di bawah ditambahkan setiap kali nilainya meningkat sum(rate (http_requests [2m]))tiga. Misalnya, jika nilainya dari 12 hingga 14, maka jumlah podnya adalah empat.



Sekarang mari kita coba mengkonfigurasi!



Pengaturan awal



Yang Anda butuhkan hanyalah cluster Kubernetes dan utilitas yang disesuaikan kubectl. Contoh ini menggunakan cluster minikube, tetapi Anda dapat menggunakan cluster lainnya. Ada panduan untuk menginstal cluster .



Instal versi terbaru di Mac: 



curl -Lo minikube 
https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 \
&& chmod +x minikube
sudo mkdir -p /usr/local/bin/
sudo install minikube /usr/local/bin/


Instal kubectl untuk mengakses cluster Kubernetes Anda.



Instal versi terbaru di Mac: 



curl -LO 
"https://storage.googleapis.com/kubernetes-release/release/$(curl -s
https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/darwin/amd64/kubectl"
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
kubectl version


Menginstal KEDA



Anda dapat menerapkan KEDA dengan beberapa cara, semuanya tercantum dalam dokumentasi . Saya menggunakan YAML monolitik: 



kubectl apply -f
https://raw.githubusercontent.com/kedacore/keda/master/deploy/KedaScaleController.yaml


KEDA dan komponennya dipasang di namespace keda. Perintah untuk memeriksa: 



kubectl get pods -n keda


Tunggu, ketika di bawah KEDA Operator mulai - pergi ke Running State. Dan kemudian lanjutkan.



Memasang Redis dengan Helm



Jika Anda belum menginstal Helm, gunakan tutorial ini . Perintah untuk menginstal di Mac: 



brew install kubernetes-helm
helm init --history-max 200


helm initmenginisialisasi CLI lokal dan juga menginstal Tillerke cluster Kubernetes. 



kubectl get pods -n kube-system | grep tiller


Tunggu pod Tiller memasuki status Running.



Catatan Penerjemah : Penulis menggunakan Helm @ 2, yang membutuhkan komponen server Tiller untuk diinstal. Helm @ 3 saat ini relevan, tidak membutuhkan bagian server.



Setelah menginstal Helm, satu perintah sudah cukup untuk memulai Redis: 



helm install --name redis-server --set cluster.enabled=false --set 
usePassword=false stable/redis


Verifikasi Redis telah berhasil dimulai: 



kubectl get pods/redis-server-master-0


Tunggu di bawah Redis untuk masuk ke status Running.



Terapkan aplikasi



Perintah untuk penyebaran: 



kubectl apply -f go-app.yaml

//output
deployment.apps/go-prom-app created
service/go-prom-app-service created


Periksa apakah semuanya dimulai: 



kubectl get pods -l=app=go-prom-app


Tunggu Redis bertransisi ke status Running.



Menerapkan Server Prometheus



Manifes Prometheus menggunakan Kubernetes Service Discovery untuk Prometheus . Ini memungkinkan Anda untuk menemukan pod aplikasi secara dinamis berdasarkan label layanan. 



kubernetes_sd_configs:
   - role: service
   relabel_configs:
   - source_labels: [__meta_kubernetes_service_label_run]
     regex: go-prom-app-service
     action: keep


Untuk penerapan: 



kubectl apply -f prometheus.yaml

//output
clusterrole.rbac.authorization.k8s.io/prometheus created
serviceaccount/default configured
clusterrolebinding.rbac.authorization.k8s.io/prometheus created
configmap/prom-conf created
deployment.extensions/prometheus-deployment created
service/prometheus-service created


Periksa apakah semuanya dimulai: 



kubectl get pods -l=app=prometheus-server


Tunggu di bawah Prometheus untuk masuk ke status Running.



Gunakan kubectl port-forwarduntuk mengakses antarmuka pengguna Prometheus (atau server API) di http: // localhost: 9090 . 



kubectl port-forward service/prometheus-service 9090


Menerapkan konfigurasi penskalaan otomatis KEDA



Perintah untuk membuat ScaledObject: 



kubectl apply -f keda-prometheus-scaledobject.yaml


Periksa log operator KEDA: 



KEDA_POD_NAME=$(kubectl get pods -n keda 
-o=jsonpath='{.items[0].metadata.name}')
kubectl logs $KEDA_POD_NAME -n keda


Hasilnya terlihat seperti ini: 



time="2019-10-15T09:38:28Z" level=info msg="Watching ScaledObject:
default/prometheus-scaledobject"
time="2019-10-15T09:38:28Z" level=info msg="Created HPA with 
namespace default and name keda-hpa-go-prom-app"


Periksa di bawah aplikasi. Satu contoh harus berjalan karena minReplicaCount1: 



kubectl get pods -l=app=go-prom-app


Verifikasi bahwa sumber daya HPA telah berhasil dibuat: 



kubectl get hpa


Anda akan melihat sesuatu seperti: 



NAME                   REFERENCE                TARGETS     MINPODS   MAXPODS   REPLICAS   AGE
keda-hpa-go-prom-app   Deployment/go-prom-app   0/3 (avg)   1         10        1          45s


Pemeriksaan kesehatan: akses ke aplikasi



Untuk mengakses titik akhir REST aplikasi kita, jalankan: 



kubectl port-forward service/go-prom-app-service 8080


Sekarang Anda dapat mengakses aplikasi Go menggunakan alamat http: // localhost: 8080 . Untuk melakukan ini, jalankan perintah: 



curl http://localhost:8080/test


Hasilnya terlihat seperti ini: 



Accessed on 2019-10-21 11:29:10.560385986 +0000 UTC 
m=+406004.817901246
Access count 1


Periksa Redis pada saat ini juga. Anda akan melihat kuncinya access_countmeningkat menjadi 1: 



kubectl exec -it redis-server-master-0 -- redis-cli get access_count
//output
"1"


Pastikan nilai metriknya http_requestssama: 



curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests number of http requests
# TYPE http_requests counter
http_requests 1


Muat kreasi



Kami akan menggunakan hey , utilitas untuk menghasilkan beban: 



curl -o hey https://storage.googleapis.com/hey-release/hey_darwin_amd64 
&& chmod a+x hey


Anda juga dapat mengunduh utilitas untuk Linux atau Windows .



Menjalankannya: 



./hey http://localhost:8080/test


Secara default, utilitas mengirimkan 200 permintaan. Anda dapat memverifikasi ini dengan menggunakan metrik Prometheus serta Redis. 



curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests number of http requests
# TYPE http_requests counter
http_requests 201
kubectl exec -it redis-server-master-0 -- redis-cli get access_count
//output
201


Konfirmasikan nilai metrik aktual (dikembalikan oleh kueri PromQL): 



curl -g 
'http://localhost:9090/api/v1/query?query=sum(rate(http_requests[2m]))'
//output
{"status":"success","data":{"resultType":"vector","result":[{"metric":{},"value":[1571734214.228,"1.686057971014493"]}]}}


Dalam hal ini, hasil sebenarnya sama 1,686057971014493dan ditampilkan di lapangan value. Ini tidak cukup untuk penskalaan karena ambang batas yang kami tetapkan adalah 3.



Lebih banyak beban!



Di terminal baru, lacak jumlah pod aplikasi: 



kubectl get pods -l=app=go-prom-app -w


Mari tingkatkan beban menggunakan perintah: 



./hey -n 2000 http://localhost:8080/test


Setelah beberapa saat, Anda akan melihat HPA menskalakan penerapan dan meluncurkan pod baru. Periksa HPA untuk memastikan: 



kubectl get hpa
NAME                   REFERENCE                TARGETS         MINPODS   MAXPODS   REPLICAS   AGE
keda-hpa-go-prom-app   Deployment/go-prom-app   1830m/3 (avg)   1         10        6          4m22s


Jika beban tidak konstan, penerapan akan dikurangi ke titik di mana hanya satu pod yang berfungsi. Jika Anda ingin memeriksa metrik sebenarnya (dikembalikan oleh kueri PromQL), gunakan perintah: 



curl -g 
'http://localhost:9090/api/v1/query?query=sum(rate(http_requests[2m]))'


Pembersihan



//Delete KEDA
kubectl delete namespace keda
//Delete the app, Prometheus server and KEDA scaled object
kubectl delete -f .
//Delete Redis
helm del --purge redis-server


Kesimpulan



KEDA memungkinkan Anda untuk secara otomatis menskalakan penerapan Kubernetes Anda (ke / dari nol) berdasarkan data dari metrik eksternal. Misalnya berdasarkan metrik Prometheus, panjang antrian di Redis, latensi konsumen dalam tema Kafka.



KEDA terintegrasi dengan sumber eksternal dan juga menyediakan metrik melalui Metrics Server untuk Horizontal Pod Autoscaler.



Semoga berhasil!



Apa lagi yang harus dibaca:



  1. Praktik dan pedoman terbaik untuk menjalankan container dan Kubernetes di lingkungan produksi .
  2. 90+ alat yang berguna untuk Kubernetes: penerapan, pengelolaan, pemantauan, keamanan, dan lainnya .
  3. Saluran kami di Sekitar Kubernetes di Telegram .


More articles:


All Articles