ProHoster > blog > administrasi > Penskalaan Otomatis Aplikasi Kubernetes dengan Prometheus dan KEDA

Penskalaan Otomatis Aplikasi Kubernetes dengan Prometheus dan KEDA

Penskalaan Otomatis Aplikasi Kubernetes dengan Prometheus dan KEDAManusia Balon oleh Cimuanos

Skalabilitas adalah persyaratan utama untuk aplikasi cloud. Dengan Kubernetes, penskalaan aplikasi semudah meningkatkan jumlah replika untuk penerapan atau penerapan yang sesuai ReplicaSet β€” tapi ini adalah proses manual.

Kubernetes memungkinkan aplikasi untuk diskalakan secara otomatis (yaitu Pod dalam penerapan atau ReplicaSet) secara deklaratif menggunakan spesifikasi Horizontal Pod Autoscaler. Kriteria default untuk penskalaan otomatis adalah metrik penggunaan CPU (metrik sumber daya), namun Anda dapat mengintegrasikan metrik khusus dan yang disediakan secara eksternal.

Tim Kubernetes aaS dari Mail.ru menerjemahkan artikel tentang cara menggunakan metrik eksternal untuk menskalakan aplikasi Kubernetes secara otomatis. Untuk menunjukkan cara kerja semuanya, penulis menggunakan metrik permintaan akses HTTP, yang dikumpulkan menggunakan Prometheus.

Alih-alih melakukan penskalaan otomatis horizontal pada pod, digunakan Kubernetes Event Driven Autoscaling (KEDA), yang merupakan operator Kubernetes open source. Ini terintegrasi secara asli dengan Horizontal Pod Autoscaler untuk menyediakan penskalaan otomatis yang lancar (termasuk ke/dari nol) untuk beban kerja berbasis peristiwa. Kode tersedia di GitHub.

Tinjauan singkat tentang sistem

Penskalaan Otomatis Aplikasi Kubernetes dengan Prometheus dan KEDA

Diagram menunjukkan deskripsi singkat tentang cara kerja semuanya:

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

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

KEDA dan Prometheus

Prometheus adalah bagian dari perangkat pemantauan dan peringatan sistem sumber terbuka Yayasan Komputasi Asli Cloud. Mengumpulkan metrik dari berbagai sumber dan menyimpannya sebagai data deret waktu. Untuk memvisualisasikan data dapat Anda gunakan grafana atau alat visualisasi lainnya yang bekerja dengan Kubernetes API.

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

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

Aplikasi uji

Aplikasi pengujian Golang menyediakan akses melalui HTTP dan menjalankan dua fungsi penting:

  1. Menggunakan pustaka klien Prometheus Go untuk melengkapi aplikasi dan menyediakan metrik http_requests, yang berisi jumlah 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 GET aplikasi menambah nilai kunci (access_count) di Redis. Ini adalah cara mudah untuk melakukan pekerjaan sebagai bagian dari penangan HTTP dan juga memeriksa metrik Prometheus. Nilai metrik harus sama dengan nilainya access_count di 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 disebarkan ke Kubernetes melalui Deployment. Sebuah layanan juga dibuat ClusterIP, ini memungkinkan server Prometheus memperoleh metrik aplikasi.

di sini 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 akses ke UI Prometheus;
  • ClusterRole, ClusterRoleBinding ΠΈ ServiceAccount β€” untuk deteksi otomatis layanan di Kubernetes (Penemuan Otomatis).

di sini adalah manifes untuk menjalankan Prometheus.

KEDA Prometheus ScaledObject

Scaler bertindak sebagai jembatan antara KEDA dan sistem eksternal dimana metrik perlu diperoleh. ScaledObject adalah sumber daya khusus yang perlu disebarkan untuk menyinkronkan penerapan dengan sumber peristiwa, dalam hal ini Prometheus.

ScaledObject berisi informasi penskalaan penerapan, metadata sumber peristiwa (seperti rahasia koneksi, nama antrean), interval polling, periode pemulihan, dan data lainnya. Hal ini menghasilkan sumber daya penskalaan otomatis yang sesuai (definisi HPA) untuk menskalakan penerapan.

Ketika suatu objek ScaledObject dihapus, definisi HPA terkait akan dihapus.

Berikut definisinya ScaledObject untuk contoh kita, ini 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]))

Harap perhatikan hal-hal berikut:

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

Dapat menginstal minReplicaCount sama dengan nol. Dalam hal ini, KEDA mengaktifkan penerapan zero-to-one dan kemudian memaparkan HPA untuk penskalaan otomatis lebih lanjut. Urutan terbalik juga dimungkinkan, yaitu penskalaan dari satu ke nol. Dalam contoh ini, kami tidak memilih nol karena ini adalah layanan HTTP dan bukan sistem on-demand.

Keajaiban dalam penskalaan otomatis

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

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

Sekarang mari kita coba mengaturnya!

presetting

Yang Anda perlukan hanyalah cluster Kubernetes dan utilitas yang dikonfigurasi kubectl. Contoh ini menggunakan cluster minikube, tapi Anda dapat mengambil yang lain. Untuk menginstal cluster ada panduan.

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/

Mengatur kubectluntuk mengakses kluster Kubernetes.

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

instalasi KEDA

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

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

KEDA dan komponennya dipasang ke dalam namespace keda. Perintah untuk memeriksa:

kubectl get pods -n keda

Tunggu Operator KEDA untuk memulai dan pergi ke Running State. Dan setelah itu lanjutkan.

Menginstal Redis menggunakan Helm

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

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

helm init menginisialisasi antarmuka baris perintah lokal dan juga menginstal Tiller ke kluster Kubernetes.

kubectl get pods -n kube-system | grep tiller

Tunggu hingga Tiller pod memasuki status Running.

Catatan penerjemah: Penulis menggunakan Helm@2 yang memerlukan instalasi komponen server Tiller. Sekarang Helm@3 relevan, tidak memerlukan 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 bahwa Redis telah berhasil dimulai:

kubectl get pods/redis-server-master-0

Tunggu hingga Redis masuk ke status Running.

Penerapan Aplikasi

Perintah penerapan:

kubectl apply -f go-app.yaml

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

Periksa apakah semuanya sudah dimulai:

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

Tunggu hingga Redis memasuki status Running.

Menyebarkan Server Prometheus

Manifes Prometheus menggunakan Penemuan Layanan Kubernetes untuk Prometheus. Hal ini memungkinkan penemuan 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 menyebarkan:

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 sudah dimulai:

kubectl get pods -l=app=prometheus-server

Tunggu hingga Prometheus masuk ke status Running.

Gunakan kubectl port-forward untuk 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 minReplicaCount sama dengan 1:

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

Verifikasi bahwa sumber daya HPA 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 aplikasi

Untuk mengakses titik akhir REST aplikasi kita, jalankan:

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

Anda sekarang dapat mengakses aplikasi Go Anda menggunakan alamat tersebut 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

Pada titik ini periksa juga Redis. Anda akan melihat kuncinya access_count meningkat menjadi 1:

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

Pastikan nilai metriknya adalah http_requests sama:

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

Pembuatan Beban

Kami akan menggunakan hei β€” 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 ΠΈΠ»ΠΈ Windows.

Menjalankannya:

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

Secara default, utilitas mengirimkan 200 permintaan. Anda dapat memverifikasi ini menggunakan metrik Prometheus dan 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

Validasi nilai metrik sebenarnya (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 adalah 1,686057971014493 dan ditampilkan di lapangan value. Ini tidak cukup untuk penskalaan, karena ambang batas yang kami tetapkan adalah 3.

Lebih banyak beban!

Di terminal baru, pantau jumlah pod aplikasi:

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

Mari tambah 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 Anda 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 muatannya tidak konsisten, penerapannya akan dikurangi hingga hanya satu pod yang berjalan. 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]))'

ΠžΡ‡ΠΈΡΡ‚ΠΊΠ°

//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 di topik Kafka.

KEDA terintegrasi dengan sumber eksternal dan juga menyediakan metriknya melalui Server Metrik ke Horizontal Pod Autoscaler.

Good Luck!

Apa lagi yang harus dibaca:

  1. Praktik terbaik dan praktik terbaik untuk menjalankan container dan Kubernetes di lingkungan produksi.
  2. 90+ alat berguna untuk Kubernetes: penerapan, pengelolaan, pemantauan, keamanan, dan banyak lagi.
  3. Saluran kami Seputar Kubernetes di Telegram.

Sumber: www.habr.com

Tambah komentar