🥇 Autoscaling cymwysiadau Kubernetes gan ddefnyddio Prometheus a KEDA

Dyn Balwn gan Cimuanos

Mae scalability yn ofyniad allweddol ar gyfer cymwysiadau cwmwl. Gyda Kubernetes, mae graddio cais mor syml â chynyddu nifer y copïau ar gyfer y defnydd priodol neu ReplicaSet - ond mae'n broses â llaw.

Mae Kubernetes yn caniatáu i geisiadau gael eu graddio'n awtomatig (h.y. Podiau mewn lleoliad neu ReplicaSet) mewn modd datganiadol gan ddefnyddio'r fanyleb Autoscaler Pod Llorweddol. Y maen prawf rhagosodedig ar gyfer graddio awtomatig yw metrigau defnydd CPU (metrigau adnoddau), ond gallwch integreiddio metrigau arfer a ddarperir yn allanol.

Tîm Kubernetes aaS o Mail.ru cyfieithu erthygl ar sut i ddefnyddio metrigau allanol i raddio cais Kubernetes yn awtomatig. I ddangos sut mae popeth yn gweithio, mae'r awdur yn defnyddio metrigau cais mynediad HTTP, sy'n cael eu casglu gan ddefnyddio Prometheus.

Yn lle awtoraddio codennau'n llorweddol, defnyddir Awtogyfnewid Kubernetes Event Driven Autoscaling (KEDA), gweithredwr ffynhonnell agored Kubernetes. Mae'n integreiddio'n frodorol â Horizontal Pod Autoscaler i ddarparu awtoraddio di-dor (gan gynnwys i / o sero) ar gyfer llwythi gwaith sy'n cael eu gyrru gan ddigwyddiadau. Cod ar gael yn GitHub.

Trosolwg byr o'r system

Mae’r diagram yn dangos disgrifiad byr o sut mae popeth yn gweithio:

Mae'r cymhwysiad yn darparu metrigau cyfrif taro HTTP ar ffurf Prometheus.
Mae Prometheus wedi'i ffurfweddu i gasglu'r metrigau hyn.
Mae'r graddiwr Prometheus yn KEDA wedi'i ffurfweddu i raddio'r rhaglen yn awtomatig yn seiliedig ar nifer yr ymweliadau HTTP.

Yn awr dywedaf wrthych yn fanwl am bob elfen.

KEDA a Prometheus

Mae Prometheus yn becyn cymorth monitro a rhybuddio system ffynhonnell agored, rhan Sefydliad Cyfrifiadura Brodorol Cloud. Yn casglu metrigau o wahanol ffynonellau ac yn eu storio fel data cyfres amser. I ddelweddu data gallwch ei ddefnyddio Grafana neu offer delweddu eraill sy'n gweithio gyda'r Kubernetes API.

Mae KEDA yn cefnogi'r cysyniad o scaler - mae'n gweithredu fel pont rhwng KEDA a'r system allanol. Mae gweithrediad y graddiwr yn benodol i bob system darged ac yn tynnu data ohoni. Yna mae KEDA yn eu defnyddio i reoli graddio awtomatig.

Mae graddwyr yn cefnogi ffynonellau data lluosog, er enghraifft, Kafka, Redis, Prometheus. Hynny yw, gellir defnyddio KEDA i raddio gosodiadau Kubernetes yn awtomatig gan ddefnyddio metrigau Prometheus fel meini prawf.

Cais prawf

Mae cymhwysiad prawf Golang yn darparu mynediad trwy HTTP ac yn cyflawni dwy swyddogaeth bwysig:

Yn defnyddio'r llyfrgell cleientiaid Prometheus Go i offeryn y cymhwysiad a darparu'r metrig http_requests, sy'n cynnwys cyfrif taro. Mae'r pwynt terfyn lle mae metrigau Prometheus ar gael wedi'i leoli yn yr URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Mewn ymateb i gais GET mae'r cymhwysiad yn cynyddu gwerth yr allwedd (access_count) yn Redis. Mae hon yn ffordd hawdd o wneud y gwaith fel rhan o driniwr HTTP a hefyd gwirio metrigau Prometheus. Rhaid i'r gwerth metrig fod yr un fath â'r gwerth access_count yn 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)
   }

Mae'r cais yn cael ei anfon i Kubernetes trwy Deployment. Mae gwasanaeth hefyd yn cael ei greu ClusterIP, mae'n caniatáu i'r gweinydd Prometheus gael metrigau cais.

Yma maniffest lleoli ar gyfer y cais.

Gweinydd Prometheus

Mae maniffest lleoli Prometheus yn cynnwys:

ConfigMap — trosglwyddo cyfluniad Prometheus;
Deployment — ar gyfer lleoli Prometheus mewn clwstwr Kubernetes;
ClusterIP — gwasanaeth ar gyfer mynediad i UI Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount - ar gyfer canfod gwasanaethau'n awtomatig yn Kubernetes (Awto-darganfod).

Yma amlwg ar gyfer rhedeg Prometheus.

Gwrthrych Graddfa KEDA Prometheus

Mae'r graddiwr yn gweithredu fel pont rhwng KEDA a'r system allanol y mae angen cael metrigau ohoni. ScaledObject yn adnodd wedi'i deilwra y mae angen ei ddefnyddio i gydamseru'r gosodiad â ffynhonnell y digwyddiad, yn yr achos hwn Prometheus.

ScaledObject yn cynnwys gwybodaeth graddio defnydd, metadata ffynhonnell digwyddiad (fel cyfrinachau cysylltiad, enw ciw), cyfwng pleidleisio, cyfnod adfer, a data arall. Mae'n arwain at yr adnodd graddio awtomatig cyfatebol (diffiniad HPA) i raddfa'r defnydd.

Pan fydd gwrthrych ScaledObject yn cael ei ddileu, mae'r diffiniad HPA cyfatebol yn cael ei glirio.

Dyma'r diffiniad ScaledObject er ein hesiampl ni, mae'n defnyddio 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]))

Ystyriwch y pwyntiau canlynol:

Mae'n pwyntio at Deployment Gydag enw go-prom-app.
Math sbardun - Prometheus. Mae cyfeiriad gweinydd Prometheus yn cael ei grybwyll ynghyd â'r enw metrig, trothwy a Ymholiad PromQL, a fydd yn cael ei ddefnyddio. Ymholiad PromQL - sum(rate(http_requests[2m])).
Yn ôl pollingInterval,Mae KEDA yn gofyn am darged gan Prometheus bob pymtheg eiliad. O leiaf un o dan (minReplicaCount), ac nid yw uchafswm nifer y codennau yn fwy maxReplicaCount (yn yr enghraifft hon - deg).

Yn gallu gosod minReplicaCount hafal i sero. Yn yr achos hwn, mae KEDA yn actifadu'r defnydd sero-i-un ac yna'n datgelu'r HPA ar gyfer graddio awtomatig pellach. Mae'r gorchymyn gwrthdro hefyd yn bosibl, hynny yw, graddio o un i sero. Yn yr enghraifft, ni wnaethom ddewis sero oherwydd gwasanaeth HTTP yw hwn ac nid system ar-alw.

Mae'r hud y tu mewn awtoscaling

Defnyddir y trothwy fel sbardun i raddfa'r defnydd. Yn ein hesiampl, yr ymholiad PromQL sum(rate (http_requests [2m])) yn dychwelyd y gyfradd ceisiadau HTTP agregedig (ceisiadau yr eiliad), wedi'i mesur dros y ddau funud diwethaf.

Gan fod y gwerth trothwy yn dri, mae'n golygu y bydd un o dan tra bod y gwerth sum(rate (http_requests [2m])) llai na thri. Os bydd y gwerth yn cynyddu, ychwanegir is ychwanegol bob tro sum(rate (http_requests [2m])) yn cynyddu o dri. Er enghraifft, os yw'r gwerth rhwng 12 a 14, yna pedwar cod yw nifer y codennau.

Nawr, gadewch i ni geisio ei sefydlu!

rhagosod

Y cyfan sydd ei angen arnoch yw clwstwr Kubernetes a chyfleustodau wedi'u ffurfweddu kubectl. Mae'r enghraifft hon yn defnyddio clwstwr minikube, ond gallwch chi gymryd unrhyw un arall. I osod clwstwr mae yna arweinyddiaeth.

Gosodwch y fersiwn diweddaraf ar 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/

Gosod ciwctli gael mynediad i glwstwr Kubernetes.

Gosodwch y fersiwn diweddaraf ar 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

gosod KEDA

Gallwch chi ddefnyddio KEDA mewn sawl ffordd, maen nhw wedi'u rhestru yn dogfennaeth. Rwy'n defnyddio YAML monolithig:

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

Mae KEDA a'i gydrannau wedi'u gosod yn y gofod enw keda. Gorchymyn i wirio:

kubectl get pods -n keda

Arhoswch i Weithredydd KEDA ddechrau ac ewch i Running State. Ac ar ôl hynny, parhewch.

Gosod Redis gan ddefnyddio Helm

Os nad oes gennych Helm wedi'i osod, defnyddiwch hwn arweinyddiaeth. Gorchymyn i'w osod ar Mac:

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

helm init yn cychwyn y rhyngwyneb llinell orchymyn lleol a hefyd yn gosod Tiller i glwstwr Kubernetes.

kubectl get pods -n kube-system | grep tiller

Arhoswch i'r pod Tiller fynd i mewn i'r cyflwr Rhedeg.

Nodyn y cyfieithydd: Mae'r awdur yn defnyddio Helm@2, sy'n gofyn am osod cydran gweinydd Tiller. Nawr bod Helm@3 yn berthnasol, nid oes angen rhan gweinydd arno.

Ar ôl gosod Helm, mae un gorchymyn yn ddigon i gychwyn Redis:

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

Gwiriwch fod Redis wedi dechrau'n llwyddiannus:

kubectl get pods/redis-server-master-0

Arhoswch i Redis fynd i'r wladwriaeth Running.

Defnyddio Cais

Gorchymyn lleoli:

kubectl apply -f go-app.yaml

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

Gwiriwch fod popeth wedi dechrau:

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

Arhoswch i Redis fynd i mewn i'r wladwriaeth Running.

Defnyddio gweinydd Prometheus

Defnyddiau amlwg Prometheus Darganfod Gwasanaeth Kubernetes ar gyfer Prometheus. Mae'n caniatáu darganfod codennau cymhwysiad yn ddeinamig yn seiliedig ar label y gwasanaeth.

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

I ddefnyddio:

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

Gwiriwch fod popeth wedi dechrau:

kubectl get pods -l=app=prometheus-server

Arhoswch i Prometheus fynd i'r wladwriaeth Running.

Defnyddiwch kubectl port-forward i gael mynediad at ryngwyneb defnyddiwr Prometheus (neu weinydd API) yn http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Defnyddio Ffurfweddu KEDA Autoscaling

Gorchymyn i greu ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Gwiriwch logiau gweithredwr KEDA:

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

Mae'r canlyniad yn edrych fel hyn:

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"

Gwiriwch o dan geisiadau. Rhaid bod un enghraifft yn rhedeg oherwydd minReplicaCount yn hafal i 1:

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

Gwiriwch fod yr adnodd HPA wedi'i greu'n llwyddiannus:

kubectl get hpa

Dylech weld rhywbeth fel:

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

Gwiriad iechyd: mynediad cais

I gael mynediad at ddiweddbwynt REST ein cais, rhedwch:

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

Gallwch nawr gael mynediad i'ch app Go gan ddefnyddio'r cyfeiriad http://localhost:8080. I wneud hyn, rhedeg y gorchymyn:

curl http://localhost:8080/test

Mae'r canlyniad yn edrych fel hyn:

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

Ar y pwynt hwn hefyd wirio Redis. Byddwch yn gweld bod yr allwedd access_count cynyddu i 1:

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

Sicrhewch fod y gwerth metrig http_requests yr un:

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

Creu Llwyth

Byddwn yn defnyddio hey - cyfleustodau ar gyfer cynhyrchu llwyth:

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

Gallwch hefyd lawrlwytho'r cyfleustodau ar gyfer Linux neu ffenestri.

Ei redeg:

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

Yn ddiofyn, mae'r cyfleustodau'n anfon 200 o geisiadau. Gallwch wirio hyn gan ddefnyddio metrigau Prometheus yn ogystal â 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

Dilyswch werth y metrig gwirioneddol (a ddychwelwyd gan ymholiad 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"]}]}}

Yn yr achos hwn y canlyniad gwirioneddol yw 1,686057971014493 ac yn cael ei arddangos yn y maes value. Nid yw hyn yn ddigon ar gyfer graddio, gan mai’r trothwy a osodwyd gennym yw 3.

Mwy o lwyth!

Yn y derfynell newydd, monitro nifer y codennau cais:

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

Gadewch i ni gynyddu'r llwyth gan ddefnyddio'r gorchymyn:

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

Ar ôl ychydig, fe welwch HPA yn graddio'r defnydd ac yn lansio codennau newydd. Gwiriwch eich HPA i wneud yn siŵr:

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

Os yw'r llwyth yn anghyson, bydd y defnydd yn cael ei leihau i'r pwynt lle mai dim ond un pod sy'n rhedeg. Os ydych chi am wirio'r metrig gwirioneddol (a ddychwelwyd gan ymholiad PromQL), yna defnyddiwch y gorchymyn:

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

Glanhau

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

Casgliad

Mae KEDA yn caniatáu ichi raddio'ch gosodiadau Kubernetes yn awtomatig (i / o sero) yn seiliedig ar ddata o fetrigau allanol. Er enghraifft, yn seiliedig ar fetrigau Prometheus, hyd y ciw yn Redis, hwyrni defnyddwyr yn y pwnc Kafka.

Mae KEDA yn integreiddio â ffynhonnell allanol ac mae hefyd yn darparu ei fetrigau trwy Metrics Server i Horizontal Pod Autoscaler.

Pob lwc!

Beth arall i'w ddarllen:

Ffynhonnell: hab.com

Autoscaling cymwysiadau Kubernetes gan ddefnyddio Prometheus a KEDA