ProHoster > Blog > administrasie > Outoskaal van Kubernetes-toepassings met Prometheus en KEDA

Outoskaal van Kubernetes-toepassings met Prometheus en KEDA

Outoskaal van Kubernetes-toepassings met Prometheus en KEDABalloon Man deur Cimuanos

Skaalbaarheid is 'n sleutelvereiste vir wolktoepassings. Met Kubernetes is die skaal van 'n toepassing so eenvoudig soos om die aantal replikas vir die toepaslike ontplooiing of ReplicaSet - maar dit is 'n handmatige proses.

Kubernetes laat toepassings toe om outomaties geskaal te word (d.w.s. Peule in 'n ontplooiing of ReplicaSet) op 'n verklarende wyse deur die Horizontal Pod Autoscaler-spesifikasie te gebruik. Die verstekkriterium vir outomatiese skaal is SVE-gebruikmaatstawwe (hulpbronmaatstawwe), maar jy kan pasgemaakte en ekstern verskafde maatstawwe integreer.

Span Kubernetes aaS van Mail.ru het 'n artikel vertaal oor hoe om eksterne maatstawwe te gebruik om 'n Kubernetes-toepassing outomaties te skaal. Om te wys hoe alles werk, gebruik die skrywer HTTP-toegangversoek-metrieke, wat met Prometheus ingesamel word.

In plaas van horisontale outoskaling van peule, word Kubernetes Event Driven Autoscaling (KEDA) gebruik, 'n oopbron Kubernetes-operateur. Dit integreer inheems met Horizontal Pod Autoscaler om naatlose outoskaling (insluitend na/van nul) vir gebeurtenisgedrewe werkladings te verskaf. Kode beskikbaar by GitHub.

Kort oorsig van die stelsel

Outoskaal van Kubernetes-toepassings met Prometheus en KEDA

Die diagram toon 'n kort beskrywing van hoe alles werk:

  1. Die toepassing bied HTTP-treffertelling-metrieke in Prometheus-formaat.
  2. Prometheus is opgestel om hierdie maatstawwe in te samel.
  3. Die Prometheus-skaaler in KEDA is gekonfigureer om die toepassing outomaties te skaal op grond van die aantal HTTP-treffers.

Nou sal ek jou in detail oor elke element vertel.

KEDA en Prometheus

Prometheus is 'n oopbron stelsel monitering en waarskuwing toolkit, deel Cloud Native Computing Foundation. Versamel statistieke uit verskeie bronne en stoor dit as tydreeksdata. Om data te visualiseer wat jy kan gebruik grafana of ander visualiseringsnutsgoed wat met die Kubernetes API werk.

KEDA ondersteun die konsep van 'n scaler - dit dien as 'n brug tussen KEDA en die eksterne stelsel. Die skaalimplementering is spesifiek vir elke teikenstelsel en onttrek data daaruit. KEDA gebruik hulle dan om outomatiese skaal te beheer.

Skalers ondersteun verskeie databronne, byvoorbeeld Kafka, Redis, Prometheus. Dit wil sê, KEDA kan gebruik word om Kubernetes-ontplooiings outomaties te skaal deur Prometheus-metrieke as kriteria te gebruik.

Toets aansoek

Die Golang-toetstoepassing bied toegang via HTTP en voer twee belangrike funksies uit:

  1. Gebruik die Prometheus Go-kliëntbiblioteek om die toepassing te instrumenteer en die http_requests-metriek te verskaf, wat 'n treftelling bevat. Die eindpunt waar Prometheus-metrieke beskikbaar is, is by die URI geleë /metrics. 
    var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
  2. In reaksie op 'n versoek GET die toepassing verhoog die waarde van die sleutel (access_count) in Redis. Dit is 'n maklike manier om die werk as deel van 'n HTTP-hanteerder te doen en ook Prometheus-statistieke na te gaan. Die metrieke waarde moet dieselfde as die waarde wees 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)
   }

Die toepassing word na Kubernetes ontplooi via Deployment. 'n Diens word ook geskep ClusterIP, dit laat die Prometheus-bediener toe om toepassingsstatistieke te verkry.

Hier ontplooiingsmanifes vir die toepassing.

Prometheus-bediener

Die Prometheus-ontplooiingsmanifes bestaan ​​uit:

  • ConfigMap — om die Prometheus-konfigurasie oor te dra;
  • Deployment - vir die ontplooiing van Prometheus in 'n Kubernetes-kluster;
  • ClusterIP — diens vir toegang tot UI Prometheus;
  • ClusterRole, ClusterRoleBinding и ServiceAccount - vir outo-opsporing van dienste in Kubernetes (outo-ontdekking).

Hier manifes vir die bestuur van Prometheus.

KEDA Prometheus ScaledObject

Die skaaler dien as 'n brug tussen KEDA en die eksterne stelsel waaruit metrieke verkry moet word. ScaledObject is 'n pasgemaakte hulpbron wat ontplooi moet word om die ontplooiing met die gebeurtenisbron, in hierdie geval Prometheus, te sinchroniseer.

ScaledObject bevat ontplooiingskaalinligting, gebeurtenisbronmetadata (soos verbindingsgeheime, tounaam), steminterval, herstelperiode en ander data. Dit lei tot die ooreenstemmende outoskaalhulpbron (HPA-definisie) om die ontplooiing te skaal.

Wanneer 'n voorwerp ScaledObject geskrap word, word die ooreenstemmende HPA-definisie uitgevee.

Hier is die definisie ScaledObject vir ons voorbeeld, dit gebruik 'n scaler 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]))

Oorweeg asseblief die volgende punte:

  1. Hy wys na Deployment Met naam go-prom-app.
  2. Sneller tipe - Prometheus. Die Prometheus-bedieneradres word saam met die metrieke naam, drempel en PromQL-navraag, wat gebruik sal word. PromQL-navraag - sum(rate(http_requests[2m])).
  3. Volgens pollingInterval,KEDA versoek elke vyftien sekondes 'n teiken van Prometheus. Ten minste een onder (minReplicaCount), en die maksimum aantal peule oorskry nie maxReplicaCount (in hierdie voorbeeld - tien).

Kan geïnstalleer word minReplicaCount gelyk aan nul. In hierdie geval aktiveer KEDA die nul-tot-een-ontplooiing en stel dan die HPA bloot vir verdere outomatiese skaal. Die omgekeerde volgorde is ook moontlik, dit wil sê, skaal van een tot nul. In die voorbeeld het ons nie nul gekies nie, want dit is 'n HTTP-diens en nie 'n op-aanvraag-stelsel nie.

Die magie binne-outoskaal

Die drempel word gebruik as 'n sneller om die ontplooiing te skaal. In ons voorbeeld, die PromQL-navraag sum(rate (http_requests [2m])) gee die saamgestelde HTTP-versoekkoers (versoeke per sekonde), gemeet oor die laaste twee minute.

Aangesien die drempelwaarde drie is, beteken dit dat daar een onder sal wees terwyl die waarde sum(rate (http_requests [2m])) minder as drie. As die waarde toeneem, word 'n bykomende sub elke keer bygevoeg sum(rate (http_requests [2m])) verhoog met drie. Byvoorbeeld, as die waarde van 12 tot 14 is, dan is die aantal peule vier.

Kom ons probeer dit nou opstel!

voorafinstelling

Al wat jy nodig het, is 'n Kubernetes-kluster en 'n gekonfigureerde hulpprogram kubectl. Hierdie voorbeeld gebruik 'n cluster minikube, maar jy kan enige ander een neem. Om 'n cluster te installeer is daar leierskap.

Installeer die nuutste weergawe op 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/

Installeer kubectlom toegang tot die Kubernetes-kluster te kry.

Installeer die nuutste weergawe op 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 installasie

U kan KEDA op verskeie maniere ontplooi, hulle is gelys in dokumentasie. Ek gebruik monolitiese YAML:

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

KEDA en sy komponente word in die naamruimte geïnstalleer keda. Opdrag om na te gaan:

kubectl get pods -n keda

Wag vir KEDA Operator om te begin en na te gaan Running State. En daarna, gaan voort.

Installeer Redis met Helm

As jy nie Helm geïnstalleer het nie, gebruik dit leierskap. Opdrag om op Mac te installeer:

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

helm init inisialiseer die plaaslike opdragreëlkoppelvlak en installeer ook Tiller na die Kubernetes-kluster.

kubectl get pods -n kube-system | grep tiller

Wag vir die Tiller-peul om die Running-toestand te betree.

Vertaler se nota: Die skrywer gebruik Helm@2, wat vereis dat die Tiller-bedienerkomponent geïnstalleer moet word. Nou is Helm@3 relevant, dit benodig nie 'n bedieneronderdeel nie.

Nadat u Helm geïnstalleer het, is een opdrag genoeg om Redis te begin:

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

Verifieer dat Redis suksesvol begin het:

kubectl get pods/redis-server-master-0

Wag vir Redis om in staat te gaan Running.

Toepassing ontplooiing

Ontplooiingsopdrag:

kubectl apply -f go-app.yaml

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

Maak seker dat alles begin het:

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

Wag vir Redis om die staat te betree Running.

Ontplooi 'n Prometheus-bediener

Die Prometheus-manifes gebruik Kubernetes Service Discovery vir Prometheus. Dit laat dinamiese ontdekking van toepassings-peule toe gebaseer op die diensetiket.

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

Om te ontplooi:

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

Maak seker dat alles begin het:

kubectl get pods -l=app=prometheus-server

Wag vir Prometheus om in staat te gaan Running.

Gebruik kubectl port-forward om toegang te verkry tot die Prometheus-gebruikerskoppelvlak (of API-bediener) by http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Ontplooi KEDA Outoskaal-konfigurasie

Opdrag om te skep ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Gaan die KEDA operateur logs na:

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

Die resultaat lyk iets soos volg:

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"

Kyk onder toepassings. Een geval moet loop omdat minReplicaCount gelyk aan 1:

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

Verifieer dat die HPA-hulpbron suksesvol geskep is:

kubectl get hpa

Jy behoort iets te sien soos:

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

Gesondheidsondersoek: Toegang tot toepassing

Om toegang tot ons toepassing se REST-eindpunt te kry, hardloop:

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

Jy kan nou toegang tot jou Go-toepassing gebruik deur die adres te gebruik http://localhost:8080. Om dit te doen, voer die opdrag uit:

curl http://localhost:8080/test

Die resultaat lyk iets soos volg:

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

Kontroleer op hierdie punt ook Redis. Jy sal sien dat die sleutel access_count verhoog tot 1:

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

Maak seker die metrieke waarde is http_requests dieselfde:

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

Ladingskepping

Ons sal gebruik hey - nut vir die opwekking van vrag:

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

Jy kan ook die nut aflaai vir Linux of Windows.

Hardloop dit:

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

By verstek stuur die hulpprogram 200 versoeke. U kan dit verifieer met behulp van Prometheus-statistieke sowel as 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

Bevestig die waarde van die werklike metriek (teruggestuur deur die PromQL-navraag):

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 hierdie geval is die werklike resultaat 1,686057971014493 en word in die veld vertoon value. Dit is nie genoeg vir skaal nie, aangesien die drempel wat ons stel 3 is.

Meer vrag!

In die nuwe terminaal, monitor die aantal toepassingpeule:

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

Kom ons verhoog die vrag deur die opdrag: 

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

Na 'n rukkie sal jy sien hoe HPA die ontplooiing skaal en nuwe peule begin. Gaan jou HPA na om seker te maak:

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

As die vrag inkonsekwent is, sal die ontplooiing verminder word tot die punt waar slegs een peul loop. As jy die werklike metrieke wil nagaan (teruggestuur deur die PromQL-navraag), gebruik dan die opdrag:

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

skoonmaak

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

Gevolgtrekking

KEDA laat jou toe om jou Kubernetes-ontplooiings outomaties te skaal (na/van nul) gebaseer op data van eksterne maatstawwe. Byvoorbeeld, gebaseer op Prometheus-metrieke, toulengte in Redis, verbruikersvertraging in Kafka-onderwerp.

KEDA integreer met 'n eksterne bron en verskaf ook sy statistieke deur Metrics Server na Horizontal Pod Autoscaler.

Good Luck!

Wat anders om te lees:

  1. Beste praktyke en beste praktyke vir die bestuur van houers en Kubernetes in produksie-omgewings.
  2. 90+ Nuttige nutsmiddels vir Kubernetes: ontplooiing, bestuur, monitering, sekuriteit en meer.
  3. Ons kanaal Around Kubernetes in Telegram.

Bron: will.com

Voeg 'n opmerking