🥇Kuongeza kiotomatiki programu za Kubernetes kwa kutumia Prometheus na KEDA

Mtu wa Puto na Cimuanos

Scalability ni hitaji muhimu kwa programu za wingu. Ukiwa na Kubernetes, kuongeza programu ni rahisi kama kuongeza idadi ya nakala za utumaji unaofaa au ReplicaSet - lakini ni mchakato wa mwongozo.

Kubernetes huruhusu programu kuongezwa kiotomatiki (yaani, Maganda katika uwekaji au ReplicaSet) kwa njia ya kutangaza kwa kutumia vipimo vya Horizontal Pod Autoscaler. Kigezo chaguo-msingi cha kuongeza kiotomatiki ni vipimo vya matumizi ya CPU (vipimo vya nyenzo), lakini unaweza kujumuisha vipimo maalum na vinavyotolewa nje.

Timu Kubernetes aaS kutoka Mail.ru ilitafsiri makala kuhusu jinsi ya kutumia vipimo vya nje kuongeza kiotomatiki programu ya Kubernetes. Ili kuonyesha jinsi kila kitu kinavyofanya kazi, mwandishi hutumia metriki za ombi la ufikiaji wa HTTP, ambazo hukusanywa kwa kutumia Prometheus.

Badala ya upakuaji otomatiki wa maganda, Kubernetes Event Driven Autoscaling (KEDA) inatumiwa, opereta wa chanzo huria wa Kubernetes. Inaunganisha asili na Horizontal Pod Autoscaler ili kutoa uboreshaji otomatiki usio na mshono (pamoja na/kutoka sifuri) kwa mizigo ya kazi inayoendeshwa na tukio. Msimbo unapatikana kwa GitHub.

Muhtasari mfupi wa mfumo

Mchoro unaonyesha maelezo mafupi ya jinsi kila kitu kinavyofanya kazi:

Programu hutoa vipimo vya hesabu vya hit ya HTTP katika umbizo la Prometheus.
Prometheus imesanidiwa ili kukusanya vipimo hivi.
Prometheus scaler katika KEDA imesanidiwa ili kuongeza kiotomatiki programu kulingana na idadi ya vibonzo vya HTTP.

Sasa nitakuambia kwa undani kuhusu kila kipengele.

KEDA na Prometheus

Prometheus ni mfumo huria wa ufuatiliaji na zana za kutahadharisha, sehemu Cloud Native Computing Foundation. Hukusanya vipimo kutoka vyanzo mbalimbali na kuvihifadhi kama data ya mfululizo wa saa. Ili kuibua data unaweza kutumia grafana au zana zingine za taswira zinazofanya kazi na Kubernetes API.

KEDA inaunga mkono dhana ya kipimo - inafanya kazi kama daraja kati ya KEDA na mfumo wa nje. Utekelezaji wa kipimo ni maalum kwa kila mfumo lengwa na hutoa data kutoka kwake. KEDA kisha inazitumia kudhibiti kuongeza kiotomatiki.

Scalers inasaidia vyanzo vingi vya data, kwa mfano, Kafka, Redis, Prometheus. Hiyo ni, KEDA inaweza kutumika kuongeza uwekaji wa Kubernetes kiotomatiki kwa kutumia metriki za Prometheus kama vigezo.

Maombi ya mtihani

Programu ya majaribio ya Golang hutoa ufikiaji kupitia HTTP na hufanya kazi mbili muhimu:

Hutumia maktaba ya mteja wa Prometheus Go ili kutayarisha programu na kutoa metriki ya http_requests, ambayo ina idadi ya watu waliopingwa. Mwisho ambapo metriki za Prometheus zinapatikana iko kwenye URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Kwa kujibu ombi GET maombi huongeza thamani ya ufunguo (access_count) katika Redis. Hii ni njia rahisi ya kufanya kazi kama sehemu ya kidhibiti cha HTTP na pia angalia metriki za Prometheus. Thamani ya kipimo lazima iwe sawa na thamani access_count katika 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)
   }

Maombi yanatumwa kwa Kubernetes kupitia Deployment. Huduma pia imeundwa ClusterIP, huruhusu seva ya Prometheus kupata vipimo vya programu.

Hapa faili ya uwasilishaji ya maombi.

Seva ya Prometheus

Dhihirisho la uwekaji la Prometheus lina:

ConfigMap - kuhamisha usanidi wa Prometheus;
Deployment - kwa kupeleka Prometheus katika nguzo ya Kubernetes;
ClusterIP - huduma ya ufikiaji wa UI Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — kwa utambuzi wa kiotomatiki wa huduma katika Kubernetes (Ugunduzi otomatiki).

Hapa dhihirisha kwa kuendesha Prometheus.

KEDA Prometheus ScaledObject

Scale hufanya kama daraja kati ya KEDA na mfumo wa nje ambao metriki zinahitajika kupatikana. ScaledObject ni rasilimali maalum ambayo inahitaji kutumwa ili kusawazisha utumaji na chanzo cha tukio, katika hali hii Prometheus.

ScaledObject ina maelezo ya uenezaji, metadata ya chanzo cha tukio (kama vile siri za muunganisho, jina la foleni), muda wa upigaji kura, kipindi cha uokoaji na data nyingine. Husababisha rasilimali inayolingana ya kupima otomatiki (ufafanuzi wa HPA) ili kuongeza utumaji.

Wakati kitu ScaledObject inafutwa, ufafanuzi wa HPA unaolingana unafutwa.

Huu hapa ufafanuzi ScaledObject kwa mfano wetu, hutumia kipimo 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]))

Zingatia mambo yafuatayo:

Anaelekeza Deployment Pamoja na jina go-prom-app.
Aina ya kichochezi - Prometheus. Anwani ya seva ya Prometheus imetajwa pamoja na jina la kipimo, kizingiti na Swali la PromQL, ambayo itatumika. Swali la PromQL - sum(rate(http_requests[2m])).
Kulingana na pollingInterval,KEDA huomba shabaha kutoka kwa Prometheus kila baada ya sekunde kumi na tano. Angalau moja chini (minReplicaCount), na idadi kubwa ya maganda hayazidi maxReplicaCount (katika mfano huu - kumi).

Inaweza kusakinisha minReplicaCount sawa na sifuri. Katika hali hii, KEDA huwasha uwekaji sifuri hadi moja na kisha kufichua HPA kwa kuongeza zaidi kiotomatiki. Agizo la nyuma pia linawezekana, ambayo ni, kuongeza kutoka kwa moja hadi sifuri. Katika mfano, hatukuchagua sifuri kwa sababu hii ni huduma ya HTTP na sio mfumo unaohitajika.

uchawi ndani ya autoscaling

Kizingiti kinatumika kama kichochezi cha kuongeza uwekaji. Katika mfano wetu, swala la PromQL sum(rate (http_requests [2m])) hurejesha kiwango cha ombi la HTTP kilichojumlishwa (maombi kwa sekunde), iliyopimwa katika dakika mbili zilizopita.

Kwa kuwa thamani ya kizingiti ni tatu, inamaanisha kutakuwa na moja chini ya wakati thamani sum(rate (http_requests [2m])) chini ya tatu. Ikiwa thamani inaongezeka, ndogo ya ziada huongezwa kila wakati sum(rate (http_requests [2m])) huongezeka kwa tatu. Kwa mfano, ikiwa thamani ni kutoka 12 hadi 14, basi idadi ya maganda ni nne.

Sasa hebu tujaribu kuisanidi!

Kuweka mapema

Unachohitaji ni nguzo ya Kubernetes na matumizi yaliyosanidiwa kubectl. Mfano huu hutumia nguzo minikube, lakini unaweza kuchukua nyingine yoyote. Kufunga nguzo kuna mwongozo.

Sakinisha toleo jipya zaidi kwenye 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/

Weka kubectlkufikia nguzo ya Kubernetes.

Sakinisha toleo jipya zaidi kwenye 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

Ufungaji wa KEDA

Unaweza kupeleka KEDA kwa njia kadhaa, zimeorodheshwa ndani nyaraka. Ninatumia YAML ya monolithic:

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

KEDA na vijenzi vyake vimewekwa kwenye nafasi ya majina keda. Amri ya kuangalia:

kubectl get pods -n keda

Subiri Opereta ya KEDA ianze na uende Running State. Na baada ya hayo, endelea.

Kufunga Redis kwa kutumia Helm

Ikiwa huna Helm iliyosakinishwa, tumia hii uongozi. Amri ya kusakinisha kwenye Mac:

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

helm init huanzisha kiolesura cha mstari wa amri ya ndani na pia kusakinisha Tiller kwa nguzo ya Kubernetes.

kubectl get pods -n kube-system | grep tiller

Subiri ganda la Tiller liingie katika hali ya Kuendesha.

Ujumbe wa mtafsiri: Mwandishi anatumia Helm@2, ambayo inahitaji kijenzi cha seva ya Tiller kusakinishwa. Sasa Helm@3 inafaa, haihitaji sehemu ya seva.

Baada ya kusanidi Helm, amri moja inatosha kuanza Redis:

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

Thibitisha kuwa Redis imeanza kwa mafanikio:

kubectl get pods/redis-server-master-0

Subiri kwa Redis kwenda katika hali Running.

Usambazaji wa Maombi

Amri ya kupeleka:

kubectl apply -f go-app.yaml

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

Angalia kuwa kila kitu kimeanza:

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

Subiri Redis iingie katika jimbo Running.

Inapeleka Seva ya Prometheus

Fahirisi ya Prometheus hutumia Ugunduzi wa Huduma ya Kubernetes kwa Prometheus. Inaruhusu ugunduzi unaobadilika wa ganda la programu kulingana na lebo ya huduma.

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

Ili kupeleka:

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

Angalia kuwa kila kitu kimeanza:

kubectl get pods -l=app=prometheus-server

Subiri Prometheus aende katika hali Running.

Tumia kubectl port-forward kufikia kiolesura cha mtumiaji cha Prometheus (au seva ya API) kwa http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Inapeleka Usanidi wa Kuongeza Kiotomatiki wa KEDA

Amri ya kuunda ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Angalia kumbukumbu za waendeshaji wa KEDA:

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

Matokeo yake yanaonekana kama hii:

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"

Angalia chini ya programu. Mfano mmoja lazima uende kwa sababu minReplicaCount sawa na 1:

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

Thibitisha kuwa rasilimali ya HPA iliundwa kwa ufanisi:

kubectl get hpa

Unapaswa kuona kitu kama:

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

Ukaguzi wa afya: ufikiaji wa maombi

Ili kufikia mwisho wa programu yetu ya REST, endesha:

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

Sasa unaweza kufikia programu yako ya Go kwa kutumia anwani http://localhost:8080. Ili kufanya hivyo, endesha amri:

curl http://localhost:8080/test

Matokeo yake yanaonekana kama hii:

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

Katika hatua hii pia angalia Redis. Utaona kwamba ufunguo access_count iliongezeka hadi 1:

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

Hakikisha thamani ya kipimo ni http_requests sawa:

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

Uundaji wa Mzigo

Tutatumia hey - matumizi ya kuzalisha mzigo:

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

Unaweza pia kupakua matumizi ya Linux au Windows.

Iendesha:

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

Kwa chaguo-msingi, matumizi hutuma maombi 200. Unaweza kuthibitisha hili kwa kutumia vipimo vya Prometheus na vile vile 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

Thibitisha thamani ya kipimo halisi (kilichorudishwa na hoja ya PromQL):

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

Katika kesi hii, matokeo halisi ni 1,686057971014493 na inaonyeshwa kwenye uwanja value. Hii haitoshi kwa kuongeza, kwani kizingiti tulichoweka ni 3.

Mzigo zaidi!

Katika terminal mpya, fuatilia idadi ya maganda ya programu:

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

Wacha tuongeze mzigo kwa kutumia amri:

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

Baada ya muda, utaona HPA ikiongeza utumaji na kuzindua maganda mapya. Angalia HPA yako ili kuhakikisha:

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

Ikiwa mzigo haufanani, uwekaji utapunguzwa hadi mahali ambapo pod moja tu inaendesha. Ikiwa unataka kuangalia metriki halisi (iliyorejeshwa na hoja ya PromQL), basi tumia amri:

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

Kusafisha

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

Hitimisho

KEDA hukuruhusu kuongeza kiotomati matumizi yako ya Kubernetes (hadi/kutoka sifuri) kulingana na data kutoka vipimo vya nje. Kwa mfano, kulingana na vipimo vya Prometheus, urefu wa foleni katika Redis, kusubiri kwa watumiaji katika mada ya Kafka.

KEDA inaunganishwa na chanzo cha nje na pia hutoa vipimo vyake kupitia Seva ya Metrics hadi Horizontal Pod Autoscaler.

Mafanikio!

Nini kingine cha kusoma:

Chanzo: mapenzi.com

Kuongeza otomatiki programu za Kubernetes kwa kutumia Prometheus na KEDA