Kubernetes lietojumprogrammu automātiskā mērogošana, izmantojot Prometheus un KEDA

Cimuanos balonu cilvēks

Mērogojamība ir galvenā prasība mākoņa lietojumprogrammām. Izmantojot Kubernetes, lietojumprogrammas mērogošana ir tikpat vienkārša kā reprodukciju skaita palielināšana atbilstošai izvietošanai vai ReplicaSet — bet tas ir manuāls process.

Kubernetes ļauj automātiski mērogot lietojumprogrammas (t.i., Pods izvietošanas vai ReplicaSet) deklaratīvā veidā, izmantojot Horizontal Pod Autoscaler specifikāciju. Automātiskās mērogošanas noklusējuma kritērijs ir CPU lietojuma metrika (resursu metrika), taču varat integrēt pielāgotu un ārēji nodrošinātu metriku.

Komanda Kubernetes aaS no Mail.ru iztulkoja rakstu par to, kā izmantot ārējos rādītājus, lai automātiski mērogotu lietojumprogrammu Kubernetes. Lai parādītu, kā viss darbojas, autors izmanto HTTP piekļuves pieprasījumu metriku, kas tiek apkopota, izmantojot Prometheus.

Pods horizontālās automātiskās mērogošanas vietā tiek izmantota Kubernetes Event Driven Autoscaling (KEDA) — atvērtā koda Kubernetes operators. Tas sākotnēji tiek integrēts ar Horizontal Pod Autoscaler, lai nodrošinātu netraucētu automātisko mērogošanu (tostarp uz/no nulles) notikuma izraisītām darba slodzēm. Kods pieejams plkst GitHub.

Īss pārskats par sistēmu

Diagrammā parādīts īss apraksts par to, kā viss darbojas:

1. Lietojumprogramma nodrošina HTTP trāpījumu skaita metriku Prometheus formātā.
2. Prometheus ir konfigurēts, lai apkopotu šos rādītājus.
3. KEDA Prometheus mērogotājs ir konfigurēts, lai automātiski mērogotu lietojumprogrammu, pamatojoties uz HTTP trāpījumu skaitu.

Tagad es jums pastāstīšu sīkāk par katru elementu.

KEDA un Prometejs

Prometheus ir atvērtā koda sistēmas uzraudzības un brīdināšanas rīku komplekta daļa Mākoņu vietējās skaitļošanas fonds. Apkopo metriku no dažādiem avotiem un saglabā tos kā laikrindu datus. Lai vizualizētu datus, varat izmantot grafana vai citi vizualizācijas rīki, kas darbojas ar Kubernetes API.

KEDA atbalsta skalera koncepciju – tas darbojas kā tilts starp KEDA un ārējo sistēmu. Mērogošanas ieviešana ir specifiska katrai mērķa sistēmai un iegūst datus no tās. Pēc tam KEDA tos izmanto, lai kontrolētu automātisko mērogošanu.

Mērogotāji atbalsta vairākus datu avotus, piemēram, Kafka, Redis, Prometheus. Tas nozīmē, ka KEDA var izmantot, lai automātiski mērogotu Kubernetes izvietojumus, kā kritērijus izmantojot Prometheus metriku.

Testa lietojumprogramma

Golang testa lietojumprogramma nodrošina piekļuvi, izmantojot HTTP, un veic divas svarīgas funkcijas:

1. Izmanto Prometheus Go klienta bibliotēku, lai instrumentētu lietojumprogrammu un nodrošinātu http_requests metriku, kurā ir ietverts trāpījumu skaits. Galapunkts, kurā ir pieejama Prometheus metrika, atrodas URI /metrics.

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

2. Atbildot uz pieprasījumu GET lietojumprogramma palielina atslēgas vērtību (access_count) Redis. Tas ir vienkāršs veids, kā veikt darbu kā HTTP apdarinātāja daļu, kā arī pārbaudīt Prometheus metriku. Metrikas vērtībai ir jābūt tādai pašai kā vērtībai access_count iekš 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)
      }
   

Lietojumprogramma tiek izvietota Kubernetes, izmantojot Deployment. Tiek izveidots arī pakalpojums ClusterIP, tas ļauj Prometheus serverim iegūt lietojumprogrammu rādītājus.

šeit ir lietojumprogrammas izvietošanas manifests.

Prometheus serveris

Prometheus izvietošanas manifests sastāv no:

• ConfigMap — pārsūtīt Prometheus konfigurāciju;
• Deployment — par Prometheus izvietošanu Kubernetes klasterī;
• ClusterIP — pakalpojums piekļuvei UI Prometheus;
• ClusterRole, ClusterRoleBinding и ServiceAccount — Kubernetes pakalpojumu automātiskai noteikšanai (automātiskā atklāšana).

šeit ir manifests Prometheus palaišanai.

KEDA Prometheus ScaledObject

Mērogs darbojas kā tilts starp KEDA un ārējo sistēmu, no kuras ir jāiegūst metrika. ScaledObject ir pielāgots resurss, kas ir jāizvieto, lai sinhronizētu izvietošanu ar notikuma avotu, šajā gadījumā ar Prometheus.

ScaledObject satur izvietošanas mērogošanas informāciju, notikumu avota metadatus (piemēram, savienojuma noslēpumus, rindas nosaukumu), aptaujas intervālu, atkopšanas periodu un citus datus. Tā rezultātā tiek iegūts atbilstošs automātiskās mērogošanas resurss (HPA definīcija), lai mērogotu izvietošanu.

Kad objekts ScaledObject tiek dzēsta, atbilstošā HPA definīcija tiek dzēsta.

Lūk, definīcija ScaledObject mūsu piemēram, tas izmanto mērogotāju 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]))

Apsveriet šādus punktus:

1. Viņš norāda uz Deployment Ar nosaukumu go-prom-app.
2. Trigera veids — Prometheus. Prometheus servera adrese ir minēta kopā ar metrikas nosaukumu, slieksni un PromQL vaicājums, kas tiks izmantots. PromQL vaicājums — sum(rate(http_requests[2m])).
3. Saskaņā ar pollingIntervalKEDA pieprasa mērķi no Prometheus ik pēc piecpadsmit sekundēm. Vismaz viens zem (minReplicaCount), un maksimālais pāksts skaits nepārsniedz maxReplicaCount (šajā piemērā - desmit).

Var uzstādīt minReplicaCount vienāds ar nulli. Šādā gadījumā KEDA aktivizē nulles pret vienu izvietošanu un pēc tam pakļauj HPA turpmākai automātiskai mērogošana. Ir iespējama arī apgrieztā secība, tas ir, mērogošana no viena līdz nullei. Piemērā mēs neatlasījām nulli, jo šis ir HTTP pakalpojums, nevis sistēma pēc pieprasījuma.

Maģija iekšā automātiskā mērogošana

Slieksnis tiek izmantots kā aktivizētājs, lai mērogotu izvietošanu. Mūsu piemērā PromQL vaicājums sum(rate (http_requests [2m])) atgriež apkopoto HTTP pieprasījumu ātrumu (pieprasījumi sekundē), kas mērīts pēdējo divu minūšu laikā.

Tā kā sliekšņa vērtība ir trīs, tas nozīmē, ka vērtība būs mazāka par vienu sum(rate (http_requests [2m])) mazāk par trim. Ja vērtība palielinās, katru reizi tiek pievienota papildu apakšdaļa sum(rate (http_requests [2m])) palielinās par trim. Piemēram, ja vērtība ir no 12 līdz 14, tad pākstu skaits ir četri.

Tagad mēģināsim to iestatīt!

priekšiestatījums

Viss, kas jums nepieciešams, ir Kubernetes klasteris un konfigurēta utilīta kubectl. Šajā piemērā tiek izmantota kopa minikube, bet jūs varat ņemt jebkuru citu. Lai instalētu klasteru, ir vadība.

Instalējiet jaunāko versiju Mac datorā:

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/

Komplekts kubectllai piekļūtu Kubernetes klasterim.

Instalējiet jaunāko versiju Mac datorā:

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 uzstādīšana

Jūs varat izvietot KEDA vairākos veidos, tie ir uzskaitīti dokumentācija. Es izmantoju monolītu YAML:

kubectl apply -f
https://raw.githubusercontent.com/kedacore/keda/master/deploy/KedaScaleController.yaml

KEDA un tās komponenti ir instalēti nosaukumu telpā keda. Komanda, lai pārbaudītu:

kubectl get pods -n keda

Pagaidiet, līdz sāk darboties KEDA operators, un dodieties uz Running State. Un pēc tam turpiniet.

Redis instalēšana, izmantojot Helm

Ja jums nav instalēta Helm, izmantojiet šo vadība. Komanda, lai instalētu operētājsistēmā Mac:

brew install kubernetes-helm
helm init --history-max 200

helm init inicializē vietējo komandrindas saskarni un arī instalē Tiller uz Kubernetes klasteru.

kubectl get pods -n kube-system | grep tiller

Pagaidiet, līdz Tiller pod pāriet režīmā Darbojas.

Tulkotāja piezīme: Autors izmanto Helm@2, kam nepieciešams instalēt Tiller servera komponentu. Tagad Helm@3 ir aktuāls, tam nav nepieciešama servera daļa.

Pēc Helm instalēšanas pietiek ar vienu komandu, lai palaistu Redis:

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

Pārbaudiet, vai Redis ir veiksmīgi startējis:

kubectl get pods/redis-server-master-0

Pagaidiet, līdz Redis pāries stāvoklī Running.

Lietojumprogrammu izvietošana

Izvietošanas komanda:

kubectl apply -f go-app.yaml

//output
deployment.apps/go-prom-app created
service/go-prom-app-service created

Pārbaudiet, vai viss ir sācies:

kubectl get pods -l=app=go-prom-app

Pagaidiet, līdz Redis pāriet stāvoklī Running.

Prometheus servera izvietošana

Prometeja manifesta lietojumi Kubernetes pakalpojuma atklāšana programmai Prometheus. Tas ļauj dinamiski atklāt lietojumprogrammas, pamatojoties uz pakalpojuma etiķeti.

kubernetes_sd_configs:
   - role: service
   relabel_configs:
   - source_labels: [__meta_kubernetes_service_label_run]
     regex: go-prom-app-service
     action: keep

Lai izvietotu:

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

Pārbaudiet, vai viss ir sācies:

kubectl get pods -l=app=prometheus-server

Pagaidiet, kamēr Prometejs ieies stāvoklī Running.

Izmantojiet kubectl port-forward lai piekļūtu Prometheus lietotāja interfeisam (vai API serverim) vietnē http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA automātiskās mērogošanas konfigurācijas izvietošana

Pavēli izveidot ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Pārbaudiet KEDA operatora žurnālus:

KEDA_POD_NAME=$(kubectl get pods -n keda 
-o=jsonpath='{.items[0].metadata.name}')
kubectl logs $KEDA_POD_NAME -n keda

Rezultāts izskatās apmēram šādi:

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"

Pārbaudiet zem pieteikumiem. Vienai instancei ir jādarbojas, jo minReplicaCount vienāds ar 1:

kubectl get pods -l=app=go-prom-app

Pārbaudiet, vai HPA resurss ir izveidots veiksmīgi:

kubectl get hpa

Jums vajadzētu redzēt kaut ko līdzīgu:

NAME                   REFERENCE                TARGETS     MINPODS   MAXPODS   REPLICAS   AGE
keda-hpa-go-prom-app   Deployment/go-prom-app   0/3 (avg)   1         10        1          45s

Veselības pārbaude: piekļuve lietojumprogrammai

Lai piekļūtu mūsu lietojumprogrammas REST galapunktam, palaidiet:

kubectl port-forward service/go-prom-app-service 8080

Tagad varat piekļūt savai lietotnei Go, izmantojot adresi http://localhost:8080. Lai to izdarītu, palaidiet komandu:

curl http://localhost:8080/test

Rezultāts izskatās apmēram šādi:

Accessed on 2019-10-21 11:29:10.560385986 +0000 UTC 
m=+406004.817901246
Access count 1

Šajā brīdī pārbaudiet arī Redis. Jūs redzēsiet, ka atslēga access_count palielināts līdz 1:

kubectl exec -it redis-server-master-0 -- redis-cli get access_count
//output
"1"

Pārliecinieties, vai metrikas vērtība ir http_requests tas pats:

curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests number of http requests
# TYPE http_requests counter
http_requests 1

Slodzes izveide

Mēs izmantosim hey — lietderība slodzes ģenerēšanai:

curl -o hey https://storage.googleapis.com/hey-release/hey_darwin_amd64 
&& chmod a+x hey

Varat arī lejupielādēt utilītu Linux vai Windows.

Palaidiet to:

./hey http://localhost:8080/test

Pēc noklusējuma utilīta nosūta 200 pieprasījumus. To var pārbaudīt, izmantojot Prometheus metriku, kā arī 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

Apstipriniet faktiskās metrikas vērtību (ko atgriež PromQL vaicājums):

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"]}]}}

Šajā gadījumā faktiskais rezultāts ir 1,686057971014493 un tiek parādīts laukā value. Ar to nepietiek, lai mērogotu, jo mūsu iestatītais slieksnis ir 3.

Vairāk slodzes!

Jaunajā terminālī uzraugiet lietojumprogrammu bloku skaitu:

kubectl get pods -l=app=go-prom-app -w

Palielināsim slodzi, izmantojot komandu:

./hey -n 2000 http://localhost:8080/test

Pēc kāda laika jūs redzēsiet, ka HPA mērogos izvietošanu un palaiž jaunas pākstis. Pārbaudiet savu HPA, lai pārliecinātos, ka:

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

Ja slodze ir nekonsekventa, izvietošana tiks samazināta līdz vietai, kurā darbojas tikai viens pods. Ja vēlaties pārbaudīt faktisko metriku (ko atgriež PromQL vaicājums), izmantojiet komandu:

curl -g 
'http://localhost:9090/api/v1/query?query=sum(rate(http_requests[2m]))'

tīrīšana

//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

Secinājums

KEDA ļauj automātiski mērogot jūsu Kubernetes izvietošanu (uz/no nulles), pamatojoties uz datiem no ārējām metrikām. Piemēram, pamatojoties uz Prometheus metriku, rindas garumu Redis, patērētāja latentumu Kafkas tēmā.

KEDA integrējas ar ārēju avotu, kā arī nodrošina savus rādītājus, izmantojot Metrics Server, lai Horizontal Pod Autoscaler.

Veiksmi!

Ko vēl lasīt:

1. Paraugprakse un labākā prakse konteineru un Kubernetes darbināšanai ražošanas vidēs.
2. Vairāk nekā 90 noderīgu rīku Kubernetes: izvietošana, pārvaldība, uzraudzība, drošība un citi.
3. Mūsu kanāls Ap Kubernetes telegrammā.

Avots: www.habr.com