ProHoster > Dienoraštis > Administravimas > Automatinis Kubernetes programų mastelio keitimas naudojant Prometheus ir KEDA

Automatinis Kubernetes programų mastelio keitimas naudojant Prometheus ir KEDA

Automatinis Kubernetes programų mastelio keitimas naudojant Prometheus ir KEDA„Cimuanos“ balionas „Man“.

Mastelio keitimas yra pagrindinis debesų programų reikalavimas. Naudojant Kubernetes, programos mastelio keitimas yra toks pat paprastas, kaip padidinti kopijų skaičių atitinkamam diegimui arba ReplicaSet – bet tai rankinis procesas.

„Kubernetes“ leidžia automatiškai keisti programų mastelį (t. y. „Pod“ diegimo metu arba ReplicaSet) deklaratyviu būdu, naudojant Horizontal Pod Autoscaler specifikaciją. Numatytasis automatinio mastelio keitimo kriterijus yra procesoriaus naudojimo metrika (išteklių metrika), tačiau galite integruoti tinkintą ir išoriškai pateiktą metriką.

Komanda Kubernetes aaS iš Mail.ru išvertė straipsnį apie tai, kaip naudoti išorinę metriką, norint automatiškai pakeisti Kubernetes taikomąją programą. Norėdamas parodyti, kaip viskas veikia, autorius naudoja HTTP prieigos užklausų metriką, kuri renkama naudojant Prometheus.

Vietoj horizontalaus automatinio mastelio keitimo, naudojamas Kubernetes Event Driven Autoscaling (KEDA), atvirojo kodo Kubernetes operatorius. Jis savaime integruojamas su „Horizontal Pod Autoscaler“, kad būtų užtikrintas sklandus automatinis mastelio keitimas (įskaitant iki nulio / nuo nulio) įvykiais pagrįstiems darbo krūviams. Kodas pasiekiamas adresu GitHub.

Trumpa sistemos apžvalga

Automatinis Kubernetes programų mastelio keitimas naudojant Prometheus ir KEDA

Diagramoje pateikiamas trumpas aprašymas, kaip viskas veikia:

  1. Programa teikia HTTP įvykių skaičiaus metriką Prometheus formatu.
  2. „Prometheus“ yra sukonfigūruotas rinkti šias metrikas.
  3. KEDA Prometheus mastelio keitiklis sukonfigūruotas taip, kad automatiškai pakeistų programos mastelį pagal HTTP įvykių skaičių.

Dabar aš jums papasakosiu išsamiai apie kiekvieną elementą.

KEDA ir Prometėjas

„Prometheus“ yra atvirojo kodo sistemos stebėjimo ir įspėjimo priemonių rinkinio dalis „Cloud Native Computing Foundation“. Renka metriką iš įvairių šaltinių ir saugo juos kaip laiko eilučių duomenis. Norėdami vizualizuoti duomenis, galite naudoti grafana arba kiti vizualizacijos įrankiai, veikiantys su Kubernetes API.

KEDA palaiko skalerio koncepciją – ji veikia kaip tiltas tarp KEDA ir išorinės sistemos. Mastelio diegimas yra specifinis kiekvienai tikslinei sistemai ir iš jos ištraukia duomenis. Tada KEDA juos naudoja automatiniam mastelio keitimui valdyti.

Skaleriai palaiko kelis duomenų šaltinius, pavyzdžiui, Kafka, Redis, Prometheus. Tai reiškia, kad KEDA galima naudoti norint automatiškai keisti „Kubernetes“ diegimus, naudojant „Prometheus“ metriką kaip kriterijus.

Bandomoji programa

Golang testavimo programa suteikia prieigą per HTTP ir atlieka dvi svarbias funkcijas:

  1. Naudoja „Prometheus Go“ kliento biblioteką, kad įtaisytų programą ir pateiktų http_requests metriką, kurioje yra įvykių skaičius. Galutinis taškas, kuriame pasiekiama „Prometheus“ metrika, yra URI /metrics. 
    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
  2. Atsakydamas į prašymą GET programa padidina rakto reikšmę (access_count) Redyje. Tai paprastas būdas atlikti HTTP tvarkyklės darbą ir patikrinti Prometheus metriką. Metrikos vertė turi būti tokia pati kaip vertė access_count Redyje. 
    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)
   }

Programa yra įdiegta Kubernetes per Deployment. Taip pat sukuriama paslauga ClusterIP, tai leidžia Prometheus serveriui gauti taikomųjų programų metriką.

Čia programos diegimo manifestas.

Prometėjo serveris

„Prometheus“ diegimo manifestą sudaro:

  • ConfigMap — perkelti Prometheus konfigūraciją;
  • Deployment — už Prometėjo dislokavimą Kubernetes klasteryje;
  • ClusterIP — prieigos prie UI Prometheus paslauga;
  • ClusterRole, ClusterRoleBinding и ServiceAccount - automatiniam paslaugų aptikimui Kubernetes (automatinis atradimas).

Čia manifestas, skirtas paleisti Prometėją.

KEDA Prometheus ScaledObject

Skaleris veikia kaip tiltas tarp KEDA ir išorinės sistemos, iš kurios reikia gauti metriką. ScaledObject yra pasirinktinis išteklius, kurį reikia įdiegti, kad būtų galima sinchronizuoti diegimą su įvykio šaltiniu, šiuo atveju „Prometheus“.

ScaledObject yra diegimo mastelio informacija, įvykių šaltinio metaduomenys (pvz., ryšio paslaptys, eilės pavadinimas), apklausos intervalas, atkūrimo laikotarpis ir kiti duomenys. Dėl to atsiranda atitinkamas automatinio mastelio keitimo išteklius (HPA apibrėžimas), kad būtų galima išplėsti diegimą.

Kai objektas ScaledObject ištrintas, atitinkamas HPA apibrėžimas išvalomas.

Štai apibrėžimas ScaledObject mūsų pavyzdžiui, jis naudoja skalerį 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]))

Atkreipkite dėmesį į šiuos dalykus:

  1. Jis nurodo Deployment Su vardu go-prom-app.
  2. Trigerio tipas - Prometheus. Prometheus serverio adresas minimas kartu su metrikos pavadinimu, slenksčiu ir PromQL užklausa, kuris bus naudojamas. PromQL užklausa – sum(rate(http_requests[2m])).
  3. Pagal pollingIntervalKEDA kas penkiolika sekundžių prašo taikinio iš Prometėjo. Bent vienas po (minReplicaCount), o didžiausias ankščių skaičius neviršija maxReplicaCount (šiame pavyzdyje – dešimt).

Galima montuoti minReplicaCount lygus nuliui. Tokiu atveju KEDA suaktyvina diegimą nuo vieno iki vieno ir atskleidžia HPA tolesniam automatiniam mastelio keitimui. Galima ir atvirkštinė tvarka, tai yra, mastelio keitimas nuo vieno iki nulio. Pavyzdyje nepasirinkome nulio, nes tai yra HTTP paslauga, o ne sistema pagal pareikalavimą.

Magija automatinio mastelio keitimo viduje

Slenkstis naudojamas kaip diegimo masto paleidiklis. Mūsų pavyzdyje PromQL užklausa sum(rate (http_requests [2m])) grąžina apibendrintą HTTP užklausų dažnį (užklausų per sekundę), išmatuotą per paskutines dvi minutes.

Kadangi slenkstinė vertė yra trys, tai reiškia, kad vertė bus mažesnė nei viena sum(rate (http_requests [2m])) mažiau nei trys. Jei reikšmė didėja, kiekvieną kartą pridedamas papildomas pogrupis sum(rate (http_requests [2m])) padidėja trimis. Pavyzdžiui, jei reikšmė yra nuo 12 iki 14, ankščių skaičius yra keturi.

Dabar pabandykime jį nustatyti!

išankstinis nustatymas

Viskas, ko jums reikia, yra „Kubernetes“ klasteris ir sukonfigūruota priemonė kubectl. Šiame pavyzdyje naudojamas klasteris minikube, bet galite pasiimti bet kurį kitą. Norėdami įdiegti klasterį, yra vadovas.

Įdiekite naujausią versiją „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/

Nustatyti kubectlpasiekti Kubernetes klasterį.

Įdiekite naujausią versiją „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

KEDA montavimas

KEDA galite įdiegti keliais būdais, jie išvardyti dokumentacija. Naudoju monolitinį YAML:

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

KEDA ir jos komponentai yra įdiegti vardų erdvėje keda. Komanda patikrinti:

kubectl get pods -n keda

Palaukite, kol KEDA operatorius pradės veikti, ir eikite į Running State. Ir po to tęskite.

„Redis“ diegimas naudojant „Helm“.

Jei nesate įdiegę „Helm“, naudokite tai vadovavimas. Įdiegimo komanda „Mac“:

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

helm init inicijuoja vietinę komandų eilutės sąsają ir taip pat įdiegia Tiller į Kubernetes klasterį.

kubectl get pods -n kube-system | grep tiller

Palaukite, kol Tiller pod pereis į Veikimo būseną.

Vertėjo pastaba: Autorius naudoja Helm@2, kuriam reikia įdiegti Tiller serverio komponentą. Dabar Helm@3 aktualus, jam nereikia serverio dalies.

Įdiegę „Helm“, pakanka vienos komandos, kad paleistumėte „Redis“:

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

Patikrinkite, ar Redis sėkmingai paleido:

kubectl get pods/redis-server-master-0

Palaukite, kol Redis pereis į būseną Running.

Programos diegimas

Diegimo komanda:

kubectl apply -f go-app.yaml

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

Patikrinkite, ar viskas prasidėjo:

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

Palaukite, kol Redis įves būseną Running.

„Prometheus“ serverio diegimas

Prometėjo manifestas naudoja „Prometheus“ „Kubernetes“ paslaugos atradimas. Tai leidžia dinamiškai aptikti taikomųjų programų paketus pagal paslaugos etiketę.

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

Norėdami įdiegti:

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

Patikrinkite, ar viskas prasidėjo:

kubectl get pods -l=app=prometheus-server

Palaukite, kol Prometėjas pereis į būseną Running.

Naudokite kubectl port-forward pasiekti Prometheus vartotojo sąsają (arba API serverį) adresu http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA automatinio mastelio keitimo konfigūracijos diegimas

Komanda sukurti ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Patikrinkite KEDA operatoriaus žurnalus:

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

Rezultatas atrodo maždaug taip:

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"

Patikrinkite paraiškose. Vienas egzempliorius turi būti paleistas, nes minReplicaCount lygus 1:

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

Patikrinkite, ar HPA išteklius buvo sukurtas sėkmingai:

kubectl get hpa

Turėtumėte pamatyti kažką panašaus:

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

Sveikatos patikrinimas: prieiga prie programos

Norėdami pasiekti mūsų programos REST galutinį tašką, paleiskite:

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

Dabar galite pasiekti „Go“ programą naudodami adresą http://localhost:8080. Norėdami tai padaryti, paleiskite komandą:

curl http://localhost:8080/test

Rezultatas atrodo maždaug taip:

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

Šiuo metu taip pat patikrinkite Redis. Pamatysite, kad raktas access_count padidintas iki 1:

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

Įsitikinkite, kad metrikos vertė yra http_requests tas pats:

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

Krovinio kūrimas

Mes naudosime ei — apkrovos generavimo įrankis:

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

Taip pat galite atsisiųsti įrankį, skirtą Linux arba Windows.

Paleiskite tai:

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

Pagal numatytuosius nustatymus programa siunčia 200 užklausų. Tai galite patikrinti naudodami „Prometheus“ metriką ir „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

Patvirtinkite tikrosios metrikos vertę (pateikiama PromQL užklausoje):

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

Šiuo atveju tikrasis rezultatas yra 1,686057971014493 ir rodomas lauke value. To nepakanka mastelio keitimui, nes mūsų nustatyta riba yra 3.

Daugiau apkrovos!

Naujajame terminale stebėkite programų rinkinių skaičių:

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

Padidinkime apkrovą naudodami komandą: 

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

Po kurio laiko pamatysite, kaip HPA padidins diegimo mastelį ir paleis naujus blokus. Patikrinkite savo HPA ir įsitikinkite, kad:

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

Jei apkrova nenuosekli, diegimas bus sumažintas iki taško, kuriame veikia tik vienas modulis. Jei norite patikrinti tikrąją metriką (kurią grąžino PromQL užklausa), naudokite komandą:

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

Valymas

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

išvada

KEDA leidžia automatiškai keisti Kubernetes diegimo mastelį (iki/iš nulio), remiantis išorinės metrikos duomenimis. Pavyzdžiui, remiantis Prometheus metrika, eilės ilgiu Redis, vartotojo delsa Kafkos temoje.

KEDA integruojasi su išoriniu šaltiniu ir taip pat pateikia savo metriką per „Metrics Server“ į „Horizontal Pod Autoscaler“.

Sėkmės!

Ką dar skaityti:

  1. Geriausia praktika ir geriausia praktika, kaip naudoti konteinerius ir „Kubernetes“ gamybos aplinkoje.
  2. 90 ir daugiau naudingų „Kubernetes“ įrankių: diegimas, valdymas, stebėjimas, sauga ir kt.
  3. Mūsų kanalas „Around Kubernetes“ telegramoje.

Šaltinis: www.habr.com

Добавить комментарий