🥇Autoscaling Kubernetes applicationes utens Prometheo et KEDA

Balloon homo per Cimuanos

Scalability clavis postulatur ad applicationes nubeculas. Cum Kubernetes, applicatio scalarum tam simplex est quam numerum replicationum augens ad aptam instruere vel ReplicaSet — sed processus manualis est.

Kubernetes applicationes admittit ut sponte scalis (i.e. leguminis in instruere vel ReplicaSet) modo declarativo utens specificatione Pod Horizontalis Autoscaler. Criterium defalta latae scalae CPU usus metrics (resource metrics), sed consuetudinem integrare potes et metris extrinsecus instructis.

bigas Kubernetes aaS ex Mail.ru articulus interpretatus est quomodo metris externis utendi ad applicationem Kubernetes automatice conscenderet. Ut ostenderet quomodo omnia opera, auctor accessum HTTP postulationis metricae adhibet, quae Prometheo utens collecta sunt.

Loco horizontalis autoscaling siliquarum, Eventus Kubernetes Autoscaling (KEDA) adhibitus, fons aperta Kubernetes operator. Integrum nativo cum Pod Autoscaler Horizontali integrationem autoscaling (inclusa / ex nihilo) in laboribus eventis agitatae praebet. Code available at GitHub.

Brevis contemplationis ratio operandi

Tabula breviter ostendit quomodo omnia opera sint;

Applicatio HTTP hit narrationem metricam in forma Promethei praebet.
Horum metrorum colligere Prometheus configuratur.
Prometheus scaber in KEDA configuratur ut statim applicationes ascendat secundum numerum HTTP hittorum.

Nunc de singulis elementis singillatim dicam.

KEDA et Prometheus

Prometheus fons aperta est ratio vigilantia et toolkit vigilantia, pars Arx nubes Computing Foundation. Collectae metricae ex variis auctoribus et pro temporis serie notatae easque recondit. Ad visualize notitia vos can utor grafana vel alia instrumenta visualizationis quae apud Kubernetes API laborant.

KEDA notionem scalaris sustinet - ut pons inter KEDA et systema externum agit. Exsecutio scalaris est specifica unicuique systematis scopo et ex eo notitia extracta. KEDA illis utitur ad scalas latis moderandas.

Scalers multiplex notitia fontes sustinent, exempli gratia, Kafka, Redis, Prometheus. Hoc est, KEDA ad automatice conscendere posse Kubernetes Prometheus metrice utendi criteriis utens instruere.

Test application

Golang experimentum applicationis aditum per HTTP praebet et duo munera magni momenti facit:

Prometheus Ite clientelam bibliothecam utitur ad applicationem instrumentorum et praebendas http_requestas metricas, quae hit narrationem continet. Finis ubi Prometheus metrice in promptu est, sita est in URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

In responsio ad petitionem GET per applicationem incrementa valorem clavis (access_count) in Redis. Haec facilis via est ad faciendum opus ut partem HTTP tracto et etiam Promethei metricam reprehendo. Valor metricus idem esse debet ac valor access_count in 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)
   }

Ad Kubernetes via . applicatio explicatur Deployment. Ministerium etiam creatus est ClusterIPtur, permittit Prometheum servo applicationis metricos impetrare.

hic deployment manifestum application.

Prometheus Servus

Manifestus Prometheus instruere constat;

ConfigMap — Prometheum transferre config;
Deployment — Prometheum in Kubernetes botro disponi;
ClusterIP - accessus ad Prometheum UI;
ClusterRole, ClusterRoleBinding и ServiceAccount — pro auto- detectione officiorum in Kubernetes (Auto-inventio).

hic patet ad currit Prometheus.

KEDA Prometheus ScaledObject

Scala fungitur pontis inter KEDA et systema externum unde metri opus obtinendum est. ScaledObject est consuetudo subsidii quae explicanda est ut instruere possit cum eventu fonte, in hoc casu Prometheus.

ScaledObject continet instruere scalas informationes, eventus fontem metadatam (ut connexionem secretorum, queue nomen), saeptum intervallum, tempus recuperationis et alia notitia. Provenit in respondente resource autoscaling (HPA definitione) ut instruere instruere.

Cum aliquid ScaledObject deleta est, debita HPA definitio explicatur.

Hic est definitio ScaledObject pro exemplo nostro utitur scaber 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]))

Vide sequentia puncta:

Ostendit to Deployment Cum nomine go-prom-app.
Genus felis - Prometheus. Inscriptio Promethei commemoratur una cum metrico nomine limen and PromQL quaesitumqui utendum erit. PromQL Query - sum(rate(http_requests[2m])).
secundum pollingIntervalKEDA signum a Prometheo singulis secundis quindecim petit. Saltem unus sub (minReplicaCount) et siliquarum numerus maximus non excedit maxReplicaCount (in this example - decem).

Potest installed minReplicaCount nulla eft. Hoc in casu, KEDA nulla ad unam instruere operatur ac deinde HPA patefacit ad scalas ulteriores latae. Potest etiam ordo contrarius, hoc est, scalis ab uno in nihilum. In exemplo, non nulla nulla delectus, quia HTTP est opera et ratio non postulatio.

Magia intus autoscaling

Limen dictum ut felis eu nibh. In nostro exemplo PromQL quaesitum est sum(rate (http_requests [2m])) redit aggregatum HTTP postulationis rate (per secunda petitiones), in duobus ultimis minutis mensus.

Cum limen valorem tres sit, significat unum esse sub valore sum(rate (http_requests [2m])) minus tribus. Si valor augetur, adiectis sub singulis additur temporibus sum(rate (http_requests [2m])) addit per tres. Exempli gratia, si valor est ab 12 ad 14, tum siliquarum numerus est quatuor.

Nunc conemur statuere!

Pre-occasum

Omnes opus est botrus Kubernetes et utilitas configurata kubectl. Hoc exemplum botri utitur minikubesed aliquam aliam potes accipere. Ut install botri est ducis.

Install versio novissima in 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/

install kubectlaccedere ad botrum Kubernetes.

Install versio novissima in 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 installation

Pluribus modis KEDA explicari potes, recensentur in documentum. Im 'usura monolithic YAML:

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

KEDA et eius partes in spatio nominali installantur keda. Mandatum sisto:

kubectl get pods -n keda

Exspecta KEDA Operans incipere et ire Running State. Et post hoc permane.

Redis installing per Helm

Si galeam non habes installed, hoc utere ducibus. Impera ut install Mac:

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

helm init initializes the order local order line interface et etiam installs " Tiller ad Kubernetes botrus.

kubectl get pods -n kube-system | grep tiller

Exspecta agricola vasculum ad Cursor status ingredi.

Interpres note: Auctor Helm@2 utitur, quod componente servo Tillerario instituendum requirit. Nunc Helm@3 pertinet, partem serverni non requirit.

Post Helm insertis unum mandatum Redis incipere satis est;

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

Cognoscere quod Redis incepit feliciter:

kubectl get pods/redis-server-master-0

Exspecta Redis ut iret in civitate Running.

Applicationem instruere

Mandatum instruere:

kubectl apply -f go-app.yaml

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

Reprehendo omnia quae incepit:

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

Exspecta Redis intrare civitatis Running.

A Prometheo Servo disponis

Prometheus manifestus usus Kubernetes Service Inventionis pro Prometheo. Sinit dynamicam inventionem siliquae applicationis fundatae in pittacio ministerio.

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

Explicare:

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

Reprehendo omnia quae incepit:

kubectl get pods -l=app=prometheus-server

Exspecta Prometheum ut iret in statum Running.

usus kubectl port-forward to access the Prometheus user interface (sive API server) at http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Explicas KEDA Autoscaling configurationis

Imperium creare ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Reprehendo omnia operator KEDA:

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

Eventus aliquid simile hoc spectat:

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"

Sisto sub applicationibus. Una instantia debet esse currens, quia minReplicaCount pares I;

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

Cognoscere quod resource HPA creatum est feliciter:

kubectl get hpa

Videres aliquid simile;

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

Salutem reprehendo: application access

Ut accedere ad applicationem nostrae quietis terminus, currite:

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

Nunc potes accedere tuum Ite app utens inscriptione http://localhost:8080. Ad hoc currite imperium;

curl http://localhost:8080/test

Eventus aliquid simile hoc spectat:

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

Hie quoque Redis reprehendo. Videbis clavem access_count auctus ad I;

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

Fac valorem metricum est http_requests ipse:

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

Onus creationis

Nos utemur Gloria - utilitate generandi onus;

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

Potes etiam download utilitatem pro Linux aut Fenestra.

Curre eam;

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

Defalta petit utilitas CC. Verificare potes hunc usum metrice Promethei necnon 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

Valorem rei metricae convalidandum (per interrogationem PromQL redditum):

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

In hoc casu ipse effectus est 1,686057971014493 et ostenditur in agro value. Hoc non satis est ad scalas, cum in limine 3 posuimus.

Plus oneris!

In novo termino, monitor siliquae applicationis numerum;

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

Augeamus onus utendo imperio;

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

Post aliquantum, videbis HPA instruere scalas et novas siliquas immittere. HPA reprehendo tuum fac:

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

Si onus repugnet, institutio reducetur ad punctum ubi unum tantum vasculum currit. Si ipsam metricam inspicere vis (per interrogationem PromQL redditam), tunc utere imperio;

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

dictum

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

conclusio,

KEDA permittit te ut sponte tua Kubernetes instruere (ad/a nulla) fundata in notitia metri externae permittat. Exempli gratia, ex metrica Promethei, queue longitudo in Redis, dolor latency in Kafka topic.

KEDA cum externo fonte integrat et etiam metrica sua praebet per Metrics Servo ad Pod Horizontalem Autoscaler.

Fortuna!

Quid est aliud legere;

Source: www.habr.com

Autoscaling Kubernetes applicationes utentes Prometheo et KEDA