ப்ரோமிதியஸ் மற்றும் KEDA உடன் ஆட்டோஸ்கேலிங் குபெர்னெட்ஸ் பயன்பாடுகள்

சிமுவானோஸ் எழுதிய பலூன் மேன்

கிளவுட் பயன்பாடுகளுக்கு அளவிடுதல் ஒரு முக்கிய தேவை. குபெர்னெட்டஸ் மூலம், ஒரு பயன்பாட்டை அளவிடுவது, பொருத்தமான வரிசைப்படுத்தலுக்கான பிரதிகளின் எண்ணிக்கையை அதிகரிப்பது போல அல்லது ReplicaSet - ஆனால் இது ஒரு கைமுறை செயல்முறை.

பயன்பாடுகளை தானாக அளவிட குபெர்னெட்டஸ் அனுமதிக்கிறது (அதாவது வரிசைப்படுத்தலில் உள்ள பாட்கள் அல்லது ReplicaSet) கிடைமட்ட பாட் ஆட்டோஸ்கேலர் விவரக்குறிப்பைப் பயன்படுத்தி ஒரு அறிவிப்பு முறையில். தானியங்கி அளவிடுதலுக்கான இயல்புநிலை அளவுகோல் CPU பயன்பாட்டு அளவீடுகள் (வள அளவீடுகள்) ஆகும், ஆனால் நீங்கள் தனிப்பயன் மற்றும் வெளிப்புறமாக வழங்கப்பட்ட அளவீடுகளை ஒருங்கிணைக்கலாம்.

அணி Mail.ru இலிருந்து Kubernetes aaS குபெர்னெட்ஸ் பயன்பாட்டை தானாக அளவிடுவதற்கு வெளிப்புற அளவீடுகளை எவ்வாறு பயன்படுத்துவது என்பது குறித்த கட்டுரையை மொழிபெயர்த்தது. அனைத்தும் எவ்வாறு செயல்படுகின்றன என்பதைக் காட்ட, ஆசிரியர் HTTP அணுகல் கோரிக்கை அளவீடுகளைப் பயன்படுத்துகிறார், அவை Prometheus ஐப் பயன்படுத்தி சேகரிக்கப்படுகின்றன.

காய்களின் கிடைமட்ட ஆட்டோஸ்கேலிங்கிற்குப் பதிலாக, குபெர்னெட்டஸ் ஈவென்ட் டிரைவன் ஆட்டோஸ்கேலிங் (கேடா) பயன்படுத்தப்படுகிறது, இது திறந்த மூல குபெர்னெட்ஸ் ஆபரேட்டர். நிகழ்வு-உந்துதல் பணிச்சுமைகளுக்கு தடையற்ற ஆட்டோஸ்கேலிங் (பூஜ்ஜியம் உட்பட/இருந்து) வழங்க, கிடைமட்ட பாட் ஆட்டோஸ்கேலருடன் இது இயல்பாகவே ஒருங்கிணைக்கிறது. குறியீடு கிடைக்கும் மகிழ்ச்சியா.

அமைப்பின் சுருக்கமான கண்ணோட்டம்

எல்லாம் எவ்வாறு செயல்படுகிறது என்பதற்கான சுருக்கமான விளக்கத்தை வரைபடம் காட்டுகிறது:

1. பயன்பாடு HTTP வெற்றி எண்ணிக்கை அளவீடுகளை Prometheus வடிவத்தில் வழங்குகிறது.
2. இந்த அளவீடுகளை சேகரிக்க Prometheus கட்டமைக்கப்பட்டுள்ளது.
3. KEDA இல் உள்ள Prometheus scaler ஆனது HTTP வெற்றிகளின் எண்ணிக்கையின் அடிப்படையில் பயன்பாட்டை தானாக அளவிடும் வகையில் கட்டமைக்கப்பட்டுள்ளது.

இப்போது ஒவ்வொரு உறுப்புகளையும் பற்றி விரிவாகச் சொல்கிறேன்.

KEDA மற்றும் Prometheus

Prometheus என்பது ஒரு திறந்த மூல அமைப்பு கண்காணிப்பு மற்றும் எச்சரிக்கை கருவித்தொகுப்பு, பகுதியாகும் கிளவுட் நேட்டிவ் கம்ப்யூட்டிங் அறக்கட்டளை. பல்வேறு மூலங்களிலிருந்து அளவீடுகளைச் சேகரித்து அவற்றை நேரத் தொடர் தரவுகளாகச் சேமிக்கிறது. தரவைக் காட்சிப்படுத்த நீங்கள் பயன்படுத்தலாம் கிரபனா அல்லது Kubernetes API உடன் வேலை செய்யும் பிற காட்சிப்படுத்தல் கருவிகள்.

KEDA ஸ்கேலர் என்ற கருத்தை ஆதரிக்கிறது - இது KEDA மற்றும் வெளிப்புற அமைப்புக்கு இடையே ஒரு பாலமாக செயல்படுகிறது. ஸ்கேலர் செயல்படுத்தல் ஒவ்வொரு இலக்கு அமைப்புக்கும் குறிப்பிட்டது மற்றும் அதிலிருந்து தரவைப் பிரித்தெடுக்கிறது. KEDA பின்னர் தானியங்கி அளவிடுதலைக் கட்டுப்படுத்த அவற்றைப் பயன்படுத்துகிறது.

ஸ்கேலர்கள் பல தரவு மூலங்களை ஆதரிக்கின்றன, எடுத்துக்காட்டாக, காஃப்கா, ரெடிஸ், ப்ரோமிதியஸ். அதாவது, ப்ரோமிதியஸ் அளவீடுகளை அளவுகோலாகப் பயன்படுத்தி தானாகவே குபெர்னெட்ஸ் வரிசைப்படுத்தல்களை அளவிட KEDA ஐப் பயன்படுத்தலாம்.

சோதனை விண்ணப்பம்

Golang சோதனை பயன்பாடு HTTP வழியாக அணுகலை வழங்குகிறது மற்றும் இரண்டு முக்கியமான செயல்பாடுகளை செய்கிறது:

1. ப்ரோமிதியஸ் கோ கிளையன்ட் லைப்ரரியைப் பயன்படுத்தி பயன்பாட்டைக் கருவியாக்குகிறது மற்றும் ஹிட் எண்ணிக்கையைக் கொண்டிருக்கும் http_requests மெட்ரிக்கை வழங்குகிறது. ப்ரோமிதியஸ் அளவீடுகள் கிடைக்கும் இறுதிப்புள்ளி URI இல் அமைந்துள்ளது /metrics.

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

2. ஒரு கோரிக்கைக்கு பதில் 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, இது Prometheus சேவையகத்தை பயன்பாட்டு அளவீடுகளைப் பெற அனுமதிக்கிறது.

இங்கே பயன்பாட்டிற்கான வரிசைப்படுத்தல் வெளிப்பாடு.

ப்ரோமிதியஸ் சர்வர்

ப்ரோமிதியஸ் வரிசைப்படுத்தல் அறிக்கை பின்வருவனவற்றைக் கொண்டுள்ளது:

• ConfigMap - ப்ரோமிதியஸ் கட்டமைப்பை மாற்ற;
• Deployment - ஒரு குபெர்னெட்ஸ் கிளஸ்டரில் ப்ரோமிதியஸை நிலைநிறுத்துவதற்காக;
• ClusterIP - UI Prometheus ஐ அணுகுவதற்கான சேவை;
• ClusterRole, ClusterRoleBinding и ServiceAccount - குபெர்னெட்டஸில் உள்ள சேவைகளை தானாகக் கண்டறிவதற்காக (தானியங்கு கண்டுபிடிப்பு).

இங்கே ப்ரோமிதியஸை இயக்குவதற்கான வெளிப்பாடு.

KEDA Prometheus ScaledObject

ஸ்கேலர் 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]))

பின்வரும் புள்ளிகளைக் கவனியுங்கள்:

1. அவர் சுட்டிக்காட்டுகிறார் Deployment பெயருடன் go-prom-app.
2. தூண்டுதல் வகை - Prometheus. ப்ரோமிதியஸ் சேவையக முகவரி மெட்ரிக் பெயர், த்ரெஷோல்ட் மற்றும் உடன் குறிப்பிடப்பட்டுள்ளது PromQL வினவல், இது பயன்படுத்தப்படும். PromQL வினவல் - sum(rate(http_requests[2m])).
3. படி pollingInterval, KEDA ஒவ்வொரு பதினைந்து வினாடிக்கும் ப்ரோமிதியஸிடம் ஒரு இலக்கைக் கோருகிறது. குறைந்தது ஒரு கீழ் (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/

நிறுவ kubectlகுபெர்னெட்ஸ் கிளஸ்டரை அணுக.

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 ஐப் பயன்படுத்துகிறார், இதற்கு டில்லர் சர்வர் கூறு நிறுவப்பட வேண்டும். இப்போது ஹெல்ம்@3 பொருத்தமானது, அதற்கு சர்வர் பகுதி தேவையில்லை.

ஹெல்மை நிறுவிய பிறகு, ரெடிஸைத் தொடங்க ஒரு கட்டளை போதும்:

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

ஒரு ப்ரோமிதியஸ் சேவையகத்தைப் பயன்படுத்துதல்

ப்ரோமிதியஸ் மேனிஃபெஸ்ட் பயன்படுத்துகிறது Prometheus க்கான குபெர்னெட்டஸ் சேவை கண்டுபிடிப்பு. இது சேவை லேபிளின் அடிப்படையில் பயன்பாட்டு பாட்களை மாறும் கண்டுபிடிப்பை அனுமதிக்கிறது.

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

இதற்கான பயன்பாட்டையும் நீங்கள் பதிவிறக்கலாம் லினக்ஸ் அல்லது விண்டோஸ்.

அதை ஓட்டு:

./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 வரிசைப்படுத்தலை அளவிடுவதையும் புதிய காய்களை அறிமுகப்படுத்துவதையும் நீங்கள் காண்பீர்கள். உறுதிசெய்ய உங்கள் 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 உங்களை அனுமதிக்கிறது. எடுத்துக்காட்டாக, ப்ரோமிதியஸ் அளவீடுகளின் அடிப்படையில், ரெடிஸில் வரிசை நீளம், காஃப்கா தலைப்பில் நுகர்வோர் தாமதம்.

KEDA ஒரு வெளிப்புற மூலத்துடன் ஒருங்கிணைக்கிறது மற்றும் அதன் அளவீடுகளை Metrics Server மூலம் Horizontal Pod Autoscalerக்கு வழங்குகிறது.

நல்ல அதிர்ஷ்டம்!

வேறு என்ன படிக்க வேண்டும்:

1. உற்பத்திச் சூழல்களில் கொள்கலன்கள் மற்றும் குபெர்னெட்களை இயக்குவதற்கான சிறந்த நடைமுறைகள் மற்றும் சிறந்த நடைமுறைகள்.
2. 90+ குபெர்னெட்களுக்கான பயனுள்ள கருவிகள்: வரிசைப்படுத்தல், மேலாண்மை, கண்காணிப்பு, பாதுகாப்பு மற்றும் பல.
3. Telegram இல் Kubernetes சுற்றி எங்கள் சேனல்.

ஆதாரம்: www.habr.com