ProHoster > blog > Amministrazzjoni > Autoscaling applikazzjonijiet Kubernetes bl-użu ta 'Prometheus u KEDA

Autoscaling applikazzjonijiet Kubernetes bl-użu ta 'Prometheus u KEDA

Autoscaling applikazzjonijiet Kubernetes bl-użu ta 'Prometheus u KEDABniedem tal-bużżieqa minn Cimuanos

L-iskalabbiltà hija rekwiżit ewlieni għall-applikazzjonijiet tal-cloud. B'Kubernetes, l-iskala ta' applikazzjoni hija sempliċi daqs li żżid in-numru ta' repliki għall-iskjerament xieraq jew ReplicaSet — iżda huwa proċess manwali.

Kubernetes jippermetti li l-applikazzjonijiet jiġu skalati awtomatikament (jiġifieri Pods fi skjerament jew ReplicaSet) b'mod dikjarattiv bl-użu tal-ispeċifikazzjoni Horizontal Pod Autoscaler. Il-kriterju default għall-iskala awtomatiku huwa metriċi tal-użu tas-CPU (metriċi tar-riżorsi), iżda tista 'tintegra metriċi personalizzati u pprovduti esternament.

Team Kubernetes aaS minn Mail.ru ittraduċiet artiklu dwar kif tuża metriċi esterni biex tiskala awtomatikament applikazzjoni Kubernetes. Biex juri kif jaħdem kollox, l-awtur juża metriċi ta 'talba ta' aċċess HTTP, li jinġabru bl-użu ta 'Prometheus.

Minflok l-autoscaling orizzontali tal-miżwed, jintuża Kubernetes Event Driven Autoscaling (KEDA), operatur ta’ Kubernetes ta’ sors miftuħ. Jintegra b'mod nattiv ma' Horizontal Pod Autoscaler biex jipprovdi awtoscaling bla xkiel (inkluż lejn/minn żero) għal xogħolijiet immexxija mill-avvenimenti. Kodiċi disponibbli fuq GitHub.

Ħarsa ġenerali qasira tas-sistema

Autoscaling applikazzjonijiet Kubernetes bl-użu ta 'Prometheus u KEDA

Id-dijagramma turi deskrizzjoni qasira ta’ kif jaħdem kollox:

  1. L-applikazzjoni tipprovdi metriċi tal-għadd tal-hit HTTP fil-format Prometheus.
  2. Prometheus huwa kkonfigurat biex jiġbor dawn il-metriċi.
  3. Il-Prometheus scaler f'KEDA huwa kkonfigurat biex awtomatikament jiskala l-applikazzjoni abbażi tan-numru ta 'hits HTTP.

Issa ngħidlek fid-dettall dwar kull element.

KEDA u Prometheus

Prometheus huwa sett ta 'għodda ta' monitoraġġ u twissija ta 'sistema ta' sors miftuħ, parti Fondazzjoni Cloud Native Computing. Jiġbor metriċi minn diversi sorsi u jaħżenhom bħala dejta tas-serje tal-ħin. Biex tara d-data tista 'tuża grafana jew għodod oħra ta 'viżwalizzazzjoni li jaħdmu mal-API Kubernetes.

KEDA tappoġġja l-kunċett ta 'scaler - taġixxi bħala pont bejn KEDA u s-sistema esterna. L-implimentazzjoni tal-iscaler hija speċifika għal kull sistema fil-mira u estratti data minnha. KEDA mbagħad jużahom biex jikkontrolla l-iskala awtomatiku.

Scalers jappoġġjaw sorsi ta 'dejta multipli, pereżempju, Kafka, Redis, Prometheus. Jiġifieri, KEDA jista 'jintuża biex awtomatikament skala l-iskjeramenti ta' Kubernetes billi tuża metriċi Prometheus bħala kriterji.

Applikazzjoni tat-test

L-applikazzjoni tat-test Golang tipprovdi aċċess permezz HTTP u twettaq żewġ funzjonijiet importanti:

  1. Juża l-librerija tal-klijenti Prometheus Go biex tistrumenta l-applikazzjoni u tipprovdi l-metrika http_requests, li fiha għadd ta’ hits. L-endpoint fejn il-metriċi Prometheus huma disponibbli jinsab fl-URI /metrics. 
    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
  2. Bi tweġiba għal talba GET l-applikazzjoni żżid il-valur taċ-ċavetta (access_count) f'Redis. Dan huwa mod faċli biex tagħmel ix-xogħol bħala parti minn handler HTTP u tiċċekkja wkoll il-metriċi Prometheus. Il-valur metriku għandu jkun l-istess bħall-valur access_count f'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)
   }

L-applikazzjoni hija skjerata għal Kubernetes permezz Deployment. Jinħoloq ukoll servizz ClusterIP, jippermetti lis-server Prometheus jikseb metriċi tal-applikazzjoni.

Hawnhekk manifest tal-iskjerament għall-applikazzjoni.

Server Prometheus

Il-manifest tal-iskjerament tal-Prometheus jikkonsisti minn:

  • ConfigMap — biex tittrasferixxi l-konfigurazzjoni tal-Prometheus;
  • Deployment — għall-iskjerament ta' Prometheus fi cluster Kubernetes;
  • ClusterIP — servizz għall-aċċess għall-UI Prometheus;
  • ClusterRole, ClusterRoleBinding и ServiceAccount — għall-iskoperta awtomatika ta’ servizzi f’Kubernetes (Awto-discovery).

Hawnhekk manifest għat-tmexxija ta’ Prometheus.

KEDA Prometheus ScaledObject

L-iscaler jaġixxi bħala pont bejn KEDA u s-sistema esterna li minnha jeħtieġ li jinkisbu l-metriċi. ScaledObject hija riżors tad-dwana li jeħtieġ li jiġi skjerat biex jissinkronizza l-iskjerament mas-sors tal-avveniment, f'dan il-każ Prometheus.

ScaledObject fih informazzjoni dwar l-iskala tal-iskjerament, metadejta tas-sors tal-avveniment (bħal sigrieti tal-konnessjoni, isem tal-kju), intervall tal-votazzjoni, perjodu ta’ rkupru, u dejta oħra. Jirriżulta fir-riżorsa awtoscaling korrispondenti (definizzjoni HPA) biex tiskala l-iskjerament.

Meta oġġett ScaledObject titħassar, id-definizzjoni tal-HPA korrispondenti titneħħa.

Hawn id-definizzjoni ScaledObject għall-eżempju tagħna, juża scaler 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]))

Ikkunsidra l-punti li ġejjin:

  1. Huwa jindika Deployment Bl-isem go-prom-app.
  2. Tip ta' trigger - Prometheus. L-indirizz tas-server Prometheus jissemma flimkien mal-isem tal-metrika, il-limitu u Mistoqsija PromQL, li se jintuża. Mistoqsija PromQL - sum(rate(http_requests[2m])).
  3. Skond pollingInterval,KEDA titlob mira mingħand Prometheus kull ħmistax-il sekonda. Mill-inqas wieħed taħt (minReplicaCount), u n-numru massimu ta 'miżwed ma jaqbiżx maxReplicaCount (f'dan l-eżempju - għaxra).

Jista 'jinstalla minReplicaCount ugwali għal żero. F'dan il-każ, KEDA jattiva l-iskjerament zero-to-one u mbagħad jesponi l-HPA għal aktar skalar awtomatiku. L-ordni inversa hija wkoll possibbli, jiġifieri, skala minn wieħed għal żero. Fl-eżempju, aħna ma għażilniex żero għaliex dan huwa servizz HTTP u mhux sistema fuq talba.

Il-maġija ġewwa l-autoscaling

Il-limitu jintuża bħala skatlu għall-iskala tal-iskjerament. Fl-eżempju tagħna, il-mistoqsija PromQL sum(rate (http_requests [2m])) jirritorna r-rata aggregata tat-talba HTTP (talbiet kull sekonda), imkejla matul l-aħħar żewġ minuti.

Peress li l-valur tal-limitu huwa tlieta, dan ifisser li se jkun hemm wieħed taħt filwaqt li l-valur sum(rate (http_requests [2m])) inqas minn tlieta. Jekk il-valur jiżdied, kull darba jiżdied sub addizzjonali sum(rate (http_requests [2m])) jiżdied bi tlieta. Pereżempju, jekk il-valur huwa minn 12 sa 14, allura n-numru ta 'miżwed huwa erbgħa.

Issa ejja nippruvaw inwaqqfuh!

Issettjar minn qabel

Kulma għandek bżonn huwa cluster Kubernetes u utilità kkonfigurata kubectl. Dan l-eżempju juża cluster minikube, imma tista' tieħu kwalunkwe waħda oħra. Biex tinstalla cluster hemm gwida.

Installa l-aħħar verżjoni fuq il-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/

Set kubectlbiex taċċessa l-cluster Kubernetes.

Installa l-aħħar verżjoni fuq il-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

Installazzjoni KEDA

Tista' tuża KEDA f'diversi modi, huma elenkati fihom dokumentazzjoni. Qed nuża YAML monolitiku:

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

KEDA u l-komponenti tiegħu huma installati fl-ispazju tal-isem keda. Kmand biex tiċċekkja:

kubectl get pods -n keda

Stenna li l-Operatur KEDA jibda u mur Running State. U wara dan, kompli.

Installazzjoni ta' Redis bl-użu ta' Helm

Jekk m'għandekx Helm installat, uża dan tmexxija. Kmand biex tinstalla fuq Mac:

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

helm init jinizjalizza l-interface tal-linja tal-kmand lokali u jinstalla wkoll Tiller lill-cluster Kubernetes.

kubectl get pods -n kube-system | grep tiller

Stenna li l-pod tat-Tiller jidħol fl-istat Running.

Nota tat-traduttur: L-awtur juża Helm@2, li jeħtieġ li jiġi installat il-komponent tas-server Tiller. Issa Helm@3 huwa rilevanti, ma jeħtieġx parti tas-server.

Wara li tinstalla Helm, kmand wieħed huwa biżżejjed biex tibda Redis:

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

Ivverifika li Redis beda b'suċċess:

kubectl get pods/redis-server-master-0

Stenna li Redis tidħol fl-istat Running.

Skjerament ta' Applikazzjoni

Kmand tal-iskjerament:

kubectl apply -f go-app.yaml

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

Iċċekkja li kollox beda:

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

Stenna li Redis tidħol fl-istat Running.

L-iskjerament ta' Server Prometheus

Il-manifest Prometheus juża Kubernetes Service Discovery għal Prometheus. Jippermetti skoperta dinamika ta 'miżwed ta' applikazzjoni bbażati fuq it-tikketta tas-servizz.

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

Biex tuża:

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

Iċċekkja li kollox beda:

kubectl get pods -l=app=prometheus-server

Stenna li Prometheus jidħol fl-istat Running.

Użu kubectl port-forward biex taċċessa l-interface tal-utent Prometheus (jew is-server API) fuq http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

L-iskjerament tal-Konfigurazzjoni tal-Autoscaling KEDA

Kmand biex toħloq ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Iċċekkja r-reġistri tal-operatur KEDA:

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

Ir-riżultat jidher xi ħaġa bħal din:

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"

Iċċekkja taħt l-applikazzjonijiet. Istanza waħda trid tkun qed taħdem għaliex minReplicaCount huwa ugwali għal 1:

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

Ivverifika li r-riżorsa HPA ġiet maħluqa b'suċċess:

kubectl get hpa

Għandek tara xi ħaġa bħal:

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

Kontroll tas-saħħa: aċċess għall-applikazzjoni

Biex taċċessa l-endpoint REST tal-applikazzjoni tagħna, mexxi:

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

Issa tista’ taċċessa l-app Go tiegħek billi tuża l-indirizz http://localhost:8080. Biex tagħmel dan, mexxi l-kmand:

curl http://localhost:8080/test

Ir-riżultat jidher xi ħaġa bħal din:

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

F'dan il-punt iċċekkja wkoll Redis. Se tara li ċ-ċavetta access_count żdied għal 1:

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

Kun żgur li l-valur metriku huwa http_requests l-istess:

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

Ħolqien tat-Tagħbija

Aħna nużaw hey — utilità għall-ġenerazzjoni tat-tagħbija:

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

Tista 'wkoll tniżżel l-utilità għal Linux jew twieqi.

Mexxiha:

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

B'mod awtomatiku, l-utilità tibgħat 200 talba. Tista' tivverifika dan billi tuża l-metriċi Prometheus kif ukoll 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

Ivvalida l-valur tal-metrika attwali (rritornata mill-mistoqsija 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"]}]}}

F'dan il-każ ir-riżultat attwali huwa 1,686057971014493 u jintwera fil-qasam value. Dan mhux biżżejjed għall-iskala, peress li l-limitu li nissettjaw huwa 3.

Aktar tagħbija!

Fit-terminal il-ġdid, immonitorja n-numru ta 'miżwed tal-applikazzjoni:

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

Ejja nżidu t-tagħbija billi tuża l-kmand: 

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

Wara xi żmien, se tara lill-HPA tiskala l-iskjerament u tniedi pods ġodda. Iċċekkja l-HPA tiegħek biex tiżgura:

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

Jekk it-tagħbija tkun inkonsistenti, l-iskjerament se jitnaqqas sal-punt fejn pod wieħed biss ikun qed jaħdem. Jekk trid tiċċekkja l-metrika attwali (rritornata mill-mistoqsija PromQL), imbagħad uża l-kmand:

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

Tindif

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

Konklużjoni

KEDA jippermettilek li tiskala awtomatikament l-iskjeramenti ta' Kubernetes tiegħek (għal/minn żero) ibbażat fuq data minn metriċi esterni. Pereżempju, ibbażat fuq metriċi Prometheus, tul tal-kju f'Redis, latency tal-konsumatur fis-suġġett Kafka.

KEDA jintegra ma 'sors estern u jipprovdi wkoll il-metriċi tiegħu permezz ta' Metrics Server għal Horizontal Pod Autoscaler.

Awguri!

X'iktar għandek taqra:

  1. L-aħjar prattiki u l-aħjar prattiki għat-tħaddim ta’ kontenituri u Kubernetes f’ambjenti ta’ produzzjoni.
  2. 90+ għodda utli għal Kubernetes: skjerament, ġestjoni, monitoraġġ, sigurtà u aktar.
  3. Il-kanal tagħna Madwar Kubernetes f'Telegram.

Sors: www.habr.com

Żid kumment