🥇प्रोमेथियस और केईडीए का उपयोग करके कुबेरनेट्स अनुप्रयोगों को ऑटोस्केल करना

सिमुआनोस द्वारा बैलून मैन

क्लाउड अनुप्रयोगों के लिए स्केलेबिलिटी एक प्रमुख आवश्यकता है। कुबेरनेट्स के साथ, किसी एप्लिकेशन को स्केल करना उतना ही सरल है जितना कि उचित तैनाती के लिए प्रतिकृतियों की संख्या बढ़ाना ReplicaSet - लेकिन यह एक मैन्युअल प्रक्रिया है।

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

टीम Mail.ru से Kubernetes aaS कुबेरनेट्स एप्लिकेशन को स्वचालित रूप से स्केल करने के लिए बाहरी मेट्रिक्स का उपयोग करने के तरीके पर एक लेख का अनुवाद किया। यह दिखाने के लिए कि सब कुछ कैसे काम करता है, लेखक HTTP एक्सेस अनुरोध मेट्रिक्स का उपयोग करता है, जो प्रोमेथियस का उपयोग करके एकत्र किए जाते हैं।

पॉड्स की क्षैतिज ऑटोस्केलिंग के बजाय, कुबेरनेट्स इवेंट ड्रिवेन ऑटोस्केलिंग (केईडीए) का उपयोग किया जाता है, जो एक खुला स्रोत कुबेरनेट्स ऑपरेटर है। यह इवेंट-संचालित वर्कलोड के लिए निर्बाध ऑटोस्केलिंग (शून्य से/शून्य सहित) प्रदान करने के लिए क्षैतिज पॉड ऑटोस्केलर के साथ मूल रूप से एकीकृत होता है। कोड यहां उपलब्ध है GitHub.

प्रणाली का संक्षिप्त अवलोकन

आरेख इस बात का संक्षिप्त विवरण दिखाता है कि सब कुछ कैसे काम करता है:

एप्लिकेशन प्रोमेथियस प्रारूप में HTTP हिट काउंट मेट्रिक्स प्रदान करता है।
प्रोमेथियस को इन मेट्रिक्स को एकत्रित करने के लिए कॉन्फ़िगर किया गया है।
केईडीए में प्रोमेथियस स्केलर को HTTP हिट की संख्या के आधार पर एप्लिकेशन को स्वचालित रूप से स्केल करने के लिए कॉन्फ़िगर किया गया है।

अब मैं आपको प्रत्येक तत्व के बारे में विस्तार से बताऊंगा।

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

प्रोमेथियस एक खुला स्रोत सिस्टम मॉनिटरिंग और अलर्टिंग टूलकिट, भाग है क्लाउड नेटिव कम्प्यूटिंग फाउंडेशन. विभिन्न स्रोतों से मेट्रिक्स एकत्र करता है और उन्हें समय श्रृंखला डेटा के रूप में संग्रहीत करता है। डेटा को विज़ुअलाइज़ करने के लिए आप इसका उपयोग कर सकते हैं ग्राफाना या अन्य विज़ुअलाइज़ेशन उपकरण जो कुबेरनेट्स एपीआई के साथ काम करते हैं।

केईडीए स्केलर की अवधारणा का समर्थन करता है - यह केईडीए और बाहरी प्रणाली के बीच एक पुल के रूप में कार्य करता है। स्केलर कार्यान्वयन प्रत्येक लक्ष्य प्रणाली के लिए विशिष्ट है और उससे डेटा निकालता है। फिर KEDA स्वचालित स्केलिंग को नियंत्रित करने के लिए उनका उपयोग करता है।

स्केलर कई डेटा स्रोतों का समर्थन करते हैं, उदाहरण के लिए, काफ्का, रेडिस, प्रोमेथियस। अर्थात्, KEDA का उपयोग मानदंड के रूप में प्रोमेथियस मेट्रिक्स का उपयोग करके कुबेरनेट्स तैनाती को स्वचालित रूप से स्केल करने के लिए किया जा सकता है।

परीक्षण आवेदन

गोलांग परीक्षण एप्लिकेशन HTTP के माध्यम से पहुंच प्रदान करता है और दो महत्वपूर्ण कार्य करता है:

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

एक अनुरोध के जवाब में GET एप्लिकेशन कुंजी का मान बढ़ाता है (access_count) रेडिस में। यह HTTP हैंडलर के हिस्से के रूप में काम करने और प्रोमेथियस मेट्रिक्स की जांच करने का एक आसान तरीका है। मीट्रिक मान मान के समान होना चाहिए 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)
   }

एप्लिकेशन को कुबेरनेट्स के माध्यम से तैनात किया गया है Deployment. एक सेवा भी बनाई गई है ClusterIP, यह प्रोमेथियस सर्वर को एप्लिकेशन मेट्रिक्स प्राप्त करने की अनुमति देता है।

यहां एप्लिकेशन के लिए परिनियोजन मैनिफ़ेस्ट.

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

प्रोमेथियस परिनियोजन मेनिफेस्ट में निम्न शामिल हैं:

ConfigMap - प्रोमेथियस कॉन्फ़िगरेशन को स्थानांतरित करने के लिए;
Deployment - कुबेरनेट्स क्लस्टर में प्रोमेथियस को तैनात करने के लिए;
ClusterIP - यूआई प्रोमेथियस तक पहुंच के लिए सेवा;
ClusterRole, ClusterRoleBinding и ServiceAccount - कुबेरनेट्स (ऑटो-डिस्कवरी) में सेवाओं का स्वत: पता लगाने के लिए।

यहां प्रोमेथियस को चलाने के लिए प्रकट.

केडा प्रोमेथियस स्केल्डऑब्जेक्ट

स्केलर केईडीए और बाहरी प्रणाली के बीच एक पुल के रूप में कार्य करता है जिससे मेट्रिक्स प्राप्त करने की आवश्यकता होती है। ScaledObject एक कस्टम संसाधन है जिसे इवेंट स्रोत के साथ परिनियोजन को सिंक्रनाइज़ करने के लिए तैनात करने की आवश्यकता है, इस मामले में प्रोमेथियस।

ScaledObject इसमें परिनियोजन स्केलिंग जानकारी, ईवेंट स्रोत मेटाडेटा (जैसे कनेक्शन रहस्य, कतार नाम), मतदान अंतराल, पुनर्प्राप्ति अवधि और अन्य डेटा शामिल हैं। इसके परिणामस्वरूप तैनाती को स्केल करने के लिए संबंधित ऑटोस्केलिंग संसाधन (एचपीए परिभाषा) प्राप्त होता है।

जब कोई वस्तु ScaledObject हटा दिया गया है, संबंधित एचपीए परिभाषा साफ़ कर दी गई है।

यहाँ परिभाषा है 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. प्रोमेथियस सर्वर पते का उल्लेख मीट्रिक नाम, सीमा और के साथ किया गया है प्रोमक्यूएल क्वेरी, जिसका उपयोग किया जाएगा। प्रोमक्यूएल क्वेरी - sum(rate(http_requests[2m])).
के अनुसार pollingInterval,KEDA हर पंद्रह सेकंड में प्रोमेथियस से एक लक्ष्य का अनुरोध करता है। कम से कम एक के अंतर्गत (minReplicaCount), और पॉड्स की अधिकतम संख्या अधिक नहीं है maxReplicaCount (इस उदाहरण में - दस).

स्थापित कर सकते हैं minReplicaCount शून्य के बराबर. इस मामले में, केईडीए शून्य-से-एक परिनियोजन को सक्रिय करता है और फिर आगे स्वचालित स्केलिंग के लिए एचपीए को उजागर करता है। उलटा क्रम भी संभव है, यानी एक से शून्य तक स्केलिंग। उदाहरण में, हमने शून्य का चयन नहीं किया क्योंकि यह एक HTTP सेवा है न कि ऑन-डिमांड प्रणाली।

ऑटोस्केलिंग के अंदर का जादू

परिनियोजन को मापने के लिए थ्रेशोल्ड का उपयोग ट्रिगर के रूप में किया जाता है। हमारे उदाहरण में, PromQL क्वेरी sum(rate (http_requests [2m])) पिछले दो मिनटों में मापी गई एकत्रित HTTP अनुरोध दर (प्रति सेकंड अनुरोध) लौटाता है।

चूँकि सीमा मान तीन है, इसका मतलब है कि मान के नीचे एक होगा sum(rate (http_requests [2m])) तीन से कम. यदि मान बढ़ता है, तो हर बार एक अतिरिक्त उप जोड़ा जाता है sum(rate (http_requests [2m])) तीन से बढ़ जाता है. उदाहरण के लिए, यदि मान 12 से 14 तक है, तो पॉड्स की संख्या चार है।

आइए अब इसे स्थापित करने का प्रयास करें!

presetting

आपको बस एक कुबेरनेट्स क्लस्टर और एक कॉन्फ़िगर उपयोगिता की आवश्यकता है kubectl. यह उदाहरण एक क्लस्टर का उपयोग करता है minikube, लेकिन आप कोई अन्य भी ले सकते हैं। एक क्लस्टर स्थापित करने के लिए वहाँ है नेतृत्व.

मैक पर नवीनतम संस्करण स्थापित करें:

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 क्लस्टर तक पहुँचने के लिए।

मैक पर नवीनतम संस्करण स्थापित करें:

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 को कई तरीकों से तैनात कर सकते हैं, वे इसमें सूचीबद्ध हैं प्रलेखन. मैं अखंड 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 का उपयोग करता है, जिसके लिए टिलर सर्वर घटक स्थापित करना आवश्यक है। अब हेल्म@3 प्रासंगिक है, इसके लिए सर्वर पार्ट की आवश्यकता नहीं है।

हेल्म स्थापित करने के बाद, रेडिस शुरू करने के लिए एक कमांड पर्याप्त है:

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

सत्यापित करें कि Redis सफलतापूर्वक प्रारंभ हो गया है:

kubectl get pods/redis-server-master-0

रेडिस के राज्य में आने की प्रतीक्षा करें 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

रेडिस के राज्य में प्रवेश करने की प्रतीक्षा करें 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 प्रोमेथियस यूजर इंटरफेस (या एपीआई सर्वर) तक पहुंचने के लिए 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

अब आप पते का उपयोग करके अपने गो ऐप तक पहुंच सकते हैं 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 या 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

थोड़ी देर के बाद, आप देखेंगे कि एचपीए तैनाती को बढ़ा रहा है और नए पॉड्स लॉन्च कर रहा है। यह सुनिश्चित करने के लिए अपना एचपीए जांचें:

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

निष्कर्ष

केईडीए आपको बाहरी मेट्रिक्स के डेटा के आधार पर अपने कुबेरनेट्स परिनियोजन को स्वचालित रूप से (शून्य से/तक) स्केल करने की अनुमति देता है। उदाहरण के लिए, प्रोमेथियस मेट्रिक्स के आधार पर, रेडिस में कतार की लंबाई, काफ्का विषय में उपभोक्ता विलंबता।

केईडीए एक बाहरी स्रोत के साथ एकीकृत होता है और मेट्रिक्स सर्वर के माध्यम से हॉरिजॉन्टल पॉड ऑटोस्केलर को अपने मेट्रिक्स भी प्रदान करता है।

सौभाग्य!

और क्या पढ़ें:

स्रोत: www.habr.com

प्रोमेथियस और केईडीए का उपयोग करके कुबेरनेट्स अनुप्रयोगों को ऑटोस्केल करना