🥇Prometheus සහ KEDA භාවිතා කරමින් Kubernetes යෙදුම් ස්වයංක්‍රීයකරණය

Cimuanos විසින් Balloon Man

වලාකුළු යෙදුම් සඳහා පරිමාණය ප්‍රධාන අවශ්‍යතාවයකි. Kubernetes සමඟින්, යෙදුමක් පරිමාණය කිරීම සුදුසු යෙදවීම සඳහා අනුරූ ගණන වැඩි කිරීම තරම් සරල ය. ReplicaSet - නමුත් එය අතින් ක්‍රියාවලියකි.

Kubernetes යෙදුම් ස්වයංක්‍රීයව පරිමාණය කිරීමට ඉඩ දෙයි (එනම් යෙදවීමක ඇති Pods හෝ ReplicaSet) Horizontal Pod Autoscaler පිරිවිතර භාවිතා කරමින් ප්‍රකාශන ආකාරයෙන්. ස්වයංක්‍රීය පරිමාණය සඳහා පෙරනිමි නිර්ණායකය CPU භාවිත ප්‍රමිතික (සම්පත් ප්‍රමිතික) වේ, නමුත් ඔබට අභිරුචි සහ බාහිරව සපයන ලද ප්‍රමිතික ඒකාබද්ධ කළ හැක.

කණ්ඩායම Mail.ru වෙතින් Kubernetes aaS Kubernetes යෙදුමක් ස්වයංක්‍රීයව පරිමාණය කිරීම සඳහා බාහිර ප්‍රමිතික භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ ලිපියක් පරිවර්තනය කරන ලදී. සෑම දෙයක්ම ක්‍රියා කරන ආකාරය පෙන්වීමට, කතුවරයා Prometheus භාවිතයෙන් එකතු කරන HTTP ප්‍රවේශ ඉල්ලීම් ප්‍රමිතික භාවිතා කරයි.

කරල්වල තිරස් ස්වයං පරිමාණය වෙනුවට, Kubernetes Event Driven Autoscaling (KEDA) භාවිතා කරනු ලැබේ, විවෘත මූලාශ්‍ර Kubernetes ක්රියාකරු. සිදුවීම් මත පදනම් වූ වැඩ බර සඳහා බාධාවකින් තොරව ස්වයංක්‍රීය පරිමාණය (ශුන්‍යයට/සිට ඇතුළුව) සැපයීම සඳහා එය දේශීයව Horizontal Pod Autoscaler සමඟ ඒකාබද්ධ වේ. කේතය ලබා ගත හැක GitHub.

පද්ධතිය පිළිබඳ කෙටි දළ විශ්ලේෂණය

රූප සටහන සෑම දෙයක්ම ක්‍රියාත්මක වන ආකාරය පිළිබඳ කෙටි විස්තරයක් පෙන්වයි:

යෙදුම ප්‍රොමිතියස් ආකෘතියෙන් HTTP පහර ගණන් කිරීමේ ප්‍රමිතික සපයයි.
Prometheus මෙම මිතික එකතු කිරීමට වින්‍යාස කර ඇත.
KEDA හි Prometheus පරිමාණකය HTTP පහර ගණන මත පදනම්ව යෙදුම ස්වයංක්‍රීයව පරිමාණය කිරීමට වින්‍යාස කර ඇත.

දැන් මම ඔබට එක් එක් අංගයන් ගැන විස්තරාත්මකව කියන්නම්.

KEDA සහ Prometheus

Prometheus යනු විවෘත කේත පද්ධති නිරීක්ෂණ සහ අනතුරු ඇඟවීමේ මෙවලම් කට්ටලයකි වලාකුළු ස්වදේශීය පරිගණක පදනම. විවිධ මූලාශ්‍රවලින් ප්‍රමිතික එකතු කර ඒවා කාල ශ්‍රේණි දත්ත ලෙස ගබඩා කරයි. ඔබට භාවිතා කළ හැකි දත්ත දෘශ්‍යමාන කිරීමට ග්‍රැෆනා හෝ Kubernetes API සමඟ වැඩ කරන වෙනත් දෘශ්‍යකරණ මෙවලම්.

KEDA ස්කේලර් සංකල්පයට සහය දක්වයි - එය KEDA සහ බාහිර පද්ධතිය අතර පාලමක් ලෙස ක්‍රියා කරයි. පරිමාණ ක්‍රියාත්මක කිරීම එක් එක් ඉලක්ක පද්ධතියට විශේෂිත වන අතර එයින් දත්ත උපුටා ගනී. KEDA පසුව ස්වයංක්‍රීය පරිමාණය පාලනය කිරීමට ඒවා භාවිතා කරයි.

ස්කේලර් බහු දත්ත මූලාශ්‍ර සඳහා සහය දක්වයි, උදාහරණයක් ලෙස, Kafka, Redis, Prometheus. එනම්, Prometheus metrics නිර්ණායක ලෙස භාවිතා කරමින් Kubernetes යෙදවීම් ස්වයංක්‍රීයව පරිමාණය කිරීමට KEDA භාවිතා කළ හැක.

පරීක්ෂණ යෙදුම

Golang පරීක්ෂණ යෙදුම HTTP හරහා ප්‍රවේශය සපයන අතර වැදගත් කාර්යයන් දෙකක් ඉටු කරයි:

ප්‍රොමිතියස් ගෝ සේවාලාභී පුස්තකාලය යෙදුම උපයෝගි කර ගැනීමට සහ පහර ගණන අඩංගු http_requests මෙට්‍රික් සැපයීමට භාවිත කරයි. Prometheus මෙට්‍රික්ස් ලබා ගත හැකි අන්ත ලක්ෂ්‍යය URI හි පිහිටා ඇත /metrics.
```
var httpRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
       Name: "http_requests",
       Help: "number of http requests",
   })
```

ඉල්ලීමකට ප්රතිචාරයක් වශයෙන් GET යෙදුම යතුරේ අගය වැඩි කරයි (access_count) රෙඩිස් හි. මෙය HTTP හසුරුවක කොටසක් ලෙස කාර්යය කිරීමට පහසු ක්‍රමයක් වන අතර Prometheus metrics ද පරීක්ෂා කරන්න. මෙට්රික් අගය අගයට සමාන විය යුතුය 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)
   }

යෙදුම Kubernetes වෙත යොදවා ඇත Deployment. සේවාවක් ද නිර්මාණය වේ ClusterIP, එය Prometheus සේවාදායකයට යෙදුම් ප්‍රමිතික ලබා ගැනීමට ඉඩ සලසයි.

මෙහි යෙදුම සඳහා යෙදවීමේ මැනිෆෙස්ටය.

Prometheus සේවාදායකය

Prometheus යෙදවීමේ ප්‍රකාශනය සමන්විත වන්නේ:

ConfigMap - Prometheus config එක මාරු කිරීමට;
Deployment - ප්‍රොමිතියස් කුබර්නෙටස් පොකුරකට යෙදවීම සඳහා;
ClusterIP - UI Prometheus වෙත ප්රවේශය සඳහා සේවාව;
ClusterRole, ClusterRoleBinding и ServiceAccount - Kubernetes හි සේවා ස්වයංක්‍රීයව හඳුනාගැනීම සඳහා (ස්වයං-සොයාගැනීම).

මෙහි Prometheus ධාවනය කිරීම සඳහා ප්‍රකාශිතය.

KEDA Prometheus ScaledObject

පරිමාණය KEDA සහ මෙට්‍රික් ලබා ගත යුතු බාහිර පද්ධතිය අතර පාලමක් ලෙස ක්‍රියා කරයි. ScaledObject මෙම අවස්ථාවෙහිදී Prometheus සිදුවීම් මූලාශ්‍රය සමඟ යෙදවීම සමමුහුර්ත කිරීමට යෙදවිය යුතු අභිරුචි සම්පතකි.

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. Prometheus සේවාදායක ලිපිනය මෙට්‍රික් නම, එළිපත්ත සහ සමඟ සඳහන් කර ඇත PromQL විමසුම, භාවිතා කරනු ඇත. PromQL විමසුම - sum(rate(http_requests[2m])).
අනුව pollingInterval,KEDA සෑම තත්පර පහළොවකට වරක් Prometheus ගෙන් ඉලක්කයක් ඉල්ලා සිටී. අවම වශයෙන් එකක් යටතේ (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 දක්වා නම්, කරල් ගණන හතරකි.

දැන් අපි එය පිහිටුවීමට උත්සාහ කරමු!

පෙර සැකසුම

ඔබට අවශ්‍ය වන්නේ Kubernetes පොකුරක් සහ වින්‍යාස කළ උපයෝගීතාවයක් පමණි 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/

සකසන්න kubectlKubernetes පොකුරට පිවිසීමට.

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 Operator ආරම්භ කිරීමට සහ වෙත යාමට රැඳී සිටින්න Running State. ඊට පස්සේ, දිගටම කරගෙන යන්න.

Helm භාවිතයෙන් Redis ස්ථාපනය කිරීම

ඔබ Helm ස්ථාපනය කර නොමැති නම්, මෙය භාවිතා කරන්න නායකත්වය. Mac මත ස්ථාපනය කිරීමට විධානය:

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

helm init දේශීය විධාන රේඛා අතුරුමුහුණත ආරම්භ කර ස්ථාපනය කරයි Tiller Kubernetes පොකුරට.

kubectl get pods -n kube-system | grep tiller

ටිලර් පොඩ් එක ධාවන තත්ත්වයට ඇතුළු වන තෙක් රැඳී සිටින්න.

පරිවර්තකයාගේ සටහන: කර්තෘ Helm@2 භාවිතා කරයි, එයට Tiller සේවාදායක සංරචකය ස්ථාපනය කිරීමට අවශ්‍ය වේ. දැන් Helm@3 අදාලයි, ඒකට server part එකක් ඕන නෑ.

Helm ස්ථාපනය කිරීමෙන් පසු, Redis ආරම්භ කිරීමට එක් විධානයක් ප්රමාණවත්ය:

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

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

Redis රාජ්‍යයට ඇතුළු වන තෙක් රැඳී සිටින්න Running.

Prometheus සේවාදායකයක් යෙදවීම

ප්‍රොමිතියස් මැනිෆෙස්ටය භාවිතා කරයි Prometheus සඳහා Kubernetes සේවා සොයාගැනීම. එය සේවා ලේබලය මත පදනම්ව යෙදුම් කරල් ගතික සොයා ගැනීමට ඉඩ සලසයි.

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 Prometheus පරිශීලක අතුරුමුහුණත (හෝ 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

මෙම අවස්ථාවේදී Redis ද පරීක්ෂා කරන්න. යතුර බව ඔබට පෙනෙනු ඇත 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

ඔබට උපයෝගීතාව බාගත කළ හැකිය ලිනක්ස් හෝ හි Windows සඳහා.

එය ධාවනය කරන්න:

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

පෙරනිමියෙන්, උපයෝගීතාව ඉල්ලීම් 200 ක් යවයි. ඔබට මෙය Prometheus metrics මෙන්ම 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

නිගමනය

බාහිර ප්‍රමිතික වලින් ලැබෙන දත්ත මත පදනම්ව ඔබගේ Kubernetes යෙදවීම් (ශුන්‍යයට/සිට) ස්වයංක්‍රීයව පරිමාණය කිරීමට KEDA ඔබට ඉඩ සලසයි. උදාහරණයක් ලෙස, Prometheus metrics මත පදනම්ව, Redis හි පෝලිම් දිග, Kafka මාතෘකාවේ පාරිභෝගික ප්‍රමාදය.

KEDA බාහිර මූලාශ්‍රයක් සමඟ ඒකාබද්ධ වන අතර Metrics Server හරහා Horizontal Pod Autoscaler වෙත එහි ප්‍රමිතික සපයයි.

සුබ පැතුම්!

තවත් කියවිය යුතු දේ:

මූලාශ්රය: www.habr.com

Prometheus සහ KEDA භාවිතයෙන් Kubernetes යෙදුම් ස්වයංක්‍රීය පරිමාණය කිරීම

පද්ධතිය පිළිබඳ කෙටි දළ විශ්ලේෂණය

KEDA සහ Prometheus

පරීක්ෂණ යෙදුම

Prometheus සේවාදායකය

KEDA Prometheus ScaledObject

ස්වයං පරිමාණය තුළ ඇති මැජික්

පෙර සැකසුම

KEDA ස්ථාපනය

Helm භාවිතයෙන් Redis ස්ථාපනය කිරීම

යෙදුම් යෙදවීම

Prometheus සේවාදායකයක් යෙදවීම

KEDA ස්වයං පරිමාණ වින්‍යාසය යෙදවීම

සෞඛ්‍ය පරීක්ෂාව: යෙදුම් ප්‍රවේශය

පැටවීම නිර්මාණය කිරීම

වැඩි බරක්!

පිරිසිදු කිරීම

නිගමනය

අදහස් එක් කරන්න

Prometheus සහ KEDA භාවිතයෙන් Kubernetes යෙදුම් ස්වයංක්‍රීය පරිමාණය කිරීම

පද්ධතිය පිළිබඳ කෙටි දළ විශ්ලේෂණය

KEDA සහ Prometheus

පරීක්ෂණ යෙදුම

Prometheus සේවාදායකය

KEDA Prometheus ScaledObject

ස්වයං පරිමාණය තුළ ඇති මැජික්

පෙර සැකසුම

KEDA ස්ථාපනය

Helm භාවිතයෙන් Redis ස්ථාපනය කිරීම

යෙදුම් යෙදවීම

Prometheus සේවාදායකයක් යෙදවීම

KEDA ස්වයං පරිමාණ වින්‍යාසය යෙදවීම

සෞඛ්‍ය පරීක්ෂාව: යෙදුම් ප්‍රවේශය

පැටවීම නිර්මාණය කිරීම

වැඩි බරක්!

පිරිසිදු කිරීම

නිගමනය

අදහස් එක් කරන්න ඊ-මේල් මගින් පිලිතුරු දෙන්න අවලංගු

අදහස් එක් කරන්න