ਪ੍ਰੋਮੀਥੀਅਸ ਅਤੇ ਕੇਡਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕੁਬਰਨੇਟਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਆਟੋਸਕੇਲਿੰਗ ਕਰਨਾ

ਸਿਮੁਆਨੋਸ ਦੁਆਰਾ ਬੈਲੂਨ ਮੈਨ

ਕਲਾਉਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਮਾਪਯੋਗਤਾ ਇੱਕ ਮੁੱਖ ਲੋੜ ਹੈ। ਕੁਬਰਨੇਟਸ ਦੇ ਨਾਲ, ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਕੇਲ ਕਰਨਾ ਉਚਿਤ ਤੈਨਾਤੀ ਲਈ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦੀ ਗਿਣਤੀ ਵਧਾਉਣ ਜਿੰਨਾ ਸੌਖਾ ਹੈ ਜਾਂ ReplicaSet - ਪਰ ਇਹ ਇੱਕ ਦਸਤੀ ਪ੍ਰਕਿਰਿਆ ਹੈ।

ਕੁਬਰਨੇਟਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸਕੇਲ ਕੀਤੇ ਜਾਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਤੈਨਾਤੀ ਵਿੱਚ ਪੌਡ ਜਾਂ ReplicaSet) ਹਰੀਜ਼ਟਲ ਪੋਡ ਆਟੋਸਕੇਲਰ ਨਿਰਧਾਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਘੋਸ਼ਣਾਤਮਕ ਢੰਗ ਨਾਲ। ਆਟੋਮੈਟਿਕ ਸਕੇਲਿੰਗ ਲਈ ਡਿਫੌਲਟ ਮਾਪਦੰਡ CPU ਵਰਤੋਂ ਮੈਟ੍ਰਿਕਸ (ਸਰੋਤ ਮੈਟ੍ਰਿਕਸ) ਹੈ, ਪਰ ਤੁਸੀਂ ਕਸਟਮ ਅਤੇ ਬਾਹਰੀ ਤੌਰ 'ਤੇ ਪ੍ਰਦਾਨ ਕੀਤੇ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰ ਸਕਦੇ ਹੋ।

ਦੀ ਟੀਮ Mail.ru ਤੋਂ Kubernetes aaS ਕੁਬਰਨੇਟਸ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸਕੇਲ ਕਰਨ ਲਈ ਬਾਹਰੀ ਮੈਟ੍ਰਿਕਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਤਰੀਕੇ ਬਾਰੇ ਇੱਕ ਲੇਖ ਦਾ ਅਨੁਵਾਦ ਕੀਤਾ। ਇਹ ਦਿਖਾਉਣ ਲਈ ਕਿ ਸਭ ਕੁਝ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਲੇਖਕ HTTP ਪਹੁੰਚ ਬੇਨਤੀ ਮੈਟ੍ਰਿਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਪ੍ਰੋਮੀਥੀਅਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਕੱਤਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਪੌਡਾਂ ਦੀ ਹਰੀਜੱਟਲ ਆਟੋਸਕੇਲਿੰਗ ਦੀ ਬਜਾਏ, ਕੁਬਰਨੇਟਸ ਇਵੈਂਟ ਡਰਾਈਵ ਆਟੋਸਕੇਲਿੰਗ (ਕੇਈਡੀਏ) ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇੱਕ ਓਪਨ ਸੋਰਸ ਕੁਬਰਨੇਟਸ ਆਪਰੇਟਰ। ਇਹ ਇਵੈਂਟ-ਸੰਚਾਲਿਤ ਵਰਕਲੋਡਾਂ ਲਈ ਸਹਿਜ ਆਟੋਸਕੇਲਿੰਗ (ਜ਼ੀਰੋ ਤੋਂ/ਜ਼ੀਰੋ ਸਮੇਤ) ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਹਰੀਜ਼ੋਂਟਲ ਪੋਡ ਆਟੋਸਕੇਲਰ ਨਾਲ ਮੂਲ ਰੂਪ ਵਿੱਚ ਏਕੀਕ੍ਰਿਤ ਹੈ। ਕੋਡ 'ਤੇ ਉਪਲਬਧ ਹੈ GitHub.

ਸਿਸਟਮ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

ਚਿੱਤਰ ਇਸ ਗੱਲ ਦਾ ਸੰਖੇਪ ਵਰਣਨ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਸਭ ਕੁਝ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:

1. ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰੋਮੀਥੀਅਸ ਫਾਰਮੈਟ ਵਿੱਚ HTTP ਹਿੱਟ ਕਾਉਂਟ ਮੈਟ੍ਰਿਕਸ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।
2. ਪ੍ਰੋਮੀਥੀਅਸ ਨੂੰ ਇਹਨਾਂ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।
3. ਕੇਡਾ ਵਿੱਚ ਪ੍ਰੋਮੀਥੀਅਸ ਸਕੇਲਰ ਨੂੰ HTTP ਹਿੱਟਾਂ ਦੀ ਸੰਖਿਆ ਦੇ ਅਧਾਰ ਤੇ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਆਪਣੇ ਆਪ ਸਕੇਲ ਕਰਨ ਲਈ ਕੌਂਫਿਗਰ ਕੀਤਾ ਗਿਆ ਹੈ।

ਹੁਣ ਮੈਂ ਤੁਹਾਨੂੰ ਹਰੇਕ ਤੱਤ ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਦੱਸਾਂਗਾ।

ਕੇਡਾ ਅਤੇ ਪ੍ਰੋਮੀਥੀਅਸ

ਪ੍ਰੋਮੀਥੀਅਸ ਇੱਕ ਓਪਨ ਸੋਰਸ ਸਿਸਟਮ ਨਿਗਰਾਨੀ ਅਤੇ ਚੇਤਾਵਨੀ ਟੂਲਕਿੱਟ ਹੈ, ਹਿੱਸਾ ਕਲਾਉਡ ਨੇਟਿਵ ਕੰਪਿ Compਟਿੰਗ ਫਾਉਂਡੇਸ਼ਨ. ਵੱਖ-ਵੱਖ ਸਰੋਤਾਂ ਤੋਂ ਮੈਟ੍ਰਿਕਸ ਇਕੱਤਰ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਮਾਂ ਲੜੀ ਦੇ ਡੇਟਾ ਵਜੋਂ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਡੇਟਾ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈ ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ ਗ੍ਰਾਫਨਾ ਜਾਂ ਹੋਰ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਟੂਲ ਜੋ ਕਿ ਕੁਬਰਨੇਟਸ API ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ।

ਕੇਡਾ ਸਕੇਲਰ ਦੀ ਧਾਰਨਾ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ - ਇਹ ਕੇਡਾ ਅਤੇ ਬਾਹਰੀ ਪ੍ਰਣਾਲੀ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਪੁਲ ਦਾ ਕੰਮ ਕਰਦਾ ਹੈ। ਸਕੇਲਰ ਲਾਗੂ ਕਰਨਾ ਹਰੇਕ ਟਾਰਗੇਟ ਸਿਸਟਮ ਲਈ ਵਿਸ਼ੇਸ਼ ਹੈ ਅਤੇ ਇਸ ਤੋਂ ਡੇਟਾ ਕੱਢਦਾ ਹੈ। ਕੇਡਾ ਫਿਰ ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਆਟੋਮੈਟਿਕ ਸਕੇਲਿੰਗ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਕਰਦਾ ਹੈ।

ਸਕੇਲਰ ਕਈ ਡਾਟਾ ਸਰੋਤਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ, ਕਾਫਕਾ, ਰੇਡਿਸ, ਪ੍ਰੋਮੀਥੀਅਸ। ਭਾਵ, KEDA ਨੂੰ ਮਾਪਦੰਡ ਵਜੋਂ ਪ੍ਰੋਮੀਥੀਅਸ ਮੈਟ੍ਰਿਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕੁਬਰਨੇਟਸ ਤੈਨਾਤੀਆਂ ਨੂੰ ਆਪਣੇ ਆਪ ਸਕੇਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਟੈਸਟ ਐਪਲੀਕੇਸ਼ਨ

ਗੋਲੰਗ ਟੈਸਟ ਐਪਲੀਕੇਸ਼ਨ HTTP ਦੁਆਰਾ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ ਅਤੇ ਦੋ ਮਹੱਤਵਪੂਰਨ ਫੰਕਸ਼ਨ ਕਰਦੀ ਹੈ:

1. ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੰਸਟਰੂਮੈਂਟ ਕਰਨ ਅਤੇ http_requests ਮੈਟ੍ਰਿਕ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ Prometheus Go ਕਲਾਇੰਟ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਹਿੱਟ ਗਿਣਤੀ ਹੁੰਦੀ ਹੈ। ਅੰਤਮ ਬਿੰਦੂ ਜਿੱਥੇ ਪ੍ਰੋਮੀਥੀਅਸ ਮੈਟ੍ਰਿਕਸ ਉਪਲਬਧ ਹਨ URI 'ਤੇ ਸਥਿਤ ਹੈ /metrics.

   var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
          Name: "http_requests",
          Help: "number of http requests",
      })
   

2. ਇੱਕ ਬੇਨਤੀ ਦੇ ਜਵਾਬ ਵਿੱਚ GET ਐਪਲੀਕੇਸ਼ਨ ਕੁੰਜੀ ਦੇ ਮੁੱਲ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ (access_count) Redis ਵਿੱਚ. ਇਹ ਇੱਕ HTTP ਹੈਂਡਲਰ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਕੰਮ ਕਰਨ ਦਾ ਇੱਕ ਆਸਾਨ ਤਰੀਕਾ ਹੈ ਅਤੇ ਪ੍ਰੋਮੀਥੀਅਸ ਮੈਟ੍ਰਿਕਸ ਦੀ ਜਾਂਚ ਵੀ ਕਰਦਾ ਹੈ। ਮੀਟ੍ਰਿਕ ਮੁੱਲ ਮੁੱਲ ਦੇ ਸਮਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ 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)
      }
   

ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੁਬਰਨੇਟਸ ਦੁਆਰਾ ਤੈਨਾਤ ਕੀਤਾ ਗਿਆ ਹੈ Deployment. ਇੱਕ ਸੇਵਾ ਵੀ ਬਣਾਈ ਗਈ ਹੈ ClusterIP, ਇਹ ਪ੍ਰੋਮੀਥੀਅਸ ਸਰਵਰ ਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਮੈਟ੍ਰਿਕਸ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਇੱਥੇ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਤੈਨਾਤੀ ਮੈਨੀਫੈਸਟ.

ਪ੍ਰੋਮੀਥੀਅਸ ਸਰਵਰ

ਪ੍ਰੋਮੀਥੀਅਸ ਡਿਪਲਾਇਮੈਂਟ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ConfigMap - Prometheus ਸੰਰਚਨਾ ਨੂੰ ਤਬਦੀਲ ਕਰਨ ਲਈ;
• Deployment - ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਵਿੱਚ ਪ੍ਰੋਮੀਥੀਅਸ ਨੂੰ ਤਾਇਨਾਤ ਕਰਨ ਲਈ;
• ClusterIP - UI ਪ੍ਰੋਮੀਥੀਅਸ ਤੱਕ ਪਹੁੰਚ ਲਈ ਸੇਵਾ;
• ClusterRole, ClusterRoleBinding и ServiceAccount - ਕੁਬਰਨੇਟਸ (ਆਟੋ-ਡਿਸਕਵਰੀ) ਵਿੱਚ ਸੇਵਾਵਾਂ ਦੀ ਸਵੈ-ਖੋਜ ਲਈ।

ਇੱਥੇ Prometheus ਨੂੰ ਚਲਾਉਣ ਲਈ ਪ੍ਰਗਟ.

ਕੇਡਾ ਪ੍ਰੋਮੀਥੀਅਸ ਸਕੇਲਡ ਆਬਜੈਕਟ

ਸਕੇਲਰ ਕੇਡਾ ਅਤੇ ਬਾਹਰੀ ਪ੍ਰਣਾਲੀ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਪੁਲ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿਸ ਤੋਂ ਮੈਟ੍ਰਿਕਸ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। 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]))

ਹੇਠਾਂ ਦਿੱਤੇ ਨੁਕਤਿਆਂ 'ਤੇ ਗੌਰ ਕਰੋ:

1. ਉਹ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ Deployment ਨਾਮ ਨਾਲ go-prom-app.
2. ਟਰਿੱਗਰ ਕਿਸਮ - Prometheus. ਪ੍ਰੋਮੀਥੀਅਸ ਸਰਵਰ ਪਤੇ ਦਾ ਜ਼ਿਕਰ ਮੀਟ੍ਰਿਕ ਨਾਮ, ਥ੍ਰੈਸ਼ਹੋਲਡ ਅਤੇ ਨਾਲ ਕੀਤਾ ਗਿਆ ਹੈ PromQL ਪੁੱਛਗਿੱਛ, ਜਿਸ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਵੇਗੀ। PromQL ਪੁੱਛਗਿੱਛ - sum(rate(http_requests[2m])).
3. ਦੇ ਅਨੁਸਾਰ pollingInterval, ਕੇਡਾ ਹਰ ਪੰਦਰਾਂ ਸਕਿੰਟਾਂ ਵਿੱਚ ਪ੍ਰੋਮੀਥੀਅਸ ਤੋਂ ਇੱਕ ਟੀਚੇ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ। ਘੱਟੋ-ਘੱਟ ਇੱਕ ਅਧੀਨ (minReplicaCount), ਅਤੇ ਪੌਡਾਂ ਦੀ ਅਧਿਕਤਮ ਸੰਖਿਆ ਵੱਧ ਨਹੀਂ ਹੈ maxReplicaCount (ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ - ਦਸ).

ਇੰਸਟਾਲ ਕਰ ਸਕਦੇ ਹਨ minReplicaCount ਜ਼ੀਰੋ ਦੇ ਬਰਾਬਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਕੇਡਾ ਜ਼ੀਰੋ-ਟੂ-ਵਨ ਤੈਨਾਤੀ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਅੱਗੇ ਆਟੋਮੈਟਿਕ ਸਕੇਲਿੰਗ ਲਈ ਐਚਪੀਏ ਦਾ ਪਰਦਾਫਾਸ਼ ਕਰਦਾ ਹੈ। ਉਲਟਾ ਕ੍ਰਮ ਵੀ ਸੰਭਵ ਹੈ, ਯਾਨੀ ਇੱਕ ਤੋਂ ਜ਼ੀਰੋ ਤੱਕ ਸਕੇਲ ਕਰਨਾ। ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਜ਼ੀਰੋ ਦੀ ਚੋਣ ਨਹੀਂ ਕੀਤੀ ਕਿਉਂਕਿ ਇਹ ਇੱਕ HTTP ਸੇਵਾ ਹੈ ਨਾ ਕਿ ਇੱਕ ਆਨ-ਡਿਮਾਂਡ ਸਿਸਟਮ।

ਆਟੋਸਕੇਲਿੰਗ ਦੇ ਅੰਦਰ ਦਾ ਜਾਦੂ

ਥ੍ਰੈਸ਼ਹੋਲਡ ਨੂੰ ਤੈਨਾਤੀ ਨੂੰ ਸਕੇਲ ਕਰਨ ਲਈ ਇੱਕ ਟਰਿੱਗਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਸਾਡੀ ਉਦਾਹਰਨ ਵਿੱਚ, PromQL ਪੁੱਛਗਿੱਛ sum(rate (http_requests [2m])) ਪਿਛਲੇ ਦੋ ਮਿੰਟਾਂ ਵਿੱਚ ਮਾਪੀ ਗਈ ਸਮੁੱਚੀ HTTP ਬੇਨਤੀ ਦਰ (ਪ੍ਰਤੀ ਸਕਿੰਟ ਬੇਨਤੀਆਂ) ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਕਿਉਂਕਿ ਥ੍ਰੈਸ਼ਹੋਲਡ ਮੁੱਲ ਤਿੰਨ ਹੈ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮੁੱਲ ਦੇ ਅਧੀਨ ਇੱਕ ਹੋਵੇਗਾ sum(rate (http_requests [2m])) ਤਿੰਨ ਤੋਂ ਘੱਟ। ਜੇਕਰ ਮੁੱਲ ਵਧਦਾ ਹੈ, ਤਾਂ ਹਰ ਵਾਰ ਇੱਕ ਵਾਧੂ ਉਪ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ sum(rate (http_requests [2m])) ਤਿੰਨ ਨਾਲ ਵਧਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਮੁੱਲ 12 ਤੋਂ 14 ਤੱਕ ਹੈ, ਤਾਂ ਪੌਡਾਂ ਦੀ ਗਿਣਤੀ ਚਾਰ ਹੈ।

ਹੁਣ ਇਸ ਨੂੰ ਸੈੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ!

ਪ੍ਰੀ-ਸੈਟਿੰਗ

ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਅਤੇ ਇੱਕ ਸੰਰਚਿਤ ਉਪਯੋਗਤਾ ਦੀ ਲੋੜ ਹੈ kubectl. ਇਹ ਉਦਾਹਰਨ ਇੱਕ ਕਲੱਸਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ minikube, ਪਰ ਤੁਸੀਂ ਕੋਈ ਹੋਰ ਲੈ ਸਕਦੇ ਹੋ। ਉੱਥੇ ਇੱਕ ਕਲੱਸਟਰ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਹੈ ਅਗਵਾਈ.

ਮੈਕ 'ਤੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਸਥਾਪਿਤ ਕਰੋ:

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ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ।

ਮੈਕ 'ਤੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਸਥਾਪਿਤ ਕਰੋ:

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

ਕੇਡਾ ਸਥਾਪਨਾ

ਤੁਸੀਂ ਕੇਡਾ ਨੂੰ ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ ਤੈਨਾਤ ਕਰ ਸਕਦੇ ਹੋ, ਉਹ ਸੂਚੀਬੱਧ ਹਨ ਦਸਤਾਵੇਜ਼. ਮੈਂ ਮੋਨੋਲਿਥਿਕ YAML ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ/ਰਹੀ ਹਾਂ:

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

KEDA ਅਤੇ ਇਸਦੇ ਹਿੱਸੇ ਨਾਮ-ਸਥਾਨ ਵਿੱਚ ਸਥਾਪਿਤ ਕੀਤੇ ਗਏ ਹਨ keda. ਜਾਂਚ ਕਰਨ ਲਈ ਹੁਕਮ:

kubectl get pods -n 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 ਢੁਕਵਾਂ ਹੈ, ਇਸ ਨੂੰ ਸਰਵਰ ਭਾਗ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਹੈਲਮ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, Redis ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਕਮਾਂਡ ਕਾਫ਼ੀ ਹੈ:

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

ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ Redis ਸਫਲਤਾਪੂਰਵਕ ਸ਼ੁਰੂ ਹੋ ਗਿਆ ਹੈ:

kubectl get pods/redis-server-master-0

Redis ਦੇ ਰਾਜ ਵਿੱਚ ਜਾਣ ਦੀ ਉਡੀਕ ਕਰੋ 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

Redis ਦੇ ਰਾਜ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੋ 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

ਕੇਡਾ ਆਟੋਸਕੇਲਿੰਗ ਸੰਰਚਨਾ ਨੂੰ ਤੈਨਾਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਬਣਾਉਣ ਲਈ ਹੁਕਮ ScaledObject:

kubectl apply -f keda-prometheus-scaledobject.yaml

ਕੇਡਾ ਆਪਰੇਟਰ ਲੌਗਸ ਦੀ ਜਾਂਚ ਕਰੋ:

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

ਲੋਡ ਰਚਨਾ

ਅਸੀਂ ਇਸਤੇਮਾਲ ਕਰਾਂਗੇ Hey — ਲੋਡ ਪੈਦਾ ਕਰਨ ਲਈ ਉਪਯੋਗਤਾ:

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

ਲਈ ਉਪਯੋਗਤਾ ਨੂੰ ਵੀ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ ਲੀਨਕਸ ਜ Windows ਨੂੰ.

ਇਸਨੂੰ ਚਲਾਓ:

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

ਜੇਕਰ ਲੋਡ ਅਸੰਗਤ ਹੈ, ਤਾਂ ਤੈਨਾਤੀ ਨੂੰ ਉਸ ਬਿੰਦੂ ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ ਜਿੱਥੇ ਸਿਰਫ਼ ਇੱਕ ਪੌਡ ਚੱਲ ਰਿਹਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਅਸਲ ਮੈਟ੍ਰਿਕ ਦੀ ਜਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ (ਪ੍ਰੋਮਕਿਯੂਐਲ ਪੁੱਛਗਿੱਛ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਗਿਆ), ਤਾਂ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰੋ:

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

ਸਿੱਟਾ

ਕੇਡਾ ਤੁਹਾਨੂੰ ਬਾਹਰੀ ਮੈਟ੍ਰਿਕਸ ਦੇ ਡੇਟਾ ਦੇ ਆਧਾਰ 'ਤੇ ਆਪਣੇ ਕੁਬਰਨੇਟਸ ਤੈਨਾਤੀਆਂ (ਜ਼ੀਰੋ ਤੋਂ/ਸਿਫ਼ਰ ਤੱਕ) ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸਕੇਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਪ੍ਰੋਮੀਥੀਅਸ ਮੈਟ੍ਰਿਕਸ ਦੇ ਆਧਾਰ 'ਤੇ, ਰੈਡਿਸ ਵਿੱਚ ਕਤਾਰ ਦੀ ਲੰਬਾਈ, ਕਾਫਕਾ ਵਿਸ਼ੇ ਵਿੱਚ ਖਪਤਕਾਰ ਲੇਟੈਂਸੀ।

ਕੇਡਾ ਇੱਕ ਬਾਹਰੀ ਸਰੋਤ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਹੁੰਦਾ ਹੈ ਅਤੇ ਮੈਟ੍ਰਿਕਸ ਸਰਵਰ ਦੁਆਰਾ ਹਰੀਜ਼ੋਂਟਲ ਪੋਡ ਆਟੋਸਕੇਲਰ ਨੂੰ ਇਸਦੇ ਮੈਟ੍ਰਿਕਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਕਾਮਯਾਬੀਆਂ!

ਹੋਰ ਕੀ ਪੜ੍ਹਨਾ ਹੈ:

1. ਉਤਪਾਦਨ ਦੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੰਟੇਨਰਾਂ ਅਤੇ ਕੁਬਰਨੇਟਸ ਨੂੰ ਚਲਾਉਣ ਲਈ ਵਧੀਆ ਅਭਿਆਸ ਅਤੇ ਵਧੀਆ ਅਭਿਆਸ.
2. ਕੁਬਰਨੇਟਸ ਲਈ 90+ ਉਪਯੋਗੀ ਟੂਲ: ਤੈਨਾਤੀ, ਪ੍ਰਬੰਧਨ, ਨਿਗਰਾਨੀ, ਸੁਰੱਖਿਆ ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ.
3. ਟੈਲੀਗ੍ਰਾਮ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸਾਡਾ ਚੈਨਲ.

ਸਰੋਤ: www.habr.com