ప్రోమేతియస్ మరియు KEDAని ఉపయోగించి ఆటోస్కేలింగ్ కుబెర్నెటెస్ అప్లికేషన్‌లు

Cimuanos ద్వారా బెలూన్ మ్యాన్

క్లౌడ్ అప్లికేషన్‌లకు స్కేలబిలిటీ ఒక కీలకమైన అవసరం. కుబెర్నెటెస్‌తో, అనువర్తనాన్ని స్కేలింగ్ చేయడం అనేది తగిన విస్తరణ కోసం ప్రతిరూపాల సంఖ్యను పెంచడం లేదా ReplicaSet - కానీ ఇది మాన్యువల్ ప్రక్రియ.

కుబెర్నెటెస్ అప్లికేషన్‌లను స్వయంచాలకంగా స్కేల్ చేయడానికి అనుమతిస్తుంది (అనగా విస్తరణలో పాడ్‌లు లేదా ReplicaSet) హారిజాంటల్ పాడ్ ఆటోస్కేలర్ స్పెసిఫికేషన్‌ని ఉపయోగించి డిక్లరేటివ్ పద్ధతిలో. ఆటోమేటిక్ స్కేలింగ్ కోసం డిఫాల్ట్ ప్రమాణం CPU వినియోగ కొలమానాలు (రిసోర్స్ మెట్రిక్స్), కానీ మీరు అనుకూల మరియు బాహ్యంగా అందించిన కొలమానాలను ఏకీకృతం చేయవచ్చు.

జట్టు Mail.ru నుండి Kubernetes aaS Kubernetes అప్లికేషన్‌ను స్వయంచాలకంగా స్కేల్ చేయడానికి బాహ్య కొలమానాలను ఎలా ఉపయోగించాలో అనే కథనాన్ని అనువదించారు. ప్రతిదీ ఎలా పని చేస్తుందో చూపించడానికి, రచయిత HTTP యాక్సెస్ అభ్యర్థన కొలమానాలను ఉపయోగిస్తాడు, వీటిని ప్రోమేథియస్ ఉపయోగించి సేకరించారు.

పాడ్‌ల క్షితిజ సమాంతర ఆటోస్కేలింగ్‌కు బదులుగా, కుబెర్నెటెస్ ఈవెంట్ డ్రైవెన్ ఆటోస్కేలింగ్ (కెఇడిఎ) ఉపయోగించబడుతుంది, ఇది ఓపెన్ సోర్స్ కుబెర్నెట్స్ ఆపరేటర్. ఈవెంట్-డ్రైవెన్ వర్క్‌లోడ్‌ల కోసం అతుకులు లేని ఆటోస్కేలింగ్ (సున్నా నుండి/సున్నా వరకు) అందించడానికి ఇది క్షితిజసమాంతర పాడ్ ఆటోస్కేలర్‌తో స్థానికంగా అనుసంధానించబడుతుంది. కోడ్ అందుబాటులో ఉంది గ్యాలరీలు.

సిస్టమ్ యొక్క సంక్షిప్త అవలోకనం

రేఖాచిత్రం ప్రతిదీ ఎలా పని చేస్తుందో సంక్షిప్త వివరణను చూపుతుంది:

1. అప్లికేషన్ ప్రోమేథియస్ ఫార్మాట్‌లో HTTP హిట్ కౌంట్ మెట్రిక్‌లను అందిస్తుంది.
2. ఈ కొలమానాలను సేకరించడానికి ప్రోమేతియస్ కాన్ఫిగర్ చేయబడింది.
3. KEDAలోని ప్రోమెథియస్ స్కేలర్ HTTP హిట్‌ల సంఖ్య ఆధారంగా అప్లికేషన్‌ను స్వయంచాలకంగా స్కేల్ చేయడానికి కాన్ఫిగర్ చేయబడింది.

ఇప్పుడు నేను ప్రతి మూలకం గురించి మీకు వివరంగా చెబుతాను.

KEDA మరియు ప్రోమేతియస్

ప్రోమేతియస్ అనేది ఓపెన్ సోర్స్ సిస్టమ్ పర్యవేక్షణ మరియు హెచ్చరిక టూల్‌కిట్, భాగం క్లౌడ్ స్థానిక కంప్యూటింగ్ ఫౌండేషన్. వివిధ మూలాల నుండి కొలమానాలను సేకరిస్తుంది మరియు వాటిని సమయ శ్రేణి డేటాగా నిల్వ చేస్తుంది. డేటాను దృశ్యమానం చేయడానికి మీరు ఉపయోగించవచ్చు గ్రాఫనా లేదా Kubernetes APIతో పని చేసే ఇతర విజువలైజేషన్ సాధనాలు.

KEDA స్కేలర్ భావనకు మద్దతు ఇస్తుంది - ఇది KEDA మరియు బాహ్య వ్యవస్థ మధ్య వంతెనగా పనిచేస్తుంది. స్కేలర్ అమలు ప్రతి లక్ష్య వ్యవస్థకు నిర్దిష్టంగా ఉంటుంది మరియు దాని నుండి డేటాను సంగ్రహిస్తుంది. KEDA ఆటోమేటిక్ స్కేలింగ్‌ని నియంత్రించడానికి వాటిని ఉపయోగిస్తుంది.

స్కేలర్లు బహుళ డేటా మూలాలకు మద్దతు ఇస్తాయి, ఉదాహరణకు, కాఫ్కా, రెడిస్, ప్రోమేథియస్. అంటే, ప్రోమెథియస్ మెట్రిక్‌లను ప్రమాణంగా ఉపయోగించి స్వయంచాలకంగా కుబెర్నెట్స్ విస్తరణలను స్కేల్ చేయడానికి KEDAని ఉపయోగించవచ్చు.

పరీక్ష అప్లికేషన్

గోలాంగ్ టెస్ట్ అప్లికేషన్ HTTP ద్వారా యాక్సెస్‌ను అందిస్తుంది మరియు రెండు ముఖ్యమైన విధులను నిర్వహిస్తుంది:

1. అప్లికేషన్‌ను ఇన్‌స్ట్రుమెంట్ చేయడానికి మరియు హిట్ కౌంట్‌ని కలిగి ఉన్న http_requests మెట్రిక్‌ని అందించడానికి Prometheus Go క్లయింట్ లైబ్రరీని ఉపయోగిస్తుంది. ప్రోమేతియస్ కొలమానాలు అందుబాటులో ఉన్న ముగింపు స్థానం URI వద్ద ఉంది /metrics.

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

2. ఒక అభ్యర్థనకు ప్రతిస్పందనగా GET అప్లికేషన్ కీ విలువను పెంచుతుంది (access_count) Redis లో. ఇది HTTP హ్యాండ్లర్‌లో భాగంగా పని చేయడానికి సులభమైన మార్గం మరియు ప్రోమేతియస్ మెట్రిక్‌లను కూడా తనిఖీ చేస్తుంది. మెట్రిక్ విలువ తప్పనిసరిగా విలువతో సమానంగా ఉండాలి 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, ఇది ప్రోమేతియస్ సర్వర్ అప్లికేషన్ మెట్రిక్‌లను పొందేందుకు అనుమతిస్తుంది.

ఇక్కడ అప్లికేషన్ కోసం విస్తరణ మానిఫెస్ట్.

ప్రోమేతియస్ సర్వర్

ప్రోమేతియస్ విస్తరణ మానిఫెస్ట్ వీటిని కలిగి ఉంటుంది:

• ConfigMap - ప్రోమేతియస్ కాన్ఫిగరేషన్‌ను బదిలీ చేయడానికి;
• Deployment - కుబెర్నెటీస్ క్లస్టర్‌లో ప్రోమేతియస్‌ని మోహరించడం కోసం;
• ClusterIP - UI ప్రోమేతియస్ యాక్సెస్ కోసం సేవ;
• ClusterRole, ClusterRoleBinding и ServiceAccount — కుబెర్నెటెస్‌లోని సేవలను స్వయంచాలకంగా గుర్తించడం కోసం (ఆటో-డిస్కవరీ).

ఇక్కడ ప్రోమేతియస్‌ను అమలు చేయడానికి మానిఫెస్ట్.

KEDA ప్రోమేతియస్ స్కేల్డ్ ఆబ్జెక్ట్

స్కేలర్ 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

టిల్లర్ పాడ్ రన్నింగ్ స్టేట్‌లోకి ప్రవేశించే వరకు వేచి ఉండండి.

అనువాదకుని గమనిక: రచయిత Helm@2ని ఉపయోగిస్తున్నారు, దీనికి Tiller సర్వర్ కాంపోనెంట్ ఇన్‌స్టాల్ చేయబడాలి. ఇప్పుడు హెల్మ్@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

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 వద్ద ప్రోమేతియస్ యూజర్ ఇంటర్‌ఫేస్ (లేదా 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

ఈ సమయంలో 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

మీరు యుటిలిటీని కూడా డౌన్‌లోడ్ చేసుకోవచ్చు linux లేదా విండోస్.

దీన్ని అమలు:

./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 బాహ్య కొలమానాల నుండి డేటా ఆధారంగా మీ కుబెర్నెట్స్ విస్తరణలను (సున్నాకి/నుండి) స్వయంచాలకంగా స్కేల్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణకు, ప్రోమేతియస్ మెట్రిక్స్, రెడిస్‌లో క్యూ పొడవు, కాఫ్కా టాపిక్‌లో వినియోగదారు జాప్యం ఆధారంగా.

KEDA బాహ్య సోర్స్‌తో అనుసంధానం చేస్తుంది మరియు మెట్రిక్స్ సర్వర్ ద్వారా క్షితిజసమాంతర పాడ్ ఆటోస్కేలర్‌కు దాని కొలమానాలను కూడా అందిస్తుంది.

గుడ్ లక్!

ఇంకా ఏమి చదవాలి:

1. ఉత్పత్తి పరిసరాలలో కంటైనర్లు మరియు కుబెర్నెట్‌లను అమలు చేయడానికి ఉత్తమ పద్ధతులు మరియు ఉత్తమ పద్ధతులు.
2. Kubernetes కోసం 90+ ఉపయోగకరమైన సాధనాలు: విస్తరణ, నిర్వహణ, పర్యవేక్షణ, భద్రత మరియు మరిన్ని.
3. టెలిగ్రామ్‌లో కుబెర్నెట్స్ చుట్టూ ఉన్న మా ఛానెల్.

మూలం: www.habr.com