🥇Kubernetes alkalmazások automatikus skálázása Prometheus és KEDA segítségével

Balloon Man by Cimuanos

A skálázhatóság a felhőalkalmazások kulcsfontosságú követelménye. A Kubernetes segítségével az alkalmazás skálázása ugyanolyan egyszerű, mint a megfelelő telepítési replikák számának növelése vagy ReplicaSet — de ez manuális folyamat.

A Kubernetes lehetővé teszi az alkalmazások automatikus skálázását (azaz a Pod-okét egy telepítésben vagy ReplicaSet) deklaratív módon a Horizontal Pod Autoscaler specifikációjának használatával. Alapértelmezés szerint az automatikus skálázás kritériuma a CPU használati metrikák (erőforrás-metrikák), de integrálhatók egyedi metrikák és külsőleg biztosított metrikák is.

A parancs Kubernetes aaS a Mail.ru-tól írt egy cikket arról, hogyan lehet külső metrikákat használni a Kubernetes alkalmazás automatikus skálázásához. A szerző bemutatja, hogyan működik mindez, HTTP-elérések metrikáit használva, amelyeket a Prometheus gyűjt.

A podok horizontális automatikus skálázása helyett Kubernetes Event Driven Autoscaling (KEDA) van érvényben — egy nyílt forráskódú Kubernetes operátor. Ez kezdetben integrálódik a Horizontal Pod Autoscalerrel, hogy zökkenőmentes automatikus skálázást biztosítson (beleértve a nulláról való skálázást is) az eseményvezérelt munkaterhelésekhez. A kód elérhető itt: GitHub.

A rendszer működésének rövid áttekintése

A diagram egy rövid leírást ad arról, hogyan működik az egész:

Az alkalmazás HTTP-hívások számának metrikáit Prometheus formátumban biztosítja.
A Prometheus be van állítva ezeknek a mutatóknak a gyűjtésére.
A KEDA-ban lévő Prometheus skálázó automatikus skálázást konfigurál az alkalmazás számára a HTTP-hívások száma alapján.

Most részletesen bemutatom az egyes elemeket.

KEDA és Prometheus

A Prometheus egy nyílt forráskódú monitoring és riasztórendszer-sorozat, amely Cloud Native Computing Foundation. Különböző forrásokból gyűjt metrikákat, és időbeli sorozatadatként tárolja őket. Az adatok vizualizálásához használhatók Grafanába vagy más vizualizáló eszközök, amelyek API Kubernetes-szel működnek.

A KEDA támogatja a skálázó fogalmat — egy hídként működik a KEDA és a külső rendszer között. A skálázó megvalósítása minden célrendszer esetében specifikus, és onnan vonja ki az adatokat. Ezt követően a KEDA ezeket használja az automatikus skálázás vezérlésére.

A skálázók támogatják a különböző adatforrásokat, például a Kafkát, a Redist és a Prometheust. Ezért a KEDA-t lehet alkalmazni a Kubernetes telepítések automatikus skálázására, a Prometheus metrikák használatával mint feltételek.

Tesztalkalmazás

A teszt Golang alkalmazás HTTP-n keresztül biztosít hozzáférést, és két fontos funkciót lát el:

Használja a Prometheus Go klienskönyvtárat az alkalmazás instrumentálására és a http_requests metrika biztosítására, amely egy számlálót tartalmaz. A Prometheus metrikák elérhetők a következő URI-n: /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "http kérések száma",
   })
```

A kérésre válaszul GET az alkalmazás növeli a kulcs értékét (access_count) a Redisben. Ez egy egyszerű módja annak, hogy a HTTP feldolgozó részeként végezze el a munkát, és ellenőrizze a Prometheus metrikákat. A metrika értékének meg kell egyeznie a access_count Redisben található értékkel.

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("Nem sikerült növelni a redis számlálót", err)
               os.Exit(1)
           }
           resp := "Hozzáférve: " + time.Now().String() + "nHozzáférések száma: " + strconv.Itoa(int(count))
           w.Write([]byte(resp))
       })
       http.ListenAndServe(":8080", nil)
   }

Az alkalmazás Kubernetesben kerül telepítésre a Deploymentsegítségével. Ezenkívül létrejön egy szolgáltatás, ClusterIP, amely lehetővé teszi a Prometheus szerver számára, hogy elérje az alkalmazás metrikáit.

Íme a telepítési manifeszt az alkalmazás számára.

Prometheus szerver

A Prometheus telepítési manifeszt a következőkből áll:

ConfigMap — a Prometheus konfiguráció átadásához;
Deployment — a Prometheus Kubernetes klaszterben történő telepítéséhez;
ClusterIP — a Prometheus UI eléréséhez szolgáltatás;
ClusterRole, ClusterRoleBinding és Szolgáltatási fiók — a Kubernetesben az automatizált szolgáltatás-automatikus felfedezéséhez (Auto-discovery).

Íme manifeszt a Prometheus futtatásához.

KEDA Prometheus ScaledObject

A skálázó hídként működik a KEDA és a külső rendszer között, ahonnan a metrikákat be kell szerezni. A ScaledObject — egy konfigurálható erőforrás, amelyet telepíteni kell az eseményforrással való szinkronizáláshoz, jelen esetben a Prometheus-szal.

A ScaledObject tartalmazza a telepítés skálázásához szükséges információkat, az eseményforrással kapcsolatos metaadatokat (például a csatlakozáshoz szükséges titkokat, a sor nevét), a lekérdezési intervallumot, a helyreállítási időt és egyéb adatokat. Ez a megfelelő automatikus skálázási erőforráshoz (HPA definíció) vezet a telepítés skálázásához.

Amikor az objektum A ScaledObject törölve, a megfelelő HPA definíció törlődik.

Íme a definíció A ScaledObject példánkhoz, skálázót használ. 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]))

Fontos figyelembe venni a következőket:

Ez azt jelzi, hogy Deployment a névvel go-prom-app.
A triggere típusa — Prometheus. A Prometheus szerver címe a metrikanevével, küszöbértékkel és PromQL lekérdezéssel, amit használni fognak. A PromQL lekérdezés — sum(rate(http_requests[2m])).
A következő szerint pollingInterval, a KEDA tizenöt másodpercenként kérdezi le a célt Prometheustól. Legalább egy pod támogatott (minReplicaCount), és a podok maximális száma nem haladhatja meg a maxReplicaCount (jelen példában — tíz).

Beállítható minReplicaCount nullára. Ebben az esetben a KEDA az indulást nulláról egyre aktiválja, majd HPA-t ad a további automatikus skálázáshoz. A fordított sorrend is lehetséges, azaz skálázás egyből nullára. A példában nem választottunk nullát, mivel ez egy HTTP-szolgáltatás, nem egy kérés alapú rendszer.

A varázslat az automatikus skálázásban

A küszöbértéket használják az elosztás skálázásának triggereiként. A példánkban a PromQL lekérdezés sum(rate (http_requests [2m])) az HTTP-kérések sebességének aggregált értékét adja vissza (kérések száma másodpercenként), amelyet az utolsó két percben mérnek.

Mivel a küszöbérték három, ezért egy pod lesz, amíg az érték sum(rate (http_requests [2m])) három alatt van. Ha viszont az érték növekszik, minden alkalommal, amikor sum(rate (http_requests [2m])) hárommal növekszik, egy további pod adódik hozzá. Például, ha az érték 12-ről 14-re emelkedik, a podok száma négy lesz.

Most próbáljuk meg beállítani!

Előkészítő beállítás

Minden, amire szükséged van — egy Kubernetes klaszter és egy beállított eszköz kubectl. A példa szerint a klasztert minikube, de bármilyen másik is használható. A klaszter telepítéséhez a kézikönyvet.

Telepítés az utolsó verzióra Mac-re:

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/

Telepítse kubectl, hogy hozzáférj a Kubernetes klaszterhez.

Az utolsó verzió telepítése Mac-re:

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 telepítése

A KEDA-t többféleképpen telepítheti, ezek az alábbiak: dokumentáció. Én egy monolit YAML-t használok:

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

A KEDA és összetevői az keda, névtérben települnek. Ellenőrző parancs:

kubectl get pods -n keda

Várja meg, amíg a KEDA Operator pod elindul — állapotba lép Running State. Ezután folytassa.

Redis telepítése Helm segítségével

Ha a Helm nincs telepítve, használja ezt: útmutatóval. Telepítési parancs Mac-re:

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

helm init localis parancssori interfészt inicializál, és telepíti a Tiller-t a Kubernetes klaszterbe.

kubectl get pods -n kube-system | grep tiller

Várja meg, amíg a Tiller pod állapota Running-ra vált.

Fordító megjegyzése: A szerző Helm@2-t használ, amely a Tiller server komponens telepítését igényli. Jelenleg a Helm@3 актуális, amelyhez nem szükséges a szerveroldali rész.

A Redis elindításához Helm telepítése után elegendő egy parancs:

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

Győződjön meg róla, hogy a Redis sikeresen elindult:

kubectl get pods/redis-server-master-0

Várja meg, amíg a Redis pod állapota Futásban.

Alkalmazás telepítése

A telepítési parancs:

kubectl apply -f go-app.yaml

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

Ellenőrizze, hogy minden elindult-e:

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

Várja meg, amíg a Redis állapota Futásban.

A Prometheus szerver telepítése

A Prometheus manifest használja a Kubernetes Service Discovery-t a Prometheus számára. Ez lehetővé teszi, hogy dinamikusan felfedezze az alkalmazás pod-okat a szolgáltatás címkéje alapján.

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

A telepítéshez:

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

Ellenőrizze, hogy minden elindult-e:

kubectl get pods -l=app=prometheus-server

Várja meg, amíg a Prometheus pod állapota Futásban.

Használja kubectl port-forward a Prometheus felhasználói felület (vagy API szerver) eléréséhez a következő címen: http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA automatikus skálázási konfiguráció telepítése

A létrehozó parancs: A ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Ellenőrizze a KEDA operátor naplóit:

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

Az eredmény körülbelül így néz ki:

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"

Ellenőrizze az alkalmazás alatt. Csak egy példányt kell futnia, mivel minReplicaCount egyenlő 1:

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

Ellenőrizze, hogy az HPA erőforrás sikeresen létrejött:

kubectl get hpa

Látnia kell valami hasonlót:

NÉV                   REFERENCIA                CÉLOK     MINPODS   MAXPODS   REPLIKÁK   KOR
keda-hpa-go-prom-app   Deployment/go-prom-app   0/3 (átlag)   1         10        1          45s

Működés ellenőrzése: hozzáférés az alkalmazáshoz

A REST végpont eléréséhez futtassa:

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

Most elérheti a Go alkalmazást a következő címen: http://localhost:8080. Ehhez futtassa a parancsot:

curl http://localhost:8080/test

Az eredmény körülbelül így néz ki:

Hozzáférve 2019-10-21 11:29:10.560385986 +0000 UTC 
m=+406004.817901246
Hozzáférések száma 1

Ezen a ponton ellenőrizze a Redis-t is. Látni fogja, hogy a kulcs access_count nőtt 1-re:

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

Győződjön meg arról, hogy a metrika értéke http_requests ugyanaz:

curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests a HTTP kérések száma
# TYPE http_requests számláló
http_requests 1

Terhelés létrehozása

Használni fogjuk a hey — terhelésgeneráló eszköz:

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

A segédprogramot is letöltheti Linux vagy Windows.

Futtassa:

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

Alapértelmezés szerint az eszköz 200 kérést küld. Ennek ellenőrzésére használhatja a Prometheus metrikáit, valamint a Redist.

curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests a HTTP kérések száma
# TYPE http_requests számláló
http_requests 201
kubectl exec -it redis-server-master-0 -- redis-cli get access_count
//output
201

Erősítse meg a tényleges metrika értékét (amelyet a PromQL lekérdezés hoz vissza):

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

Ebben az esetben a tényleges eredmény egyenlő 1,686057971014493 és megjelenik a mezőben érték. Ez nem elegendő a skálázáshoz, mivel általunk beállított küszöb 3.

Növeljük a terhelést!

Egy új terminálban figyelje az alkalmazás podjainak számát:

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

Növeljük a terhelést a következő parancs segítségével:

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

Rövid idő múlva látnia kell, hogy az HPA méretezni kezdi a telepítést és új podokat indít. Ellenőrizze az HPA-t, hogy megbizonyosodjon róla:

kubectl get hpa
NÉV                   REFERENCIA                CÉLOK         MINPODS   MAXPODS   REPLIKÁK   KOR
keda-hpa-go-prom-app   Deployment/go-prom-app   1830m/3 (átlag)   1         10        6          4m22s

Ha a terhelés változó, a telepítés csökkenni fog arra a pontra, ahol csak egy pod működik. Ha szeretné ellenőrizni a tényleges metrikát (amit a PromQL lekérdezés visszaad), használja a következő parancsot:

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

Tisztítás

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

Zárás

A KEDA lehetővé teszi a Kubernetes telepítések automatikus skálázását (nulláról/fel) külső metrikák alapján. Például Prometheus metrikák, Redis sorhossz vagy Kafka témában a fogyasztó késleltetése alapján.

A KEDA integrálódik a külső forrással, és biztosítja annak metrikáit a Metrics Server számára a Horizontal Pod Autoscaler számára.

Sok sikert!

Mit érdemes még olvasni:

Forrás: habr.com