Prometheus နှင့် KEDA ဖြင့် Kubernetes အပလီကေးရှင်းများကို အလိုအလျောက် ချိန်ညှိခြင်း။

Cimuanos မှ Balloon Man

Scalability သည် cloud အပလီကေးရှင်းများအတွက် အဓိကလိုအပ်ချက်တစ်ခုဖြစ်သည်။ Kubernetes ဖြင့်၊ အပလီကေးရှင်းတစ်ခုအား ချဲ့ထွင်ခြင်းသည် သင့်လျော်သောအသုံးချမှုအတွက် သို့မဟုတ် ပုံတူပွားအရေအတွက်ကို တိုးမြှင့်ခြင်းကဲ့သို့ ရိုးရှင်းပါသည်။ ReplicaSet - ဒါပေမယ့် ဒါဟာ manual process ဖြစ်ပါတယ်။

Kubernetes သည် အပလီကေးရှင်းများကို အလိုအလျောက် စကေးချရန် ခွင့်ပြုသည် (ဆိုလိုသည်မှာ ဖြန့်ကျက်မှုတစ်ခုတွင် Pods သို့မဟုတ် ReplicaSet) Horizontal Pod Autoscaler သတ်မှတ်ချက်ကို အသုံးပြု၍ ကြေငြာသည့်ပုံစံ။ အလိုအလျောက် အတိုင်းအတာအတွက် မူရင်းစံသတ်မှတ်ချက်မှာ CPU အသုံးပြုမှု မက်ထရစ်များ (အရင်းအမြစ် မက်ထရစ်များ) ဖြစ်သော်လည်း စိတ်ကြိုက်နှင့် ပြင်ပမှ ပေးထားသည့် မက်ထရစ်များကို ပေါင်းစပ်နိုင်သည်။

အဖွဲ့ Mail.ru မှ Kubernetes aaS Kubernetes အပလီကေးရှင်းကို အလိုအလျောက် အတိုင်းအတာတစ်ခုအထိ ပြင်ပတိုင်းတာမှုများကို အသုံးပြုနည်းအကြောင်း ဆောင်းပါးတစ်ပုဒ်ကို ဘာသာပြန်ထားသည်။ အရာအားလုံးမည်သို့အလုပ်လုပ်သည်ကိုပြသရန် စာရေးသူသည် Prometheus ကိုအသုံးပြု၍စုဆောင်းထားသော HTTP ဝင်ရောက်ခွင့်တောင်းဆိုမှုမက်ထရစ်များကိုအသုံးပြုသည်။

pods များကို အလျားလိုက် အလိုအလျောက် အရွယ်အစား ချဲ့ခြင်းအစား Kubernetes Event Driven Autoscaling (KEDA) ကို အသုံးပြုပြီး open source Kubernetes အော်ပရေတာ တစ်ခု ဖြစ်သည်။ ၎င်းသည် အဖြစ်အပျက်-မောင်းနှင်သော အလုပ်တာဝန်များအတွက် ချောမွေ့မှုမရှိသော အော်တိုစကေးချိန်ညှိခြင်း (သုညမှ သုညအထိ) ပံ့ပိုးပေးရန်အတွက် ၎င်းသည် မူရင်းအတိုင်း ပေါင်းစပ်ထားသည်။ ကုဒ်မှာ ရနိုင်ပါတယ်။ GitHub.

စနစ်၏အကျဉ်းချုပ်

ပုံကြမ်းတွင် အရာအားလုံးအလုပ်လုပ်ပုံအကြောင်း အတိုချုံးဖော်ပြချက်ကို ပြသည်-

1. အပလီကေးရှင်းသည် Prometheus ဖော်မတ်တွင် HTTP hit count မက်ထရစ်များကို ပံ့ပိုးပေးသည်။
2. Prometheus သည် ဤမက်ထရစ်များကို စုဆောင်းရန် ပြင်ဆင်ထားသည်။
3. KEDA ရှိ Prometheus scaler ကို HTTP hits အရေအတွက်ပေါ်မူတည်၍ အပလီကေးရှင်းကို အလိုအလျောက် ချိန်ညှိရန် စီစဉ်ထားပါသည်။

အခု ငါ မင်းကို အစိတ်အပိုင်းတစ်ခုစီအကြောင်း အသေးစိတ်ပြောပြမယ်။

KEDA နှင့် Prometheus

Prometheus သည် ပွင့်လင်းသော ရင်းမြစ် စနစ် စောင့်ကြည့်ခြင်းနှင့် သတိပေးခြင်း ကိရိယာ အစိတ်အပိုင်း၊ Cloud Native ကွန်ပျူတာဖောင်ဒေးရှင်း. အရင်းအမြစ်အမျိုးမျိုးမှ မက်ထရစ်များကို စုဆောင်းပြီး ၎င်းတို့ကို အချိန်စီးရီးဒေတာအဖြစ် သိမ်းဆည်းပါ။ ဒေတာကို မြင်ယောင်ရန် သင်သုံးနိုင်သည်။ Grafana သို့မဟုတ် Kubernetes API နှင့်အလုပ်လုပ်သော အခြားမြင်ယောင်ပုံဖော်ရေးကိရိယာများ။

KEDA သည် စကေးစက်တစ်ခု၏ သဘောတရားကို ပံ့ပိုးပေးသည် - ၎င်းသည် KEDA နှင့် ပြင်ပစနစ်ကြားတွင် တံတားတစ်ခုအဖြစ် လုပ်ဆောင်သည်။ အတိုင်းအတာ အကောင်အထည်ဖော်မှုသည် ပစ်မှတ်စနစ်တစ်ခုစီအတွက် သီးသန့်ဖြစ်ပြီး ၎င်းမှဒေတာကို ထုတ်ယူသည်။ ထို့နောက် KEDA သည် ၎င်းတို့ကို အလိုအလျောက် အတိုင်းအတာကို ထိန်းချုပ်ရန် ၎င်းတို့ကို အသုံးပြုသည်။

Scalers သည် ဒေတာရင်းမြစ်များစွာကို ပံ့ပိုးပေးသည်၊ ဥပမာ၊ Kafka၊ Redis၊ Prometheus။ ဆိုလိုသည်မှာ၊ Prometheus မက်ထရစ်များကို စံနှုန်းအဖြစ် အသုံးပြု၍ Kubernetes ဖြန့်ကျက်မှုများကို အလိုအလျောက် တိုင်းတာရန် KEDA ကို အသုံးပြုနိုင်သည်။

စမ်းသပ်လျှောက်လွှာ

Golang စမ်းသပ်ခြင်းအပလီကေးရှင်းသည် HTTP မှတစ်ဆင့်ဝင်ရောက်ခွင့်ပေးပြီး အရေးကြီးသောလုပ်ဆောင်ချက်နှစ်ခုကို လုပ်ဆောင်သည်-

1. အပလီကေးရှင်းကို ကိရိယာတန်ဆာပလာနှင့် hit အရေအတွက်ပါရှိသော http_requests မက်ထရစ်ကို ပံ့ပိုးရန် Prometheus Go သုံးစွဲသူ စာကြည့်တိုက်ကို အသုံးပြုသည်။ Prometheus မက်ထရစ်များရရှိနိုင်သည့်အဆုံးမှတ်သည် URI တွင်တည်ရှိသည်။ /metrics.

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

2. တောင်းဆိုချက်ကို တုံ့ပြန်သည်။ GET အပလီကေးရှင်းသည် သော့၏တန်ဖိုးကို တိုးစေသည် (access_countRedis တွင်) ၎င်းသည် 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 config ကိုလွှဲပြောင်းရန်;
• Deployment - Kubernetes အစုအဝေးတွင် Prometheus ကို အသုံးပြုရန်အတွက်၊
• ClusterIP - UI Prometheus သို့ဝင်ရောက်ခွင့်အတွက် ဝန်ဆောင်မှု။
• ClusterRole, ClusterRoleBinding и ServiceAccount Kubernetes (အလိုအလျောက်ရှာဖွေတွေ့ရှိမှု) တွင် ဝန်ဆောင်မှုများကို အလိုအလျောက်ရှာဖွေခြင်းအတွက်။

ဒီမှာ Prometheus လည်ပတ်မှုအတွက် ထင်ရှားသည်။.

KEDA Prometheus ScaledObject

စကေးကိရိယာသည် KEDA နှင့် ပြင်ပစနစ်ကြားတွင် ပေါင်းကူးအဖြစ် လုပ်ဆောင်သည်။ ScaledObject ဤကိစ္စတွင် Prometheus သည် အစီအစဉ်အရင်းအမြစ်နှင့် ဖြန့်ကျက်မှုကို တပြိုင်တည်းလုပ်ဆောင်ရန် စိတ်ကြိုက်ရင်းမြစ်တစ်ခုဖြစ်သည်။

ScaledObject ဖြန့်ကျက်ချဲ့ထွင်ခြင်းဆိုင်ရာ အချက်အလက်၊ ဖြစ်ရပ်အရင်းအမြစ် မက်တာဒေတာ (ဥပမာ ချိတ်ဆက်မှုလျှို့ဝှက်ချက်များ၊ တန်းစီအမည်)၊ မဲရုံကြားကာလ၊ ပြန်လည်ရယူရေးကာလနှင့် အခြားဒေတာများ ပါဝင်ပါသည်။ ၎င်းသည် ဖြန့်ကျက်မှုအတိုင်းအတာကို တိုင်းတာရန်အတွက် သက်ဆိုင်ရာ autoscaling resource (HPA definition) ကို ဖြစ်စေသည်။

အရာဝတ္ထုတစ်ခု 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 ဆာဗာလိပ်စာကို မက်ထရစ်အမည်၊ အဆင့်သတ်မှတ်ချက်များနှင့် အတူဖော်ပြထားသည်။ PromQL မေးမြန်းမှုအသုံးပြုမည့်၊ PromQL မေးမြန်းချက် - sum(rate(http_requests[2m])).
3. အတိုင်း pollingIntervalKEDA သည် ဆယ့်ငါးစက္ကန့်တိုင်း Prometheus ထံမှ ပစ်မှတ်တစ်ခုကို တောင်းဆိုသည်။ အနည်းဆုံး (အောက်)၊minReplicaCount) နှင့် အများဆုံး pods အရေအတွက်ထက် မကျော်လွန်ပါ။ maxReplicaCount (ဤဥပမာ-ဆယ်)။

တပ်ဆင်နိုင်သည်။ minReplicaCount သုညနှင့် ညီမျှသည်။ ဤကိစ္စတွင်၊ KEDA သည် သုညမှတစ်ခုသို့ ဖြန့်ကျက်မှုကို အသက်သွင်းပြီး နောက်ထပ် အလိုအလျောက် အတိုင်းအတာအတွက် HPA ကို ဖော်ထုတ်သည်။ ပြောင်းပြန်အစီအစဥ်သည် တစ်ခုမှ သုညအထိ ချဲ့ထွင်ခြင်းလည်း ဖြစ်နိုင်သည်။ ဥပမာတွင်၊ ၎င်းသည် HTTP ဝန်ဆောင်မှုဖြစ်ပြီး လိုအပ်သလောက်စနစ်မဟုတ်သောကြောင့် သုညကို ကျွန်ုပ်တို့မရွေးချယ်ခဲ့ပါ။

အလိုအလျောက် ချဲ့ထွင်ခြင်းအတွင်းမှ မှော်ပညာ

ဖြန့်ကျက်မှုအား အတိုင်းအတာတစ်ခုအဖြစ် အသုံးပြုရန် တံခါးခုံကို အစပျိုးတစ်ခုအဖြစ် အသုံးပြုသည်။ ကျွန်ုပ်တို့၏ဥပမာတွင် PromQL မေးမြန်းချက် sum(rate (http_requests [2m])) နောက်ဆုံးနှစ်မိနစ်အတွင်း တိုင်းတာထားသော HTTP တောင်းဆိုမှုနှုန်း (တစ်စက္ကန့်လျှင် တောင်းဆိုချက်များ) ကို ပြန်ပေးသည်။

threshold value သည် XNUMX ဖြစ်ပြီး၊ ၎င်းသည် တန်ဖိုးနေစဉ်တွင် တစ်ခုရှိမည်ဟု ဆိုလိုသည်။ sum(rate (http_requests [2m])) သုံးပုံအောက်။ တန်ဖိုးများလာပါက၊ တစ်ကြိမ်စီတွင် နောက်ထပ်အခွဲတစ်ခု ထပ်ထည့်ပါသည်။ sum(rate (http_requests [2m])) သုံးမျိုးတိုးလာသည်။ ဥပမာအားဖြင့်၊ တန်ဖိုးသည် 12 မှ 14 ဖြစ်ပါက pods အရေအတွက်သည် လေးခုဖြစ်သည်။

အခုပဲ စလုပ်ကြည့်ရအောင်။

ကြိုတင်ပြင်ဆင်ခြင်း။

သင်လိုအပ်သမျှမှာ 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/

သတ်မှတ်မည် kubectlKubernetes အစုအဝေးသို့ ဝင်ရောက်ရန်။

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 ကို နည်းလမ်းများစွာဖြင့် အသုံးချနိုင်ပြီး ၎င်းတို့ကို စာရင်းပြုစုထားသည်။ စာရွက်စာတမ်း. ငါ monolithic YAML သုံးနေတယ်

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

KEDA နှင့် ၎င်း၏ အစိတ်အပိုင်းများကို namespace တွင် ထည့်သွင်းထားသည်။ keda. စစ်ဆေးရန် အမိန့်

kubectl get pods -n keda

KEDA အော်ပရေတာ စတင်ရန် စောင့်ပြီး သွားပါ။ Running State. ထို့နောက် ဆက်လက်လုပ်ဆောင်ပါ။

Helm ကို အသုံးပြု၍ Redis ကို ထည့်သွင်းခြင်း။

Helm မတပ်ဆင်ထားပါက ၎င်းကိုသုံးပါ။ ခေါင်းဆောင်မှု. Mac တွင် ထည့်သွင်းရန် အမိန့်

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

helm init local command line interface ကို အစပြုပြီး install လုပ်သည်။ Tiller Kubernetes အစုအဝေးသို့

kubectl get pods -n kube-system | grep tiller

Tiller pod သည် Running state သို့ဝင်ရန် စောင့်ပါ။

ဘာသာပြန်သူ၏မှတ်ချက်- စာရေးသူသည် Tiller ဆာဗာအစိတ်အပိုင်းကို ထည့်သွင်းရန် လိုအပ်သည့် Helm@2 ကို အသုံးပြုသည်။ ယခု Helm@3 သည် ဆီလျော်သည်၊ ၎င်းသည် ဆာဗာအပိုင်း မလိုအပ်ပါ။

Helm ကိုထည့်သွင်းပြီးနောက်၊ Redis ကိုစတင်ရန် command တစ်ခုသည်လုံလောက်သည်။

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 ကိုအသုံးပြုသည်။ Prometheus အတွက် Kubernetes Service Discovery. ၎င်းသည် ဝန်ဆောင်မှုတံဆိပ်အပေါ် အခြေခံ၍ အပလီကေးရှင်း 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 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. ဒါကိုလုပ်ဖို့၊ command ကို run ပါ။

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"

မက်ထရစ်တန်ဖိုးကို သေချာပါစေ။ 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

သင့်အတွက် utility ကို ဒေါင်းလုဒ်လုပ်နိုင်သည်။ Linux ကို သို့မဟုတ် Windows ကို.

၎င်းကိုလုပ်ဆောင်ပါ

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

ပုံမှန်အားဖြင့်၊ utility သည် တောင်းဆိုချက် 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 ဖြစ်သောကြောင့် အတိုင်းအတာချဲ့ရန် မလုံလောက်ပါ။

ဝန်ပို.

terminal အသစ်တွင်၊ application pods အရေအတွက်ကို စောင့်ကြည့်ပါ-

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

command ကိုအသုံးပြု၍ load ကိုတိုးမြှင့်ကြပါစို့။

./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

ဝန်သည် တသမတ်တည်းဖြစ်နေပါက၊ pod တစ်ခုသာ လုပ်ဆောင်နေသည့်နေရာအထိ ဖြန့်ကျက်မှုကို လျှော့ချမည်ဖြစ်သည်။ အမှန်တကယ်မက်ထရစ်ကိုစစ်ဆေးလိုပါက (PromQL query မှပြန်ပေးသည်)၊ ထို့နောက် command ကိုသုံးပါ-

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 သည် ပြင်ပအရင်းအမြစ်တစ်ခုနှင့် ပေါင်းစပ်ပြီး ၎င်း၏ မက်ထရစ်ဆာဗာမှတစ်ဆင့် အလျားလိုက် Pod Autoscaler သို့ ၎င်း၏ မက်ထရစ်များကို ထောက်ပံ့ပေးသည်။

ကံကောင်းပါစေ!

နောက်ထပ်ဖတ်စရာများ

1. ထုတ်လုပ်မှုပတ်ဝန်းကျင်ရှိ ကွန်တိန်နာများနှင့် Kubernetes လည်ပတ်ခြင်းအတွက် အကောင်းဆုံးအလေ့အကျင့်များနှင့် အကောင်းဆုံးအလေ့အကျင့်များ.
2. Kubernetes အတွက် အသုံးဝင်သော ကိရိယာ 90+- ဖြန့်ကျက်ခြင်း၊ စီမံခန့်ခွဲခြင်း၊ စောင့်ကြည့်ခြင်း၊ လုံခြုံရေးနှင့် အခြားအရာများ.
3. Telegram ရှိ Kubernetes ဝန်းကျင်တွင် ကျွန်ုပ်တို့၏ချန်နယ်.

source: www.habr.com