🥇Prometheus ಮತ್ತು KEDA ಬಳಸಿಕೊಂಡು ಕುಬರ್ನೆಟ್ಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಆಟೋಸ್ಕೇಲಿಂಗ್

Cimuanos ಅವರಿಂದ ಬಲೂನ್ ಮ್ಯಾನ್

ಕ್ಲೌಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸ್ಕೇಲೆಬಿಲಿಟಿ ಪ್ರಮುಖ ಅವಶ್ಯಕತೆಯಾಗಿದೆ. ಕುಬರ್ನೆಟ್ಸ್ನೊಂದಿಗೆ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಕೇಲಿಂಗ್ ಮಾಡುವುದು ಸೂಕ್ತವಾದ ನಿಯೋಜನೆಗಾಗಿ ಪ್ರತಿಕೃತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸುವಷ್ಟು ಸರಳವಾಗಿದೆ ಅಥವಾ ReplicaSet - ಆದರೆ ಇದು ಹಸ್ತಚಾಲಿತ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ.

ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಕೇಲ್ ಮಾಡಲು ಕುಬರ್ನೆಟ್ಸ್ ಅನುಮತಿಸುತ್ತದೆ (ಅಂದರೆ ನಿಯೋಜನೆಯಲ್ಲಿರುವ ಪಾಡ್‌ಗಳು ಅಥವಾ ReplicaSet) ಸಮತಲ ಪಾಡ್ ಆಟೋಸ್ಕೇಲರ್ ವಿವರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಘೋಷಣೆಯ ರೀತಿಯಲ್ಲಿ. ಸ್ವಯಂಚಾಲಿತ ಸ್ಕೇಲಿಂಗ್‌ಗಾಗಿ ಡೀಫಾಲ್ಟ್ ಮಾನದಂಡವೆಂದರೆ CPU ಬಳಕೆಯ ಮೆಟ್ರಿಕ್‌ಗಳು (ಸಂಪನ್ಮೂಲ ಮೆಟ್ರಿಕ್‌ಗಳು), ಆದರೆ ನೀವು ಕಸ್ಟಮ್ ಮತ್ತು ಬಾಹ್ಯವಾಗಿ ಒದಗಿಸಿದ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು.

ತಂಡದ Mail.ru ನಿಂದ Kubernetes aaS ಕುಬರ್ನೆಟ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳೆಯಲು ಬಾಹ್ಯ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಕುರಿತು ಲೇಖನವನ್ನು ಅನುವಾದಿಸಲಾಗಿದೆ. ಎಲ್ಲವೂ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು, ಲೇಖಕರು HTTP ಪ್ರವೇಶ ವಿನಂತಿ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಬಳಸುತ್ತಾರೆ, ಇವುಗಳನ್ನು Prometheus ಬಳಸಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

ಪಾಡ್‌ಗಳ ಸಮತಲ ಆಟೋಸ್ಕೇಲಿಂಗ್ ಬದಲಿಗೆ, ಕುಬರ್ನೆಟ್ಸ್ ಈವೆಂಟ್ ಡ್ರೈವನ್ ಆಟೋಸ್ಕೇಲಿಂಗ್ (ಕೆಇಡಿಎ) ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಓಪನ್ ಸೋರ್ಸ್ ಕುಬರ್ನೆಟ್ಸ್ ಆಪರೇಟರ್ ಆಗಿದೆ. ಈವೆಂಟ್-ಚಾಲಿತ ಕೆಲಸದ ಹೊರೆಗಳಿಗಾಗಿ ತಡೆರಹಿತ ಆಟೋಸ್ಕೇಲಿಂಗ್ (ಶೂನ್ಯಕ್ಕೆ/ಇದರಿಂದ) ಒದಗಿಸಲು ಇದು ಸ್ಥಳೀಯವಾಗಿ ಸಮತಲ ಪಾಡ್ ಆಟೋಸ್ಕೇಲರ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ. ಕೋಡ್ ಲಭ್ಯವಿದೆ GitHub.

ವ್ಯವಸ್ಥೆಯ ಸಂಕ್ಷಿಪ್ತ ಅವಲೋಕನ

ರೇಖಾಚಿತ್ರವು ಎಲ್ಲವೂ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಸಂಕ್ಷಿಪ್ತ ವಿವರಣೆಯನ್ನು ತೋರಿಸುತ್ತದೆ:

ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಮೀತಿಯಸ್ ಸ್ವರೂಪದಲ್ಲಿ HTTP ಹಿಟ್ ಕೌಂಟ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಈ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಪ್ರಮೀತಿಯಸ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ.
HTTP ಹಿಟ್‌ಗಳ ಸಂಖ್ಯೆಯ ಆಧಾರದ ಮೇಲೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳೆಯಲು KEDA ನಲ್ಲಿನ ಪ್ರೊಮೀಥಿಯಸ್ ಸ್ಕೇಲರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ.

ಈಗ ನಾನು ಪ್ರತಿ ಅಂಶದ ಬಗ್ಗೆ ವಿವರವಾಗಿ ಹೇಳುತ್ತೇನೆ.

KEDA ಮತ್ತು ಪ್ರಮೀತಿಯಸ್

ಪ್ರಮೀತಿಯಸ್ ಓಪನ್ ಸೋರ್ಸ್ ಸಿಸ್ಟಮ್ ಮಾನಿಟರಿಂಗ್ ಮತ್ತು ಅಲರ್ಟಿಂಗ್ ಟೂಲ್ಕಿಟ್, ಭಾಗವಾಗಿದೆ ಮೇಘ ಸ್ಥಳೀಯ ಕಂಪ್ಯೂಟಿಂಗ್ ಪ್ರತಿಷ್ಠಾನ. ವಿವಿಧ ಮೂಲಗಳಿಂದ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಸಮಯ ಸರಣಿ ಡೇಟಾದಂತೆ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ನೀವು ಬಳಸಬಹುದು ಗ್ರಾಫಾನಾ ಅಥವಾ ಕುಬರ್ನೆಟ್ಸ್ API ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಇತರ ದೃಶ್ಯೀಕರಣ ಉಪಕರಣಗಳು.

KEDA ಸ್ಕೇಲರ್ ಪರಿಕಲ್ಪನೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ - ಇದು KEDA ಮತ್ತು ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಯ ನಡುವಿನ ಸೇತುವೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಸ್ಕೇಲರ್ ಅನುಷ್ಠಾನವು ಪ್ರತಿ ಗುರಿ ವ್ಯವಸ್ಥೆಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿರುತ್ತದೆ ಮತ್ತು ಅದರಿಂದ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ. KEDA ನಂತರ ಸ್ವಯಂಚಾಲಿತ ಸ್ಕೇಲಿಂಗ್ ಅನ್ನು ನಿಯಂತ್ರಿಸಲು ಅವುಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ಸ್ಕೇಲರ್‌ಗಳು ಬಹು ಡೇಟಾ ಮೂಲಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ, ಉದಾಹರಣೆಗೆ, ಕಾಫ್ಕಾ, ರೆಡಿಸ್, ಪ್ರಮೀತಿಯಸ್. ಅಂದರೆ, ಪ್ರೊಮೆಥಿಯಸ್ ಮೆಟ್ರಿಕ್ಸ್ ಅನ್ನು ಮಾನದಂಡವಾಗಿ ಬಳಸಿಕೊಂಡು ಕುಬರ್ನೆಟ್ಸ್ ನಿಯೋಜನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳೆಯಲು KEDA ಅನ್ನು ಬಳಸಬಹುದು.

ಪರೀಕ್ಷಾ ಅಪ್ಲಿಕೇಶನ್

ಗೋಲಾಂಗ್ ಪರೀಕ್ಷಾ ಅಪ್ಲಿಕೇಶನ್ HTTP ಮೂಲಕ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಎರಡು ಪ್ರಮುಖ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:

ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಾಧನವಾಗಿಸಲು Prometheus Go ಕ್ಲೈಂಟ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಹಿಟ್ ಎಣಿಕೆಯನ್ನು ಹೊಂದಿರುವ http_requests ಮೆಟ್ರಿಕ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಪ್ರಮೀತಿಯಸ್ ಮೆಟ್ರಿಕ್‌ಗಳು ಲಭ್ಯವಿರುವ ಅಂತಿಮ ಬಿಂದುವು URI ನಲ್ಲಿದೆ /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```
ವಿನಂತಿಯೊಂದಕ್ಕೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ GET ಅಪ್ಲಿಕೇಶನ್ ಕೀಲಿಯ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ (access_count) ರೆಡಿಸ್ ನಲ್ಲಿ. HTTP ಹ್ಯಾಂಡ್ಲರ್‌ನ ಭಾಗವಾಗಿ ಕೆಲಸವನ್ನು ಮಾಡಲು ಇದು ಸುಲಭವಾದ ಮಾರ್ಗವಾಗಿದೆ ಮತ್ತು Prometheus ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಸಹ ಪರಿಶೀಲಿಸಿ. ಮೆಟ್ರಿಕ್ ಮೌಲ್ಯವು ಮೌಲ್ಯದಂತೆಯೇ ಇರಬೇಕು access_count ರೆಡಿಸ್ ನಲ್ಲಿ.
```
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)
   }
```

ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕುಬರ್ನೆಟ್ಸ್ ಮೂಲಕ ನಿಯೋಜಿಸಲಾಗಿದೆ Deployment. ಸೇವೆಯನ್ನು ಸಹ ರಚಿಸಲಾಗಿದೆ ClusterIP, ಇದು ಪ್ರಮೀತಿಯಸ್ ಸರ್ವರ್ ಅಪ್ಲಿಕೇಶನ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ.

ಇಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ನಿಯೋಜನೆ ಮ್ಯಾನಿಫೆಸ್ಟ್.

ಪ್ರಮೀತಿಯಸ್ ಸರ್ವರ್

ಪ್ರಮೀತಿಯಸ್ ನಿಯೋಜನೆ ಮ್ಯಾನಿಫೆಸ್ಟ್ ಒಳಗೊಂಡಿದೆ:

ConfigMap - ಪ್ರಮೀತಿಯಸ್ ಸಂರಚನೆಯನ್ನು ವರ್ಗಾಯಿಸಲು;
Deployment - ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ನಲ್ಲಿ ಪ್ರಮೀತಿಯಸ್ ಅನ್ನು ನಿಯೋಜಿಸಲು;
ClusterIP - UI ಪ್ರಮೀತಿಯಸ್‌ಗೆ ಪ್ರವೇಶಕ್ಕಾಗಿ ಸೇವೆ;
ClusterRole, ClusterRoleBinding и ServiceAccount - ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿನ ಸೇವೆಗಳ ಸ್ವಯಂ ಪತ್ತೆಗಾಗಿ (ಸ್ವಯಂ-ಶೋಧನೆ).

ಇಲ್ಲಿ ಪ್ರಮೀತಿಯಸ್ ರನ್ನಿಂಗ್ ಮ್ಯಾನಿಫೆಸ್ಟ್.

KEDA ಪ್ರಮೀತಿಯಸ್ ಸ್ಕೇಲ್ಡ್ ಆಬ್ಜೆಕ್ಟ್

ಸ್ಕೇಲರ್ KEDA ಮತ್ತು ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಪಡೆಯಬೇಕಾದ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಯ ನಡುವಿನ ಸೇತುವೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ScaledObject ಈವೆಂಟ್ ಮೂಲದೊಂದಿಗೆ ನಿಯೋಜನೆಯನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ನಿಯೋಜಿಸಬೇಕಾದ ಕಸ್ಟಮ್ ಸಂಪನ್ಮೂಲವಾಗಿದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಪ್ರಮೀತಿಯಸ್.

ScaledObject ನಿಯೋಜನೆ ಸ್ಕೇಲಿಂಗ್ ಮಾಹಿತಿ, ಈವೆಂಟ್ ಮೂಲ ಮೆಟಾಡೇಟಾ (ಸಂಪರ್ಕ ರಹಸ್ಯಗಳು, ಸರದಿ ಹೆಸರು), ಮತದಾನದ ಮಧ್ಯಂತರ, ಚೇತರಿಕೆಯ ಅವಧಿ ಮತ್ತು ಇತರ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿದೆ. ಇದು ನಿಯೋಜನೆಯನ್ನು ಅಳೆಯಲು ಅನುಗುಣವಾದ ಆಟೋಸ್ಕೇಲಿಂಗ್ ಸಂಪನ್ಮೂಲಕ್ಕೆ (HPA ವ್ಯಾಖ್ಯಾನ) ಕಾರಣವಾಗುತ್ತದೆ.

ಯಾವಾಗ ವಸ್ತು ScaledObject ಅಳಿಸಲಾಗಿದೆ, ಅನುಗುಣವಾದ HPA ವ್ಯಾಖ್ಯಾನವನ್ನು ತೆರವುಗೊಳಿಸಲಾಗಿದೆ.

ವ್ಯಾಖ್ಯಾನ ಇಲ್ಲಿದೆ ScaledObject ನಮ್ಮ ಉದಾಹರಣೆಗಾಗಿ, ಇದು ಸ್ಕೇಲರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ 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]))

ದಯವಿಟ್ಟು ಈ ಕೆಳಗಿನ ಅಂಶಗಳನ್ನು ಗಮನಿಸಿ:

ಅವರು ಸೂಚಿಸುತ್ತಾರೆ Deployment ಹೆಸರಿನೊಂದಿಗೆ go-prom-app.
ಪ್ರಚೋದಕ ಪ್ರಕಾರ - Prometheus. ಪ್ರಮೀತಿಯಸ್ ಸರ್ವರ್ ವಿಳಾಸವನ್ನು ಮೆಟ್ರಿಕ್ ಹೆಸರು, ಮಿತಿ ಮತ್ತು ಜೊತೆಗೆ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ PromQL ಪ್ರಶ್ನೆ, ಇದನ್ನು ಬಳಸಲಾಗುವುದು. PromQL ಪ್ರಶ್ನೆ - sum(rate(http_requests[2m])).
ಪ್ರಕಾರ pollingInterval,ಕೆಇಡಿಎ ಪ್ರತಿ ಹದಿನೈದು ಸೆಕೆಂಡಿಗೆ ಪ್ರಮೀತಿಯಸ್‌ನಿಂದ ಗುರಿಯನ್ನು ವಿನಂತಿಸುತ್ತದೆ. ಕನಿಷ್ಠ ಒಂದು ಅಡಿಯಲ್ಲಿ (minReplicaCount), ಮತ್ತು ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಬೀಜಕೋಶಗಳು ಮೀರುವುದಿಲ್ಲ maxReplicaCount (ಈ ಉದಾಹರಣೆಯಲ್ಲಿ - ಹತ್ತು).

ಅಳವಡಿಸಬಹುದಾಗಿದೆ minReplicaCount ಶೂನ್ಯಕ್ಕೆ ಸಮ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, KEDA ಶೂನ್ಯದಿಂದ ಒಂದು ನಿಯೋಜನೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಮತ್ತಷ್ಟು ಸ್ವಯಂಚಾಲಿತ ಸ್ಕೇಲಿಂಗ್‌ಗಾಗಿ HPA ಅನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ. ರಿವರ್ಸ್ ಆರ್ಡರ್ ಸಹ ಸಾಧ್ಯವಿದೆ, ಅಂದರೆ, ಒಂದರಿಂದ ಶೂನ್ಯಕ್ಕೆ ಸ್ಕೇಲಿಂಗ್. ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಶೂನ್ಯವನ್ನು ಆಯ್ಕೆ ಮಾಡಿಲ್ಲ ಏಕೆಂದರೆ ಇದು HTTP ಸೇವೆಯಾಗಿದೆ ಮತ್ತು ಬೇಡಿಕೆಯ ವ್ಯವಸ್ಥೆಯಲ್ಲ.

ಆಟೋಸ್ಕೇಲಿಂಗ್ ಒಳಗಿನ ಮ್ಯಾಜಿಕ್

ನಿಯೋಜನೆಯನ್ನು ಅಳೆಯಲು ಪ್ರಚೋದಕವಾಗಿ ಮಿತಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, PromQL ಪ್ರಶ್ನೆ sum(rate (http_requests [2m])) ಕಳೆದ ಎರಡು ನಿಮಿಷಗಳಲ್ಲಿ ಅಳೆಯಲಾದ ಒಟ್ಟು HTTP ವಿನಂತಿ ದರವನ್ನು (ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ವಿನಂತಿಗಳು) ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಥ್ರೆಶೋಲ್ಡ್ ಮೌಲ್ಯವು ಮೂರು ಆಗಿರುವುದರಿಂದ, ಮೌಲ್ಯದ ಅಡಿಯಲ್ಲಿ ಒಂದು ಇರುತ್ತದೆ ಎಂದರ್ಥ sum(rate (http_requests [2m])) ಮೂರಕ್ಕಿಂತ ಕಡಿಮೆ. ಮೌಲ್ಯವು ಹೆಚ್ಚಾದರೆ, ಪ್ರತಿ ಬಾರಿ ಹೆಚ್ಚುವರಿ ಉಪವನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ sum(rate (http_requests [2m])) ಮೂರು ಹೆಚ್ಚಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಮೌಲ್ಯವು 12 ರಿಂದ 14 ರವರೆಗೆ ಇದ್ದರೆ, ನಂತರ ಪಾಡ್ಗಳ ಸಂಖ್ಯೆ ನಾಲ್ಕು.

ಈಗ ಅದನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ!

ಪೂರ್ವಹೊಂದಿಕೆ

ನಿಮಗೆ ಬೇಕಾಗಿರುವುದು ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಉಪಯುಕ್ತತೆಯಾಗಿದೆ kubectl. ಈ ಉದಾಹರಣೆಯು ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ minikube, ಆದರೆ ನೀವು ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಅಲ್ಲಿ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ನಾಯಕತ್ವ.

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/

ಸ್ಥಾಪಿಸಿ kubectlಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು.

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 ಸ್ಥಾಪನೆ

ನೀವು KEDA ಅನ್ನು ಹಲವಾರು ವಿಧಗಳಲ್ಲಿ ನಿಯೋಜಿಸಬಹುದು, ಅವುಗಳನ್ನು ಪಟ್ಟಿಮಾಡಲಾಗಿದೆ ದಸ್ತಾವೇಜನ್ನು. ನಾನು ಏಕಶಿಲೆಯ YAML ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ:

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

KEDA ಮತ್ತು ಅದರ ಘಟಕಗಳನ್ನು ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ keda. ಪರಿಶೀಲಿಸಲು ಆದೇಶ:

kubectl get pods -n keda

KEDA ಆಪರೇಟರ್ ಪ್ರಾರಂಭಿಸಲು ಮತ್ತು ಹೋಗಲು ನಿರೀಕ್ಷಿಸಿ Running State. ಮತ್ತು ಅದರ ನಂತರ, ಮುಂದುವರಿಯಿರಿ.

ಹೆಲ್ಮ್ ಬಳಸಿ ರೆಡಿಸ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

ನೀವು ಹೆಲ್ಮ್ ಅನ್ನು ಸ್ಥಾಪಿಸದಿದ್ದರೆ, ಇದನ್ನು ಬಳಸಿ ನಾಯಕತ್ವ. ಮ್ಯಾಕ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲು ಆಜ್ಞೆ:

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

helm init ಸ್ಥಳೀಯ ಆಜ್ಞಾ ಸಾಲಿನ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಸ್ಥಾಪಿಸುತ್ತದೆ Tiller ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗೆ.

kubectl get pods -n kube-system | grep tiller

ಟಿಲ್ಲರ್ ಪಾಡ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಸ್ಥಿತಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ನಿರೀಕ್ಷಿಸಿ.

ಅನುವಾದಕರ ಟಿಪ್ಪಣಿ: ಲೇಖಕರು ಹೆಲ್ಮ್@2 ಅನ್ನು ಬಳಸುತ್ತಾರೆ, ಇದಕ್ಕೆ ಟಿಲ್ಲರ್ ಸರ್ವರ್ ಘಟಕವನ್ನು ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿದೆ. ಈಗ ಹೆಲ್ಮ್ @ 3 ಪ್ರಸ್ತುತವಾಗಿದೆ, ಇದಕ್ಕೆ ಸರ್ವರ್ ಭಾಗ ಅಗತ್ಯವಿಲ್ಲ.

ಹೆಲ್ಮ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ, ರೆಡಿಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಒಂದು ಆಜ್ಞೆಯು ಸಾಕು:

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

ರೆಡಿಸ್ ಯಶಸ್ವಿಯಾಗಿ ಪ್ರಾರಂಭವಾಗಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಿ:

kubectl get pods/redis-server-master-0

ರೆಡಿಸ್ ರಾಜ್ಯಕ್ಕೆ ಹೋಗಲು ನಿರೀಕ್ಷಿಸಿ Running.

ಅಪ್ಲಿಕೇಶನ್ ನಿಯೋಜನೆ

ನಿಯೋಜನೆ ಆಜ್ಞೆ:

kubectl apply -f go-app.yaml

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

ಎಲ್ಲವೂ ಪ್ರಾರಂಭವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ:

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

ರೆಡಿಸ್ ರಾಜ್ಯವನ್ನು ಪ್ರವೇಶಿಸಲು ನಿರೀಕ್ಷಿಸಿ Running.

ಪ್ರಮೀತಿಯಸ್ ಸರ್ವರ್ ಅನ್ನು ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ

ಪ್ರಮೀತಿಯಸ್ ಮ್ಯಾನಿಫೆಸ್ಟ್ ಬಳಸುತ್ತದೆ ಪ್ರಮೀತಿಯಸ್‌ಗಾಗಿ ಕುಬರ್ನೆಟ್ಸ್ ಸರ್ವಿಸ್ ಡಿಸ್ಕವರಿ. ಇದು ಸೇವಾ ಲೇಬಲ್‌ನ ಆಧಾರದ ಮೇಲೆ ಅಪ್ಲಿಕೇಶನ್ ಪಾಡ್‌ಗಳ ಡೈನಾಮಿಕ್ ಅನ್ವೇಷಣೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

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

ನಿಯೋಜಿಸಲು:

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

ಎಲ್ಲವೂ ಪ್ರಾರಂಭವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ:

kubectl get pods -l=app=prometheus-server

ಪ್ರಮೀತಿಯಸ್ ರಾಜ್ಯಕ್ಕೆ ಹೋಗಲು ನಿರೀಕ್ಷಿಸಿ Running.

ಬಳಸಿ kubectl port-forward ನಲ್ಲಿ ಪ್ರಮೀತಿಯಸ್ ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್ (ಅಥವಾ API ಸರ್ವರ್) ಅನ್ನು ಪ್ರವೇಶಿಸಲು http://localhost:9090.

kubectl port-forward service/prometheus-service 9090

KEDA ಆಟೋಸ್ಕೇಲಿಂಗ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ

ರಚಿಸಲು ಆಜ್ಞೆ ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

KEDA ಆಪರೇಟರ್ ಲಾಗ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ:

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

ಫಲಿತಾಂಶವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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"

ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಅಡಿಯಲ್ಲಿ ಪರಿಶೀಲಿಸಿ. ಒಂದು ನಿದರ್ಶನ ಚಾಲನೆಯಲ್ಲಿರಲೇಬೇಕು ಏಕೆಂದರೆ minReplicaCount 1 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ:

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

HPA ಸಂಪನ್ಮೂಲವನ್ನು ಯಶಸ್ವಿಯಾಗಿ ರಚಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ:

kubectl get hpa

ನೀವು ಅಂತಹದನ್ನು ನೋಡಬೇಕು:

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

ಆರೋಗ್ಯ ತಪಾಸಣೆ: ಅಪ್ಲಿಕೇಶನ್ ಪ್ರವೇಶ

ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ REST ಅಂತಿಮ ಬಿಂದುವನ್ನು ಪ್ರವೇಶಿಸಲು, ರನ್ ಮಾಡಿ:

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

ನೀವು ಈಗ ವಿಳಾಸವನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ Go ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು http://localhost:8080. ಇದನ್ನು ಮಾಡಲು, ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:

curl http://localhost:8080/test

ಫಲಿತಾಂಶವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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

ಈ ಹಂತದಲ್ಲಿ ರೆಡಿಸ್ ಅನ್ನು ಸಹ ಪರಿಶೀಲಿಸಿ. ಕೀಲಿಯನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ access_count 1ಕ್ಕೆ ಹೆಚ್ಚಿಸಲಾಗಿದೆ:

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

ಮೆಟ್ರಿಕ್ ಮೌಲ್ಯವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ http_requests ಅದೇ:

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

ಲೋಡ್ ಸೃಷ್ಟಿ

ನಾವು ಬಳಸುತ್ತೇವೆ ಹೇ - ಲೋಡ್ ಉತ್ಪಾದಿಸುವ ಉಪಯುಕ್ತತೆ:

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

ನೀವು ಉಪಯುಕ್ತತೆಯನ್ನು ಸಹ ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಲಿನಕ್ಸ್ ಅಥವಾ ವಿಂಡೋಸ್.

ಇದನ್ನು ಚಲಾಯಿಸಿ:

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

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಉಪಯುಕ್ತತೆಯು 200 ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ನೀವು ಇದನ್ನು Prometheus ಮೆಟ್ರಿಕ್ಸ್ ಹಾಗೂ 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

ನಿಜವಾದ ಮೆಟ್ರಿಕ್‌ನ ಮೌಲ್ಯವನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ (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"]}]}}

ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಿಜವಾದ ಫಲಿತಾಂಶ 1,686057971014493 ಮತ್ತು ಕ್ಷೇತ್ರದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ value. ಸ್ಕೇಲಿಂಗ್‌ಗೆ ಇದು ಸಾಕಾಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ನಾವು ಹೊಂದಿಸಿರುವ ಮಿತಿ 3 ಆಗಿದೆ.

ಹೆಚ್ಚು ಲೋಡ್!

ಹೊಸ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ, ಅಪ್ಲಿಕೇಶನ್ ಪಾಡ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ:

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

ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಲೋಡ್ ಅನ್ನು ಹೆಚ್ಚಿಸೋಣ:

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

ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ, HPA ನಿಯೋಜನೆಯನ್ನು ಸ್ಕೇಲಿಂಗ್ ಮಾಡುವುದನ್ನು ಮತ್ತು ಹೊಸ ಪಾಡ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ. ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ HPA ಪರಿಶೀಲಿಸಿ:

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

ಲೋಡ್ ಅಸಮಂಜಸವಾಗಿದ್ದರೆ, ನಿಯೋಜನೆಯು ಕೇವಲ ಒಂದು ಪಾಡ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಹಂತಕ್ಕೆ ಕಡಿಮೆಯಾಗುತ್ತದೆ. ನೀವು ನಿಜವಾದ ಮೆಟ್ರಿಕ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ಬಯಸಿದರೆ (PromQL ಪ್ರಶ್ನೆಯಿಂದ ಹಿಂತಿರುಗಿಸಲಾಗಿದೆ), ನಂತರ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ:

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

ತೀರ್ಮಾನಕ್ಕೆ

ಬಾಹ್ಯ ಮೆಟ್ರಿಕ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಆಧರಿಸಿ ನಿಮ್ಮ ಕುಬರ್ನೆಟ್ಸ್ ನಿಯೋಜನೆಗಳನ್ನು (ಶೂನ್ಯಕ್ಕೆ/ನಿಂದ) ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳೆಯಲು KEDA ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪ್ರೊಮೆಥಿಯಸ್ ಮೆಟ್ರಿಕ್ಸ್, ರೆಡಿಸ್‌ನಲ್ಲಿ ಸರತಿ ಉದ್ದ, ಕಾಫ್ಕಾ ವಿಷಯದಲ್ಲಿ ಗ್ರಾಹಕರ ಲೇಟೆನ್ಸಿ ಆಧರಿಸಿ.

KEDA ಬಾಹ್ಯ ಮೂಲದೊಂದಿಗೆ ಸಂಯೋಜನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಮೆಟ್ರಿಕ್ಸ್ ಸರ್ವರ್ ಮೂಲಕ ಹಾರಿಜಾಂಟಲ್ ಪಾಡ್ ಆಟೋಸ್ಕೇಲರ್‌ಗೆ ಅದರ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಅದೃಷ್ಟ!

ಇನ್ನೇನು ಓದಬೇಕು:

ಮೂಲ: www.habr.com

Prometheus ಮತ್ತು KEDA ಬಳಸಿಕೊಂಡು ಆಟೋಸ್ಕೇಲಿಂಗ್ ಕುಬರ್ನೆಟ್ಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು