🥇Kubernetes rakenduste autoskaleerimine Prometheuse ja KEDA abil

Balloon Man by Cimuanos

Skaleeritavus on hädavajalik nõue pilve rakenduste jaoks. Kubernetesega on rakenduse skaleerimine sama lihtne kui koopia arvu suurendamine vastavale juurutamisele või ReplicaSet — kuid see on käsitsi protsess.

Kubernetes võimaldab rakendusi automaatselt skaleerida (st Pods juurutamises või ReplicaSet) deklaratiivselt, kasutades Horizontaalset Pod Autoscaler'i spetsifikatsiooni. Vaikimisi on automaatse skaleerimise kriteeriumiks CPU kasutuse mõõdikud (ressursi mõõdikud), kuid on võimalik integreerida ka kohandatud mõõdikud ja välised mõõdikud.

Meeskond Mail.ru Kubernetes aaS tõlkis artikli selle kohta, kuidas kasutada väliseid mõõdikuid Kubernetesi rakenduste automaatseks skaleerimiseks. Näitamaks, kuidas kõik töötab, kasutab autor HTTP-kuulutuste mõõdikuid, mida kogutakse Prometheuse abil.

Kubernetes Event Driven Autoscaling (KEDA) rakendab automaatset skaleerimist, mitte horisontaalset automaatset skaleerimist pod'ide jaoks — avatud lähtekoodiga Kubernetes'i operaator. See integreerub algselt Horisontaalse Pod Automaatse Skaleerijaga, et tagada sujuv automaatne skaleerimine (sh nullist skaleerimine) sündmustest juhitud töökoormuste jaoks. Kood on saadaval aadressil GitHub.

Süsteemi ülevaade

Joonisel on lühike seletus, kuidas kõik töötab:

Rakendus edastab HTTP päringute arvu mõõdud Prometheus formaadis.
Prometheus on seadistatud nende näitajate kogumiseks.
KEDA Prometheuse skaleerija on konfigureeritud rakenduse automaatseks skaleerimiseks HTTP päringute arvu põhjal.

Nüüd räägin kõigist elementidest lähemalt.

KEDA ja Prometheus

Prometheus on avatud lähtekoodiga süsteemide jälgimise ja teavitamise tööriistakomplekt, osa Cloud Native Computing Foundation. Kogub mõõdud erinevatest allikatest ja salvestab need ajaarvamise andmetena. Andmete visualiseerimiseks võib kasutada Grafana või muid visualiseerimistööriistu, mis töötavad Kubernetes'i API-ga.

KEDA toetab skaaleri kontseptsiooni — see toimib silla leidmiseks KEDA ja välist süsteemi vahel. Skaaleri rakendamine on igale sihtsüsteemile spetsiifiline ja tõmbab andmed sellest. Seejärel kasutab KEDA neid automaatse skaleerimise juhtimiseks.

Skaalerid toetavad mitmeid andmeallikaid, nagu Kafka, Redis, Prometheus. Seega saab KEDA-d kasutada Kubernetes'i juurutuste automaatseks skaleerimiseks, kasutades kriteeriumina Prometheuse mõõdikuid.

Testrakendus

Testimine Golang rakendus võimaldab pääseda HTTP kaudu ja täidab kahte olulist funktsiooni:

Kasutab Prometheuse Go kliendiraamatukogu rakenduse instrumenteerimiseks ja http_requests mõõdiku pakkumiseks, mis sisaldab päringute loendurit. Prometheuse mõõdikud on kättesaadavad URI-l. /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "HTTP päringute arv",
   })
```

Päringu vastuseks GET rakendus suurendab võtme väärtust (access_count) Redis. See on lihtne viis töö tegemiseks osana HTTP töötlejast ja ka Prometheuse mõõdikute kontrollimiseks. Mõõdiku väärtus peaks olema sama, mis väärtus access_count 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)
   }

Rakendus deployitakse Kubernetes'is kaudu Deployment. Samuti luuakse teenus ClusterIP, see võimaldab Prometheus serveril rakenduse mõõdikuid saada.

Siin on rakenduse deployimise manifest.

Prometheus Server

Prometheuse deployimise manifest koosneb järgmistest:

ConfigMap — Prometheuse konfi edastamiseks;
Deployment — Prometheuse deployimiseks Kubernetes klastris;
ClusterIP — teenus Prometheuse UI juurde pääsemiseks;
ClusterRole, ClusterRoleBinding ja ServiceAccount — teenuste automaatseks avastamiseks Kubernetesis (Auto-discovery).

Siin on manifest Prometheuse käivitamiseks.

KEDA Prometheuse ScaledObject

Skaleerija toimib sillana KEDA ja välist süsteemi vahel, millest on vajalik mõõdikute saamine. ScaledObject — konfigureeritav ressurss, mis tuleb deployida sündmuste allika, antud juhul Prometheusega, sünkroniseerimiseks.

ScaledObject sisaldab teavet rakenduse skaleerimise, sündmuse allika metaandmete (nt ühenduse saladused, järjekorra nimi), küsitlusintervalli, taastumisperioodi ja teiste andmete kohta. See viib vastava automaatse skaleerimise ressursi juurde (HPA määratlus) rakenduse skaleerimiseks.

Kui objekt ScaledObject kustutatakse, siis vastav HPA määratlus eemaldatakse.

Siin on määratlus ScaledObject meie näite jaoks, kus kasutatakse skaaladjust: 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]))

Pange tähele järgmisi punkte:

See viitab Deployment nimega go-prom-app.
Tüübi käivitaja — Prometheus. Prometheuse serveri aadress mainitakse koos metrika nime, läviväärtuse ja PromQL päringuga, mida kasutatakse. PromQL päring — sum(rate(http_requests[2m])).
Vastavalt pollingInterval, KEDA küsib eesmärgi kohta Prometheuse juurest iga viieteistkümne sekundi järel. Toetatakse vähemalt ühte podi (minReplicaCount), samas kui maksimaalne podide arv ei ületa maxReplicaCount (näites — kümme).

Saab seadistada minReplicaCount nulliks. Sel juhul aktiveerib KEDA rakenduse nullist üheni, seejärel annab HPA edasi automaatseks skaaleerimiseks. Samuti on võimalik vastupidine järjestus, st skaaleerimine ühest nulli. Näites ei valinud me nulli, kuna see on HTTP-teenus, mitte päringute süsteem.

Automaatskaalumise võlu

Piirväärtust kasutatakse rakenduse skaaleerimise käivitamiseks. Meie näites on PromQL päring sum(rate(http_requests[2m])) tagastab HTTP-päringute kiirusest (päringute arv sekundis) kogustatud väärtuse, mida mõõdetakse viimase kahe minuti jooksul.

Kuna piirväärtus on kolm, siis toimub üks alamskaleerimine, kuni väärtus on sum(rate(http_requests[2m])) vähem kui kolm. Kui aga väärtus suureneb, lisandub iga kord, kui sum(rate(http_requests[2m])) see suureneb kolme võrra, uus alam. Näiteks, kui väärtus on 12–14, siis on alameid neli.

Nüüd proovime seadistada!

Eelsättimine

Kõik, mida vajate, on Kubernetes klaster ja seadistatud tööriist kubectl. Selles näites kasutatakse klastrit minikube, kuid saate valida ka mõne teise. Klusteri 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'i klusterile.

Installige 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

Saate KEDA-d rakendada mitmel viisil, need on loetletud dokumentatsioonis. Kasutan monoliitset YAML-i:

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

KEDA ja selle koostisosad installitakse ruumi nimega keda. Kontrollimise käsk:

kubectl get pods -n keda

Oodake, kuni KEDA operaatori pod käivitub — läheb olekusse Running State. Ja pärast seda jätkake.

Redis'i installimine Helm'i abil

Kui Helm pole installitud, tutvuge selle juhendiga. Maci installimise käsk:

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

helm init algatab kohaliku käsurea liidese ja installib Tiller'i Kubernetes'i klustisse.

kubectl get pods -n kube-system | grep tiller

Oodake, et Tiller'i pod läheb olekusse Running.

Tõlkija märkus: Autor kasutab Helm@2, mis vajab Tilleri serverikomponendi installimist. Käesoleval ajal on aktiivne Helm@3, mille jaoks serveriosa ei ole vajalik.

Pärast Helmi installimist piisab Redis’i käivitamiseks ühest käsklusest:

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

Veendu, et Redis on edukalt käivitatud:

kubectl get pods/redis-server-master-0

Oota, kuni Redis'i pod jõuab olekusse Running.

Rakenduse juurutamine

Käsk rakenduse juurutamiseks:

kubectl apply -f go-app.yaml

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

Kontrolli, et kõik on käivitatud:

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

Oota, kuni Redis jõuab olekusse Running.

Prometheuse serveri juurutamine

Prometheuse manifest kasutab Kubernetes Teenuse Avastamine Prometheusele. See võimaldab dünaamiliselt avastada rakenduse pode 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

Kontrolli, et kõik on käivitatud:

kubectl get pods -l=app=prometheus-server

Oodake, kuni Prometheus läheb olekusse Running.

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

kubectl port-forward service/prometheus-service 9090

KEDA automaatse skaleerimise konfiguratsiooni juurutamine

Käsk faili 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 selline:

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 eksemplar peaks olema käivitatud, kuna minReplicaCount on võrdsed 1:

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

Kontrollige, et HPA ressurss on edukalt loodud:

kubectl get hpa

Peaksite nägema midagi sellist:

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

Töökindluse kontroll: juurdepääs rakendusele

Et pääseda meie rakenduse REST lõpp-punkti, käivitage:

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

Nüüd saate pääseda Go rakendusele, kasutades aadressi http://localhost:8080. Selleks käivitage käsk:

curl http://localhost:8080/test

Tulemus näeb välja umbes selline:

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

Selle etapi juures kontrollige ka Redis. Näete, et võtme access_count väärtus on suurenenud kuni 1:

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

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

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

Koormuse genereerimine

Kasvame hey — koormuse genereerimise tööriista:

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

Saate ka tööriista alla laadida Linux või Windows.

Käivitage see:

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

Vaikimisi saadab tööriist 200 päringut. Saate seda kontrollida, kasutades Prometheuse mõõtmeid ning ka Redis'i.

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

Kinnitage tegeliku mõõtme väärtus (mille PromQL päring tagastab):

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

Sel juhul on tegelik tulemus 1,686057971014493 ja kuvatakse väljale value. Seda ei piisa skaleerimiseks, kuna seame piiri väärtus on 3.

Rohkem koormust!

Uues terminalis jälgige rakenduse podide arvu:

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

Suurendame koormust järgmise käsuga:

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

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

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

Kui koormus on ebastabiilne, vähendatakse rakendust punkti, kus töötab ainult üks pod. Kui soovite kontrollida tegelikku mõõdikut (mille tagastab PromQL päring), kasutage käsku:

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

Kustutus

//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 rakendusi (nullist ja tagasi) väliste mõõdikute andmete põhjal. Näiteks Prometheus mõõdikutest, Redis järjekorra pikkusest, Kafka teemade tarbimise viivitusest.

KEDA integreerub välise allikaga ja pakub selle mõõdikud läbi Metrics Serveri Horisontaalsesse Pod Automaatse Skaleerijasse.

Edu!

Mida veel lugeda:

Allikas: habr.com