🥇 Feidhmchláir Kubernetes a uathscálú ag baint úsáide as Prometheus agus KEDA

Fear Balún le Cimuanos

Is príomhriachtanas é scalability d'iarratais scamall. Le Kubernetes, tá sé chomh simplí feidhmchlár a scálú le líon na macasamhla a mhéadú don imscaradh cuí nó ReplicaSet - ach is próiseas láimhe é.

Ligeann Kubernetes feidhmchláir a scála go huathoibríoch (i.e. Podaí in imscaradh nó ReplicaSet) ar mhodh dearbhaithe ag baint úsáide as an tsonraíocht Uathscálaálaí Pod Cothrománach. Is é an critéar réamhshocraithe le haghaidh scálaithe uathoibríoch ná méadracht úsáide LAP (méadracht acmhainne), ach is féidir leat méadracht saincheaptha agus a sholáthraítear go seachtrach a chomhtháthú.

Foireann Kubernetes aaS ó Mail.ru d'aistrigh alt ar conas méadracht sheachtrach a úsáid chun feidhmchlár Kubernetes a scála go huathoibríoch. Chun a thaispeáint conas a oibríonn gach rud, úsáideann an t-údar méadracht iarratais rochtana HTTP, a bhailítear ag baint úsáide as Prometheus.

In ionad autoscaling cothrománach pods, úsáidtear Kubernetes Event Driven Autoscaling (KEDA), oibreoir foinse oscailte Kubernetes. Comhtháthaíonn sé go dúchais le Cothrománach Pod Autoscaler chun uathscálú gan uaim (lena n-áirítear go / ó nialas) a sholáthar le haghaidh ualaí oibre atá tiomáinte ag imeachtaí. Cód ar fáil ag GitHub.

Forbhreathnú gairid ar an gcóras

Taispeánann an léaráid cur síos gairid ar conas a oibríonn gach rud:

Soláthraíonn an feidhmchlár méadracht chomhairimh hit HTTP i bhformáid Prometheus.
Tá Prometheus cumraithe chun na méadrachtaí seo a bhailiú.
Tá an scálaire Prometheus i KEDA cumraithe chun an feidhmchlár a scála go huathoibríoch bunaithe ar líon na n-amas HTTP.

Anois inseoidh mé duit go mion faoi gach eilimint.

KEDA agus Prometheus

Is foireann uirlisí faireacháin agus foláirimh córais foinse oscailte é Prometheus, cuid Fondúireacht Ríomhaireachta Dúchasach Cloud. Bailíonn sé méadracht ó fhoinsí éagsúla agus stóráiltear iad mar shonraí sraith ama. Is féidir leat úsáid a bhaint as chun sonraí a shamhlú grafana nó uirlisí léirshamhlaithe eile a oibríonn leis an Kubernetes API.

Tacaíonn KEDA leis an gcoincheap scálaire - feidhmíonn sé mar dhroichead idir KEDA agus an córas seachtrach. Baineann cur i bhfeidhm an scálaitheora go sonrach le gach córas sprice agus baintear sonraí uaidh. Úsáideann KEDA iad ansin chun scálú uathoibríoch a rialú.

Tacaíonn scálairí le foinsí iomadúla sonraí, mar shampla, Kafka, Redis, Prometheus. Is é sin, is féidir KEDA a úsáid chun imscaradh Kubernetes a scála go huathoibríoch ag baint úsáide as méadracht Prometheus mar chritéir.

Iarratas tástála

Soláthraíonn feidhmchlár tástála Golang rochtain trí HTTP agus comhlíonann sé dhá fheidhm thábhachtacha:

Úsáideann sé an leabharlann cliant Prometheus Go chun an feidhmchlár a ghléasadh agus an méadrach http_requests a sholáthar, ina bhfuil comhaireamh buailte. Tá an críochphointe ina bhfuil méadracht Prometheus ar fáil suite ag an URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Mar fhreagra ar iarratas GET ardaíonn an feidhmchlár luach na heochrach (access_count) i Redis. Is bealach éasca é seo chun an obair a dhéanamh mar chuid de láimhseálaí HTTP agus méadracht Prometheus a sheiceáil freisin. Caithfidh an luach méadrach a bheith mar an gcéanna leis an luach access_count i 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)
   }

Déantar an feidhmchlár a imscaradh chuig Kubernetes trí Deployment. Cruthaítear seirbhís freisin ClusterIP, ceadaíonn sé don fhreastalaí Prometheus méadracht iarratais a fháil.

Anseo léiriú imlonnaithe don iarratas.

Freastalaí Prometheus

Is éard atá i léiriú imscartha Prometheus ná:

ConfigMap — chumraíocht Prometheus a aistriú;
Deployment — chun Prometheus a imscaradh i mbraisle Kubernetes;
ClusterIP — seirbhís le haghaidh rochtana ar Chomhéadain Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — le haghaidh uathbhraite seirbhísí in Kubernetes (Uathfhionnachtain).

Anseo Léiriú le haghaidh rith Prometheus.

KEDA Prometheus Scála réad

Feidhmíonn an scálaire mar dhroichead idir KEDA agus an córas seachtrach óna dteastaíonn méadracht. ScaledObject Is acmhainn shaincheaptha é nach mór a imscaradh chun an t-imscaradh a shioncronú le foinse an imeachta, sa chás seo Prometheus.

ScaledObject ina bhfuil faisnéis maidir le scálaithe imlonnaithe, meiteashonraí foinse imeachta (amhail rúin nasc, ainm scuaine), eatramh vótaíochta, tréimhse aisghabhála, agus sonraí eile. Is é an toradh atá air ná an acmhainn uathscálaithe comhfhreagrach (sainmhíniú HPA) chun an t-imscaradh a scála.

Nuair a réad ScaledObject scriostar, glantar an sainmhíniú HPA comhfhreagrach.

Seo é an sainmhíniú ScaledObject mar shampla, úsáideann sé scálaire 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]))

Smaoinigh ar na pointí seo a leanas:

Pointí sé go Deployment Le hainm go-prom-app.
Cineál truicear - Prometheus. Luaitear seoladh an fhreastalaí Prometheus mar aon leis an ainm méadrach, an tairseach agus Ceist PromQL, a úsáidfear. Iarratas PromQL - sum(rate(http_requests[2m])).
De réir pollingInterval, Iarrann KEDA sprioc ó Prometheus gach cúig shoicind déag. Ar a laghad ceann amháin faoi (minReplicaCount), agus ní sháraíonn an líon uasta pods maxReplicaCount (sa sampla seo - deich).

Is féidir a shuiteáil minReplicaCount comhionann le nialas. Sa chás seo, gníomhaíonn KEDA an t-imscaradh náid le duine agus ansin nochtar an HPA le haghaidh tuilleadh scálaithe uathoibríoch. Is féidir an t-ordú droim ar ais a dhéanamh freisin, is é sin, scálú ó aon go nialas. Sa sampla, níor roghnaigh muid nialas toisc gur seirbhís HTTP é seo agus ní córas ar éileamh.

An draíocht taobh istigh autoscaling

Úsáidtear an tairseach mar thruicear chun an t-imscaradh a scála. Inár sampla, an cheist PromQL sum(rate (http_requests [2m])) cuireann sé ar ais an ráta iarratais HTTP comhiomlán (iarratais sa soicind), arna thomhas thar an dá nóiméad dheireanacha.

Ós rud é go bhfuil an luach tairsí trí, ciallaíonn sé go mbeidh ceann amháin faoi agus an luach sum(rate (http_requests [2m])) níos lú ná trí. Má thagann méadú ar an luach, cuirtear fo-mhír bhreise leis gach uair sum(rate (http_requests [2m])) méaduithe faoi thrí. Mar shampla, má tá an luach ó 12 go 14, ansin tá líon na pods ceithre.

Anois déanaimis iarracht é a shocrú!

réamhshocrú

Níl uait ach braisle Kubernetes agus fóntais cumraithe kubectl. Úsáideann an sampla seo braisle minikube, ach is féidir leat aon cheann eile a ghlacadh. Chun braisle a shuiteáil tá treoir.

Suiteáil an leagan is déanaí 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/

Socraigh cubectlrochtain a fháil ar bhraisle Kubernetes.

Suiteáil an leagan is déanaí 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

Suiteáil KEDA

Is féidir leat KEDA a imscaradh ar bhealaí éagsúla, tá siad liostaithe i doiciméadú. Tá YAML monolithic á úsáid agam:

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

Tá KEDA agus a chomhpháirteanna suiteáilte san ainmspás keda. Ordú le seiceáil:

kubectl get pods -n keda

Fan go dtosóidh Oibreoir KEDA agus téigh go dtí Running State. Agus ina dhiaidh sin, lean ar aghaidh.

Suiteáil Redis ag baint úsáide as Helm

Mura bhfuil Helm suiteáilte agat, úsáid é seo ceannaireacht. Ordú a shuiteáil ar Mac:

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

helm init cuireann sé an comhéadan líne ordaithe áitiúil i dtosach agus suiteálann sé freisin Tiller chuig braisle Kubernetes.

kubectl get pods -n kube-system | grep tiller

Fan go dtiocfaidh an pod Tiller isteach sa stát Rith.

Nóta aistritheora: Úsáideann an t-údar Helm@2, a éilíonn an chomhpháirt freastalaí Tiller a shuiteáil. Anois go bhfuil Helm@3 ábhartha, níl cuid freastalaí ag teastáil uaidh.

Tar éis Helm a shuiteáil, is leor ordú amháin chun Redis a thosú:

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

Fíoraigh gur éirigh le Redis:

kubectl get pods/redis-server-master-0

Fan go dtiocfaidh Redis isteach sa stát Running.

Imscaradh Feidhmchláir

Ordú imlonnaithe:

kubectl apply -f go-app.yaml

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

Seiceáil go bhfuil gach rud tosaithe:

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

Fan go dtiocfaidh Redis isteach sa stát Running.

Freastalaí Prometheus a imscaradh

Úsáideann an léiriú Prometheus Fionnachtain Seirbhíse Kubernetes do Prometheus. Ligeann sé pods feidhmchlár a aimsiú go dinimiciúil bunaithe ar an lipéad seirbhíse.

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

Chun imscaradh:

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

Seiceáil go bhfuil gach rud tosaithe:

kubectl get pods -l=app=prometheus-server

Fan go dtiocfaidh Prometheus isteach sa stát Running.

Bain úsáid as kubectl port-forward chun comhéadan úsáideora Prometheus (nó freastalaí API) a rochtain ag http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Cumraíocht Uathscálaithe KEDA a Imscaradh

Ordú a chruthú ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Seiceáil logaí oibreora KEDA:

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

Breathnaíonn an toradh rud éigin mar seo:

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"

Seiceáil faoi iarratais. Caithfidh sampla amháin a bheith ar siúl mar gheall ar minReplicaCount cothrom le 1:

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

Fíoraigh gur éirigh leis an acmhainn HPA a chruthú:

kubectl get hpa

Ba cheart go bhfeicfeá rud éigin mar:

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

Seiceáil sláinte: rochtain ar fheidhmchláir

Chun críochphointe REST ár bhfeidhmchlár a rochtain, rith:

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

Is féidir leat rochtain a fháil anois ar d’aip Téigh tríd an seoladh a úsáid http://localhost:8080. Chun seo a dhéanamh, rith an t-ordú:

curl http://localhost:8080/test

Breathnaíonn an toradh rud éigin mar seo:

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

Ag an bpointe seo seiceáil freisin Redis. Feicfidh tú go bhfuil an eochair access_count méadaithe go 1:

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

Déan cinnte go bhfuil an luach méadrach http_requests mar an gcéanna:

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

Cruthú Luchtaigh

Úsáidfimid hug — áirgiúlacht chun ualach a ghiniúint:

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

Is féidir leat a íoslódáil freisin an fóntais le haghaidh Linux nó Windows.

Rith é:

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

De réir réamhshocraithe, seolann an áirgiúlacht 200 iarratas. Is féidir leat é seo a fhíorú ag baint úsáide as méadracht Prometheus chomh maith le 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

Bailíochtaigh luach na méadrach iarbhír (ar ais ag an gceist 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"]}]}}

Sa chás seo is é an toradh iarbhír 1,686057971014493 agus tá sé ar taispeáint sa réimse value. Ní leor é seo le haghaidh scálaithe, mar is é 3 an tairseach a leagamar síos.

Níos mó ualach!

Sa teirminéal nua, déan monatóireacht ar líon na pods feidhmchlár:

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

Méadóimid an t-ualach ag baint úsáide as an ordú:

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

Tar éis tamaill, feicfidh tú HPA ag scálaiú an imscartha agus ag seoladh pods nua. Seiceáil do HPA chun a chinntiú:

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

Má tá an t-ualach ar neamhréir, laghdófar an t-imscaradh go dtí an pointe nach bhfuil ach pod amháin ag rith. Más mian leat an méadrach iarbhír a sheiceáil (ar ais ag an gceist PromQL), bain úsáid as an ordú:

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

Glanadh

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

Conclúid

Ligeann KEDA duit d'imscaradh Kubernetes a scála go huathoibríoch (go / ó nialas) bunaithe ar shonraí ó mhéadracht sheachtrach. Mar shampla, bunaithe ar mhéadracht Prometheus, fad scuaine i Redis, latency tomhaltóra i Kafka topaic.

Comhtháthaíonn KEDA le foinse sheachtrach agus cuireann sé a mhéadracht ar fáil freisin trí Freastalaí Méadrach go Pod Cothrománach Autoscaler.

N-éirí leat!

Cad eile atá le léamh:

Foinse: will.com

Feidhmchláir Kubernetes a scálú go huathoibríoch ag baint úsáide as Prometheus agus KEDA