🥇Kubernetes-sovellusten automaattinen skaalaus Prometheuksen ja KEDA:n avulla

Cimuanosin Balloon Man

Skaalautuvuus on pilvisovellusten keskeinen vaatimus. Kubernetesilla sovelluksen skaalaaminen on yhtä helppoa kuin replikoiden määrän lisääminen tietylle käyttöönotolle tai ReplicaSet - mutta se on manuaalinen prosessi.

Kubernetesin avulla voit skaalata sovelluksia automaattisesti (esim. käyttöönoton aikana tai ReplicaSet) deklaratiivisesti käyttämällä Horizontal Pod Autoscaler -spesifikaatiota. Automaattisen skaalauksen oletusehto on suorittimen käyttömetriikka (resurssimetriikka), mutta voit integroida mukautettuja mittareita ja ulkoisesti toimitettuja mittareita.

Joukkue Kubernetes aaS osoitteesta Mail.ru käänsi artikkelin ulkoisten mittareiden käyttämisestä Kubernetes-sovelluksen automaattiseen skaalaukseen. Näyttääkseen kuinka kaikki toimii, kirjoittaja käyttää HTTP-käyttöpyyntömittareita, jotka kerätään Prometheuksen avulla.

Vaakasuuntaisen pod-automaattisen skaalauksen sijaan Kubernetes Event Driven Autoscaling (KEDA) on avoimen lähdekoodin Kubernetes-operaattori. Se integroituu natiivisti Horizontal Pod Autoscalerin kanssa ja tarjoaa saumattoman automaattisen skaalauksen (mukaan lukien nollasta/nollasta) tapahtumapohjaisissa työkuormissa. Koodi on saatavilla osoitteessa GitHub.

Lyhyt katsaus järjestelmän toimivuuteen

Kaavio on lyhyt kuvaus siitä, kuinka kaikki toimii:

Sovellus tarjoaa HTTP-osumamäärämittauksia Prometheus-muodossa.
Prometheus on määritetty keräämään näitä mittareita.
KEDA:n Prometheus-skaalaaja on määritetty skaalaamaan sovellus automaattisesti HTTP-osumien määrän perusteella.

Puhutaan nyt jokaisesta elementistä yksityiskohtaisesti.

KEDA ja Prometheus

Prometheus on avoimen lähdekoodin järjestelmän valvonta- ja hälytystyökalusarja, osa Cloud Native Computing -säätiö. Kerää mittareita eri lähteistä ja tallentaa aikasarjatietoina. Voit visualisoida tietoja käyttämällä grafana tai muita Kubernetes API:n kanssa toimivia visualisointityökaluja.

KEDA tukee skaalauskonseptia - se toimii siltana KEDA:n ja ulkoisen järjestelmän välillä. Skaalaustoteutus on kunkin kohdejärjestelmän mukainen ja poimii siitä dataa. KEDA käyttää niitä sitten automaattisen skaalauksen ohjaamiseen.

Skaalaimet tukevat useita tietolähteitä, kuten Kafka, Redis, Prometheus. Toisin sanoen KEDAa voidaan käyttää Kubernetes-asennusten automaattiseen skaalaukseen käyttämällä Prometheus-mittareita kriteereinä.

testisovellus

Golang-testisovellus tarjoaa HTTP-yhteyden ja suorittaa kaksi tärkeää toimintoa:

Käyttää Prometheus Go -asiakaskirjastoa instrumentoidakseen sovelluksen ja tarjotakseen http_requests-mittarin, joka sisältää osumamäärän. Päätepiste, jossa Prometheus-mittarit ovat saatavilla, sijaitsee URI:n mukaan /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Vastauksena pyyntöön GET sovellus lisää avaimen arvoa (access_count) Redisissä. Tämä on helppo tapa saada työ tehtyä osana HTTP-käsittelijää ja myös tarkistaa Prometheus-mittarit. Mittarin arvon on oltava sama kuin arvon access_count paikassa 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)
   }

Sovellus otetaan käyttöön Kubernetesin kautta Deployment. Se luo myös palvelun ClusterIP, sen avulla Prometheus-palvelin voi saada sovellusmittareita.

Täällä sovelluksen käyttöönottoluettelo.

Prometheus-palvelin

Prometheus-käyttöönottoluettelo koostuu:

ConfigMap - siirtää Prometheus-konfiguraatio;
Deployment - ottaa Prometheus käyttöön Kubernetes-klusterissa;
ClusterIP — Prometheus-käyttöliittymän käyttöoikeuspalvelu;
ClusterRole, ClusterRoleBinding и ServiceAccount - Kubernetes-palveluiden automaattiseen tunnistamiseen (Auto-Discovery).

Täällä manifesti suorittaa Prometheus.

KEDA Prometheus ScaledObject

Skaalauslaite toimii siltana KEDA:n ja ulkoisen järjestelmän välillä, josta saadaan mittareita. ScaledObject on mukautettu resurssi, se on otettava käyttöön, jotta käyttöönotto synkronoidaan tapahtumalähteen, tässä tapauksessa Prometheuksen, kanssa.

ScaledObject sisältää tietoja käyttöönoton skaalauksesta, metatiedot tapahtuman lähteestä (esimerkiksi yhteyden salaisuudet, jonon nimi), kyselyvälistä, palautusjaksosta ja muita tietoja. Se johtaa asianmukaiseen automaattiseen skaalaukseen (HPA-määrittely) käyttöönoton skaalaamiseksi.

Kun esine ScaledObject on poistettu, sitä vastaava HPA-määritelmä tyhjennetään.

Tässä on määritelmä ScaledObject esimerkiksi se käyttää skaalainta 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]))

Harkitse seuraavia kohtia:

Hän osoittaa Deployment Nimellä go-prom-app.
laukaisutyyppi - Prometheus. Prometheus-palvelimen osoite mainitaan yhdessä mittarin nimen, kynnyksen ja PromQL kyselykäytettäväksi. PromQL-kysely − sum(rate(http_requests[2m])).
Mukaan pollingIntervalKEDA kysyy Prometheukselta kohdetta viidentoista sekunnin välein. Vähintään yksi pod on tuettu (minReplicaCount), ja palojen enimmäismäärä ei ylitä maxReplicaCount (tässä esimerkissä kymmenen).

Voi asentaa minReplicaCount yhtä suuri kuin nolla. Tässä tapauksessa KEDA aktivoi käyttöönoton nollasta yhteen ja tarjoaa sitten HPA:n automaattista lisäskaalausta varten. Myös käänteinen järjestys on mahdollinen, eli skaalaus yhdestä nollaan. Esimerkissä emme valinneet nollaa, koska se on HTTP-palvelu eikä tilausjärjestelmä.

Taika automaattiskaalan sisällä

Kynnysarvoa käytetään käynnistyksenä skaalattaessa käyttöönottoa. Esimerkissämme PromQL-kysely sum(rate (http_requests [2m])) palauttaa kootun HTTP-pyyntönopeuden (pyyntöjä sekunnissa) mitattuna viimeisen kahden minuutin aikana.

Koska kynnysarvo on kolme, arvoon asti on yksi pod sum(rate (http_requests [2m])) alle kolme. Jos arvo kasvaa, ylimääräinen ali lisätään joka kerta sum(rate (http_requests [2m])) kasvaa kolmella. Jos arvo on esimerkiksi 12-14, koteloiden lukumäärä on neljä.

Nyt yritetään mukauttaa!

esiasetus

Tarvitset vain Kubernetes-klusterin ja määritetyn apuohjelman kubectl. Tässä esimerkissä käytetään klusteria minikube, mutta voit ottaa minkä tahansa muun. Voit perustaa klusterin руководство.

Asenna uusin versio Maciin:

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/

Asettaa kubectlpäästäksesi Kubernetes-klusteriin.

Asenna uusin versio Maciin:

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 asennus

Voit ottaa KEDA:n käyttöön useilla tavoilla, jotka on lueteltu kohdassa dokumentointi. Käytän monoliittista YAML:a:

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

KEDA ja sen komponentit asennetaan nimiavaruuteen keda. Komento tarkistaa:

kubectl get pods -n keda

Odota, kunnes se käynnistyy KEDA-operaattorin alla - se vaihtuu Running State. Ja sen jälkeen jatka.

Rediksen asentaminen Helmin kanssa

Jos sinulla ei ole Helmiä asennettuna, käytä tätä johtajuutta. Maciin asennettava komento:

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

helm init alustaa paikallisen komentoriviliittymän ja myös asettaa Tiller Kubernetes-klusteriin.

kubectl get pods -n kube-system | grep tiller

Odota, kunnes Tiller Pod siirtyy Käynnissä-tilaan.

Kääntäjän huomautus: Tekijä käyttää Helm@2:ta, joka vaatii Tiller-palvelinkomponentin asentamisen. Nyt Helm@3 on relevantti, palvelinosaa ei siihen tarvita.

Helmin asennuksen jälkeen yksi komento riittää käynnistämään Redis:

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

Varmista, että Redis käynnistyi onnistuneesti:

kubectl get pods/redis-server-master-0

Odota, kunnes Redis siirtyy tilaan Running.

Sovelluksen käyttöönotto

Käyttöönottokomento:

kubectl apply -f go-app.yaml

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

Tarkista, että kaikki toimii:

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

Odota, että Redis siirtyy tilaan Running.

Prometheus-palvelimen käyttöönotto

Prometheuksen manifesti käyttää Kubernetes Service Discovery for Prometheus. Sen avulla voit löytää dynaamisesti sovellustyyppejä palvelutarran perusteella.

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

Käyttöönottoa varten:

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

Tarkista, että kaikki toimii:

kubectl get pods -l=app=prometheus-server

Odota, kunnes Prometheus tulee osavaltioon Running.

käyttö kubectl port-forward päästäksesi Prometheus-käyttöliittymään (tai API-palvelimeen) osoitteessa http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA Autoscale Configurationin käyttöönotto

Komento luoda ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Tarkista KEDA-operaattorin lokit:

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

Tulos näyttää suunnilleen tältä:

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"

Tarkista sovellukset alta. Yhden esiintymän on oltava käynnissä, koska minReplicaCount on yhtä kuin 1:

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

Varmista, että HPA-resurssin luominen onnistui:

kubectl get hpa

Sinun pitäisi nähdä jotain tällaista:

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

Terveystarkastus: App Access

Pääset sovelluksemme REST-päätepisteeseen suorittamalla:

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

Voit nyt käyttää Go-sovellusta käyttämällä osoitetta http://localhost:8080. Voit tehdä tämän suorittamalla komennon:

curl http://localhost:8080/test

Tulos näyttää suunnilleen tältä:

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

Tarkista tässä vaiheessa myös Redis. Näet sen avaimen access_count nostettu 1:een:

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

Varmista metriarvo http_requests sama:

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

Kuorman luominen

Käytämme hei - apuohjelma kuorman luomiseen:

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

Voit myös ladata apuohjelman Linux tai Windows.

Suorita se:

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

Oletusarvoisesti apuohjelma lähettää 200 pyyntöä. Voit varmistaa tämän käyttämällä Prometheus-mittareita sekä 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

Vahvista todellisen mittarin arvo (palauttaa PromQL-kyselyn):

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

Tässä tapauksessa todellinen tulos on 1,686057971014493 ja näytetään kentällä value. Tämä ei riitä skaalaukseen, koska asettamamme kynnys on 3.

Lisää kuormaa!

Seuraa uudessa terminaalissa sovelluskoteloiden määrää:

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

Lisätään kuormaa komennolla:

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

Hetken kuluttua huomaat, että HPA laajentaa käyttöönottoa ja käynnistää uusia koteloita. Tarkista HPA varmistaaksesi:

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

Jos kuormitus on ajoittaista, käyttöönotto kutistuu pisteeseen, jossa vain yksi Pod on käynnissä. Jos haluat tarkistaa todellisen mittarin (jonka PromQL-kysely palauttaa), käytä komentoa:

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

puhdistus

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

Johtopäätös

KEDA antaa sinun skaalata Kubernetes-asetuksesi automaattisesti (nollaan/nollasta) ulkoisten mittareiden tietojen perusteella. Esimerkiksi Prometheus-mittareiden perusteella jonon pituus Redisissä, kuluttajaviive Kafka-aiheessa.

KEDA integroituu ulkoiseen lähteeseen ja tarjoaa myös mittansa Metrics Serverin kautta Horizontal Pod Autoscaleriin.

Good Luck!

Mitä muuta luettavaa:

Lähde: will.com

Kubernetes-sovellusten automaattinen skaalaus Prometheuksen ja KEDA:n avulla