🥇A Kubernetes alkalmazások automatikus skálázása Prometheus és KEDA

Balloon Man a Cimuanostól

A skálázhatóság kulcsfontosságú követelmény a felhőalkalmazásokkal szemben. A Kubernetes segítségével egy alkalmazás méretezése olyan egyszerű, mint a replikák számának növelése a megfelelő telepítéshez 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 egy központi telepítésben vagy ReplicaSet) deklaratív módon a Horizontal Pod Autoscaler specifikáció használatával. Az automatikus méretezés alapértelmezett feltétele a CPU-használati metrikák (erőforrás-metrikák), de integrálhat egyéni és külsőleg biztosított mérőszámokat is.

Csapat Kubernetes aaS a Mail.ru webhelyről lefordított egy cikket arról, hogyan lehet külső mérőszámokat használni a Kubernetes-alkalmazások automatikus méretezéséhez. Annak bemutatására, hogyan működik minden, a szerző HTTP-hozzáférési kérés mérőszámait használja, amelyeket a Prometheus segítségével gyűjt össze.

A podok vízszintes automatikus skálázása helyett a Kubernetes Event Driven Autoscaling (KEDA) használatos, egy nyílt forráskódú Kubernetes operátor. Natív módon integrálódik a Horizontal Pod Autoscaler-rel, hogy zökkenőmentes automatikus skálázást biztosítson (beleértve a nullára/nulláról való) az eseményvezérelt munkaterhelésekhez. A kód elérhető: GitHub.

A rendszer rövid áttekintése

Az ábra röviden leírja, hogyan működik minden:

Az alkalmazás Prometheus formátumban biztosít HTTP találatszám-mérőszámokat.
A Prometheus úgy van beállítva, hogy összegyűjtse ezeket a mutatókat.
A KEDA Prometheus skálázója úgy van konfigurálva, hogy automatikusan skálázza az alkalmazást a HTTP találatok száma alapján.

Most részletesen elmondom az egyes elemekről.

KEDA és Prometheus

A Prometheus egy nyílt forráskódú rendszerfigyelő és riasztási eszköztár, része Cloud Native Computing Foundation. Különféle forrásokból gyűjti össze a mérőszámokat, és idősoros adatokként tárolja azokat. Az adatok megjelenítéséhez használhatja grafana vagy más, a Kubernetes API-val együttműködő vizualizációs eszközöket.

A KEDA támogatja a skálázó koncepcióját – hídként működik a KEDA és a külső rendszer között. A skálázó megvalósítás minden célrendszerre jellemző, és onnan nyeri ki az adatokat. A KEDA ezután ezeket használja az automatikus méretezés vezérlésére.

A skálázók többféle adatforrást támogatnak, például Kafka, Redis, Prometheus. Ez azt jelenti, hogy a KEDA használható a Kubernetes-telepítések automatikus méretezésére a Prometheus-metrikák kritériumként.

Tesztalkalmazás

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

A Prometheus Go klienskönyvtárat használja az alkalmazás műszerezésére és a http_requests metrika biztosítására, amely tartalmazza a találatok számát. A végpont, ahol a Prometheus-metrikák elérhetők, az URI-n található /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

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

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

Az alkalmazás telepítése a Kubernetesbe keresztül történik Deployment. Létrejön egy szolgáltatás is ClusterIP, lehetővé teszi a Prometheus szerver számára az alkalmazási metrikák lekérését.

Itt az alkalmazás telepítési jegyzéke.

Prometheus szerver

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

ConfigMap — a Prometheus konfiguráció átvitele;
Deployment – a Prometheus telepítéséhez egy Kubernetes-fürtben;
ClusterIP — a Prometheus felhasználói felülethez való hozzáférést biztosító szolgáltatás;
ClusterRole, ClusterRoleBinding и ServiceAccount — a Kubernetes szolgáltatásainak automatikus felismeréséhez (Automatikus felfedezés).

Itt manifest 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, amelyből a mérőszámokat be kell szerezni. ScaledObject egy egyéni erőforrás, amelyet telepíteni kell a telepítés szinkronizálásához az eseményforrással, ebben az esetben a Prometheusszal.

ScaledObject tartalmazza a telepítési skálázási információkat, az eseményforrás metaadatait (például a kapcsolat titkait, a sor nevét), a lekérdezési időközt, a helyreállítási időszakot és egyéb adatokat. Ez a megfelelő automatikus skálázási erőforrást (HPA-definíció) eredményezi a telepítés méretezéséhez.

Amikor egy tárgy ScaledObject törlésre kerül, a megfelelő HPA definíció törlődik.

Íme a definíció ScaledObject példánkban 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]))

Vegye figyelembe a következő pontokat:

Rámutat Deployment Névvel go-prom-app.
Trigger típusa - Prometheus. A Prometheus szerver címe szerepel a metrikanévvel, a küszöbértékkel és a küszöbértékkel együtt PromQL lekérdezés, amelyet használni fognak. PromQL lekérdezés - sum(rate(http_requests[2m])).
Szerint pollingIntervalA KEDA tizenöt másodpercenként kér célpontot a Prometheustól. Legalább egy alatt (minReplicaCount), és a hüvelyek maximális száma nem haladja meg maxReplicaCount (ebben a példában - tíz).

Telepíthető minReplicaCount egyenlő nullával. Ebben az esetben a KEDA aktiválja a nulla-egyhez központi telepítést, majd felfedi a HPA-t további automatikus méretezéshez. Fordított sorrend is lehetséges, azaz egyről nullára skálázás. A példában nem választottuk ki a nullát, mert ez egy HTTP szolgáltatás, és nem egy igény szerinti rendszer.

Az automatikus skálázás varázsa

A küszöbértéket triggerként használják a telepítés skálázásához. Példánkban a PromQL lekérdezés sum(rate (http_requests [2m])) visszaadja az összesített HTTP-kérés arányát (kérések másodpercenként), az elmúlt két percben mérve.

Mivel a küszöbérték három, ez azt jelenti, hogy eggyel alacsonyabb lesz, miközben az érték sum(rate (http_requests [2m])) kevesebb mint három. Ha az érték növekszik, minden alkalommal egy további alpont kerül hozzáadásra sum(rate (http_requests [2m])) hárommal nő. Például, ha az érték 12 és 14 között van, akkor a hüvelyek száma négy.

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

előbeállítás

Csak egy Kubernetes-fürtre és egy konfigurált segédprogramra van szüksége kubectl. Ez a példa fürtöt használ minikube, de bármelyik másikat is veheted. Van egy fürt telepítése vezetés.

Telepítse a legújabb verziót 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/

Készlet kubectla Kubernetes-fürt eléréséhez.

Telepítse a legújabb verziót 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és

A KEDA-t többféleképpen telepítheti, ezek felsorolva vannak dokumentáció. Monolit YAML-t használok:

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

A KEDA és összetevői a névtérbe kerülnek telepítésre keda. Parancs az ellenőrzéshez:

kubectl get pods -n keda

Várja meg, amíg a KEDA Operator elindul, és lépjen a következőre Running State. És ezek után folytassa.

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

Ha nincs telepítve a Helm, használja ezt vezetés. Telepítési parancs Mac-en:

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

helm init inicializálja a helyi parancssori felületet és telepíti is Tiller a Kubernetes klaszterbe.

kubectl get pods -n kube-system | grep tiller

Várja meg, amíg a Tiller pod Futó állapotba kerül.

A fordító megjegyzése: A szerző a Helm@2-t használja, amihez telepíteni kell a Tiller szerver összetevőt. Most a Helm@3 releváns, nem igényel szerver részt.

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

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

Ellenőrizze, hogy a Redis sikeresen elindult-e:

kubectl get pods/redis-server-master-0

Várja meg, amíg Redis állapotba kerül Running.

Alkalmazások telepítése

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:

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

Várja meg, amíg a Redis állapotba lép Running.

Prometheus szerver telepítése

A Prometheus manifeszt felhasználása Kubernetes szolgáltatás felfedezése a Prometheus számára. Lehetővé teszi az alkalmazásdobozok dinamikus felfedezését a szolgáltatáscímke 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:

kubectl get pods -l=app=prometheus-server

Várja meg, amíg Prometheus állapotba kerül Running.

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

kubectl port-forward service/prometheus-service 9090

A KEDA Autoscaling Configuration telepítése

Parancs a létrehozáshoz ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Ellenőrizze a KEDA kezelői 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 valahogy í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ások alatt. Egy példánynak futnia kell, mert minReplicaCount egyenlő 1:

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

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

kubectl get hpa

Valami ilyesmit kellene látnod:

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

Állapotfelmérés: alkalmazás hozzáférés

Alkalmazásunk REST végpontjának eléréséhez futtassa:

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

Mostantól elérheti Go alkalmazását a cím használatával http://localhost:8080. Ehhez futtassa a parancsot:

curl http://localhost:8080/test

Az eredmény valahogy így néz ki:

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

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

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 number of http requests
# TYPE http_requests counter
http_requests 1

Betöltés létrehozása

Használni fogjuk hey — terhelést előállító segédprogram:

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

Letöltheti a segédprogramot is Linux vagy Windows.

Futtasd:

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

Alapértelmezés szerint a segédprogram 200 kérést küld. Ezt ellenőrizheti a Prometheus-metrikák és a Redis segítségével.

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

Érvényesítse a tényleges metrika értékét (a PromQL lekérdezés adja 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 1,686057971014493 és megjelenik a mezőben value. Ez nem elég a méretezéshez, hiszen az általunk beállított küszöb 3.

Több terhelés!

Az új terminálban figyelje az alkalmazássorok számát:

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

Növeljük a terhelést a következő paranccsal:

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

Egy idő után látni fogja, hogy a HPA méretezi a telepítést, és új podokat indít el. Ellenőrizze HPA-ját, hogy megbizonyosodjon a következőkről:

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

Ha a terhelés inkonzisztens, a telepítés addig a pontig csökken, ahol csak egy pod fut. Ha ellenőrizni szeretné a tényleges metrikát (amelyet a PromQL lekérdezés adott vissza), akkor használja a következő parancsot:

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

Очистка

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

Következtetés

A KEDA lehetővé teszi a Kubernetes-telepítések automatikus méretezését (nullára/nulláról) a külső metrikákból származó adatok alapján. Például a Prometheus mérőszámai alapján a várólista hossza Redisben, fogyasztói késleltetés a Kafka témában.

A KEDA integrálódik egy külső forrásba, és a Metrics Serveren keresztül a Horizontal Pod Autoscalerhez is biztosítja a mérőszámait.

Sok szerencsét!

Mit kell még olvasni:

Forrás: will.com

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