Autoscaling Kubernetes applications ໂດຍໃຊ້ Prometheus ແລະ KEDA

Balloon Man ໂດຍ Cimuanos

ຄວາມສາມາດຂະຫຍາຍໄດ້ແມ່ນຄວາມຕ້ອງການຫຼັກສໍາລັບແອັບພລິເຄຊັນຄລາວ. ດ້ວຍ Kubernetes, ການຂະຫຍາຍແອັບພລິເຄຊັນແມ່ນງ່າຍດາຍເທົ່າກັບການເພີ່ມຈໍານວນການຈໍາລອງສໍາລັບການນໍາໃຊ້ທີ່ເຫມາະສົມຫຼື ReplicaSet — ແຕ່​ວ່າ​ມັນ​ເປັນ​ຂະ​ບວນ​ການ​ຄູ່​ມື​.

Kubernetes ອະນຸຍາດໃຫ້ແອັບພລິເຄຊັນຖືກປັບຂະໜາດອັດຕະໂນມັດ (ເຊັ່ນ: Pods ໃນການນຳໃຊ້ ຫຼື ReplicaSet) ໃນລັກສະນະການປະກາດໂດຍໃຊ້ສະເພາະ Horizontal Pod Autoscaler. ມາດຕະຖານມາດຕະຖານສໍາລັບການປັບຂະຫນາດອັດຕະໂນມັດແມ່ນ metrics ການນໍາໃຊ້ CPU (metrics ຊັບພະຍາກອນ), ແຕ່ທ່ານສາມາດປະສົມປະສານ metrics ກໍານົດເອງແລະພາຍນອກສະຫນອງໃຫ້.

ທີມງານ Kubernetes aaS ຈາກ Mail.ru ແປບົດຄວາມກ່ຽວກັບວິທີໃຊ້ຕົວວັດແທກພາຍນອກເພື່ອປັບຂະໜາດແອັບພລິເຄຊັນ Kubernetes ໂດຍອັດຕະໂນມັດ. ເພື່ອສະແດງໃຫ້ເຫັນວ່າທຸກສິ່ງທຸກຢ່າງເຮັດວຽກແນວໃດ, ຜູ້ຂຽນໃຊ້ຕົວຊີ້ບອກການຮ້ອງຂໍການເຂົ້າເຖິງ HTTP, ເຊິ່ງຖືກລວບລວມໂດຍໃຊ້ Prometheus.

ແທນການປັບຂະໜາດອັດຕະໂນມັດຕາມແນວນອນຂອງຝັກ, Kubernetes Event Driven Autoscaling (KEDA) ຖືກນໍາໃຊ້, ເປັນແຫຼ່ງເປີດ Kubernetes operator. ມັນປະສົມປະສານແບບດັ້ງເດີມກັບ Horizontal Pod Autoscaler ເພື່ອສະໜອງການປັບຂະໜາດອັດຕະໂນມັດແບບບໍ່ມີຮອຍຕໍ່ (ລວມທັງຫາ/ຈາກສູນ) ສໍາລັບວຽກທີ່ຂັບເຄື່ອນໂດຍເຫດການ. ລະຫັດມີຢູ່ GitHub.

ພາບລວມໂດຍຫຍໍ້ຂອງລະບົບ

ແຜນວາດສະແດງລາຍລະອຽດສັ້ນໆກ່ຽວກັບວິທີເຮັດວຽກທຸກຢ່າງ:

1. ແອັບພລິເຄຊັນໃຫ້ HTTP hit count metrics ໃນຮູບແບບ Prometheus.
2. Prometheus ໄດ້ຖືກຕັ້ງຄ່າເພື່ອເກັບກໍາການວັດແທກເຫຼົ່ານີ້.
3. Prometheus scaler ໃນ KEDA ຖືກຕັ້ງຄ່າເພື່ອປັບຂະຫນາດຄໍາຮ້ອງສະຫມັກໂດຍອັດຕະໂນມັດໂດຍອີງໃສ່ຈໍານວນ HTTP hits.

ໃນປັດຈຸບັນຂ້າພະເຈົ້າຈະບອກທ່ານຢ່າງລະອຽດກ່ຽວກັບແຕ່ລະອົງປະກອບ.

KEDA ແລະ Prometheus

Prometheus ແມ່ນຊຸດເຄື່ອງມືການຕິດຕາມ ແລະແຈ້ງເຕືອນລະບົບແຫຼ່ງເປີດ, ສ່ວນໜຶ່ງ ມູນນິທິຄອມພິວເຕີ້ Cloud Native. ລວບລວມການວັດແທກຈາກແຫຼ່ງຕ່າງໆແລະເກັບຮັກສາພວກມັນເປັນຂໍ້ມູນຊຸດເວລາ. ເພື່ອສະແດງຂໍ້ມູນໃຫ້ເຫັນ, ທ່ານສາມາດນໍາໃຊ້ ກຣາຟານາ ຫຼືເຄື່ອງມືການເບິ່ງເຫັນອື່ນໆທີ່ເຮັດວຽກກັບ Kubernetes API.

KEDA ສະຫນັບສະຫນູນແນວຄວາມຄິດຂອງ scaler - ມັນເຮັດຫນ້າທີ່ເປັນຂົວລະຫວ່າງ KEDA ແລະລະບົບພາຍນອກ. ການປະຕິບັດ scaler ແມ່ນສະເພາະກັບແຕ່ລະລະບົບເປົ້າຫມາຍແລະສະກັດຂໍ້ມູນຈາກມັນ. KEDA ຫຼັງຈາກນັ້ນໃຊ້ພວກມັນເພື່ອຄວບຄຸມການປັບຂະຫນາດອັດຕະໂນມັດ.

Scalers ສະຫນັບສະຫນູນແຫຼ່ງຂໍ້ມູນຫຼາຍ, ສໍາລັບການຍົກຕົວຢ່າງ, Kafka, Redis, Prometheus. ນັ້ນແມ່ນ, KEDA ສາມາດໃຊ້ເພື່ອປັບຂະ ໜາດ ການຕິດຕັ້ງ Kubernetes ໂດຍອັດຕະໂນມັດໂດຍໃຊ້ Prometheus metrics ເປັນເງື່ອນໄຂ.

ຄໍາຮ້ອງສະຫມັກການທົດສອບ

ຄໍາຮ້ອງສະຫມັກການທົດສອບ Golang ສະຫນອງການເຂົ້າເຖິງຜ່ານ HTTP ແລະປະຕິບັດສອງຫນ້າທີ່ສໍາຄັນ:

1. ໃຊ້ຫ້ອງສະໝຸດລູກຄ້າ Prometheus Go ເພື່ອເປັນເຄື່ອງມືຂອງແອັບພລິເຄຊັນ ແລະສະໜອງການວັດແທກ http_requests, ເຊິ່ງປະກອບດ້ວຍການນັບຕີ. ຈຸດສິ້ນສຸດບ່ອນທີ່ຕົວວັດແທກ Prometheus ມີຢູ່ແມ່ນຢູ່ທີ່ URI /metrics.

   var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
          Name: "http_requests",
          Help: "number of http requests",
      })
   

2. ໃນ​ການ​ຕອບ​ສະ​ຫນອງ​ການ​ຮ້ອງ​ຂໍ​ GET ແອັບພລິເຄຊັນເພີ່ມມູນຄ່າຂອງລະຫັດ (access_count) ໃນ Redis. ນີ້ແມ່ນວິທີທີ່ງ່າຍທີ່ຈະເຮັດວຽກເປັນສ່ວນຫນຶ່ງຂອງຕົວຈັດການ HTTP ແລະຍັງກວດເບິ່ງ Prometheus metrics. ຄ່າເມຕຣິກຕ້ອງເທົ່າກັບຄ່າ access_count ໃນ 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)
      }
   

ແອັບພລິເຄຊັນຖືກນຳໃຊ້ກັບ Kubernetes ຜ່ານ Deployment. ການບໍລິການຍັງຖືກສ້າງຂື້ນ ClusterIP, ມັນອະນຸຍາດໃຫ້ເຄື່ອງແມ່ຂ່າຍຂອງ Prometheus ໄດ້ຮັບການວັດແທກຄໍາຮ້ອງສະຫມັກ.

ທີ່ນີ້ ການປະຕິບັດ manifest ສໍາລັບຄໍາຮ້ອງສະຫມັກ.

ເຊີບເວີ Prometheus

ການສະແດງອອກຂອງການປະຕິບັດ Prometheus ປະກອບດ້ວຍ:

• ConfigMap - ການ​ໂອນ​ການ​ຕັ້ງ​ຄ່າ Prometheus​;
• Deployment — ສໍາລັບການນໍາໃຊ້ Prometheus ໃນກຸ່ມ Kubernetes;
• ClusterIP — ການ​ບໍ​ລິ​ການ​ສໍາ​ລັບ​ການ​ເຂົ້າ​ເຖິງ UI Prometheus​;
• ClusterRole, ClusterRoleBinding и ServiceAccount — ສໍາ​ລັບ​ການ​ກວດ​ສອບ​ອັດ​ຕະ​ໂນ​ມັດ​ຂອງ​ການ​ບໍ​ລິ​ການ​ໃນ Kubernetes (ການ​ຄົ້ນ​ພົບ​ອັດ​ຕະ​ໂນ​ມັດ​)​.

ທີ່ນີ້ manifest ສໍາລັບແລ່ນ Prometheus.

KEDA Prometheus ScaledObject

ເຄື່ອງວັດແທກຂະຫນາດເຮັດຫນ້າທີ່ເປັນຂົວລະຫວ່າງ KEDA ແລະລະບົບພາຍນອກທີ່ຕ້ອງໄດ້ຮັບ metrics. ScaledObject ເປັນຊັບພະຍາກອນທີ່ກໍາຫນົດເອງທີ່ຕ້ອງໄດ້ຮັບການປະຕິບັດເພື່ອ synchronize ການຕິດຕັ້ງກັບແຫຼ່ງເຫດການ, ໃນກໍລະນີນີ້ Prometheus.

ScaledObject ປະກອບມີຂໍ້ມູນການປັບຂະໜາດການນຳໃຊ້, metadata ແຫຼ່ງເຫດການ (ເຊັ່ນ: ຄວາມລັບຂອງການເຊື່ອມຕໍ່, ຊື່ແຖວ), ໄລຍະການສຳຫຼວດ, ໄລຍະເວລາການກູ້ຂໍ້ມູນ ແລະຂໍ້ມູນອື່ນໆ. ມັນສົ່ງຜົນໃຫ້ຊັບພະຍາກອນ autoscaling ທີ່ສອດຄ້ອງກັນ (HPA ຄໍານິຍາມ) ເພື່ອປັບຂະຫນາດການໃຊ້ງານ.

ເມື່ອວັດຖຸ ScaledObject ຖືກລຶບ, ຄໍານິຍາມ HPA ທີ່ສອດຄ້ອງກັນຖືກລຶບລ້າງ.

ນີ້ແມ່ນຄໍານິຍາມ ScaledObject ຕົວຢ່າງຂອງພວກເຮົາ, ມັນໃຊ້ເຄື່ອງປັບຂະຫນາດ 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]))

ພິຈາລະນາຈຸດຕໍ່ໄປນີ້:

1. ລາວຊີ້ໃຫ້ເຫັນ Deployment ດ້ວຍ​ຊື່ go-prom-app.
2. ປະ​ເພດ Trigger - Prometheus. ທີ່ຢູ່ເຊີບເວີ Prometheus ໄດ້ຖືກກ່າວເຖິງພ້ອມກັບຊື່ metric, ເກນແລະ ສອບຖາມ PromQL, ເຊິ່ງຈະຖືກນໍາໃຊ້. PromQL Query - sum(rate(http_requests[2m])).
3. ອີງຕາມການ pollingInterval,KEDA ຮ້ອງຂໍເປົ້າຫມາຍຈາກ Prometheus ທຸກໆສິບຫ້າວິນາທີ. ຢ່າງຫນ້ອຍຫນຶ່ງພາຍໃຕ້ (minReplicaCount), ແລະຈໍານວນສູງສຸດຂອງຝັກບໍ່ເກີນ maxReplicaCount (ໃນຕົວຢ່າງນີ້ - ສິບ).

ສາມາດຕິດຕັ້ງໄດ້ minReplicaCount ເທົ່າກັບສູນ. ໃນ​ກໍ​ລະ​ນີ​ນີ້, KEDA activates ການ​ນໍາ​ໃຊ້ zero-to-one ແລະ​ຫຼັງ​ຈາກ​ນັ້ນ exposes HPA ສໍາ​ລັບ​ການ​ປັບ​ຂະ​ຫນາດ​ອັດ​ຕະ​ໂນ​ມັດ​ເພີ່ມ​ເຕີມ. ຄໍາສັ່ງປີ້ນກັບກັນກໍ່ເປັນໄປໄດ້, ນັ້ນແມ່ນ, ຂະຫນາດຈາກຫນຶ່ງຫາສູນ. ໃນຕົວຢ່າງ, ພວກເຮົາບໍ່ໄດ້ເລືອກສູນເພາະວ່ານີ້ແມ່ນການບໍລິການ HTTP ແລະບໍ່ແມ່ນລະບົບຕາມຄວາມຕ້ອງການ.

ຄວາມມະຫັດສະຈັນພາຍໃນ autoscaling

ເກນຖືກໃຊ້ເປັນຕົວກະຕຸ້ນເພື່ອປັບຂະໜາດການນຳໃຊ້. ໃນຕົວຢ່າງຂອງພວກເຮົາ, ຄໍາຖາມ PromQL sum(rate (http_requests [2m])) ສົ່ງຄືນອັດຕາການຮ້ອງຂໍ HTTP ລວມ (ຄໍາຮ້ອງຂໍຕໍ່ວິນາທີ), ວັດແທກໃນໄລຍະສອງນາທີທີ່ຜ່ານມາ.

ເນື່ອງຈາກຄ່າເກນແມ່ນສາມ, ມັນຫມາຍຄວາມວ່າຈະມີຫນຶ່ງພາຍໃຕ້ໃນຂະນະທີ່ມູນຄ່າ sum(rate (http_requests [2m])) ຫນ້ອຍກວ່າສາມ. ຖ້າມູນຄ່າເພີ່ມຂຶ້ນ, ຍ່ອຍເພີ່ມເຕີມຈະຖືກເພີ່ມໃນແຕ່ລະຄັ້ງ sum(rate (http_requests [2m])) ເພີ່ມ​ຂຶ້ນ​ສາມ​. ຕົວຢ່າງ, ຖ້າຄ່າແມ່ນຈາກ 12 ຫາ 14, ຫຼັງຈາກນັ້ນຈໍານວນຂອງຝັກແມ່ນສີ່.

ຕອນນີ້ໃຫ້ລອງຕັ້ງຄ່າມັນເບິ່ງ!

ການຕັ້ງຄ່າລ່ວງໜ້າ

ທັງ​ຫມົດ​ທີ່​ທ່ານ​ຕ້ອງ​ການ​ແມ່ນ​ກຸ່ມ Kubernetes ແລະ​ອຸ​ປະ​ກອນ​ທີ່​ກໍາ​ນົດ​ຄ່າ kubectl. ຕົວຢ່າງນີ້ໃຊ້ກຸ່ມ minikube, ແຕ່ເຈົ້າສາມາດເອົາອັນອື່ນໄດ້. ການຕິດຕັ້ງ cluster ມີ ຄູ່ມື.

ຕິດຕັ້ງເວີຊັນຫຼ້າສຸດໃນ 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/

ຕັ້ງ kubectlເພື່ອເຂົ້າເຖິງກຸ່ມ Kubernetes.

ຕິດຕັ້ງເວີຊັນຫຼ້າສຸດໃນ 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

ການຕິດຕັ້ງ KEDA

ທ່ານ​ສາ​ມາດ​ນໍາ​ໃຊ້ KEDA ໃນ​ຫຼາຍ​ວິ​ທີ​ການ​, ພວກ​ເຂົາ​ເຈົ້າ​ໄດ້​ລະ​ບຸ​ໄວ້​ໃນ​ ເອກະສານ. ຂ້ອຍກໍາລັງໃຊ້ YAML monolithic:

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

KEDA ແລະອົງປະກອບຂອງມັນຖືກຕິດຕັ້ງເຂົ້າໄປໃນ namespace keda. ຄໍາ​ສັ່ງ​ທີ່​ຈະ​ກວດ​ສອບ​:

kubectl get pods -n keda

ລໍຖ້າໃຫ້ KEDA Operator ເລີ່ມຕົ້ນ ແລະໄປທີ່ Running State. ແລະຫຼັງຈາກນັ້ນ, ສືບຕໍ່.

ການຕິດຕັ້ງ Redis ໂດຍໃຊ້ Helm

ຖ້າທ່ານບໍ່ໄດ້ຕິດຕັ້ງ Helm, ໃຫ້ໃຊ້ອັນນີ້ ຄວາມເປັນຜູ້ນໍາ. ຄໍາ​ສັ່ງ​ທີ່​ຈະ​ຕິດ​ຕັ້ງ​ໃນ Mac​:

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

helm init ເລີ່ມຕົ້ນການໂຕ້ຕອບເສັ້ນຄໍາສັ່ງໃນທ້ອງຖິ່ນແລະຍັງຕິດຕັ້ງ Tiller ໄປຫາກຸ່ມ Kubernetes.

kubectl get pods -n kube-system | grep tiller

ລໍຖ້າໃຫ້ Tiller pod ເຂົ້າສູ່ສະຖານະແລ່ນ.

ບັນທຶກຂອງນັກແປ: ຜູ້ຂຽນໃຊ້ Helm@2, ເຊິ່ງຕ້ອງການອົງປະກອບເຊີບເວີ Tiller ທີ່ຈະຕິດຕັ້ງ. ໃນປັດຈຸບັນ Helm@3 ມີຄວາມກ່ຽວຂ້ອງ, ມັນບໍ່ໄດ້ຮຽກຮ້ອງໃຫ້ມີສ່ວນຂອງເຄື່ອງແມ່ຂ່າຍ.

ຫຼັງຈາກການຕິດຕັ້ງ Helm, ຄໍາສັ່ງຫນຶ່ງແມ່ນພຽງພໍທີ່ຈະເລີ່ມຕົ້ນ Redis:

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

ກວດ​ສອບ​ວ່າ Redis ໄດ້​ເລີ່ມ​ຕົ້ນ​ສໍາ​ເລັດ​ຜົນ​:

kubectl get pods/redis-server-master-0

ລໍຖ້າ Redis ເຂົ້າໄປໃນສະຖານະ Running.

ການນຳໃຊ້ແອັບພລິເຄຊັນ

ຄໍາ​ສັ່ງ​ການ​ນໍາ​ໃຊ້​:

kubectl apply -f go-app.yaml

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

ກວດເບິ່ງວ່າທຸກຢ່າງໄດ້ເລີ່ມຕົ້ນແລ້ວ:

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

ລໍຖ້າ Redis ເຂົ້າສູ່ສະຖານະ Running.

ນຳໃຊ້ເຊີບເວີ Prometheus

Prometheus manifest ໃຊ້ ການຄົ້ນພົບບໍລິການ Kubernetes ສໍາລັບ Prometheus. ມັນອະນຸຍາດໃຫ້ຄົ້ນພົບແບບເຄື່ອນໄຫວຂອງຝັກແອັບພລິເຄຊັນໂດຍອີງໃສ່ປ້າຍບໍລິການ.

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

ເພື່ອນຳໃຊ້:

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

ກວດເບິ່ງວ່າທຸກຢ່າງໄດ້ເລີ່ມຕົ້ນແລ້ວ:

kubectl get pods -l=app=prometheus-server

ລໍຖ້າ Prometheus ເຂົ້າໄປໃນລັດ Running.

ໃຊ້ kubectl port-forward ເພື່ອເຂົ້າເຖິງສ່ວນຕິດຕໍ່ຜູ້ໃຊ້ Prometheus (ຫຼືເຄື່ອງແມ່ຂ່າຍ API) ຢູ່ http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

ນຳໃຊ້ KEDA Autoscaling Configuration

ຄໍາສັ່ງທີ່ຈະສ້າງ ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

ກວດເບິ່ງບັນທຶກຜູ້ປະຕິບັດງານ KEDA:

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

ຜົນໄດ້ຮັບເບິ່ງຄືວ່ານີ້:

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"

ກວດເບິ່ງພາຍໃຕ້ຄໍາຮ້ອງສະຫມັກ. ຕົວຢ່າງຫນຶ່ງຕ້ອງຖືກແລ່ນເພາະວ່າ minReplicaCount ເທົ່າກັບ 1:

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

ກວດສອບວ່າຊັບພະຍາກອນ HPA ຖືກສ້າງຂຶ້ນຢ່າງສໍາເລັດຜົນ:

kubectl get hpa

ທ່ານຄວນເບິ່ງບາງສິ່ງບາງຢ່າງເຊັ່ນ:

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

ກວດສຸຂະພາບ: ເຂົ້າເຖິງແອັບພລິເຄຊັນ

ເພື່ອເຂົ້າເຖິງຈຸດສິ້ນສຸດ REST ຂອງແອັບພລິເຄຊັນຂອງພວກເຮົາ, ໃຫ້ແລ່ນ:

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

ດຽວນີ້ເຈົ້າສາມາດເຂົ້າເຖິງແອັບ Go ຂອງທ່ານໄດ້ໂດຍໃຊ້ທີ່ຢູ່ http://localhost:8080. ເພື່ອເຮັດສິ່ງນີ້, ດໍາເນີນການຄໍາສັ່ງ:

curl http://localhost:8080/test

ຜົນໄດ້ຮັບເບິ່ງຄືວ່ານີ້:

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

ໃນຈຸດນີ້ຍັງກວດເບິ່ງ Redis. ເຈົ້າຈະເຫັນວ່າສໍາຄັນ access_count ເພີ່ມ​ຂຶ້ນ​ເປັນ 1​:

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

ໃຫ້ແນ່ໃຈວ່າຄ່າ metric ແມ່ນ http_requests ຄື​ກັນ:

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

ໂຫຼດການສ້າງ

ພວກເຮົາຈະນໍາໃຊ້ hey - ຜົນ​ປະ​ໂຫຍດ​ສໍາ​ລັບ​ການ​ສ້າງ​ການ​ໂຫຼດ​:

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

ນອກນັ້ນທ່ານຍັງສາມາດດາວນ໌ໂຫລດຜົນປະໂຫຍດສໍາລັບ Linux ຫຼື Windows.

ແລ່ນມັນ:

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

ໂດຍຄ່າເລີ່ມຕົ້ນ, ຜົນປະໂຫຍດສົ່ງ 200 ຄໍາຮ້ອງຂໍ. ທ່ານສາມາດກວດສອບນີ້ໂດຍໃຊ້ Prometheus metrics ເຊັ່ນດຽວກັນກັບ 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

ກວດສອບມູນຄ່າຂອງຕົວວັດແທກຕົວຈິງ (ສົ່ງຄືນໂດຍການສອບຖາມ 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"]}]}}

ໃນກໍລະນີດັ່ງກ່າວນີ້, ຜົນໄດ້ຮັບທີ່ແທ້ຈິງ 1,686057971014493 ແລະຖືກສະແດງຢູ່ໃນພາກສະຫນາມ value. ອັນນີ້ບໍ່ພຽງພໍສຳລັບການປັບຂະໜາດ, ເນື່ອງຈາກເກນທີ່ພວກເຮົາກຳນົດໄວ້ແມ່ນ 3.

ໂຫຼດເພີ່ມເຕີມ!

ໃນ terminal ໃຫມ່, ຕິດຕາມກວດກາຈໍານວນຂອງ pods ຄໍາຮ້ອງສະຫມັກ:

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

ໃຫ້ເພີ່ມການໂຫຼດໂດຍໃຊ້ຄໍາສັ່ງ:

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

ຫຼັງຈາກນັ້ນບໍ່ດົນ, ທ່ານຈະເຫັນ HPA ຂະຫຍາຍການໃຊ້ງານ ແລະເປີດຕົວຝັກໃຫມ່. ກວດເບິ່ງ HPA ຂອງທ່ານເພື່ອໃຫ້ແນ່ໃຈວ່າ:

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

ຖ້າການໂຫຼດບໍ່ສອດຄ່ອງ, ການຕິດຕັ້ງຈະຫຼຸດລົງເຖິງຈຸດທີ່ມີພຽງແຕ່ຫນຶ່ງຝັກກໍາລັງແລ່ນ. ຖ້າທ່ານຕ້ອງການກວດສອບການວັດແທກຕົວຈິງ (ສົ່ງຄືນໂດຍການສອບຖາມ PromQL), ຫຼັງຈາກນັ້ນໃຫ້ໃຊ້ຄໍາສັ່ງ:

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

ສະຫລຸບ

KEDA ອະ​ນຸ​ຍາດ​ໃຫ້​ທ່ານ​ເພື່ອ​ປັບ​ຂະ​ຫນາດ​ການ​ນໍາ​ໃຊ້ Kubernetes ຂອງ​ທ່ານ​ອັດ​ຕະ​ໂນ​ມັດ (ເປັນ / ຈາກ​ສູນ​) ໂດຍ​ອີງ​ໃສ່​ຂໍ້​ມູນ​ຈາກ​ການ​ວັດ​ແທກ​ພາຍ​ນອກ​. ຕົວຢ່າງ, ອີງໃສ່ metrics Prometheus, ຄວາມຍາວແຖວໃນ Redis, ຄວາມຊັກຊ້າຂອງຜູ້ບໍລິໂພກໃນຫົວຂໍ້ Kafka.

KEDA ປະສົມປະສານກັບແຫຼ່ງພາຍນອກແລະຍັງສະຫນອງ metrics ຂອງມັນໂດຍຜ່ານ Metrics Server ກັບ Horizontal Pod Autoscaler.

ໂຊກດີ!

ມີຫຍັງອີກແດ່ທີ່ຈະອ່ານ:

1. ການປະຕິບັດທີ່ດີທີ່ສຸດແລະການປະຕິບັດທີ່ດີທີ່ສຸດສໍາລັບການແລ່ນຕູ້ຄອນເທນເນີແລະ Kubernetes ໃນສະພາບແວດລ້ອມການຜະລິດ.
2. 90+ ເຄື່ອງມືທີ່ເປັນປະໂຫຍດສໍາລັບ Kubernetes: ການນຳໃຊ້, ການຈັດການ, ການຕິດຕາມ, ຄວາມປອດໄພ ແລະອື່ນໆອີກ.
3. ຊ່ອງຂອງພວກເຮົາປະມານ Kubernetes ໃນ Telegram.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com