🥇Automatické škálování aplikací Kubernetes pomocí Prometheus a KEDA

Balloon Man od Cimuanos

Škálovatelnost je klíčovým požadavkem pro cloudové aplikace. S Kubernetes je škálování aplikace stejně jednoduché jako zvýšení počtu replik pro příslušné nasazení nebo ReplicaSet — ale je to ruční proces.

Kubernetes umožňuje automatické škálování aplikací (tj. Pody v nasazení nebo ReplicaSet) deklarativním způsobem pomocí specifikace Horizontal Pod Autoscaler. Výchozím kritériem pro automatické škálování jsou metriky využití CPU (metriky zdrojů), ale můžete integrovat vlastní a externě poskytované metriky.

Tým Kubernetes aaS z Mail.ru přeložil článek o tom, jak používat externí metriky k automatickému škálování aplikace Kubernetes. Aby autor ukázal, jak vše funguje, používá metriky požadavků na přístup HTTP, které jsou shromažďovány pomocí Prometheus.

Místo horizontálního automatického škálování podů se používá Kubernetes Event Driven Autoscaling (KEDA), open source operátor Kubernetes. Nativně se integruje s Horizontal Pod Autoscaler a poskytuje bezproblémové automatické škálování (včetně do/od nuly) pro pracovní zátěže řízené událostmi. Kód dostupný na GitHub.

Stručný přehled systému

Diagram ukazuje stručný popis toho, jak vše funguje:

Aplikace poskytuje metriky počtu přístupů HTTP ve formátu Prometheus.
Prometheus je nakonfigurován ke shromažďování těchto metrik.
Prometheus scaler v KEDA je nakonfigurován tak, aby automaticky škáloval aplikaci na základě počtu HTTP zásahů.

Nyní vám řeknu podrobně o každém prvku.

KEDA a Prometheus

Prometheus je open source sada nástrojů pro monitorování a varování, část Cloud Native Computing Foundation. Shromažďuje metriky z různých zdrojů a ukládá je jako data časových řad. K vizualizaci dat můžete použít grafana nebo jiné vizualizační nástroje, které pracují s Kubernetes API.

KEDA podporuje koncept scaleru – funguje jako most mezi KEDA a externím systémem. Implementace scaleru je specifická pro každý cílový systém a extrahuje z něj data. KEDA je pak používá k řízení automatického škálování.

Scalery podporují více zdrojů dat, například Kafka, Redis, Prometheus. To znamená, že KEDA lze použít k automatickému škálování nasazení Kubernetes pomocí metrik Prometheus jako kritérií.

Testovací aplikace

Testovací aplikace Golang poskytuje přístup přes HTTP a plní dvě důležité funkce:

Používá klientskou knihovnu Prometheus Go k instrumentaci aplikace a poskytování metriky http_requests, která obsahuje počet zásahů. Koncový bod, kde jsou dostupné metriky Prometheus, se nachází na URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

V reakci na žádost GET aplikace zvýší hodnotu klíče (access_count) v Redis. Toto je snadný způsob, jak pracovat jako součást obsluhy HTTP a také kontrolovat metriky Prometheus. Metrická hodnota musí být stejná jako hodnota access_count v 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)
   }

Aplikace je nasazena na Kubernetes přes Deployment. Je také vytvořena služba ClusterIPumožňuje serveru Prometheus získat metriky aplikace.

zde je manifest nasazení pro aplikaci.

Server Prometheus

Manifest nasazení Prometheus se skládá z:

ConfigMap — pro přenos konfigurace Prometheus;
Deployment — pro nasazení Prometheus v clusteru Kubernetes;
ClusterIP — služba pro přístup k uživatelskému rozhraní Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — pro automatickou detekci služeb v Kubernetes (Auto-discovery).

zde je manifest pro spuštění Promethea.

KEDA Prometheus ScaledObject

Scaler funguje jako most mezi KEDA a externím systémem, ze kterého je třeba získávat metriky. ScaledObject je vlastní zdroj, který je třeba nasadit, aby bylo možné synchronizovat nasazení se zdrojem události, v tomto případě Prometheus.

ScaledObject obsahuje informace o měřítku nasazení, metadata zdroje událostí (jako jsou tajné klíče připojení, název fronty), interval dotazování, období obnovy a další data. Výsledkem je odpovídající prostředek automatického škálování (definice HPA) pro škálování nasazení.

Když objekt ScaledObject vymažete, odpovídající definice HPA se vymaže.

Tady je definice ScaledObject pro náš příklad používá scaler 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]))

Vezměte prosím na vědomí následující body:

Ukazuje na Deployment Se jménem go-prom-app.
Typ spouštění - Prometheus. Adresa serveru Prometheus je uvedena spolu s názvem metriky, prahem a Dotaz PromQL, který bude použit. Dotaz PromQL - sum(rate(http_requests[2m])).
Podle pollingInterval,KEDA požaduje od Promethea cíl každých patnáct sekund. Alespoň jeden pod (minReplicaCount) a maximální počet lusků nepřekračuje maxReplicaCount (v tomto příkladu - deset).

Lze nainstalovat minReplicaCount rovna nule. V tomto případě KEDA aktivuje nasazení nula ku jedné a poté vystaví HPA pro další automatické škálování. Možné je i obrácené pořadí, tedy škálování od jedné do nuly. V příkladu jsme nevybrali nulu, protože se jedná o službu HTTP a ne o systém na vyžádání.

Kouzlo uvnitř automatického škálování

Práh se používá jako spouštěč pro škálování nasazení. V našem příkladu dotaz PromQL sum(rate (http_requests [2m])) vrací agregovanou rychlost HTTP požadavků (požadavky za sekundu), měřenou za poslední dvě minuty.

Protože prahová hodnota je tři, znamená to, že bude jedna pod hodnotou sum(rate (http_requests [2m])) méně než tři. Pokud se hodnota zvýší, pokaždé se přidá další dílčí sum(rate (http_requests [2m])) zvýší o tři. Pokud je například hodnota od 12 do 14, pak je počet lusků čtyři.

Teď to zkusíme nastavit!

Přednastavení

Vše, co potřebujete, je cluster Kubernetes a nakonfigurovaný nástroj kubectl. Tento příklad používá cluster minikube, ale můžete si vzít jakýkoli jiný. Chcete-li nainstalovat cluster, existuje průvodce.

Nainstalujte nejnovější verzi na Mac:

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/

Sada kubectlpro přístup ke clusteru Kubernetes.

Nainstalujte nejnovější verzi na Mac:

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

Instalace KEDA

KEDA můžete nasadit několika způsoby, jsou uvedeny v dokumentace. Používám monolitický YAML:

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

KEDA a jeho součásti jsou nainstalovány do jmenného prostoru keda. Příkaz ke kontrole:

kubectl get pods -n keda

Počkejte, až se KEDA Operator spustí, a přejděte na Running State. A poté pokračujte.

Instalace Redis pomocí Helm

Pokud nemáte nainstalovaný Helm, použijte toto vedení lidí. Příkaz k instalaci na Mac:

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

helm init inicializuje místní rozhraní příkazového řádku a také nainstaluje Tiller do clusteru Kubernetes.

kubectl get pods -n kube-system | grep tiller

Počkejte, až ovládací modul přejde do stavu Running.

Poznámka překladatele: Autor používá Helm@2, který vyžaduje instalaci serverové komponenty Tiller. Nyní je Helm@3 relevantní, nevyžaduje serverovou část.

Po instalaci Helmu stačí ke spuštění Redis jeden příkaz:

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

Ověřte, že se Redis úspěšně spustil:

kubectl get pods/redis-server-master-0

Počkejte, až Redis přejde do stavu Running.

Nasazení aplikací

Příkaz k nasazení:

kubectl apply -f go-app.yaml

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

Zkontrolujte, zda vše začalo:

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

Počkejte, až Redis vstoupí do stavu Running.

Nasazení serveru Prometheus

Manifest Prometheus používá Kubernetes Service Discovery pro Prometheus. Umožňuje dynamické zjišťování aplikačních modulů na základě servisního štítku.

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

Rozmístit:

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

Zkontrolujte, zda vše začalo:

kubectl get pods -l=app=prometheus-server

Počkejte, až Prométheus přejde do stavu Running.

použití kubectl port-forward pro přístup k uživatelskému rozhraní Prometheus (nebo serveru API) na adrese http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Nasazení konfigurace automatického škálování KEDA

Příkaz k vytvoření ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Zkontrolujte protokoly operátora KEDA:

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

Výsledek vypadá asi takto:

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"

Zkontrolujte pod aplikacemi. Jedna instance musí být spuštěna, protože minReplicaCount rovná se 1:

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

Ověřte, zda byl prostředek HPA úspěšně vytvořen:

kubectl get hpa

Měli byste vidět něco jako:

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

Kontrola stavu: přístup k aplikaci

Chcete-li získat přístup ke koncovému bodu REST naší aplikace, spusťte:

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

Nyní můžete přistupovat k aplikaci Go pomocí adresy http://localhost:8080. Chcete-li to provést, spusťte příkaz:

curl http://localhost:8080/test

Výsledek vypadá asi takto:

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

V tomto okamžiku také zkontrolujte Redis. Uvidíte, že klíč access_count zvýšen na 1:

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

Ujistěte se, že metrická hodnota je http_requests stejný:

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

Načíst vytvoření

Budeme používat hej — nástroj pro generování zátěže:

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

Můžete si také stáhnout nástroj pro Linux nebo Windows.

Spusť to:

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

Ve výchozím nastavení nástroj odešle 200 požadavků. Můžete to ověřit pomocí metrik Prometheus a také Redis.

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

Ověřte hodnotu skutečné metriky (vrácené dotazem PromQL):

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

V tomto případě je skutečný výsledek 1,686057971014493 a zobrazí se v poli value. To pro škálování nestačí, protože prahová hodnota, kterou jsme nastavili, je 3.

Více zátěže!

V novém terminálu sledujte počet aplikačních modulů:

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

Zvyšme zátěž pomocí příkazu:

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

Po chvíli uvidíte, že HPA škáluje nasazení a spouští nové moduly. Zkontrolujte svůj HPA a ujistěte se, že:

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

Pokud je zatížení nekonzistentní, bude nasazení omezeno do bodu, kdy běží pouze jeden modul. Pokud chcete zkontrolovat skutečnou metriku (vrácenou dotazem PromQL), použijte příkaz:

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

Čištění

//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ávěr

KEDA vám umožňuje automaticky škálovat vaše nasazení Kubernetes (na/od nuly) na základě dat z externích metrik. Například na základě metrik Prometheus, délky fronty v Redis, latence spotřebitelů v tématu Kafka.

KEDA se integruje s externím zdrojem a také poskytuje své metriky přes Metrics Server do Horizontal Pod Autoscaler.

Good Luck!

Co ještě číst:

Zdroj: www.habr.com

Automatické škálování aplikací Kubernetes pomocí Prometheus a KEDA