Prometheus, KEDA എന്നിവയ്‌ക്കൊപ്പമുള്ള ഓട്ടോസ്‌കേലിംഗ് കുബർനെറ്റസ് ആപ്ലിക്കേഷനുകൾ

സിമുവാനോസിന്റെ ബലൂൺ മാൻ

ക്ലൗഡ് ആപ്ലിക്കേഷനുകൾക്കുള്ള പ്രധാന ആവശ്യകതയാണ് സ്കേലബിളിറ്റി. കുബെർനെറ്റസ് ഉപയോഗിച്ച്, ഒരു ആപ്ലിക്കേഷൻ സ്കെയിൽ ചെയ്യുന്നത് ഉചിതമായ വിന്യാസത്തിനോ അല്ലെങ്കിൽ ReplicaSet - എന്നാൽ ഇത് ഒരു മാനുവൽ പ്രക്രിയയാണ്.

കുബെർനെറ്റസ് ആപ്ലിക്കേഷനുകൾ സ്വയമേവ സ്കെയിൽ ചെയ്യാൻ അനുവദിക്കുന്നു (അതായത് ഒരു വിന്യാസത്തിലെ പോഡുകൾ അല്ലെങ്കിൽ ReplicaSet) ഹൊറിസോണ്ടൽ പോഡ് ഓട്ടോസ്കെയിലർ സ്പെസിഫിക്കേഷൻ ഉപയോഗിച്ച് ഒരു ഡിക്ലറേറ്റീവ് രീതിയിൽ. ഓട്ടോമാറ്റിക് സ്കെയിലിംഗിന്റെ ഡിഫോൾട്ട് മാനദണ്ഡം CPU ഉപയോഗ മെട്രിക്‌സ് ആണ് (റിസോഴ്‌സ് മെട്രിക്‌സ്), എന്നാൽ നിങ്ങൾക്ക് ഇഷ്ടാനുസൃതവും ബാഹ്യമായി നൽകിയതുമായ മെട്രിക്‌സ് സമന്വയിപ്പിക്കാൻ കഴിയും.

ടീം Mail.ru-ൽ നിന്ന് Kubernetes aaS ഒരു കുബർനെറ്റസ് ആപ്ലിക്കേഷൻ സ്വയമേവ സ്കെയിൽ ചെയ്യുന്നതിന് ബാഹ്യ അളവുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ചുള്ള ഒരു ലേഖനം വിവർത്തനം ചെയ്തു. എല്ലാം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണിക്കാൻ, രചയിതാവ് HTTP ആക്സസ് അഭ്യർത്ഥന മെട്രിക്സ് ഉപയോഗിക്കുന്നു, അവ പ്രോമിത്യൂസ് ഉപയോഗിച്ച് ശേഖരിക്കുന്നു.

പോഡുകളുടെ തിരശ്ചീന ഓട്ടോസ്‌കേലിംഗിന് പകരം, ഓപ്പൺ സോഴ്‌സ് കുബർനെറ്റസ് ഓപ്പറേറ്ററായ കുബർനെറ്റസ് ഇവന്റ് ഡ്രൈവൺ ഓട്ടോസ്‌കേലിംഗ് (കെഇഡിഎ) ഉപയോഗിക്കുന്നു. ഇവന്റ്-ഡ്രൈവ് വർക്ക് ലോഡുകൾക്ക് തടസ്സമില്ലാത്ത ഓട്ടോസ്‌കേലിംഗ് (പൂജ്യം ഉൾപ്പെടെ/മുതൽ) നൽകുന്നതിന് ഇത് ഹോറിസോണ്ടൽ പോഡ് ഓട്ടോസ്‌കെയിലറുമായി നേറ്റീവ് ആയി സംയോജിപ്പിക്കുന്നു. കോഡ് ഇവിടെ ലഭ്യമാണ് സാമൂഹികം.

സിസ്റ്റത്തിന്റെ ഹ്രസ്വ അവലോകനം

എല്ലാം എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു ഹ്രസ്വ വിവരണം ഡയഗ്രം കാണിക്കുന്നു:

1. ആപ്ലിക്കേഷൻ പ്രോമിത്യൂസ് ഫോർമാറ്റിൽ HTTP ഹിറ്റ് കൗണ്ട് മെട്രിക്സ് നൽകുന്നു.
2. ഈ അളവുകൾ ശേഖരിക്കുന്നതിനായി പ്രോമിത്യൂസ് കോൺഫിഗർ ചെയ്‌തിരിക്കുന്നു.
3. HTTP ഹിറ്റുകളുടെ എണ്ണത്തെ അടിസ്ഥാനമാക്കി ആപ്ലിക്കേഷൻ സ്വയമേവ സ്കെയിൽ ചെയ്യുന്നതിനായി KEDA-യിലെ പ്രോമിത്യൂസ് സ്കെയിലർ ക്രമീകരിച്ചിരിക്കുന്നു.

ഇപ്പോൾ ഞാൻ ഓരോ ഘടകത്തെക്കുറിച്ചും വിശദമായി പറയാം.

കെഇഡിഎയും പ്രൊമിത്യൂസും

പ്രൊമിത്യൂസ് ഒരു ഓപ്പൺ സോഴ്സ് സിസ്റ്റം മോണിറ്ററിംഗ് ആൻഡ് അലേർട്ടിംഗ് ടൂൾകിറ്റ് ആണ്, ഭാഗം ക്ലൗഡ് നേറ്റീവ് കമ്പ്യൂട്ടിംഗ് ഫ .ണ്ടേഷൻ. വിവിധ സ്രോതസ്സുകളിൽ നിന്ന് അളവുകൾ ശേഖരിക്കുകയും അവയെ സമയ ശ്രേണി ഡാറ്റയായി സംഭരിക്കുകയും ചെയ്യുന്നു. ഡാറ്റ ദൃശ്യവൽക്കരിക്കുന്നതിന് നിങ്ങൾക്ക് ഉപയോഗിക്കാം ഗ്രാഫാന അല്ലെങ്കിൽ Kubernetes API-യിൽ പ്രവർത്തിക്കുന്ന മറ്റ് വിഷ്വലൈസേഷൻ ടൂളുകൾ.

KEDA ഒരു സ്കെയിലർ എന്ന ആശയത്തെ പിന്തുണയ്ക്കുന്നു - ഇത് KEDA യ്ക്കും ബാഹ്യ സംവിധാനത്തിനും ഇടയിലുള്ള ഒരു പാലമായി പ്രവർത്തിക്കുന്നു. സ്കെയിലർ നടപ്പിലാക്കൽ ഓരോ ടാർഗെറ്റ് സിസ്റ്റത്തിനും പ്രത്യേകമാണ്, അതിൽ നിന്ന് ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നു. ഓട്ടോമാറ്റിക് സ്കെയിലിംഗ് നിയന്ത്രിക്കാൻ KEDA പിന്നീട് അവ ഉപയോഗിക്കുന്നു.

സ്കെയിലറുകൾ ഒന്നിലധികം ഡാറ്റ ഉറവിടങ്ങളെ പിന്തുണയ്ക്കുന്നു, ഉദാഹരണത്തിന്, കാഫ്ക, റെഡിസ്, പ്രോമിത്യൂസ്. അതായത്, പ്രോമിത്യൂസ് മെട്രിക്‌സ് മാനദണ്ഡമായി ഉപയോഗിച്ച് കുബർനെറ്റസ് വിന്യാസങ്ങൾ സ്വയമേവ സ്കെയിൽ ചെയ്യാൻ KEDA ഉപയോഗിക്കാം.

ടെസ്റ്റ് ആപ്ലിക്കേഷൻ

Golang ടെസ്റ്റ് ആപ്ലിക്കേഷൻ HTTP വഴി ആക്സസ് നൽകുകയും രണ്ട് പ്രധാന പ്രവർത്തനങ്ങൾ നിർവഹിക്കുകയും ചെയ്യുന്നു:

1. ആപ്ലിക്കേഷൻ ഇൻസ്ട്രുമെന്റ് ചെയ്യാനും ഹിറ്റ് കൗണ്ട് അടങ്ങുന്ന http_requests മെട്രിക് നൽകാനും Prometheus Go ക്ലയന്റ് ലൈബ്രറി ഉപയോഗിക്കുന്നു. പ്രോമിത്യൂസ് മെട്രിക്‌സ് ലഭ്യമായ എൻഡ്‌പോയിന്റ് യുആർഐയിലാണ് /metrics.

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

2. ഒരു അഭ്യർത്ഥനയ്ക്ക് മറുപടിയായി GET ആപ്ലിക്കേഷൻ കീയുടെ മൂല്യം വർദ്ധിപ്പിക്കുന്നു (access_count) റെഡിസിൽ. ഒരു എച്ച്ടിടിപി ഹാൻഡ്‌ലറിന്റെ ഭാഗമായി ജോലി ചെയ്യാനുള്ള എളുപ്പവഴിയാണിത്, കൂടാതെ പ്രോമിത്യൂസ് മെട്രിക്‌സ് പരിശോധിക്കുക. മെട്രിക് മൂല്യം മൂല്യത്തിന് തുല്യമായിരിക്കണം 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 - കുബർനെറ്റസിലെ സേവനങ്ങൾ സ്വയമേവ കണ്ടെത്തുന്നതിന് (ഓട്ടോ-കണ്ടെത്തൽ).

ഇവിടെ പ്രൊമിത്യൂസിനെ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള പ്രകടനമാണ്.

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 പൂജ്യത്തിന് തുല്യം. ഈ സാഹചര്യത്തിൽ, കെ‌ഇ‌ഡി‌എ സീറോ-ടു-വൺ വിന്യാസം സജീവമാക്കുകയും തുടർന്ന് കൂടുതൽ ഓട്ടോമാറ്റിക് സ്‌കെയിലിംഗിനായി എച്ച്‌പി‌എ വെളിപ്പെടുത്തുകയും ചെയ്യുന്നു. വിപരീത ക്രമവും സാധ്യമാണ്, അതായത് ഒന്നിൽ നിന്ന് പൂജ്യത്തിലേക്ക് സ്കെയിലിംഗ്. ഉദാഹരണത്തിൽ, ഞങ്ങൾ പൂജ്യം തിരഞ്ഞെടുത്തില്ല, കാരണം ഇതൊരു 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/

ഇൻസ്റ്റാൾ ചെയ്യുക കുബെക്ലികുബർനെറ്റസ് ക്ലസ്റ്ററിലേക്ക് പ്രവേശിക്കാൻ.

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. പരിശോധിക്കാനുള്ള കമാൻഡ്:

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 ഉപയോഗിക്കുന്നു, ഇതിന് ടില്ലർ സെർവർ ഘടകം ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. ഇപ്പോൾ Helm@3 പ്രസക്തമാണ്, അതിന് ഒരു സെർവർ ഭാഗം ആവശ്യമില്ല.

Helm ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, Redis ആരംഭിക്കാൻ ഒരു കമാൻഡ് മതി:

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 പ്രോമിത്യൂസ് ഉപയോക്തൃ ഇന്റർഫേസ് (അല്ലെങ്കിൽ 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 അഭ്യർത്ഥനകൾ അയയ്ക്കുന്നു. പ്രോമിത്യൂസ് മെട്രിക്‌സും റെഡിസും ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് സ്ഥിരീകരിക്കാനാകും.

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 നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, പ്രോമിത്യൂസ് മെട്രിക്‌സ്, റെഡിസിലെ ക്യൂ ദൈർഘ്യം, കാഫ്ക വിഷയത്തിലെ ഉപഭോക്തൃ ലേറ്റൻസി എന്നിവയെ അടിസ്ഥാനമാക്കി.

കെ‌ഇ‌ഡി‌എ ഒരു ബാഹ്യ ഉറവിടവുമായി സംയോജിപ്പിക്കുകയും അതിന്റെ മെട്രിക്‌സ് മെട്രിക്‌സ് സെർവർ വഴി ഹോറിസോണ്ടൽ പോഡ് ഓട്ടോസ്‌കേലറിലേക്ക് നൽകുകയും ചെയ്യുന്നു.

ഗുഡ് ലക്ക്!

മറ്റെന്താണ് വായിക്കേണ്ടത്:

1. ഉൽപ്പാദന പരിതസ്ഥിതിയിൽ കണ്ടെയ്‌നറുകളും കുബർനെറ്റുകളും പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള മികച്ച രീതികളും മികച്ച രീതികളും.
2. 90+ കുബർനെറ്റുകൾക്കുള്ള ഉപയോഗപ്രദമായ ഉപകരണങ്ങൾ: വിന്യാസം, മാനേജ്മെന്റ്, നിരീക്ഷണം, സുരക്ഷ എന്നിവയും അതിലേറെയും.
3. ടെലിഗ്രാമിലെ ഞങ്ങളുടെ ചാനൽ കുബെർനെറ്റസിന് ചുറ്റും.

അവലംബം: www.habr.com