🥇Kubernetes'i rakenduste automaatne skaleerimine Prometheuse ja KEDA abil

Balloon Man by Cimuanos

Skaleeritavus on pilve rakenduste põhivajadus. Kuberneteses on rakenduse skaleerimine sama lihtne kui koopia arvu suurendamine vastavale kasutusele või ReplicaSet — kuid see on käsitsi protsess.

Kubernetes võimaldab rakenduste automaatset skaleerimist (st Pod rakenduses või ReplicaSet) deklaratiivsel viisil, kasutades Horizontal Pod Autoscaler spetsifikatsiooni. Vaikimisi on automaatse skaleerimise kriteeriumid CPU kasutuse meetrikad (ressursimeetrikad), kuid saab integreerida ka kohandatud meetrikad ja välise pakkumisega meetrikad.

Meeskond Kubernetes aaS Mail.ru-lt tõlkis artikli sellest, kuidas kasutada välist mõõdikud Kubernetes rakenduse automaatseks skaleerimiseks. Autori poolt näidatud, kuidas kõik töötab, kasutatakse HTTP päringute mõõdikud, mis kogutakse Prometheus'e abil.

Horisonthaalsete podide automaatse skaleerimise asemel rakendatakse Kubernetes Event Driven Autoscaling (KEDA) — avatud lähtekoodiga Kubernetes operaator. See integreerub algselt Horizontal Pod Autoscaleriga, et tagada sujuv automaatne skaleerimine (sealhulgas nullist skaleerimine) sündmustele orienteeritud töökoormustele. Kood on saadaval GitHub.

Süsteemi töö ülevaade

Skeemil on lühike kirjeldus sellest, kuidas kõik töötab:

Rakendus pakub HTTP-päringute arvust mõõdikud Prometheus formaadis.
Prometheus on seadistatud nende näitajate kogumiseks.
Prometheuse skaleerija KEDA-s on seadistatud rakenduse automaatseks skaleerimiseks lähtudes HTTP päringute arvust.

Nüüd tutvustan iga elementi detailselt.

KEDA ja Prometheus

Prometheus on avatud lähtekoodiga rakenduste komplekt süsteemide jälgimiseks ja hoiatamiseks, osa Cloud Native Computing Foundation. See kogub mõõdikud erinevatest allikatest ja salvestab need ajareadana. Andmete visualiseerimiseks saab kasutada Grafana või muid visualiseerimisvahendeid, mis töötavad Kubernetes API-ga.

KEDA toetab skaleerija kontseptsiooni — see toimib sillana KEDA ja välist süsteemi vahel. Skaleerija teostus on spetsiifiline iga sihtsüsteemi jaoks ja tõmbab sealt andmeid. Seejärel kasutab KEDA neid automaatse skaleerimise haldamiseks.

Skalerid toetavad mitmeid andmeallikaid, nagu Kafka, Redis, Prometheus. See tähendab, et KEDA-d saab kasutada Kubernetes'i rakenduste automaatseks skaleerimiseks, kasutades kriteeriumina Prometheuse mõõdikute järgi.

Testrakendus

Testimine Golang-rakendus, mis pakub juurdepääsu HTTP kaudu ja täidab kahte olulist funktsiooni:

Kasutab Prometheuse Go kliendiraamatukogu rakenduse instrumenteerimiseks ja HTTP päringute mõõdiku http_requests, mis sisaldab päringute loenduri, pakkumiseks. Prometheuse mõõdikute kaudu juurdepääsetav lõpp-punkt on URI-l /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "http päringute arv",
   })
```

Päringule vastates GET rakendus suurendab võtme väärtust (access_count) Redis'is. See on lihtne viis töö tegemiseks HTTP töötlejana ning ka Prometheuse mõõdikute kontrollimiseks. Mõõdiku väärtus peaks olema sama kui väärtus access_count Redis'is.

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("Ei saanud Redis loenduri väärtust suurendada", err)
               os.Exit(1)
           }
           resp := "Juurdepääs " + time.Now().String() + "nJuurdepääsude arv " + strconv.Itoa(int(count))
           w.Write([]byte(resp))
       })
       http.ListenAndServe(":8080", nil)
   }

Rakenduse juurutamine Kubernetes'i kaudu Deployment. Samuti luuakse teenus ClusterIP, mis võimaldab Prometheuse serveril rakenduse mõõdikute hankimist.

Siin rakenduse juurutamise manifest.

Prometheuse server

Prometheuse juurutamise manifest koosneb järgmistest:

ConfigMap — Prometheuse konfi ülekandmiseks;
Deployment — Prometheuse juurutamiseks Kubernetes'i klastris;
ClusterIP — teenus soovib juurdepääsu Prometheuse UI-le;
ClusterRole, ClusterRoleBinding ja ServiceAccount — teenuste autoavastamise toimimiseks Kubernetes'is (Auto-discovery).

Siin Prometheuse käivitamise manifest.

KEDA Prometheus ScaledObject

Skaleri toimib sillana KEDA ja välist süsteemi vahel, kust tuleb mõõdikud saada. ScaledObject — kohandatav ressurss, mille tuleb juurutada, et sünkroniseerida juurutamine ürituste allikaga, antud juhul Prometheusega.

ScaledObject sisaldab teavet juurutamise skaleerimise kohta, ürituse allika metaandmeid (nt ühenduse saladused, järjekorra nimi), küsitluse intervalli, taastumisperioodi ja muid andmeid. See toob kaasa vastava automaatse skaleerimise ressursi (HPA määratlemine), et skaleerida juurutamist.

Kui objekt ScaledObject kustutatakse, vastav HPA määramine tühistatakse.

Siin on määratlemine ScaledObject meie näite jaoks, kasutatakse skaalijat 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]))

Arvestage järgmisi punkte:

See osutab Deployment nimega go-prom-app.
Triggere tüübi — Prometheus. Prometheuse serveri aadress mainitakse koos mõõdiku nime, läviväärtuse ja PromQL päringuga, mida kasutatakse. PromQL päring on sum(rate(http_requests[2m])).
Vastavalt pollingInterval, KEDA küsib sihtpunkti Prometheux 'ilt igal viiel sekundil. Minimaalne koormuse arv on vähemalt üks (minReplicaCount), maksimaalne koormus ei ületa maxReplicaCount näites kümme.

Seda saab seada minReplicaCount nulliks. Sellisel juhul aktiveerib KEDA rakenduse nullist ühte ja seejärel annab HPA täiendavaks automaatseks skaleerimiseks. On võimalus skaleerida ka ühte kuni nullini. Näites ei ole nulli valitud, kuna see on HTTP-teenus, mitte päringute süsteem.

Automaatse skaleerimise maagia

Läviväärtust kasutatakse rakenduse skaleerimise trigerina. Meie näites PromQL päring sum(rate(http_requests[2m])) tagastab HTTP-päringute kiirus (päringute arv sekundis), mis mõõdetakse viimase kahe minuti jooksul.

Kuna läviväärtus on kolm, on üks koormus, kuni väärtus on sum(rate(http_requests[2m])) alla kolme. Kui väärtus tõuseb, lisatakse igal kerral üks koormus, kui sum(rate(http_requests[2m])) see tõuseb kolme võrra. Näiteks, kui väärtus tõuseb 12-lt 14-le, siis koormuste arv on neli.

Nüüd proovime seadistada!

Eelseade

Kõik, mida vajate — Kubernetes klaster ja seadistatud utiliit kubectl. Näites kasutatakse klastrit minikube, kuid võite valida mõne muu. Klastri seadistamiseks on juhend.

Installige uusim versioon Macile:

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/

Installige kubectl, et pääseda ligi Kubernetes klastrile.

Paigaldage uusim versioon Macile:

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 installimine

KEDA-d saab juurutada mitmel viisil, need on loetletud dokumentatsioon. Ma kasutan monoliitset YAML-i:

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

KEDA ja selle komponendid installitakse nimekirja keda. Kontrollimiseks kasutage käsku:

kubectl get pods -n keda

Oodake, kuni KEDA Operator jõuab olekusse Running State. Ja seejärel jätkake.

Redis installimine Helmiga

Kui teil ei ole Helm-i, kasutage seda juhendit. Maci installimiseks kasutage käsku:

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

helm init algatab kohaliku käskude liidese ja installib Tiller Kubernetes klastrisse.

kubectl get pods -n kube-system | grep tiller

Oodake, kuni Tilleri pod jõuab olekusse Running.

Tõlkija märkus: Autor kasutab Helm@2, mis vajab serveri komponenti Tiller. Praegu on aktuaalne Helm@3, mille jaoks serveri osa pole vajalik.

Pärast Helmi installimist piisab Redis käivitamiseks ühest käsust:

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

Veenduge, et Redis oleks edukalt käivitunud:

kubectl get pods/redis-server-master-0

Oodake, kuni Redis jõuab olekusse Käimas.

Rakenduse juurutamine

Käsk juurutamiseks:

kubectl apply -f go-app.yaml

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

Kontrollige, et kõik oleks käimas:

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

Oodake, kuni Redis jõuab olekusse Käimas.

Prometheuse serveri juurutamine

Prometheuse manifest kasutab Kubernetes Service Discovery Prometheusele. See võimaldab dünaamiliselt tuvastada rakenduse podid teenuse sildi põhjal.

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

Juurutamiseks:

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

Kontrollige, et kõik oleks käimas:

kubectl get pods -l=app=prometheus-server

Oodake, kuni Prometheuse pod jõuab olekusse Käimas.

Kasutage kubectl port-forward Prometheuse (või API serveri) kasutajaliidese juurde pääsemiseks aadressil http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA automaatmõõtmise konfiguratsiooni juurutamine

Käsk loomiseks ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Kontrollige KEDA operaatori logisid:

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

Tulemus näeb välja umbes nii:

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"

Kontrollige rakenduse poodi. Üks instants peab olema aktiveeritud, kuna minReplicaCount võrdub 1:

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

Kontrollige, et HPA ressurs on edukalt loodud:

kubectl get hpa

Te peaksite nägema midagi sellist:

NIMI                   VIIDATAV                CIELDID     MINPODS   MAXPODS   REPLIKAD   VANUS
keda-hpa-go-prom-app   Deployment/go-prom-app   0/3 (keskmine)   1         10        1          45s

Töökorras kontrollimine: juurdepääs rakendusele

Rakenduse REST-lõpp-punkti ligipääsuks käivitage:

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

Nüüd pääsete Go rakendusele juurde, kasutades aadressi http://localhost:8080. Selleks täitke käsk:

curl http://localhost:8080/test

Tulemus näeb välja umbes nii:

Juurdepääsetud 2019-10-21 11:29:10.560385986 +0000 UTC 
m=+406004.817901246
Juurdepääsukordade arv 1

Selle sammu käigus kontrollige ka Redis. Näete, et võti access_count on suurenenud 1-ni:

kubectl exec -it redis-server-master-0 -- redis-cli get access_count
//väljastus
"1"

Veenduge, et mõõdiku väärtus http_requests on sama:

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

Koormuse loomine

Kasutame hey — koormuse genereerimise utiliiti:

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

Samuti võite allalaadida utiliidi Linux või Windows.

Käivitage see:

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

Vaikimisi saadab utiliit 200 päringut. Saate seda kontrollida Prometheuse mõõdikute ja ka Redis'i abil.

curl http://localhost:8080/metrics | grep http_requests
//väljastus
# 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
//väljastus
201

Kinnitage tegeliku mõõdiku väärtus (tagasinurga päringu kaudu):

curl -g 
'http://localhost:9090/api/v1/query?query=sum(rate(http_requests[2m]))'
//väljastus
{"status":"success","data":{"resultType":"vector","result":[{"metric":{},"value":[1571734214.228,"1.686057971014493"]}]}}

Selles osas on tegelik tulemus 1,686057971014493 ja kuvatakse väljale value. Seda ei piisa skaleerimiseks, kuna seatud lävi on 3.

Rohkem koormust!

Uues terminalis jälgige rakenduse poodide arvu:

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

Suurendame koormust käsuga:

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

Mõne aja pärast näete, et HPA skaleerib juurutuse ja käivitab uusi poode. Kontrollige HPA-d, et selles veenduda:

kubectl get hpa
Nimi                   Viide                    Sihtmärgid      MINPODS  MAXPODS  Replikad  Vanus
keda-hpa-go-prom-app   Deployment/go-prom-app  1830m/3 (avg)   1        10       6         4m22s

Kui koormus ei ole ühtlane, siis rakendus väheneb punktini, kus töötab ainult üks pod. Kui soovite vaadata tegelikku mõõdikut (mida tagastab PromQL päring), siis kasutage käsku:

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

Puhastamine

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

Kokkuvõte

KEDA võimaldab automaatselt skaleerida teie Kubernetes'i rakendusi (nullist/ nulli) nende mõõdikute põhjal, mis pärinevad välistest allikatest. Näiteks Prometheuse mõõdikute, Redis'i järjekorra pikkuse, või Kafka teema tarbija viivituse põhjal.

KEDA integreerib välist allikat ja pakub selle mõõdikud kaudu Metrics Server'i Horisontaalse Pod'i Automaatika (Horizontal Pod Autoscaler) jaoks.

Edu!

Mida veel lugeda:

Allikas: habr.com