🥇Tự động mở rộng ứng dụng Kubernetes bằng Prometheus và KEDA

Balloon Man của Cimuanos

Khả năng mở rộng là một yêu cầu quan trọng đối với các ứng dụng đám mây. Với Kubernetes, việc mở rộng quy mô ứng dụng cũng đơn giản như tăng số lượng bản sao để triển khai hoặc ReplicaSet - nhưng đó là một quá trình thủ công.

Kubernetes cho phép các ứng dụng được tự động mở rộng quy mô (tức là các Pod đang được triển khai hoặc ReplicaSet) theo cách khai báo bằng cách sử dụng đặc tả của Horizontal Pod Autoscaler. Tiêu chí mặc định để tự động điều chỉnh quy mô là số liệu sử dụng CPU (số liệu tài nguyên), nhưng bạn có thể tích hợp các số liệu tùy chỉnh và được cung cấp bên ngoài.

Đội Kubernetes aaS từ Mail.ru đã dịch một bài viết về cách sử dụng các số liệu bên ngoài để tự động mở rộng quy mô ứng dụng Kubernetes. Để hiển thị cách mọi thứ hoạt động, tác giả sử dụng số liệu yêu cầu truy cập HTTP được thu thập bằng Prometheus.

Thay vì tự động điều chỉnh theo chiều ngang của các nhóm, Kubernetes Event Driven Autoscaling (KEDA) được sử dụng, một toán tử Kubernetes nguồn mở. Nó tích hợp nguyên bản với Horizontal Pod Autoscaler để cung cấp khả năng tự động điều chỉnh quy mô liền mạch (bao gồm đến/từ XNUMX) cho khối lượng công việc theo sự kiện. Mã có sẵn tại GitHub.

Tổng quan ngắn gọn về hệ thống

Sơ đồ hiển thị mô tả ngắn gọn về cách mọi thứ hoạt động:

Ứng dụng này cung cấp số liệu về số lần truy cập HTTP ở định dạng Prometheus.
Prometheus được cấu hình để thu thập các số liệu này.
Bộ chia tỷ lệ Prometheus trong KEDA được định cấu hình để tự động mở rộng quy mô ứng dụng dựa trên số lần truy cập HTTP.

Bây giờ tôi sẽ kể chi tiết cho bạn về từng yếu tố.

KEDA và Prometheus

Prometheus là bộ công cụ cảnh báo và giám sát hệ thống nguồn mở, một phần Nền tảng điện toán bản địa đám mây. Thu thập số liệu từ nhiều nguồn khác nhau và lưu trữ chúng dưới dạng dữ liệu chuỗi thời gian. Để trực quan hóa dữ liệu bạn có thể sử dụng grafana hoặc các công cụ trực quan khác hoạt động với API Kubernetes.

KEDA hỗ trợ khái niệm bộ chia tỷ lệ - nó đóng vai trò là cầu nối giữa KEDA và hệ thống bên ngoài. Việc triển khai bộ chia tỷ lệ là dành riêng cho từng hệ thống mục tiêu và trích xuất dữ liệu từ nó. KEDA sau đó sử dụng chúng để kiểm soát quy mô tự động.

Bộ chia tỷ lệ hỗ trợ nhiều nguồn dữ liệu, ví dụ: Kafka, Redis, Prometheus. Nghĩa là, KEDA có thể được sử dụng để tự động mở rộng quy mô triển khai Kubernetes bằng cách sử dụng số liệu Prometheus làm tiêu chí.

Ứng dụng thử nghiệm

Ứng dụng thử nghiệm Golang cung cấp quyền truy cập qua HTTP và thực hiện hai chức năng quan trọng:

Sử dụng thư viện máy khách Prometheus Go để trang bị cho ứng dụng và cung cấp số liệu http_requests, trong đó có số lần truy cập. Điểm cuối nơi số liệu Prometheus có sẵn được đặt tại URI /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

Để đáp lại một yêu cầu GET ứng dụng tăng giá trị của khóa (access_count) trong Redis. Đây là một cách dễ dàng để thực hiện công việc như một phần của trình xử lý HTTP và cũng có thể kiểm tra các số liệu của Prometheus. Giá trị số liệu phải giống với giá trị access_count ở 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)
   }

Ứng dụng được triển khai lên Kubernetes thông qua Deployment. Một dịch vụ cũng được tạo ra ClusterIP, nó cho phép máy chủ Prometheus lấy số liệu ứng dụng.

Đây bảng kê khai triển khai cho ứng dụng.

Máy chủ Prometheus

Bản kê khai triển khai Prometheus bao gồm:

ConfigMap — để chuyển cấu hình Prometheus;
Deployment — để triển khai Prometheus trong cụm Kubernetes;
ClusterIP — dịch vụ truy cập vào UI Prometheus;
ClusterRole, ClusterRoleBinding и ServiceAccount — để tự động phát hiện các dịch vụ trong Kubernetes (Tự động khám phá).

Đây bảng kê khai để chạy Prometheus.

KEDA Prometheus ScaledObject

Bộ chia tỷ lệ hoạt động như một cầu nối giữa KEDA và hệ thống bên ngoài mà từ đó cần lấy số liệu. ScaledObject là tài nguyên tùy chỉnh cần được triển khai để đồng bộ hóa quá trình triển khai với nguồn sự kiện, trong trường hợp này là Prometheus.

ScaledObject chứa thông tin mở rộng quy mô triển khai, siêu dữ liệu nguồn sự kiện (chẳng hạn như bí mật kết nối, tên hàng đợi), khoảng thời gian bỏ phiếu, thời gian khôi phục và dữ liệu khác. Nó tạo ra tài nguyên tự động điều chỉnh quy mô tương ứng (định nghĩa HPA) để mở rộng quy mô triển khai.

Khi một vật thể ScaledObject bị xóa, định nghĩa HPA tương ứng sẽ bị xóa.

Đây là định nghĩa ScaledObject trong ví dụ của chúng tôi, nó sử dụng bộ chia tỷ lệ 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]))

Hãy xem xét các điểm sau:

Anh ấy chỉ vào Deployment Với tên go-prom-app.
Loại kích hoạt - Prometheus. Địa chỉ máy chủ Prometheus được đề cập cùng với tên số liệu, ngưỡng và Truy vấn PromQL, sẽ được sử dụng. Truy vấn PromQL - sum(rate(http_requests[2m])).
Theo pollingInterval,KEDA yêu cầu một mục tiêu từ Prometheus cứ sau mười lăm giây. Ít nhất một dưới (minReplicaCount) và số lượng nhóm tối đa không vượt quá maxReplicaCount (trong ví dụ này - mười).

Có thể được cài đặt minReplicaCount bằng không. Trong trường hợp này, KEDA kích hoạt triển khai zero-to-one và sau đó hiển thị HPA để tự động mở rộng quy mô hơn nữa. Thứ tự ngược lại cũng có thể xảy ra, tức là chia tỷ lệ từ XNUMX thành XNUMX. Trong ví dụ này, chúng tôi không chọn số XNUMX vì đây là dịch vụ HTTP chứ không phải hệ thống theo yêu cầu.

Sự kỳ diệu bên trong tính năng tự động tính toán

Ngưỡng này được sử dụng làm yếu tố kích hoạt để mở rộng quy mô triển khai. Trong ví dụ của chúng tôi, truy vấn PromQL sum(rate (http_requests [2m])) trả về tốc độ yêu cầu HTTP tổng hợp (số yêu cầu mỗi giây), được đo trong hai phút qua.

Vì giá trị ngưỡng là ba, điều đó có nghĩa là sẽ có một giá trị ở dưới trong khi giá trị sum(rate (http_requests [2m])) ít hơn ba. Nếu giá trị tăng lên, một sub bổ sung sẽ được thêm vào mỗi lần sum(rate (http_requests [2m])) tăng lên ba. Ví dụ: nếu giá trị từ 12 đến 14 thì số lượng nhóm là bốn.

Bây giờ hãy thử thiết lập nó!

đặt trước

Tất cả những gì bạn cần là cụm Kubernetes và tiện ích được định cấu hình kubectl. Ví dụ này sử dụng một cụm minikube, nhưng bạn có thể lấy bất kỳ cái nào khác. Để cài đặt một cụm có khả năng lãnh đạo.

Cài đặt phiên bản mới nhất trên 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/

Tải về kubectlđể truy cập cụm Kubernetes.

Cài đặt phiên bản mới nhất trên 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

cài đặt KEDA

Bạn có thể triển khai KEDA theo nhiều cách, chúng được liệt kê trong tài liệu. Tôi đang sử dụng YAML nguyên khối:

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

KEDA và các thành phần của nó được cài đặt vào không gian tên keda. Lệnh để kiểm tra:

kubectl get pods -n keda

Đợi Nhà điều hành KEDA bắt đầu và đi tới Running State. Và sau đó, tiếp tục.

Cài đặt Redis bằng Helm

Nếu bạn chưa cài đặt Helm, hãy sử dụng cái này Khả năng lãnh đạo. Lệnh cài đặt trên Mac:

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

helm init khởi tạo giao diện dòng lệnh cục bộ và cũng cài đặt Tiller đến cụm Kubernetes.

kubectl get pods -n kube-system | grep tiller

Đợi nhóm Máy xới chuyển sang trạng thái Đang chạy.

Ghi chú của người dịch: Tác giả sử dụng Helm@2, yêu cầu cài đặt thành phần máy chủ Tiller. Bây giờ Helm@3 đã phù hợp, nó không yêu cầu phần máy chủ.

Sau khi cài đặt Helm, một lệnh là đủ để khởi động Redis:

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

Xác minh rằng Redis đã khởi động thành công:

kubectl get pods/redis-server-master-0

Đợi Redis vào trạng thái Running.

Triển khai ứng dụng

Lệnh triển khai:

kubectl apply -f go-app.yaml

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

Kiểm tra xem mọi thứ đã bắt đầu chưa:

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

Đợi Redis vào trạng thái Running.

Triển khai máy chủ Prometheus

Bản kê khai Prometheus sử dụng Khám phá dịch vụ Kubernetes cho Prometheus. Nó cho phép khám phá động các nhóm ứng dụng dựa trên nhãn dịch vụ.

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

Để triển khai:

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

Kiểm tra xem mọi thứ đã bắt đầu chưa:

kubectl get pods -l=app=prometheus-server

Đợi Prometheus đi vào trạng thái Running.

Sử dụng kubectl port-forward để truy cập giao diện người dùng Prometheus (hoặc máy chủ API) tại http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

Triển khai cấu hình tự động điều chỉnh tỷ lệ KEDA

Lệnh tạo ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

Kiểm tra nhật ký của người vận hành KEDA:

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

Kết quả trông giống như thế này:

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"

Kiểm tra dưới các ứng dụng. Một phiên bản phải đang chạy vì minReplicaCount bằng 1:

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

Xác minh rằng tài nguyên HPA đã được tạo thành công:

kubectl get hpa

Bạn sẽ thấy một cái gì đó như:

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

Kiểm tra sức khỏe: quyền truy cập ứng dụng

Để truy cập điểm cuối REST của ứng dụng của chúng tôi, hãy chạy:

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

Bây giờ bạn có thể truy cập ứng dụng Go của mình bằng địa chỉ http://localhost:8080. Để thực hiện việc này, hãy chạy lệnh:

curl http://localhost:8080/test

Kết quả trông giống như thế này:

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

Tại thời điểm này cũng kiểm tra Redis. Bạn sẽ thấy rằng chìa khóa access_count tăng lên 1:

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

Đảm bảo giá trị số liệu là http_requests giống nhau:

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

Tạo tải

Chúng tôi sẽ sử dụng hey - tiện ích tạo tải:

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

Bạn cũng có thể tải xuống tiện ích dành cho Linux hoặc Windows.

Chạy nó:

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

Theo mặc định, tiện ích sẽ gửi 200 yêu cầu. Bạn có thể xác minh điều này bằng cách sử dụng số liệu Prometheus cũng như 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

Xác thực giá trị của số liệu thực tế (được truy vấn PromQL trả về):

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

Trong trường hợp này, kết quả thực tế là 1,686057971014493 và được hiển thị trong trường value. Điều này là không đủ để chia tỷ lệ vì ngưỡng chúng tôi đặt là 3.

Thêm tải!

Trong thiết bị đầu cuối mới, theo dõi số lượng nhóm ứng dụng:

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

Hãy tăng tải bằng lệnh:

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

Sau một thời gian, bạn sẽ thấy HPA mở rộng quy mô triển khai và khởi chạy các nhóm mới. Kiểm tra HPA của bạn để đảm bảo:

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

Nếu tải không nhất quán, quá trình triển khai sẽ bị giảm xuống mức chỉ có một nhóm đang chạy. Nếu bạn muốn kiểm tra số liệu thực tế (được truy vấn PromQL trả về), hãy sử dụng lệnh:

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

Vệ sinh

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

Kết luận

KEDA cho phép bạn tự động mở rộng quy mô triển khai Kubernetes (đến/từ XNUMX) dựa trên dữ liệu từ các số liệu bên ngoài. Ví dụ: dựa trên số liệu Prometheus, độ dài hàng đợi trong Redis, độ trễ của người tiêu dùng trong chủ đề Kafka.

KEDA tích hợp với một nguồn bên ngoài và cũng cung cấp số liệu của nó thông qua Máy chủ số liệu cho Bộ chia tỷ lệ tự động Pod ngang.

Chúc may mắn!

Những gì khác để đọc:

Nguồn: www.habr.com

Tự động mở rộng ứng dụng Kubernetes bằng Prometheus và KEDA