🥇Autoskalning av Kubernetes-applikationer med Prometheus och KEDA

Balloon Man av Cimuanos

Skalbarhet är ett centralt krav för molnapplikationer. Med Kubernetes är det lika enkelt att skala upp en applikation som att öka antalet repliker för en specifik distribution eller ReplicaSet — men det är en manuell process.

Kubernetes gör det möjligt att automatiskt skala applikationer (det vill säga Pod i distribution eller ReplicaSet) på ett deklarativt sätt med hjälp av specifikationen för Horizontal Pod Autoscaler. Som standard är kriteriet för automatisk skalning resursanvändningens CPU-metrik (resursmetrik), men det går att integrera anpassade metrikvärden och metrikvärden som tillhandahålls extern.

Team Kubernetes aaS från Mail.ru översatte en artikel om hur man använder externa metrier för automatisk skalning av Kubernetes-applikationer. För att visa hur allt fungerar använder författaren metrikvärden för HTTP-åtkomst, som samlas in med hjälp av Prometheus.

Istället för horisontell automatisk skalning av poddar används Kubernetes Event Driven Autoscaling (KEDA) — en öppen källkodskontrollant för Kubernetes. Den är ursprungligen integrerad med Horizontal Pod Autoscaler för att säkerställa smidig automatisk skalning (inklusive till/från noll) för händelsedrivna arbetsbelastningar. Koden finns tillgänglig på GitHub.

En kort översikt av systemets arbete

Diagrammet visar en kort beskrivning av hur allt fungerar:

Applikationen tillhandahåller metrik för antal HTTP-förfrågningar i Prometheus-format.
Prometheus är konfigurerat för att samla in dessa mätvärden.
Prometheus-skalan i KEDA är inställd på att automatiskt skala applikationen baserat på antalet HTTP-förfrågningar.

Nu kommer jag att gå in mer i detalj om varje element.

KEDA och Prometheus

Prometheus är en uppsättning verktyg för övervakning och varning av system med öppen källkod, en del av Cloud Native Computing Foundation. Samlar in mätvärden från olika källor och lagrar dem i form av tidsserie-data. För att visualisera data kan man använda Grafana eller andra visualiseringsverktyg som arbetar med Kubernetes API.

KEDA stöder konceptet av en skalar — den fungerar som en bro mellan KEDA och ett externt system. Implementeringen av skalaren är specifik för varje målsystem och hämtar data från det. Därefter använder KEDA dessa data för att hantera automatisk skalning.

Skalare stöder flera datakällor, som Kafka, Redis, Prometheus. Det innebär att KEDA kan användas för automatisk skalning av Kubernetes-distributioner, med Prometheus-metrik som kriterier.

Testapplikation

Det testbaserade Golang-applikationen erbjuder åtkomst via HTTP och utför två viktiga funktioner:

Använder klientbiblioteket Prometheus Go för att instrumentera applikationen och erbjuda metrik http_requests, som innehåller en räknare för anrop. Den slutpunkt där Prometheus-metrik är tillgänglig finns på URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "antal http-anrop",
   })
```

Som svar på förfrågan GET applikationen ökar värdet av nyckeln (access_count) i Redis. Detta är ett enkelt sätt att utföra jobbet som en del av HTTP-hanteraren, samt kontrollera Prometheus-metriken. Värdet av metrik ska vara samma som värdet access_count i 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("Kunde inte öka redis-räknaren", err)
               os.Exit(1)
           }
           resp := "Åtkomstdatum " + time.Now().String() + "nÅtkomstantal " + strconv.Itoa(int(count))
           w.Write([]byte(resp))
       })
       http.ListenAndServe(":8080", nil)
   }

Applikationen distribueras i Kubernetes genom Deployment. En tjänst skapas också ClusterIP, som möjliggör för Prometheus-servern att ta emot applikationsmetrik.

Här är distributionsmanifestet för applikationen.

Prometheus-server

Distributionsmanifestet för Prometheus består av:

ConfigMap — för att överföra Prometheus-konfigurationen;
Deployment — för att distribuera Prometheus i Kubernetes-klustret;
ClusterIP — en tjänst för att få åtkomst till Prometheus UI;
ClusterRole, ClusterRoleBinding och ServiceAccount — för att möjliggöra automatisk upptäckte av tjänster i Kubernetes (Auto-discovery).

Här är manifestet för att köra Prometheus.

KEDA Prometheus ScaledObject

Skalaren fungerar som en bro mellan KEDA och det externa systemet där metrik behöver samlas in. ScaledObject — en konfigurerbar resurs, som måste distribueras för att synkronisera distributionen med händelsekällan, i detta fall Prometheus.

ScaledObject innehåller information om att skala distributionen, metadata om händelsekällan (till exempel hemligheter för anslutning, namn på kön), intervall för avkall, återställningsperiod och annan data. Det leder till den relevanta resursen för automatisk skalning (HPA-definition) för att skala distributionen.

När objektet ScaledObject raderas, den motsvarande HPA-definitionen rensas.

Här är en definition ScaledObject för vårt exempel, där en skalerare används 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]))

Tänk på följande punkter:

Den pekar på Deployment med namnet go-prom-app.
Typ av trigger är Prometheus. Serveradress för Prometheus nämns tillsammans med metriknamnet, tröskelvärdet och PromQL-frågan, som kommer att användas. PromQL-frågan är sum(rate(http_requests[2m])).
Enligt pollingInterval, KEDA frågar målet hos Prometheus var femtonde sekund. Det stöds minst en podd (minReplicaCount), och det maximala antalet poddar överstiger inte maxReplicaCount i detta exempel - tio.

Du kan ställa in minReplicaCount till noll. I det här fallet aktiverar KEDA distributionen från noll till en och ger sedan HPA för vidare automatisk skalning. Omvänd ordning är även möjlig, det vill säga scaling från en till noll. I exemplet har vi inte valt noll, eftersom detta är en HTTP-tjänst och inte en systembegäran.

Magin bakom autoskalning

Tröskelvärdet används som en trigger för att skala distributionen. I vårt exempel ger PromQL-frågan sum(rate (http_requests [2m])) ett aggregerat värde för hastigheten på HTTP-förfrågningar (antal förfrågningar per sekund), vilket mäts under de senaste två minuterna.

Eftersom tröskelvärdet är tre kommer det att finnas en podd så länge värdet sum(rate (http_requests [2m])) är mindre än tre. Om värdet istället ökar, läggs en ytterligare podd till varje gång sum(rate (http_requests [2m])) det ökar med tre. Till exempel, om värdet går från 12 till 14, kommer antalet poddar vara fyra.

Nu låt oss försöka konfigurera!

Förinställning

Allt du behöver är en Kubernetes-kluster och ett konfigurerat verktyg kubectl. I detta exempel används klustret minikube, men du kan använda något annat. För installation av klustret finns det en guide.

Installera den senaste versionen på 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/

Installera kubectl, för att få tillgång till Kubernetes-klustret.

Installera den senaste versionen på 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

Installation av KEDA

Du kan distribuera KEDA på flera sätt, som listas i dokumentationen. Jag använder en monolitisk YAML:

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

KEDA och dess komponenter installeras i namnutrymmet keda. Kommandot för att kontrollera:

kubectl get pods -n keda

Vänta tills KEDA Operator-podden startar — går över till Running State. Och fortsätt sedan.

Installation av Redis med Helm

Om du inte har Helm installerat, använd den här guiden. Kommandot för installation på Mac:

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

helm init initialiserar det lokala kommandogränssnittet och installerar Tiller i Kubernetes-klustret.

kubectl get pods -n kube-system | grep tiller

Vänta tills Tiller-podden går till status Running.

Översättarens kommentar: Författaren använder Helm@2, vilket kräver installation av serverkomponenten Tiller. Just nu är Helm@3 aktuellt, för den behövs ingen serverdel.

Efter installationen av Helm behövs endast ett kommando för att starta Redis:

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

Kontrollera att Redis har startat framgångsrikt:

kubectl get pods/redis-server-master-0

Vänta tills Redis-podden går till status Running.

Distribution av applikation

Kommandot för distribution:

kubectl apply -f go-app.yaml

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

Kontrollera att allt har startat:

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

Vänta tills Redis går till status Running.

Distribution av Prometheus-servern

Manifestet för Prometheus använder Kubernetes Service Discovery för Prometheus. Den gör det möjligt att dynamiskt upptäcka applikationspoddar baserat på tjänstetiketten.

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

För distribution:

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

Kontrollera att allt har startat:

kubectl get pods -l=app=prometheus-server

Vänta tills Prometheus-podden går till status Running.

Använd kubectl port-forward för att få åtkomst till användargränssnittet för Prometheus (eller API-servern) på adressen http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Distribution av KEDA:s automatiska skalningskonfiguration

Kommandot för att skapa ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Kontrollera KEDA-operatorns loggar:

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

Resultatet ser ut ungefär så här:

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"

Kontrollera appens poddar. Det bör finnas en instans som är igång, eftersom minReplicaCount lika med 1:

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

Kontrollera att HPA-resursen har skapats framgångsrikt:

kubectl get hpa

Du bör se något som liknar:

NAMN                   REFERENS                MÅL     MINPADS   MAXPADS   REPLIKER   ÅLDER
keda-hpa-go-prom-app   Deployment/go-prom-app   0/3 (genomsnitt)   1         10        1          45s

Kontroll av funktionalitet: tillgång till applikationen

För att få åtkomst till REST-endpointen för vår applikation, kör:

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

Nu kan du få åtkomst till Go-applikationen via adressen http://localhost:8080. För detta, kör kommandot:

curl http://localhost:8080/test

Resultatet ser ut ungefär så här:

Åtkommet den 2019-10-21 11:29:10.560385986 +0000 UTC 
m=+406004.817901246
Åtkomstantal 1

Vid detta steg bör du också kontrollera Redis. Du kommer att se att nyckeln access_count ökat till 1:

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

Se till att metrisvärdet http_requests är detsamma:

curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests antal http-förfrågningar
# TYPE http_requests counter
http_requests 1

Skapa belastning

Vi kommer att använda hey — ett verktyg för att generera belastning:

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

Du kan också ladda ner verktyget för Linux eller Windows.

Kör det:

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

Som standard skickar verktyget 200 förfrågningar. Du kan kontrollera detta med hjälp av Prometheus-metrik samt Redis.

curl http://localhost:8080/metrics | grep http_requests
//output
# HELP http_requests antal http-förfrågningar
# TYPE http_requests counter
http_requests 201
kubectl exec -it redis-server-master-0 -- redis-cli get access_count
//output
201

Bekräfta det faktiska metrisvärdet (returnerat av PromQL-förfrågan):

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

I det här fallet är det faktiska resultatet 1,686057971014493 och visas i fältet value. Detta är inte tillräckligt för att skala, eftersom den tröskel vi har ställt in är 3.

Mer belastning!

I ett nytt terminalfönster, håll koll på antalet poddar för applikationen:

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

Låt oss öka belastningen med kommandot:

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

Efter en tid kommer du att se att HPA skalar distributionen och startar nya poddar. Kontrollera HPA för att bekräfta detta:

kubectl get hpa
NAMN                   REFERENS                MÅL         MINPODS   MAXPODS   REPLIKER   ÅLDER
keda-hpa-go-prom-app   Distribution/go-prom-app   1830m/3 (genomsnitt)   1         10        6          4m22s

Om belastningen är variabel minskar distributionen till en punkt där endast en podd körs. Om du vill kontrollera den faktiska metrik (som returneras av PromQL-förfrågan) använd kommandot:

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

Rensa

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

Slutsats

KEDA möjliggör automatisk skalning av dina Kubernetes-distributioner (till/från noll) baserat på data från externa metrik. Till exempel baserat på Prometheus-metrik, kölängd i Redis, eller förseningar för konsumenten i Kafka-ämnet.

KEDA utför integration med en extern källa och tillhandahåller även dess metrik via Metrics Server för Horizontal Pod Autoscaler.

Lycka till!

Vad mer att läsa:

Källa: habr.com