🥇प्रोमिथियस आणि KEDA वापरून कुबर्नेट्स ऍप्लिकेशन्सचे ऑटोस्केलिंग

Cimuanos द्वारे बलून मॅन

क्लाउड ऍप्लिकेशन्ससाठी स्केलेबिलिटी ही मुख्य आवश्यकता आहे. Kubernetes सह, अनुप्रयोग स्केलिंग करणे योग्य तैनातीसाठी प्रतिकृतींची संख्या वाढवण्याइतके सोपे आहे किंवा ReplicaSet - पण ही एक मॅन्युअल प्रक्रिया आहे.

Kubernetes अनुप्रयोगांना आपोआप स्केल करण्यास अनुमती देते (उदा. उपयोजनातील पॉड्स किंवा ReplicaSet) क्षैतिज पॉड ऑटोस्केलर तपशील वापरून घोषणात्मक पद्धतीने. स्वयंचलित स्केलिंगसाठी डीफॉल्ट निकष CPU वापर मेट्रिक्स (संसाधन मेट्रिक्स) आहे, परंतु तुम्ही सानुकूल आणि बाह्यरित्या प्रदान केलेले मेट्रिक्स एकत्रित करू शकता.

संघ Mail.ru वरून Kubernetes aaS Kubernetes ऍप्लिकेशन स्वयंचलितपणे स्केल करण्यासाठी बाह्य मेट्रिक्स कसे वापरावे यावरील लेखाचे भाषांतर केले. सर्व काही कसे कार्य करते हे दर्शविण्यासाठी, लेखक HTTP प्रवेश विनंती मेट्रिक्स वापरतात, जे प्रोमिथियस वापरून संकलित केले जातात.

पॉड्सच्या क्षैतिज ऑटोस्केलिंगऐवजी, कुबर्नेट्स इव्हेंट ड्रायव्हन ऑटोस्केलिंग (KEDA) वापरला जातो, एक ओपन सोर्स Kubernetes ऑपरेटर. इव्हेंट-चालित वर्कलोड्ससाठी सीमलेस ऑटोस्केलिंग (शून्य पासून/शून्य सहित) प्रदान करण्यासाठी हे क्षैतिज पॉड ऑटोस्केलरसह मूळपणे समाकलित करते. कोड येथे उपलब्ध आहे GitHub.

प्रणालीचे संक्षिप्त विहंगावलोकन

आकृती सर्वकाही कसे कार्य करते याचे संक्षिप्त वर्णन दर्शविते:

ऍप्लिकेशन प्रोमिथियस फॉरमॅटमध्ये HTTP हिट काउंट मेट्रिक्स प्रदान करते.
हे मेट्रिक्स गोळा करण्यासाठी प्रोमिथियस कॉन्फिगर केले आहे.
KEDA मधील प्रोमिथियस स्केलर हे HTTP हिटच्या संख्येवर आधारित ऍप्लिकेशन स्वयंचलितपणे मोजण्यासाठी कॉन्फिगर केले आहे.

आता मी तुम्हाला प्रत्येक घटकाबद्दल तपशीलवार सांगेन.

केडा आणि प्रोमिथियस

प्रोमिथियस हे ओपन सोर्स सिस्टम मॉनिटरिंग आणि अलर्टिंग टूलकिट आहे क्लाउड नेटिव्ह कम्प्यूटिंग फाउंडेशन. विविध स्त्रोतांकडून मेट्रिक्स संकलित करते आणि त्यांना वेळ मालिका डेटा म्हणून संग्रहित करते. डेटाची कल्पना करण्यासाठी तुम्ही वापरू शकता ग्राफाना किंवा इतर व्हिज्युअलायझेशन टूल्स जे Kubernetes API सह कार्य करतात.

KEDA स्केलरच्या संकल्पनेला समर्थन देते - ते केडा आणि बाह्य प्रणाली यांच्यातील पूल म्हणून काम करते. स्केलर अंमलबजावणी प्रत्येक लक्ष्य प्रणालीसाठी विशिष्ट आहे आणि त्यातून डेटा काढतो. KEDA नंतर स्वयंचलित स्केलिंग नियंत्रित करण्यासाठी त्यांचा वापर करते.

स्केलर एकाधिक डेटा स्त्रोतांना समर्थन देतात, उदाहरणार्थ, काफ्का, रेडिस, प्रोमिथियस. म्हणजेच, KEDA चा वापर प्रोमिथियस मेट्रिक्सचा निकष म्हणून वापर करून कुबर्नेट्स उपयोजना स्वयंचलितपणे मोजण्यासाठी केला जाऊ शकतो.

चाचणी अर्ज

गोलांग चाचणी अनुप्रयोग HTTP द्वारे प्रवेश प्रदान करतो आणि दोन महत्त्वपूर्ण कार्ये करतो:

अॅप्लिकेशन इन्स्ट्रुमेंट करण्यासाठी आणि http_requests मेट्रिक प्रदान करण्यासाठी Prometheus Go क्लायंट लायब्ररी वापरते, ज्यामध्ये हिट संख्या असते. प्रोमिथियस मेट्रिक्स जिथे उपलब्ध आहेत तो शेवटचा बिंदू URI वर स्थित आहे /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

विनंतीला प्रतिसाद म्हणून GET अनुप्रयोग कि चे मूल्य वाढवते (access_count) रेडिस मध्ये. 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)
   }

अर्ज कुबेरनेट्सवर द्वारे तैनात केला आहे Deployment. एक सेवा देखील तयार केली आहे ClusterIP, हे प्रोमिथियस सर्व्हरला ऍप्लिकेशन मेट्रिक्स प्राप्त करण्यास अनुमती देते.

येथे अर्जासाठी डिप्लॉयमेंट मॅनिफेस्ट.

प्रोमिथियस सर्व्हर

प्रोमिथियस डिप्लॉयमेंट मॅनिफेस्टमध्ये हे समाविष्ट आहे:

ConfigMap - प्रोमिथियस कॉन्फिगरेशन हस्तांतरित करण्यासाठी;
Deployment - कुबर्नेट्स क्लस्टरमध्ये प्रोमिथियस तैनात करण्यासाठी;
ClusterIP - यूआय प्रोमिथियसमध्ये प्रवेश करण्यासाठी सेवा;
ClusterRole, ClusterRoleBinding и ServiceAccount — Kubernetes (ऑटो-डिस्कव्हरी) मधील सेवांच्या स्वयं-शोधासाठी.

येथे प्रोमिथियस चालविण्यासाठी मॅनिफेस्ट.

KEDA Prometheus ScaledObject

स्केलर KEDA आणि बाह्य प्रणाली ज्यामधून मेट्रिक्स प्राप्त करणे आवश्यक आहे यामधील पूल म्हणून कार्य करते. ScaledObject एक सानुकूल संसाधन आहे ज्याला इव्हेंट स्त्रोतासह उपयोजन समक्रमित करण्यासाठी उपयोजित करणे आवश्यक आहे, या प्रकरणात Prometheus.

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,केईडीए दर पंधरा सेकंदांनी प्रोमिथियसकडून लक्ष्याची विनंती करते. किमान एक अंतर्गत (minReplicaCount), आणि शेंगांची कमाल संख्या ओलांडत नाही maxReplicaCount (या उदाहरणात - दहा).

स्थापित केले जाऊ शकते minReplicaCount शून्याच्या बरोबरीचे. या प्रकरणात, KEDA शून्य-टू-वन तैनाती सक्रिय करते आणि नंतर पुढील स्वयंचलित स्केलिंगसाठी HPA उघड करते. उलट क्रम देखील शक्य आहे, म्हणजे, एक ते शून्य पर्यंत स्केल करणे. उदाहरणामध्ये, आम्ही शून्य निवडले नाही कारण ही HTTP सेवा आहे आणि मागणीनुसार प्रणाली नाही.

ऑटोस्केलिंगमधील जादू

तैनाती मोजण्यासाठी थ्रेशोल्डचा वापर ट्रिगर म्हणून केला जातो. आमच्या उदाहरणात, PromQL क्वेरी sum(rate (http_requests [2m])) एकत्रित HTTP विनंती दर परत करते (प्रति सेकंद विनंत्या), शेवटच्या दोन मिनिटांत मोजलेले.

थ्रेशोल्ड मूल्य तीन असल्याने, याचा अर्थ मूल्य असताना एक खाली असेल 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/

सेट 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 ला अनेक प्रकारे उपयोजित करू शकता, ते त्यात सूचीबद्ध आहेत दस्तऐवजीकरण. मी मोनोलिथिक YAML वापरत आहे:

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

KEDA आणि त्याचे घटक नेमस्पेसमध्ये स्थापित केले आहेत keda. तपासण्यासाठी आदेश:

kubectl get pods -n keda

KEDA ऑपरेटर सुरू होईपर्यंत प्रतीक्षा करा आणि वर जा Running State. आणि त्यानंतर, सुरू ठेवा.

हेल्म वापरून रेडिस स्थापित करणे

तुमच्याकडे हेल्म इन्स्टॉल केलेले नसल्यास, हे वापरा नेतृत्व. Mac वर स्थापित करण्यासाठी आदेश:

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

helm init स्थानिक कमांड लाइन इंटरफेस सुरू करते आणि स्थापित देखील करते Tiller कुबर्नेट्स क्लस्टरकडे.

kubectl get pods -n kube-system | grep tiller

टिलर पॉड रनिंग स्टेटमध्ये येईपर्यंत प्रतीक्षा करा.

अनुवादकाची टीप: लेखक हेल्म@2 वापरतो, ज्यासाठी टिलर सर्व्हर घटक स्थापित करणे आवश्यक आहे. आता Helm@3 प्रासंगिक आहे, त्याला सर्व्हर भाग आवश्यक नाही.

हेल्म स्थापित केल्यानंतर, रेडिस सुरू करण्यासाठी एक कमांड पुरेशी आहे:

helm install --name redis-server --set cluster.enabled=false --set 
usePassword=false stable/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

प्रोमिथियस राज्यात जाण्यासाठी प्रतीक्षा करा 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 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

यावेळी रेडिस देखील तपासा. तुम्हाला ते कळेल 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

आपण यासाठी उपयुक्तता देखील डाउनलोड करू शकता linux किंवा विंडोज.

ते चालवा:

./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 आहे.

अधिक भार!

नवीन टर्मिनलमध्ये, ऍप्लिकेशन पॉड्सच्या संख्येचे निरीक्षण करा:

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

कमांड वापरून लोड वाढवू:

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

काही काळानंतर, तुम्हाला एचपीए तैनाती स्केल करताना आणि नवीन पॉड लॉन्च करताना दिसेल. हे सुनिश्चित करण्यासाठी तुमचा 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

जर लोड विसंगत असेल, तर तैनाती फक्त एक पॉड चालू असलेल्या बिंदूपर्यंत कमी केली जाईल. तुम्हाला वास्तविक मेट्रिक (प्रॉमक्यूएल क्वेरीद्वारे परत आले) तपासायचे असल्यास, कमांड वापरा:

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 बाह्य स्त्रोताशी समाकलित होते आणि त्याचे मेट्रिक्स मेट्रिक्स सर्व्हर ते Horizontal Pod Autoscaler द्वारे देखील प्रदान करते.

रिझर्व्हर्व्हर ... पुन्हा!

आणखी काय वाचायचे:

स्त्रोत: www.habr.com

Prometheus आणि KEDA वापरून Kubernetes अनुप्रयोग ऑटोस्केलिंग