પ્રોમિથિયસ અને KEDA નો ઉપયોગ કરીને કુબરનેટ્સ એપ્લિકેશનને ઓટોસ્કેલિંગ કરવું

સિમુઆનોસ દ્વારા બલૂન મેન

ક્લાઉડ એપ્લીકેશન માટે માપનીયતા એ મુખ્ય આવશ્યકતા છે. કુબરનેટ્સ સાથે, એપ્લિકેશનને સ્કેલિંગ કરવું એ યોગ્ય જમાવટ માટે પ્રતિકૃતિઓની સંખ્યા વધારવા જેટલું સરળ છે અથવા ReplicaSet - પરંતુ તે મેન્યુઅલ પ્રક્રિયા છે.

કુબરનેટ્સ એપ્લીકેશનને આપમેળે માપવા માટે પરવાનગી આપે છે (એટલે ​​​​કે જમાવટમાં પોડ્સ અથવા ReplicaSet) હોરીઝોન્ટલ પોડ ઓટોસ્કેલર સ્પષ્ટીકરણનો ઉપયોગ કરીને ઘોષણાત્મક રીતે. ઓટોમેટિક સ્કેલિંગ માટે ડિફોલ્ટ માપદંડ CPU વપરાશ મેટ્રિક્સ (સંસાધન મેટ્રિક્સ) છે, પરંતુ તમે કસ્ટમ અને બાહ્ય રીતે પ્રદાન કરેલ મેટ્રિક્સને એકીકૃત કરી શકો છો.

ટીમ Mail.ru માંથી કુબરનેટ્સ એએએસ કુબરનેટ્સ એપ્લિકેશનને આપમેળે માપવા માટે બાહ્ય મેટ્રિક્સનો ઉપયોગ કેવી રીતે કરવો તેના લેખનો અનુવાદ કર્યો. બધું કેવી રીતે કાર્ય કરે છે તે બતાવવા માટે, લેખક HTTP ઍક્સેસ વિનંતી મેટ્રિક્સનો ઉપયોગ કરે છે, જે પ્રોમિથિયસનો ઉપયોગ કરીને એકત્રિત કરવામાં આવે છે.

પોડ્સના આડા ઓટોસ્કેલિંગને બદલે, કુબરનેટ્સ ઇવેન્ટ ડ્રિવન ઓટોસ્કેલિંગ (KEDA) નો ઉપયોગ કરવામાં આવે છે, જે એક ઓપન સોર્સ કુબરનેટ્સ ઓપરેટર છે. તે ઘટના-સંચાલિત વર્કલોડ માટે સીમલેસ ઓટોસ્કેલિંગ (શૂન્યથી/શૂન્ય સહિત) પ્રદાન કરવા માટે હોરિઝોન્ટલ પોડ ઓટોસ્કેલર સાથે મૂળ રીતે સંકલિત કરે છે. પર ઉપલબ્ધ કોડ GitHub.

સિસ્ટમની સંક્ષિપ્ત ઝાંખી

આકૃતિ બધું કેવી રીતે કાર્ય કરે છે તેનું સંક્ષિપ્ત વર્ણન બતાવે છે:

1. એપ્લિકેશન પ્રોમિથિયસ ફોર્મેટમાં HTTP હિટ કાઉન્ટ મેટ્રિક્સ પ્રદાન કરે છે.
2. પ્રોમિથિયસ આ મેટ્રિક્સ એકત્રિત કરવા માટે ગોઠવેલ છે.
3. KEDA માં પ્રોમિથિયસ સ્કેલર HTTP હિટની સંખ્યાના આધારે એપ્લિકેશનને આપમેળે માપવા માટે ગોઠવેલ છે.

હવે હું તમને દરેક તત્વ વિશે વિગતવાર જણાવીશ.

કેડા અને પ્રોમિથિયસ

પ્રોમિથિયસ એ ઓપન સોર્સ સિસ્ટમ મોનિટરિંગ અને એલર્ટિંગ ટૂલકિટ છે, ભાગ ક્લાઉડ નેટીવ કમ્પ્યુટિંગ ફાઉન્ડેશન. વિવિધ સ્ત્રોતોમાંથી મેટ્રિક્સ એકત્રિત કરે છે અને તેમને સમય શ્રેણીના ડેટા તરીકે સંગ્રહિત કરે છે. ડેટાની કલ્પના કરવા માટે તમે ઉપયોગ કરી શકો છો ગ્રાફના અથવા અન્ય વિઝ્યુલાઇઝેશન ટૂલ્સ કે જે કુબરનેટ્સ 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) રેડિસમાં. 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 — 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,કેઈડીએ દર પંદર સેકન્ડે પ્રોમિથિયસ પાસેથી લક્ષ્યની વિનંતી કરે છે. ઓછામાં ઓછું એક હેઠળ (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 નો ઉપયોગ કરે છે, જેના માટે ટિલર સર્વર ઘટક ઇન્સ્ટોલ કરવું જરૂરી છે. હવે Helm@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

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

આ બિંદુએ રેડિસ પણ તપાસો. તમે જોશો કે કી 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

વાસ્તવિક મેટ્રિકનું મૂલ્ય માન્ય કરો (પ્રોમક્યુએલ ક્વેરી દ્વારા પરત કરવામાં આવેલ):

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

જો લોડ અસંગત હોય, તો જમાવટ એ બિંદુ સુધી ઘટાડવામાં આવશે જ્યાં માત્ર એક પોડ ચાલી રહ્યું છે. જો તમે વાસ્તવિક મેટ્રિક (પ્રોમક્યુએલ ક્વેરી દ્વારા પરત) તપાસવા માંગતા હોવ, તો આદેશનો ઉપયોગ કરો:

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. કુબરનેટ્સ માટે 90+ ઉપયોગી સાધનો: જમાવટ, સંચાલન, દેખરેખ, સુરક્ષા અને વધુ.
3. ટેલિગ્રામમાં કુબરનેટ્સની આસપાસ અમારી ચેનલ.

સોર્સ: www.habr.com