Prometheus እና KEDA | በመጠቀም የኩበርኔትስ አፕሊኬሽኖችን አውቶማቲክ ማድረግ ፕሮሆስተር

ፊኛ ሰው በሲሙአኖስ

ልኬታማነት ለደመና አፕሊኬሽኖች ቁልፍ መስፈርት ነው። በኩበርኔትስ፣ አፕሊኬሽኑን ማመጣጠን ለተገቢው ማሰማራት ወይም ቅጂዎች ብዛት እንደማሳደግ ቀላል ነው። ReplicaSet - ግን በእጅ የሚሰራ ሂደት ነው።

Kubernetes መተግበሪያዎችን በራስ-ሰር እንዲመጠን ይፈቅዳል (ማለትም በማሰማራት ውስጥ ያሉ ፖድስ ወይም ReplicaSet) የ Horizontal Pod Autoscaler መግለጫን በመጠቀም ገላጭ በሆነ መንገድ። ለራስ-ሰር ልኬት ነባሪው መስፈርት የሲፒዩ አጠቃቀም ሜትሪክስ (የመርጃ መለኪያዎች) ነው፣ ነገር ግን ብጁ እና ውጫዊ የቀረቡ መለኪያዎችን ማዋሃድ ይችላሉ።

ቡድን Kubernetes aaS ከ Mail.ru የኩበርኔትስ መተግበሪያን በራስ-ሰር ለመለካት ውጫዊ መለኪያዎችን እንዴት መጠቀም እንደሚቻል ላይ አንድ ጽሑፍ ተርጉሟል። ሁሉም ነገር እንዴት እንደሚሰራ ለማሳየት ደራሲው ፕሮሜቲየስን በመጠቀም የተሰበሰቡትን የኤችቲቲፒ መዳረሻ ጥያቄ መለኪያዎችን ይጠቀማል።

በፖድድ አግድም አውቶማቲካሊንግ ፋንታ Kubernetes Event Driven Autoscaling (KEDA) ጥቅም ላይ ይውላል፣ የኩበርኔትስ ኦፕሬተር ክፍት ነው። በክስተቱ ላይ ለሚነሱ የስራ ጫናዎች እንከን የለሽ አውቶማቲክ (ወደ/ዜሮን ጨምሮ) ለማቅረብ ከHorizontal Pod Autoscaler ጋር ይዋሃዳል። ኮድ የሚገኘው በ የፊልሙ.

የስርዓቱ አጭር መግለጫ

ስዕሉ ሁሉም ነገር እንዴት እንደሚሰራ አጭር መግለጫ ያሳያል-

አፕሊኬሽኑ የኤችቲቲፒ የመምታት ብዛት መለኪያዎችን በPrometheus ቅርጸት ያቀርባል።
Prometheus እነዚህን መለኪያዎች ለመሰብሰብ ተዋቅሯል።
በ KEDA ውስጥ ያለው የፕሮሜቲየስ ሚዛን አፕሊኬሽኑን በኤችቲቲፒ ስኬቶች ብዛት ላይ በመመስረት በራስ-ሰር እንዲመዘን ተዋቅሯል።

አሁን ስለ እያንዳንዱ ንጥረ ነገር በዝርዝር እነግራችኋለሁ.

ኬዳ እና ፕሮሜቲየስ

Prometheus የክፍት ምንጭ ስርዓት ክትትል እና ማንቂያ መሳሪያ ነው፣ ክፍል የደመና ቤተኛ ኮምፒተር ፋውንዴሽን. መለኪያዎችን ከተለያዩ ምንጮች ይሰበስባል እና እንደ የጊዜ ተከታታይ ውሂብ ያከማቻል። ውሂብን በዓይነ ሕሊናህ ለማየት መጠቀም ትችላለህ ግራፋና ወይም ከ Kubernetes API ጋር የሚሰሩ ሌሎች የእይታ መሳሪያዎች።

KEDA የመለኪያ ጽንሰ-ሐሳብን ይደግፋል - በ KEDA እና በውጫዊ ስርዓት መካከል እንደ ድልድይ ሆኖ ይሠራል። የመለኪያ አተገባበር ለእያንዳንዱ ዒላማ ስርዓት የተለየ እና መረጃን ከእሱ ያወጣል። KEDA ከዚያም አውቶማቲክ ሚዛንን ለመቆጣጠር ይጠቀምባቸዋል.

Scalers ብዙ የውሂብ ምንጮችን ይደግፋሉ, ለምሳሌ, Kafka, Redis, Prometheus. ማለትም፣ KEDA የPrometheus መለኪያዎችን እንደ መስፈርት በመጠቀም የኩበርኔትስ ማሰማራቶችን በራስ ሰር ለመለካት ጥቅም ላይ ሊውል ይችላል።

የሙከራ መተግበሪያ

የጎላንግ ሙከራ መተግበሪያ በ HTTP በኩል መዳረሻ ይሰጣል እና ሁለት አስፈላጊ ተግባራትን ያከናውናል፡

አፕሊኬሽኑን ለመጠቅለል እና የ http_requests መለኪያን ለማቅረብ የፕሮሜቴየስ ጎ ደንበኛ ቤተ-መጽሐፍትን ይጠቀማል፣ ይህም ከፍተኛ ውጤት ይይዛል። የፕሮሜቲየስ መለኪያዎች የሚገኙበት የመጨረሻ ነጥብ በዩአርአይ ይገኛል። /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

ለጥያቄው ምላሽ GET አፕሊኬሽኑ የቁልፉን ዋጋ ይጨምራል (access_count) በሬዲስ. ይህ እንደ ኤችቲቲፒ ተቆጣጣሪ አካል ሆኖ ስራውን ለመስራት እና እንዲሁም የፕሮሜቲየስ መለኪያዎችን ለመፈተሽ ቀላል መንገድ ነው። የሜትሪክ እሴቱ ከዋጋው ጋር አንድ አይነት መሆን አለበት access_count በሬዲስ.

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 አገልጋይ

የፕሮሜቲየስ ማሰማራት አንጸባራቂ የሚከተሉትን ያካትታል፡-

ConfigMap - የ Prometheus ውቅረትን ለማስተላለፍ;
Deployment - ፕሮሜቲየስን በኩበርኔትስ ክላስተር ውስጥ ለማሰማራት;
ClusterIP - ወደ UI Prometheus ለመድረስ አገልግሎት;
ClusterRole, ClusterRoleBinding и ServiceAccount - በ Kubernetes ውስጥ አገልግሎቶችን በራስ-ሰር ለማግኘት (ራስ-ግኝት)።

እዚህ ፕሮሜቲየስን ለማሄድ አንጸባራቂ.

ኬዳ ፕሮሜቴየስ ስካሌድ ነገር

መለኪያው በ KEDA እና በውጫዊ ስርዓት መካከል እንደ ድልድይ ሆኖ የሚሠራ ሲሆን ይህም መለኪያዎችን ማግኘት ያስፈልጋል. ScaledObject በዚህ ጉዳይ ላይ ፕሮሜቲየስን ከክስተቱ ምንጭ ጋር ለማመሳሰል መሰማራት ያለበት ብጁ ግብዓት ነው።

ScaledObject የማሰማራት ልኬት መረጃ፣ የክስተት ምንጭ ዲበ ውሂብ (እንደ የግንኙነት ሚስጥሮች፣ የወረፋ ስም)፣ የምርጫ ክፍተት፣ የመልሶ ማግኛ ጊዜ እና ሌላ ውሂብ ይዟል። የማሰማራቱን መጠን ለመለካት ተጓዳኝ አውቶማቲክ ሪሶርስ (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]))

የሚከተሉትን ነጥቦች ተመልከት።

እሱ ይጠቁማል Deployment በስም go-prom-app.
ቀስቅሴ ዓይነት - Prometheus. የፕሮሜቲየስ አገልጋይ አድራሻ ከሜትሪክ ስም፣ ገደብ እና ጋር ተጠቅሷል PromQL መጠይቅጥቅም ላይ የሚውለው. PromQL መጠይቅ - sum(rate(http_requests[2m])).
እንደ pollingInterval,KEDA በየአስራ አምስት ሰከንድ ከPrometheus ኢላማ ይጠይቃል። ቢያንስ አንድ ስር (minReplicaCount), እና ከፍተኛው የፖዳዎች ብዛት አይበልጥም maxReplicaCount (በዚህ ምሳሌ - አስር).

መጫን ይችላል። minReplicaCount ከዜሮ ጋር እኩል ነው። በዚህ አጋጣሚ KEDA ከዜሮ ወደ አንድ ማሰማራቱን ያነቃዋል እና በመቀጠል HPA ን ለተጨማሪ አውቶማቲክ ልኬት ያጋልጣል። የተገላቢጦሽ ቅደም ተከተል እንዲሁ ይቻላል ፣ ማለትም ፣ ከአንድ ወደ ዜሮ ማመጣጠን። በምሳሌው ላይ፣ ይህ የኤችቲቲፒ አገልግሎት እንጂ የሚጠየቅ ስርዓት ስላልሆነ ዜሮን አልመረጥንም።

በራስ መመዘኛ ውስጥ ያለው አስማት

ጣራው ዝርጋታውን ለመለካት እንደ ቀስቅሴ ጥቅም ላይ ይውላል። በእኛ ምሳሌ፣ የPromQL ጥያቄ sum(rate (http_requests [2m])) ባለፉት ሁለት ደቂቃዎች የተለካውን አጠቃላይ የኤችቲቲፒ ጥያቄ መጠን (ጥያቄዎች በሰከንድ) ይመልሳል።

የመነሻ እሴቱ ሦስት ስለሆነ፣ እሴቱ እያለ አንድ ይኖራል ማለት ነው። sum(rate (http_requests [2m])) ከሶስት ያነሰ. እሴቱ ከጨመረ፣ በእያንዳንዱ ጊዜ ተጨማሪ ንዑስ ይታከላል sum(rate (http_requests [2m])) በሦስት ይጨምራል. ለምሳሌ, እሴቱ ከ 12 ወደ 14 ከሆነ, የፖዳዎች ቁጥር አራት ነው.

አሁን ለማዋቀር እንሞክር!

ቅድመ ዝግጅት ማድረግ

የሚያስፈልግህ የኩበርኔትስ ክላስተር እና የተዋቀረ መገልገያ ነው። 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 እየተጠቀምኩ ነው፡-

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

KEDA እና ክፍሎቹ በስም ቦታ ላይ ተጭነዋል keda. ለመፈተሽ ትእዛዝ፦

kubectl get pods -n keda

KEDA ኦፕሬተር እስኪጀምር ይጠብቁ እና ወደ ይሂዱ Running State. እና ከዚያ በኋላ, ይቀጥሉ.

Helm በመጠቀም Redis ን መጫን

Helm የተጫነ ከሌለዎት ይህንን ይጠቀሙ አመራር. በ Mac ላይ ለመጫን ትዕዛዝ:

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

helm init የአካባቢውን የትእዛዝ መስመር በይነገጽ ያስጀምራል እና ይጫናል Tiller ወደ ኩበርኔትስ ክላስተር።

kubectl get pods -n kube-system | grep tiller

የቲለር ፖድ ወደ ሩጫ ሁኔታ እስኪገባ ድረስ ይጠብቁ።

የአስተርጓሚ ማስታወሻደራሲው የቲለር አገልጋይ አካል እንዲጫን የሚፈልገውን Helm@2 ይጠቀማል። አሁን 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.

የፕሮሜቲየስ አገልጋይን በማሰማራት ላይ

ፕሮሜቲየስ አንጸባራቂ ይጠቀማል የኩበርኔትስ አገልግሎት ግኝት ለፕሮሜቲየስ. በአገልግሎት መለያው ላይ በመመስረት የመተግበሪያ ፖድዎችን ተለዋዋጭ ግኝት ይፈቅዳል።

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 ውቅረትን በማሰማራት ላይ

ለመፍጠር ትእዛዝ 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"

የሜትሪክ እሴቱ መሆኑን ያረጋግጡ 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

እንዲሁም መገልገያውን ለ ማውረድ ይችላሉ። ሊኑክስ ወይም የ Windows.

አሂድ፡

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

በነባሪነት መገልገያው 200 ጥያቄዎችን ይልካል። ይህንን ፕሮሜቲየስ ሜትሪክስ እንዲሁም ሬዲስን በመጠቀም ማረጋገጥ ይችላሉ።

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 ነው።

ተጨማሪ ጭነት!

በአዲሱ ተርሚናል ውስጥ የመተግበሪያ ፖድዎችን ብዛት ይቆጣጠሩ፡-

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 ማሰማራቶችን (ወደ / ከዜሮ) በውጫዊ መለኪያዎች ላይ በመመርኮዝ በራስ-ሰር እንዲመዘኑ ይፈቅድልዎታል። ለምሳሌ፣ በፕሮሜቲየስ ሜትሪክስ ላይ በመመስረት፣ በሬዲስ ውስጥ የወረፋ ርዝመት፣ የሸማቾች መዘግየት በካፍ ርዕስ።

KEDA ከውጪ ምንጭ ጋር ይዋሃዳል እና በሜትሪክስ አገልጋይ በኩል ወደ አግድም ፖድ አውቶማቲክ መለኪያ ያቀርባል።

መልካም ዕድል!

ሌላ ምን ማንበብ አለበት:

ምንጭ: hab.com

Prometheus እና KEDA በመጠቀም የኩበርኔትስ አፕሊኬሽኖችን በራስ-ማስኬድ