🥇Automatsko skaliranje Kubernetes aplikacija koristeći Prometheus i KEDA

Balon Man od Cimuanosa

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

Kubernetes omogućava da se aplikacije automatski skaliraju (tj. Podovi u implementaciji ili ReplicaSet) na deklarativni način koristeći specifikaciju Horizontal Pod Autoscaler. Zadani kriterij za automatsko skaliranje je metrika korištenja CPU-a (metrika resursa), ali možete integrirati prilagođene i eksterno dostavljene metrike.

tim Kubernetes aaS sa Mail.ru preveo je članak o tome kako koristiti eksterne metrike za automatsko skaliranje Kubernetes aplikacije. Kako 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 operater otvorenog koda. Nativno se integrira sa Horizontal Pod Autoscaler kako bi omogućio besprijekorno automatsko skaliranje (uključujući od/od nule) za radna opterećenja vođena događajima. Kod dostupan na GitHub.

Kratak pregled sistema

Dijagram prikazuje kratak opis kako sve funkcionira:

Aplikacija pruža HTTP metriku broja pogodaka u Prometheus formatu.
Prometheus je konfiguriran da prikuplja ove metrike.
Prometheus skaler u KEDA-i je konfigurisan da automatski skalira aplikaciju na osnovu broja HTTP pogodaka.

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

KEDA i Prometej

Prometheus je komplet alata za praćenje i upozorenje otvorenog koda, dio Cloud Native Computing Foundation. Prikuplja metriku 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 sa Kubernetes API-jem.

KEDA podržava koncept skalera – on djeluje kao most između KEDA-e i vanjskog sistema. Implementacija skalera je specifična za svaki ciljni sistem 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 implementacije koristeći Prometheus metriku kao kriterijum.

Test aplikacija

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

Koristi klijentsku biblioteku Prometheus Go da instrumentira aplikaciju i pruži metriku http_requests, koja sadrži broj pogodaka. Krajnja tačka na kojoj su dostupne Prometheus metrike nalazi se na URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

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 provjerite Prometheus metriku. Vrijednost metrike mora biti ista kao i vrijednost access_count 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)
   }

Aplikacija se postavlja na Kubernetes putem Deployment. Takođe je kreiran servis ClusterIP, omogućava Prometheus serveru da dobije metriku aplikacije.

ovdje manifest implementacije za aplikaciju.

Prometheus Server

Manifest implementacije Prometheusa sastoji se od:

ConfigMap — za prijenos Prometheus konfiguracije;
Deployment — za postavljanje Prometheusa u Kubernetes klaster;
ClusterIP — servis za pristup korisničkom interfejsu Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — za automatsko otkrivanje usluga u Kubernetesu (Auto-otkrivanje).

ovdje manifest za pokretanje Prometeja.

KEDA Prometej ScaledObject

Skaler djeluje kao most između KEDA-e i vanjskog sistema iz kojeg se moraju dobiti metrika. ScaledObject je prilagođeni resurs koji treba da se rasporedi da bi se implementacija sinhronizovala sa izvorom događaja, u ovom slučaju Prometheus.

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

Kada objekat 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]))

Molimo uzmite u obzir sljedeće tačke:

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

Može se instalirati minReplicaCount jednaka nuli. U ovom slučaju, KEDA aktivira primenu nula prema jedan, a zatim izlaže HPA za dalje 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 sistem na zahtjev.

Magija 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 u sekundi), mjerenu u posljednje dvije minute.

Pošto je vrijednost praga tri, to znači da će biti jedan ispod dok je vrijednost 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.

Pokušajmo sada to podesiti!

unapred podešavanje

Sve što vam treba je Kubernetes klaster i konfigurisani uslužni program kubectl. Ovaj primjer koristi klaster minikube, ali možete uzeti bilo koji drugi. Za instaliranje klastera postoji vodič.

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/

Ustanovite 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 možete implementirati na nekoliko načina, oni su navedeni u dokumentaciju. Koristim monolitni YAML:

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

KEDA i njegove komponente su instalirane u imenskom prostoru keda. Naredba za provjeru:

kubectl get pods -n keda

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

Instaliranje Redis-a pomoću Helm-a

Ako nemate instaliran Helm, koristite ovo vođstvo. Naredba za instalaciju na Mac:

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

helm init inicijalizira sučelje lokalne komandne linije i također instalira Tiller u Kubernetes klaster.

kubectl get pods -n kube-system | grep tiller

Pričekajte da Tiller pod uđe u stanje Running.

Napomena prevodioca: Autor koristi Helm@2, koji zahtijeva instaliranje Tiller serverske komponente. Sada je Helm@3 relevantan, ne zahtijeva serverski dio.

Nakon instaliranja Helm-a, jedna naredba je dovoljna za pokretanje Redis-a:

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

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

Primena aplikacije

Komanda raspoređivanja:

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

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

Postavljanje Prometheus servera

Prometejev manifest koristi Kubernetes Service Discovery za Prometheus. Omogućava dinamičko otkrivanje modula aplikacije na osnovu 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

Sačekajte da Prometej pređe u stanje Running.

Koristite kubectl port-forward za pristup Prometheus korisničkom interfejsu (ili API serveru) na http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Postavljanje KEDA Autoscaling konfiguracije

Naredba za kreiranje ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Provjerite dnevnike 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 zdravlja: pristup aplikaciji

Da pristupite REST krajnjoj tački naše aplikacije, pokrenite:

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

Sada možete pristupiti svojoj Go aplikaciji koristeći adresu 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ćano 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

Kreiranje učitavanja

Koristić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:

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

Po defaultu, uslužni program šalje 200 zahtjeva. Ovo možete provjeriti koristeći Prometheus metriku kao i 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

Potvrdite vrijednost stvarne metrike (koju je vratio 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, jer 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, implementacija će se smanjiti do točke u kojoj radi samo jedna pod. Ako želite provjeriti stvarnu metriku (koju je vratio PromQL upit), tada koristite 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ćava da automatski skalirate svoje Kubernetes implementacije (na/od nule) na osnovu podataka iz eksternih metrika. Na primjer, na osnovu Prometheus metrike, dužine reda u Redis-u, kašnjenja potrošača u Kafka temi.

KEDA se integriše sa eksternim izvorom i takođe obezbeđuje svoje metrike preko Metrics Servera do Horizontal Pod Autoscaler.

Sretno!

Šta još pročitati:

izvor: www.habr.com

Automatsko skaliranje Kubernetes aplikacija koristeći Prometheus i KEDA