🥇Rritja automatike e aplikacioneve Kubernetes duke përdorur Prometheus dhe KEDA

Balloon Man nga Cimuanos

Shkallueshmëria është një kërkesë kryesore për aplikacionet cloud. Me Kubernetes, shkallëzimi i një aplikacioni është po aq i thjeshtë sa rritja e numrit të kopjeve për vendosjen e duhur ose ReplicaSet - por është një proces manual.

Kubernetes lejon që aplikacionet të shkallëzohen automatikisht (d.m.th. Pods në një vendosje ose ReplicaSet) në mënyrë deklarative duke përdorur specifikimin Horizontal Pod Autoscaler. Kriteri i parazgjedhur për shkallëzimin automatik është metrika e përdorimit të CPU (metrika e burimeve), por ju mund të integroni metrikë të personalizuar dhe të ofruar nga jashtë.

Ekip Kubernetes aaS nga Mail.ru përktheu një artikull se si të përdorni metrikë të jashtëm për të shkallëzuar automatikisht një aplikacion Kubernetes. Për të treguar se si funksionon gjithçka, autori përdor matjet e kërkesës për qasje në HTTP, të cilat mblidhen duke përdorur Prometheus.

Në vend të shkallëzimit automatik horizontal të pods, përdoret Kubernetes Event Driven Autoscaling (KEDA), një operator Kubernetes me burim të hapur. Ai integrohet në mënyrë origjinale me Horizontal Pod Autoscaler për të ofruar shkallëzim automatik të pandërprerë (duke përfshirë në/nga zero) për ngarkesat e punës të drejtuara nga ngjarjet. Kodi i disponueshëm në GitHub.

Pasqyrë e shkurtër e sistemit

Diagrami tregon një përshkrim të shkurtër se si funksionon gjithçka:

Aplikacioni ofron metrikë të numrit të goditjeve HTTP në formatin Prometheus.
Prometheus është konfiguruar për të mbledhur këto metrikë.
Skalleri Prometheus në KEDA është konfiguruar që të shkallëzojë automatikisht aplikacionin bazuar në numrin e goditjeve HTTP.

Tani do t'ju tregoj në detaje për secilin element.

KEDA dhe Prometeu

Prometheus është një pjesë e veglave të monitorimit dhe sinjalizimit të sistemit me burim të hapur Fondacioni Cloud Native Computing. Mbledh metrika nga burime të ndryshme dhe i ruan ato si të dhëna të serive kohore. Për të vizualizuar të dhënat që mund të përdorni grafana ose mjete të tjera vizualizimi që punojnë me Kubernetes API.

KEDA mbështet konceptin e një shkallëzuesi - ai vepron si një urë lidhëse ndërmjet KEDA-s dhe sistemit të jashtëm. Zbatimi i shkallëzuesit është specifik për çdo sistem të synuar dhe nxjerr të dhëna prej tij. Më pas KEDA i përdor ato për të kontrolluar shkallëzimin automatik.

Scalers mbështesin burime të shumta të të dhënave, për shembull, Kafka, Redis, Prometheus. Kjo do të thotë, KEDA mund të përdoret për të shkallëzuar automatikisht vendosjet e Kubernetes duke përdorur metrikën Prometheus si kriter.

Aplikimi testues

Aplikacioni i testit Golang siguron akses nëpërmjet HTTP dhe kryen dy funksione të rëndësishme:

Përdor bibliotekën e klientëve Prometheus Go për të instrumentuar aplikacionin dhe për të ofruar metrikën http_kërkesat, e cila përmban një numër të goditjeve. Pika përfundimtare ku janë të disponueshme matjet e Prometheus ndodhet në URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Në përgjigje të një kërkese GET aplikacioni rrit vlerën e çelësit (access_count) në Redis. Kjo është një mënyrë e thjeshtë për të kryer punën si pjesë e një mbajtësi HTTP dhe gjithashtu për të kontrolluar matjet e Prometheus. Vlera metrike duhet të jetë e njëjtë me vlerën access_count në 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)
   }

Aplikacioni vendoset në Kubernetes nëpërmjet Deployment. Gjithashtu krijohet një shërbim ClusterIP, lejon serverin Prometheus të marrë metrikat e aplikacionit.

Këtu manifesti i vendosjes për aplikacionin.

Serveri Prometheus

Manifesti i vendosjes së Prometheus përbëhet nga:

ConfigMap - për të transferuar konfigurimin e Prometheus;
Deployment - për vendosjen e Prometeut në një grup Kubernetes;
ClusterIP — shërbim për akses në UI Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — për zbulimin automatik të shërbimeve në Kubernetes (Zbulim automatik).

Këtu manifest për drejtimin e Prometeut.

KEDA Prometheus ScaledObject

Skaleri vepron si një urë lidhëse ndërmjet KEDA-s dhe sistemit të jashtëm nga i cili duhet të merren metrikat. ScaledObject është një burim i personalizuar që duhet të vendoset për të sinkronizuar vendosjen me burimin e ngjarjes, në këtë rast Prometheus.

ScaledObject përmban informacione për shkallëzimin e vendosjes, meta të dhënat e burimit të ngjarjeve (si sekretet e lidhjes, emri i radhës), intervalin e votimit, periudhën e rikuperimit dhe të dhëna të tjera. Rezulton në burimin përkatës të shkallëzimit automatik (përkufizimi HPA) për të shkallëzuar vendosjen.

Kur një objekt ScaledObject fshihet, përkufizimi përkatës i HPA pastrohet.

Këtu është përkufizimi ScaledObject për shembullin tonë, ai përdor një shkallëzues 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]))

Merrni parasysh pikat e mëposhtme:

Ai tregon për Deployment Me emër go-prom-app.
Lloji i këmbëzës - Prometheus. Adresa e serverit Prometheus përmendet së bashku me emrin metrikë, pragun dhe Pyetje PromQL, i cili do të përdoret. Pyetja PromQL - sum(rate(http_requests[2m])).
Sipas pollingIntervalKEDA kërkon një objektiv nga Prometeu çdo pesëmbëdhjetë sekonda. Të paktën një nën (minReplicaCount), dhe numri maksimal i bishtajave nuk kalon maxReplicaCount (në këtë shembull - dhjetë).

Mund të instalohet minReplicaCount e barabartë me zero. Në këtë rast, KEDA aktivizon vendosjen zero me një dhe më pas ekspozon HPA për shkallëzim të mëtejshëm automatik. Rendi i kundërt është gjithashtu i mundur, domethënë, shkallëzimi nga një në zero. Në shembull, ne nuk zgjodhëm zero sepse ky është një shërbim HTTP dhe jo një sistem sipas kërkesës.

Magjia brenda shkallëzimit automatik

Pragu përdoret si shkas për të shkallëzuar vendosjen. Në shembullin tonë, pyetja PromQL sum(rate (http_requests [2m])) kthen shkallën e përmbledhur të kërkesës HTTP (kërkesat për sekondë), të matur gjatë dy minutave të fundit.

Meqenëse vlera e pragut është tre, do të thotë se do të jetë një nën ndërsa vlera sum(rate (http_requests [2m])) më pak se tre. Nëse vlera rritet, çdo herë shtohet një nën shtesë sum(rate (http_requests [2m])) rritet me tre. Për shembull, nëse vlera është nga 12 në 14, atëherë numri i bishtajave është katër.

Tani le të përpiqemi ta konfigurojmë!

paravendosje

Gjithçka që ju nevojitet është një grup Kubernetes dhe një mjet i konfiguruar kubectl. Ky shembull përdor një grup minikube, por ju mund të merrni ndonjë tjetër. Për të instaluar një grup ekziston udhëheqja.

Instaloni versionin më të fundit në 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/

instaloj kubectlpër të hyrë në grupin Kubernetes.

Instaloni versionin më të fundit në 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

Instalimi i KEDA-s

Ju mund ta vendosni KEDA-n në disa mënyra, ato janë të listuara në dokumentacionin. Unë jam duke përdorur YAML monolit:

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

KEDA dhe komponentët e tij janë instaluar në hapësirën e emrave keda. Komanda për të kontrolluar:

kubectl get pods -n keda

Prisni që Operatori KEDA të fillojë dhe shkoni te Running State. Dhe pas kësaj, vazhdoni.

Instalimi i Redis duke përdorur Helm

Nëse nuk e keni të instaluar Helm, përdorni këtë udhëheqja. Komanda për të instaluar në Mac:

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

helm init inicializon ndërfaqen e linjës komanduese lokale dhe gjithashtu instalon Tiller te grupi Kubernetes.

kubectl get pods -n kube-system | grep tiller

Prisni që pod Tiller të hyjë në gjendjen e funksionimit.

Shënim i përkthyesit: Autori përdor Helm@2, i cili kërkon që komponenti i serverit Tiller të instalohet. Tani Helm@3 është i rëndësishëm, nuk kërkon një pjesë të serverit.

Pas instalimit të Helm, mjafton një komandë për të nisur Redis:

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

Verifikoni që Redis ka filluar me sukses:

kubectl get pods/redis-server-master-0

Prisni që Redis të hyjë në gjendje Running.

Vendosja e aplikacionit

Komanda e vendosjes:

kubectl apply -f go-app.yaml

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

Kontrolloni që gjithçka ka filluar:

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

Prisni që Redis të hyjë në gjendje Running.

Vendosja e një serveri Prometheus

Manifesti i Prometeut përdor Zbulimi i Shërbimit Kubernetes për Prometheun. Ai lejon zbulimin dinamik të pod-eve të aplikacionit bazuar në etiketën e shërbimit.

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

Për të vendosur:

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

Kontrolloni që gjithçka ka filluar:

kubectl get pods -l=app=prometheus-server

Prisni që Prometeu të hyjë në shtet Running.

përdorim kubectl port-forward për të hyrë në ndërfaqen e përdoruesit të Prometheus (ose serverin API) në http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Vendosja e konfigurimit të shkallëzimit automatik të KEDA-s

Komanda për të krijuar ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Kontrolloni regjistrat e operatorit KEDA:

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

Rezultati duket diçka si ky:

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"

Kontrolloni nën aplikacionet. Një shembull duhet të funksionojë sepse minReplicaCount është e barabartë me 1:

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

Verifikoni që burimi HPA është krijuar me sukses:

kubectl get hpa

Ju duhet të shihni diçka të tillë:

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

Kontrolli shëndetësor: qasja në aplikacion

Për të hyrë në pikën përfundimtare REST të aplikacionit tonë, ekzekutoni:

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

Tani mund të hyni në aplikacionin tuaj Go duke përdorur adresën http://localhost:8080. Për ta bërë këtë, ekzekutoni komandën:

curl http://localhost:8080/test

Rezultati duket diçka si ky:

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

Në këtë pikë kontrolloni edhe Redis. Do të shihni se çelësi access_count u rrit në 1:

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

Sigurohuni që vlera metrike është http_requests e njëjta:

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

Krijimi i ngarkimit

ne do të përdorim hej — mjet për gjenerimin e ngarkesës:

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

Ju gjithashtu mund të shkarkoni programin për Linux ose Dritaret.

Drejtojeni:

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

Si parazgjedhje, programi dërgon 200 kërkesa. Ju mund ta verifikoni këtë duke përdorur matjet e Prometheus si dhe 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

Vërtetoni vlerën e metrikës aktuale (e kthyer nga pyetja 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"]}]}}

Në këtë rast, rezultati aktual është 1,686057971014493 dhe shfaqet në fushë value. Kjo nuk mjafton për shkallëzim, pasi pragu që vendosëm është 3.

Më shumë ngarkesë!

Në terminalin e ri, monitoroni numrin e podave të aplikacionit:

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

Le të rrisim ngarkesën duke përdorur komandën:

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

Pas një kohe, do të shihni HPA që shkallëzon vendosjen dhe lëshon pods të rinj. Kontrolloni HPA-në tuaj për t'u siguruar:

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

Nëse ngarkesa është e paqëndrueshme, vendosja do të reduktohet deri në pikën ku funksionon vetëm një pod. Nëse dëshironi të kontrolloni metrikën aktuale (të kthyer nga pyetja PromQL), atëherë përdorni komandën:

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

Përfundim

KEDA ju lejon të shkallëzoni automatikisht vendosjet tuaja të Kubernetes (në/nga zero) bazuar në të dhënat nga matjet e jashtme. Për shembull, bazuar në matjet e Prometheus, gjatësia e radhës në Redis, vonesa e konsumatorit në temën Kafka.

KEDA integrohet me një burim të jashtëm dhe gjithashtu ofron matjet e tij përmes Metrics Server në Horizontal Pod Autoscaler.

Good Luck!

Çfarë tjetër për të lexuar:

Burimi: www.habr.com

Shkallëzimi automatik i aplikacioneve Kubernetes me Prometheus dhe KEDA