ProHoster > Blog > Rêveberî > Bi karanîna Prometheus û KEDA-ê serîlêdanên Kubernetes-ê bi otoscaling

Bi karanîna Prometheus û KEDA-ê serîlêdanên Kubernetes-ê bi otoscaling

Bi karanîna Prometheus û KEDA-ê serîlêdanên Kubernetes-ê bi otoscalingBalloon Man ji hêla Cimuanos ve

Scalability ji bo serîlêdanên ewr pêdivîyek bingehîn e. Bi Kubernetes re, pîvandina serîlêdanek bi qasî zêdekirina hejmara kopiyan ji bo bicîhkirina guncan an hêsan e. ReplicaSet - lê ew pêvajoyek destan e.

Kubernetes dihêle ku serîlêdan bixweber werin pîvandin (ango Pods di vesazkirinê de an ReplicaSet) bi rengek daxuyandî bi karanîna taybetmendiya Horizontal Pod Autoscaler. Pîvana xwerû ya ji bo pîvandina otomatîkî metrîkên karanîna CPU-yê ye (metrîkên çavkaniyê), lê hûn dikarin metrîkên xwerû û yên ji derve hatine peyda kirin yek bikin.

tîma Kubernetes aaS ji Mail.ru gotarek li ser ka meriv çawa metrîkên derveyî bikar tîne da ku bixweber serîlêdana Kubernetes pîvandinê bike wergerandin. Ji bo ku nîşan bide ka her tişt çawa dixebite, nivîskar metrîkên daxwaza gihîştina HTTP-ê bikar tîne, ku bi Prometheus têne berhev kirin.

Li şûna pîvandina otomatîkî ya horizontî ya pods, Kubernetes Event Driven Autoscaling (KEDA) tê bikar anîn, ku operatorek Kubernetes ya çavkaniyek vekirî ye. Ew bi xwemalî bi Horizontal Pod Autoscaler re yek dibe ku ji bo barkêşên xebatê yên bûyer-rêveberî pîvandina otomatîkî ya bêkêmasî (tevî/ji sifir) peyda dike. Kod li ser heye GitHub.

Bi kurtî li ser operasyona pergalê

Bi karanîna Prometheus û KEDA-ê serîlêdanên Kubernetes-ê bi otoscaling

Diagram ravekek kurt nîşan dide ka her tişt çawa dixebite:

  1. Serlêdan di forma Prometheus de metrîkên hejmartina lêdana HTTP-ê peyda dike.
  2. Prometheus ji bo berhevkirina van metrîkan hatiye mîheng kirin.
  3. Pîvana Prometheus ya di KEDA de ji bo ku serîlêdanê bixweber li gorî hejmara lêdanên HTTP-ê pîvaz bike tê mîheng kirin.

Niha ez ê li ser her hêmanek bi hûrgulî ji we re vebêjim.

KEDA û Prometheus

Prometheus amûrek çavdêrî û hişyarkirina pergala çavkaniyek vekirî ye, beşek Weqfa Computing Native Cloud. Metrîkan ji çavkaniyên cihêreng berhev dike û wan wekî daneyên rêzikên demê hilîne. Ji bo dîtina daneyan hûn dikarin bikar bînin Grafana an amûrên dîtbarî yên din ên ku bi Kubernetes API re dixebitin.

KEDA piştgiriya konsepta scaler dike - ew wek pirek di navbera KEDA û pergala derve de tevdigere. Pêkanîna scaler ji bo her pergala armancê taybetî ye û daneyan jê derdixe. Piştre KEDA wan ji bo kontrolkirina pîvana otomatîk bikar tîne.

Scalers gelek çavkaniyên daneyê piştgirî dikin, mînakî, Kafka, Redis, Prometheus. Ango, KEDA dikare were bikar anîn da ku bixweber bicîhkirinên Kubernetes bi karanîna pîvanên Prometheus wekî pîvanan were pîvandin.

Serlêdana testê

Serlêdana testa Golang bi rêya HTTP-ê gihîştina peyda dike û du fonksiyonên girîng pêk tîne:

  1. Pirtûkxaneya muwekîlê Prometheus Go bikar tîne da ku serîlêdanê amûr bike û metrika http_requests peyda bike, ku tê de hejmarek lêdan heye. Xala dawî ya ku metrîkên Prometheus lê hene li URI-yê ye /metrics. 
    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
  2. Di bersiva daxwazekê de GET serîlêdan nirxa mifteyê zêde dike (access_count) li Redis. Ev rêgezek hêsan e ku hûn wekî beşek ji hilgirê HTTP-ê kar bikin û metrîkên Prometheus jî kontrol bikin. Divê nirxa metrîkê wekî nirxê be access_count li 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)
   }

Serlêdan bi navgîniya Kubernetes ve tê şandin Deployment. Xizmetek jî tê çêkirin ClusterIP, ew destûrê dide servera Prometheus ku pîvanên serîlêdanê bistîne.

vir ji bo serîlêdanê eşkerekirina belavkirinê.

Server Prometheus

Manîfestoya bicihkirina Prometheus ji van pêk tê:

  • ConfigMap - veguherîna konfigurasyona Prometheus;
  • Deployment - ji bo bicihkirina Prometheus di komek Kubernetes de;
  • ClusterIP - karûbarê ji bo gihîştina UI Prometheus;
  • ClusterRole, ClusterRoleBinding и ServiceAccount - ji bo oto-tespîtkirina karûbaran li Kubernetes (Auto-vedîtin).

vir manîfesto ji bo birêvebirina Prometheus.

KEDA Prometheus ScaledObject

Scaler wekî pirek di navbera KEDA û pergala derveyî ya ku pêdivî ye ku metrîk jê were girtin de tevdigere. ScaledObject çavkaniyek xwerû ye ku pêdivî ye ku were saz kirin da ku bicîhkirinê bi çavkaniya bûyerê re hevdeng bike, di vê rewşê de Prometheus.

ScaledObject agahdariya pîvana bicîhkirinê, metadata çavkaniya bûyerê (wekî nehêniyên pêwendiyê, navê rêzê), navbera dengdanê, heyama başbûnê, û daneyên din vedihewîne. Ew di çavkaniya pîvana xweser a têkildar (pênaseya HPA) de encam dide ku pîvandinê bike.

Dema ku object ScaledObject tê jêbirin, pênase HPA-ya têkildar tê paqij kirin.

Li vir pênase heye ScaledObject ji bo nimûneya me, ew pîvanek bikar tîne 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]))

Ji kerema xwe xalên jêrîn bala xwe bidin:

  1. Ew nîşan dide Deployment Bi navê go-prom-app.
  2. Tîpa tetikê - Prometheus. Navnîşana servera Prometheus bi navê metrîk, sînor û Pirsa PromQL, ku dê bikar bînin. Pirsa PromQL - sum(rate(http_requests[2m])).
  3. Li gorî pollingIntervalKEDA ji Prometheus her panzdeh saniye carek hedefek dixwaze. Bi kêmanî yek di bin (minReplicaCount), û hejmara herî zêde ya potan derbas nabe maxReplicaCount (di vê nimûneyê de - deh).

Dikare were sazkirin minReplicaCount wek sifir. Di vê rewşê de, KEDA vekirina sifir-yek-yek çalak dike û paşê HPA-ê ji bo pîvana otomatîkî ya bêtir eşkere dike. Rêza berevajî jî mimkun e, ango pîvandina ji yek ber bi sifirê. Di nimûneyê de, me sifir hilnebijart ji ber ku ev karûbarek HTTP ye û ne pergalek li ser daxwazê ​​ye.

Magic di hundurê otoscaling

Bendavê wekî tetikek ji bo pîvandina birêkûpêk tê bikar anîn. Di mînaka me de, pirsa PromQL sum(rate (http_requests [2m])) rêjeya daxwaza HTTP-ê ya berhevkirî (daxwazên her çirkeyê), ku di du hûrdeman de hatî pîvandin vedigerîne.

Ji ber ku nirxa bendê sê ye, ev tê vê wateyê ku dê di binê nirxê de yek hebe sum(rate (http_requests [2m])) kêmtir ji sê. Ger nirx zêde bibe, her carê subek zêde tê zêdekirin sum(rate (http_requests [2m])) sê zêde dibe. Mînakî, heke nirx ji 12 heta 14 be, wê hingê hejmara potan çar e.

Naha em biceribînin ku wê saz bikin!

pêşdibistanê

Tişta ku hûn hewce ne komek Kubernetes û amûrek mîhengkirî ye kubectl. Ev nimûne komekê bikar tîne minikube, lê hûn dikarin yekî din bigirin. Ji bo sazkirina komek heye birêvebirî.

Guhertoya herî dawî li Mac-ê saz bikin:

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/

Lêkirin kubectlku bigihîjin koma Kubernetes.

Guhertoya herî dawî li Mac-ê saz bikin:

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

Sazkirina KEDA

Hûn dikarin KEDA bi çend awayan bi cîh bikin, ew di navnîşan de ne belgekirin. Ez YAML monolîtîk bikar tînim:

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

KEDA û pêkhateyên wê di nav qada navan de têne sazkirin keda. Fermana kontrolkirinê:

kubectl get pods -n keda

Li bendê bin ku Operatorê KEDA dest pê bike û biçe Running State. Û piştî wê, berdewam bike.

Sazkirina Redis bi karanîna Helm

Heke we Helm saz nekiribe, vê yekê bikar bînin birêvebirî. Fermana sazkirinê li Mac-ê:

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

helm init pêwendiya rêza fermana herêmî dest pê dike û saz dike Tiller ji koma Kubernetes re.

kubectl get pods -n kube-system | grep tiller

Li bendê bin ku pod Tiller têkeve rewşa Rêvekirinê.

Têbiniya wergêr: Nivîskar Helm@2 bikar tîne, ku pêdivî ye ku pêkhateya servera Tiller were saz kirin. Naha Helm@3 têkildar e, ew beşek serverê hewce nake.

Piştî sazkirina Helm, yek ferman bes e ku Redis dest pê bike:

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

Verast bikin ku Redis bi serfirazî dest pê kir:

kubectl get pods/redis-server-master-0

Li bendê bin ku Redis biçe dewletê Running.

Daxistina Serlêdanê

Fermana bicihkirinê:

kubectl apply -f go-app.yaml

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

Kontrol bikin ku her tişt dest pê kiriye:

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

Li bendê bin ku Redis têkeve dewletê Running.

Bicihkirina Serverek Prometheus

Manîfestoya Prometheus bikar tîne Vedîtina Karûbarê Kubernetes ji bo Prometheus. Ew rê dide vedîtina dînamîkî ya podên serîlêdanê li ser bingeha nîşana karûbarê.

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

Ji bo belavkirinê:

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

Kontrol bikin ku her tişt dest pê kiriye:

kubectl get pods -l=app=prometheus-server

Li bendê bin ku Prometheus here dewletê Running.

Bikar bînin kubectl port-forward ji bo gihîştina navrûya bikarhênerê Prometheus (an servera API) li ser http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Bicihkirina Veavakirina Xweseriya KEDA

Fermana afirandinê ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Têketinên operatorê KEDA kontrol bikin:

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

Encam tiştek bi vî rengî xuya dike:

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"

Di bin serîlêdanan de kontrol bikin. Yek mînakek pêdivî ye ku ji ber ku dimeşîne minReplicaCount wekhevî 1:

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

Verast bikin ku çavkaniya HPA bi serfirazî hate afirandin:

kubectl get hpa

Divê hûn tiştek wekî bibînin:

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

Kontrola tenduristiyê: gihîştina serîlêdanê

Ji bo gihîştina xala dawiya REST ya serîlêdana me, bixebitin:

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

Naha hûn dikarin bi karanîna navnîşanê xwe bigihînin sepana Go-ya xwe http://localhost:8080. Ji bo vê yekê, fermanê bimeşînin:

curl http://localhost:8080/test

Encam tiştek bi vî rengî xuya dike:

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

Di vê nuqteyê de Redis jî kontrol bikin. Hûn ê bibînin ku key access_count zêde bû 1:

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

Bawer bikin ku nirxa metrîkê ye http_requests hemen:

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

Afirandina barkirinê

Em ê bikar bînin hey - kargêriya ji bo hilberîna barkirinê:

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

Her weha hûn dikarin amûrê ji bo dakêşin Linux an Windows.

Bixebitîne:

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

Bi xwerû, karûbar 200 daxwazan dişîne. Hûn dikarin vê yekê bi karanîna metrîkên Prometheus û her weha Redis verast bikin.

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

Nirxa metrîka rastîn rast bikin (ji hêla pirsa PromQL ve hatî vegerandin):

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

Di vê rewşê de, encama rastîn e 1,686057971014493 û li qadê tê nîşandan value. Ev ji bo pîvandinê ne bes e, ji ber ku sînorê ku me destnîşan kiriye 3 ye.

Zêdetir barkirin!

Di termînala nû de, hejmara pêlên serîlêdanê bişopînin:

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

Ka em bi karanîna fermanê barkirinê zêde bikin: 

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

Piştî demekê, hûn ê bibînin ku HPA-ê pîvaz dike û pêlên nû dest pê dike. HPA-ya xwe kontrol bikin ku hûn pê ewle bibin:

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

Ger barkirin nakok be, dê bicîhkirin heya nuqteya ku tenê yek pod dimeşe kêm bibe. Heke hûn dixwazin pîvana rastîn kontrol bikin (ji hêla lêpirsîna PromQL ve hatî vegerandin), wê hingê emrê bikar bînin:

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

Paqijkirin

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

encamê

KEDA destûrê dide te ku hûn li ser bingeha daneyên ji metrîkên derveyî bixweber bicîhkirinên Kubernetes (ji/ji sifirê) pîvandin. Mînakî, li ser bingeha metrîka Prometheus, dirêjahiya rêzê li Redis, derengiya xerîdar di mijara Kafka de.

KEDA bi çavkaniyek derveyî re yek dike û di heman demê de pîvanên xwe bi navgîniya Metrics Server ji Horizontal Pod Autoscaler re peyda dike.

Bextê te xweş bî

Wekî din çi bixwînin:

  1. Pratîkên çêtirîn û pratîkên çêtirîn ên ji bo xebitandina konteyniran û Kubernetes di hawîrdorên hilberînê de.
  2. Zêdetirî 90 Amûrên Kêrhatî ji bo Kubernetes: Dabeşkirin, Rêvebirin, Çavdêrî, Ewlekarî û Zêdetir.
  3. Kanala me li dora Kubernetes di Telegram de.

Source: www.habr.com

Add a comment