ProHoster > Blog > uprava > Automatsko skaliranje Kubernetes aplikacija s Prometheusom i KEDA-om

Automatsko skaliranje Kubernetes aplikacija s Prometheusom i KEDA-om

Automatsko skaliranje Kubernetes aplikacija s Prometheusom i KEDA-omBalon Man by Cimuanos

Skalabilnost je ključni zahtjev za aplikacije u oblaku. Uz Kubernetes, skaliranje aplikacije jednostavno je poput povećanja broja replika za odgovarajuću implementaciju ili ReplicaSet — ali to je ručni proces.

Kubernetes omogućuje automatsko skaliranje aplikacija (tj. Pods u implementaciji ili ReplicaSet) na deklarativan način koristeći specifikaciju Horizontal Pod Autoscaler. Zadani kriterij za automatsko skaliranje je metrika upotrebe CPU-a (metrika resursa), ali možete integrirati prilagođene i vanjske metrike.

Momčad Kubernetes aaS s Mail.ru preveo je članak o tome kako koristiti vanjske metrike za automatsko skaliranje Kubernetes aplikacije. Da bi pokazao kako sve funkcionira, autor koristi metriku HTTP zahtjeva za pristup, koja se prikuplja pomoću Prometheusa.

Umjesto horizontalnog automatskog skaliranja podova, koristi se Kubernetes Event Driven Autoscaling (KEDA), Kubernetes operator otvorenog koda. Izvorno se integrira s Horizontal Pod Autoscaler kako bi omogućio besprijekorno automatsko skaliranje (uključujući do/od nule) za radna opterećenja vođena događajima. Kod dostupan na GitHub.

Kratak pregled sustava

Automatsko skaliranje Kubernetes aplikacija s Prometheusom i KEDA-om

Dijagram prikazuje kratak opis kako sve funkcionira:

  1. Aplikacija pruža metriku brojanja HTTP pogodaka u Prometheus formatu.
  2. Prometheus je konfiguriran za prikupljanje tih metrika.
  3. Prometheus skaler u KEDA-i je konfiguriran za automatsko skaliranje aplikacije na temelju broja HTTP pogodaka.

Sada ću vam detaljno reći o svakom elementu.

KEDA i Prometej

Prometheus je skup alata za nadzor i uzbunjivanje sustava otvorenog koda, dio Cloud Native Computing Foundation. Prikuplja metrike iz različitih izvora i pohranjuje ih kao podatke vremenske serije. Za vizualizaciju podataka možete koristiti grafana ili druge alate za vizualizaciju koji rade s Kubernetes API-jem.

KEDA podržava koncept skalera - djeluje kao most između KEDA-e i vanjskog sustava. Implementacija skalera specifična je za svaki ciljni sustav i izvlači podatke iz njega. KEDA ih zatim koristi za kontrolu automatskog skaliranja.

Skaleri podržavaju više izvora podataka, na primjer, Kafka, Redis, Prometheus. To jest, KEDA se može koristiti za automatsko skaliranje Kubernetes implementacija koristeći Prometheus metriku kao kriterij.

Testna aplikacija

Testna aplikacija Golang omogućuje pristup putem HTTP-a i obavlja dvije važne funkcije:

  1. Koristi biblioteku klijenta Prometheus Go za instrumentiranje aplikacije i pruža metriku http_requests koja sadrži broj pogodaka. Krajnja točka gdje su Prometheusove metrike dostupne nalazi se na URI-ju /metrics. 
    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
  2. Kao odgovor na zahtjev GET aplikacija povećava vrijednost ključa (access_count) u Redisu. Ovo je jednostavan način da obavite posao kao dio HTTP rukovatelja i također provjerite Prometheusove metrike. Vrijednost metričke vrijednosti mora biti ista kao vrijednost access_count u Redisu. 
    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)
   }

Aplikacija se postavlja na Kubernetes putem Deployment. Izrađuje se i usluga ClusterIP, omogućuje poslužitelju Prometheus dobivanje metrike aplikacije.

ovdje je manifest implementacije za aplikaciju.

Prometheus poslužitelj

Manifest implementacije Prometheusa sastoji se od:

  • ConfigMap — za prijenos Prometheusove konfiguracije;
  • Deployment — za postavljanje Prometheusa u Kubernetes klaster;
  • ClusterIP — servis za pristup UI Prometheus;
  • ClusterRole, ClusterRoleBinding и ServiceAccount — za auto-detekciju usluga u Kubernetesu (Auto-discovery).

ovdje je manifest za pokretanje Prometeja.

KEDA Prometheus ScaledObject

Skaler djeluje kao most između KEDA-e i vanjskog sustava iz kojeg je potrebno dobiti metriku. ScaledObject je prilagođeni resurs koji se treba implementirati za sinkronizaciju implementacije s izvorom događaja, u ovom slučaju Prometheus.

ScaledObject sadrži informacije o skaliranju implementacije, metapodatke o izvoru događaja (kao što su tajne veze, naziv reda čekanja), interval prozivanja, razdoblje oporavka i druge podatke. Rezultat je odgovarajući resurs za automatsko skaliranje (HPA definicija) za skaliranje implementacije.

Kada objekt ScaledObject se briše, odgovarajuća HPA definicija se briše.

Evo definicije ScaledObject za naš primjer, koristi 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]))

Uzmite u obzir sljedeće točke:

  1. On pokazuje na Deployment S imenom go-prom-app.
  2. Vrsta okidača - Prometheus. Adresa Prometheus poslužitelja spominje se zajedno s nazivom metrike, pragom i PromQL upit, koji će se koristiti. PromQL upit - sum(rate(http_requests[2m])).
  3. Prema pollingInterval,KEDA traži metu od Prometeja svakih petnaest sekundi. Barem jedan ispod (minReplicaCount), a najveći broj mahuna ne prelazi maxReplicaCount (u ovom primjeru - deset).

Može se instalirati minReplicaCount jednaka nuli. U ovom slučaju, KEDA aktivira implementaciju od nula prema jedan i zatim izlaže HPA za daljnje automatsko skaliranje. Moguć je i obrnuti redoslijed, odnosno skaliranje od jedan do nule. U primjeru nismo odabrali nulu jer je ovo HTTP usluga, a ne sustav na zahtjev.

Čarolija unutar automatskog skaliranja

Prag se koristi kao okidač za skaliranje implementacije. U našem primjeru, PromQL upit sum(rate (http_requests [2m])) vraća agregiranu stopu HTTP zahtjeva (zahtjeva po sekundi), izmjerenu u posljednje dvije minute.

Budući da je vrijednost praga tri, to znači da će jedna biti ispod vrijednosti sum(rate (http_requests [2m])) manje od tri. Ako se vrijednost poveća, svaki put se dodaje dodatni sub sum(rate (http_requests [2m])) povećava za tri. Na primjer, ako je vrijednost od 12 do 14, tada je broj mahuna četiri.

Sada pokušajmo to postaviti!

predpodešavanje

Sve što trebate je Kubernetes klaster i konfigurirani uslužni program kubectl. Ovaj primjer koristi klaster minikube, ali možete uzeti bilo koji drugi. Za instaliranje klastera postoji rukovodstvo.

Instalirajte najnoviju verziju 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/

Postaviti kubectlza pristup Kubernetes klasteru.

Instalirajte najnoviju verziju 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

KEDA instalacija

KEDA-u možete implementirati na nekoliko načina, oni su navedeni u dokumentacija. Koristim monolitni YAML:

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

KEDA i njene komponente instalirane su u imenski prostor keda. Naredba za provjeru:

kubectl get pods -n keda

Pričekajte da se KEDA Operator pokrene i idite na Running State. I nakon toga, nastavite.

Instalacija Redisa pomoću Helma

Ako nemate instaliran Helm, koristite ovo rukovodstvo. Naredba za instalaciju na Macu:

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

helm init inicijalizira lokalno sučelje naredbenog retka i također instalira Tiller u Kubernetes klaster.

kubectl get pods -n kube-system | grep tiller

Pričekajte da upravljačka jedinica uđe u stanje rada.

Napomena prevoditelja: Autor koristi Helm@2, za koji je potrebno instalirati Tiller serversku komponentu. Sada je Helm@3 relevantan, ne zahtijeva serverski dio.

Nakon instalacije Helma dovoljna je jedna naredba za pokretanje Redisa:

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

Provjerite je li Redis uspješno pokrenut:

kubectl get pods/redis-server-master-0

Pričekajte da Redis prijeđe u stanje Running.

Implementacija aplikacije

Naredba za implementaciju:

kubectl apply -f go-app.yaml

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

Provjerite je li sve počelo:

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

Pričekajte da Redis uđe u stanje Running.

Postavljanje Prometheus poslužitelja

Manifest Prometheus koristi Otkriće usluge Kubernetes za Prometheus. Omogućuje dinamičko otkrivanje podova aplikacija na temelju oznake usluge.

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

Za implementaciju:

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

Provjerite je li sve počelo:

kubectl get pods -l=app=prometheus-server

Pričekajte da Prometheus prijeđe u stanje Running.

upotreba kubectl port-forward za pristup Prometheus korisničkom sučelju (ili API poslužitelju) na http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Uvođenje KEDA konfiguracije automatskog skaliranja

Naredba za stvaranje ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Provjerite zapise operatera KEDA:

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

Rezultat izgleda otprilike ovako:

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"

Provjerite pod aplikacijama. Jedna instanca mora biti pokrenuta jer minReplicaCount jednako 1:

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

Provjerite je li HPA resurs uspješno kreiran:

kubectl get hpa

Trebali biste vidjeti nešto poput:

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

Provjera stanja: pristup aplikaciji

Za pristup REST krajnjoj točki naše aplikacije, pokrenite:

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

Sada možete pristupiti svojoj Go aplikaciji pomoću adrese http://localhost:8080. Da biste to učinili, pokrenite naredbu:

curl http://localhost:8080/test

Rezultat izgleda otprilike ovako:

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

U ovom trenutku također provjerite Redis. Vidjet ćete da je ključ access_count povećan na 1:

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

Provjerite je li metrička vrijednost http_requests isto:

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

Stvaranje opterećenja

Koristit ćemo ej — uslužni program za generiranje opterećenja:

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

Također možete preuzeti uslužni program za Linux ili Windows.

Pokreni ga:

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

Prema zadanim postavkama, uslužni program šalje 200 zahtjeva. To možete provjeriti pomoću Prometheusove metrike kao i Redisa.

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

Provjerite vrijednost stvarne metrike (koju vraća PromQL upit):

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

U ovom slučaju stvarni rezultat je 1,686057971014493 i prikazuje se u polju value. Ovo nije dovoljno za skaliranje, budući da je prag koji smo postavili 3.

Više opterećenja!

U novom terminalu pratite broj podova aplikacija:

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

Povećajmo opterećenje pomoću naredbe: 

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

Nakon nekog vremena vidjet ćete kako HPA skalira implementaciju i pokreće nove podove. Provjerite svoj HPA kako biste bili sigurni:

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

Ako je opterećenje nedosljedno, raspoređivanje će se smanjiti do točke u kojoj radi samo jedna kapsula. Ako želite provjeriti stvarnu metriku (koju vraća PromQL upit), upotrijebite naredbu:

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

čišćenje

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

Zaključak

KEDA vam omogućuje da automatski skalirate svoje Kubernetes implementacije (na/od nule) na temelju podataka iz vanjskih metrika. Na primjer, na temelju Prometheusove metrike, duljine čekanja u Redisu, kašnjenja korisnika u Kafkinoj temi.

KEDA se integrira s vanjskim izvorom i također pruža svoje metrike putem Metrics Servera Horizontal Pod Autoscaleru.

Sretno!

Što još pročitati:

  1. Najbolji primjeri iz prakse i najbolji primjeri iz prakse za pokretanje spremnika i Kubernetesa u produkcijskim okruženjima.
  2. 90+ korisnih alata za Kubernetes: implementacija, upravljanje, nadzor, sigurnost i više.
  3. Naš kanal Oko Kubernetesa u Telegramu.

Izvor: www.habr.com

Dodajte komentar