🥗 🤾 😚 कुबेरनेट्स: सिस्टम संसाधन प्रबंधन स्थापित करना इतना महत्वपूर्ण क्यों है? 🥐 🤚🏿 👨‍🏫

एक नियम के रूप में, इसके सही और स्थिर संचालन के लिए किसी भी आवेदन के लिए संसाधनों का एक समर्पित पूल प्रदान करने की आवश्यकता है। लेकिन क्या होगा यदि कई अनुप्रयोग एक ही समय में एक ही क्षमता पर काम करते हैं? उनमें से प्रत्येक के लिए न्यूनतम आवश्यक संसाधन कैसे प्रदान करें? मैं संसाधन खपत को कैसे सीमित कर सकता हूं? नोड्स के बीच लोड को सही ढंग से कैसे वितरित करें? आवेदन पर बढ़ते भार के मामले में क्षैतिज स्केलिंग के तंत्र को कैसे सुनिश्चित करें?

आपको सिस्टम में मौजूद बुनियादी प्रकार के संसाधनों के साथ शुरू करने की आवश्यकता है - बेशक, प्रोसेसर समय और रैम। K8s मेनिफेस्टों में, इन प्रकार के संसाधनों को निम्नलिखित इकाइयों में मापा जाता है:

सीपीयू - कोर में
रैम - बाइट्स में

इसके अलावा, प्रत्येक संसाधन के लिए दो प्रकार की आवश्यकताओं - अनुरोधों और सीमाओं को निर्धारित करने का अवसर है। अनुरोध - कंटेनर को चलाने के लिए नोड के नि: शुल्क संसाधनों (और चूल्हा पूरे) के लिए न्यूनतम आवश्यकताओं का वर्णन करता है, जबकि सीमाएं कंटेनर के लिए उपलब्ध संसाधनों पर एक सख्त सीमा निर्धारित करती हैं।

यह समझना महत्वपूर्ण है कि प्रकट में यह दोनों प्रकारों को स्पष्ट रूप से परिभाषित करने के लिए आवश्यक नहीं है, और व्यवहार निम्नानुसार होगा:

यदि केवल संसाधन की सीमा स्पष्ट रूप से निर्धारित की जाती है, तो इस संसाधन के लिए अनुरोध स्वचालित रूप से सीमा के बराबर मूल्य लेते हैं (इसे विवरण संस्थाओं को कॉल करके सत्यापित किया जा सकता है)। यानी वास्तव में, कंटेनर का संचालन उसी संसाधनों तक सीमित होगा जो इसे चलाने के लिए आवश्यक है।
यदि केवल अनुरोधों को किसी संसाधन के लिए स्पष्ट रूप से सेट किया जाता है, तो इस संसाधन के ऊपर कोई प्रतिबंध नहीं लगाए जाते हैं - अर्थात कंटेनर केवल नोड के संसाधनों द्वारा ही सीमित है।

संसाधन प्रबंधन को न केवल एक विशिष्ट कंटेनर के स्तर पर, बल्कि निम्नलिखित नाम का उपयोग करके नाम स्थान के स्तर पर भी कॉन्फ़िगर करना संभव है:

LimitRange - ns में कंटेनर / चूल्हा स्तर पर प्रतिबंध नीति का वर्णन करता है और कंटेनर / चूल्हा पर डिफ़ॉल्ट प्रतिबंधों का वर्णन करने के लिए आवश्यक है, साथ ही स्पष्ट रूप से वसा कंटेनर / चूल्हा (या इसके विपरीत) के निर्माण को रोकने के लिए, उनकी संख्या को सीमित करें और सीमाओं के भीतर मूल्यों में संभावित अंतर को निर्धारित करें। और अनुरोध
रिसोर्सक्वाट्स - एनएस में सभी कंटेनरों के लिए सामान्य रूप से प्रतिबंध नीति का वर्णन करते हैं और एक नियम के रूप में, पर्यावरण के बीच संसाधनों में अंतर करने के लिए उपयोग किया जाता है (उपयोगी जब वातावरण नोड्स के स्तर पर कठोरता से सीमांकित नहीं होते हैं)

निम्नलिखित ऐसे उदाहरण हैं जो संसाधन सीमाएँ निर्धारित करते हैं:

विशिष्ट कंटेनर स्तर पर:
```
containers: - name: app-nginx image: nginx resources: requests: memory: 1Gi limits: cpu: 200m 
```
यानी इस मामले में, nginx के साथ एक कंटेनर शुरू करने के लिए, आपको नोड पर कम से कम 1G ओपी और 0.2 सीपीयू की उपलब्धता की आवश्यकता होगी, जबकि अधिकतम कंटेनर 0.2 सीपीयू और नोड पर सभी उपलब्ध ओपी खा सकते हैं।
पूर्णांक स्तर ns पर:
```
 apiVersion: v1 kind: ResourceQuota metadata: name: nxs-test spec: hard: requests.cpu: 300m requests.memory: 1Gi limits.cpu: 700m limits.memory: 2Gi 
```
यानी डिफ़ॉल्ट ns में सभी अनुरोध कंटेनर का योग सीपीयू के लिए 300 मीटर और ओपी के लिए 1 जी से अधिक नहीं हो सकता है, और सीपीयू के लिए सभी सीमा का योग 700 मीटर और ओपी के लिए 2 जी है।
एनएस में कंटेनरों के लिए डिफ़ॉल्ट प्रतिबंध:
```
 apiVersion: v1 kind: LimitRange metadata: name: nxs-limit-per-container spec: limits: - type: Container defaultRequest: cpu: 100m memory: 1Gi default: cpu: 1 memory: 2Gi min: cpu: 50m memory: 500Mi max: cpu: 2 memory: 4Gi 
```
यानी सभी कंटेनरों के लिए डिफ़ॉल्ट नेमस्पेस में, डिफ़ॉल्ट रूप से, सीपीयू के लिए 100 मीटर और ओपी के लिए 1 जी, सीमा - 1 सीपीयू और 2 जी के लिए अनुरोध किया जाएगा। इसी समय, सीपीयू (50 मीटर <x <2) और रैम (500 एम <x <4 जी) के लिए अनुरोध / सीमा में संभावित मूल्यों पर प्रतिबंध भी स्थापित किया गया था।
एनएस चूल्हा स्तर पर सीमाएं:
```
 apiVersion: v1 kind: LimitRange metadata: name: nxs-limit-pod spec: limits: - type: Pod max: cpu: 4 memory: 1Gi 
```
यानी डिफ़ॉल्ट एनएस में प्रत्येक चूल्हा के लिए, 4 वीसीपीयू और 1 जी की सीमा निर्धारित की जाएगी।

अब मैं आपको बताना चाहूंगा कि इन प्रतिबंधों की स्थापना से हमें क्या फायदे हो सकते हैं।

नोड्स के बीच लोड संतुलन का तंत्र

जैसा कि आप जानते हैं, k8 घटक जैसे कि अनुसूचक , जो एक निश्चित एल्गोरिथ्म के अनुसार काम करता है, नोड्स पर चूल्हा के वितरण के लिए जिम्मेदार है। चलाने के लिए इष्टतम नोड चुनने की प्रक्रिया में यह एल्गोरिथ्म दो चरणों से गुजरता है:

छानने
श्रेणी

यानी वर्णित नीति के अनुसार, नोड्स को शुरू में चुना जाता है, जिस पर एक चूल्हा विधेयकों के सेट के आधार पर लॉन्च किया जा सकता है (जिसमें नोड में चूल्हा चलाने के लिए पर्याप्त संसाधन हैं - PodFitsResources), और फिर प्राथमिकता के अनुसार इनमें से प्रत्येक नोड के लिए अंक प्रदान किए जाते हैं (सहित) नोड के पास जितने अधिक मुक्त संसाधन हैं - उतने अधिक अंक - LeastResourceAllocation / LeastRequestedPriority / BalancedResourceAllocation) और इसे अधिकांश बिंदुओं के साथ नोड पर चलाया जाता है (यदि कई नोड एक बार में इस स्थिति को संतुष्ट करते हैं, तो एक यादृच्छिक एक का चयन किया जाता है)।

उसी समय, आपको यह समझने की आवश्यकता है कि अनुसूचक, नोड के उपलब्ध संसाधनों का मूल्यांकन करते समय, आदि में संग्रहीत डेटा पर ध्यान केंद्रित करता है - अर्थात। इस नोड पर चलने वाले प्रत्येक पॉड के अनुरोधित / सीमा संसाधन की मात्रा से, लेकिन संसाधनों की वास्तविक खपत से नहीं। यह जानकारी kubectl describe node $NODE कमांड के आउटपुट में प्राप्त की जा सकती है, उदाहरण के लिए:

 # kubectl describe nodes nxs-k8s-s1 .. Non-terminated Pods: (9 in total) Namespace Name CPU Requests CPU Limits Memory Requests Memory Limits AGE --------- ---- ------------ ---------- --------------- ------------- --- ingress-nginx nginx-ingress-controller-754b85bf44-qkt2t 0 (0%) 0 (0%) 0 (0%) 0 (0%) 233d kube-system kube-flannel-26bl4 150m (0%) 300m (1%) 64M (0%) 500M (1%) 233d kube-system kube-proxy-exporter-cb629 0 (0%) 0 (0%) 0 (0%) 0 (0%) 233d kube-system kube-proxy-x9fsc 0 (0%) 0 (0%) 0 (0%) 0 (0%) 233d kube-system nginx-proxy-k8s-worker-s1 25m (0%) 300m (1%) 32M (0%) 512M (1%) 233d nxs-monitoring alertmanager-main-1 100m (0%) 100m (0%) 425Mi (1%) 25Mi (0%) 233d nxs-logging filebeat-lmsmp 100m (0%) 0 (0%) 100Mi (0%) 200Mi (0%) 233d nxs-monitoring node-exporter-v4gdq 112m (0%) 122m (0%) 200Mi (0%) 220Mi (0%) 233d Allocated resources: (Total limits may be over 100 percent, ie, overcommitted.) Resource Requests Limits -------- -------- ------ cpu 487m (3%) 822m (5%) memory 15856217600 (2%) 749976320 (3%) ephemeral-storage 0 (0%) 0 (0%)

यहां हम सभी पॉड्स को एक विशेष नोड पर चल रहे हैं, साथ ही उन संसाधनों को देखते हैं जो प्रत्येक पॉड्स अनुरोध करते हैं। और यहां क्रोनजोब-क्रोन-ईवेंट्स-1573793820-xt6q9 पॉड शुरू करते समय शेड्यूलर लॉग दिखता है (यह जानकारी शेड्यूलर लॉग में प्रकट होती है जब स्टार्ट कमांड के तर्क में लॉगिंग के 10 वें स्तर को सेट करते हुए --v = 10):

चौड़ी गल

 I1115 07:57:21.637791 1 scheduling_queue.go:908] About to try and schedule pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 I1115 07:57:21.637804 1 scheduler.go:453] Attempting to schedule pod: nxs-stage/cronjob-cron-events-1573793820-xt6q9 I1115 07:57:21.638285 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s5 is allowed, Node is running only 16 out of 110 Pods. I1115 07:57:21.638300 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s6 is allowed, Node is running only 20 out of 110 Pods. I1115 07:57:21.638322 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s3 is allowed, Node is running only 20 out of 110 Pods. I1115 07:57:21.638322 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s4 is allowed, Node is running only 17 out of 110 Pods. I1115 07:57:21.638334 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s10 is allowed, Node is running only 16 out of 110 Pods. I1115 07:57:21.638365 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s12 is allowed, Node is running only 9 out of 110 Pods. I1115 07:57:21.638334 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s11 is allowed, Node is running only 11 out of 110 Pods. I1115 07:57:21.638385 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s1 is allowed, Node is running only 19 out of 110 Pods. I1115 07:57:21.638402 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s2 is allowed, Node is running only 21 out of 110 Pods. I1115 07:57:21.638383 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s9 is allowed, Node is running only 16 out of 110 Pods. I1115 07:57:21.638335 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s8 is allowed, Node is running only 18 out of 110 Pods. I1115 07:57:21.638408 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s13 is allowed, Node is running only 8 out of 110 Pods. I1115 07:57:21.638478 1 predicates.go:1369] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s10 is allowed, existing pods anti-affinity terms satisfied. I1115 07:57:21.638505 1 predicates.go:1369] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s8 is allowed, existing pods anti-affinity terms satisfied. I1115 07:57:21.638577 1 predicates.go:1369] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s9 is allowed, existing pods anti-affinity terms satisfied. I1115 07:57:21.638583 1 predicates.go:829] Schedule Pod nxs-stage/cronjob-cron-events-1573793820-xt6q9 on Node nxs-k8s-s7 is allowed, Node is running only 25 out of 110 Pods. I1115 07:57:21.638932 1 resource_allocation.go:78] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s10: BalancedResourceAllocation, capacity 39900 millicores 66620178432 memory bytes, total request 2343 millicores 9640186880 memory bytes, score 9 I1115 07:57:21.638946 1 resource_allocation.go:78] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s10: LeastResourceAllocation, capacity 39900 millicores 66620178432 memory bytes, total request 2343 millicores 9640186880 memory bytes, score 8 I1115 07:57:21.638961 1 resource_allocation.go:78] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s9: BalancedResourceAllocation, capacity 39900 millicores 66620170240 memory bytes, total request 4107 millicores 11307422720 memory bytes, score 9 I1115 07:57:21.638971 1 resource_allocation.go:78] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s8: BalancedResourceAllocation, capacity 39900 millicores 66620178432 memory bytes, total request 5847 millicores 24333637120 memory bytes, score 7 I1115 07:57:21.638975 1 resource_allocation.go:78] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s9: LeastResourceAllocation, capacity 39900 millicores 66620170240 memory bytes, total request 4107 millicores 11307422720 memory bytes, score 8 I1115 07:57:21.638990 1 resource_allocation.go:78] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s8: LeastResourceAllocation, capacity 39900 millicores 66620178432 memory bytes, total request 5847 millicores 24333637120 memory bytes, score 7 I1115 07:57:21.639022 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s10: TaintTolerationPriority, Score: (10) I1115 07:57:21.639030 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s8: TaintTolerationPriority, Score: (10) I1115 07:57:21.639034 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s9: TaintTolerationPriority, Score: (10) I1115 07:57:21.639041 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s10: NodeAffinityPriority, Score: (0) I1115 07:57:21.639053 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s8: NodeAffinityPriority, Score: (0) I1115 07:57:21.639059 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s9: NodeAffinityPriority, Score: (0) I1115 07:57:21.639061 1 interpod_affinity.go:237] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s10: InterPodAffinityPriority, Score: (0) I1115 07:57:21.639063 1 selector_spreading.go:146] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s10: SelectorSpreadPriority, Score: (10) I1115 07:57:21.639073 1 interpod_affinity.go:237] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s8: InterPodAffinityPriority, Score: (0) I1115 07:57:21.639077 1 selector_spreading.go:146] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s8: SelectorSpreadPriority, Score: (10) I1115 07:57:21.639085 1 interpod_affinity.go:237] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s9: InterPodAffinityPriority, Score: (0) I1115 07:57:21.639088 1 selector_spreading.go:146] cronjob-cron-events-1573793820-xt6q9 -> nxs-k8s-s9: SelectorSpreadPriority, Score: (10) I1115 07:57:21.639103 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s10: SelectorSpreadPriority, Score: (10) I1115 07:57:21.639109 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s8: SelectorSpreadPriority, Score: (10) I1115 07:57:21.639114 1 generic_scheduler.go:726] cronjob-cron-events-1573793820-xt6q9_nxs-stage -> nxs-k8s-s9: SelectorSpreadPriority, Score: (10) I1115 07:57:21.639127 1 generic_scheduler.go:781] Host nxs-k8s-s10 => Score 100037 I1115 07:57:21.639150 1 generic_scheduler.go:781] Host nxs-k8s-s8 => Score 100034 I1115 07:57:21.639154 1 generic_scheduler.go:781] Host nxs-k8s-s9 => Score 100037 I1115 07:57:21.639267 1 scheduler_binder.go:269] AssumePodVolumes for pod "nxs-stage/cronjob-cron-events-1573793820-xt6q9", node "nxs-k8s-s10" I1115 07:57:21.639286 1 scheduler_binder.go:279] AssumePodVolumes for pod "nxs-stage/cronjob-cron-events-1573793820-xt6q9", node "nxs-k8s-s10": all PVCs bound and nothing to do I1115 07:57:21.639333 1 factory.go:733] Attempting to bind cronjob-cron-events-1573793820-xt6q9 to nxs-k8s-s10

यहाँ हम देखते हैं कि प्रारंभ में अनुसूचक फ़िल्टरिंग करता है और 3 नोड्स की एक सूची बनाता है, जिस पर इसे चलाना संभव है (nxs-k8s-s8, nxs-k8s-s9, nxs-k8s-s10)। इसके बाद सबसे उपयुक्त नोड को निर्धारित करने के लिए इनमें से प्रत्येक नोड के लिए कई मापदंडों (BalancedResourceAllocation, LeastResourceAllocation सहित) के अनुसार अंकों की गणना की जाती है। अंत में, यह सबसे अधिक अंकों के साथ नोड के तहत योजनाबद्ध है (यहां, दो नोड्स एक ही बार में अंकों की संख्या 100037 है, इसलिए एक यादृच्छिक एक का चयन किया जाता है - nxs-k8s-s10)।

निष्कर्ष : यदि फली नोड पर काम करते हैं जिसके लिए कोई प्रतिबंध नहीं है, तो k8s (संसाधन खपत के दृष्टिकोण से) के लिए यह बराबर होगा यदि ऐसी नोड्स इस नोड पर पूरी तरह से अनुपस्थित थीं। इसलिए, यदि आपके पास सशर्त रूप से एक प्रचंड प्रक्रिया (उदाहरण के लिए, wowza) के साथ एक फली है और इसके लिए कोई प्रतिबंध नहीं हैं, तो ऐसी स्थिति उत्पन्न हो सकती है, जब वास्तव में, किसी दिए गए नोड के सभी संसाधनों को खा लिया जाता है, लेकिन k8 के लिए यह नोड अनलोड और माना जाता है रैंकिंग करते समय (उपलब्ध संसाधनों के आकलन के साथ अंक में), साथ ही एक नोड जिसमें कार्य पिच नहीं होता है, को समान अंक से सम्मानित किया जाएगा, जिससे अंत में नोड्स के बीच लोड का असमान वितरण हो सकता है।

चूल्हा बेदखल करना

जैसा कि आप जानते हैं, प्रत्येक फली को 3 क्यूओएस कक्षाओं में से एक सौंपा गया है:

क्रमबद्ध - जब स्मृति और सीपीयू के लिए चूल्हा में प्रत्येक कंटेनर के लिए अनुरोध और सीमा निर्धारित की जाती है, और ये मूल्य मेल खाते हैं
फटने योग्य - चूल्हा में कम से कम एक कंटेनर में अनुरोध और सीमा होती है, जबकि अनुरोध <सीमा
सबसे अच्छा प्रयास - जब चूल्हा में कोई कंटेनर संसाधनों में सीमित नहीं है

उसी समय, जब नोड पर संसाधनों (डिस्क, मेमोरी) की कमी होती है, तो एक निश्चित एल्गोरिथ्म के अनुसार पॉड को रैंक और बेदखल करना शुरू हो जाता है जो फली और उसके क्यूओएस वर्ग की प्राथमिकता को ध्यान में रखता है। उदाहरण के लिए, यदि हम RAM के बारे में बात कर रहे हैं, तो QoS वर्ग के आधार पर निम्नलिखित सिद्धांत के अनुसार अंक दिए जाते हैं:

गारंटी : -998
BestEffort : 1000
अस्थिर : न्यूनतम (अधिकतम (2, 1000 - (1000 * memoryRequestBytes) / मशीनमेसरीसिटी बाइट्स), 999)

यानी उसी प्राथमिकता के साथ, क्यूबलेट पहले नोड से सबसे अच्छा प्रयास क्यूओएस वर्ग के साथ फली को निष्कासित करेगा।

निष्कर्ष : यदि आप उस पर अपर्याप्त संसाधनों के मामले में नोड से आवश्यक फली निकालने की संभावना को कम करना चाहते हैं, तो प्राथमिकता के साथ, आपको इसके लिए अनुरोध / सीमा निर्धारित करने का भी ध्यान रखना होगा।

आवेदन चूल्हा क्षैतिज ऑटो-स्केलिंग तंत्र (HPA)

जब कार्य संसाधनों (सिस्टम - सीपीयू / रैम या उपयोगकर्ता - आरपीएस) के उपयोग के आधार पर फली की संख्या में स्वचालित रूप से वृद्धि और कमी करता है, तो k8s जैसे कि एचपीए (क्षैतिज पॉड ऑटोकैसलर) इसके समाधान में मदद कर सकता है। जिसका एल्गोरिथ्म इस प्रकार है:

मनाया संसाधन (currentMetricValue) की वर्तमान रीडिंग निर्धारित की जाती है
संसाधन के लिए वांछित मान (वांछितMetricValue) निर्धारित किए जाते हैं, जो अनुरोध का उपयोग करके सिस्टम संसाधनों के लिए निर्धारित किए जाते हैं
प्रतिकृतियों की वर्तमान संख्या निर्धारित की जाती है (currentReplicas)
निम्नलिखित सूत्र प्रतिकृतियों की वांछित संख्या की गणना करता है।
वांछितReplicas = [currentReplicas * (currentMetricValue / वांछितMetricVueue]]

हालांकि, स्केलिंग तब नहीं होगी जब गुणांक (currentMetricValue / वांछितMetricValue) 1 के करीब है (हम स्वयं स्वीकार्य त्रुटि सेट कर सकते हैं, डिफ़ॉल्ट रूप से यह 0.1 है)।

ऐप-टेस्ट एप्लिकेशन (तैनाती के रूप में वर्णित) का उपयोग करके hpa पर विचार करें, जहां सीपीयू की खपत के आधार पर प्रतिकृतियों की संख्या को बदलना आवश्यक है:

आवेदन प्रकट
```
 kind: Deployment apiVersion: apps/v1beta2 metadata: name: app-test spec: selector: matchLabels: app: app-test replicas: 2 template: metadata: labels: app: app-test spec: containers: - name: nginx image: registry.nixys.ru/generic-images/nginx imagePullPolicy: Always resources: requests: cpu: 60m ports: - name: http containerPort: 80 - name: nginx-exporter image: nginx/nginx-prometheus-exporter resources: requests: cpu: 30m ports: - name: nginx-exporter containerPort: 9113 args: - -nginx.scrape-uri - http://127.0.0.1:80/nginx-status 
```
यानी हम देखते हैं कि एप्लिकेशन के तहत इसे शुरू में दो उदाहरणों में लॉन्च किया गया है, जिनमें से प्रत्येक में दो कंटेनर nginx और nginx-export शामिल हैं, जिनमें से प्रत्येक के लिए सीपीयू के लिए अनुरोध दिए गए हैं।
एचपीए प्रकट
```
 apiVersion: autoscaling/v2beta2 kind: HorizontalPodAutoscaler metadata: name: app-test-hpa spec: maxReplicas: 10 minReplicas: 2 scaleTargetRef: apiVersion: extensions/v1beta1 kind: Deployment name: app-test metrics: - type: Resource resource: name: cpu target: type: Utilization averageUtilization: 30 
```
यानी हमने एक ऐसा hpa बनाया है जो परिनियोजन ऐप-परीक्षण की निगरानी करेगा और cpu संकेतक के आधार पर एप्लिकेशन के साथ हार्ट की संख्या को समायोजित करेगा (हम उम्मीद करते हैं कि इसे CPU के 30% प्रतिशत का अनुरोध करना चाहिए), जबकि प्रतिकृतियों की संख्या 2-10 की सीमा में है।

अब, हम hpa संचालन तंत्र पर विचार करेंगे यदि हम एक चूल्हे पर लोड लागू करते हैं:
```
  # kubectl top pod NAME CPU(cores) MEMORY(bytes) app-test-78559f8f44-pgs58 101m 243Mi app-test-78559f8f44-cj4jz 4m 240Mi 
```

कुल हम निम्नलिखित हैं:

वांछित मान (वांछितMetricValue) - hpa सेटिंग्स के अनुसार, हमारे पास 30% है
वर्तमान मान (currentMetricValue) - गणना के लिए, नियंत्रक-प्रबंधक% में संसाधन खपत के औसत मूल्य की गणना करता है, अर्थात। सशर्त रूप से निम्न कार्य करता है:
1. मीट्रिक सर्वर से चूल्हा मेट्रिक्स के पूर्ण मूल्यों को प्राप्त करता है, अर्थात 101 मी और 4 मी
2. औसत निरपेक्ष मान की गणना करता है, अर्थात (101 मी + 4 मी) / 2 = 53 मी
3. वांछित संसाधन खपत के लिए पूर्ण मूल्य प्राप्त होता है (इसके लिए, सभी कंटेनरों का अनुरोध संक्षेप में है) 60 मीटर + 30 मीटर = 90 मीटर
4. अनुरोध चूल्हा के सापेक्ष सीपीयू की खपत का औसत प्रतिशत, अर्थात् 53 मीटर / 90 मीटर * 100% = 59%

अब हमारे पास यह निर्धारित करने के लिए आवश्यक सब कुछ है कि क्या प्रतिकृतियों की संख्या को बदलना आवश्यक है, इसके लिए हम गुणांक की गणना करते हैं:

ratio = 59% / 30% = 1.96

यानी प्रतिकृतियों की संख्या को ~ 2 गुना बढ़ाया जाना चाहिए और [2 * 1.96] = 4 करना चाहिए।

निष्कर्ष: जैसा कि आप देख सकते हैं, इस तंत्र के काम करने के लिए, एक पूर्वापेक्षा शामिल है, जिसमें मनाया कंटेनर में सभी कंटेनरों के लिए अनुरोध उपलब्ध हैं।

नोड्स के क्षैतिज ऑटो-स्केलिंग का तंत्र (क्लस्टर ऑटोस्कोलर)

लोड के फटने के दौरान सिस्टम पर नकारात्मक प्रभाव को बेअसर करने के लिए, एक ट्यून्ड हैपा की उपस्थिति पर्याप्त नहीं है। उदाहरण के लिए, hpa कंट्रोलर मैनेजर में सेटिंग्स के अनुसार यह तय करता है कि प्रतिकृतियों की संख्या में 2 गुना वृद्धि करने की आवश्यकता है, हालाँकि, नोड्स पर ऐसे पॉड्स चलाने के लिए कोई नि: शुल्क संसाधन नहीं हैं (यानी नोड फली अनुरोधों के लिए अनुरोधित संसाधन प्रदान कर सकते हैं) और ये पॉड्स लंबित स्थिति दर्ज करें।

इस मामले में, यदि प्रदाता के पास उपयुक्त IaaS / PaS (उदाहरण के लिए, GKE / GCE, AKS, EKS, आदि) है, तो Node Autoscaler जैसे उपकरण हमारी मदद कर सकते हैं। यह आपको क्लस्टर में अधिकतम और न्यूनतम संख्या सेट करने की अनुमति देता है और स्वचालित रूप से नोड्स की वर्तमान संख्या (नोड प्रदाता को हटाने / हटाने के लिए क्लाउड प्रदाता एपीआई तक पहुंच) को समायोजित करता है जब क्लस्टर में संसाधनों की कमी होती है और पॉड्स शेड्यूल नहीं किए जा सकते हैं (लंबित स्थिति में)।

निष्कर्ष: नोड्स को स्वचालित रूप से स्केल करने में सक्षम होने के लिए, चूल्हा कंटेनरों में अनुरोध निर्दिष्ट करना आवश्यक है ताकि k8s नोड्स के लोड का सही मूल्यांकन कर सकें और तदनुसार रिपोर्ट करें कि अगली चूल्हा शुरू करने के लिए क्लस्टर में कोई संसाधन नहीं हैं।

निष्कर्ष

यह ध्यान दिया जाना चाहिए कि कंटेनर के लिए संसाधन सीमा निर्धारित करना एप्लिकेशन के सफल लॉन्च के लिए एक शर्त नहीं है, लेकिन निम्नलिखित कारणों से ऐसा करना बेहतर है:

K8s नोड्स के बीच लोड संतुलन के संदर्भ में अधिक सटीक अनुसूचक संचालन के लिए
एक चूल्हा बेदखली घटना की संभावना को कम करने के लिए
क्षैतिज ऑटो-स्केलिंग एप्लिकेशन हार्ट्स (HPA) के लिए
क्लाउड प्रदाताओं के लिए नोड्स (क्लस्टर ऑटोस्कोलिंग) के क्षैतिज ऑटो-स्केलिंग के लिए

कुबेरनेट्स: सिस्टम संसाधन प्रबंधन स्थापित करना इतना महत्वपूर्ण क्यों है?

नोड्स के बीच लोड संतुलन का तंत्र

चूल्हा बेदखल करना

आवेदन चूल्हा क्षैतिज ऑटो-स्केलिंग तंत्र (HPA)

नोड्स के क्षैतिज ऑटो-स्केलिंग का तंत्र (क्लस्टर ऑटोस्कोलर)

निष्कर्ष

हमारे ब्लॉग पर अन्य लेख भी पढ़ें:

More articles: