ធ្វើមាត្រដ្ឋានកម្មវិធី Kubernetes ដោយស្វ័យប្រវត្តិដោយប្រើ Prometheus និង KEDA

Balloon Man ដោយ Cimuanos

ការធ្វើមាត្រដ្ឋានគឺជាតម្រូវការសំខាន់សម្រាប់កម្មវិធីពពក។ ជាមួយ Kubernetes ការធ្វើមាត្រដ្ឋានកម្មវិធីគឺសាមញ្ញដូចជាការបង្កើនចំនួនចម្លងសម្រាប់ការដាក់ឱ្យប្រើប្រាស់សមស្រប ឬ ReplicaSet - ប៉ុន្តែវាជាដំណើរការដោយដៃ។

Kubernetes អនុញ្ញាតឱ្យកម្មវិធីត្រូវបានធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវត្តិ (ឧទាហរណ៍ Pods នៅក្នុងការដាក់ពង្រាយ ឬ ReplicaSet) ក្នុង​លក្ខណៈ​ប្រកាស​ដោយ​ប្រើ​ការ​បញ្ជាក់​របស់ Horizontal Pod Autoscaler។ លក្ខណៈវិនិច្ឆ័យលំនាំដើមសម្រាប់ការធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវត្តិគឺជារង្វាស់នៃការប្រើប្រាស់ស៊ីភីយូ (រង្វាស់ធនធាន) ប៉ុន្តែអ្នកអាចរួមបញ្ចូលរង្វាស់ផ្ទាល់ខ្លួន និងផ្នែកខាងក្រៅដែលបានផ្តល់ឱ្យ។

ក្រុមការងារ Kubernetes aaS ពី Mail.ru បានបកប្រែអត្ថបទមួយអំពីរបៀបប្រើរង្វាស់ខាងក្រៅដើម្បីធ្វើមាត្រដ្ឋានកម្មវិធី Kubernetes ដោយស្វ័យប្រវត្តិ។ ដើម្បីបង្ហាញពីរបៀបដែលអ្វីៗដំណើរការ អ្នកនិពន្ធប្រើរង្វាស់សំណើការចូលប្រើ HTTP ដែលត្រូវបានប្រមូលដោយប្រើ Prometheus ។

ជំនួសឱ្យការធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវតិ្តផ្តេក ការប្រើប្រាស់កម្មវិធី Kubernetes Event Driven Autoscaling (KEDA) ដែលជាប្រតិបត្តិករ Kubernetes ប្រភពបើកចំហ។ វារួមបញ្ចូលដើមកំណើតជាមួយ Horizontal Pod Autoscaler ដើម្បីផ្តល់នូវការធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវត្តិដោយគ្មានថ្នេរ (រួមទាំងទៅ/ពីសូន្យ) សម្រាប់បន្ទុកការងារដែលជំរុញដោយព្រឹត្តិការណ៍។ លេខកូដមាននៅ GitHub.

ទិដ្ឋភាពសង្ខេបនៃប្រព័ន្ធ

ដ្យាក្រាមបង្ហាញការពិពណ៌នាសង្ខេបអំពីរបៀបដែលអ្វីៗដំណើរការ៖

1. កម្មវិធីនេះផ្តល់នូវការរាប់ចំនួន HTTP ក្នុងទម្រង់ Prometheus ។
2. Prometheus ត្រូវបានកំណត់រចនាសម្ព័ន្ធដើម្បីប្រមូលម៉ែត្រទាំងនេះ។
3. ឧបករណ៍ធ្វើមាត្រដ្ឋាន Prometheus នៅក្នុង KEDA ត្រូវបានតំឡើងដើម្បីធ្វើមាត្រដ្ឋានកម្មវិធីដោយស្វ័យប្រវត្តិដោយផ្អែកលើចំនួន HTTP ។

ឥឡូវនេះខ្ញុំនឹងប្រាប់អ្នកឱ្យលម្អិតអំពីធាតុនីមួយៗ។

KEDA និង Prometheus

Prometheus គឺជាកម្មវិធីត្រួតពិនិត្យប្រព័ន្ធប្រភពបើកចំហរ និងប្រអប់ឧបករណ៍ជូនដំណឹងជាផ្នែក មូលនិធិកុំព្យូទ័រពពកកំណើត. ប្រមូលម៉ែត្រពីប្រភពផ្សេងៗ ហើយរក្សាទុកវាជាទិន្នន័យស៊េរីពេលវេលា។ ដើម្បីមើលឃើញទិន្នន័យអ្នកអាចប្រើ ហ្គ្រេណាណា ឬឧបករណ៍មើលឃើញផ្សេងទៀតដែលដំណើរការជាមួយ Kubernetes API ។

KEDA គាំទ្រគោលគំនិតនៃមាត្រដ្ឋាន - វាដើរតួជាស្ពានរវាង KEDA និងប្រព័ន្ធខាងក្រៅ។ ការអនុវត្តមាត្រដ្ឋានគឺជាក់លាក់ចំពោះប្រព័ន្ធគោលដៅនីមួយៗ ហើយទាញយកទិន្នន័យពីវា។ បន្ទាប់មក KEDA ប្រើពួកវាដើម្បីគ្រប់គ្រងការធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវត្តិ។

Scalers គាំទ្រប្រភពទិន្នន័យជាច្រើនឧទាហរណ៍ Kafka, Redis, Prometheus ។ នោះគឺ KEDA អាចត្រូវបានប្រើដើម្បីធ្វើមាត្រដ្ឋានការដាក់ពង្រាយ Kubernetes ដោយស្វ័យប្រវត្តិដោយប្រើរង្វាស់ Prometheus ជាលក្ខណៈវិនិច្ឆ័យ។

កម្មវិធីសាកល្បង

កម្មវិធីសាកល្បង 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 ផងដែរ។ តម្លៃម៉ែត្រត្រូវតែដូចគ្នាទៅនឹងតម្លៃ 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 ទទួលបានម៉ែត្រកម្មវិធី។

នៅទីនេះ ការបង្ហាញនៃការដាក់ពង្រាយសម្រាប់កម្មវិធី.

ម៉ាស៊ីនមេ Prometheus

ការបង្ហាញអំពីការដាក់ពង្រាយ Prometheus រួមមានៈ

• ConfigMap - ដើម្បីផ្ទេរការកំណត់រចនាសម្ព័ន្ធ Prometheus;
• Deployment - សម្រាប់ការដាក់ពង្រាយ Prometheus នៅក្នុងចង្កោម Kubernetes;
• ClusterIP - សេវាកម្មសម្រាប់ការចូលប្រើ UI Prometheus;
• ClusterRole, ClusterRoleBinding и ServiceAccount — សម្រាប់ការរកឃើញដោយស្វ័យប្រវត្តិនៃសេវាកម្មនៅក្នុង Kubernetes (ការរកឃើញដោយស្វ័យប្រវត្តិ)។

នៅទីនេះ ការបង្ហាញសម្រាប់ការដំណើរការ Prometheus.

វត្ថុ KEDA Prometheus ScaledObject

ឧបករណ៍វាស់ស្ទង់ដើរតួនាទីជាស្ពានរវាង KEDA និងប្រព័ន្ធខាងក្រៅ ដែលម៉ែត្រត្រូវការទទួលបាន។ ScaledObject គឺជាធនធានផ្ទាល់ខ្លួនដែលត្រូវការដាក់ពង្រាយដើម្បីធ្វើសមកាលកម្មការដាក់ពង្រាយជាមួយប្រភពព្រឹត្តិការណ៍ ក្នុងករណីនេះ Prometheus ។

ScaledObject មានព័ត៌មានអំពីការធ្វើមាត្រដ្ឋានដាក់ពង្រាយ ទិន្នន័យមេតាប្រភពព្រឹត្តិការណ៍ (ដូចជាការសម្ងាត់នៃការតភ្ជាប់ ឈ្មោះជួរ) ចន្លោះពេលបោះឆ្នោត រយៈពេលនៃការស្តារឡើងវិញ និងទិន្នន័យផ្សេងទៀត។ វាផ្តល់លទ្ធផលនៅក្នុងធនធាន 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. ប្រភេទកេះ - Prometheus. អាសយដ្ឋានម៉ាស៊ីនមេ Prometheus ត្រូវបានរៀបរាប់រួមជាមួយនឹងឈ្មោះម៉ែត្រ កម្រិត និង សំណួរ PromQLដែលនឹងត្រូវបានប្រើ។ សំណួរ PromQL - sum(rate(http_requests[2m])).
3. នេះបើយោងតាម pollingIntervalKEDA ស្នើសុំគោលដៅពី Prometheus រៀងរាល់ដប់ប្រាំវិនាទី។ យ៉ាងហោចណាស់មួយនៅក្រោម (minReplicaCount) ហើយចំនួនអតិបរមានៃ pods មិនលើសពី maxReplicaCount (ក្នុងឧទាហរណ៍នេះ - ដប់) ។

អាចត្រូវបានដំឡើង minReplicaCount ស្មើនឹងសូន្យ។ ក្នុងករណីនេះ KEDA ដំណើរការការដាក់ពង្រាយពីសូន្យទៅមួយ ហើយបន្ទាប់មកបង្ហាញ 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ប៉ុន្តែអ្នកអាចយកមួយផ្សេងទៀត។ ដើម្បីដំឡើងចង្កោមមាន ភាពជាអ្នកដឹកនាំ.

ដំឡើងកំណែចុងក្រោយបំផុតនៅលើ 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 ចាប់ផ្តើម ហើយចូលទៅកាន់ 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. វាអនុញ្ញាតឱ្យមានការរកឃើញថាមវន្តនៃកម្មវិធី pods ដោយផ្អែកលើស្លាកសេវាកម្ម។

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

ពាក្យបញ្ជាដើម្បីបង្កើត 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 ស្មើ ១៖

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 កើនឡើងដល់ ១៖

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

ត្រូវប្រាកដថាតម្លៃម៉ែត្រគឺ 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

ផ្ទុកការបង្កើត

យើងនឹងប្រើ អេ - ឧបករណ៍សម្រាប់បង្កើតបន្ទុក៖

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 ក៏ដូចជា 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 ។

ផ្ទុកកាន់តែច្រើន!

នៅក្នុងស្ថានីយថ្មី សូមតាមដានចំនួនកម្មវិធី pods៖

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

តោះបង្កើនបន្ទុកដោយប្រើពាក្យបញ្ជា៖

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

មួយសន្ទុះក្រោយមក អ្នកនឹងឃើញ HPA ធ្វើមាត្រដ្ឋានការដាក់ពង្រាយ និងបើកដំណើរការ pods ថ្មី។ ពិនិត្យ 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 របស់អ្នកដោយស្វ័យប្រវត្តិ (ទៅ/ពីសូន្យ) ដោយផ្អែកលើទិន្នន័យពីម៉ែត្រខាងក្រៅ។ ឧទាហរណ៍ ផ្អែកលើរង្វាស់ Prometheus ប្រវែងជួរក្នុង Redis ភាពយឺតយ៉ាវរបស់អ្នកប្រើប្រាស់នៅក្នុងប្រធានបទ Kafka។

KEDA រួមបញ្ចូលជាមួយប្រភពខាងក្រៅ ហើយថែមទាំងផ្តល់នូវរង្វាស់របស់វាតាមរយៈ Metrics Server ទៅកាន់ Horizontal Pod Autoscaler។

សូមសំណាងល្អ!

តើមានអ្វីទៀតដែលត្រូវអាន៖

1. ការអនុវត្តល្អបំផុត និងការអនុវត្តល្អបំផុតសម្រាប់ការដំណើរការកុងតឺន័រ និង Kubernetes នៅក្នុងបរិយាកាសផលិតកម្ម.
2. ឧបករណ៍មានប្រយោជន៍ 90+ សម្រាប់ Kubernetes៖ ការដាក់ពង្រាយ ការគ្រប់គ្រង ការត្រួតពិនិត្យ សុវត្ថិភាព និងច្រើនទៀត.
3. ប៉ុស្តិ៍របស់យើងនៅជុំវិញ Kubernetes នៅក្នុង Telegram.

ប្រភព: www.habr.com