🥇Sjálfvirk stærð Kubernetes forrita með Prometheus og KEDA

Balloon Man eftir Cimuanos

Sveigjanleiki er lykilkrafa fyrir skýjaforrit. Með Kubernetes er stærð forrits eins einfalt og að fjölga eftirlíkingum fyrir viðeigandi dreifingu eða ReplicaSet — en það er handvirkt ferli.

Kubernetes gerir kleift að stækka forrit sjálfkrafa (þ.e. belg í dreifingu eða ReplicaSet) á yfirlýsandi hátt með því að nota Horizontal Pod Autoscaler forskriftina. Sjálfgefin viðmiðun fyrir sjálfvirka mælikvarða er örgjörvanotkunarmælingar (auðlindamælingar), en þú getur samþætt sérsniðnar og utanaðkomandi mælikvarða.

Team Kubernetes aaS frá Mail.ru þýddi grein um hvernig á að nota ytri mælikvarða til að skala Kubernetes forrit sjálfkrafa. Til að sýna hvernig allt virkar notar höfundur HTTP aðgangsbeiðnamælingar, sem safnað er með Prometheus.

Í stað láréttrar sjálfstýringar á belgjum er Kubernetes Event Driven Autoscaling (KEDA) notuð, opinn uppspretta Kubernetes rekstraraðila. Það samþættist innbyggt með Horizontal Pod Autoscaler til að veita óaðfinnanlega sjálfstýringu (þar á meðal til/frá núlli) fyrir atburðadrifið vinnuálag. Kóði fáanlegur á GitHub.

Stutt yfirlit yfir kerfið

Skýringarmyndin sýnir stutta lýsingu á því hvernig allt virkar:

Forritið veitir HTTP fjölda höggmælinga á Prometheus sniði.
Prometheus er stillt til að safna þessum mæligildum.
Prometheus mælikvarði í KEDA er stilltur til að skala forritið sjálfkrafa út frá fjölda HTTP heimsókna.

Nú mun ég segja þér í smáatriðum um hvern þátt.

KEDA og Prometheus

Prometheus er opinn uppspretta kerfiseftirlits- og viðvörunarverkfærasett, hluti Cloud Native Computing Foundation. Safnar mælingum frá ýmsum aðilum og geymir þær sem tímaraðargögn. Til að sjá gögn sem þú getur notað grafana eða önnur sjónræn verkfæri sem vinna með Kubernetes API.

KEDA styður hugmyndina um mælikvarða - það virkar sem brú á milli KEDA og ytra kerfisins. Útfærsla scaler er sértæk fyrir hvert markkerfi og dregur gögn úr því. KEDA notar þá síðan til að stjórna sjálfvirkri mælingu.

Scalers styðja margar gagnaveitur, til dæmis Kafka, Redis, Prometheus. Það er, KEDA er hægt að nota til að skala Kubernetes dreifingu sjálfkrafa með því að nota Prometheus mælikvarða sem viðmið.

Próf umsókn

Golang prófunarforritið veitir aðgang í gegnum HTTP og sinnir tveimur mikilvægum aðgerðum:

Notar Prometheus Go biðlarasafnið til að stjórna forritinu og gefa upp http_requests mæligildið, sem inniheldur fjölda heimsókna. Endapunkturinn þar sem Prometheus mælingar eru fáanlegar er staðsettur á URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Sem svar við beiðni GET forritið hækkar gildi lykilsins (access_count) í Redis. Þetta er auðveld leið til að vinna verkið sem hluti af HTTP meðhöndlun og athuga einnig Prometheus mælingar. Mæligildið verður að vera það sama og gildið access_count í 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)
   }

Forritið er sent til Kubernetes í gegnum Deployment. Einnig er búið til þjónusta ClusterIP, það gerir Prometheus þjóninum kleift að fá forritamælingar.

Hér dreifingarskrá fyrir forritið.

Prometheus þjónn

Uppsetningarskrá Prometheus dreifingar samanstendur af:

ConfigMap — til að flytja Prometheus stillinguna;
Deployment — fyrir að dreifa Prometheus í Kubernetes klasa;
ClusterIP — þjónusta fyrir aðgang að HÍ Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — fyrir sjálfvirka greiningu á þjónustu í Kubernetes (sjálfvirk uppgötvun).

Hér upplýsingaskrá til að keyra Prometheus.

KEDA Prometheus ScaledObject

Mælingin virkar sem brú á milli KEDA og ytra kerfisins sem þarf að fá mæligildi úr. ScaledObject er sérsniðið tilfang sem þarf að nota til að samstilla dreifinguna við viðburðaruppsprettu, í þessu tilviki Prometheus.

ScaledObject inniheldur upplýsingar um dreifingarstærð, lýsigögn atburðaruppsprettu (eins og leyndarmál tengingar, heiti biðraðar), könnunarbil, endurheimtartímabil og önnur gögn. Það leiðir til samsvarandi sjálfvirkrar stærðartilföngs (HPA skilgreining) til að skala dreifinguna.

Þegar hlutur ScaledObject er eytt, er samsvarandi HPA skilgreining hreinsuð.

Hér er skilgreiningin ScaledObject fyrir dæmi okkar, það notar 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]))

Íhugaðu eftirfarandi atriði:

Hann bendir á Deployment Með nafni go-prom-app.
Gerð kveikju - Prometheus. Netfang Prometheus netþjóns er nefnt ásamt metraheiti, þröskuldi og PromQL fyrirspurn, sem notað verður. PromQL fyrirspurn - sum(rate(http_requests[2m])).
Samkvæmt pollingInterval,KEDA biður um skotmark frá Prometheus á fimmtán sekúndna fresti. Að minnsta kosti einn undir (minReplicaCount), og hámarksfjöldi fræbelgja fer ekki yfir maxReplicaCount (í þessu dæmi - tíu).

Getur sett upp minReplicaCount jafnt og núll. Í þessu tilviki virkjar KEDA núll-til-einn dreifinguna og afhjúpar síðan HPA fyrir frekari sjálfvirka mælikvarða. Öfug röð er líka möguleg, það er að kvarða frá einum í núll. Í dæminu völdum við ekki núll vegna þess að þetta er HTTP þjónusta en ekki eftirspurn kerfi.

Galdurinn inni í sjálfsstærðinni

Þröskuldurinn er notaður sem kveikja til að skala dreifinguna. Í dæminu okkar, PromQL fyrirspurnin sum(rate (http_requests [2m])) skilar uppsöfnuðum HTTP beiðni hlutfalli (beiðnir á sekúndu), mælt á síðustu tveimur mínútum.

Þar sem viðmiðunargildið er þrjú þýðir það að það verður einn undir á meðan gildið er sum(rate (http_requests [2m])) færri en þrír. Ef gildið eykst bætist við auka undir í hvert skipti sum(rate (http_requests [2m])) hækkar um þrjá. Til dæmis, ef gildið er frá 12 til 14, þá er fjöldi fræbelgja fjögurra.

Nú skulum við reyna að setja það upp!

forstilling

Allt sem þú þarft er Kubernetes þyrping og stillt tól kubectl. Þetta dæmi notar klasa minikube, en þú getur tekið hvaða aðra. Til að setja upp þyrping er til forystu.

Settu upp nýjustu útgáfuna á 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/

Setja kubectltil að fá aðgang að Kubernetes klasanum.

Settu upp nýjustu útgáfuna á 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

KEDA uppsetning

Þú getur notað KEDA á nokkra vegu, þeir eru skráðir í skjöl. Ég er að nota monolithic YAML:

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

KEDA og íhlutir þess eru settir upp í nafnrýmið keda. Skipun til að athuga:

kubectl get pods -n keda

Bíddu eftir að KEDA Operator byrjar og fer í Running State. Og eftir það, haltu áfram.

Uppsetning Redis með Helm

Ef þú ert ekki með Helm uppsett skaltu nota þetta forysta. Skipun til að setja upp á Mac:

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

helm init frumstillir staðbundið skipanalínuviðmót og setur einnig upp Tiller til Kubernetes klasans.

kubectl get pods -n kube-system | grep tiller

Bíddu þar til Tiller belgurinn fer í hlaupandi ástand.

Athugasemd þýðanda: Höfundur notar Helm@2, sem krefst þess að Tiller miðlara íhluturinn sé settur upp. Núna er Helm@3 viðeigandi, það þarf ekki miðlarahluta.

Eftir að Helm hefur verið sett upp nægir ein skipun til að ræsa Redis:

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

Staðfestu að Redis hafi byrjað með góðum árangri:

kubectl get pods/redis-server-master-0

Bíddu eftir að Redis fer í ástand Running.

Dreifing forrita

Dreifingarskipun:

kubectl apply -f go-app.yaml

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

Athugaðu hvort allt sé byrjað:

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

Bíddu eftir að Redis fer í ástand Running.

Að setja upp Prometheus netþjón

The Prometheus manifest notar Kubernetes Service Discovery fyrir Prometheus. Það gerir kraftmikla uppgötvun á forritabelgjum byggt á þjónustumerkinu.

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

Til að dreifa:

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

Athugaðu hvort allt sé byrjað:

kubectl get pods -l=app=prometheus-server

Bíddu eftir að Prometheus fari í ríki Running.

Используйте kubectl port-forward til að fá aðgang að Prometheus notendaviðmótinu (eða API þjóninum) á http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Uppsetning KEDA sjálfvirkrar stærðarstillingar

Skipun til að búa til ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Athugaðu rekstrarskrá KEDA:

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

Útkoman lítur einhvern veginn svona út:

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"

Athugaðu undir umsóknir. Eitt tilvik verður að vera í gangi vegna þess minReplicaCount jafngildir 1:

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

Staðfestu að HPA tilföngin hafi verið búin til:

kubectl get hpa

Þú ættir að sjá eitthvað eins og:

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

Heilsufarsskoðun: aðgangur að forritum

Til að fá aðgang að REST endapunkti forritsins okkar skaltu keyra:

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

Þú getur nú fengið aðgang að Go appinu þínu með því að nota heimilisfangið http://localhost:8080. Til að gera þetta skaltu keyra skipunina:

curl http://localhost:8080/test

Útkoman lítur einhvern veginn svona út:

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

Á þessum tímapunkti athugaðu líka Redis. Þú munt sjá að lykillinn access_count hækkað í 1:

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

Gakktu úr skugga um að mæligildið sé http_requests það sama:

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

Hlaðasköpun

Við munum nota hey — tól til að búa til álag:

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

Þú getur líka halað niður tólinu fyrir Linux eða Windows.

Keyra það:

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

Sjálfgefið er að tólið sendir 200 beiðnir. Þú getur staðfest þetta með því að nota Prometheus mælikvarða sem og 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

Staðfestu gildi raunverulegs mælikvarða (skilað af PromQL fyrirspurninni):

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

Í þessu tilviki er raunveruleg niðurstaða 1,686057971014493 og birtist í reitnum value. Þetta er ekki nóg til að skala, þar sem þröskuldurinn sem við setjum er 3.

Meira álag!

Í nýju flugstöðinni skaltu fylgjast með fjölda forritabelgja:

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

Við skulum auka álagið með skipuninni:

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

Eftir smá stund muntu sjá HPA stækka dreifinguna og setja af stað nýja belg. Athugaðu HPA til að ganga úr skugga um:

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

Ef álagið er ósamræmi mun dreifingin minnka að því marki að aðeins einn belg er í gangi. Ef þú vilt athuga raunverulegan mælikvarða (skilað af PromQL fyrirspurninni), notaðu þá skipunina:

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

Þrif

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

Ályktun

KEDA gerir þér kleift að skala Kubernetes dreifinguna þína sjálfkrafa (til/frá núll) byggt á gögnum frá ytri mælingum. Til dæmis, byggt á Prometheus mælingum, lengd biðraðar í Redis, leynd neytenda í Kafka efni.

KEDA samþættist utanaðkomandi uppsprettu og veitir einnig mælikvarða sína í gegnum Metric Server til Horizontal Pod Autoscaler.

Good Luck!

Hvað annað að lesa:

Heimild: www.habr.com

Sjálfvirk stærð Kubernetes forrita með Prometheus og KEDA