🥇Autoscaling aplikasi Kubernetes menggunakan Prometheus dan KEDA

Lelaki Belon oleh Cimuanos

Kebolehskalaan adalah keperluan utama untuk aplikasi awan. Dengan Kubernetes, penskalaan aplikasi adalah semudah menambah bilangan replika untuk penggunaan yang sesuai atau ReplicaSet — tetapi ia adalah proses manual.

Kubernetes membenarkan aplikasi diskalakan secara automatik (iaitu Pod dalam penempatan atau ReplicaSet) secara deklaratif menggunakan spesifikasi Autoscaler Pod Horizontal. Kriteria lalai untuk penskalaan automatik ialah metrik penggunaan CPU (metrik sumber), tetapi anda boleh menyepadukan metrik tersuai dan yang disediakan secara luaran.

Pasukan Kubernetes aaS daripada Mail.ru menterjemah artikel tentang cara menggunakan metrik luaran untuk menskalakan aplikasi Kubernetes secara automatik. Untuk menunjukkan cara semuanya berfungsi, pengarang menggunakan metrik permintaan akses HTTP, yang dikumpulkan menggunakan Prometheus.

Daripada penskalaan auto mendatar pod, Penskalaan Auto Didorong Peristiwa Kubernetes (KEDA) digunakan, pengendali Kubernetes sumber terbuka. Ia disepadukan secara asli dengan Horizontal Pod Autoscaler untuk menyediakan penskalaan automatik yang lancar (termasuk ke/daripada sifar) untuk beban kerja yang didorong oleh peristiwa. Kod boleh didapati di GitHub.

Gambaran keseluruhan ringkas sistem

Rajah menunjukkan penerangan ringkas tentang cara semuanya berfungsi:

Aplikasi ini menyediakan metrik kiraan hit HTTP dalam format Prometheus.
Prometheus dikonfigurasikan untuk mengumpul metrik ini.
Penskala Prometheus dalam KEDA dikonfigurasikan untuk menskalakan aplikasi secara automatik berdasarkan bilangan klik HTTP.

Sekarang saya akan memberitahu anda secara terperinci tentang setiap elemen.

KEDA dan Prometheus

Prometheus ialah kit alat pemantauan dan amaran sistem sumber terbuka, sebahagian Yayasan Pengkomputeran Asli Cloud. Mengumpul metrik daripada pelbagai sumber dan menyimpannya sebagai data siri masa. Untuk menggambarkan data yang anda boleh gunakan grafana atau alat visualisasi lain yang berfungsi dengan API Kubernetes.

KEDA menyokong konsep skalar - ia bertindak sebagai jambatan antara KEDA dan sistem luaran. Pelaksanaan penskala adalah khusus untuk setiap sistem sasaran dan mengekstrak data daripadanya. KEDA kemudian menggunakannya untuk mengawal penskalaan automatik.

Scaler menyokong berbilang sumber data, contohnya, Kafka, Redis, Prometheus. Iaitu, KEDA boleh digunakan untuk menskalakan penggunaan Kubernetes secara automatik menggunakan metrik Prometheus sebagai kriteria.

Permohonan ujian

Aplikasi ujian Golang menyediakan akses melalui HTTP dan melaksanakan dua fungsi penting:

Menggunakan pustaka klien Prometheus Go untuk memperalatkan aplikasi dan menyediakan metrik http_requests, yang mengandungi kiraan hit. Titik akhir di mana metrik Prometheus tersedia terletak di URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Sebagai tindak balas kepada permintaan GET aplikasi menambah nilai kunci (access_count) dalam Redis. Ini ialah cara mudah untuk melakukan kerja sebagai sebahagian daripada pengendali HTTP dan juga menyemak metrik Prometheus. Nilai metrik mestilah sama dengan nilai 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 digunakan untuk Kubernetes melalui Deployment. Perkhidmatan juga dibuat ClusterIP, ia membolehkan pelayan Prometheus mendapatkan metrik aplikasi.

di sini ialah manifes penggunaan untuk aplikasi.

Pelayan Prometheus

Manifes penggunaan Prometheus terdiri daripada:

ConfigMap — untuk memindahkan konfigurasi Prometheus;
Deployment — untuk menggunakan Prometheus dalam kelompok Kubernetes;
ClusterIP — perkhidmatan untuk akses kepada UI Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — untuk pengesanan automatik perkhidmatan dalam Kubernetes (Auto-penemuan).

di sini ialah manifes untuk menjalankan Prometheus.

KEDA Prometheus ScaledObject

Skala bertindak sebagai jambatan antara KEDA dan sistem luaran yang metrik perlu diperolehi. ScaledObject ialah sumber tersuai yang perlu digunakan untuk menyegerakkan penggunaan dengan sumber acara, dalam kes ini Prometheus.

ScaledObject mengandungi maklumat penskalaan penempatan, metadata sumber acara (seperti rahsia sambungan, nama baris gilir), selang pengundian, tempoh pemulihan dan data lain. Ia menghasilkan sumber autoscaling yang sepadan (definisi HPA) untuk menskalakan penggunaan.

Apabila objek ScaledObject dipadamkan, definisi HPA yang sepadan dikosongkan.

Inilah definisinya ScaledObject untuk contoh kami, ia menggunakan penimbang 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]))

Sila ambil perhatian perkara berikut:

Dia menunjuk ke Deployment Dengan nama go-prom-app.
Jenis pencetus - Prometheus. Alamat pelayan Prometheus disebut bersama dengan nama metrik, ambang dan Pertanyaan PromQL, yang akan digunakan. Pertanyaan PromQL - sum(rate(http_requests[2m])).
Menurut pollingInterval,KEDA meminta sasaran daripada Prometheus setiap lima belas saat. Sekurang-kurangnya satu di bawah (minReplicaCount), dan bilangan maksimum pod tidak melebihi maxReplicaCount (dalam contoh ini - sepuluh).

Boleh dipasang minReplicaCount sama dengan sifar. Dalam kes ini, KEDA mengaktifkan penggunaan sifar-ke-satu dan kemudian mendedahkan HPA untuk penskalaan automatik selanjutnya. Urutan terbalik juga mungkin, iaitu, skala dari satu kepada sifar. Dalam contoh, kami tidak memilih sifar kerana ini adalah perkhidmatan HTTP dan bukan sistem atas permintaan.

Keajaiban dalam autoscaling

Ambang digunakan sebagai pencetus untuk menskalakan penggunaan. Dalam contoh kami, pertanyaan PromQL sum(rate (http_requests [2m])) mengembalikan kadar permintaan HTTP terkumpul (permintaan sesaat), yang diukur selama dua minit terakhir.

Oleh kerana nilai ambang adalah tiga, ini bermakna akan ada satu di bawah manakala nilainya sum(rate (http_requests [2m])) kurang daripada tiga. Jika nilai meningkat, sub tambahan ditambahkan setiap kali sum(rate (http_requests [2m])) meningkat sebanyak tiga. Sebagai contoh, jika nilainya adalah dari 12 hingga 14, maka bilangan pod ialah empat.

Sekarang mari cuba sediakannya!

Pra-tetapan

Apa yang anda perlukan ialah gugusan Kubernetes dan utiliti yang dikonfigurasikan kubectl. Contoh ini menggunakan kluster minikube, tetapi anda boleh mengambil mana-mana yang lain. Untuk memasang kluster ada panduan.

Pasang versi terkini pada 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/

Tetapkan kubectluntuk mengakses kluster Kubernetes.

Pasang versi terkini pada 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

pemasangan KEDA

Anda boleh menggunakan KEDA dalam beberapa cara, mereka disenaraikan dalam dokumentasi. Saya menggunakan YAML monolitik:

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

KEDA dan komponennya dipasang ke dalam ruang nama keda. Perintah untuk menyemak:

kubectl get pods -n keda

Tunggu Operator KEDA bermula dan pergi ke Running State. Dan selepas itu, teruskan.

Memasang Redis menggunakan Helm

Jika anda tidak memasang Helm, gunakan ini kepimpinan. Perintah untuk memasang pada Mac:

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

helm init memulakan antara muka baris arahan tempatan dan juga memasang Tiller kepada gugusan Kubernetes.

kubectl get pods -n kube-system | grep tiller

Tunggu pod Tiller memasuki keadaan Running.

Nota penterjemah: Pengarang menggunakan Helm@2, yang memerlukan komponen pelayan Tiller dipasang. Sekarang Helm@3 adalah relevan, ia tidak memerlukan bahagian pelayan.

Selepas memasang Helm, satu arahan sudah cukup untuk memulakan Redis:

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

Sahkan bahawa Redis telah berjaya dimulakan:

kubectl get pods/redis-server-master-0

Tunggu Redis masuk ke negeri Running.

Penyerahan Aplikasi

Perintah penyebaran:

kubectl apply -f go-app.yaml

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

Semak bahawa semuanya telah bermula:

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

Tunggu Redis memasuki negeri Running.

Menggunakan Pelayan Prometheus

Manifes Prometheus menggunakan Penemuan Perkhidmatan Kubernetes untuk Prometheus. Ia membenarkan penemuan dinamik pod aplikasi berdasarkan label perkhidmatan.

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

Untuk menggunakan:

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

Semak bahawa semuanya telah bermula:

kubectl get pods -l=app=prometheus-server

Tunggu Prometheus pergi ke negeri Running.

Gunakan kubectl port-forward untuk mengakses antara muka pengguna Prometheus (atau pelayan API) di http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Menggunakan Konfigurasi Penskalaan Auto KEDA

Perintah untuk mencipta ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Semak 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 kelihatan 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"

Semak di bawah aplikasi. Satu contoh mesti berjalan kerana minReplicaCount sama dengan 1:

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

Sahkan bahawa sumber HPA berjaya dibuat:

kubectl get hpa

Anda sepatutnya 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 kesihatan: akses aplikasi

Untuk mengakses titik akhir REST aplikasi kami, jalankan:

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

Anda kini boleh mengakses apl Go anda menggunakan alamat tersebut http://localhost:8080. Untuk melakukan ini, jalankan arahan:

curl http://localhost:8080/test

Hasilnya kelihatan seperti ini:

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

Pada ketika ini juga semak Redis. Anda akan melihat bahawa kunci access_count meningkat kepada 1:

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

Pastikan nilai metrik 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

Penciptaan Muatan

Kami akan menggunakan hey — utiliti untuk menjana beban:

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

Anda juga boleh memuat turun utiliti untuk Linux atau Windows.

Jalankan ia:

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

Secara lalai, utiliti menghantar 200 permintaan. Anda boleh mengesahkan ini 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

Sahkan nilai metrik sebenar (dikembalikan oleh pertanyaan 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 kes ini keputusan sebenar adalah 1,686057971014493 dan dipaparkan di lapangan value. Ini tidak mencukupi untuk penskalaan, kerana ambang yang kami tetapkan ialah 3.

Lebih banyak beban!

Dalam terminal baharu, pantau bilangan pod aplikasi:

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

Mari tambahkan beban menggunakan arahan:

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

Selepas beberapa ketika, anda akan melihat HPA menskalakan penggunaan dan melancarkan pod baharu. Semak 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 beban tidak konsisten, penggunaan akan dikurangkan ke tahap di mana hanya satu pod sedang berjalan. Jika anda ingin menyemak metrik sebenar (dikembalikan oleh pertanyaan PromQL), kemudian gunakan arahan:

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 membolehkan anda menskalakan penggunaan Kubernetes anda secara automatik (kepada/daripada sifar) berdasarkan data daripada metrik luaran. Contohnya, berdasarkan metrik Prometheus, panjang gilir dalam Redis, kependaman pengguna dalam topik Kafka.

KEDA berintegrasi dengan sumber luaran dan juga menyediakan metriknya melalui Pelayan Metrik kepada Autoscaler Pod Horizontal.

Semoga Berjaya!

Apa lagi yang perlu dibaca:

Sumber: www.habr.com

Autoscaling aplikasi Kubernetes menggunakan Prometheus dan KEDA