ProHoster > Blog > Administrácia > Automatické škálovanie aplikácií Kubernetes pomocou Prometheus a KEDA

Automatické škálovanie aplikácií Kubernetes pomocou Prometheus a KEDA

Automatické škálovanie aplikácií Kubernetes pomocou Prometheus a KEDABalloon Man od Cimuanos

Škálovateľnosť je kľúčová požiadavka pre cloudové aplikácie. S Kubernetes je škálovanie aplikácie rovnako jednoduché, ako zvýšiť počet replik pre príslušné nasadenie alebo ReplicaSet — ale to je ručný proces.

Kubernetes umožňuje automaticky škálovať aplikácie (t.j. Pod v nasadení alebo ReplicaSet) deklaratívnym spôsobom pomocou špecifikácie Horizontal Pod Autoscaler. Predpokladom pre automatické škálovanie sú štandardne metriky využitia CPU (metriky zdrojov), avšak je možné integrovať aj vlastné metriky a metriky poskytované zvonka.

Tím Kubernetes aaS od Mail.ru preložila článok o tom, ako používať externé metriky na automatické škálovanie aplikácie Kubernetes. Aby ukázala, ako to funguje, autor používa metriky HTTP dopytov, ktoré sú zhromažďované pomocou Prometheus.

Namiesto horizontálneho automatického škálovania podov sa používa Kubernetes Event Driven Autoscaling (KEDA) — open-source operátor Kubernetes. Pôvodne sa integruje s Horizontal Pod Autoscaler, aby zabezpečil plynulé automatické škálovanie (vrátane škálovania na/od nuly) pre pracovné zaťaženia riadené udalosťami. Kód je dostupný na GitHub.

Stručný prehľad fungovania systému

Automatické škálovanie aplikácií Kubernetes pomocou Prometheus a KEDA

Na schéme je stručný popis toho, ako to celé funguje:

  1. Aplikácia poskytuje metriky počtu požiadaviek na HTTP vo formáte Prometheus.
  2. Prometheus je nastavený na zber týchto ukazovateľov.
  3. Sčka Prometheus v KEDA je nastavený na automatické škálovanie aplikácie na základe počtu požiadaviek na HTTP.

Teraz podrobne poviem o každom prvku.

KEDA a Prometheus

Prometheus je open-source nástroj na monitorovanie a upozorňovanie systémov, časť Cloud Native Computing Foundation. Zhromažďuje metriky z rôznych zdrojov a uchováva ich vo forme časových radov. Na vizualizáciu dát je možné použiť Grafana alebo iné vizualizačné nástroje pracujúce s API Kubernetes.

KEDA podporuje koncept škálovača — pôsobí ako most medzi KEDA a externým systémom. Implementácia škálovača je špecifická pre každý cieľový systém a extrahuje z neho dáta. Potom KEDA tieto dáta využíva na riadenie automatického škálovania.

Skálera podporujú viaceré zdroje údajov, ako sú Kafka, Redis, Prometheus. To znamená, že KEDA sa dá použiť na automatické škálovanie nasadení Kubernetes na základe metriky Prometheus.

Testovacia aplikácia

Testovacia aplikácia v Golangu poskytuje prístup cez HTTP a vykonáva dve dôležité funkcie:

  1. Používa klientsku knižnicu Prometheus Go na instrumentáciu aplikácie a poskytovanie metriky http_requests, ktorá obsahuje počet požiadaviek. Konečný bod, na ktorom sú metriky Prometheus dostupné, sa nachádza na URI /metrics.
    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "počet http požiadaviek",
   })
  2. Na požiadavku GET aplikácia zvyšuje hodnotu kľúča (access_count) v Redis. To je jednoduchý spôsob, ako vykonať prácu ako súčasť HTTP spracovateľa a skontrolovať metriky Prometheus. Hodnota metriky by mala byť rovnaká ako 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("Nemožno zvýšiť počítadlo redis", err)
               os.Exit(1)
           }
           resp := "Prístup na " + time.Now().String() + "nPočet prístupov " + strconv.Itoa(int(count))
           w.Write([]byte(resp))
       })
       http.ListenAndServe(":8080", nil)
   }

Aplikácia sa nasadzuje v Kubernetes cez Nasadenie. Tiež sa vytvorí služba ClusterIP, ktorá umožňuje serveru Prometheus prijímať metriky aplikácie.

Tu sú manifest nasadenia pre aplikáciu.

Server Prometheus

Manifest nasadenia Prometheus pozostáva z:

  • ConfigMap — pre prenášanie konfigurácie Prometheus;
  • Nasadenie — na nasadenie Prometheus v Kubernetes klastri;
  • ClusterIP — služba na prístup k UI Prometheus;
  • ClusterRole, ClusterRoleBinding a ServiceAccount — na vykonávanie automatického objavovania služieb v Kubernetes (Auto-discovery).

Tu sú manifest na spustenie Prometheus.

KEDA Prometheus ScaledObject

Skáler funguje ako most medzi KEDA a externým systémom, z ktorého je potrebné získavať metriky. ScaledObject — konfigurovateľný zdroj, ktorý je potrebné nasadiť na synchronizáciu nasadenia so zdrojom udalostí, v tomto prípade s Prometheus.

ScaledObject obsahuje informácie o škálovaní nasadenia, metadáta o zdroji udalosti (napr. tajomstvá na pripojenie, názov fronty), interval dotazovania, čas zotavenia a ďalšie údaje. Vedie k zodpovedajúcemu zdroju automatického škálovania (definícia HPA) pre škálovanie nasadenia.

Keď objekt ScaledObject odstráni sa, zodpovedajúca definícia HPA sa vyčistí.

Tu je definícia ScaledObject pre náš príklad, používa sa škálovač 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]))

Zohľadnite nasledujúce body:

  1. Ukazuje na Nasadenie s názvom go-prom-app.
  2. Typ spúšťača je Prometheus. Adresa servera Prometheus sa spomína spolu s názvom metriky, prahovou hodnotou a dotazom PromQL, ktorý sa použije. Dotaz PromQL je sum(rate(http_requests[2m])).
  3. Podľa pollingInterval, KEDA žiada cieľ od Prometheus každých pätnásť sekúnd. Podporuje sa minimálne jeden pod (minReplicaCount), pričom maximálny počet podov nesmie prekročiť maxReplicaCount v tomto príklade — desať.

Môže sa nastaviť minReplicaCount na nulu. V tomto prípade KEDA spustí nasadenie zo systému nula na jeden a potom zabezpečí HPA na ďalšie automatické škálovanie. Možný je aj opačný poriadok, teda škálovanie z jedného na nula. V príklade sme nezvolili nulu, pretože ide o HTTP službu, nie systém na požiadanie.

Kúzlo v rámci automatického škálovania

Prahová hodnota sa používa ako spúšťač pre škálovanie nasadenia. V našom príklade dotaz PromQL sum(rate(http_requests[2m])) vracia agregovanú hodnotu rýchlosti HTTP požiadaviek (počet požiadaviek za sekundu), meranú za posledné dve minúty.

Keďže prahová hodnota je tri, bude jeden pod, pokiaľ bude hodnota sum(rate(http_requests[2m])) menšia ako tri. Keď sa však hodnota zvyšuje, pridáva sa ďalší pod vždy, keď sum(rate(http_requests[2m])) sa zvýši o tri. Napríklad, ak hodnota stúpne z 12 na 14, počet podov bude štyri.

Teraz to skúsme nastaviť!

Predbežné nastavenie

Všetko, čo potrebujete, je cluster Kubernetes a nastavený nástroj kubectl. V tomto príklade sa používa cluster minikube, ale môžete použiť akýkoľvek iný. Pre inštaláciu clusteru existuje príručka.

Inštalovať najnovšiu verziu 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/

Nainštalujte kubectl, aby ste získali prístup k clusteru Kubernetes.

Nainštalovať najnovšiu verziu 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

Inštalácia KEDA

Môžete nasadiť KEDA rôznymi spôsobmi, ktoré sú uvedené v dokumenácie. Používam monolitný YAML:

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

KEDA a jej komponenty sa inštalujú do priestoru názvov keda. Príkaz na kontrolu:

kubectl get pods -n keda

Čakajte, kým pod KEDA Operator štartuje — prejde do bežiaceho stavu. A potom pokračujte.

Inštalácia Redis pomocou Helm

Ak nemáte nainštalovaný Helm, použite tento návod. Príkaz na inštaláciu na Mac:

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

helm init iniciuje lokálny príkazový riadok a tiež inštaluje Tiller do Kubernetes klastrov.

kubectl get pods -n kube-system | grep tiller

Čakajte, kým pod Tiller prejde do stavu Running.

Poznámka prekladateľa: Autor používa Helm@2, ktorý vyžaduje inštaláciu serverovej komponenty Tiller. Momentálne je aktuálny Helm@3, pre ktorý serverová časť nie je potrebná.

Po inštalácii Helmu je na spustenie Redis potrebný len jeden príkaz:

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

Uistite sa, že Redis sa úspešne spustil:

kubectl get pods/redis-server-master-0

Čakajte, kým pod Redis prejde do stavu Running.

Nasadenie aplikácie

Príkaz na nasadenie:

kubectl apply -f go-app.yaml

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

Skontrolujte, že všetko beží:

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

Čakajte, kým Redis prejde do stavu Running.

Nasadenie servera Prometheus

Manifest Prometheus používa Kubernetes Service Discovery pre Prometheus. Umožňuje dynamicky objavovať pod aplikácie na základe označenia služby.

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

Na nasadenie:

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

Skontrolujte, že všetko beží:

kubectl get pods -l=app=prometheus-server

Čakajte, kým pod Prometheus prejde do stavu Running.

Použite kubectl port-forward na prístup k používateľskému rozhraniu Prometheus (alebo serveru API) na adrese http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Nasadenie konfigurácie automatického škálovania KEDA

Príkaz na vytvorenie ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Skontrolujte záznamy 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ýsledok vyzerá približne 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"

Skontrolujte pod aplikácie. Musí byť spustený jeden exemplár, pretože minReplicaCount rovná 1:

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

Skontrolujte, či bol zdroj HPA úspešne vytvorený:

kubectl get hpa

Mali by ste vidieť niečo ako:

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

Kontrola dostupnosti: prístup k aplikácii

Aby ste získali prístup k koncovému bodu REST našej aplikácie, spustite:

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

Teraz môžete získať prístup k aplikácii Go pomocou adresy http://localhost:8080. Na to vykonajte príkaz:

curl http://localhost:8080/test

Výsledok vyzerá približne takto:

Prístupné dňa 2019-10-21 11:29:10.560385986 +0000 UTC 
m=+406004.817901246
Počet prístupov 1

V tejto fáze skontrolujte aj Redis. Uvidíte, že kľúč access_count sa zvýšil na 1:

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

Uistite sa, že hodnota metriky http_requests je rovnaká:

curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests počet HTTP požiadaviek
# TYPE http_requests counter
http_requests 1

Generovanie záťaže

Budem používať hey — utilitu na generovanie záťaže:

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

Môžete si tiež stiahnuť utilitu pre Linux alebo Windows.

Spustite ju:

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

Predvolene utilita posiela 200 požiadaviek. Môžete sa o tom presvedčiť pomocou metrík Prometheus a tiež Redis.

curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests počet HTTP požiadaviek
# TYPE http_requests counter
http_requests 201
kubectl exec -it redis-server-master-0 -- redis-cli get access_count
//output
201

Potvrďte hodnotu skutočnej metriky (vrátenej požiadavkou 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 prípade je skutočný výsledok 1,686057971014493 a zobrazuje sa v poli value. To nestačí na škálovanie, pretože stanovený prah je 3.

Viac záťaže!

V novom termináli sledujte počet podov aplikácie:

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

Poďme zvýšiť záťaž pomocou príkazu:

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

O chvíľu uvidíte, že HPA škáluje nasadenie a spúšťa nové pod. Skontrolujte HPA, aby ste si to overili:

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

Ak je záťaž nepravidelná, nasadenie sa zníži na bod, pri ktorom funguje len jeden pod. Ak chcete skontrolovať skutočnú metriku (vrátenú dopytom PromQL), použite príkaz:

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

Vymazanie

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

KEDA umožňuje automaticky škálovať vaše nasadenia Kubernetes (až/od nuly) na základe údajov z externých metrík. Napríklad na základe metrík Prometheus, dĺžky fronty v Redis, oneskorenia spotrebiteľa v téme Kafka.

KEDA vykonáva integráciu s externým zdrojom a poskytuje jeho metriku prostredníctvom Metrics Server pre Horizontal Pod Autoscaler.

Veľa šťastia!

Čo ďalšie čítať:

  1. Najlepšie praktiky a odporúčania pre spúšťanie kontajnerov a Kubernetes v produkčných prostrediach.
  2. 90+ užitočných nástrojov pre Kubernetes: nasadenie, správa, monitoring, bezpečnosť a nielen to.
  3. Náš kanál Okolo Kubernetes na Telegrame.

Zdroj: habr.com

Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery 🔥 Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery | ProHoster