🥇Prometheus ve KEDA kullanarak Kubernetes uygulamalarını otomatik ölçeklendirme

Cimuanos'tan Balon Adam

Ölçeklenebilirlik, bulut uygulamaları için temel bir gereksinimdir. Kubernetes ile bir uygulamayı ölçeklendirmek, uygun dağıtım için kopya sayısını artırmak veya ReplicaSet — ancak bu manuel bir işlemdir.

Kubernetes, uygulamaların otomatik olarak ölçeklendirilmesine olanak tanır (örneğin, dağıtımdaki Pod'lar veya ReplicaSet) Yatay Kapsül Otomatik Ölçekleyici spesifikasyonunu kullanarak bildirimsel bir şekilde. Otomatik ölçeklendirmenin varsayılan kriteri CPU kullanım ölçümleridir (kaynak ölçümleri), ancak özel ve harici olarak sağlanan ölçümleri entegre edebilirsiniz.

Ekip Mail.ru'dan Kubernetes aaS Bir Kubernetes uygulamasını otomatik olarak ölçeklendirmek için harici ölçümlerin nasıl kullanılacağına ilişkin bir makaleyi tercüme etti. Her şeyin nasıl çalıştığını göstermek için yazar, Prometheus kullanılarak toplanan HTTP erişim isteği ölçümlerini kullanır.

Pod'ların yatay otomatik ölçeklendirmesi yerine, açık kaynaklı bir Kubernetes operatörü olan Kubernetes Olay Odaklı Otomatik Ölçeklendirme (KEDA) kullanılır. Olay odaklı iş yükleri için kesintisiz otomatik ölçeklendirme (sıfıra/sıfıra kadar dahil) sağlamak üzere Yatay Kapsül Otomatik Ölçekleyici ile yerel olarak entegre olur. Kod şu adreste mevcuttur: GitHub.

Sisteme kısa genel bakış

Diyagramda her şeyin nasıl çalıştığına dair kısa bir açıklama gösterilmektedir:

Uygulama, Prometheus formatında HTTP isabet sayısı ölçümleri sağlar.
Prometheus bu metrikleri toplayacak şekilde yapılandırılmıştır.
KEDA'daki Prometheus ölçekleyici, uygulamayı HTTP isabet sayısına göre otomatik olarak ölçeklendirecek şekilde yapılandırılmıştır.

Şimdi size her bir öğeyi ayrıntılı olarak anlatacağım.

KEDA ve Prometheus

Prometheus, açık kaynaklı bir sistem izleme ve uyarı araç setidir. Bulut Yerel Bilgi İşlem Vakfı. Çeşitli kaynaklardan metrikler toplar ve bunları zaman serisi verileri olarak saklar. Verileri görselleştirmek için kullanabileceğiniz grafana veya Kubernetes API ile çalışan diğer görselleştirme araçları.

KEDA, ölçekleyici konseptini desteklemektedir; KEDA ile harici sistem arasında bir köprü görevi görmektedir. Ölçekleyici uygulaması her hedef sisteme özeldir ve verileri buradan alır. KEDA daha sonra bunları otomatik ölçeklendirmeyi kontrol etmek için kullanır.

Ölçekleyiciler, Kafka, Redis, Prometheus gibi birden fazla veri kaynağını destekler. Yani KEDA, Prometheus ölçümlerini kriter olarak kullanarak Kubernetes dağıtımlarını otomatik olarak ölçeklendirmek için kullanılabilir.

Test uygulaması

Golang test uygulaması HTTP üzerinden erişim sağlar ve iki önemli işlevi yerine getirir:

Uygulamayı denetlemek ve isabet sayısını içeren http_requests ölçüsünü sağlamak için Prometheus Go istemci kitaplığını kullanır. Prometheus metriklerinin mevcut olduğu uç nokta URI'de bulunur /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Bir talebe yanıt olarak GET uygulama anahtarın değerini artırır (access_count) Redis'te. Bu, işi bir HTTP işleyicisinin parçası olarak yapmanın ve ayrıca Prometheus ölçümlerini kontrol etmenin kolay bir yoludur. Metrik değeri değerle aynı olmalıdır access_count Redis'te.

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)
   }

Uygulama Kubernetes'e dağıtılır. Deployment. Bir hizmet de yaratıldı ClusterIPPrometheus sunucusunun uygulama metriklerini elde etmesine olanak tanır.

Burada uygulama için dağıtım bildirimi.

Prometheus Sunucusu

Prometheus dağıtım bildirimi aşağıdakilerden oluşur:

ConfigMap — Prometheus yapılandırmasını aktarmak için;
Deployment — Prometheus'u bir Kubernetes kümesinde dağıtmak için;
ClusterIP — UI Prometheus'a erişim hizmeti;
ClusterRole, ClusterRoleBinding и ServiceAccount — Kubernetes'teki hizmetlerin otomatik olarak algılanması için (Otomatik bulma).

Burada Prometheus'u çalıştırma manifestosu.

KEDA Prometheus Ölçekli Nesne

Ölçekleyici, KEDA ile ölçümlerin alınması gereken harici sistem arasında bir köprü görevi görür. ScaledObject dağıtımı olay kaynağıyla (bu durumda Prometheus) senkronize etmek için dağıtılması gereken özel bir kaynaktır.

ScaledObject dağıtım ölçeklendirme bilgilerini, olay kaynağı meta verilerini (bağlantı sırları, kuyruk adı gibi), yoklama aralığını, kurtarma süresini ve diğer verileri içerir. Dağıtımı ölçeklendirmek için karşılık gelen otomatik ölçeklendirme kaynağı (HPA tanımı) ile sonuçlanır.

Ne zaman bir nesne ScaledObject silindiğinde ilgili HPA tanımı temizlenir.

İşte tanım ScaledObject örneğimizde bir ölçekleyici kullanıyor 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]))

Aşağıdaki noktaları göz önünde bulundurun:

O işaret ediyor Deployment Adı ile go-prom-app.
Tetikleyici türü - Prometheus. Prometheus sunucu adresi, metrik adı, eşiği ve değeriyle birlikte belirtilir. PromQL sorgusu, kullanılacaktır. PromQL Sorgusu - sum(rate(http_requests[2m])).
Göre pollingIntervalKEDA her on beş saniyede bir Prometheus'tan hedef talep ediyor. En az bir tanesi (minReplicaCount) ve maksimum kapsül sayısı aşmıyor maxReplicaCount (bu örnekte - on).

yükleyebilir minReplicaCount sıfıra eşittir. Bu durumda KEDA, sıfıra bir dağıtımı etkinleştirir ve ardından daha fazla otomatik ölçeklendirme için HPA'yı kullanıma sunar. Ters sıra da mümkündür, yani birden sıfıra ölçeklendirme. Örnekte sıfırı seçmedik çünkü bu bir HTTP hizmetidir ve isteğe bağlı bir sistem değildir.

Otomatik ölçeklendirmenin içindeki sihir

Eşik, dağıtımı ölçeklendirmek için tetikleyici olarak kullanılır. Örneğimizde PromQL sorgusu sum(rate (http_requests [2m])) son iki dakika içinde ölçülen toplu HTTP istek oranını (saniyedeki istek sayısı) döndürür.

Eşik değeri üç olduğu için değerin altında bir tane olacağı anlamına gelir. sum(rate (http_requests [2m])) üçten az. Değer artarsa her seferinde ek bir alt eklenir sum(rate (http_requests [2m])) üç oranında artar. Örneğin değer 12'den 14'e kadarsa bölme sayısı dört olur.

Şimdi ayarlamayı deneyelim!

ön ayar

İhtiyacınız olan tek şey bir Kubernetes kümesi ve yapılandırılmış bir yardımcı programdır kubectl. Bu örnekte bir küme kullanılıyor minikube, ama başka birini alabilirsin. Bir küme kurmak için liderlik.

En son sürümü Mac'e yükleyin:

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/

Ayarlamak KubectlKubernetes kümesine erişmek için.

En son sürümü Mac'e yükleyin:

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 kurulumu

KEDA'yı çeşitli şekillerde dağıtabilirsiniz; bunlar şurada listelenmiştir: belgeleme. Monolitik YAML kullanıyorum:

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

KEDA ve bileşenleri ad alanına kurulur keda. Kontrol etme komutu:

kubectl get pods -n keda

KEDA Operatörünün başlamasını bekleyin ve şuraya gidin: Running State. Bundan sonra devam edin.

Redis'i Helm kullanarak yükleme

Helm kurulu değilse bunu kullanın liderlik. Mac'e yükleme komutu:

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

helm init yerel komut satırı arayüzünü başlatır ve ayrıca yükler Tiller Kubernetes kümesine.

kubectl get pods -n kube-system | grep tiller

Yeke podunun Çalışıyor durumuna girmesini bekleyin.

Çevirmenin Notu: Yazar, Tiller sunucu bileşeninin kurulmasını gerektiren Helm@2'yi kullanıyor. Artık Helm@3 uygundur, sunucu parçası gerektirmez.

Helm'i yükledikten sonra Redis'i başlatmak için tek bir komut yeterlidir:

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

Redis'in başarıyla başlatıldığını doğrulayın:

kubectl get pods/redis-server-master-0

Redis'in duruma geçmesini bekleyin Running.

Uygulama Dağıtımı

Dağıtım komutu:

kubectl apply -f go-app.yaml

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

Her şeyin başladığını kontrol edin:

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

Redis'in duruma girmesini bekleyin Running.

Prometheus Sunucusunun Dağıtılması

Prometheus manifestosunun kullanım alanları Prometheus için Kubernetes Hizmet Keşfi. Hizmet etiketine göre uygulama bölmelerinin dinamik olarak keşfedilmesine olanak tanır.

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

Dağıtmak için:

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

Her şeyin başladığını kontrol edin:

kubectl get pods -l=app=prometheus-server

Prometheus'un duruma geçmesini bekleyin Running.

Kullanmak kubectl port-forward Prometheus kullanıcı arayüzüne (veya API sunucusuna) şu adresten erişmek için: http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA Otomatik Ölçeklendirme Yapılandırmasını Dağıtma

Oluşturma komutu ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

KEDA operatör kayıtlarını kontrol edin:

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

Sonuç şuna benzer:

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"

Uygulamalar altında kontrol edin. Bir örneğin çalışıyor olması gerekir çünkü minReplicaCount 1'e eşittir:

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

HPA kaynağının başarıyla oluşturulduğunu doğrulayın:

kubectl get hpa

Şöyle bir şey görmelisiniz:

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

Durum kontrolü: uygulama erişimi

Uygulamamızın REST uç noktasına erişmek için şunu çalıştırın:

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

Artık Go uygulamanıza şu adresi kullanarak erişebilirsiniz: http://localhost:8080. Bunu yapmak için şu komutu çalıştırın:

curl http://localhost:8080/test

Sonuç şuna benzer:

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

Bu noktada Redis'i de kontrol edin. Anahtarın olduğunu göreceksin access_count 1'e yükseldi:

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

Metrik değerinin olduğundan emin olun http_requests aynısı:

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

Yük Oluşturma

Kullanacağız hey — yük oluşturmaya yönelik yardımcı program:

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

Ayrıca yardımcı programı da indirebilirsiniz. Linux veya Windows.

Çalıştır:

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

Yardımcı program varsayılan olarak 200 istek gönderir. Redis'in yanı sıra Prometheus metriklerini kullanarak bunu doğrulayabilirsiniz.

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

Gerçek metriğin değerini doğrulayın (PromQL sorgusu tarafından döndürülür):

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

Bu durumda asıl sonuç 1,686057971014493 ve alanda görüntülenir value. Belirlediğimiz eşik 3 olduğundan ölçeklendirme için bu yeterli değildir.

Daha fazla yük!

Yeni terminalde uygulama bölmelerinin sayısını izleyin:

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

Komutu kullanarak yükü artıralım:

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

Bir süre sonra HPA'nın dağıtımı ölçeklendirdiğini ve yeni kapsüller başlattığını göreceksiniz. Aşağıdakilerden emin olmak için HPA'nızı kontrol edin:

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

Yük tutarsızsa dağıtım yalnızca bir bölmenin çalıştığı noktaya kadar azaltılacaktır. Gerçek ölçümü (PromQL sorgusu tarafından döndürülen) kontrol etmek istiyorsanız şu komutu kullanın:

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

Очистка

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

Sonuç

KEDA, harici ölçümlerden elde edilen verilere dayanarak Kubernetes dağıtımlarınızı otomatik olarak (sıfırdan/sıfıra) ölçeklendirmenize olanak tanır. Örneğin Prometheus metriklerine, Redis'teki kuyruk uzunluğuna, Kafka konusundaki tüketici gecikmesine göre.

KEDA, harici bir kaynakla entegre olur ve ayrıca ölçümlerini Metrics Server aracılığıyla Yatay Pod Otomatik Ölçekleyiciye sağlar.

İyi şanslar!

Okumak için başka ne var:

Kaynak: habr.com

Prometheus ve KEDA ile Kubernetes Uygulamalarını Otomatik Ölçeklendirme