ProHoster > Blog > Rianachd > A’ dèanamh fèin-sgèileadh air tagraidhean Kubernetes a’ cleachdadh Prometheus agus KEDA

A’ dèanamh fèin-sgèileadh air tagraidhean Kubernetes a’ cleachdadh Prometheus agus KEDA

A’ dèanamh fèin-sgèileadh air tagraidhean Kubernetes a’ cleachdadh Prometheus agus KEDABalloon Man le Cimuano

Tha scalability na phrìomh riatanas airson tagraidhean sgòthan. Le Kubernetes, tha sgèileadh tagradh cho sìmplidh ri bhith ag àrdachadh an àireamh de mhac-samhail airson an cleachdadh iomchaidh no ReplicaSet - ach is e pròiseas làimhe a th’ ann.

Leigidh Kubernetes le tagraidhean a bhith air an sgèileadh gu fèin-ghluasadach (ie Pods ann an cleachdadh no ReplicaSet) ann an dòigh dhearbhach a’ cleachdadh an t-sònrachadh Horizontal Pod Autoscaler. Is e an slat-tomhais bunaiteach airson sgèileadh fèin-ghluasadach metrics cleachdadh CPU (meatairean stòrais), ach faodaidh tu metrics gnàthaichte agus taobh a-muigh a thoirt a-steach.

sgioba Kubernetes aaS bho Mail.ru eadar-theangachadh artaigil air mar a chleachdas tu meatrach taobh a-muigh gus iarrtas Kubernetes a sgèile gu fèin-ghluasadach. Gus sealltainn mar a tha a h-uile càil ag obair, bidh an t-ùghdar a’ cleachdadh metrics iarrtas ruigsinneachd HTTP, a tha air an cruinneachadh a’ cleachdadh Prometheus.

An àite fèin-sgèileadh còmhnard de pods, thathas a’ cleachdadh Kubernetes Event Driven Autoscaling (KEDA), gnìomhaiche stòr fosgailte Kubernetes. Bidh e a’ fighe a-steach gu dùthchasach le Horizontal Pod Autoscaler gus fèin-sgèileadh fuaigheil a thoirt seachad (a’ toirt a-steach gu / bho neoni) airson eallach obrach air a stiùireadh le tachartas. Còd ri fhaighinn aig GitHub.

Geàrr-chunntas air an t-siostam

A’ dèanamh fèin-sgèileadh air tagraidhean Kubernetes a’ cleachdadh Prometheus agus KEDA

Tha an diagram a’ sealltainn tuairisgeul goirid air mar a tha a h-uile càil ag obair:

  1. Tha an tagradh a’ toirt seachad meatrach àireamh hit HTTP ann an cruth Prometheus.
  2. Tha Prometheus air a rèiteachadh gus na meatrach sin a chruinneachadh.
  3. Tha an sgèilear Prometheus ann an KEDA air a rèiteachadh gus an tagradh a sgèileadh gu fèin-ghluasadach stèidhichte air an àireamh de bhuillean HTTP.

A-nis innsidh mi dhut gu mionaideach mu gach eileamaid.

KEDA agus Prometheus

Tha Prometheus na inneal sgrùdaidh agus rabhaidh siostam stòr fosgailte, pàirt Bunait Coimpiutaireachd Dùthchasach Cloud. A’ cruinneachadh metrics bho dhiofar thùsan agus gan stòradh mar dàta sreath ùine. Gus dàta fhaicinn, faodaidh tu a chleachdadh grafana no innealan seallaidh eile a bhios ag obair leis an Kubernetes API.

Tha KEDA a 'toirt taic don bhun-bheachd de sgèileadair - tha e na dhrochaid eadar KEDA agus an siostam a-muigh. Tha buileachadh an sgèileadair sònraichte do gach siostam targaid agus a’ tarraing dàta bhuaithe. Bidh KEDA an uairsin gan cleachdadh gus smachd a chumail air sgèileadh fèin-ghluasadach.

Bidh scalers a’ toirt taic do ghrunn stòran dàta, mar eisimpleir, Kafka, Redis, Prometheus. Is e sin, faodar KEDA a chleachdadh gus cleachdadh Kubernetes a sgèile gu fèin-ghluasadach a’ cleachdadh metrics Prometheus mar shlatan-tomhais.

Iarrtas deuchainn

Tha tagradh deuchainn Golang a’ toirt cothrom tro HTTP agus a’ coileanadh dà ghnìomh chudromach:

  1. A’ cleachdadh leabharlann teachdaiche Prometheus Go gus an tagradh a chleachdadh agus am meatrach http_requests a thoirt seachad, anns a bheil cunntas bhuail. Tha an t-àite crìochnachaidh far a bheil metrics Prometheus rim faighinn aig an URI /metrics. 
    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
  2. Mar fhreagairt air iarrtas GET bidh an tagradh ag àrdachadh luach na h-iuchrach (access_count) ann an Redis. Is e dòigh fhurasta a tha seo airson an obair a dhèanamh mar phàirt de làimhseachadh HTTP agus cuideachd sùil a thoirt air metrics Prometheus. Feumaidh an luach meatrach a bhith co-ionann ris an luach access_count ann an 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)
   }

Tha an tagradh air a chuir gu Kubernetes tro Deployment. Tha seirbheis air a chruthachadh cuideachd ClusterIP, leigidh e le frithealaiche Prometheus metrics tagraidh fhaighinn.

an seo cleachdadh follaiseach airson an tagraidh.

Prometheus am frithealaiche a

Tha cleachdadh Prometheus air a dhèanamh suas de:

  • ConfigMap - gus an rèiteachadh Prometheus a ghluasad;
  • Deployment - airson Prometheus a chuir a-steach ann am buidheann Kubernetes;
  • ClusterIP - seirbheis airson faighinn gu UI Prometheus;
  • ClusterRole, ClusterRoleBinding и ServiceAccount - airson fèin-lorg seirbheisean ann an Kubernetes (Auto-lorg).

an seo follaiseach air son ruith Prometheus.

Rudan sgèile KEDA Prometheus

Tha an sgèilear ag obair mar dhrochaid eadar KEDA agus an siostam a-muigh às am feumar metrics fhaighinn. ScaledObject na ghoireas àbhaisteach a dh’ fheumar a chleachdadh gus an cleachdadh a shioncronachadh le stòr an tachartais, sa chùis seo Prometheus.

ScaledObject anns a bheil fiosrachadh sgèileadh cleachdadh, meata-dàta stòr tachartais (leithid dìomhaireachdan ceangail, ainm ciudha), àm bhòtaidh, ùine ath-bheothachaidh, agus dàta eile. Bidh e a’ leantainn gu goireas fèin-sgèile co-fhreagarrach (mìneachadh HPA) gus an cleachdadh a sgèileadh.

Nuair a nì nì ScaledObject air a dhubhadh às, tha am mìneachadh HPA co-fhreagarrach air a ghlanadh.

Seo am mìneachadh ScaledObject airson ar n-eisimpleir, bidh e a’ cleachdadh sgèilear 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]))

Thoir an aire do na puingean a leanas:

  1. Tha e a’ comharrachadh Deployment Le ainm go-prom-app.
  2. Seòrsa brosnachaidh - Prometheus. Thathas a’ toirt iomradh air seòladh frithealaiche Prometheus còmhla ris an ainm meatrach, stairsneach agus Ceist PromQL, a thèid a chleachdadh. Ceist PromQL - sum(rate(http_requests[2m])).
  3. A rèir pollingInterval, Bidh KEDA ag iarraidh targaid bho Prometheus a h-uile còig diog deug. Co-dhiù aon fo (minReplicaCount), agus chan eil an àireamh as motha de pods nas àirde na maxReplicaCount (anns an eisimpleir seo - deich).

Faodar a stàladh minReplicaCount co-ionann ri neoni. Anns a ’chùis seo, bidh KEDA a’ gnìomhachadh cleachdadh neoni-gu-aon agus an uairsin a ’nochdadh an HPA airson tuilleadh sgèileadh fèin-ghluasadach. Tha an òrdugh cùil comasach cuideachd, is e sin, sgèileadh bho aon gu neoni. San eisimpleir, cha do thagh sinn neoni oir is e seirbheis HTTP a tha seo agus chan e siostam air-iarrtas.

An draoidheachd taobh a-staigh autoscaling

Tha an stairsneach air a chleachdadh mar inneal brosnachaidh gus an cleachdadh a mheudachadh. Anns an eisimpleir againn, a’ cheist PromQL sum(rate (http_requests [2m])) a’ tilleadh an ìre iarrtais HTTP iomlan (iarrtasan gach diog), air a thomhas thairis air an dà mhionaid mu dheireadh.

Leis gur e luach an stairsnich trì, tha e a’ ciallachadh gum bi aon fo fhad ‘s a tha an luach sum(rate (http_requests [2m])) nas lugha na trì. Ma thèid an luach àrdachadh, thèid fo-roinn a bharrachd a chur ris gach turas sum(rate (http_requests [2m])) àrdachadh le trì. Mar eisimpleir, ma tha an luach bho 12 gu 14, tha an àireamh de pods ceithir.

A-nis feuch sinn a rèiteachadh!

ro-aithris

Chan eil agad ach cruinneachadh Kubernetes agus goireas rèiteachaidh kubectl. Tha an eisimpleir seo a’ cleachdadh brabhsair minikube, ach faodaidh tu fear sam bith eile a ghabhail. Gus brabhsair a stàladh tha stiùireadh.

Stàlaich an tionndadh as ùire air 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/

Stàlaich cubectlgus faighinn gu buidheann Kubernetes.

Stàlaich an tionndadh as ùire air 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

Stàladh KEDA

Faodaidh tu KEDA a chleachdadh ann an grunn dhòighean, tha iad air an liostadh ann sgrìobhainnean. Tha mi a’ cleachdadh YAML monolithic:

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

Tha KEDA agus na co-phàirtean aige air an cur a-steach don spacespace keda. Òrdugh airson sgrùdadh:

kubectl get pods -n keda

Fuirich airson KEDA Operator tòiseachadh agus a dhol gu Running State. Agus às deidh sin, lean ort.

A 'stàladh Redis a' cleachdadh Helm

Mura h-eil Helm agad, cleachd seo ceannas. Òrdugh airson a stàladh air Mac:

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

helm init a’ tòiseachadh an eadar-aghaidh loidhne-àithne ionadail agus cuideachd a’ stàladh Tiller gu buidheann Kubernetes.

kubectl get pods -n kube-system | grep tiller

Fuirich airson am pod Tiller a dhol a-steach don stàit ruith.

Nota an eadar-theangair: Bidh an t-ùghdar a’ cleachdadh Helm@2, a dh’ fheumas am pàirt frithealaiche Tiller a chuir a-steach. A-nis tha Helm@3 buntainneach, chan fheum e pàirt frithealaiche.

Às deidh dhut Helm a chuir a-steach, tha aon àithne gu leòr airson Redis a thòiseachadh:

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

Dèan cinnteach gu bheil Redis air tòiseachadh gu soirbheachail:

kubectl get pods/redis-server-master-0

Fuirich airson Redis a dhol a-steach don stàit Running.

Cleachdadh Iarrtais

Òrdugh cleachdadh:

kubectl apply -f go-app.yaml

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

Dèan cinnteach gu bheil a h-uile càil air tòiseachadh:

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

Fuirich airson Redis a dhol a-steach don stàit Running.

A 'cleachdadh frithealaiche Prometheus

Tha an taisbeanadh Prometheus a’ cleachdadh Lorg seirbheis Kubernetes airson Prometheus. Leigidh e le bhith a’ lorg pods tagraidh stèidhichte air bileag na seirbheis.

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

Gus a chleachdadh:

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

Dèan cinnteach gu bheil a h-uile càil air tòiseachadh:

kubectl get pods -l=app=prometheus-server

Fuirich airson Prometheus a dhol a-steach don stàit Running.

Cleachd kubectl port-forward gus faighinn gu eadar-aghaidh cleachdaiche Prometheus (no frithealaiche API) aig http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

A’ cleachdadh KEDA Autoscaling Configuration

Òrdugh airson a chruthachadh ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Thoir sùil air logaichean gnìomhaiche KEDA:

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

Tha an toradh a’ coimhead rudeigin 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"

Thoir sùil air fo aplacaidean. Feumaidh aon eisimpleir a bhith a’ ruith air sgàth minReplicaCount co-ionann ri 1:

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

Dèan cinnteach gun deach goireas HPA a chruthachadh gu soirbheachail:

kubectl get hpa

Bu chòir dhut rudeigin mar seo fhaicinn:

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

Sgrùdadh slàinte: ruigsinneachd tagraidh

Gus faighinn gu puing crìochnachaidh REST an tagraidh againn, ruith:

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

Faodaidh tu a-nis faighinn chun app Go agad leis an t-seòladh http://localhost:8080. Gus seo a dhèanamh, ruith an àithne:

curl http://localhost:8080/test

Tha an toradh a’ coimhead rudeigin mar seo:

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

Aig an ìre seo cuideachd thoir sùil air Redis. Chì thu sin an iuchair access_count àrdachadh gu 1:

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

Dèan cinnteach gu bheil an luach meatrach http_requests An t-aon rud:

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

Cruthachadh Luchdaich

Cleachdaidh sinn Hey - goireas airson luchdan a ghineadh:

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

Faodaidh tu cuideachd an goireas a luchdachadh sìos airson Linux no Windows.

Ruith e:

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

Gu gnàthach, bidh an goireas a’ cur 200 iarrtas. Faodaidh tu seo a dhearbhadh le bhith a’ cleachdadh Prometheus metrics a bharrachd air 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

Dearbhaich luach an fhìor mheatrach (air a thilleadh le ceist 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"]}]}}

Anns a 'chùis seo, tha an toradh fìor 1,686057971014493 agus tha e air a thaisbeanadh san raon value. Chan eil seo gu leòr airson sgèileadh, oir is e 3 an stairsneach a shuidhich sinn.

Barrachd luchdan!

Anns a’ chrìoch ùr, cùm sùil air an àireamh de pods tagraidh:

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

Meudaichidh sinn an luchd leis an àithne: 

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

An ceann greiseag, chì thu HPA a 'sgèileadh an cleachdadh agus a' cur air bhog pods ùra. Thoir sùil air an HPA agad gus dèanamh cinnteach:

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

Ma tha an luchd neo-chunbhalach, thèid an cleachdadh a lughdachadh chun na h-ìre far nach eil ach aon pod a’ ruith. Ma tha thu airson sùil a thoirt air an fhìor mheatrach (air a thilleadh le ceist PromQL), cleachd an àithne:

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

co-dhùnadh

Leigidh KEDA leat na cleachdaidhean Kubernetes agad a sgèileadh gu fèin-ghluasadach (gu / bho neoni) stèidhichte air dàta bho mheatrics taobh a-muigh. Mar eisimpleir, stèidhichte air metrics Prometheus, fad ciudha ann an Redis, latency luchd-cleachdaidh ann an cuspair Kafka.

Bidh KEDA a’ fighe a-steach le stòr bhon taobh a-muigh agus cuideachd a’ toirt seachad a mheatairean tro Metrics Server gu Horizontal Pod Autoscaler.

Beannachd leat

Dè eile ri leughadh:

  1. Na cleachdaidhean as fheàrr agus na cleachdaidhean as fheàrr airson ruith shoithichean agus Kubernetes ann an àrainneachdan cinneasachaidh.
  2. 90+ innealan feumail airson Kubernetes: cleachdadh, riaghladh, sgrùdadh, tèarainteachd agus barrachd.
  3. An sianal againn timcheall air Kubernetes ann an Telegram.

Source: www.habr.com

Cuir beachd ann