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
Id-dijagramma turi deskrizzjoni qasira ta’ kif jaħdem kollox:
Prometheus huwa kkonfigurat biex jiġbor dawn il-metriċi.
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:
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",
})
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.
L-applikazzjoni hija skjerata għal Kubernetes permezz Deployment. Jinħoloq ukoll servizz ClusterIP, jippermetti lis-server Prometheus jikseb metriċi tal-applikazzjoni.
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:
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])).
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.
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:
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.
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:
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
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:
//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.