🥇Kubernetes aplikazioen eskala automatikoa Prometheus eta KEDA

Globo Gizona Cimuanosen eskutik

Eskalagarritasuna funtsezko baldintza da hodeiko aplikazioetarako. Kubernetes-ekin, aplikazio bat eskalatzea egokia den inplementaziorako erreplika kopurua handitzea bezain erraza da ReplicaSet — baina eskuzko prozesu bat da.

Kubernetes-ek aplikazioak automatikoki eskalatzeko aukera ematen du (hau da, inplementazio bateko podak edo ReplicaSet) modu deklaratiboan Horizontal Pod Autoscaler zehaztapena erabiliz. Eskalatze automatikoaren irizpide lehenetsia PUZaren erabilera-neurriak dira (baliabide-neurriak), baina neurri pertsonalizatuak eta kanpotik emandako neurriak integra ditzakezu.

Team Kubernetes aaS Mail.ru-tik artikulu bat itzuli du kanpo-neurriak nola erabili Kubernetes aplikazio bat automatikoki eskalatzeko. Dena nola funtzionatzen duen erakusteko, egileak HTTP sarbide-eskaeraren neurketak erabiltzen ditu, Prometheus erabiliz biltzen direnak.

Poden eskalatze automatiko horizontalaren ordez, Kubernetes Event Driven Autoscaling (KEDA) erabiltzen da, kode irekiko Kubernetes operadorea. Natiboki integratzen da Horizontal Pod Autoscaler-ekin eskalatze automatikoa (zerotik/zerotik barne) eskalatze automatikoa eskaintzeko, gertaeren araberako lan-kargak. Kodea eskuragarri helbidean GitHub.

Sistemaren ikuspegi laburra

Diagramak guztiaren funtzionamenduaren deskribapen labur bat erakusten du:

Aplikazioak HTTP hit-kopuruaren neurketak eskaintzen ditu Prometheus formatuan.
Prometheus metrika hauek biltzeko konfiguratuta dago.
KEDA-ko Prometheus eskalatzailea aplikazioa automatikoki eskalatzeko konfiguratuta dago HTTP hit-en kopuruaren arabera.

Orain elementu bakoitzari buruz zehatz-mehatz kontatuko dizuet.

KEDA eta Prometeo

Prometheus kode irekiko sistemaren jarraipena eta alerta-tresna-tresna bat da Cloud Native Computing Fundazioa. Hainbat iturritako neurketak biltzen ditu eta denbora serieko datu gisa gordetzen ditu. Erabili ditzakezun datuak ikusteko Grafana edo Kubernetes APIarekin lan egiten duten bisualizazio tresnak.

KEDA-k eskalatzaile baten kontzeptua onartzen du - KEDAren eta kanpoko sistemaren arteko zubi gisa jokatzen du. Eskalatzaileen inplementazioa helburu-sistema bakoitzerako espezifikoa da eta bertatik datuak ateratzen ditu. Ondoren, KEDAk eskalatze automatikoa kontrolatzeko erabiltzen ditu.

Eskalatzaileek hainbat datu-iturri onartzen dituzte, adibidez, Kafka, Redis, Prometheus. Hau da, KEDA Kubernetes inplementazioak automatikoki eskalatzeko erabil daiteke Prometheus-en neurketak irizpide gisa erabiliz.

Test aplikazioa

Golang test aplikazioak HTTP bidez sarbidea ematen du eta bi funtzio garrantzitsu betetzen ditu:

Prometheus Go bezero-liburutegia erabiltzen du aplikazioa instrumentatzeko eta http_requests metrika eskaintzeko, zeinak hit-zenbaketa daukana. Prometheus-en neurketak eskuragarri dauden amaierako puntua URIan dago /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Eskaera bati erantzunez GET aplikazioak gakoaren balioa handitzen du (access_count) Redis-en. Hau HTTP kudeatzaile baten zati gisa lana egiteko modu erraza da eta Prometheus-en neurketak ere egiaztatzeko. Balio metrikoak balioaren berdina izan behar du access_count Redis-en.

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)
   }

Aplikazioa Kubernetesen bidez zabaltzen da Deployment. Zerbitzu bat ere sortzen da ClusterIP, Prometheus zerbitzariari aplikazioen metrika lortzeko aukera ematen dio.

Hemen aplikazioaren hedapen manifestua.

Prometheus zerbitzaria

Prometheus inplementazioaren manifestuak honako hauek ditu:

ConfigMap — Prometheus konfigurazioa transferitzeko;
Deployment — Prometheus Kubernetes kluster batean zabaltzeagatik;
ClusterIP — UI Prometheus-era sartzeko zerbitzua;
ClusterRole, ClusterRoleBinding и ServiceAccount — Kubernetes-en zerbitzuak automatikoki hautemateko (Auto-aurkikuntza).

Hemen Prometeo martxan jartzeko manifestua.

KEDA Prometheus ScaledObject

Eskalatzaileak KEDAren eta kanpoko sistemaren arteko zubi gisa funtzionatzen du eta bertatik neurketak lortu behar dira. ScaledObject Inplementazioa gertaeren iturburuarekin sinkronizatzeko hedatu behar den baliabide pertsonalizatua da, kasu honetan Prometheus.

ScaledObject inplementazioa eskalatzeko informazioa, gertaeren iturburuko metadatuak (adibidez, konexio sekretuak, ilararen izena), galdeketaren tartea, berreskuratzeko epea eta beste datu batzuk ditu. Dagokion eskalatze automatikoko baliabidea (HPA definizioa) sortzen du hedapena eskalatzeko.

Objektu bat denean ScaledObject ezabatzen da, dagokion HPA definizioa garbitzen da.

Hona hemen definizioa ScaledObject gure adibidez, eskalatzailea erabiltzen du 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]))

Kontuan izan puntu hauek:

Seinalatu zuen Deployment Izenarekin go-prom-app.
Trigger mota - Prometheus. Prometheus zerbitzariaren helbidea aipatzen da metrikaren izenarekin, atalasearekin eta PromQL kontsulta, erabiliko dena. PromQL kontsulta - sum(rate(http_requests[2m])).
Arabera pollingInterval,KEDAk helburu bat eskatzen dio Prometheusi hamabost segundoro. Gutxienez bat azpian (minReplicaCount), eta lekaren gehienezko kopurua ez da gainditzen maxReplicaCount (adibide honetan - hamar).

Instalatu daiteke minReplicaCount zeroren berdina. Kasu honetan, KEDAk zero-to-one inplementazioa aktibatzen du eta gero HPA agerian uzten du eskalatze automatiko gehiago egiteko. Alderantzizko ordena ere posible da, hau da, batetik zerora eskalatzea. Adibidean, ez dugu zero hautatu hau HTTP zerbitzu bat delako eta ez eskaeraren araberako sistema bat.

Eskalatze automatikoaren barruan dagoen magia

Atalasea abiarazle gisa erabiltzen da hedapena eskalatzeko. Gure adibidean, PromQL kontsulta sum(rate (http_requests [2m])) HTTP eskaera-tasa (segundoko eskaerak) bateratua itzultzen du, azken bi minutuetan neurtuta.

Atalasearen balioa hirukoa denez, balioaren azpitik bat egongo dela esan nahi du sum(rate (http_requests [2m])) hiru baino gutxiago. Balioa handitzen bada, azpiko gehigarri bat gehitzen da bakoitzean sum(rate (http_requests [2m])) hirutan handitzen da. Adibidez, balioa 12tik 14ra bitartekoa bada, orduan lek kopurua lau da.

Orain saia gaitezen konfiguratzen!

Aurrez ezartzea

Behar duzun guztia Kubernetes kluster bat eta konfiguratutako utilitate bat da kubectl. Adibide honek cluster bat erabiltzen du minikube, baina beste edozein har dezakezu. Cluster bat instalatzeko dago lidergoa.

Instalatu azken bertsioa Mac-en:

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/

instalatu kubectlKubernetes klusterera sartzeko.

Instalatu azken bertsioa Mac-en:

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 instalazioa

KEDA hainbat modutara inplementa dezakezu, zerrendan daude dokumentazioa. YAML monolitikoa erabiltzen ari naiz:

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

KEDA eta bere osagaiak izenen espazioan instalatzen dira keda. Egiaztatzeko komandoa:

kubectl get pods -n keda

Itxaron KEDA Operator hasi arte eta joan Running State. Eta horren ostean, jarraitu.

Helm erabiliz Redis instalatzen

Helm instalatuta ez baduzu, erabili hau lidergoa. Mac-en instalatzeko komandoa:

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

helm init tokiko komando-lerroko interfazea hasieratzen du eta instalatzen du Tiller Kubernetes klusterera.

kubectl get pods -n kube-system | grep tiller

Itxaron Tiller poda Korrika egoeran sartu arte.

Itzultzailearen oharra: egileak Helm@2 erabiltzen du, eta horrek Tiller zerbitzariaren osagaia instalatu behar du. Orain Helm@3 garrantzitsua da, ez du zerbitzariaren zatirik behar.

Helm instalatu ondoren, komando bat nahikoa da Redis abiarazteko:

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

Egiaztatu Redis behar bezala hasi dela:

kubectl get pods/redis-server-master-0

Itxaron Redis egoerara joan arte Running.

Aplikazioaren hedapena

Inplementatzeko komandoa:

kubectl apply -f go-app.yaml

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

Egiaztatu dena hasi dela:

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

Itxaron Redis egoeran sartu arte Running.

Prometheus zerbitzari bat zabaltzea

Prometheus manifest erabilerak Prometheus-erako Kubernetes Zerbitzuaren aurkikuntza. Zerbitzu-etiketan oinarritutako aplikazio-poden aurkikuntza dinamikoa ahalbidetzen du.

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

Hedatzeko:

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

Egiaztatu dena hasi dela:

kubectl get pods -l=app=prometheus-server

Itxaron Prometeo egoerara joan arte Running.

erabilera kubectl port-forward Prometheus erabiltzailearen interfazera (edo API zerbitzaria) sartzeko http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA Autoscaling konfigurazioa zabaltzen

Sortzeko komandoa ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Begiratu KEDA operadoreen erregistroak:

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

Emaitza honelakoa da:

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"

Begiratu aplikazioen azpian. Instantzia bat exekutatzen egon behar da minReplicaCount 1 berdin:

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

Egiaztatu HPA baliabidea behar bezala sortu dela:

kubectl get hpa

Horrelako zerbait ikusi beharko zenuke:

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

Osasun-egiaztapena: aplikaziorako sarbidea

Gure aplikazioaren REST amaiera puntura sartzeko, exekutatu:

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

Orain zure Go aplikaziora sar zaitezke helbidea erabiliz http://localhost:8080. Horretarako, exekutatu komandoa:

curl http://localhost:8080/test

Emaitza honelakoa da:

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

Une honetan ere egiaztatu Redis. Hori ikusiko duzu gakoa access_count 1era igo da:

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

Ziurtatu balio metrikoa dela http_requests berdina:

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

Karga sortzea

Erabiliko dugu hey — Karga sortzeko erabilgarritasuna:

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

Era berean, erabilgarritasuna deskarga dezakezu Linux edo Windows.

Exekutatu:

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

Lehenespenez, utilitateak 200 eskaera bidaltzen ditu. Hori egiazta dezakezu Prometheus metrics eta baita Redis erabiliz.

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

Baliozkotu benetako metrikaren balioa (PromQL kontsultak itzultzen duena):

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

Kasu honetan benetako emaitza da 1,686057971014493 eta eremuan bistaratzen da value. Hau ez da nahikoa eskalatzeko, ezarri dugun atalasea 3 baita.

Karga gehiago!

Terminal berrian, kontrolatu aplikazio-kopurua:

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

Handitu dezagun karga komandoa erabiliz:

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

Pixka bat igaro ondoren, HPA hedapena eskalatzen eta pod berriak abiarazten ikusiko dituzu. Egiaztatu zure HPA ziurtatzeko:

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

Karga koherentea ez bada, hedapena pod bakarra exekutatzen ari den punturaino murriztuko da. Benetako metrika egiaztatu nahi baduzu (PromQL kontsultak itzultzen duena), erabili komandoa:

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

garbiketa

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

Ondorioa

KEDAk zure Kubernetes inplementazioak automatikoki eskala ditzakezu (zerotik/zerotik) kanpoko neurketen datuetan oinarrituta. Adibidez, Prometheus-en metriketan oinarrituta, ilararen luzera Redis-en, kontsumitzaileen latentzia Kafka gaian.

KEDA kanpoko iturri batekin integratzen da eta metrika-zerbitzariaren bidez ere eskaintzen ditu Horizontal Pod Autoscaler-i.

Good Luck!

Zer gehiago irakurri:

Iturria: www.habr.com

Kubernetes aplikazioak autoeskalatzea Prometheus eta KEDA erabiliz