🥇Kubernetese rakenduste automaatskaleerimine Prometheuse ja KEDA

Balloon Man autor Cimuanos

Skaleeritavus on pilverakenduste põhinõue. Kubernetese abil on rakenduse skaleerimine sama lihtne kui vastava juurutuse jaoks koopiate arvu suurendamine või ReplicaSet — aga see on käsitsi protsess.

Kubernetes võimaldab rakendusi automaatselt skaleerida (nt juurutamisel või ReplicaSet) deklaratiivsel viisil, kasutades Horizontal Pod Autoscaleri spetsifikatsiooni. Automaatse skaleerimise vaikekriteerium on protsessori kasutusmõõdikud (ressursside mõõdikud), kuid saate integreerida kohandatud ja väliselt pakutud mõõdikuid.

Meeskond Kubernetes aaS saidilt Mail.ru tõlkis artikli väliste mõõdikute kasutamise kohta Kubernetese rakenduse automaatseks skaleerimiseks. Näitamaks, kuidas kõik toimib, kasutab autor HTTP juurdepääsutaotluse mõõdikuid, mida kogutakse Prometheuse abil.

Podide horisontaalse automaatskaleerimise asemel kasutatakse Kubernetes Event Driven Autoscaling (KEDA), avatud lähtekoodiga Kubernetese operaatorit. See integreerub natiivselt Horizontal Pod Autoscaleriga, et pakkuda sündmustest tingitud töökoormuste jaoks sujuvat automaatskaleerimist (sealhulgas nullini või nullist). Kood saadaval aadressil GitHub.

Lühiülevaade süsteemist

Diagramm näitab lühikirjeldust, kuidas kõik töötab:

Rakendus pakub Prometheuse vormingus HTTP tabamuste loenduse mõõdikuid.
Prometheus on konfigureeritud neid mõõdikuid koguma.
KEDA Prometheuse skaler on konfigureeritud rakendust automaatselt skaleerima HTTP-takistuste arvu alusel.

Nüüd räägin teile üksikasjalikult iga elemendi kohta.

KEDA ja Prometheus

Prometheus on avatud lähtekoodiga süsteemi jälgimise ja hoiatamise tööriistakomplekt Cloud Native Computing Foundation. Kogub mõõdikuid erinevatest allikatest ja salvestab need aegridade andmetena. Andmete visualiseerimiseks saate kasutada grafana või muud visualiseerimistööriistad, mis töötavad Kubernetes API-ga.

KEDA toetab skaleri kontseptsiooni – see toimib sillana KEDA ja välise süsteemi vahel. Skaleri rakendamine on iga sihtsüsteemi jaoks spetsiifiline ja eraldab sellest andmed. Seejärel kasutab KEDA neid automaatse skaleerimise juhtimiseks.

Skalerid toetavad mitut andmeallikat, näiteks Kafka, Redis, Prometheus. See tähendab, et KEDA-t saab kasutada Kubernetese juurutuste automaatseks skaleerimiseks, kasutades kriteeriumina Prometheuse mõõdikuid.

Testrakendus

Golangi testirakendus pakub juurdepääsu HTTP kaudu ja täidab kahte olulist funktsiooni:

Kasutab Prometheus Go klienditeeki rakenduse instrumenteerimiseks ja http_requests mõõdiku pakkumiseks, mis sisaldab tabamuste arvu. Lõpp-punkt, kus Prometheuse mõõdikud on saadaval, asub URI-s /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Vastuseks palvele GET rakendus suurendab võtme väärtust (access_count) Redis. See on lihtne viis HTTP-käitleja osana töö tegemiseks ja ka Prometheuse mõõdikute kontrollimiseks. Mõõdiku väärtus peab olema väärtusega sama access_count aastal 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 juurutatakse Kubernetesi kaudu Deployment. Samuti luuakse teenus ClusterIP, võimaldab see Prometheuse serveril hankida rakenduste mõõdikuid.

siin on rakenduse juurutamise manifest.

Prometheuse server

Prometheuse kasutuselevõtu manifest koosneb:

ConfigMap — Prometheuse konfiguratsiooni ülekandmiseks;
Deployment — Prometheuse juurutamiseks Kubernetese klastris;
ClusterIP — teenus kasutajaliidesele Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — teenuste automaatseks tuvastamiseks Kubernetesis (automaatne avastamine).

siin on manifest Prometheuse käitamiseks.

KEDA Prometheuse skaleeritud objekt

Skaler toimib sillana KEDA ja välise süsteemi vahel, kust tuleb mõõdikuid hankida. ScaledObject on kohandatud ressurss, mis tuleb juurutada, et sünkroonida juurutamine sündmuse allikaga, antud juhul Prometheusega.

ScaledObject sisaldab juurutuse skaleerimise teavet, sündmuste allika metaandmeid (nt ühenduse saladused, järjekorra nimi), küsitlusintervalli, taasteperioodi ja muid andmeid. Selle tulemuseks on juurutuse skaleerimiseks vastav automaatse skaleerimise ressurss (HPA definitsioon).

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

Siin on määratlus ScaledObject meie näiteks kasutab see skalerit 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]))

Mõelge järgmistele punktidele:

Ta osutab Deployment Nimega go-prom-app.
Päästiku tüüp - Prometheus. Prometheuse serveri aadressi mainitakse koos mõõdiku nime, läve ja PromQL päring, mida hakatakse kasutama. PromQL päring – sum(rate(http_requests[2m])).
Vastavalt pollingIntervalKEDA küsib Prometheuselt sihtmärki iga viieteistkümne sekundi järel. Vähemalt üks all (minReplicaCount) ja maksimaalne kaunade arv ei ületa maxReplicaCount (selles näites - kümme).

Saab paigaldada minReplicaCount võrdne nulliga. Sel juhul aktiveerib KEDA null-ühele juurutamise ja paljastab seejärel HPA edasiseks automaatseks skaleerimiseks. Võimalik on ka vastupidine järjekord, st skaleerimine ühest nullini. Näites ei valinud me nulli, kuna see on HTTP-teenus, mitte tellitav süsteem.

Maagia automaatse skaleerimise sees

Lävi kasutatakse juurutuse skaleerimiseks päästikuna. Meie näites PromQL päring sum(rate (http_requests [2m])) tagastab koondatud HTTP päringu kiiruse (päringud sekundis), mõõdetuna viimase kahe minuti jooksul.

Kuna läviväärtus on kolm, tähendab see, et väärtus jääb alla ühe sum(rate (http_requests [2m])) vähem kui kolm. Kui väärtus suureneb, lisatakse iga kord täiendav alam sum(rate (http_requests [2m])) suureneb kolme võrra. Näiteks kui väärtus on 12 kuni 14, siis on kaunade arv neli.

Nüüd proovime seda seadistada!

eelseadistus

Kõik, mida vajate, on Kubernetese klaster ja konfigureeritud utiliit kubectl. See näide kasutab klastrit minikube, kuid võite võtta mis tahes muu. Klastri paigaldamiseks on olemas juhtpositsiooni.

Installige Maci uusim versioon:

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/

Komplekt kubectlKubernetese klastrile juurdepääsuks.

Installige Maci uusim versioon:

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 paigaldus

Saate KEDA 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 nimeruumi keda. Kontrollimiseks käsk:

kubectl get pods -n keda

Oodake, kuni KEDA Operator käivitub, ja minge lehele Running State. Ja pärast seda jätkake.

Redise installimine Helmi abil

Kui teil pole Helmi installitud, kasutage seda juhtimine. Maci installimise käsk:

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

helm init initsialiseerib kohaliku käsurea liidese ja ka installib Tiller Kubernetese klastrisse.

kubectl get pods -n kube-system | grep tiller

Oodake, kuni Tiller pod läheb tööolekusse.

Tõlkija märkus: autor kasutab Helm@2, mis nõuab Tiller serveri komponendi installimist. Nüüd on Helm@3 asjakohane, see ei vaja serveriosa.

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

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

Kontrollige, kas Redis on edukalt käivitunud:

kubectl get pods/redis-server-master-0

Oodake, kuni Redis olekusse läheb Running.

Rakenduse juurutamine

Juurutamise käsk:

kubectl apply -f go-app.yaml

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

Kontrollige, kas kõik on alanud:

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

Oodake, kuni Redis olekusse siseneb Running.

Prometheuse serveri juurutamine

Prometheuse manifest kasutab Kubernetese teenuse avastamine Prometheuse jaoks. See võimaldab dünaamiliselt avastada rakendusi, mis põhinevad teenusesildil.

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, kas kõik on alanud:

kubectl get pods -l=app=prometheus-server

Oodake, kuni Prometheus läheb olekusse Running.

Kasutage kubectl port-forward juurdepääsuks Prometheuse kasutajaliidesele (või API serverile) aadressil http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA automaatse skaleerimise konfiguratsiooni juurutamine

Käsk luua 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 rakenduste alt. Üks eksemplar peab töötama, sest minReplicaCount võrdub 1:

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

Veenduge, et HPA ressurss loodi edukalt:

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

Tervisekontroll: juurdepääs rakendusele

Meie rakenduse REST-otspunktile juurdepääsuks käivitage:

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

Nüüd pääsete oma rakendusele Go juurde aadressi kasutades 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

Siinkohal kontrollige ka Redis. Näete seda võtit access_count suurendati 1-ni:

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

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

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

Laadi loomine

Me kasutame hei — utiliit koormuse tekitamiseks:

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

Võite alla laadida ka utiliidi Linux või Windows.

Käivita see:

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

Vaikimisi saadab utiliit 200 päringut. Saate seda kontrollida nii Prometheuse mõõdikute kui ka Redise abil.

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õõdiku väärtus (tagastati PromQL-i päringuga):

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äljal value. Sellest skaleerimiseks ei piisa, kuna meie seatud lävi on 3.

Rohkem koormust!

Uues terminalis jälgige rakenduste 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, kuidas HPA skaleerib juurutamist ja käivitab uued kaustad. Kontrollige oma HPA-d ja veenduge, et:

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 ebaühtlane, vähendatakse juurutamist punktini, kus töötab ainult üks pod. Kui soovite kontrollida tegelikku mõõdikut (tagastati PromQL-i päringuga), 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

Järeldus

KEDA võimaldab teil automaatselt skaleerida oma Kubernetese juurutusi (nullist/nullist) väliste mõõdikute andmete põhjal. Näiteks Prometheuse mõõdikute põhjal järjekorra pikkus Redis, tarbija latentsus Kafka teemas.

KEDA integreerub välise allikaga ja pakub oma mõõdikuid ka Metrics Serveri kaudu Horizontal Pod Autoscalerile.

Õnn kaasa!

Mida veel lugeda:

Allikas: www.habr.com

Kubernetese rakenduste automaatne skaleerimine Prometheuse ja KEDA abil