प्रलेखन

• 1: कुबेरनेट्स प्रलेखन
• 1.1: प्रलेखन के उपलब्ध संस्करण
• 2: शुरू करना
• 2.1: सीखने का माहौल
• 2.2: उत्पादन वातावरण
• 2.2.1: कंटेनर रनटाइम
• 2.2.2: Turnkey Cloud Solutions
• 2.2.3: परिनियोजन टूल के साथ कुबेरनेट्स स्थापित करे
• 2.2.4: कुबेरनेट्स में Windows
• 2.3: उत्तम प्रथाएं
• 3: अवधारणाएँ
• 3.1: अवलोकन
• 3.2: सर्विसेज, लोड बैलेंसिंग और नेटवर्किंग
• 3.3: नीतियाँ
• 4: कार्य
• 4.1: उपकरण स्थापित करें
• 4.1.1: Linux पर kubectl इंस्टॉल और सेट अप करें
• 4.1.2: macOS पर kubectl इंस्टॉल और सेटअप करें
• 4.1.3: Windows पर kubectl इंस्टॉल और सेटअप करें
• 4.2: नेटवर्क पॉलिसी प्रोवाइडर इंस्टॉल करें
• 4.2.1: नेटवर्कपॉलिसी के लिए Antrea का उपयोग करें
• 4.3: जॉब चलाएं
• 4.3.1: क्रॉनजॉब के साथ स्वचालित कार्य चलाना
• 4.3.2: वर्क क्यू का उपयोग करके मोटे समानांतर प्रसंस्करण
• 4.3.3: वर्क क्यू का उपयोग करके सूक्ष्म समानांतर प्रसंस्करण
• 4.3.4: स्थिर कार्य असाइनमेंट के साथ समानांतर प्रसंस्करण के लिए अनुक्रमित जॉब
• 4.3.5: पॉड-टू-पॉड कम्युनिकेशन के साथ जॉब
• 4.3.6: समानांतर प्रसंस्करण विस्तार
• 4.3.7: पॉड फेलियर पॉलिसी
• 4.4: TLS
• 4.4.1: क्यूबलेट के लिए प्रमाणपत्र आवर्तन कॉन्फ़िगर करें
• 5: ट्यूटोरियल
• 5.1: हेलो मिनीक्यूब
• 5.2: बुनियादी कुबेरनेट्स सीखें
• 5.2.1: एक क्लस्टर बनाएं
• 5.2.1.1: Minikube का उपयोग कर क्लस्टर बनाना
• 5.2.2: डिप्लॉय ऐप
• 5.2.2.1: डिप्लॉयमेंट बनाने के लिए kubectl का उपयोग करना
• 5.2.3: ऐप का अन्वेषण करें
• 5.2.3.1: पॉड्स और नोड्स की जांच करना
• 5.2.4: अपने ऐप को सार्वजनिक रूप से एक्सपोस करें
• 5.2.4.1: अपने ऐप को एक्सपोज़ करने के लिए किसी सर्विस का उपयोग करना
• 5.2.5: अपने ऐप को स्केल करें
• 5.2.5.1: अपने ऐप के कई इंस्टेंस चलाना
• 5.2.6: अपना ऐप अपडेट करें
• 5.2.6.1: रोलिंग अपडेट करना
• 6: संदर्भ
• 6.1: शब्दकोष
• 6.2: शेडुलिंग
• 6.3: अन्य उपकरण
• 7: कुबेरनेटेस डॉक्स में योगदान दे
• 7.1: प्रलेखन शैली अवलोकन
• 7.2: साइट विश्लेषिकी देखना
• 8: डॉक्स स्मोक टेस्ट पेज

1 - कुबेरनेट्स प्रलेखन

1.1 - प्रलेखन के उपलब्ध संस्करण

इस वेबसाइट में कुबेरनेट्स के वर्तमान और चार पिछले संस्करण के प्रलेखन शामिल हैं।

2 - शुरू करना

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

कुबेरनेट्स क्लस्टर को स्थानीय मशीन पर, क्लाउड में, या अपने स्वयं के डेटासेंटर में डिप्लॉय करने के लिए आप कुबेरनेट्स डाउनलोड कर सकते हैं।

यदि आप कुबेरनेट्स क्लस्टर को स्वयं संभालना नहीं चाहते हैं, तो आप एक संचालन सेवा चुन सकते हैं, जैसे ये प्रमाणित प्लेटफॉर्म। क्लाउड की विस्तृत श्रृंखला और बेयर मेटल वातावरण के लिए अन्य मानकीकृत और कस्टम समाधान भी उपलब्ध हैं।

सीखने का वातावरण

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

प्रोडक्शन वातावरण

प्रोडक्शन वातावरण के लिए समाधान का मूल्यांकन करते समय, विचार करें कि कुबेरनेट्स क्लस्टर के किन पहलुओं (या abstractions) का संचालन आप स्वयं प्रबंधित करना चाहते हैं और किसे आप एक प्रदाता को सौंपना पसंद करते हैं।

स्वयं प्रबंधित कर रहे कुबेरनेट्स क्लस्टर डिप्लॉय करने के लिए kubeadm आधिकारिक टूल है।

आगे क्या है

• कुबेरनेट्स डाउनलोड करें
• kubectl सहित डाउनलोड और टूल इंस्टॉल करें।
• अपने नए क्लस्टर के लिए कंटेनर रनटाइम चुनें।
• क्लस्टर सेटअप के लिए सर्वोत्तम प्रक्रियाओं के बारे में जानें।

कुबेरनेट्स के कण्ट्रोल प्लेन को Linux पर चलाने के लिए डिज़ाइन किया गया है। अपने क्लस्टर के अंदर आप Linux या अन्य ऑपरेटिंग सिस्टम पर एप्लिकेशन चला सकते हैं, जिसमें windows भी शामिल हैं।

• windows नोड्स के साथ क्लस्टर सेट अप करना सीखें।

2.1 - सीखने का माहौल

2.2 - उत्पादन वातावरण

उत्पादन-गुणवत्ता वाले कुबेरनेट्स क्लस्टर के लिए योजना और तैयारी की आवश्यकता होती है। यदि आपका कुबेरनेट्स क्लस्टर महत्वपूर्ण कार्यभार चलाने के लिए है, तो इसे लचीला होने के लिए कॉन्फ़िगर किया जाना चाहिए। यह पेज उन चरणों के बारे में बताता है जो आप उत्पादन के लिए तैयार क्लस्टर सेटअप करने के लिए, या उत्पादन के उपयोग के लिए मौजूदा क्लस्टर को अपग्रेड करने के लिए उठा सकते हैं। यदि आप पहले से ही उत्पादन सेटअप से परिचित हैं और लिंक चाहते हैं, तो आगे जाएं।

उत्पादन विचार

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

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

• उपलब्धता: सिंगल-मशीन कुबेरनेट्स सीखने का माहौल में विफलता का एक बिंदु है। अत्यधिक उपलब्ध क्लस्टर बनाने का अर्थ है:

  • कण्ट्रोल प्लेन को वर्कर नोड्स से अलग करना।
  • कई नोड्स पर कण्ट्रोल प्लेन घटकों की प्रतिकृति।
  • क्लस्टर के लिए संतुलन यातायात लोड करेंAPI server.
  • पर्याप्त वर्कर नोड्स उपलब्ध होना, या जल्दी से उपलब्ध होने में सक्षम होना, क्योंकि बदलते वर्कलोड इसे वारंट करते हैं।

• स्केल: यदि आप उम्मीद करते हैं कि आपके उत्पादन कुबेरनेट्स पर्यावरण को मांग की एक स्थिर मात्रा प्राप्त होगी, तो आप उस क्षमता के लिए सेटअप करने में सक्षम हो सकते हैं जिसकी आपको आवश्यकता है और किया जा सकता है। हालाँकि, यदि आप समय के साथ मांग बढ़ने की उम्मीद करते हैं या मौसम या विशेष घटनाओं जैसी चीजों के आधार पर अचानक से बदलते हैं, तो आपको योजना बनाने की आवश्यकता है कि कण्ट्रोल प्लेन और वर्कर नोड्स के लिए अधिक अनुरोधों से बढ़े दबाव को कैसे दूर किया जाए या अप्रयुक्त संसाधनों को कम करने के लिए स्केल किया जाए।

• सुरक्षा और एक्सेस मैनेजमेंट: आपके अपने कुबेरनेट्स लर्निंग क्लस्टर पर पूर्ण व्यवस्थापकीय विशेषाधिकार हैं। लेकिन महत्वपूर्ण कार्यभार के साथ साझा क्लस्टर, और एक या दो से अधिक उपयोगकर्ता, को क्लस्टर संसाधनों तक कौन और क्या एक्सेस कर सकता है, इसके लिए अधिक परिष्कृत दृष्टिकोण की आवश्यकता होती है। आप यह सुनिश्चित करने के लिए (भूमिका-आधारित एक्सेस कण्ट्रोल) और अन्य सुरक्षा तंत्रों का उपयोग कर सकते हैं कि उपयोगकर्ता और कार्यभार उन संसाधनों तक पहुँच प्राप्त कर सकते हैं जिनकी उन्हें आवश्यकता है, साथ ही में कार्यभार और क्लस्टर को साथ में सुरक्षित रख सके। आप नीतियों और कंटेनर संसाधन को प्रबंधित करके उन संसाधनों की सीमा निर्धारित कर सकते हैं जिन तक उपयोगकर्ता और कार्यभार पहुंच सकते हैं।

कुबेरनेट्स उत्पादन वातावरण को स्वयं बनाने से पहले, इस कार्य में से कुछ या सभी को सौंपने पर विचार करें टर्नकी क्लाउड सॉल्यूशंस प्रदाता या अन्य कुबेरनेट्स पार्टनर्स विकल्पों में शामिल हैं:

• सर्वरलेस: किसी क्लस्टर को प्रबंधित किए बिना केवल तृतीय-पक्ष उपकरण पर कार्यभार चलाएं। आपसे सीपीयू उपयोग, मेमोरी और डिस्क अनुरोध जैसी चीज़ों के लिए शुल्क लिया जाएगा।
• व्यवस्थित कण्ट्रोल प्लेन: प्रदाता को क्लस्टर के कण्ट्रोल प्लेन के पैमाने और उपलब्धता का प्रबंधन करने दें, साथ ही पैच और अपग्रेड को भी संभालें।
• व्यवस्थित वर्कर नोड्स: अपनी आवश्यकताओं को पूरा करने के लिए नोड्स के पूल को कॉन्फ़िगर करें, फिर प्रदाता सुनिश्चित करता है कि वे नोड उपलब्ध हैं और जरूरत पड़ने पर अपग्रेड को लागू करने के लिए तैयार हैं।
• एकीकरण: ऐसे प्रदाता हैं जो कुबेरनेट्स को अन्य सेवाओं के साथ एकीकृत करते हैं जिनकी आपको आवश्यकता हो सकती है, जैसे भंडारण, कंटेनर रजिस्ट्रियां, प्रमाणीकरण तरीके, और विकास उपकरण।

चाहे आप कुबेरनेट्स क्लस्टर का निर्माण स्वयं करें या भागीदारों के साथ काम करें, अपनी आवश्यकताओं का मूल्यांकन करने के लिए निम्नलिखित अनुभागों की समीक्षा करें क्योंकि वे आपके क्लस्टर से संबंधित हैं कण्ट्रोल प्लेन, वर्कर नोड्स, यूज़र एक्सेस, और वर्कलोड रिसोर्सस.

उत्पादन क्लस्टर सेटअप

उत्पादन-गुणवत्ता वाले कुबेरनेट्स क्लस्टर में, कण्ट्रोल प्लेन क्लस्टर को उन सेवाओं से प्रबंधित करता है जिन्हें विभिन्न तरीकों से कई कंप्यूटरों में फैलाया जा सकता है। हालाँकि, प्रत्येक वर्कर नोड एक एकल इकाई का प्रतिनिधित्व करता है जिसे कुबेरनेट्स पॉड चलाने के लिए कॉन्फ़िगर किया गया है।

उत्पादन कण्ट्रोल प्लेन

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

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

• डिप्लॉयमेंट टूल्स चुनें: आप kubeadm, kops, और kubespray जैसे टूल का उपयोग करके एक कण्ट्रोल प्लेन को तैनात कर सकते हैं। उनमें से प्रत्येक डिप्लॉयमेंट विधियों का उपयोग करके उत्पादन-गुणवत्ता डिप्लॉयमेंट के लिए युक्तियों को जानने के लिए डिप्लॉयमेंट टूल्स के साथ कुबेरनेट्स स्थापित करना देखें। आपके डिप्लॉयमेंट के साथ उपयोग करने के लिए विभिन्न कंटेनर रनटाइम उपलब्ध हैं।
• सर्टिफ़िकेट प्रबंधित करे: कण्ट्रोल प्लेन सेवाओं के बीच सुरक्षित संचार सर्टिफ़िकेटस का उपयोग करके कार्यान्वित किया जाता है। डिप्लॉयमेंट के दौरान सर्टिफ़िकेट स्वचालित रूप से उत्पन्न होते हैं या आप अपने स्वयं के सर्टिफ़िकेट अथॉरिटी का उपयोग करके उन्हें उत्पन्न कर सकते हैं। विवरण के लिए PKI सर्टिफ़िकेटस और आवश्यकताएं देखें।
• एपिसर्वर के लिए लोड बैलेंसर कॉन्फ़िगर करें: विभिन्न नोड्स पर चल रहे एपिसर्वर सर्विस इंस्टेंस के लिए बाहरी एपीआई अनुरोधों को वितरित करने के लिए लोड बैलेंसर को कॉन्फ़िगर करें। विवरण के लिए एक बाहरी लोड बैलेंसर बनाना देखें।
• अलग और बैकअप etcd सेवा: अतिरिक्त सुरक्षा और उपलब्धता के लिए etcd सेवाएं या तो अन्य कंट्रोल प्लेन सेवाओं के समान मशीनों पर चल सकती हैं या अलग मशीनों पर चल सकती हैं। क्योंकि etcd क्लस्टर कॉन्फ़िगरेशन डेटा संग्रहीत करता है, etcd डेटाबेस का बैकअप नियमित रूप से किया जाना चाहिए ताकि यह सुनिश्चित हो सके कि यदि आवश्यक हो तो आप उस डेटाबेस की मरम्मत कर सकते हैं। etcd को कॉन्फ़िगर करने और उपयोग करने के विवरण के लिए etcd अक्सर पूछे जाने वाले प्रश्न देखें। विवरण के लिए कुबेरनेट्स के लिए ऑपरेटिंग etcd क्लस्टर और क्यूबएडीएम के साथ एक उच्च उपलब्धता etcd क्लस्टर स्थापित करें देखें।
• मल्टीपल कण्ट्रोल प्लेन सिस्टम बनाएं: उच्च उपलब्धता के लिए, कण्ट्रोल प्लेन एक मशीन तक सीमित नहीं होना चाहिए। यदि कण्ट्रोल प्लेन सेवाएं एक init सेवा (जैसे systemd) द्वारा चलाई जाती हैं, तो प्रत्येक सेवा को कम से कम तीन मशीनों पर चलना चाहिए। हालाँकि, कुबेरनेट्स में पॉड्स के रूप में कण्ट्रोल प्लेन सेवाएं चलाना सुनिश्चित करता है कि आपके द्वारा अनुरोधित सेवाओं की प्रतिकृति संख्या हमेशा उपलब्ध रहेगी। अनुसूचक फॉल्ट सहने वाला होना चाहिए, लेकिन अत्यधिक उपलब्ध नहीं होना चाहिए। कुबेरनेट्स सेवाओं के नेता चुनाव करने के लिए कुछ डिप्लॉयमेंट उपकरण राफ्ट सर्वसम्मति एल्गोरिथ्म की स्थापना करते हैं। यदि प्राथमिक चला जाता है, तो दूसरी सेवा स्वयं को चुनती है और कार्यभार संभालती है।
• कई क्षेत्रों में विस्तार करना: यदि अपने क्लस्टर को हर समय उपलब्ध रखना महत्वपूर्ण है, तो एक ऐसा क्लस्टर बनाने पर विचार करें, जो कई डेटा केंद्रों पर चलता हो, जिसे क्लाउड वातावरण में ज़ोन के रूप में संदर्भित किया जाता है। ज़ोन(zone) के समूहों को रीजन(region) कहा जाता है। एक ही क्षेत्र में कई क्षेत्रों में एक क्लस्टर फैलाकर, यह इस संभावना में सुधार कर सकता है कि एक क्षेत्र अनुपलब्ध होने पर भी आपका क्लस्टर कार्य करना जारी रखेगा। विवरण के लिए एक से अधिक ज़ोन मे चलाना देखें।
• चल रही सुविधाओं का प्रबंधन: यदि आप अपने क्लस्टर को समय के साथ रखने की योजना बनाते हैं, तो इसके स्वास्थ्य और सुरक्षा को बनाए रखने के लिए आपको कुछ कार्य करने होंगे। उदाहरण के लिए, यदि आपने क्यूबएडीएम के साथ स्थापित किया है, तो आपको सर्टिफिकेट प्रबंधन और क्यूबएडीएम क्लस्टर्स को अपग्रेड करने में मदद करने के लिए निर्देश दिए गए हैं, कुबेरनेट्स प्रशासनिक कार्यों की लंबी सूची के लिए क्लस्टर का एडमिनिस्टर देखें।

जब आप कण्ट्रोल प्लेन सेवाएं चलाते हैं, तो उपलब्ध विकल्पों के बारे में जानने के लिए, kube-apiserver, क्यूब-कंट्रोलर-मैनेजर, देखें। और क्यूब-शेड्यूलर कॉम्पोनेन्ट पेज। अत्यधिक उपलब्ध कंट्रोल प्लेन उदाहरणों के लिए अत्यधिक उपलब्ध टोपोलॉजी के लिए विकल्प, kubeadm के साथ अत्यधिक उपलब्ध क्लस्टर बनाना, और कुबेरनेट्स के लिए ऑपरेटिंग etcd क्लस्टर। etcd बैकअप योजना बनाने के बारे में जानकारी के लिए etcd क्लस्टर का बैकअप लेना देखें।

उत्पादन वर्कर नोड्स

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

• नोड्स कॉन्फ़िगर करें: नोड्स भौतिक या आभासी मशीन हो सकते हैं। यदि आप अपने स्वयं के नोड्स बनाना और प्रबंधित करना चाहते हैं, तो आप एक समर्थित ऑपरेटिंग सिस्टम स्थापित कर सकते हैं, फिर उपयुक्त जोड़ और चला सकते हैं नोड सेवाएं। विचार करना:
  • जब आप उपयुक्त मेमोरी, सीपीयू, और डिस्क स्पीड और स्टोरेज क्षमता उपलब्ध कराकर नोड्स सेट करते हैं तो आपके वर्कलोड की मांग।
  • क्या जेनेरिक कंप्यूटर सिस्टम करेंगे या आपके पास ऐसे वर्कलोड हैं जिन्हें GPU प्रोसेसर, Windows नोड्स या VM आइसोलेशन की आवश्यकता है।
• वैलिदेट(Validate) नोड: यह सुनिश्चित करने के तरीके के बारे में जानकारी के लिए वैलिद(Valid) नोड सेटअप देखें कि एक नोड कुबेरनेट्स क्लस्टर में शामिल होने के लिए आवश्यकताओं को पूरा करता है।
• क्लस्टर में नोड जोड़ें: यदि आप अपने स्वयं के क्लस्टर का प्रबंधन कर रहे हैं, तो आप अपनी स्वयं की मशीनें स्थापित करके और या तो उन्हें मैन्युअल रूप से जोड़कर या क्लस्टर के एपिसर्वर में खुद को पंजीकृत करवाकर नोड्स जोड़ सकते हैं। इन तरीकों से नोड्स जोड़ने के लिए कुबेरनेट्स को कैसे सेट करें, इस बारे में जानकारी के लिए नोड्स अनुभाग देखें।
• क्लस्टर में Windows नोड्स जोड़ें: कुबेरनेट्स Windows वर्कर नोड्स के लिए समर्थन प्रदान करता है, जिससे आप Windows कंटेनरों में लागू वर्कलोड को चला सकते हैं। विवरण के लिए कुबेरनेट्स में Windows देखें।
• स्केल नोड्स: आपके क्लस्टर को अंततः जिस क्षमता की आवश्यकता होगी, उसके विस्तार के लिए एक योजना बनाएं। आपको चलाने के लिए आवश्यक पॉड्स और कंटेनरों की संख्या के आधार पर, यह निर्धारित करने में सहायता के लिए बड़े समूहों के लिए विचार देखें कि आपको कितने नोड्स की आवश्यकता है। यदि आप स्वयं नोड्स का प्रबंधन कर रहे हैं, तो इसका अर्थ यह हो सकता है कि आप अपने स्वयं के भौतिक उपकरण खरीदना और स्थापित करना चाहते हैं।
• ऑटोस्केल नोड्स: अधिकांश क्लाउड प्रदाता अस्वस्थ नोड्स को बदलने के लिए क्लस्टर ऑटोस्केलर का समर्थन करते हैं या मांग के अनुसार नोड्स की संख्या को बढ़ाते और घटाते हैं। विभिन्न क्लाउड प्रदाताओं द्वारा इसे कैसे कार्यान्वित किया जाता है, इसके लिए अक्सर पूछे जाने वाले प्रश्न ऑटोस्केलर कैसे काम करता है और डिप्लॉयमेंट देखें। ऑन-प्रिमाइसेस के लिए, कुछ वर्चुअलाइजेशन प्लेटफॉर्म हैं जिन्हें मांग के आधार पर नए नोड्स को स्पिन करने के लिए स्क्रिप्ट किया जा सकता है।
• नोड स्वास्थ्य जांच सेट करें: महत्वपूर्ण कार्यभार के लिए, आप यह सुनिश्चित करना चाहते हैं कि उन नोड्स पर चलने वाले नोड और पॉड स्वस्थ हैं। नोड समस्या डिटेक्टर डेमॉन का उपयोग करके, आप सुनिश्चित कर सकते हैं कि आपके नोड स्वस्थ हैं।

उत्पादन उपयोगकर्ता प्रबंधन

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

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

• प्रमाणीकरण: apiserver क्लाइंट का उपयोग करके उपयोगकर्ताओं को प्रमाणित कर सकता है प्रमाण पत्र, वाहक टोकन, एक प्रमाणीकरण प्रॉक्सी, या HTTP मूल प्रमाणीकरण। आप चुन सकते हैं कि आप किन प्रमाणीकरण विधियों का उपयोग करना चाहते हैं। प्लगइन्स का उपयोग करके, apiserver आपके संगठन की मौजूदा प्रमाणीकरण विधियों, जैसे LDAP या Kerberos का लाभ उठा सकता है। कुबेरनेट्स उपयोगकर्ताओं को प्रमाणित करने के इन विभिन्न तरीकों के विवरण के लिए प्रमाणीकरण देखो।
• प्राधिकरण: जब आप अपने नियमित उपयोगकर्ताओं को अधिकृत करने के लिए निकलते हैं, तो आप शायद आरबीएसी और एबीएसी प्राधिकरण के बीच चयन करेंगे। उपयोगकर्ता खातों को अधिकृत करने के लिए विभिन्न तरीकों की समीक्षा करने के लिए प्राधिकरण अवलोकन देखें (साथ ही आपके क्लस्टर में सेवा खाते तक पहुंच):
  • भूमिका-आधारित अभिगम नियंत्रण (RBAC): प्रमाणित उपयोगकर्ताओं को अनुमतियों के विशिष्ट सेट की अनुमति देकर आप अपने क्लस्टर तक पहुँच प्रदान कर सकते हैं। अनुमतियाँ एक विशिष्ट नेमस्पेस्स (भूमिका) या संपूर्ण क्लस्टर (ClusterRole) के लिए असाइन की जा सकती हैं। फिर रोलबाइंडिंग और क्लस्टररोलबाइंडिंग का उपयोग करके, उन अनुमतियों को विशेष उपयोगकर्ताओं से जोड़ा जा सकता है।
  • विशेषता-आधारित अभिगम नियंत्रण (ABAC): आपको क्लस्टर में संसाधन विशेषताओं के आधार पर नीतियां बनाने देता है और उन विशेषताओं के आधार पर पहुंच की अनुमति देगा या अस्वीकार करेगा। नीति फ़ाइल की प्रत्येक पंक्ति विषय (उपयोगकर्ता या समूह), संसाधन संपत्ति, गैर-संसाधन संपत्ति (/ संस्करण या / एपिस), और केवल पढ़ने के लिए संस्करण गुणों (एपीआई संस्करण और प्रकार) और विशिष्ट गुणों के मानचित्र की पहचान करती है। विवरण के लिए देखें उदाहरण।

जब कोई आपके उत्पादन कुबेरनेट्स क्लस्टर पर प्रमाणीकरण और प्राधिकरण सेटअप कर रहा हो, तो यहां कुछ बातों पर विचार करना चाहिए:

• प्राधिकरण मोड सेट करें: जब कुबेरनेट्स एपीआई सर्वर (kube-apiserver) शुरू होता है, समर्थित प्रमाणीकरण मोड को --authorization-mode फ़्लैग का उपयोग करके सेट किया जाना चाहिए। उदाहरण के लिए, kube-adminserver.yaml फ़ाइल में वह फ़्लैग (/etc/kubernetes/manifests में) नोड, आरबीएसी पर सेट किया जा सकता है। यह प्रमाणित अनुरोधों के लिए नोड और आरबीएसी प्राधिकरण की अनुमति देगा।
• उपयोगकर्ता प्रमाणपत्र और रोल बाइंडिंग (RBAC) बनाएं: यदि आप आरबीएसी प्राधिकरण का उपयोग कर रहे हैं, तो उपयोगकर्ता एक सर्टिफिकेट साइनिंग रिक्वेस्ट (सीएसआर) बना सकते हैं जिस पर क्लस्टर सीए द्वारा हस्ताक्षर किए जा सकते हैं। फिर आप प्रत्येक उपयोगकर्ता के लिए रोल्स और क्लस्टररोल्स को बाध्य कर सकते हैं। विवरण के लिए प्रमाणपत्र पर हस्ताक्षर करने के अनुरोध देखें।
• ऐसी नीतियां बनाएं जो विशेषताओं को जोड़ती हैं (ABAC): यदि आप एबीएसी प्राधिकरण का उपयोग कर रहे हैं, तो आप चुनिंदा उपयोगकर्ताओं या समूहों को विशेष संसाधनों (जैसे पॉड), नेमस्पेस, या एपीग्रुप तक पहुंचने के लिए अधिकृत करने के लिए नीतियां बनाने के लिए विशेषताओं के संयोजन असाइन कर सकते हैं। अधिक जानकारी के लिए देखें उदाहरण।
• प्रवेश नियंत्रकों पर विचार करें: एपीआई सर्वर के माध्यम से आने वाले अनुरोधों के लिए प्राधिकरण के अतिरिक्त रूपों में शामिल हैं वेबहुक टोकन प्रमाणीकरण। वेबहुक और अन्य विशेष प्राधिकरण प्रकारों को एपीआई सर्वर में प्रवेश नियंत्रक जोड़कर सक्षम करने की आवश्यकता है।

कार्यभार संसाधनों पर सीमा निर्धारित करें

उत्पादन कार्यभार की मांग कुबेरनेट्स नियंत्रण विमान के अंदर और बाहर दोनों जगह दबाव पैदा कर सकती है। अपने क्लस्टर के वर्कलोड की जरूरतों के लिए सेट अप करते समय इन मदों पर विचार करें:

• नेमस्पेस्स की सीमा निर्धारित करें: मेमोरी और सीपीयू जैसी चीजों पर प्रति नेमस्पेस कोटा सेट करें। विवरण के लिए मेमोरी, सीपीयू और एपीआई संसाधन प्रबंधित करें देखें। आप इनहेरिट करने की सीमा के लिए हिरार्चीकैल नेमस्पेस्स भी सेट कर सकते हैं।
• DNS मांग के लिए तैयार करें: यदि आप वर्कलोड के बड़े पैमाने पर बढ़ने की उम्मीद करते हैं, तो आपकी DNS सेवा भी बड़े पैमाने पर तैयार होनी चाहिए। क्लस्टर में DNS सेवा को ऑटोस्केल करना देखें।
• अतिरिक्त सेवा खाते बनाएं: उपयोगकर्ता खाते यह निर्धारित करते हैं कि उपयोगकर्ता क्लस्टर पर क्या कर सकते हैं, जबकि एक सेवा खाता किसी विशेष नेमस्पेस्स के भीतर पॉड एक्सेस को परिभाषित करता है। डिफ़ॉल्ट रूप से, एक पॉड अपने नेमस्पेस्स से डिफ़ॉल्ट सेवा खाता लेता है। नया सेवा खाता बनाने के बारे में जानकारी के लिए सेवा खातों का प्रबंधन देखें। उदाहरण के लिए, आप शायद यह करना चाहें:
  • ऐसे रहस्य जोड़ें जिनका उपयोग पॉड किसी विशेष कंटेनर रजिस्ट्री से इमेज खींचने के लिए कर सकता है। उदाहरण के लिए पॉड्स के लिए सेवा खाते कॉन्फ़िगर करें देखें।
  • किसी सेवा खाते में RBAC अनुमतियाँ असाइन करें। विवरण के लिए सेवा खाता अनुमतियां देखें।

आगे क्या है

• तय करें कि आप अपना खुद का उत्पादन कुबेरनेट्स बनाना चाहते हैं या उपलब्ध टर्नकी क्लाउड सॉल्यूशंस से एक प्राप्त करना चाहते हैं या कुबेरनेट्स पार्टनर्स।
• यदि आप अपना स्वयं का क्लस्टर बनाना चुनते हैं, तो योजना बनाएं कि आप प्रमाणपत्र को कैसे संभालना चाहते हैं और etcd जैसी सुविधाओं के लिए उच्च उपलब्धता सेट करें। और एपीआई सर्वर।
• kubeadm, kops या kubespray डिप्लॉयमेंट विधियों में से चुनें।
• अपना निर्धारित करके उपयोगकर्ता प्रबंधन को कॉन्फ़िगर करें प्रमाणीकरण और प्राधिकरण विधियां।
• सेटअप करके एप्लिकेशन वर्कलोड की तैयारी करें संसाधन सीमाएं, DNS ऑटोस्केलिंग और सेवा खाते।

2.2.1 - कंटेनर रनटाइम

आपको क्लस्टर में प्रत्येक नोड में एक कंटेनर रनटाइम इंस्टॉल करना होगा ताकि पॉड वहां चल सकें। यह पृष्ठ बताता है कि क्या शामिल है और नोड्स की स्थापना के लिए संबंधित कार्यों का वर्णन करता है।

कुबेरनेट्स 1.33 के लिए आवश्यक है कि आप एक रनटाइम का उपयोग करें जो कंटेनर रनटाइम इंटरफ़ेस (CRI) के अनुरूप है।

अधिक जानकारी के लिए CRI version support देखें।

यह पृष्ठ Linux पर कुबेरनेट्स के साथ कई सामान्य कंटेनर रनटाइम का उपयोग करने के विवरण सूचीबद्ध करता है:

• containerd
• CRI-O
• Docker Engine
• Mirantis Container Runtime

Cgroup ड्राइवर

प्रक्रियाओं के लिए आवंटित संसाधनों को सीमित करने के लिए कंट्रोल ग्रुप का उपयोग किया जाता है।

जब Linux वातावरण के लिए init सिस्टम, systemd को चुना जाता है, तब init प्रक्रिया रुट(root) control group (cgroup) उत्पन्न करती है और उपभोग करती है तथा cgroup मैनेजर की तरह काम करता है। Systemd और cgroups एकीकृत हैं और प्रत्येक systemd यूनिट को एक cgroup आवंटित होता है। अपने कन्टैनर रनटाइम और kubelet को cgroupfs प्रयोग करने के लिए कॉन्फ़िगर करना संभव है। systemd के साथ cgroupfs प्रयोग करने के कारण दो अलग cgroup मैनेजर होंगे।

एक एकल cgroup प्रबंधक इस दृष्टिकोण को सरल बनाता है कि कौन से संसाधन आवंटित किए जा रहे हैं और डिफ़ॉल्ट रूप से उपलब्ध और उपयोग में आने वाले संसाधनों के बारे में अधिक सुसंगत दृश्य होगा। जब एक सिस्टम पर दो cgroup मैनेजर होते हैं, तो आपको उन रिसोर्सेज के दो व्यू मिलते हैं। क्षेत्र में, लोगों ने ऐसे मामलों की सूचना दी है जहां नोड्स जो kubelet और डॉकर के लिए cgroupfs का उपयोग करने के लिए कॉन्फ़िगर किए गए हैं, लेकिन बाकी प्रक्रियाओं के लिए systemd संसाधन दबाव के कारण अस्थिर हो जाते हैं।

सेटिंग्स को इस तरह बदलना कि आपका कंटेनर रनटाइम और kubelet systemd का उपयोग करें क्योंकि cgroup ड्राइवर सिस्टम को स्थिर करता है। डॉकर के लिए इसे कॉन्फ़िगर करने के लिए, native.cgroupdriver=systemd सेट करें।

Cgroup v2

Cgroup v2, cgroup Linux API का अगला संस्करण है। Cgroup v1 से अलग, प्रत्येक कंट्रोलर के लिए एक अलग अनुक्रम के बजाय एक पदानुक्रम है।

नया संस्करण cgroup v1 पर कई सुधार प्रदान करता है, इनमें से कुछ सुधार हैं:

• API का उपयोग करने का स्पष्ट और आसान तरीका
• कंटेनरों के लिए सुरक्षित उप-वृक्ष प्रतिनिधिमंडल
• प्रेशर स्टॉल की जानकारी जैसी नई सुविधाएँ

भले ही कर्नेल हाइब्रिड कॉन्फ़िगरेशन का समर्थन करता हो, जहां कुछ नियंत्रक cgroup v1 द्वारा प्रबंधित किए जाते हैं और कुछ अन्य cgroup v2 द्वारा, Kubernetes सभी नियंत्रकों को प्रबंधित करने के लिए केवल उसी cgroup संस्करण का समर्थन करता है।

यदि सिस्टमड (Systemd) डिफ़ॉल्ट रूप से cgroup v2 का उपयोग नहीं करता है, तो आप कर्नेल कमांड लाइन में systemd.unified_cgroup_hierarchy=1 जोड़कर सिस्टम को इसका उपयोग करने के लिए कॉन्फ़िगर कर सकते हैं।

# यह उदाहरण एक Linux OS के लिए है जो DNF पैकेज मैनेजर का उपयोग करता है
# आपका सिस्टम कमांड लाइन सेट करने के लिए एक अलग विधि का उपयोग कर सकता है
# लिनक्स कर्नेल का उपयोग करता है।
sudo dnf install -y grubby && \
  sudo grubby \
  --update-kernel=ALL \
  --args="systemd.unified_cgroup_hierarchy=1"

यदि आप कर्नेल के लिए कमांड लाइन बदलते हैं, तो आपको अपने से पहले नोड को रिबूट करना होगा परिवर्तन प्रभावी होता है।

Cgroup v2 में स्विच करते समय उपयोगकर्ता अनुभव में कोई उल्लेखनीय अंतर नहीं होना चाहिए, जब तक कि उपयोगकर्ता सीग्रुप फाइल सिस्टम को सीधे नोड पर या कंटेनरों के भीतर से एक्सेस कर रहे हैं।

इसका उपयोग करने के लिए, Cgroup v2 को CRI रनटाइम द्वारा भी सपोर्टेड (supported) होना चाहिए।

Kubeadm प्रबंधित क्लस्टर में systemd ड्राइवर में माइग्रेट करना

यदि आप मौजूदा kubeadm प्रबंधित क्लस्टर में systemd cgroup ड्राइवर में माइग्रेट करना चाहते हैं, तो माइग्रेशन गाइड का पालन करें।

CRI संस्करण समर्थन

आपके कंटेनर रनटाइम को कंटेनर रनटाइम इंटरफ़ेस के कम से कम v1alpha2 का समर्थन करना चाहिए।

कुबेरनेट्स 1.33 डिफ़ॉल्ट रूप से CRI API के v1 का उपयोग करता है। यदि कंटेनर रनटाइम v1 API का समर्थन नहीं करता है, तो क्यूबलेट वापस आ जाता है इसके बजाय (बहिष्कृत) v1alpha2 API का उपयोग करना।

कंटेनर रनटाइम

कंटेनरडी

यह खंड कंटेनरडी को CRI रनटाइम के रूप में उपयोग करने के लिए आवश्यक कदम है।

अपने सिस्टम पर containerd इंस्टॉल करने के लिए निम्नलिखित कमांड का उपयोग करें:

पूर्वापेक्षाएँ इंस्टॉल और कॉन्फ़िगर करें:

cat <<EOF | sudo tee /etc/modules-load.d/containerd.conf
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter
# सेटअप आवश्यक sysctl params, ये रिबूट के दौरान बने रहते हैं।
cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes-cri.conf
net.bridge.bridge-nf-call-iptables  = 1
net.ipv4.ip_forward                 = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
# रिबूट के बिना sysctl params लागू करें
sudo sysctl --system

कंटेनरडी इंस्टॉल करें:

• Linux
• Windows (PowerShell)

systemd` cgroup ड्राइवर का उपयोग करें

systemd cgroup ड्राइवर {#containerd-systemd} का उपयोग करना runc के साथ /etc/containerd/config.toml में systemd cgroup ड्राइवर का उपयोग करने के लिए, सेट करें

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
  ...
  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
    SystemdCgroup = true

यदि आप इस परिवर्तन को लागू करते हैं,तो सुनिश्चित करें कि आप फिर से कंटेनरडी को पुनरारंभ करें:

sudo systemctl restart containerd

जब आप kubeadm का उपयोग करें, मैन्युअल रूप से कॉन्फ़िगर करें क्यूबलेट के लिए cgroup ड्राइवर मैन्युअल रूप से कॉन्फ़िगर करें।

CRI-O

इस खंड में CRI-O को कंटेनर रनटाइम के रूप में इंस्टॉल करने के लिए आवश्यक जानकारी है।

अपने सिस्टम पर CRI-O इंस्टॉल करने के लिए निम्नलिखित कमांड का उपयोग करें:

पूर्वापेक्षाएँ इंस्टॉल और कॉन्फ़िगर करें:

# बूटअप पर मॉड्यूल लोड करने के लिए .conf फाइल बनाएं
cat <<EOF | sudo tee /etc/modules-load.d/crio.conf
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter
# आवश्यक sysctl params सेट करें, ये रिबूट के दौरान बने रहते हैं।
cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes-cri.conf
net.bridge.bridge-nf-call-iptables  = 1
net.ipv4.ip_forward                 = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
sudo sysctl --system

• Debian
• Ubuntu
• CentOS
• openSUSE Tumbleweed
• Fedora

cat <<EOF | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /
EOF
cat <<EOF | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.list
deb http://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/ /
EOF
curl -L https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$VERSION/$OS/Release.key | sudo apt-key --keyring /etc/apt/trusted.gpg.d/libcontainers.gpg add -
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | sudo apt-key --keyring /etc/apt/trusted.gpg.d/libcontainers.gpg add -
sudo apt-get update
sudo apt-get install cri-o cri-o-runc

cat <<EOF | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /
EOF
cat <<EOF | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.list
deb http://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/ /
EOF
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | sudo apt-key --keyring /etc/apt/trusted.gpg.d/libcontainers.gpg add -
curl -L https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$VERSION/$OS/Release.key | sudo apt-key --keyring /etc/apt/trusted.gpg.d/libcontainers-cri-o.gpg add -
sudo apt-get update
sudo apt-get install cri-o cri-o-runc

sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/devel:kubic:libcontainers:stable.repo
sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$VERSION/$OS/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo
sudo yum install cri-o

sudo zypper install cri-o

sudo dnf module list cri-o

sudo dnf module enable cri-o:$VERSION
sudo dnf install cri-o

CRI-O शुरू करें :

sudo systemctl daemon-reload
sudo systemctl enable crio --now

अधिक जानकारी के लिए CRI-O इंस्टॉलेशन गाइड देखें।

cgroup ड्राइवर

CRI-O डिफ़ॉल्ट रूप से systemd cgroup ड्राइवर का उपयोग करता है। cgroupfs cgroup ड्राइवर पर स्विच करने के लिए, या तो /etc/crio/crio.conf संपादित करें या /etc/crio/crio.conf.d/02-cgroup-manager.conf में ड्रॉप-इन कॉन्फ़िगरेशन रखें। उदाहरण के लिए:

[crio.runtime]
conmon_cgroup = "pod"
cgroup_manager = "cgroupfs"

कृपया बदले हुए conmon_cgroup पर भी ध्यान दें, जिसे cgroupfs के साथ CRI-O का उपयोग करते समय पॉड मान पर सेट करना होगा। आमतौर पर क्यूबलेट के cgroup ड्राइवर कॉन्फ़िगरेशन (आमतौर पर kubeadm के माध्यम से किया जाता है) और CRI-O को सिंक में रखना आवश्यक है।

डॉकर इंजन

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

डॉकर इंजन कुबेरनेट्स 1.33 के साथ सीधे संगत है, जो कि बहिष्कृत dockershim घटक का उपयोग करता है। अधिक जानकारी के लिए और संदर्भ, Dockershim deprecation FAQ देखें।

आप तृतीय-पक्ष एडेप्टर भी पा सकते हैं जो आपको कुबेरनेट्स के साथ डॉकर इंजन का उपयोग करने देता है, समर्थित Container Runtime Interface के माध्यम से (CRI)।

निम्नलिखित CRI एडेप्टर डॉकर इंजन के साथ काम करने के लिए डिज़ाइन किए गए हैं:

• cri-dockerd Mirantis से

मिरांटिस कंटेनर रनटाइम

Mirantis Container Runtime (MCR) एक व्यावसायिक रूप से है उपलब्ध कंटेनर रनटाइम जिसे पहले डॉकर एंटरप्राइज एडिशन के नाम से जाना जाता था।

आप खुले स्रोत का उपयोग करके कुबेरनेट्स के साथ मिरांटिस कंटेनर रनटाइम का उपयोग कर सकते हैं cri-dockerd घटक, MCR के साथ शामिल है।

2.2.2 - Turnkey Cloud Solutions

यह पृष्ठ कुबेरनेट्स प्रमाणित समाधान प्रदाताओं की एक सूची प्रदान करता है। हर एक प्रदाता पृष्ठ से आप सीख सकते हैं कि उत्पादन योग्य क्लस्टर को इंस्टॉल और सेटअप कैसे करें।

2.2.3 - परिनियोजन टूल के साथ कुबेरनेट्स स्थापित करे

अपना स्वयं का प्रोडक्शन कुबेरनेट्स क्लस्टर स्थापित करने के लिए कई विधियाँ और उपकरण है। उदाहरण के लिए:

• kubeadm

• kops: एक स्वचालित क्लस्टर प्रावधान उपकरण। ट्यूटोरियल, सर्वोत्तम प्रथाओं, कॉन्फ़िगरेशन विकल्पों और समुदाय तक पहुंचने की जानकारी के लिए, कृपया kOps वेबसाइट देखें।

• kubespray: सामान्य OS/कुबेरनेट्स क्लस्टर कॉन्फ़िगरेशन प्रबंधन कार्यों के लिए अन्सिबल प्लेबुकस, इन्वेंट्री, प्रोविजनिंग टूल और डोमेन ज्ञान की एक संरचना। आप स्लैक चैनल #kubespray पर समुदाय को संपर्क कर सकते है।

2.2.4 - कुबेरनेट्स में Windows

2.3 - उत्तम प्रथाएं

3 - अवधारणाएँ

अवधारणा अनुभाग आपको कुबेरनेट्स प्रणाली के हिस्सों के बारे में जानने में मदद करता है जिसका उपयोग कुबेरनेट्स आपके क्लस्टर का प्रतिनिधित्व करने के लिए करता है, और कुबेरनेट्स कार्यप्रणाली की गहरी समझ प्राप्त करने में आपकी मदद करता है।

3.1 - अवलोकन

यह पृष्ठ कुबेरनेट्स का एक अवलोकन है।

कुबेरनेट्स कंटेनरीकृत वर्कलोड और सेवाओं के प्रबंधन के लिए एक पोर्टेबल, एक्स्टेंसिबल, ओपन-सोर्स प्लेटफॉर्म है, जो घोषणात्मक कॉन्फ़िगरेशन और स्वचालन दोनों की सुविधा प्रदान करता है। इसका एक बड़ा, तेजी से बढ़ता हुआ पारिस्थितिकी तंत्र है। कुबेरनेट्स सेवाएँ, समर्थन और उपकरण व्यापक रूप से उपलब्ध हैं।

कुबेरनेट्स नाम ग्रीक से उत्पन्न हुआ है, जिसका अर्थ है हेल्समैन या पायलट। K8s एक संक्षिप्त नाम के रूप में "K" और "s" के बीच आठ अक्षरों को गिनने का परिणाम है। Google ने 2014 में कुबेरनेट्स प्रोजेक्ट को ओपन-सोर्स किया। कुबेरनेट्स गूगल के 15 से अधिक वर्षों के अनुभव को समुदाय से सर्वोत्तम नस्ल के विचारों और प्रथाओं के साथ बड़े पैमाने पर उत्पादन कार्यभार को जोड़ती है।

काल में वापस जाना

आइए काल में वापस जाकर एक नज़र डालते हैं कि कुबेरनेट्स इतना उपयोगी क्यों है।

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

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

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

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

कंटेनर डिप्लॉयमेंट युग: कंटेनर VMs के समान होते हैं, लेकिन उनके पास एप्लिकेशनो के बीच ऑपरेटिंग सिस्टम (OS) को साझा करने के लिए अलगाव गुण होते हैं। इसलिए, कंटेनरों को हल्का माना जाता है। वीएम (VM) के समान, एक कंटेनर का अपना फाइल सिस्टम, सीपीयू का हिस्सा, मेमोरी, प्रोसेस स्पेस और बहुत कुछ होता है। चूंकि वे अंतर्निहित बुनियादी ढांचे से अलग हो गए हैं, वे बादलों और ओएस (OS) वितरण में पोर्टेबल हैं।

कंटेनर लोकप्रिय हो गए हैं क्योंकि वे अतिरिक्त लाभ प्रदान करते हैं, जैसे:

• अजाइल (Agile) एप्लिकेशन निर्माण और डिप्लॉयमेंट: VM इमेज उपयोग की तुलना में कंटेनर इमेज निर्माण की आसानी और दक्षता में वृद्धि हुई है।
• निरंतर विकास, एकीकरण और डिप्लॉयमेंट: विश्वसनीय और लगातार कंटेनर इमेज निर्माण और त्वरित और कुशल रोलबैक के साथ तैनाती (इमेज अपरिवर्तनीयता के कारण) प्रदान करता है।
• डेव (Dev) और ऑप्स (Ops) चिंताओं का पृथक्करण: डिप्लॉयमेंट समय के बजाय बिल्ड/रिलीज़ समय पर एप्लिकेशन कंटेनर इमेजेस (images) बनाएं, जिससे बुनियादी ढांचे से एप्लिकेशनो को अलग किया जा सके।
• अवलोकन: न केवल ओएस-स्तर की जानकारी और मेट्रिक्स को सतह पर रखता है, बल्कि एप्लिकेशन स्वास्थ्य और अन्य संकेतों को भी लागू करता है।
• विकास, परीक्षण और उत्पादन में पर्यावरणीय स्थिरता: लैपटॉप पर वैसे ही चलता है जैसे क्लाउड में चलता है।
• क्लाउड और ओएस (OS) वितरण पोर्टेबिलिटी: उबंटू, RHEL, coreOS, ऑन-प्रिमाइसेस, प्रमुख सार्वजनिक क्लाउड पर और कहीं भी चलता है।
• एप्लिकेशन-केंद्रित प्रबंधन: वर्चुअल हार्डवेयर पर OS चलाने से लेकर तार्किक संसाधनों का उपयोग करके OS पर एप्लिकेशन चलाने तक अमूर्तता के स्तर को बढ़ाता है ।
• शिथिल युग्मित, वितरित, लोचदार, मुक्त सूक्ष्म सेवाएँ: एप्लिकेशन को छोटे, स्वतंत्र टुकड़ों में तोड़ा जाता है और उन्हें गतिशील रूप से तैनात और प्रबंधित किया जा सकता है - एक बड़ी एकल-उद्देश्य वाली मशीन पर चलने वाला एक मोनोलिथिक स्टैक नहीं।
• संसाधन अलगाव: अनुमानित एप्लिकेशन प्रदर्शन।
• संसाधन उपयोग: उच्च दक्षता और घनत्व।

आपको कुबेरनेट्स की आवश्यकता क्यों है और यह क्या कर सकता है

कंटेनर आपके एप्लिकेशनो को बंडल करने और चलाने का एक अच्छा तरीका है। उत्पादन के माहौल में, आप को उन कंटेनरों को प्रबंधित करने की आवश्यकता होती है जो एप्लिकेशने चलाते हैं और सुनिश्चित करते हैं कि कोई डाउनटाइम नहीं है। उदाहरण के लिए, यदि एक कंटेनर बंद हो जाता है, तो दूसरे कंटेनर को शुरू करने की आवश्यकता होती है। क्या यह आसान नहीं होगा यदि इस व्यवहार को एक प्रणाली द्वारा नियंत्रित किया जा सके ?

इस तरह कुबेरनेट्स बचाव के लिए आता है! कुबेरनेट्स आपको वितरित सिस्टम को लचीलेपन से चलाने के लिए एक ढांचा प्रदान करता है। यह आपके एप्लिकेशन के लिए स्केलिंग और फेलओवर का ख्याल रखता है, डिप्लॉयमेंट पैटर्न प्रदान करता है, और भी बहुत कुछ। उदाहरण के लिए, कुबेरनेट्स आपके सिस्टम के लिए कैनरी डिप्लॉयमेंट को आसानी से प्रबंधित कर सकता है।

कुबेरनेट्स आपको प्रदान करता है:

• सेवा की खोज और लोड संतुलन कुबेरनेट्स DNS नाम का उपयोग करके या अपने स्वयं के आईपी (IP) पते का उपयोग करके एक कंटेनर को उजागर कर सकता हैं। यदि एक कंटेनर में ट्रैफ़िक अधिक है, तो कुबेरनेट्स लोड बैलेंस करने और नेटवर्क ट्रैफ़िक को वितरित करने में सक्षम है ताकि डिप्लॉयमेंट स्थिर हो।
• स्टोरेज ऑर्केस्ट्रेशन कुबेरनेट्स आपको अपनी पसंद के स्टोरेज सिस्टम को स्वचालित रूप से माउंट करने की अनुमति देता है, जैसे कि स्थानीय स्टोरेज, पब्लिक क्लाउड प्रोवाइडर, और बहुत कुछ।
• स्वचालित रोलआउट और रोलबैक आप कुबेरनेट्स का उपयोग करके अपने तैनात कंटेनरों के लिए वांछित स्थिति का वर्णन कर सकते हैं, और यह वास्तविक स्थिति को नियंत्रित दर पर वांछित स्थिति में बदल सकता है। उदाहरण के लिए, आप अपने डिप्लॉयमेंट के लिए नए कंटेनर बनाने के लिए कुबेरनेट्स को स्वचालित कर सकते हैं, मौजूदा कंटेनरों को हटा सकते हैं और उनके सभी संसाधनों को नए कंटेनर में अपना सकते हैं।
• **स्वचालित बिन पैकिंग ** आप कुबेरनेट्स को नोड्स के एक समूह के साथ प्रदान करते हैं जिसका उपयोग वह कंटेनरीकृत कार्यों को चलाने के लिए कर सकता है। आप कुबेरनेट्स को बताते हैं कि प्रत्येक कंटेनर को कितना सीपीयू और मेमोरी (रैम) चाहिए। कुबेरनेट्स आपके संसाधनों का सर्वोत्तम उपयोग करने के लिए कंटेनरों को आपके नोड्स में फिट कर सकता है।
• सेल्फ-हीलिंग कुबेरनेट्स विफल कंटेनरों को फिर से शुरू करता है, कंटेनरों को बदल देता है, उन कंटेनरों को नष्ट कर देता है जो आपकी उपयोगकर्ता-परिभाषित स्वास्थ्य जांच का जवाब नहीं देते हैं, और जब तक वे सेवा के लिए तैयार नहीं होते हैं, तब तक ग्राहकों को उनका विज्ञापन नहीं करते हैं।
• सीक्रेट और कॉन्फ़िगरेशन प्रबंधन कुबेरनेट्स आपको पासवर्ड, OAuth टोकन और SSH कुंजियों जैसी संवेदनशील जानकारी को संग्रहीत और प्रबंधित करने देता है। आप अपनी कंटेनर इमेजेस (images) के पुनर्निर्माण के बिना, और अपने स्टैक कॉन्फ़िगरेशन में रहस्यों को उजागर किए बिना रहस्यों और एप्लिकेशन कॉन्फ़िगरेशन को तैनात और अपडेट कर सकते हैं।

कुबेरनेट्स क्या नहीं है :

कुबेरनेट्स एक पारंपरिक, सर्व-समावेशी PaaS (एक सेवा के रूप में प्लेटफ़ॉर्म) प्रणाली नहीं है। चूंकि कुबेरनेट्स हार्डवेयर स्तर के बजाय कंटेनर स्तर पर काम करता है, यह कुछ सामान्य रूप से लागू सुविधाओं को प्रदान करता है, जैसे कि तैनाती, स्केलिंग, लोड बैलेंसिंग, और उपयोगकर्ताओं को उनके लॉगिंग, निगरानी और अलर्ट समाधान को एकीकृत करने देता है। हालाँकि, कुबेरनेट्स मोनोलिथिक नहीं है, और ये डिफ़ॉल्ट समाधान वैकल्पिक और प्लग करने योग्य हैं। कुबेरनेट्स डेवलपर प्लेटफॉर्म के निर्माण के लिए बिल्डिंग ब्लॉक्स प्रदान करता है, लेकिन जहां यह महत्वपूर्ण है वहां उपयोगकर्ता की पसंद और लचीलेपन को बरकरार रखता है।

कुबेरनेट्स:

• समर्थित एप्लिकेशनो के प्रकारों को सीमित नहीं करता है। कुबेरनेट्स का उद्देश्य स्टेटलेस, स्टेटफुल और डेटा-प्रोसेसिंग वर्कलोड सहित अत्यंत विविध प्रकार के वर्कलोड का समर्थन करना है। यदि कोई एप्लिकेशन कंटेनर में चल सकता है, तो उसे कुबेरनेट्स पर बहुत अच्छा चलना चाहिए।
• स्रोत कोड डेप्लॉय नहीं करता है और आपके एप्लिकेशन का निर्माण नहीं करता है। कंटीन्यूअस इंटीग्रेशन, डिलीवरी और डिप्लॉयमेंट(CI/CD) कार्यप्रवाह संगठन संस्कृतियों और प्राथमिकताओं के साथ-साथ तकनीकी आवश्यकताओं द्वारा निर्धारित किए जाते हैं।
• एप्लिकेशन-स्तरीय सेवाएं प्रदान नहीं करता है, जैसे कि मिडलवेयर (उदाहरण के लिए, message buses), डेटा-प्रोसेसिंग फ्रेमवर्क (उदाहरण के लिए, spark), डेटाबेस (उदाहरण के लिए, MySQL), कैश, और न ही क्लस्टर स्टोरेज सिस्टम (उदाहरण के लिए, Ceph) अंतर्निहित सेवाओं के रूप में। ऐसे घटक कुबेरनेट्स पर चल सकते हैं, और/या ओपन सर्विस ब्रोकर जैसे पोर्टेबल तंत्र के माध्यम से कुबेरनेट्स पर चल रहे एप्लिकेशनो द्वारा एक्सेस किए जा सकते हैं।
• लॉगिंग, मॉनिटरिंग या अलर्टिंग सॉल्यूशंस को निर्देशित नहीं करता है। यह अवधारणा के प्रमाण के रूप में कुछ एकीकरण प्रदान करता है, और मेट्रिक्स एकत्र करने और निर्यात करने के लिए तंत्र प्रदान करता है।
• कॉन्फ़िगरेशन भाषा/सिस्टम (उदाहरण के लिए, Jsonnet) प्रदान नहीं करता है और न ही अनिवार्य करता है। यह एक घोषणात्मक API प्रदान करता है जिसे घोषणात्मक विनिर्देशों के मनमाने रूपों द्वारा लक्षित किया जा सकता है।
• कोई व्यापक मशीन कॉन्फ़िगरेशन, रखरखाव, प्रबंधन, या स्वयं-उपचार प्रणाली प्रदान नहीं करता है और न ही अपनाता है।
• इसके अतिरिक्त, कुबेरनेट्स केवल एक ऑर्केस्ट्रेशन प्रणाली नहीं है। वास्तव में, यह ऑर्केस्ट्रेशन की आवश्यकता को समाप्त करता है। ऑर्केस्ट्रेशन की तकनीकी परिभाषा एक परिभाषित वर्कफ़्लो का निष्पादन है: पहले ए (A) करें, फिर बी (B), फिर सी (C)। इसके विपरीत, कुबेरनेट्स में स्वतंत्र, कंपोज़ेबल नियंत्रण प्रक्रियाओं का एक सेट शामिल है जो वर्तमान स्थिति को प्रदान की गई वांछित स्थिति की ओर लगातार चलता है। इससे कोई फर्क नहीं पड़ता कि आप ए से सी कैसे प्राप्त करते हैं। केंद्रीकृत नियंत्रण की भी आवश्यकता नहीं है। इसका परिणाम एक ऐसी प्रणाली में होता है जो उपयोग में आसान और अधिक शक्तिशाली, मजबूत, लचीला और एक्स्टेंसिबल है।

आगे क्या है

• कुबेरनेट्स के घटक पर एक नज़र डालें ।
• क्या आप शुरू करने के लिए तैयार हैं?

3.2 - सर्विसेज, लोड बैलेंसिंग और नेटवर्किंग

कुबेर्नेट्स नेटवर्क मॉडल

कुबेर्नेट्स नेटवर्क मॉडल कई हिस्सों से बना है:

• क्लस्टर में प्रत्येक पॉड को अपना विशिष्ट क्लस्टर-व्यापी IP एड्रेस मिलता है।

क्लस्टर में प्रत्येक पॉड को अपना विशिष्ट क्लस्टर-व्यापी IP एड्रेस मिलता है।

• एक पॉड का अपना निजी नेटवर्क नेमस्पेस होता है जिसे उस पॉड के सभी कंटेनर आपस में साझा करते हैं। एक ही पॉड में अलग-अलग कंटेनरों में चलने वाले प्रोसेस localhost के माध्यम से एक-दूसरे से बात कर सकते हैं।

• पॉड नेटवर्क (जिसे क्लस्टर नेटवर्क भी कहा जाता है) पॉड्स के बीच संचार को संभालता है। यह सुनिश्चित करता है कि (जानबूझकर नेटवर्क विभाजन को छोड़कर):

  • सभी पॉड्स सभी अन्य पॉड्स से बात कर सकते हैं, चाहे वे एक ही नोड पर हों या अलग-अलग नोड्स पर। पॉड्स सीधे एक-दूसरे से बिना किसी प्रॉक्सी या एड्रेस ट्रांसलेशन (NAT) के बात कर सकते हैं।

    Windows पर, यह नियम होस्ट-नेटवर्क पॉड्स पर लागू नहीं होता।

  • नोड पर एजेंट (जैसे सिस्टम डेमॉन या kubelet) उस नोड पर सभी पॉड्स से बात कर सकते हैं।

• सर्विस API आपको एक स्थायी IP एड्रेस या होस्टनेम प्रदान करता है जो एक या अधिक बैकएंड पॉड्स द्वारा चलाई जा रही सर्विस के लिए होता है। सर्विस बनाने वाले पॉड्स समय के साथ बदल सकते हैं।

  • कुबेर्नेट्स अपने आप एंडपॉइंटस्लाइस ऑब्जेक्ट्स को मैनेज करता है ताकि सर्विस के वर्तमान पॉड्स की जानकारी उपलब्ध रहे।

  • एक सर्विस प्रॉक्सी इम्प्लीमेंटेशन Service और EndpointSlice ऑब्जेक्ट्स के सेट की निगरानी करता है और डेटा प्लेन को प्रोग्राम करता है ताकि सर्विस ट्रैफिक को उसके बैकएंड्स तक रूट किया जा सके। यह ऑपरेटिंग सिस्टम या क्लाउड प्रोवाइडर के API का उपयोग करके पैकेट्स को इंटरसेप्ट या रीराइट करता है।

• गेटवे API (या इसका पहले का वर्जन, इंग्रेस) आपको क्लस्टर के बाहर के क्लाइंट्स के लिए सर्विसेज को एक्सेस करने की सुविधा देता है।

  • क्लस्टर में बाहर से एक्सेस के लिए एक सरल, लेकिन कम कॉन्फ़िगर करने योग्य तरीका सर्विस API के type: LoadBalancer के माध्यम से उपलब्ध है, जब एक सपोर्टेड क्लाउड प्रदाता (Cloud Provider) का उपयोग किया जाता है।

• नेटवर्क पॉलिसी एक बिल्ट-इन Kubernetes API है जो आपको पॉड्स के बीच या पॉड्स और बाहरी दुनिया के बीच ट्रैफ़िक को नियंत्रित करने की अनुमति देता है।

पुराने कंटेनर सिस्टम में, विभिन्न होस्ट्स पर कंटेनरों के बीच स्वचालित कनेक्टिविटी नहीं होती थी, इसलिए कंटेनरों के बीच स्पष्ट लिंक बनाना या अन्य होस्ट्स पर कंटेनरों द्वारा उन्हें सुलभ बनाने के लिए कंटेनर पोर्ट्स को होस्ट पोर्ट्स पर मैप करना अक्सर आवश्यक होता था। Kubernetes में यह आवश्यक नहीं है; Kubernetes का मॉडल है कि पॉड्स को VMs या भौतिक होस्ट्स की तरह माना जा सकता है, पोर्ट आवंटन, नामकरण, सर्विस डिस्कवरी, लोड बैलेंसिंग, एप्लिकेशन कॉन्फ़िगरेशन और माइग्रेशन के दृष्टिकोण से।

इस मॉडल के केवल कुछ हिस्से ही Kubernetes द्वारा स्वयं लागू किए जाते हैं। अन्य भागों के लिए, Kubernetes API को परिभाषित करता है, लेकिन संबंधित कार्यक्षमता बाहरी घटकों द्वारा प्रदान की जाती है, जिनमें से कुछ वैकल्पिक हैं:

• पॉड नेटवर्क नेमस्पेस सेटअप कंटेनर रनटाइम इंटरफ़ेस को लागू करने वाले सिस्टम-स्तरीय सॉफ़्टवेयर द्वारा संभाला जाता है।

• पॉड नेटवर्क का प्रबंधन एक पॉड नेटवर्क कार्यान्वयन द्वारा किया जाता है। Linux पर, अधिकांश कंटेनर रनटाइम्स पॉड नेटवर्क कार्यान्वयन के साथ इंटरैक्ट करने के लिए कंटेनर नेटवर्किंग इंटरफ़ेस (CNI) का उपयोग करते हैं, इसलिए इन कार्यान्वयनों को अक्सर CNI प्लगइन्स कहा जाता है।

• Kubernetes सर्विस प्रॉक्सींग का एक डिफ़ॉल्ट कार्यान्वयन प्रदान करता है, जिसे kube-proxy कहा जाता है, लेकिन कुछ पॉड नेटवर्क कार्यान्वयन इसके बजाय अपने स्वयं के सर्विस प्रॉक्सी का उपयोग करते हैं जो शेष कार्यान्वयन के साथ अधिक दृढ़ता से एकीकृत होता है।

• NetworkPolicy आमतौर पर पॉड नेटवर्क कार्यान्वयन द्वारा भी लागू की जाती है। (कुछ सरल पॉड नेटवर्क कार्यान्वयन NetworkPolicy को लागू नहीं करते हैं, या एक व्यवस्थापक पॉड नेटवर्क को NetworkPolicy समर्थन के बिना कॉन्फ़िगर करना चुन सकता है। इन मामलों में, API अभी भी मौजूद होगा, लेकिन उसका कोई प्रभाव नहीं होगा।)

• गेटवे API के कई कार्यान्वयन हैं, जिनमें से कुछ विशेष क्लाउड ए

आगे क्या है

सर्विसेज के साथ अनुप्रयोगों को कनेक्ट करना ट्यूटोरियल आपको एक व्यावहारिक उदाहरण के साथ सर्विसेज और Kubernetes नेटवर्किंग के बारे में सीखने में मदद करता है।

क्लस्टर नेटवर्किंग बताता है कि अपने क्लस्टर के लिए नेटवर्किंग कैसे सेटअप करें, और शामिल प्रौद्योगिकियों का एक समीक्षा भी प्रदान करता है।

3.3 - नीतियाँ

Kubernetes नीतियाँ वे कॉन्फ़िगरेशन होती हैं जो अन्य कॉन्फ़िगरेशन या रनटाइम व्यवहारों को प्रबंधित करती हैं। Kubernetes विभिन्न प्रकार की नीतियाँ प्रदान करता है, जो नीचे दी गई हैं:

API ऑब्जेक्ट्स का उपयोग करके नीतियाँ लागू करें

कुछ API ऑब्जेक्ट्स नीतियों के रूप में कार्य करते हैं। यहाँ कुछ उदाहरण दिए गए हैं:

• NetworkPolicies का उपयोग किसी वर्कलोड के लिए इनग्रेस और एग्रेस ट्रैफिक को प्रतिबंधित करने के लिए किया जा सकता है।
• LimitRanges विभिन्न ऑब्जेक्ट प्रकारों के बीच संसाधन आवंटन सीमाओं का प्रबंधन करते हैं।
• ResourceQuotas किसी नेमस्पेस के लिए संसाधन खपत को सीमित करती हैं।

Admission Controllers का उपयोग करके नीतियाँ लागू करें

एक admission controller API सर्वर में चलता है और API अनुरोधों को सत्यापित या बदल सकता है। कुछ admission controllers नीतियों को लागू करने के लिए कार्य करते हैं। उदाहरण के लिए, AlwaysPullImages admission controller प्रत्येक नए Pod में इमेज पुल नीति को Always पर सेट करने के लिए सक्षम करता है।

Kubernetes के पास कई अंतर्निहित admission controllers हैं जिन्हें API सर्वर --enable-admission-plugins फ्लैग के माध्यम से कॉन्फ़िगर किया जा सकता है।

Admission controllers के बारे में विस्तृत जानकारी, उपलब्ध admission controllers की पूरी सूची के साथ, एक समर्पित अनुभाग में प्रलेखित है:

• Admission Controllers

ValidatingAdmissionPolicy का उपयोग करके नीतियाँ लागू करें

Validating admission policies, API सर्वर में कॉन्फ़िगर करने योग्य सत्यापन जांचों को लागू करने की अनुमति देती हैं, जो Common Expression Language (CEL) का उपयोग करती हैं। उदाहरण के लिए, एक ValidatingAdmissionPolicy का उपयोग latest इमेज टैग के उपयोग को अस्वीकृत करने के लिए किया जा सकता है।

एक ValidatingAdmissionPolicy एक API अनुरोध पर कार्य करता है और गैर-अनुपालन कॉन्फ़िगरेशनों के बारे में उपयोगकर्ताओं को ब्लॉक, ऑडिट, और चेतावनी देने के लिए उपयोग किया जा सकता है।

ValidatingAdmissionPolicy API के बारे में विवरण, उदाहरणों सहित, एक समर्पित अनुभाग में प्रलेखित है:

• Validating Admission Policy

Dynamic admission control का उपयोग करके नीतियाँ लागू करें

Dynamic admission controllers (या admission webhooks) API सर्वर के बाहर एक अलग एप्लिकेशन के रूप में चलते हैं जो API अनुरोधों के सत्यापन या संशोधन के लिए वेबहुक अनुरोधों को प्राप्त करने के लिए पंजीकृत होते हैं।

Dynamic admission controllers का उपयोग API अनुरोधों पर नीतियाँ लागू करने और अन्य नीति-आधारित वर्कफ़्लोज़ को ट्रिगर करने के लिए किया जा सकता है। एक dynamic admission controller ऐसी जटिल जांच कर सकता है, जिसमें अन्य क्लस्टर संसाधनों और बाहरी डेटा की पुनर्प्राप्ति की आवश्यकता होती है। उदाहरण के लिए, एक इमेज सत्यापन जांच OCI रजिस्ट्रियों से डेटा प्राप्त करके कंटेनर इमेज हस्ताक्षर और प्रमाणपत्रों को मान्य करने के लिए उपयोग की जा सकती है।

Dynamic admission control के बारे में विवरण एक समर्पित अनुभाग में प्रलेखित है:

• Dynamic Admission Control

Implementations

Dynamic admission controllers जो फ्लेक्सिबल नीति इंजन के रूप में कार्य करते हैं, उन्हें कुबेरनेट्स इकोसिस्टम में विकसित किया जा रहा है, जैसे की:

• Kubewarden
• Kyverno
• OPA Gatekeeper
• Polaris

Kubelet कॉन्फ़िगरेशनों का उपयोग करके नीतियाँ लागू करें

Kubernetes प्रत्येक वर्कर नोड पर Kubelet को कॉन्फ़िगर करने की अनुमति देता है। कुछ Kubelet कॉन्फ़िगरेशन नीतियों के रूप में कार्य करते हैं:

• Process ID limits and reservations का उपयोग आवंटन योग्य PIDs को सीमित और आरक्षित करने के लिए किया जाता है।
• Node Resource Managers उच्च-प्रदर्शन और विलंब-संवेदनशील वर्कलोड्स के लिए कंप्यूट, मेमोरी, और डिवाइस संसाधनों का प्रबंधन कर सकते हैं।

4 - कार्य

कुबेरनेट्स प्रलेखन के इस खंड के पृष्ठ एकल कार्य करने का तरीका दिखाते हैं। आमतौर पर, कार्य पृष्ठ दिखाता है कि किसी एक काम को कई छोटे चरणों में विभाजित करके कैसे करना है।

यदि आप एक कार्य पृष्ठ लिखना चाहते हैं, तो देखें प्रलेखन के लिए एक पुल अनुरोध (Pull Request) बनाएं.

4.1 - उपकरण स्थापित करें

kubectl

कुबेरनेट्स कमांड-लाइन टूल, kubectl, आपको कुबेरनेट्स क्लस्टर पर कमांड चलाने की अनुमति देता है।

आप एप्लिकेशन को डिप्लॉय करने, क्लस्टर संसाधनों का निरीक्षण और प्रबंधन करने और लॉग देखने के लिए kubectl का उपयोग कर सकते हैं।

kubectl संचालन की पूरी सूची सहित अधिक जानकारी के लिए, देखें kubectl संदर्भ प्रलेखन.

kubectl विभिन्न प्रकार के Linux प्लेटफॉर्म, macOS और Windows पर इंस्टॉल करने योग्य है। नीचे अपना उपयुक्त ऑपरेटिंग सिस्टम खोजें।

• kubectl Linux पर इंस्टॉल करें
• kubectl macOS पर इंस्टॉल करें
• kubectl Windows पर इंस्टॉल करें

kind

kind आपको अपने कंप्यूटर पर कुबेरनेट्स चलाने देता है। इस उपकरण के लिए आवश्यक है कि आपके पास Docker इंस्टॉल और कॉन्फ़िगर किया गया हो।

kind क्विक स्टार्ट पृष्ठ आपको दिखाता है कि kind चलाने के लिए आपको क्या करने की आवश्यकता है।

kind क्विक स्टार्ट गाइड देखें

minikube

kind की तरह, minikube एक उपकरण है जो आपको स्थानीय स्तर पर कुबेरनेट्स चलाने देता है। minikube आपके कंप्यूटर (windows, macOS और linux पीसी सहित) पर सिंगल-नोड कुबेरनेट्स क्लस्टर चलाता है ताकि आप कुबेरनेट्स सीख सकें या डेवलपमेंट कर सकें।

यदि आपका ध्यान उपकरण को इंस्टॉल करने पर है तो आप मुख्य आरंभ करें! गाइड का अनुसरण कर सकते हैं।

minikube क्विक स्टार्ट गाइड देखें

एक बार जब आपके पास minikube काम कर रहा हो, तो आप इसका उपयोग नमूना एप्लिकेशन चलाने के लिए कर सकते हैं।

kubeadm

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

kubeadm इंस्टॉल करना आपको दिखाता है कि kubeadm को कैसे इंस्टॉल किया जाए। एक बार इंस्टॉल होने के बाद, आप इसका उपयोग क्लस्टर बनाने के लिए कर सकते हैं।

kubeadm इंस्टॉल गाइड देखें

4.1.1 - Linux पर kubectl इंस्टॉल और सेट अप करें

शुरू करने से पहले

आप kubectl संस्करण का उपयोग करे जो आपके क्लस्टर के एक माइनर संस्करण के भीतर हो। उदाहरण के लिए, v1.33 क्लाइंट v1.32, v1.33 और v1.34 कण्ट्रोल प्लेन के साथ संवाद कर सकते हैं। kubectl के नवीनतम संस्करण का उपयोग करने से अप्रत्याशित मुद्दों से बचने में मदद मिलती है।

Linux पर kubectl इंस्टॉल करें

Linux पर kubectl संस्थापित करने के लिए निम्नलिखित विधियाँ मौजूद हैं:

• Linux पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें
• नेटिव पैकेज मैनेजमेंट के माध्यम से इंस्टॉल करें
• अन्य पैकेज मैनेजमेंट के माध्यम से इंस्टॉल करें

Linux पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें

1. कमांड से नवीनतम रिलीज डाउनलोड करें:

   curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
   

   टिप्पणी:

   एक विशिष्ट संस्करण डाउनलोड करने के लिए, कमांड के $(curl -L -s https://dl.k8s.io/release/stable.txt) हिस्से को विशिष्ट संस्करण से बदलें।

   उदाहरण के लिए, लिनक्स पर 1.33.0 संस्करण डाउनलोड करने के लिए, टाइप करें:

   curl -LO https://dl.k8s.io/release/v1.33.0/bin/linux/amd64/kubectl
   

2. बाइनरी को मान्य करें (वैकल्पिक)

kubectl चेकसम फाइल डाउनलोड करें:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"

चेकसम फ़ाइल से kubectl बाइनरी को मान्य करें:

echo "$(<kubectl.sha256) kubectl" | sha256sum --check

यदि मान्य है, तो आउटपुट है:

kubectl: OK

अगर चेक फेल हो जाता है, तो sha256 nonzero स्थिति के साथ बाहर निकलता है और इस आउटपुट के समान प्रिंट करता है:

kubectl: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

1. kubectl इंस्टॉल करें

   sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
   

   टिप्पणी:

   यदि आपके पास टारगेट सिस्टम पर रुट एक्सेस नहीं है, आप तब भी kubectl को ~/.local/bin डायरेक्टरी में इंस्टॉल कर सकते हैं:

   chmod +x kubectl
   mkdir -p ~/.local/bin/kubectl
   mv ./kubectl ~/.local/bin/kubectl
   # and then add ~/.local/bin/kubectl to $PATH
   

2. यह सुनिश्चित करने के लिए परीक्षण करें कि आपके द्वारा इंस्टॉल किया गया संस्करण उप-टू-डेट है:

   kubectl version --client
   

नेटिव पैकेज मैनेजमेंट के माध्यम से इंस्टॉल करें

• Debian-based distributions
• Red Hat-based distributions

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF
yum install -y kubectl

अन्य पैकेज मैनेजमेंट के माध्यम से इंस्टॉल करें

• Snap
• Homebrew

snap install kubectl --classic
kubectl version --client

brew install kubectl
kubectl version --client

kubectl कॉन्फ़िगरेशन सत्यापित करें

kubectl को कुबेरनेट्स क्लस्टर को खोजने और एक्सेस करने के लिए, उसे क्यूबकॉन्फिग फाइल(kubeconfig) की आवश्यकता होती है, जो स्वचालित रूप से तब बनता है जब आप kube-up.sh का उपयोग करके क्लस्टर बनाते हैं या मिनीक्यूब क्लस्टर को सफलतापूर्वक डिप्लॉय करते हैं। डिफ़ॉल्ट रूप से, kubectl कॉन्फ़िगरेशन ~/.kube/config पर स्थित होता है।

जाँच करें कि क्लस्टर स्टेट प्राप्त करके kubectl को ठीक से कॉन्फ़िगर किया गया है:

kubectl cluster-info

यदि आपको एक URL प्रतिक्रिया दिखती हैं, तो kubectl आपके क्लस्टर तक पहुँचने के लिए सही ढंग से कॉन्फ़िगर हुआ है।

यदि आपको निम्नलिखित संदेश दिखाई देता है, तो kubectl ठीक से कॉन्फ़िगर नहीं हुआ है या कुबेरनेट्स क्लस्टर से कनेक्ट करने में सक्षम नहीं है।

The connection to the server <server-name:port> was refused - did you specify the right host or port?

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

यदि kubectl cluster-info URL प्रतिक्रिया देता है, लेकिन आप अपने क्लस्टर को एक्सेस नहीं कर पा रहें हैं, तो यह जाँचने के लिए कि क्या यह ठीक से कॉन्फ़िगर किया गया है, इस कमांड का उपयोग करें:

kubectl cluster-info dump

वैकल्पिक kubectl कॉन्फ़िगरेशन और प्लगइन्स

शेल ऑटोकम्प्लेशन सक्षम करें

kubectl Bash और Zsh के लिए ऑटोकम्प्लेशन का सपोर्ट प्रदान करता है, जो आपका काफी समय बचा सकता है।

नीचे Bash और Zsh के लिए ऑटोकम्प्लेशन स्थापित करने की प्रक्रियाएँ हैं।

• Bash
• Zsh

source /usr/share/bash-completion/bash_completion

echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -F __start_kubectl k' >>~/.bashrc

source <(kubectl completion zsh)

echo 'alias k=kubectl' >>~/.zshrc
echo 'complete -F __start_kubectl k' >>~/.zshrc

autoload -Uz compinit
compinit

kubectl convert प्लगइन इंस्टॉल करें

कुबेरनेट्स कमांड-लाइन टूल kubectl के लिए एक प्लगइन, जो आपको विभिन्न API संस्करण के बीच मैनिफ़ेस्ट को बदलने करने की अनुमति देता है। यह विशेष रूप से नए कुबेरनेट्स रिलीज के साथ एक गैर-बहिष्कृत API संस्करण में मैनिफेस्ट को माइग्रेट करने में सहायक हो सकता है। अधिक जानकारी के लिए, गैर पदावनत एपिस में विस्थापित करें पर जाएं।

1. कमांड से नवीनतम रिलीज डाउनलोड करें:

   curl -LO https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert
   

2. बाइनरी को मान्य करें (वैकल्पिक)

   kubectl-convert चेकसम फ़ाइल डाउनलोड करें:

   curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert.sha256"
   

   चेकसम फ़ाइल से kubectl-convert बाइनरी को मान्य करें:

   echo "$(<kubectl-convert.sha256) kubectl-convert" | sha256sum --check
   

   यदि मान्य है, तो आउटपुट है:

   kubectl-convert: OK
   

   अगर चेक फेल हो जाता है, तो sha256 nonzero स्थिति के साथ बाहर निकलता है और इस आउटपुट के समान प्रिंट करता है:

   kubectl-convert: FAILED
   sha256sum: WARNING: 1 computed checksum did NOT match
   

   टिप्पणी:

   बाइनरी और चेकसम का एक ही संस्करण डाउनलोड करें।

3. kubectl-convert इंस्टॉल करें

   sudo install -o root -g root -m 0755 kubectl-convert /usr/local/bin/kubectl-convert
   

4. सत्यापित करें कि प्लगइन सफलतापूर्वक इंस्टॉल है

   kubectl convert --help
   

   यदि आपको कोई त्रुटि नहीं दिखाई देती है, तो इसका मतलब है कि प्लगइन सफलतापूर्वक इंस्टॉल हो गया है।

आगे क्या है

• मिनीक्यूब (Minikube) इंस्टॉल करें
• क्लस्टर बनाने के बारे में अधिक जानकारी के लिए आरंभ करने की मार्गदर्शिका देखें।
• अपने एप्लिकेशन को लॉन्च और एक्सपोज़ करने का तरीका जानें।
• यदि आपको किसी ऐसे क्लस्टर को उपयोग करने की आवश्यकता है जिसे आपने नहीं बनाया है, तो क्लस्टर एक्सेस दस्तावेज़ साझा करना देखें।
• kubectl संदर्भ प्रलेखन पढ़ें।

4.1.2 - macOS पर kubectl इंस्टॉल और सेटअप करें

शुरू करने से पहले

आप kubectl संस्करण का उपयोग करे जो आपके क्लस्टर के एक माइनर संस्करण भीतर हो। उदाहरण के लिए, v1.33 क्लाइंट v1.32, v1.33 और v1.34 कण्ट्रोल प्लेन के साथ कम्युनिकेट कर सकते हैं। kubectl के नए संस्करण का उपयोग करने से समस्या से बचत हो सकती है।

macOS पर kubectl इंस्टॉल करें

macOS पर kubectl संस्थापित करने के लिए निम्नलिखित विधियाँ मौजूद हैं:

• macOS पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें
• Homebrew के माध्यम से macOS पर इंस्टॉल करें
• Macports के माध्यम से macOS पर इंस्टॉल करें

macOS पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें

1. नवीनतम रिलीज़ डाउनलोड करें:

   • Intel
   • Apple Silicon

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl"
      

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl"
      

   टिप्पणी:

   एक विशिष्ट संस्करण डाउनलोड करने के लिए, कमांड के इस हिस्से $(curl -L -s https://dl.k8s.io/release/stable.txt) को विशिष्ट संस्करण से बदलें।

   उदाहरण के लिए, Intel macOS पर 1.33.0 संस्करण डाउनलोड करने के लिए, टाइप करें:

   curl -LO "https://dl.k8s.io/release/v1.33.0/bin/darwin/amd64/kubectl"
   

   और Apple Silicon macOS के लिए, टाइप करें:

   curl -LO "https://dl.k8s.io/release/v1.33.0/bin/darwin/arm64/kubectl"
   

2. बाइनरी को मान्य करें (वैकल्पिक))

   kubectl चेकसम फाइल डाउनलोड करें:

   • Intel
   • Apple Silicon

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl.sha256"
      

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl.sha256"
      

   चेकसम फ़ाइल से kubectl बाइनरी को मान्य करें:

   echo "$(<kubectl.sha256)  kubectl" | shasum -a 256 --check
   

   यदि मान्य है, तो आउटपुट है:

   kubectl: OK
   

   अगर चेक फेल हो जाता है, तो shasum nonzero स्थिति के साथ बाहर निकलता है और इस आउटपुट के समान प्रिंट करता है:

   kubectl: FAILED
   shasum: WARNING: 1 computed checksum did NOT match
   

   टिप्पणी:

   बाइनरी और चेकसम का एक ही संस्करण डाउनलोड करें।

3. kubectl बाइनरी को एक्सेक्यूट करने योग्य बनायें।

   chmod +x ./kubectl
   

4. kubectl बाइनरी को अपने सिस्टम PATH के फ़ाइल स्थान पर ले जाएँ।

   sudo mv ./kubectl /usr/local/bin/kubectl
   sudo chown root: /usr/local/bin/kubectl
   

   टिप्पणी:

   सुनिश्चित करें कि /usr/local/bin आपके पाथ एनवायरनमेंट वेरिएबल में है।

5. यह सुनिश्चित करने के लिए परीक्षण करें कि आपके द्वारा इंस्टॉल किया गया संस्करण उप-टू-डेट है:

   kubectl version --client
   

Homebrew के माध्यम से macOS पर इंस्टॉल करें

यदि आप macOS पर हैं और Homebrew पैकेज मैनेजर का उपयोग कर रहे हैं, आप Homebrew के साथ kubectl इंस्टॉल कर सकते हैं।

1. इंस्टालेशन कमांड रन करें:

   brew install kubectl 
   

   या

   brew install kubernetes-cli
   

2. यह सुनिश्चित करने के लिए परीक्षण करें कि आपके द्वारा इंस्टॉल किया गया संस्करण उप-टू-डेट है:

   kubectl version --client
   

Macports के माध्यम से macOS पर इंस्टॉल करें

यदि आप macOS पर हैं और Macports पैकेज मैनेजर का उपयोग कर रहे हैं, आप Macports के साथ kubectl इंस्टॉल कर सकते हैं।

1. इंस्टालेशन कमांड रन करें:

   sudo port selfupdate
   sudo port install kubectl
   

2. यह सुनिश्चित करने के लिए परीक्षण करें कि आपके द्वारा इंस्टॉल किया गया संस्करण उप-टू-डेट है:

   kubectl version --client
   

kubectl कॉन्फ़िगरेशन सत्यापित करें

kubectl को कुबेरनेट्स क्लस्टर को खोजने और एक्सेस करने के लिए, उसे क्यूबकॉन्फिग फाइल(kubeconfig) की आवश्यकता होती है, जो स्वचालित रूप से तब बनता है जब आप kube-up.sh का उपयोग करके क्लस्टर बनाते हैं या मिनीक्यूब क्लस्टर को सफलतापूर्वक डिप्लॉय करते हैं। डिफ़ॉल्ट रूप से, kubectl कॉन्फ़िगरेशन ~/.kube/config पर स्थित होता है।

जाँच करें कि क्लस्टर स्टेट प्राप्त करके kubectl को ठीक से कॉन्फ़िगर किया गया है:

kubectl cluster-info

यदि आपको एक URL प्रतिक्रिया दिखती हैं, तो kubectl आपके क्लस्टर तक पहुँचने के लिए सही ढंग से कॉन्फ़िगर हुआ है।

यदि आपको निम्नलिखित संदेश दिखाई देता है, तो kubectl ठीक से कॉन्फ़िगर नहीं हुआ है या कुबेरनेट्स क्लस्टर से कनेक्ट करने में सक्षम नहीं है।

The connection to the server <server-name:port> was refused - did you specify the right host or port?

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

यदि kubectl cluster-info URL प्रतिक्रिया देता है, लेकिन आप अपने क्लस्टर को एक्सेस नहीं कर पा रहें हैं, तो यह जाँचने के लिए कि क्या यह ठीक से कॉन्फ़िगर किया गया है, इस कमांड का उपयोग करें:

kubectl cluster-info dump

वैकल्पिक Kubectl कॉन्फ़िगरेशन और प्लगइन्स

शेल ऑटोकम्प्लेशन सक्षम करें

kubectl Bash और Zsh के लिए ऑटोकम्प्लेशन का सपोर्ट प्रदान करता है, जो आपका काफी समय बचा सकता है।

नीचे Bash और Zsh के लिए ऑटोकम्प्लेशन स्थापित करने की प्रक्रियाएँ हैं।

• Bash
• Zsh

echo $BASH_VERSION

brew install bash

echo $BASH_VERSION $SHELL

brew install bash-completion@2

export BASH_COMPLETION_COMPAT_DIR="/usr/local/etc/bash_completion.d"

[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . "/usr/local/etc/profile.d/bash_completion.sh"

source <(kubectl completion zsh)

echo 'alias k=kubectl' >>~/.zshrc
echo 'complete -F __start_kubectl k' >>~/.zshrc

autoload -Uz compinit
compinit

kubectl convert प्लगइन इंस्टॉल करें

कुबेरनेट्स कमांड-लाइन टूल kubectl के लिए एक प्लगइन, जो आपको विभिन्न API संस्करण के बीच मैनिफ़ेस्ट को बदलने करने की अनुमति देता है। यह विशेष रूप से नए कुबेरनेट्स रिलीज के साथ एक गैर-बहिष्कृत API संस्करण में मैनिफेस्ट को माइग्रेट करने में सहायक हो सकता है। अधिक जानकारी के लिए, गैर पदावनत एपिस में विस्थापित करें पर जाएं।

1. इस कमांड से नवीनतम रिलीज डाउनलोड करें:

   • Intel
   • Apple Silicon

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl-convert"
      

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl-convert"
      

2. बाइनरी को मान्य करें (वैकल्पिक)

   kubectl-convert चेकसम फ़ाइल डाउनलोड करें:

   • Intel
   • Apple Silicon

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl-convert.sha256"
      

   
      curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl-convert.sha256"
      

   चेकसम फ़ाइल से kubectl-convert बाइनरी को मान्य करें:

   echo "$(<kubectl-convert.sha256)  kubectl-convert" | shasum -a 256 --check
   

   यदि मान्य है, तो आउटपुट है:

   kubectl-convert: OK
   

   अगर चेक फेल हो जाता है, तो sha256 nonzero स्थिति के साथ बाहर निकलता है और इस आउटपुट के समान प्रिंट करता है:

   kubectl-convert: FAILED
   shasum: WARNING: 1 computed checksum did NOT match
   

   टिप्पणी:

   बाइनरी और चेकसम का एक ही संस्करण डाउनलोड करें।

3. Kubectl-कन्वर्ट बाइनरी को एक्सेक्यूट करने योग्य बनाएं

   chmod +x ./kubectl-convert
   

4. kubectl-convert binary बाइनरी को अपने सिस्टम PATH के फ़ाइल स्थान पर ले जाएँ।

   sudo mv ./kubectl-convert /usr/local/bin/kubectl-convert
   sudo chown root: /usr/local/bin/kubectl-convert
   

   टिप्पणी:

   सुनिश्चित करें कि /usr/local/bin आपके पाथ एनवायरनमेंट वेरिएबल में है।

5. सत्यापित करें कि प्लगइन सफलतापूर्वक इंस्टॉल हो गया है

   kubectl convert --help
   

   यदि आपको कोई त्रुटि नहीं दिखाई देती है, तो इसका मतलब है कि प्लगइन सफलतापूर्वक इंस्टॉल हो गया है।

आगे क्या है

• मिनीक्यूब (Minikube) इंस्टॉल करें
• क्लस्टर बनाने के बारे में अधिक जानकारी के लिए आरंभ करने की मार्गदर्शिका देखें।
• अपने एप्लिकेशन को लॉन्च और एक्सपोज़ करने का तरीका जानें।
• यदि आपको किसी ऐसे क्लस्टर को उपयोग करने की आवश्यकता है जिसे आपने नहीं बनाया है, तो क्लस्टर एक्सेस दस्तावेज़ साझा करना देखें।
• kubectl संदर्भ प्रलेखन पढ़ें।

4.1.3 - Windows पर kubectl इंस्टॉल और सेटअप करें

शुरू करने से पहले

आप kubectl संस्करण का उपयोग करे जो आपके क्लस्टर के एक माइनर संस्करण भीतर हो। उदाहरण के लिए, v1.33 क्लाइंट v1.32, v1.33 और v1.34 कण्ट्रोल प्लेन के साथ कम्युनिकेट कर सकते हैं। kubectl के नए संस्करण का उपयोग करने से समस्या से बचत हो सकती है।

Windows पर kubectl इंस्टॉल करें

Windows पर kubectl संस्थापित करने के लिए निम्नलिखित विधियाँ मौजूद हैं:

• Windows पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें
• Chocolatey या Scoop का उपयोग करके Windows पर इंस्टॉल करें

Windows पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें

1. latest release 1.33.0 डाउनलोड करें।

   या यदि आपके पास curl है, तो इस कमांड का उपयोग करें:

   curl -LO https://dl.k8s.io/release/v1.33.0/bin/windows/amd64/kubectl.exe
   

   टिप्पणी:

   नवीनतम स्थिर संस्करण का पता लगाने के लिए (जैसे, स्क्रिप्टिंग के लिए), https://dl.k8s.io/release/stable.txt पर एक नज़र डालें।

2. बाइनरी को मान्य करें (वैकल्पिक)

   kubectl चेकसम फाइल डाउनलोड करें:

   curl -LO https://dl.k8s.io/v1.33.0/bin/windows/amd64/kubectl.exe.sha256
   

   चेकसम फ़ाइल से kubectl बाइनरी को मान्य करें:

   • मैन्युअल रूप से कमांड प्रॉम्प्ट का उपयोग करके CertUtil के आउटपुट की तुलना डाउनलोडेड चेकसम फ़ाइल से करें:

     CertUtil -hashfile kubectl.exe SHA256
     type kubectl.exe.sha256
     

   • True या False परिणाम प्राप्त करने के लिए -eq ऑपरेटर का उपयोग करके सत्यापन को ऑटोमेट करने के लिए powershell का उपयोग करें:

      $(Get-FileHash -Algorithm SHA256 .\kubectl.exe).Hash -eq $(Get-Content .\kubectl.exe.sha256)
     

3. अपने PATH में बाइनरी जोड़ें।

4. यह सुनिश्चित करने के लिए परीक्षण करें कि kubectl संस्करण डाउनलोड के समान है:

   kubectl version --client
   

Chocolatey या Scoop का उपयोग करके Windows पर इंस्टॉल करें

1. Windows पर kubectl इंस्टॉल करने के लिए आप या तो Chocolatey पैकेज मैनेजर अथवा Scoop कमांड-लाइन इंस्टॉलर का उपयोग कर सकते हैं।

   • choco
   • scoop

   choco install kubernetes-cli
   

   scoop install kubectl
   

2. यह सुनिश्चित करने के लिए परीक्षण करें कि आपके द्वारा इंस्टॉल किया गया संस्करण उप-टू-डेट है:

   kubectl version --client
   

3. अपनी होम डायरेक्टरी पर जाएं:

   # यदि आप cmd.exe का प्रयोग कर रहे हैं, तो: cd %USERPROFILE%
   cd ~
   

4. .kube डायरेक्टरी बनाएं:

   mkdir .kube
   

5. आपके द्वारा अभी बनाई गई .kube डायरेक्टरी में जाएं:

   cd .kube
   

6. दूरस्थ कुबेरनेट्स क्लस्टर का उपयोग करने के लिए kubectl को कॉन्फ़िगर करें:

   New-Item config -type file
   

kubectl कॉन्फ़िगरेशन सत्यापित करें

kubectl को कुबेरनेट्स क्लस्टर को खोजने और एक्सेस करने के लिए, उसे क्यूबकॉन्फिग फाइल(kubeconfig) की आवश्यकता होती है, जो स्वचालित रूप से तब बनता है जब आप kube-up.sh का उपयोग करके क्लस्टर बनाते हैं या मिनीक्यूब क्लस्टर को सफलतापूर्वक डिप्लॉय करते हैं। डिफ़ॉल्ट रूप से, kubectl कॉन्फ़िगरेशन ~/.kube/config पर स्थित होता है।

जाँच करें कि क्लस्टर स्टेट प्राप्त करके kubectl को ठीक से कॉन्फ़िगर किया गया है:

kubectl cluster-info

यदि आपको एक URL प्रतिक्रिया दिखती हैं, तो kubectl आपके क्लस्टर तक पहुँचने के लिए सही ढंग से कॉन्फ़िगर हुआ है।

यदि आपको निम्नलिखित संदेश दिखाई देता है, तो kubectl ठीक से कॉन्फ़िगर नहीं हुआ है या कुबेरनेट्स क्लस्टर से कनेक्ट करने में सक्षम नहीं है।

The connection to the server <server-name:port> was refused - did you specify the right host or port?

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

यदि kubectl cluster-info URL प्रतिक्रिया देता है, लेकिन आप अपने क्लस्टर को एक्सेस नहीं कर पा रहें हैं, तो यह जाँचने के लिए कि क्या यह ठीक से कॉन्फ़िगर किया गया है, इस कमांड का उपयोग करें:

kubectl cluster-info dump

वैकल्पिक kubectl कॉन्फ़िगरेशन और प्लगइन्स

शेल ऑटोकम्प्लेशन सक्षम करें

kubectl Bash और Zsh के लिए ऑटोकम्प्लेशन का सपोर्ट प्रदान करता है, जो आपको बहुत सारी टाइपिंग बचा सकता है।

नीचे Zsh के लिए ऑटोकम्प्लेशन स्थापित करने की प्रक्रियाएँ हैं, यदि आप इसे Windows पर चला रहे हैं।

Zsh के लिए kubectl कम्पलीशन स्क्रिप्ट kubectl completion zsh कमांड के साथ उत्पन्न की जा सकती है। आपके शेल में कम्पलीशन स्क्रिप्ट को सोर्स करने से kubectl ऑटो-कम्पलीशन सक्षम हो जाती है।

अपने सभी शेल सत्रों में ऐसा करने के लिए, निम्नलिखित को अपनी ~/.zshrc फ़ाइल में जोड़ें:

source <(kubectl completion zsh)

यदि आपके पास kubectl के लिए एक उपनाम है, तो आप उस उपनाम के साथ काम करने के लिए शेल कम्पलीशन को बढ़ा सकते हैं:

echo 'alias k=kubectl' >>~/.zshrc
echo 'complete -F __start_kubectl k' >>~/.zshrc

अपने शेल को पुनः लोड करने के बाद, kubectl ऑटो-कम्पलीशन कार्य करना चाहिए।

यदि आपको कोई त्रुटि मिलती है जैसे complete:13: command not found: compdef, तो अपनी ~/.zshrc फ़ाइल की शुरुआत में निम्नलिखित जोड़ें:

autoload -Uz compinit
compinit

इंस्टॉल kubectl convert प्लगइन

कुबेरनेट्स कमांड-लाइन टूल kubectl के लिए एक प्लगइन, जो आपको विभिन्न API संस्करण के बीच मैनिफ़ेस्ट को बदलने करने की अनुमति देता है। यह विशेष रूप से नए कुबेरनेट्स रिलीज के साथ एक गैर-बहिष्कृत API संस्करण में मैनिफेस्ट को माइग्रेट करने में सहायक हो सकता है। अधिक जानकारी के लिए, गैर पदावनत एपिस में विस्थापित करें पर जाएं।

1. इस कमांड से नवीनतम रिलीज डाउनलोड करें:

   curl -LO https://dl.k8s.io/release/v1.33.0/bin/windows/amd64/kubectl-convert.exe
   

2. बाइनरी को मान्य करें (वैकल्पिक)

   kubectl-convert चेकसम फ़ाइल डाउनलोड करें:

   curl -LO https://dl.k8s.io/v1.33.0/bin/windows/amd64/kubectl-convert.exe.sha256
   

   चेकसम फ़ाइल से kubectl-convert बाइनरी को मान्य करें:

   • मैन्युअल रूप से कमांड प्रॉम्प्ट का उपयोग करके CertUtil के आउटपुट की तुलना डाउनलोड किये गये चेकसम फ़ाइल से करें:

     CertUtil -hashfile kubectl-convert.exe SHA256
     type kubectl-convert.exe.sha256
     

   • True या False परिणाम प्राप्त करने और -eq ऑपरेटर का उपयोग करके सत्यापन को ऑटोमेट करने के लिए Powershell का उपयोग करें:

     $($(CertUtil -hashfile .\kubectl-convert.exe SHA256)[1] -replace " ", "") -eq $(type .\kubectl-convert.exe.sha256)
     

3. अपने PATH में बाइनरी जोड़ें।

4. सत्यापित करें कि प्लगइन सफलतापूर्वक इंस्टॉल हो गया है।

   kubectl convert --help
   

   यदि आपको कोई त्रुटि नहीं दिखाई देती है, तो इसका मतलब है कि प्लगइन सफलतापूर्वक इंस्टॉल हो गया है।

आगे क्या है

• मिनीक्यूब (Minikube) इंस्टॉल करें
• क्लस्टर बनाने के बारे में अधिक जानकारी के लिए आरंभ करने की मार्गदर्शिका देखें।
• अपने एप्लिकेशन को लॉन्च और एक्सपोज़ करने का तरीका जानें।
• यदि आपको किसी ऐसे क्लस्टर को उपयोग करने की आवश्यकता है जिसे आपने नहीं बनाया है, तो क्लस्टर एक्सेस दस्तावेज़ साझा करना देखें।
• kubectl संदर्भ प्रलेखन पढ़ें।

4.2 - नेटवर्क पॉलिसी प्रोवाइडर इंस्टॉल करें

4.2.1 - नेटवर्कपॉलिसी के लिए Antrea का उपयोग करें

यह पेज कुबेरनेट्स पर Antrea CNI प्लगइन को कैसे इंस्टॉल और उपयोग करें, यह दिखाता है। प्रोजेक्ट Antrea की पृष्ठभूमि के लिए, Antrea का परिचय पढ़ें।

शुरू करने से पहले

आपके पास एक कुबेरनेट्स क्लस्टर होना चाहिए। एक क्लस्टर को बूटस्ट्रैप करने के लिए kubeadm आरंभ करने की गाइड का पालन करें।

kubeadm के साथ Antrea को डिप्लॉय करना

kubeadm के लिए Antrea को डिप्लॉय करने के लिए आरंभ करने की गाइड का पालन करें।

आगे क्या है

एक बार जब आपका क्लस्टर चल रहा हो, तो आप कुबेरनेट्स नेटवर्कपॉलिसी को आज़माने के लिए नेटवर्क पॉलिसी घोषित करें का पालन कर सकते हैं।

4.3 - जॉब चलाएं

4.3.1 - क्रॉनजॉब के साथ स्वचालित कार्य चलाना

यह पेज दिखाता है कि कैसे Kubernetes CronJob ऑब्जेक्ट का उपयोग करके स्वचालित कार्य चलाए जाते हैं।

शुरू करने से पहले

• आपको कुबरनेट्स क्लस्टर की ज़रूरत पड़ेगी और क्यूब सीटीएल कमांड लाइन साधन को समनुरूप करना होगा ताकि वो आपके क्लस्टर के साथ संवाद कर सकें। हमारी सलाह है की इस टुटोरिअल को क्लस्टर में रन करने के लिए कम से कम दो नोड का इस्तेमाल करे जो कि कंट्रोल प्लेन होस्ट के तरह ना एक्ट करे। अगर आपके पास पहले से क्लस्टर नही है, आप minikube की मदद से वह बना सकते है या आप नीचे दिए हुए इन दो कुबरनेट्स प्लेग्राउंड का इस्तेमाल कर सकते हैं:

  • Katacoda
  • प्ले विथ कुबेरनेट्स

क्रॉनजॉब बनाना

क्रॉन जॉब्स को एक कॉन्फ़िग फ़ाइल की आवश्यकता होती है। यहाँ एक क्रॉनजॉब के लिए मैनिफेस्ट है जो हर मिनट एक साधारण डेमो कार्य चलाता है:

application/job/cronjob.yaml

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "* * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox:1.28
            imagePullPolicy: IfNotPresent
            command:
            - /bin/sh
            - -c
            - date; echo Hello from the Kubernetes cluster
          restartPolicy: OnFailure

इस कमांड का उपयोग करके उदाहरण क्रॉनजॉब चलाएं:

kubectl create -f https://k8s.io/examples/application/job/cronjob.yaml

आउटपुट इस तरह का होगा:

cronjob.batch/hello created

क्रॉनजॉब बनाने के बाद, इस कमांड का उपयोग करके इसकी स्थिति प्राप्त करें:

kubectl get cronjob hello

आउटपुट इस तरह का होगा:

NAME    SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
hello   */1 * * * *   False     0        <none>          10s

जैसा कि आप कमांड के परिणामों से देख सकते हैं, क्रॉन जॉब ने अभी तक कोई जॉब शेड्यूल या चलाया नहीं है। लगभग एक मिनट में जॉब के बनने के लिए देखें:

kubectl get jobs --watch

आउटपुट इस तरह का होगा:

NAME               COMPLETIONS   DURATION   AGE
hello-4111706356   0/1                      0s
hello-4111706356   0/1           0s         0s
hello-4111706356   1/1           5s         5s

अब आपने "hello" क्रॉन जॉब द्वारा शेड्यूल किया गया एक चलता हुआ जॉब देखा है। आप जॉब को देखना बंद कर सकते हैं और क्रॉन जॉब को फिर से देख सकते हैं यह देखने के लिए कि इसने जॉब को शेड्यूल किया:

kubectl get cronjob hello

आउटपुट इस तरह का होगा:

NAME    SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
hello   */1 * * * *   False     0        50s             75s

आपको दिखाई देगा कि क्रॉन जॉब hello ने LAST SCHEDULE में निर्दिष्ट समय पर सफलतापूर्वक एक जॉब शेड्यूल किया। वर्तमान में 0 सक्रिय जॉब हैं, जिसका अर्थ है कि जॉब पूरा हो गया है या विफल हो गया है।

अब, पिछले शेड्यूल किए गए जॉब द्वारा बनाए गए पॉड्स को ढूंढें और एक पॉड का स्टैंडर्ड आउटपुट देखें।

# "hello-4111706356" को अपने सिस्टम में जॉब नाम से बदलें
pods=$(kubectl get pods --selector=job-name=hello-4111706356 --output=jsonpath={.items[*].metadata.name})

पॉड लॉग दिखाएं:

kubectl logs $pods

आउटपुट इस तरह का होगा:

Fri Feb 22 11:02:09 UTC 2019
Hello from the Kubernetes cluster

क्रॉनजॉब हटाना

जब आपको क्रॉन जॉब की और आवश्यकता नहीं होती है, तो इसे kubectl delete cronjob <cronjob name> के साथ हटा दें:

kubectl delete cronjob hello

क्रॉन जॉब को हटाने से इसके द्वारा बनाए गए सभी जॉब और पॉड हट जाते हैं और यह अतिरिक्त जॉब बनाना बंद कर देता है। आप गारबेज कलेक्शन में जॉब हटाने के बारे में और पढ़ सकते हैं।

4.3.2 - वर्क क्यू का उपयोग करके मोटे समानांतर प्रसंस्करण

इस उदाहरण में, आप कई समानांतर वर्कर प्रोसेस के साथ एक Kubernetes जॉब चलाएंगे।

इस उदाहरण में, जैसे ही प्रत्येक पॉड बनाया जाता है, यह कार्य कतार से एक कार्य इकाई लेता है, इसे पूरा करता है, इसे कतार से हटा देता है, और बाहर निकल जाता है।

यहाँ इस उदाहरण में चरणों का एक सिंहावलोकन है:

1. एक मैसेज क्यू सेवा शुरू करें। इस उदाहरण में, आप RabbitMQ का उपयोग करते हैं, लेकिन आप कोई अन्य भी उपयोग कर सकते हैं। व्यवहार में आप एक मैसेज क्यू सेवा एक बार सेट करेंगे और इसका उपयोग कई जॉब्स के लिए करेंगे।
2. एक क्यू बनाएं, और इसे संदेशों से भरें। प्रत्येक संदेश एक कार्य का प्रतिनिधित्व करता है जो किया जाना है। इस उदाहरण में, एक संदेश एक पूर्णांक है जिस पर हम एक लंबी गणना करेंगे।
3. क्यू से कार्यों पर काम करने वाला एक जॉब शुरू करें। जॉब कई पॉड शुरू करता है। प्रत्येक पॉड मैसेज क्यू से एक कार्य लेता है, इसे संसाधित करता है, और बाहर निकल जाता है।

शुरू करने से पहले

आपको पहले से ही Job के बुनियादी, गैर-समानांतर उपयोग से परिचित होना चाहिए।

आपको कुबरनेट्स क्लस्टर की ज़रूरत पड़ेगी और क्यूब सीटीएल कमांड लाइन साधन को समनुरूप करना होगा ताकि वो आपके क्लस्टर के साथ संवाद कर सकें। हमारी सलाह है की इस टुटोरिअल को क्लस्टर में रन करने के लिए कम से कम दो नोड का इस्तेमाल करे जो कि कंट्रोल प्लेन होस्ट के तरह ना एक्ट करे। अगर आपके पास पहले से क्लस्टर नही है, आप minikube की मदद से वह बना सकते है या आप नीचे दिए हुए इन दो कुबरनेट्स प्लेग्राउंड का इस्तेमाल कर सकते हैं:

• Katacoda
• प्ले विथ कुबेरनेट्स

आपको एक कंटेनर इमेज रजिस्ट्री की आवश्यकता होगी जहां आप अपने क्लस्टर में चलाने के लिए इमेज अपलोड कर सकते हैं।

यह कार्य उदाहरण यह भी मानता है कि आपने Docker को स्थानीय रूप से स्थापित किया है।

मैसेज क्यू सेवा शुरू करना

यह उदाहरण RabbitMQ का उपयोग करता है, हालांकि, आप उदाहरण को किसी अन्य AMQP-प्रकार की मैसेज सेवा का उपयोग करने के लिए अनुकूलित कर सकते हैं।

व्यवहार में आप एक क्लस्टर में एक बार मैसेज क्यू सेवा सेट कर सकते हैं और इसका पुन: उपयोग कई जॉब्स के साथ-साथ लंबे समय तक चलने वाली सेवाओं के लिए कर सकते हैं।

RabbitMQ को निम्नानुसार शुरू करें:

# StatefulSet के उपयोग के लिए एक सेवा बनाएं
kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq/rabbitmq-service.yaml

service "rabbitmq-service" created

kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq/rabbitmq-statefulset.yaml

statefulset "rabbitmq" created

मैसेज क्यू सेवा का परीक्षण

अब, हम मैसेज क्यू तक पहुंचने का प्रयोग कर सकते हैं। हम एक अस्थायी इंटरैक्टिव पॉड बनाएंगे, इस पर कुछ टूल स्थापित करेंगे, और क्यू के साथ प्रयोग करेंगे।

पहले एक अस्थायी इंटरैक्टिव पॉड बनाएं।

# एक अस्थायी इंटरैक्टिव कंटेनर बनाएं
kubectl run -i --tty temp --image ubuntu:22.04

Waiting for pod default/temp-loe07 to be running, status is Pending, pod ready: false
... [ पिछली लाइन कई बार दोहराई जाती है .. जब यह रुक जाए तो रिटर्न दबाएं ] ...

ध्यान दें कि आपका पॉड नाम और कमांड प्रॉम्प्ट अलग होंगे।

अगला amqp-tools स्थापित करें ताकि आप मैसेज क्यू के साथ काम कर सकें। अगले कमांड दिखाते हैं कि आपको उस पॉड में इंटरैक्टिव शेल के अंदर क्या चलाने की आवश्यकता है:

apt-get update && apt-get install -y curl ca-certificates amqp-tools python3 dnsutils

बाद में, आप एक कंटेनर इमेज बनाएंगे जिसमें ये पैकेज शामिल हैं।

अगला, आप जांचेंगे कि आप RabbitMQ के लिए सेवा का पता लगा सकते हैं:

# इन कमांड को पॉड के अंदर चलाएं
# ध्यान दें कि rabbitmq-service में एक DNS नाम है, जो Kubernetes द्वारा प्रदान किया गया है:
nslookup rabbitmq-service

Server:        10.0.0.10
Address:    10.0.0.10#53

Name:    rabbitmq-service.default.svc.cluster.local
Address: 10.0.147.152

(IP पते अलग-अलग होंगे)

यदि kube-dns एडऑन सही ढंग से सेट नहीं किया गया है, तो पिछला चरण आपके लिए काम नहीं कर सकता है। आप उस सेवा के लिए IP पता एक पर्यावरण चर में भी पा सकते हैं:

# यह जांच पॉड के अंदर चलाएं
env | grep RABBITMQ_SERVICE | grep HOST

RABBITMQ_SERVICE_SERVICE_HOST=10.0.147.152

(IP पता अलग होगा)

अगला आप सत्यापित करेंगे कि आप एक क्यू बना सकते हैं, और संदेशों को प्रकाशित और उपभोग कर सकते हैं।

# इन कमांड को पॉड के अंदर चलाएं
# अगली लाइन में, rabbitmq-service वह होस्टनाम है जहां rabbitmq-service
# तक पहुंचा जा सकता है। 5672 rabbitmq के लिए मानक पोर्ट है।
export BROKER_URL=amqp://guest:guest@rabbitmq-service:5672
# यदि आप पिछले चरण में "rabbitmq-service" को रिज़ॉल्व नहीं कर सके,
# तो इसके बजाय इस कमांड का उपयोग करें:
BROKER_URL=amqp://guest:guest@$RABBITMQ_SERVICE_SERVICE_HOST:5672

# अब एक क्यू बनाएं:

/usr/bin/amqp-declare-queue --url=$BROKER_URL -q foo -d

foo

क्यू में एक संदेश प्रकाशित करें:

/usr/bin/amqp-publish --url=$BROKER_URL -r foo -p -b Hello

# और इसे वापस प्राप्त करें।

/usr/bin/amqp-consume --url=$BROKER_URL -q foo -c 1 cat && echo 1>&2

Hello

अंतिम कमांड में, amqp-consume टूल ने क्यू से एक संदेश (-c 1) लिया, और उस संदेश को एक मनमाने कमांड के मानक इनपुट में पास किया। इस मामले में, प्रोग्राम cat मानक इनपुट से पढ़े गए अक्षरों को प्रिंट करता है, और echo एक कैरिज रिटर्न जोड़ता है ताकि उदाहरण पढ़ने योग्य हो।

क्यू को कार्यों से भरें

अब, क्यू को कुछ सिमुलेटेड कार्यों से भरें। इस उदाहरण में, कार्य प्रिंट किए जाने वाले स्ट्रिंग्स हैं।

अभ्यास में, संदेशों की सामग्री हो सकती है:

• फ़ाइलों के नाम जिन्हें संसाधित करने की आवश्यकता है
• प्रोग्राम के लिए अतिरिक्त फ्लैग
• डेटाबेस टेबल में कुंजियों की सीमाएं
• सिमुलेशन के लिए कॉन्फ़िगरेशन पैरामीटर
• रेंडर किए जाने वाले दृश्य के फ्रेम नंबर

यदि बड़ा डेटा है जिसे जॉब के सभी पॉड द्वारा केवल पढ़ने के मोड में आवश्यकता है, तो आप आमतौर पर उसे NFS जैसी साझा फ़ाइल सिस्टम में डालते हैं और उसे सभी पॉड पर केवल पढ़ने के लिए माउंट करते हैं, या पॉड में प्रोग्राम को इस तरह लिखते हैं कि यह क्लस्टर फ़ाइल सिस्टम से डेटा को मूल रूप से पढ़ सके (उदाहरण के लिए: HDFS)।

इस उदाहरण के लिए, आप AMQP कमांड लाइन टूल का उपयोग करके क्यू बनाएंगे और इसे भरेंगे। व्यवहार में, आप AMQP क्लाइंट लाइब्रेरी का उपयोग करके क्यू को भरने के लिए एक प्रोग्राम लिख सकते हैं।

# इसे अपने कंप्यूटर पर चलाएं, पॉड में नहीं
/usr/bin/amqp-declare-queue --url=$BROKER_URL -q job1  -d

job1

क्यू में आइटम जोड़ें:

for f in apple banana cherry date fig grape lemon melon
do
  /usr/bin/amqp-publish --url=$BROKER_URL -r job1 -p -b $f
done

आपने क्यू में 8 संदेश जोड़े हैं।

एक कंटेनर इमेज बनाएं

अब आप एक इमेज बनाने के लिए तैयार हैं जिसे आप एक जॉब के रूप में चलाएंगे।

जॉब क्यू से संदेश पढ़ने और वास्तविक कार्य करने के लिए amqp-consume उपयोगिता का उपयोग करेगा। यहाँ एक बहुत ही सरल उदाहरण प्रोग्राम है:

4.3.3 - वर्क क्यू का उपयोग करके सूक्ष्म समानांतर प्रसंस्करण

इस उदाहरण में, आप एक Kubernetes जॉब चलाएंगे जो कई समानांतर कार्यों को वर्कर प्रोसेस के रूप में चलाता है, जहां प्रत्येक कार्य एक अलग पॉड के रूप में चलता है।

इस उदाहरण में, जैसे-जैसे प्रत्येक पॉड बनाया जाता है, यह कार्य कतार से एक कार्य इकाई लेता है, उसे प्रोसेस करता है, और कतार के अंत तक पहुंचने तक इसे दोहराता है।

यहाँ इस उदाहरण के चरणों का एक सिंहावलोकन है:

1. कार्य कतार को संग्रहित करने के लिए एक स्टोरेज सेवा शुरू करें। इस उदाहरण में, आप कार्य आइटम को स्टोर करने के लिए Redis का उपयोग करेंगे। पिछले उदाहरण में, आपने RabbitMQ का उपयोग किया था। इस उदाहरण में, आप Redis और एक कस्टम वर्क-क्यू क्लाइंट लाइब्रेरी का उपयोग करेंगे; यह इसलिए है क्योंकि AMQP क्लाइंट्स को यह पता लगाने का कोई अच्छा तरीका प्रदान नहीं करता कि एक सीमित-लंबाई वाली कार्य कतार खाली है या नहीं। व्यवहार में आप Redis जैसा स्टोर एक बार सेट करेंगे और इसका पुन: उपयोग कई जॉब्स की कार्य कतारों और अन्य चीजों के लिए करेंगे।
2. एक कतार बनाएं, और इसे संदेशों से भरें। प्रत्येक संदेश एक कार्य को दर्शाता है जो किया जाना है। इस उदाहरण में, एक संदेश एक पूर्णांक है जिस पर हम एक लंबी गणना करेंगे।
3. कतार से कार्यों पर काम करने वाला एक जॉब शुरू करें। जॉब कई पॉड्स शुरू करता है। प्रत्येक पॉड संदेश कतार से एक कार्य लेता है, उसे प्रोसेस करता है, और कतार के अंत तक पहुंचने तक इसे दोहराता है।

शुरू करने से पहले

आपको कुबरनेट्स क्लस्टर की ज़रूरत पड़ेगी और क्यूब सीटीएल कमांड लाइन साधन को समनुरूप करना होगा ताकि वो आपके क्लस्टर के साथ संवाद कर सकें। हमारी सलाह है की इस टुटोरिअल को क्लस्टर में रन करने के लिए कम से कम दो नोड का इस्तेमाल करे जो कि कंट्रोल प्लेन होस्ट के तरह ना एक्ट करे। अगर आपके पास पहले से क्लस्टर नही है, आप minikube की मदद से वह बना सकते है या आप नीचे दिए हुए इन दो कुबरनेट्स प्लेग्राउंड का इस्तेमाल कर सकते हैं:

• Katacoda
• प्ले विथ कुबेरनेट्स

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

यह कार्य उदाहरण यह भी मानता है कि आपने Docker को स्थानीय रूप से इंस्टॉल किया है। आप कंटेनर इमेज बनाने के लिए Docker का उपयोग करते हैं।

Job के बुनियादी, गैर-समानांतर उपयोग से परिचित हों।

Redis शुरू करना

इस उदाहरण के लिए, सरलता के लिए, आप Redis का एक एकल इंस्टेंस शुरू करेंगे। Redis को स्केलेबल और रिडंडेंट तरीके से डिप्लॉय करने के उदाहरण के लिए Redis उदाहरण देखें।

आप निम्नलिखित फ़ाइलों को सीधे भी डाउनलोड कर सकते हैं:

• redis-pod.yaml
• redis-service.yaml
• Dockerfile
• job.yaml
• rediswq.py
• worker.py

Redis का एक एकल इंस्टेंस शुरू करने के लिए, आपको redis पॉड और redis सेवा बनाने की आवश्यकता है:

kubectl apply -f https://k8s.io/examples/application/job/redis/redis-pod.yaml
kubectl apply -f https://k8s.io/examples/application/job/redis/redis-service.yaml

कतार को कार्यों से भरना

अब चलिए कतार को कुछ "कार्यों" से भरें। इस उदाहरण में, कार्य प्रिंट किए जाने वाले स्ट्रिंग्स हैं।

Redis CLI चलाने के लिए एक अस्थायी इंटरैक्टिव पॉड शुरू करें।

kubectl run -i --tty temp --image redis --command "/bin/sh"

Waiting for pod default/redis2-c7h78 to be running, status is Pending, pod ready: false
Hit enter for command prompt

अब एंटर दबाएं, Redis CLI शुरू करें, और इसमें कुछ कार्य आइटम्स के साथ एक सूची बनाएं।

redis-cli -h redis

redis:6379> rpush job2 "apple"
(integer) 1
redis:6379> rpush job2 "banana"
(integer) 2
redis:6379> rpush job2 "cherry"
(integer) 3
redis:6379> rpush job2 "date"
(integer) 4
redis:6379> rpush job2 "fig"
(integer) 5
redis:6379> rpush job2 "grape"
(integer) 6
redis:6379> rpush job2 "lemon"
(integer) 7
redis:6379> rpush job2 "melon"
(integer) 8
redis:6379> rpush job2 "orange"
(integer) 9
redis:6379> lrange job2 0 -1
1) "apple"
2) "banana"
3) "cherry"
4) "date"
5) "fig"
6) "grape"
7) "lemon"
8) "melon"
9) "orange"

इस प्रकार, job2 कुंजी वाली सूची कार्य कतार होगी।

नोट: यदि आपका Kube DNS सही ढंग से सेटअप नहीं है, तो आपको उपरोक्त ब्लॉक के पहले चरण को redis-cli -h $REDIS_SERVICE_HOST में बदलना पड़ सकता है।

एक कंटेनर इमेज बनाएं

अब आप एक ऐसी इमेज बनाने के लिए तैयार हैं जो उस कतार में कार्य को प्रोसेस करेगी।

आप संदेश कतार से संदेश पढ़ने के लिए Redis क्लाइंट के साथ एक Python वर्कर प्रोग्राम का उपयोग करने जा रहे हैं।

एक सरल Redis कार्य कतार क्लाइंट लाइब्रेरी प्रदान की गई है, जिसे rediswq.py कहा जाता है (डाउनलोड)।

जॉब के प्रत्येक पॉड में "वर्कर" प्रोग्राम कार्य प्राप्त करने के लिए कार्य कतार क्लाइंट लाइब्रेरी का उपयोग करता है। यहाँ यह है:

application/job/redis/worker.py

#!/usr/bin/env python

import time
import rediswq

host="redis"
# Uncomment next two lines if you do not have Kube-DNS working.
# import os
# host = os.getenv("REDIS_SERVICE_HOST")

q = rediswq.RedisWQ(name="job2", host=host)
print("Worker with sessionID: " +  q.sessionID())
print("Initial queue state: empty=" + str(q.empty()))
while not q.empty():
  item = q.lease(lease_secs=10, block=True, timeout=2) 
  if item is not None:
    itemstr = item.decode("utf-8")
    print("Working on " + itemstr)
    time.sleep(10) # Put your actual work here instead of sleep.
    q.complete(item)
  else:
    print("Waiting for work")
print("Queue empty, exiting")

आप worker.py, rediswq.py, और Dockerfile फ़ाइलें भी डाउनलोड कर सकते हैं, फिर कंटेनर इमेज बना सकते हैं। यहाँ Docker का उपयोग करके इमेज बनाने का एक उदाहरण दिया गया है:

docker build -t job-wq-2 .

इमेज को पुश करें

Docker Hub के लिए, अपनी ऐप इमेज को अपने उपयोगकर्ता नाम के साथ टैग करें और नीचे दिए गए कमांड्स के साथ Hub पर पुश करें। <username> को अपने Hub उपयोगकर्ता नाम से बदलें।

docker tag job-wq-2 <username>/job-wq-2
docker push <username>/job-wq-2

आपको एक सार्वजनिक रिपॉजिटरी में पुश करना होगा या अपने क्लस्टर को अपनी निजी रिपॉजिटरी तक पहुंच प्राप्त करने के लिए कॉन्फ़िगर करना होगा।

एक जॉब को परिभाषित करना

यहाँ आपके द्वारा बनाए जाने वाले जॉब के लिए एक मैनिफेस्ट है:

application/job/redis/job.yaml

apiVersion: batch/v1
kind: Job
metadata:
  name: job-wq-2
spec:
  parallelism: 2
  template:
    metadata:
      name: job-wq-2
    spec:
      containers:
      - name: c
        image: gcr.io/myproject/job-wq-2
      restartPolicy: OnFailure

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

जॉब को चलाना

तो, अब जॉब चलाएं:

# यह मानता है कि आपने मैनिफेस्ट को पहले ही डाउनलोड और संपादित कर लिया है
kubectl apply -f ./job.yaml

अब थोड़ी देर प्रतीक्षा करें, फिर जॉब की जांच करें:

kubectl describe jobs/job-wq-2

Name:             job-wq-2
Namespace:        default
Selector:         controller-uid=b1c7e4e3-92e1-11e7-b85e-fa163ee3c11f
Labels:           controller-uid=b1c7e4e3-92e1-11e7-b85e-fa163ee3c11f
                  job-name=job-wq-2
Annotations:      <none>
Parallelism:      2
Completions:      <unset>
Start Time:       Mon, 11 Jan 2022 17:07:59 +0000
Pods Statuses:    1 Running / 0 Succeeded / 0 Failed
Pod Template:
  Labels:       controller-uid=b1c7e4e3-92e1-11e7-b85e-fa163ee3c11f
                job-name=job-wq-2
  Containers:
   c:
    Image:              container-registry.example/exampleproject/job-wq-2
    Port:
    Environment:        <none>
    Mounts:             <none>
  Volumes:              <none>
Events:
  FirstSeen    LastSeen    Count    From            SubobjectPath    Type        Reason            Message
  ---------    --------    -----    ----            -------------    --------    ------            -------
  33s          33s         1        {job-controller }                Normal      SuccessfulCreate  Created pod: job-wq-2-lglf8

आप टाइमआउट के साथ जॉब के सफल होने की प्रतीक्षा कर सकते हैं:

# कंडीशन नाम की जांच केस-इनसेंसिटिव है
kubectl wait --for=condition=complete --timeout=300s job/job-wq-2

kubectl logs pods/job-wq-2-7r7b2

Worker with sessionID: bbd72d0a-9e5c-4dd6-abf6-416cc267991f
Initial queue state: empty=False
Working on banana
Working on date
Working on lemon

जैसा कि आप देख सकते हैं, इस जॉब के लिए एक पॉड ने कई कार्य इकाइयों पर काम किया।

विकल्प

यदि एक कतार सेवा चलाना या अपने कंटेनरों को कार्य कतार का उपयोग करने के लिए संशोधित करना असुविधाजनक है, तो आप अन्य जॉब पैटर्न्स में से एक पर विचार करना चाह सकते हैं।

यदि आपके पास चलाने के लिए पृष्ठभूमि प्रसंस्करण कार्य की एक निरंतर धारा है, तो अपने पृष्ठभूमि वर्कर्स को ReplicaSet के साथ चलाने पर विचार करें, और https://github.com/resque/resque जैसी पृष्ठभूमि प्रसंस्करण लाइब्रेरी चलाने पर विचार करें।

4.3.4 - स्थिर कार्य असाइनमेंट के साथ समानांतर प्रसंस्करण के लिए अनुक्रमित जॉब

इस उदाहरण में, आप एक Kubernetes जॉब चलाएंगे जो कई समानांतर वर्कर प्रोसेस का उपयोग करता है। प्रत्येक वर्कर अपने स्वयं के पॉड में चलने वाला एक अलग कंटेनर है। पॉड्स में एक अनुक्रमणिका संख्या होती है जो कंट्रोल प्लेन स्वचालित रूप से सेट करता है, जो प्रत्येक पॉड को समग्र कार्य के किस भाग पर काम करना है यह पहचानने की अनुमति देता है।

पॉड अनुक्रमणिका एनोटेशन batch.kubernetes.io/job-completion-index में इसके दशमलव मान का प्रतिनिधित्व करने वाली स्ट्रिंग के रूप में उपलब्ध है। कंटेनरीकृत कार्य प्रक्रिया को यह अनुक्रमणिका प्राप्त करने के लिए, आप डाउनवर्ड API तंत्र का उपयोग करके एनोटेशन के मान को प्रकाशित कर सकते हैं। सुविधा के लिए, कंट्रोल प्लेन स्वचालित रूप से डाउनवर्ड API को अनुक्रमणिका को JOB_COMPLETION_INDEX पर्यावरण चर में प्रकट करने के लिए सेट करता है।

यहाँ इस उदाहरण में चरणों का एक सिंहावलोकन है:

1. अनुक्रमित पूर्णता का उपयोग करते हुए एक जॉब मैनिफेस्ट को परिभाषित करें। डाउनवर्ड API आपको पॉड अनुक्रमणिका एनोटेशन को एक पर्यावरण चर या फ़ाइल के रूप में कंटेनर में पास करने की अनुमति देता है।
2. उस मैनिफेस्ट के आधार पर एक अनुक्रमित जॉब शुरू करें।

शुरू करने से पहले

आपको पहले से ही Job के बुनियादी, गैर-समानांतर उपयोग से परिचित होना चाहिए।

आपको कुबरनेट्स क्लस्टर की ज़रूरत पड़ेगी और क्यूब सीटीएल कमांड लाइन साधन को समनुरूप करना होगा ताकि वो आपके क्लस्टर के साथ संवाद कर सकें। हमारी सलाह है की इस टुटोरिअल को क्लस्टर में रन करने के लिए कम से कम दो नोड का इस्तेमाल करे जो कि कंट्रोल प्लेन होस्ट के तरह ना एक्ट करे। अगर आपके पास पहले से क्लस्टर नही है, आप minikube की मदद से वह बना सकते है या आप नीचे दिए हुए इन दो कुबरनेट्स प्लेग्राउंड का इस्तेमाल कर सकते हैं:

• Katacoda
• प्ले विथ कुबेरनेट्स

संस्करण की जांच करने के लिए, लिखें kubectl version.

एक दृष्टिकोण चुनें

वर्कर प्रोग्राम से कार्य आइटम तक पहुंचने के लिए, आपके पास कुछ विकल्प हैं:

1. JOB_COMPLETION_INDEX पर्यावरण चर पढ़ें। जॉब कंट्रोलर स्वचालित रूप से इस चर को पूर्णता अनुक्रमणिका वाले एनोटेशन से जोड़ता है।
2. पूर्णता अनुक्रमणिका वाली एक फ़ाइल पढ़ें।
3. यह मानते हुए कि आप प्रोग्राम को संशोधित नहीं कर सकते, आप इसे एक स्क्रिप्ट के साथ रैप कर सकते हैं जो ऊपर दी गई किसी भी विधि का उपयोग करके अनुक्रमणिका पढ़ती है और इसे कुछ ऐसे में परिवर्तित करती है जिसे प्रोग्राम इनपुट के रूप में उपयोग कर सकता है।

इस उदाहरण के लिए, कल्पना करें कि आपने विकल्प 3 चुना है और आप rev उपयोगिता चलाना चाहते हैं। यह प्रोग्राम एक फ़ाइल को आर्गुमेंट के रूप में स्वीकार करता है और इसकी सामग्री को उल्टा करके प्रिंट करता है।

rev data.txt

आप busybox कंटेनर इमेज से rev टूल का उपयोग करेंगे।

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

एक अनुक्रमित जॉब को परिभाषित करें

यहाँ एक नमूना जॉब मैनिफेस्ट है जो अनुक्रमित पूर्णता मोड का उपयोग करता है:

application/job/indexed-job.yaml

apiVersion: batch/v1
kind: Job
metadata:
  name: 'indexed-job'
spec:
  completions: 5
  parallelism: 3
  completionMode: Indexed
  template:
    spec:
      restartPolicy: Never
      initContainers:
      - name: 'input'
        image: 'docker.io/library/bash'
        command:
        - "bash"
        - "-c"
        - |
          items=(foo bar baz qux xyz)
          echo ${items[$JOB_COMPLETION_INDEX]} > /input/data.txt          
        volumeMounts:
        - mountPath: /input
          name: input
      containers:
      - name: 'worker'
        image: 'docker.io/library/busybox'
        command:
        - "rev"
        - "/input/data.txt"
        volumeMounts:
        - mountPath: /input
          name: input
      volumes:
      - name: input
        emptyDir: {}

उपरोक्त उदाहरण में, आप जॉब कंट्रोलर द्वारा सभी कंटेनर के लिए सेट किए गए बिल्ट-इन JOB_COMPLETION_INDEX पर्यावरण चर का उपयोग करते हैं। एक इनिट कंटेनर अनुक्रमणिका को एक स्थिर मान में मैप करता है और इसे एक फ़ाइल में लिखता है जो emptyDir वॉल्यूम के माध्यम से वर्कर चलाने वाले कंटेनर के साथ साझा की जाती है। वैकल्पिक रूप से, आप डाउनवर्ड API के माध्यम से अपना स्वयं का पर्यावरण चर परिभाषित कर सकते हैं कंटेनर में अनुक्रमणिका प्रकाशित करने के लिए। आप ConfigMap से एक पर्यावरण चर या फ़ाइल के रूप में मानों की एक सूची लोड करना भी चुन सकते हैं।

वैकल्पिक रूप से, आप सीधे डाउनवर्ड API का उपयोग कर सकते हैं एनोटेशन मान को एक वॉल्यूम फ़ाइल के रूप में पास करने के लिए, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

application/job/indexed-job-vol.yaml

apiVersion: batch/v1
kind: Job
metadata:
  name: 'indexed-job'
spec:
  completions: 5
  parallelism: 3
  completionMode: Indexed
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: 'worker'
        image: 'docker.io/library/busybox'
        command:
        - "rev"
        - "/input/data.txt"
        volumeMounts:
        - mountPath: /input
          name: input
      volumes:
      - name: input
        downwardAPI:
          items:
          - path: "data.txt"
            fieldRef:
              fieldPath: metadata.annotations['batch.kubernetes.io/job-completion-index']

जॉब चलाना

अब जॉब चलाएं:

# यह पहले दृष्टिकोण का उपयोग करता है ($JOB_COMPLETION_INDEX पर निर्भर)
kubectl apply -f https://kubernetes.io/examples/application/job/indexed-job.yaml

जब आप यह जॉब बनाते हैं, तो कंट्रोल प्लेन प्रत्येक अनुक्रमणिका के लिए एक पॉड की एक श्रृंखला बनाता है जो आपने निर्दिष्ट की है। .spec.parallelism का मान निर्धारित करता है कि एक साथ कितने चल सकते हैं जबकि .spec.completions निर्धारित करता है कि जॉब कुल कितने पॉड बनाता है।

चूंकि .spec.parallelism .spec.completions से कम है, कंट्रोल प्लेन उनमें से अधिक शुरू करने से पहले पहले कुछ पॉड के पूरा होने की प्रतीक्षा करता है।

आप जॉब के सफल होने की प्रतीक्षा कर सकते हैं, टाइमआउट के साथ:

# स्थिति नाम की जांच केस-असंवेदनशील है
kubectl wait --for=condition=complete --timeout=300s job/indexed-job

अब, जॉब का विवरण करें और जांचें कि यह सफल था।

kubectl describe jobs/indexed-job

आउटपुट इस तरह का होता है:

Name:              indexed-job
Namespace:         default
Selector:          controller-uid=bf865e04-0b67-483b-9a90-74cfc4c3e756
Labels:            controller-uid=bf865e04-0b67-483b-9a90-74cfc4c3e756
                   job-name=indexed-job
Annotations:       <none>
Parallelism:       3
Completions:       5
Start Time:        Thu, 11 Mar 2021 15:47:34 +0000
Pods Statuses:     2 Running / 3 Succeeded / 0 Failed
Completed Indexes: 0-2
Pod Template:
  Labels:  controller-uid=bf865e04-0b67-483b-9a90-74cfc4c3e756
           job-name=indexed-job
  Init Containers:
   input:
    Image:      docker.io/library/bash
    Port:       <none>
    Host Port:  <none>
    Command:
      bash
      -c
      items=(foo bar baz qux xyz)
      echo ${items[$JOB_COMPLETION_INDEX]} > /input/data.txt

    Environment:  <none>
    Mounts:
      /input from input (rw)
  Containers:
   worker:
    Image:      docker.io/library/busybox
    Port:       <none>
    Host Port:  <none>
    Command:
      rev
      /input/data.txt
    Environment:  <none>
    Mounts:
      /input from input (rw)
  Volumes:
   input:
    Type:       EmptyDir (a temporary directory that shares a pod's lifetime)
    Medium:
    SizeLimit:  <unset>
Events:
  Type    Reason            Age   From            Message
  ----    ------            ----  ----            -------
  Normal  SuccessfulCreate  4s    job-controller  Created pod: indexed-job-njkjj
  Normal  SuccessfulCreate  4s    job-controller  Created pod: indexed-job-9kd4h
  Normal  SuccessfulCreate  4s    job-controller  Created pod: indexed-job-qjwsz
  Normal  SuccessfulCreate  1s    job-controller  Created pod: indexed-job-fdhq5
  Normal  SuccessfulCreate  1s    job-controller  Created pod: indexed-job-ncslj

इस उदाहरण में, आप प्रत्येक अनुक्रमणिका के लिए कस्टम मानों के साथ जॉब चलाते हैं। आप पॉड्स में से एक का आउटपुट निरीक्षण कर सकते हैं:

kubectl logs indexed-job-fdhq5 # इसे उस जॉब के एक पॉड के नाम से बदलें

आउटपुट इस तरह का होता है:

xuq

4.3.5 - पॉड-टू-पॉड कम्युनिकेशन के साथ जॉब

इस उदाहरण में, आप एक जॉब चलाएंगे जो इंडेक्स्ड कम्प्लीशन मोड में कॉन्फ़िगर किया गया है, जिससे जॉब द्वारा बनाए गए पॉड्स पॉड IP एड्रेस के बजाय पॉड होस्टनाम का उपयोग करके एक-दूसरे के साथ कम्युनिकेट कर सकते हैं।

जॉब के भीतर पॉड्स को एक-दूसरे के साथ कम्युनिकेट करने की आवश्यकता हो सकती है। प्रत्येक पॉड में चल रहा यूजर वर्कलोड Kubernetes API सर्वर से अन्य पॉड्स के IPs जानने के लिए क्वेरी कर सकता है, लेकिन Kubernetes के बिल्ट-इन DNS रेजोल्यूशन पर भरोसा करना बहुत आसान है।

इंडेक्स्ड कम्प्लीशन मोड में जॉब्स स्वचालित रूप से पॉड्स के होस्टनाम को ${jobName}-${completionIndex} फॉर्मेट में सेट करते हैं। आप इस फॉर्मेट का उपयोग पॉड होस्टनाम को निर्धारित रूप से बनाने और पॉड कम्युनिकेशन को सक्षम करने के लिए कर सकते हैं, बिना Kubernetes कंट्रोल प्लेन के साथ क्लाइंट कनेक्शन बनाए बिना API रिक्वेस्ट के माध्यम से पॉड होस्टनाम/IPs प्राप्त करने की आवश्यकता के।

यह कॉन्फ़िगरेशन उन उपयोग के मामलों के लिए उपयोगी है जहां पॉड नेटवर्किंग की आवश्यकता होती है लेकिन आप Kubernetes API सर्वर के साथ नेटवर्क कनेक्शन पर निर्भर नहीं करना चाहते हैं।

शुरू करने से पहले

आपको पहले से ही Job के बुनियादी उपयोग से परिचित होना चाहिए।

आपको कुबरनेट्स क्लस्टर की ज़रूरत पड़ेगी और क्यूब सीटीएल कमांड लाइन साधन को समनुरूप करना होगा ताकि वो आपके क्लस्टर के साथ संवाद कर सकें। हमारी सलाह है की इस टुटोरिअल को क्लस्टर में रन करने के लिए कम से कम दो नोड का इस्तेमाल करे जो कि कंट्रोल प्लेन होस्ट के तरह ना एक्ट करे। अगर आपके पास पहले से क्लस्टर नही है, आप minikube की मदद से वह बना सकते है या आप नीचे दिए हुए इन दो कुबरनेट्स प्लेग्राउंड का इस्तेमाल कर सकते हैं:

• Katacoda
• प्ले विथ कुबेरनेट्स

संस्करण की जांच करने के लिए, लिखें kubectl version.

नोट:

यदि आप minikube या इसी तरह के टूल का उपयोग कर रहे हैं, तो आपको यह सुनिश्चित करने के लिए अतिरिक्त कदम उठाने की आवश्यकता हो सकती है कि आपके पास DNS है।

पॉड-टू-पॉड कम्युनिकेशन के साथ जॉब शुरू करना

जॉब में पॉड होस्टनाम का उपयोग करके पॉड-टू-पॉड कम्युनिकेशन को सक्षम करने के लिए, आपको निम्नलिखित करना होगा:

1. आपके जॉब द्वारा बनाए गए पॉड्स के लिए एक वैध लेबल सेलेक्टर के साथ एक हेडलेस सर्विस सेटअप करें। हेडलेस सर्विस जॉब के समान नेमस्पेस में होनी चाहिए। इसे करने का एक आसान तरीका job-name: <your-job-name> सेलेक्टर का उपयोग करना है, क्योंकि job-name लेबल स्वचालित रूप से Kubernetes द्वारा जोड़ा जाएगा। यह कॉन्फ़िगरेशन DNS सिस्टम को आपके जॉब को चलाने वाले पॉड्स के होस्टनाम के रिकॉर्ड बनाने के लिए ट्रिगर करेगा।
2. निम्नलिखित मान को अपने जॉब टेम्पलेट स्पेक में शामिल करके जॉब पॉड्स के लिए हेडलेस सर्विस को सबडोमेन सर्विस के रूप में कॉन्फ़िगर करें:

subdomain: <headless-svc-name>  

उदाहरण

नीचे पॉड होस्टनाम के माध्यम से पॉड-टू-पॉड कम्युनिकेशन के साथ एक जॉब का एक कार्यशील उदाहरण है। जॉब तभी पूरा होता है जब सभी पॉड्स होस्टनाम का उपयोग करके एक-दूसरे को सफलतापूर्वक पिंग करते हैं।

नोट:

नीचे दिए गए उदाहरण में प्रत्येक पॉड पर निष्पादित बैश स्क्रिप्ट में, यदि पॉड को नेमस्पेस के बाहर से पहुंचने की आवश्यकता है तो पॉड होस्टनाम को नेमस्पेस द्वारा भी प्रीफिक्स किया जा सकता है।

apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None # clusterIP को हेडलेस सर्विस बनाने के लिए None होना चाहिए
  selector:
    job-name: example-job # जॉब नाम से मेल खाना चाहिए
---
apiVersion: batch/v1
kind: Job
metadata:
  name: example-job
spec:
  completions: 3
  parallelism: 3
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc # सर्विस नाम से मेल खाना चाहिए
      restartPolicy: Never
      containers:
      - name: example-workload
        image: bash:latest
        command:
        - bash
        - -c
        - |
          for i in 0 1 2
          do
            gotStatus="-1"
            wantStatus="0"             
            while [ $gotStatus -ne $wantStatus ]
            do                                       
              ping -c 1 example-job-${i}.headless-svc > /dev/null 2>&1
              gotStatus=$?                
              if [ $gotStatus -ne $wantStatus ]; then
                echo "Failed to ping pod example-job-${i}.headless-svc, retrying in 1 second..."
                sleep 1
              fi
            done                                                         
            echo "Successfully pinged pod: example-job-${i}.headless-svc"
          done                    

उपरोक्त उदाहरण को लागू करने के बाद, नेटवर्क पर एक-दूसरे तक पहुंचें: <pod-hostname>.<headless-service-name>। आपको निम्नलिखित के समान आउटपुट दिखाई देना चाहिए:

kubectl logs example-job-0-qws42

Failed to ping pod example-job-0.headless-svc, retrying in 1 second...
Successfully pinged pod: example-job-0.headless-svc
Successfully pinged pod: example-job-1.headless-svc
Successfully pinged pod: example-job-2.headless-svc

नोट:

ध्यान रखें कि इस उदाहरण में उपयोग किया गया <pod-hostname>.<headless-service-name> नाम फॉर्मेट DNS पॉलिसी को None या Default पर सेट करने के साथ काम नहीं करेगा। पॉड की DNS पॉलिसी देखें।

4.3.6 - समानांतर प्रसंस्करण विस्तार

इस उदाहरण में, आप एक जॉब चलाएंगे जो कई समानांतर वर्कर प्रोसेस का उपयोग करता है। प्रत्येक वर्कर अपने स्वयं के पॉड में चलने वाला एक अलग कंटेनर है।

इस उदाहरण में, जैसे-जैसे प्रत्येक पॉड बनाया जाता है, यह कार्य कतार से एक कार्य इकाई लेता है, इसे प्रोसेस करता है, और बाहर निकल जाता है।

यहाँ इस उदाहरण में चरणों का एक सिंहावलोकन है:

1. एक मैसेज क्यू सेवा शुरू करें। इस उदाहरण में, आप RabbitMQ का उपयोग करते हैं, लेकिन आप कोई अन्य भी उपयोग कर सकते हैं। व्यवहार में आप एक मैसेज क्यू सेवा एक बार सेट करेंगे और इसका उपयोग कई जॉब्स के लिए करेंगे।
2. एक क्यू बनाएं, और इसे संदेशों से भरें। प्रत्येक संदेश एक कार्य का प्रतिनिधित्व करता है जो किया जाना है। इस उदाहरण में, एक संदेश एक पूर्णांक है जिस पर हम एक लंबी गणना करेंगे।
3. क्यू से कार्यों पर काम करने वाला एक जॉब शुरू करें। जॉब कई पॉड शुरू करता है। प्रत्येक पॉड मैसेज क्यू से एक कार्य लेता है, इसे संसाधित करता है, और बाहर निकल जाता है।

शुरू करने से पहले

आपको पहले से ही Job के बुनियादी, गैर-समानांतर उपयोग से परिचित होना चाहिए।

आपको कुबरनेट्स क्लस्टर की ज़रूरत पड़ेगी और क्यूब सीटीएल कमांड लाइन साधन को समनुरूप करना होगा ताकि वो आपके क्लस्टर के साथ संवाद कर सकें। हमारी सलाह है की इस टुटोरिअल को क्लस्टर में रन करने के लिए कम से कम दो नोड का इस्तेमाल करे जो कि कंट्रोल प्लेन होस्ट के तरह ना एक्ट करे। अगर आपके पास पहले से क्लस्टर नही है, आप minikube की मदद से वह बना सकते है या आप नीचे दिए हुए इन दो कुबरनेट्स प्लेग्राउंड का इस्तेमाल कर सकते हैं:

• Katacoda
• प्ले विथ कुबेरनेट्स

आपको एक कंटेनर इमेज रजिस्ट्री की आवश्यकता होगी जहां आप अपने क्लस्टर में चलाने के लिए इमेज अपलोड कर सकते हैं।

यह कार्य उदाहरण यह भी मानता है कि आपने Docker को स्थानीय रूप से स्थापित किया है।

मैसेज क्यू सेवा शुरू करना

यह उदाहरण RabbitMQ का उपयोग करता है, हालांकि, आप उदाहरण को किसी अन्य AMQP-प्रकार की मैसेज सेवा का उपयोग करने के लिए अनुकूलित कर सकते हैं।

व्यवहार में आप एक क्लस्टर में एक बार मैसेज क्यू सेवा सेट कर सकते हैं और इसका पुन: उपयोग कई जॉब्स के साथ-साथ लंबे समय तक चलने वाली सेवाओं के लिए कर सकते हैं।

RabbitMQ को निम्नानुसार शुरू करें:

# StatefulSet के उपयोग के लिए एक सेवा बनाएं
kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq/rabbitmq-service.yaml

service "rabbitmq-service" created

kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq/rabbitmq-statefulset.yaml

statefulset "rabbitmq" created

मैसेज क्यू सेवा का परीक्षण

अब, हम मैसेज क्यू तक पहुंचने का प्रयोग कर सकते हैं। हम एक अस्थायी इंटरैक्टिव पॉड बनाएंगे, इस पर कुछ टूल स्थापित करेंगे, और क्यू के साथ प्रयोग करेंगे।

पहले एक अस्थायी इंटरैक्टिव पॉड बनाएं।

# एक अस्थायी इंटरैक्टिव कंटेनर बनाएं
kubectl run -i --tty temp --image ubuntu:22.04

Waiting for pod default/temp-loe07 to be running, status is Pending, pod ready: false
... [ पिछली लाइन कई बार दोहराई जाती है .. जब यह रुक जाए तो रिटर्न दबाएं ] ...

ध्यान दें कि आपका पॉड नाम और कमांड प्रॉम्प्ट अलग होंगे।

अगला amqp-tools स्थापित करें ताकि आप मैसेज क्यू के साथ काम कर सकें। अगले कमांड दिखाते हैं कि आपको उस पॉड में इंटरैक्टिव शेल के अंदर क्या चलाने की आवश्यकता है:

apt-get update && apt-get install -y curl ca-certificates amqp-tools python3 dnsutils

बाद में, आप एक कंटेनर इमेज बनाएंगे जिसमें ये पैकेज शामिल हैं।

अगला, आप जांचेंगे कि आप RabbitMQ के लिए सेवा का पता लगा सकते हैं:

# इन कमांड को पॉड के अंदर चलाएं
# ध्यान दें कि rabbitmq-service में एक DNS नाम है, जो Kubernetes द्वारा प्रदान किया गया है:
nslookup rabbitmq-service

Server:        10.0.0.10
Address:    10.0.0.10#53

Name:    rabbitmq-service.default.svc.cluster.local
Address: 10.0.147.152

(IP पते अलग-अलग होंगे)

यदि kube-dns एडऑन सही ढंग से सेट नहीं किया गया है, तो पिछला चरण आपके लिए काम नहीं कर सकता है। आप उस सेवा के लिए IP पता एक पर्यावरण चर में भी पा सकते हैं:

# यह जांच पॉड के अंदर चलाएं
env | grep RABBITMQ_SERVICE | grep HOST

RABBITMQ_SERVICE_SERVICE_HOST=10.0.147.152

(IP पता अलग होगा)

अगला आप सत्यापित करेंगे कि आप एक क्यू बना सकते हैं, और संदेशों को प्रकाशित और उपभोग कर सकते हैं।

# इन कमांड को पॉड के अंदर चलाएं
# अगली लाइन में, rabbitmq-service वह होस्टनाम है जहां rabbitmq-service
# तक पहुंचा जा सकता है। 5672 rabbitmq के लिए मानक पोर्ट है।
export BROKER_URL=amqp://guest:guest@rabbitmq-service:5672
# यदि आप पिछले चरण में "rabbitmq-service" को रिज़ॉल्व नहीं कर सके,
# तो इसके बजाय इस कमांड का उपयोग करें:
BROKER_URL=amqp://guest:guest@$RABBITMQ_SERVICE_SERVICE_HOST:5672

# अब एक क्यू बनाएं:

/usr/bin/amqp-declare-queue --url=$BROKER_URL -q foo -d

foo

क्यू में एक संदेश प्रकाशित करें:

/usr/bin/amqp-publish --url=$BROKER_URL -r foo -p -b Hello

# और इसे वापस प्राप्त करें।

/usr/bin/amqp-consume --url=$BROKER_URL -q foo -c 1 cat && echo 1>&2

Hello

अंतिम कमांड में, amqp-consume टूल ने क्यू से एक संदेश (-c 1) लिया, और उस संदेश को एक मनमाने कमांड के मानक इनपुट में पास किया। इस मामले में, प्रोग्राम cat मानक इनपुट से पढ़े गए अक्षरों को प्रिंट करता है, और echo एक कैरिज रिटर्न जोड़ता है ताकि उदाहरण पढ़ने योग्य हो।

क्यू को कार्यों से भरें

अब, क्यू को कुछ सिमुलेटेड कार्यों से भरें। इस उदाहरण में, कार्य प्रिंट किए जाने वाले स्ट्रिंग्स हैं।

अभ्यास में, संदेशों की सामग्री हो सकती है:

• फ़ाइलों के नाम जिन्हें संसाधित करने की आवश्यकता है
• प्रोग्राम के लिए अतिरिक्त फ्लैग
• डेटाबेस टेबल में कुंजियों की सीमाएं
• सिमुलेशन के लिए कॉन्फ़िगरेशन पैरामीटर
• रेंडर किए जाने वाले दृश्य के फ्रेम नंबर

यदि बड़ा डेटा है जिसे जॉब के सभी पॉड द्वारा केवल पढ़ने के मोड में आवश्यकता है, तो आप आमतौर पर उसे NFS जैसी साझा फ़ाइल सिस्टम में डालते हैं और उसे सभी पॉड पर केवल पढ़ने के लिए माउंट करते हैं, या पॉड में प्रोग्राम को इस तरह लिखते हैं कि यह क्लस्टर फ़ाइल सिस्टम से डेटा को मूल रूप से पढ़ सके (उदाहरण के लिए: HDFS)।

इस उदाहरण के लिए, आप AMQP कमांड लाइन टूल का उपयोग करके क्यू बनाएंगे और इसे भरेंगे। व्यवहार में, आप AMQP क्लाइंट लाइब्रेरी का उपयोग करके क्यू को भरने के लिए एक प्रोग्राम लिख सकते हैं।

# इसे अपने कंप्यूटर पर चलाएं, पॉड में नहीं
/usr/bin/amqp-declare-queue --url=$BROKER_URL -q job1  -d

job1

क्यू में आइटम जोड़ें:

for f in apple banana cherry date fig grape lemon melon
do
  /usr/bin/amqp-publish --url=$BROKER_URL -r job1 -p -b $f
done

आपने क्यू में 8 संदेश जोड़े हैं।

एक कंटेनर इमेज बनाएं

अब आप एक इमेज बनाने के लिए तैयार हैं जिसे आप एक जॉब के रूप में चलाएंगे।

जॉब क्यू से संदेश पढ़ने और वास्तविक कार्य करने के लिए amqp-consume उपयोगिता का उपयोग करेगा। यहाँ एक बहुत ही सरल उदाहरण प्रोग्राम है:

4.3.7 - पॉड फेलियर पॉलिसी

पॉड फेलियर पॉलिसी आपको निम्नलिखित में मदद कर सकती है:

• कम्प्यूटेशनल संसाधनों का बेहतर उपयोग करके अनावश्यक पॉड रिट्राइज से बचें।
• पॉड डिसरप्शन (जैसे प्रीम्प्शन, API-इनिशिएटेड एविक्शन या टेंट-बेस्ड एविक्शन) के कारण जॉब फेलियर से बचें।

शुरू करने से पहले

आपको पहले से ही Job के बुनियादी उपयोग से परिचित होना चाहिए।

आपको कुबरनेट्स क्लस्टर की ज़रूरत पड़ेगी और क्यूब सीटीएल कमांड लाइन साधन को समनुरूप करना होगा ताकि वो आपके क्लस्टर के साथ संवाद कर सकें। हमारी सलाह है की इस टुटोरिअल को क्लस्टर में रन करने के लिए कम से कम दो नोड का इस्तेमाल करे जो कि कंट्रोल प्लेन होस्ट के तरह ना एक्ट करे। अगर आपके पास पहले से क्लस्टर नही है, आप minikube की मदद से वह बना सकते है या आप नीचे दिए हुए इन दो कुबरनेट्स प्लेग्राउंड का इस्तेमाल कर सकते हैं:

• Katacoda
• प्ले विथ कुबेरनेट्स

संस्करण की जांच करने के लिए, लिखें kubectl version.

आपके Kubernetes सर्वर का वर्जन v1.25 या उससे बाद का होना चाहिए।

वर्जन जांचने के लिए, kubectl version दर्ज करें।

अनावश्यक पॉड रिट्राइज से बचने के लिए पॉड फेलियर पॉलिसी का उपयोग करना

निम्नलिखित उदाहरण के साथ, आप सीख सकते हैं कि कैसे पॉड फेलियर पॉलिसी का उपयोग करके अनावश्यक पॉड रीस्टार्ट से बचा जा सकता है जब एक पॉड फेलियर एक नॉन-रेट्रायबल सॉफ्टवेयर बग का संकेत देता है।

सबसे पहले, कॉन्फ़िग के आधार पर एक जॉब बनाएं:

apiVersion: batch/v1
kind: Job
metadata:
  name: job-pod-failure-policy-failjob
spec:
  completions: 8
  parallelism: 2
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: main
        image: docker.io/library/bash:5
        command: ["bash"]
        args:
        - -c
        - echo "Hello world! I'm going to exit with 42 to simulate a software bug." && sleep 30 && exit 42
  backoffLimit: 6
  podFailurePolicy:
    rules:
    - action: FailJob
      onExitCodes:
        containerName: main
        operator: In
        values: [42]

इसे चलाकर:

kubectl create -f job-pod-failure-policy-failjob.yaml

लगभग 30 सेकंड के बाद पूरा जॉब टर्मिनेट हो जाना चाहिए। जॉब की स्थिति की जांच करने के लिए चलाएं:

kubectl get jobs -l job-name=job-pod-failure-policy-failjob -o yaml

जॉब स्थिति में, निम्नलिखित कंडीशन्स दिखाई देते हैं:

• FailureTarget कंडीशन: reason फील्ड PodFailurePolicy पर सेट है और message फील्ड में टर्मिनेशन के बारे में अधिक जानकारी है, जैसे Container main for pod default/job-pod-failure-policy-failjob-8ckj8 failed with exit code 42 matching FailJob rule at index 0। जॉब कंट्रोलर जॉब को फेलियर मानते ही इस कंडीशन को जोड़ता है। विवरण के लिए, टर्मिनेशन ऑफ जॉब पॉड्स देखें।
• Failed कंडीशन: FailureTarget कंडीशन के समान reason और message। जॉब कंट्रोलर जॉब के सभी पॉड्स टर्मिनेट होने के बाद इस कंडीशन को जोड़ता है।

तुलना के लिए, यदि पॉड फेलियर पॉलिसी डिसेबल होती, तो पॉड के 6 रिट्राइज लगते, जिसमें कम से कम 2 मिनट लगते।

सफाई

आपके द्वारा बनाए गए जॉब को हटाएं:

kubectl delete jobs/job-pod-failure-policy-failjob

क्लस्टर स्वचालित रूप से पॉड्स को साफ कर देगा।

पॉड डिसरप्शन को अनदेखा करने के लिए पॉड फेलियर पॉलिसी का उपयोग करना

निम्नलिखित उदाहरण के साथ, आप सीख सकते हैं कि कैसे पॉड फेलियर पॉलिसी का उपयोग करके पॉड डिसरप्शन को अनदेखा किया जा सकता है जो .spec.backoffLimit लिमिट की ओर पॉड रिट्राइ काउंटर को बढ़ाने से रोकता है।

सावधानी:

इस उदाहरण के लिए टाइमिंग महत्वपूर्ण है, इसलिए आप निष्पादन से पहले चरणों को पढ़ना चाह सकते हैं। पॉड डिसरप्शन को ट्रिगर करने के लिए, जबकि पॉड उस पर चल रहा हो (पॉड के शेड्यूल होने के 90 सेकंड के भीतर) नोड को ड्रेन करना महत्वपूर्ण है।

1. कॉन्फ़िग के आधार पर एक जॉब बनाएं:

apiVersion: batch/v1
kind: Job
metadata:
  name: job-pod-failure-policy-ignore
spec:
  completions: 4
  parallelism: 2
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: main
        image: docker.io/library/bash:5
        command: ["bash"]
        args:
        - -c
        - echo "Hello world! I'm going to exit with 0 (success)." && sleep 90 && exit 0
  backoffLimit: 0
  podFailurePolicy:
    rules:
    - action: Ignore
      onPodConditions:
      - type: DisruptionTarget

इसे चलाकर:

kubectl create -f job-pod-failure-policy-ignore.yaml

2. पॉड के शेड्यूल किए गए nodeName की जांच करने के लिए यह कमांड चलाएं:

nodeName=$(kubectl get pods -l job-name=job-pod-failure-policy-ignore -o jsonpath='{.items[0].spec.nodeName}')

3. पॉड के पूरा होने से पहले नोड को ड्रेन करें (90 सेकंड के भीतर):

kubectl drain nodes/$nodeName --ignore-daemonsets --grace-period=0

4. जॉब के लिए काउंटर न बढ़ने की जांच करने के लिए .status.failed की जांच करें:

kubectl get jobs -l job-name=job-pod-failure-policy-ignore -o yaml

5. नोड को अनकॉर्डन करें:

kubectl uncordon nodes/$nodeName

जॉब रिज्यूम होता है और सफल होता है।

तुलना के लिए, यदि पॉड फेलियर पॉलिसी डिसेबल होती, तो पॉड डिसरप्शन पूरे जॉब को टर्मिनेट कर देता (क्योंकि .spec.backoffLimit 0 पर सेट है)।

सफाई

आपके द्वारा बनाए गए जॉब को हटाएं:

kubectl delete jobs/job-pod-failure-policy-ignore

क्लस्टर स्वचालित रूप से पॉड्स को साफ कर देगा।

कस्टम पॉड कंडीशन्स के आधार पर अनावश्यक पॉड रिट्राइज से बचने के लिए पॉड फेलियर पॉलिसी का उपयोग करना

निम्नलिखित उदाहरण के साथ, आप सीख सकते हैं कि कैसे पॉड फेलियर पॉलिसी का उपयोग करके कस्टम पॉड कंडीशन्स के आधार पर अनावश्यक पॉड रीस्टार्ट से बचा जा सकता है।

नोट:

नीचे दिया गया उदाहरण वर्जन 1.27 से काम करता है क्योंकि यह Pending फेज में डिलीट किए गए पॉड्स के टर्मिनल फेज में ट्रांजिशन पर निर्भर करता है (देखें: पॉड फेज)।

1. सबसे पहले, कॉन्फ़िग के आधार पर एक जॉब बनाएं:

apiVersion: batch/v1
kind: Job
metadata:
  name: job-pod-failure-policy-config-issue
spec:
  completions: 8
  parallelism: 2
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: main
        image: "non-existing-repo/non-existing-image:example"
  backoffLimit: 6
  podFailurePolicy:
    rules:
    - action: FailJob
      onPodConditions:
      - type: ConfigIssue

इसे चलाकर:

kubectl create -f job-pod-failure-policy-config-issue.yaml

ध्यान दें कि, इमेज मिसकॉन्फ़िगर्ड है, क्योंकि यह मौजूद नहीं है।

2. जॉब के पॉड्स की स्थिति की जांच करने के लिए चलाएं:

kubectl get pods -l job-name=job-pod-failure-policy-config-issue -o yaml

आप इसके समान आउटपुट देखेंगे:

containerStatuses:
- image: non-existing-repo/non-existing-image:example
   ...
   state:
   waiting:
      message: Back-off pulling image "non-existing-repo/non-existing-image:example"
      reason: ImagePullBackOff
      ...
phase: Pending

ध्यान दें कि पॉड Pending फेज में रहता है क्योंकि यह मिसकॉन्फ़िगर्ड इमेज को पुल करने में विफल रहता है। सिद्धांत रूप में, यह एक ट्रांजिएंट इश्यू हो सकता है और इमेज पुल की जा सकती है। हालांकि, इस मामले में, इमेज मौजूद नहीं है इसलिए हम इस तथ्य को एक कस्टम कंडीशन द्वारा इंगित करते हैं।

3. कस्टम कंडीशन जोड़ें। पहले पैच तैयार करें:

cat <<EOF > patch.yaml
status:
  conditions:
  - type: ConfigIssue
    status: "True"
    reason: "NonExistingImage"
    lastTransitionTime: "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
EOF

दूसरा, जॉब द्वारा बनाए गए पॉड्स में से एक का चयन करें:

podName=$(kubectl get pods -l job-name=job-pod-failure-policy-config-issue -o jsonpath='{.items[0].metadata.name}')

फिर, निम्न कमांड चलाकर एक पॉड पर पैच लागू करें:

kubectl patch pod $podName --subresource=status --patch-file=patch.yaml

यदि सफलतापूर्वक लागू किया गया, तो आपको इसके समान एक नोटिफिकेशन मिलेगा:

pod/job-pod-failure-policy-config-issue-k6pvp patched

4. पॉड को Failed फेज में ट्रांजिशन करने के लिए इसे डिलीट करें:

kubectl delete pods/$podName

5. जॉब की स्थिति की जांच करने के लिए चलाएं:

kubectl get jobs -l job-name=job-pod-failure-policy-config-issue -o yaml

जॉब स्थिति में, reason फील्ड PodFailurePolicy के बराबर वाली जॉब Failed कंडीशन देखें। इसके अतिरिक्त, message फील्ड में जॉब टर्मिनेशन के बारे में अधिक विस्तृत जानकारी होती है, जैसे: Pod default/job-pod-failure-policy-config-issue-k6pvp has condition ConfigIssue matching FailJob rule at index 0।

नोट:

प्रोडक्शन एनवायरनमेंट में, चरण 3 और 4 को यूजर-प्रोवाइडेड कंट्रोलर द्वारा ऑटोमेट किया जाना चाहिए।

सफाई

आपके द्वारा बनाए गए जॉब को हटाएं:

kubectl delete jobs/job-pod-failure-policy-config-issue

क्लस्टर स्वचालित रूप से पॉड्स को साफ कर देगा।

वैकल्पिक

आप केवल पॉड बैकऑफ फेलियर पॉलिसी पर भरोसा कर सकते हैं, जॉब के .spec.backoffLimit फील्ड को निर्दिष्ट करके। हालांकि, कई स्थितियों में .spec.backoffLimit के लिए एक कम वैल्यू सेट करके अनावश्यक पॉड रिट्राइज से बचने और फिर भी यह सुनिश्चित करने के लिए कि जॉब पॉड डिसरप्शन द्वारा टर्मिनेट नहीं होगा, के बीच संतुलन खोजना समस्याग्रस्त हो सकता है।

आगे क्या है

• जॉब्स के बारे में और जानें
• पॉड फेलियर पॉलिसी के बारे में और जानें
• पॉड्स के बारे में और जानें
• सेवाएं के बारे में और जानें

4.4 - TLS

4.4.1 - क्यूबलेट के लिए प्रमाणपत्र आवर्तन कॉन्फ़िगर करें

यह पृष्ठ दिखाता है कि क्यूबलेट के लिए प्रमाणपत्र आवर्तन कैसे सक्षम और कॉन्फ़िगर कर सकते है।

शुरू करने से पहले

• कम से कम कुबेरनेट्स संस्करण 1.8.0 या उसके बाद की आवश्यकता है।

अवलोकन

क्यूबलेट प्रमाणपत्रों का उपयोग कुबरनेट्स API के साथ प्रमाणित करने के लिए करता है। डिफ़ॉल्ट रूप से, ये प्रमाणपत्र एक वर्ष की समाप्ति के साथ जारी किए जाते हैं ताकि उन्हें बार-बार नवीनीकृत करने की आवश्यकता न हो।

कुबरनेट्स में क्यूबलेट प्रमाणपत्र आवर्तन शामिल है, जो स्वचालित रूप से एक नई कुंजी उत्पन्न करेगा जो स्वचालित रूप से एक नई कुंजी उत्पन्न करेगा और वर्तमान प्रमाणपत्र की समाप्ति के करीब आने पर कुबरनेट्स API से एक नया प्रमाणपत्र अनुरोध करेगा। एक बार नया प्रमाणपत्र उपलब्ध हो जाने पर, यह कुबरनेट्स API के साथ कनेक्शन को प्रमाणित करने के लिए उपयोग किया जाएगा।

क्लाइंट प्रमाणपत्र रोटेशन सक्षम करना

kubelet प्रक्रिया एक प्राचल --rotate-certificates स्वीकार करती है जो नियंत्रित करती है कि क्या कुबलेट स्वचालित रूप से वर्तमान में उपयोग किए जा रहे प्रमाणपत्र की समाप्ति के करीब आने पर एक नया प्रमाणपत्र अनुरोध करेगा।

kube-controller-manager प्रक्रिया एक प्राचल स्वीकार करती है --cluster-signing-duration (--experimental-cluster-signing-duration 1.19 से पहले) जो नियंत्रित करता है कि प्रमाणपत्र कितने समय के लिए जारी किए जाएंगे।

प्रमाणपत्र रोटेशन कॉन्फ़िगरेशन को समझना

जब एक कुबलेट शुरू होता है, यदि इसे बूटस्ट्रैप करने के लिए कॉन्फ़िगर किया गया है (उपयोग करते हुए --bootstrap-kubeconfig फ्लैग), तो यह कुबरनेट्स API से कनेक्ट करने और एक प्रमाणपत्र हस्ताक्षर अनुरोध जारी करने के लिए अपने प्रारंभिक प्रमाणपत्र का उपयोग करेगा। आप प्रमाणपत्र हस्ताक्षर अनुरोधों की स्थिति देख सकते हैं:

kubectl get csr

शुरुआत में, किसी नोड पर कुबलेट से एक प्रमाणपत्र हस्ताक्षर अनुरोध की स्थिति Pending होगी। यदि प्रमाणपत्र हस्ताक्षर अनुरोध विशिष्ट मानदंडों को पूरा करता है, तो इसे नियंत्रक प्रबंधक द्वारा स्वचालित रूप से अनुमोदित किया जाएगा, और फिर इसकी स्थिति Approved होगी। इसके बाद, नियंत्रक प्रबंधक एक प्रमाणपत्र पर हस्ताक्षर करेगा, जो --cluster-signing-duration पैरामीटर द्वारा निर्दिष्ट अवधि के लिए जारी किया जाएगा, और हस्ताक्षरित प्रमाणपत्र को प्रमाणपत्र हस्ताक्षर अनुरोध से जोड़ा जाएगा।

कुबलेट कुबरनेट्स API से हस्ताक्षरित प्रमाणपत्र प्राप्त करेगा और इसे डिस्क पर लिखेगा, --cert-dir द्वारा निर्दिष्ट स्थान में। फिर कुबलेट कुबरनेट्स API से कनेक्ट करने के लिए नए प्रमाणपत्र का उपयोग करेगा।

जैसे ही हस्ताक्षरित प्रमाणपत्र की समाप्ति निकट आती है, कुबलेट स्वचालित रूप से कुबरनेट्स API का उपयोग करके एक नया प्रमाणपत्र हस्ताक्षर अनुरोध जारी करेगा। यह प्रमाणपत्र पर शेष समय के 30% और 10% के बीच किसी भी बिंदु पर हो सकता है। फिर से, नियंत्रक प्रबंधक स्वचालित रूप से प्रमाणपत्र अनुरोध को अनुमोदित करेगा और प्रमाणपत्र हस्ताक्षर अनुरोध से एक हस्ताक्षरित प्रमाणपत्र जोड़ेगा। कुबलेट कुबरनेट्स API से नया हस्ताक्षरित प्रमाणपत्र प्राप्त करेगा और इसे डिस्क पर लिखेगा। फिर यह कुबरनेट्स API के साथ कनेक्शन को नए प्रमाणपत्र का उपयोग करके पुन: कनेक्ट करने के लिए अपडेट करेगा।

5 - ट्यूटोरियल

प्रलेखन के इस खंड में ट्यूटोरियल हैं। ट्यूटोरियल दिखाता है कि किसी एकल कार्य से बड़े लक्ष्य को कैसे पूरा किया जाए। आमतौर पर एक ट्यूटोरियल में कई खंड होते हैं, जिनमें से प्रत्येक में चरणों के क्रम होते हैं। प्रत्येक ट्यूटोरियल से परिचित होने से पहले, हम आपको मानकीकृत शब्दावली पृष्ट को बुकमार्क करने की सलाह देते हैं।

मूलभूत

• मूलभूत कुबरनेट्स एक गहन संवादात्मक ट्यूटोरियल है जो आपको कुबेरनेट्स प्रणाली को समझने और कुबेरनेट्स की कुछ बुनियादी सुविधाओं को आज़माने में मदद करता है।

• Introduction to Kubernetes (edX)

• Hello Minikube

विन्यास

• Configuring Redis Using a ConfigMap (कॉन्फिग मैप का उपयोग करके Redis का विन्यास करना)

स्टेटलेस एप्लीकेशन

• Exposing an External IP Address to Access an Application in a Cluster (किसी क्लस्टर में किसी एप्लिकेशन तक पहुंचने के लिए बाहरी आईपी पते को उजागर करना)

• Example: Deploying PHP Guestbook application with Redis (उदाहरण: रेडिस के साथ PHP गेस्टबुक एप्लिकेशन को उपयोग करना)

स्टेटफुल एप्लीकेशन

• स्टेटफुलसेट मूलभूत

• उदाहरण: दृढ़ वॉल्यूम के साथ वर्डप्रेस और MySQL

• उदाहरण: कैसेंड्रा को स्टेटफुल सेट के साथ उपयोग करना

• एक CP वितरित प्रणाली, ज़ूकीपर चलाना

क्लस्टर

• AppArmor

• Seccomp

सर्विस

• सोर्स आईपी का उपयोग करना

आगे क्या है

यदि आप एक ट्यूटोरियल लिखना चाहते हैं, तो ट्यूटोरियल पेज प्रकार के बारे में जानकारी के लिए सामग्री पृष्ठ प्रकार देखें।

5.1 - हेलो मिनीक्यूब

यह ट्यूटोरियल आपको मिनिक्यूब का उपयोग करते हुए कुबेरनेट्स पर एक सैम्पल ऐप चलाने का तरीका दिखाता है। ट्यूटोरियल एक कंटेनर छवि प्रदान करता है जो सभी अनुरोधों को प्रतिध्वनित करने के लिए NGINX का उपयोग करता है।

उद्देश्य

• मिनीक्यूब में एक नमूना एप्लीकेशन डेप्लॉय करें।
• ऐप को चलाएं।
• एप्लिकेशन लॉग देखें।

शुरू करने से पहले

यह ट्यूटोरियल मानता है कि आपने पहले ही मिनीक्यूब सेट कर लिया है। इंस्टॉलेशन निर्देशों के लिए मिनीक्यूब स्टार्ट में Step 1 देखें।

आपको kubectl भी इंस्टॉल करना होगा। स्थापाना निर्देश के लिए Kubectl स्थापित करें देखें।

एक मिनीक्यूब क्लस्टर बनाएं

minikube start

कुबेरनेट्स डैशबोर्ड खोलें:

कुबेरनेट्स डैशबोर्ड खोलें। आप इसे दो अलग-अलग तरीकों से कर सकते हैं:

• ब्राउज़र से लॉन्च करें
• URL कॉपी और पेस्ट करें

# एक नया टर्मिनल प्रारंभ करें, और इस कमांड को चालू छोड़ दें।
minikube dashboard

minikube dashboard --url

डेप्लॉयमेंट बनाएँ

कुबेरनेट्स पॉड एक या अधिक कंटेनरों का एक समूह है, जो प्रशासन और नेटवर्किंग के उद्देश्यों के लिए एक साथ बंधे होते हैं। इस ट्यूटोरियल के पॉड में केवल एक कंटेनर है। कुबेरनेट्स डेप्लॉयमेंट आपके पॉड के स्वास्थ्य की जाँच करता है और यदि पॉड बंद हो जाता है तो पॉड के कंटेनर को पुनः आरंभ करता है। पॉड्स के निर्माण और स्केलिंग को प्रबंधित करने के लिए डेप्लॉयमेंट अनुशंसित तरीका है।

1. पॉड को प्रबंधित करने वाला डेप्लॉयमेंट बनाने के लिए kubectl create कमांड का उपयोग करें। पॉड प्रदान की गई डॉकर इमेज के आधार पर एक कंटेनर चलाता है।

   kubectl create deployment hello-node --image=registry.k8s.io/echoserver:1.4
   

2. डेप्लॉयमेंट देखें:

   kubectl get deployments
   

   आउटपुट कुछ इस समान होगा:

   NAME         READY   UP-TO-DATE   AVAILABLE   AGE
   hello-node   1/1     1            1           1m
   

3. पॉड देखें:

   kubectl get pods
   

   आउटपुट कुछ इस समान होगा:

   NAME                          READY     STATUS    RESTARTS   AGE
   hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m
   

4. क्लस्टर इवेंट देखें:

   kubectl get events
   

5. kubectl कॉन्फ़िगरेशन देखें:

   kubectl config view
   

सर्विस बनाएं

आमतौर पर, पॉड कुबेरनेट्स क्लस्टर के भीतर अपने आंतरिक IP पते से ही पहुँचा जा सकता है। hello-node कंटेनर को कुबेरनेट्स वर्चुअल नेटवर्क के बाहर से सुलभ बनाने के लिए,पॉड को कुबेरनेट्स सर्विस के रूप में बेनकाब करना होगा।

1. kubectl expose कमांड का उपयोग करके पॉड को सार्वजनिक इंटरनेट पर एक्सपोज़ करें:

   kubectl expose deployment hello-node --type=LoadBalancer --port=8080
   

   --type=LoadBalancer फ्लैग इंगित करता है कि आप क्लस्टर के बाहर अपने सर्विस को प्रदर्शित करना चाहते हैं।

   इमेज के अंदर एप्लिकेशन कोड registry.k8s.io/echoserver केवल TCP पोर्ट 8080 पर सुनता है। यदि आपने किसी भिन्न पोर्ट को एक्सपोज़ करने के लिए kubectl एक्सपोज़ का उपयोग किया है, तो क्लाइंट उस अन्य पोर्ट से जुड़ नहीं सकते।

2. आपके द्वारा बनाई गई सर्विस देखें:

   kubectl get service
   

   आउटपुट कुछ इस समान होगा:

   NAME         TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   hello-node   LoadBalancer   10.108.144.78   <pending>     8080:30369/TCP   21s
   kubernetes   ClusterIP      10.96.0.1       <none>        443/TCP          23m
   

   लोड बैलेंसर्स का समर्थन करने वाले क्लाउड प्रदाताओं पर, सर्विस तक पहुंचने के लिए एक बाहरी IP पते का प्रावधान किया जाएगा। मिनीक्यूब पर, LoadBalancer टाइप minikube service कमांड से सर्विस को पहुंच योग्य बनाता है।

3. इस कमांड को चलायें:

   minikube service hello-node
   

   यह कमांड एक ब्राउज़र विंडो खोलता है जो ऐप की प्रतिक्रिया दिखाती है।

ऐडऑन सक्षम करें

मिनीक्यूब टूल में बिल्ट-इन ऐडऑन (add on) का एक समूह शामिल है जिसे स्थानीय कुबेरनेट्स वातावरण में सक्षम, अक्षम और खोला जा सकता है।

1. वर्तमान में उपलब्ध ऐडऑन की सूची:

   minikube addons list
   

   आउटपुट कुछ इस समान होगा:

   addon-manager: enabled
   dashboard: enabled
   default-storageclass: enabled
   efk: disabled
   freshpod: disabled
   gvisor: disabled
   helm-tiller: disabled
   ingress: disabled
   ingress-dns: disabled
   logviewer: disabled
   metrics-server: disabled
   nvidia-driver-installer: disabled
   nvidia-gpu-device-plugin: disabled
   registry: disabled
   registry-creds: disabled
   storage-provisioner: enabled
   storage-provisioner-gluster: disabled
   

2. एक ऐडऑन सक्षम करें, उदाहरण के लिए, metrics-server:

   minikube addons enable metrics-server
   

   आउटपुट कुछ इस समान होगा:

   The 'metrics-server' addon is enabled
   

3. आपके द्वारा बनाई गई पॉड और सर्विस देखें:

   kubectl get pod,service -n kube-system
   

   आउटपुट कुछ इस समान होगा:

   NAME                                        READY     STATUS    RESTARTS   AGE
   pod/coredns-5644d7b6d9-mh9ll                1/1       Running   0          34m
   pod/coredns-5644d7b6d9-pqd2t                1/1       Running   0          34m
   pod/metrics-server-67fb648c5                1/1       Running   0          26s
   pod/etcd-minikube                           1/1       Running   0          34m
   pod/influxdb-grafana-b29w8                  2/2       Running   0          26s
   pod/kube-addon-manager-minikube             1/1       Running   0          34m
   pod/kube-apiserver-minikube                 1/1       Running   0          34m
   pod/kube-controller-manager-minikube        1/1       Running   0          34m
   pod/kube-proxy-rnlps                        1/1       Running   0          34m
   pod/kube-scheduler-minikube                 1/1       Running   0          34m
   pod/storage-provisioner                     1/1       Running   0          34m
   
   NAME                           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGE
   service/metrics-server         ClusterIP   10.96.241.45    <none>        80/TCP              26s
   service/kube-dns               ClusterIP   10.96.0.10      <none>        53/UDP,53/TCP       34m
   service/monitoring-grafana     NodePort    10.99.24.54     <none>        80:30002/TCP        26s
   service/monitoring-influxdb    ClusterIP   10.111.169.94   <none>        8083/TCP,8086/TCP   26s
   

4. metrics-serverअक्षम करें:

   minikube addons disable metrics-server
   

   आउटपुट कुछ इस समान होगा:

   metrics-server was successfully disabled
   

साफ - सफाई

अब आप अपने क्लस्टर में बनाए गए संसाधनों को साफ कर सकते हैं:

kubectl delete service hello-node
kubectl delete deployment hello-node

वैकल्पिक रूप से, मिनिक्यूब वर्चुअल मशीन (VM) को बंद करें:

minikube stop

वैकल्पिक रूप से, मिनिक्यूब VM को डिलीट करें:

minikube delete

आगे क्या है

• डेप्लॉयमेंट ऑब्जेक्ट के बारे में अधिक जाने।
• एप्लीकेशन डेप्लॉय करने के बारे में अधिक जाने।
• सर्विस ऑब्जेक्ट के बारे में अधिक जाने।

5.2 - बुनियादी कुबेरनेट्स सीखें

बुनियादी कुबेरनेट्स

यह ट्यूटोरियल कुबेरनेट्स क्लस्टर ऑर्केस्ट्रेशन सिस्टम की मूल बातों का पूर्वाभ्यास प्रदान करता है। प्रत्येक मॉड्यूल में कुबेरनेट्स की प्रमुख विशेषताओं और अवधारणाओं पर कुछ जानकारी और एक इंटरैक्टिव ऑनलाइन ट्यूटोरियल शामिल होते हैं। ये इंटरेक्टिव ट्यूटोरियल आपको अपने लिए एक साधारण क्लस्टर और इसके कंटेनरीकृत एप्लीकेशन का प्रबंधन करने देते हैं।

इंटरैक्टिव ट्यूटोरियल का उपयोग करके, आप सीख सकते हैं:

• एक क्लस्टर पर कंटेनरीकृत एप्लीकेशन डिप्लॉय करें।
• डिप्लॉयमेंट को स्केल करें।
• नए सॉफ़्टवेयर संस्करण के साथ कंटेनरीकृत एप्लिकेशन को अपडेट करें।
• कंटेनरीकृत एप्लिकेशन को डीबग करें।

कुबेरनेट्स आपके लिए क्या कर सकता है?

आधुनिक वेब सेवाओं के साथ उपयोगकर्ता उम्मीद करते हैं कि एप्लिकेशन 24/7 उपलब्ध होंगे, और डेवलपर्स उन एप्लिकेशन के नए संस्करणों को दिन में कई बार डिप्लॉय करने की उम्मीद करते हैं। कंटेनरीकरण पैकेज सॉफ़्टवेयर को इन लक्ष्यों को पूरा करने में मदद करता है, जिससे एप्लिकेशन बिना डाउनटाइम के रिलीज़ और अपडेट किए जा सकते हैं। कुबेरनेट्स आपको यह सुनिश्चित करने में मदद करता है कि वे कंटेनरीकृत एप्लिकेशन जहां और जब आप चाहते हैं, चलते हैं, और उन्हें उन संसाधनों और उपकरणों को खोजने में मदद करते हैं जिनकी उन्हें काम करने के लिए आवश्यकता होती है। कुबेरनेट्स एक उत्पादन के लिए तैयार, ओपन सोर्स प्लेटफॉर्म है जिसे कंटेनर ऑर्केस्ट्रेशन में गूगल के संचित अनुभव के साथ डिज़ाइन किया गया है और समुदाय के उत्तम विचारों से संयुक्त है।

बुनियादी कुबेरनेट्स मॉड्यूल

1. कुबेरनेट्स क्लस्टर बनाएं

2. ऐप डिप्लॉय करें

3. अपना ऐप एक्सप्लोर करें

4. अपने ऐप को सार्वजनिक रूप से एक्सपोज़ करें

5. अपना ऐप स्केल करें

6. अपना ऐप अपडेट करें

5.2.1 - एक क्लस्टर बनाएं

कुबेरनेट्स क्लस्टर के बारे में जानें और मिनिक्यूब का उपयोग करके एक सरल क्लस्टर बनाएं।

5.2.1.1 - Minikube का उपयोग कर क्लस्टर बनाना

5.2.2 - डिप्लॉय ऐप

5.2.2.1 - डिप्लॉयमेंट बनाने के लिए kubectl का उपयोग करना

5.2.3 - ऐप का अन्वेषण करें

5.2.3.1 - पॉड्स और नोड्स की जांच करना

5.2.4 - अपने ऐप को सार्वजनिक रूप से एक्सपोस करें

5.2.4.1 - अपने ऐप को एक्सपोज़ करने के लिए किसी सर्विस का उपयोग करना

http://127.0.0.1:51082
! क्योंकि आप डार्विन पर डॉकर ड्राइवर का उपयोग कर रहे हैं, इसे चलाने के लिए टर्मिनल का खुला होना आवश्यक है।

5.2.5 - अपने ऐप को स्केल करें

5.2.5.1 - अपने ऐप के कई इंस्टेंस चलाना

उद्देश्य

• kubectl का उपयोग करके किसी ऐप को स्केल करें।

एक एप्लीकेशन को स्केल करना

पिछले मॉड्यूल में हमने एक डिप्लॉयमेंट बनाया और इसे सर्विस के माध्यम से सार्वजनिक रूप से प्रदर्शित किया। डिप्लॉयमेंट ने हमारे एप्लिकेशन को चलाने के लिए केवल एक पॉड बनाया। जब ट्रैफ़िक बढ़ता है, तो हमें उपयोगकर्ता की मांग को पूरा करने के लिए एप्लिकेशन को स्केल करना होता है।

डिप्लॉयमेंट में रेप्लिका की संख्या को बदलकर स्केलिंग को प्राप्त किया जाता है।

टिप्पणी:

यदि आप पिछले अनुभाग के बाद यह प्रयास कर रहे हैं, तो हो सकता है कि आपने डिप्लॉयमेंट को उजागर करने वाली सेवा को हटा दिया हो। उस स्थिति में, कृपया निम्नलिखित कमांड का उपयोग करके डिप्लॉयमेंट को फिर से उजागर करें:

kubectl expose deployment/kubernetes-bootcamp --type="NodePort" --port 8080

सारांश:

• एक डिप्लॉयमेंट को स्केल करना

आप kubectl create deployment कमांड के लिए --replicas पैरामीटर का उपयोग करके कई इंस्टेंस के साथ एक डिप्लॉयमेंट शुरू से बना सकते हैं।

स्केलिंग अवलोकन

पिछला अगला

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

किसी एप्लिकेशन के कई इंस्टेंस को चलाने के लिए उन सभी को ट्रैफ़िक वितरित करने के तरीके की आवश्यकता होगी। सर्विसों में एक एकीकृत लोड-बैलेंसर होता है जो एक एक्सपोज्ड डिप्लॉयमेंट के सभी पॉड्स को नेटवर्क ट्रैफ़िक वितरित करेगा। सर्विसे एंडपॉइंट्स का उपयोग करते हुए रनिंग पॉड्स की लगातार निगरानी करेंगी यह सुनिश्चित करने के लिए कि ट्रैफ़िक केवल उपलब्ध पॉड्स को ही भेजा जाए।

डिप्लॉयमेंट में रेप्लिका की संख्या को बदलकर स्केलिंग को पूरा किया जाता है।

एक बार जब आपके पास किसी एप्लिकेशन के चलने के कई इंस्टेंस हैं, तो आप डाउनटाइम के बिना रोलिंग अपडेट करने में सक्षम होंगे। हम इसे अगले मॉड्यूल में करेंगे। अब, ऑनलाइन टर्मिनल पर चलते हैं और हमारे एप्लिकेशन को स्केल करते हैं।

डिप्लॉयमेंट को स्केल करना

अपनी तैनाती को सूचीबद्ध करने के लिए, get deployments उपकमांड का उपयोग करें:

kubectl get deployments

आउटपुट इसके समान होना चाहिए:

                NAME                  READY   UP-TO-DATE   AVAILABLE   AGE
                kubernetes-bootcamp   1/1     1            1           11m
                

हमारे पास 1 पॉड होना चाहिए। यदि नहीं, तो कमांड फिर से चलाएँ। इससे पता चलता है:

• NAME क्लस्टर में परिनियोजन के नाम सूचीबद्ध करता है।
• READY वर्तमान/वांछित प्रतिकृतियों का अनुपात दर्शाता है
• UP-TO-DATE उन प्रतिकृतियों की संख्या प्रदर्शित करता है जिन्हें वांछित स्थिति प्राप्त करने के लिए अद्यतन किया गया है।
• AVAILABLE प्रदर्शित करता है कि आपके उपयोगकर्ताओं के लिए एप्लिकेशन की कितनी प्रतिकृतियां उपलब्ध हैं।
• AGE एप्लिकेशन के चलने की अवधि प्रदर्शित करता है।

परिनियोजन द्वारा बनाए गए रेप्लिकासेट को देखने के लिए, चलाएँ:

kubectl get rs

ध्यान दें कि रेप्लिकासेट का नाम हमेशा [DEPLOYMENT-NAME]-[RANDOM-STRING] के रूप में स्वरूपित होता है। यादृच्छिक स्ट्रिंग यादृच्छिक रूप से उत्पन्न होती है और बीज के रूप में पॉड-टेम्पलेट-हैश का उपयोग करती है।

इस आउटपुट के दो महत्वपूर्ण कॉलम हैं:

• DESIRED एप्लिकेशन की प्रतिकृतियों की वांछित संख्या प्रदर्शित करता है, जिसे आप परिनियोजन बनाते समय परिभाषित करते हैं। यह वांछित स्थिति है.
• CURRENT दर्शाता है कि वर्तमान में कितनी प्रतिकृतियां चल रही हैं।

इसके बाद, आइए परिनियोजन को 4 प्रतिकृतियों तक मापें। हम kubectl scale कमांड का उपयोग करेंगे, इसके बाद परिनियोजन प्रकार, नाम और उदाहरणों की वांछित संख्या का उपयोग करेंगे:

kubectl scale deployment/kubernetes-bootcamp --replicas=4

अपनी तैनाती को एक बार फिर से सूचीबद्ध करने के लिए, get deployment का उपयोग करें:

kubectl get deployments

जब परिवर्तन लागू किया गया था, उसकी वजह से हमारे पास अब एप्लिकेशन के 4 उदाहरण उपलब्ध हैं। इसके बाद, आइए देखें कि पॉड्स की संख्या बदली है या नहीं:

kubectl get pods -o wide

अब अलग-अलग ip पते के साथ 4 पॉड हैं। परिवर्तन परिनियोजन ईवेंट लॉग में दर्ज किया गया था। इसे जाँचने के लिए, डिस्क्रिप्शन उपकमांड का उपयोग करें:

kubectl describe deployments/kubernetes-bootcamp

आप इस कमांड के आउटपुट में यह भी देख सकते हैं कि अब 4 प्रतिकृतियां हैं।

लोड संतुलन

आइए जांचें कि सेवा ट्रैफ़िक को लोड-संतुलित कर रही है या नहीं। उजागर आईपी और पोर्ट का पता लगाने के लिए हम वर्णन सेवा का उपयोग कर सकते हैं जैसा कि हमने ट्यूटोरियल के पिछले भाग में सीखा था:

kubectl describe services/kubernetes-bootcamp

NODE_PORT नामक एक पर्यावरण चर बनाएं जिसका मान नोड पोर्ट के रूप में हो:

export NODE_PORT='$(kubectl getservices/kubernetes-bootcamp -o go-template='{{(index .spec.ports 0).nodePort}}')'

echo NODE_PORT=$NODE_PORT

इसके बाद, हम उजागर आईपी पते और पोर्ट पर एक curl करेंगे। कमांड को कई बार निष्पादित करें:

curl http://"$(minikube ip):$NODE_PORT"

हम प्रत्येक अनुरोध के साथ एक अलग पॉड पर पहुंचते हैं। यह दर्शाता है कि लोड-संतुलन काम कर रहा है।

स्केल डाउन

परिनियोजन को 2 प्रतिकृतियों तक कम करने के लिए, scale उपकमांड को फिर से चलाएँ:

kubectl scale deployment/kubernetes-bootcamp --replicas=2

यह जांचने के लिए परिनियोजन को सूचीबद्ध करें कि क्या परिवर्तन get deployments उपकमांड के साथ लागू किया गया था:

kubectl get deployments

प्रतिकृतियों की संख्या घटकर 2 हो गई। get pods के साथ पॉड्स की संख्या सूचीबद्ध करें:

kubectl get pods -o wide

यह पुष्टि करता है कि 2 पॉड समाप्त कर दिए गए थे।

एक बार जब आप तैयार हो जाएं, तो एक रोलिंग अपडेट निष्पादित करना पर आगे बढ़ें।

5.2.6 - अपना ऐप अपडेट करें

5.2.6.1 - रोलिंग अपडेट करना

उद्देश्य

• kubectl का उपयोग करके रोलिंग अपडेट करें।

एप्लिकेशन को अपडेट करना

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

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

सारांश:

• ऐप अपडेट करना

रोलिंग अपडेट पॉड्स को नए इंस्टेंस के साथ अपडेट करके डिप्लॉयमेंट के अपडेट को शून्य डाउनटाइम के साथ होने देता है।

रोलिंग अपडेट अवलोकन

पिछला अगला

एप्लिकेशन स्केलिंग के समान, यदि कोई डिप्लॉयमेंट सार्वजनिक रूप से एक्सपोज़ होता है, तो सर्विस केवल अपडेट के दौरान उपलब्ध पॉड्स पर ट्रैफ़िक को लोड-बैलेंस करेगी। उपलब्ध पॉड एक इंस्टेंस है जो एप्लिकेशन के उपयोगकर्ताओं के लिए उपलब्ध है।

रोलिंग अपडेट निम्नलिखित क्रियाओं की अनुमति देते हैं:

• किसी एप्लिकेशन को एक एनवायरनमेंट से दूसरे एनवायरनमेंट में प्रचारित करें (कंटेनर इमेज अपडेट के माध्यम से)
• पिछले संस्करणों में रोलबैक करें
• शून्य डाउनटाइम के साथ एप्लीकेशन का निरंतर इंटीग्रेशन और निरंतर डिलीवरी

यदि कोई डिप्लॉयमेंट सार्वजनिक रूप से प्रकट होता है, तो सर्विस अपडेट के दौरान केवल उपलब्ध पॉड्स पर ट्रैफ़िक लोड-बैलेंस करेगी।

चलिए अगले भाग पर चलते हैं और अपने एप्लिकेशन को एक नए संस्करण में अपडेट और रोलबैक करते है।

ऐप का संस्करण अपडेट करें

अपनी तैनाती को सूचीबद्ध करने के लिए, get deployments उपकमांड चलाएँ: kubectl get deployments

चल रहे पॉड्स को सूचीबद्ध करने के लिए, get pods उपकमांड चलाएँ:

kubectl get pods

ऐप का वर्तमान छवि संस्करण देखने के लिए, describe pod उपकमांड चलाएँ और image फ़ील्ड देखें:

kubectl describe pods

एप्लिकेशन की छवि को संस्करण 2 में अद्यतन करने के लिए, set image उपकमांड का उपयोग करें, इसके बाद परिनियोजन नाम और नया छवि संस्करण लिखें:

kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=jocatalin/kubernetes-bootcamp:v2

कमांड ने आपके ऐप के लिए एक अलग छवि का उपयोग करने के लिए परिनियोजन को सूचित किया और एक रोलिंग अपडेट शुरू किया। नए पॉड्स की स्थिति जांचें, और पुराने पॉड्स को get pods उपकमांड के साथ समाप्त होते हुए देखें:

kubectl get pods

अपडेट सत्यापित करें

सबसे पहले, जांचें कि ऐप चल रहा है या नहीं। उजागर आईपी पते और पोर्ट को खोजने के लिए, describe service कमांड चलाएँ:

kubectl describe services/kubernetes-bootcamp

NODE_PORT नामक एक पर्यावरण चर बनाएं जिसमें निर्दिष्ट नोड पोर्ट का मान हो:

export NODE_PORT='$(kubectl getservices/kubernetes-bootcamp -o go-template='{{(index .spec.ports 0).nodePort}}')'
echo "NODE_PORT=$NODE_PORT"

इसके बाद, उजागर आईपी और पोर्ट पर curl करें:

curl http://'$(minikube ip):$NODE_PORT'

हर बार जब आप curl कमांड चलाएंगे, तो आप एक अलग पॉड से टकराएंगे। ध्यान दें कि सभी पॉड्स अब नवीनतम संस्करण (v2) चला रहे हैं।

आप rollout status उपकमांड चलाकर भी अपडेट की पुष्टि कर सकते हैं:

kubectl rollout status deployments/kubernetes-bootcamp

ऐप का वर्तमान छवि संस्करण देखने के लिए, describe pod उपकमांड चलाएँ:

kubectl describe pods

आउटपुट के image फ़ील्ड में, सत्यापित करें कि आप नवीनतम छवि संस्करण (v2) चला रहे हैं।

अपडेट वापस रोल करें

आइए एक और अपडेट करें, और v10 के साथ टैग की गई छवि को तैनात करने का प्रयास करें:

kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=gcr.io/google-samples/kubernetes-bootcamp:v10

डिप्लॉयमेंट की स्थिति देखने के लिए get deployments का उपयोग करें:

kubectl get deployments

ध्यान दें कि आउटपुट उपलब्ध पॉड्स की वांछित संख्या सूचीबद्ध नहीं करता है। सभी पॉड्स को सूचीबद्ध करने के लिए get pods उपकमांड चलाएँ:

kubectl get pods

ध्यान दें कि कुछ पॉड्स की स्थिति ImagePullBackOff है।

समस्या के बारे में अधिक जानकारी प्राप्त करने के लिए, describe pod उपकमांड चलाएँ:

kubectl describe pods

प्रभावित पॉड्स के आउटपुट के event अनुभाग में, ध्यान दें कि v10 छवि संस्करण रिपॉजिटरी में मौजूद नहीं था।

परिनियोजन को अपने अंतिम कार्यशील संस्करण में वापस लाने के लिए, rollout undo उपकमांड का उपयोग करें:

kubectl rollout undo deployment/kubernetes-bootcamp

rollout undo कमांड परिनियोजन को पिछली ज्ञात स्थिति (छवि का v2) में वापस कर देता है। अद्यतन संस्करणित हैं और आप परिनियोजन की किसी भी पूर्व ज्ञात स्थिति पर वापस लौट सकते हैं।

पॉड्स को फिर से सूचीबद्ध करने के लिए get pods उपकमांड का उपयोग करें:

kubectl get pods

चार पॉड्स चल रहे हैं। इन पॉड्स पर तैनात छवि की जांच करने के लिए, <कोड>describe pods उपकमांड का उपयोग करें:

kubectl describe pods

परिनियोजन एक बार फिर ऐप के स्थिर संस्करण (v2) का उपयोग कर रहा है। रोलबैक सफल रहा.

अपने स्थानीय क्लस्टर को साफ़ करना याद रखें

kubectl delete deployments/kubernetes-bootcamp services/kubernetes-bootcamp

6 - संदर्भ

कुबेरनेट्स प्रलेखन के इस खंड में संदर्भ हैं।

API संदर्भ

• शब्दकोष - कुबेरनेट्स शब्दावली की एक व्यापक, मानकीकृत सूची।
• कुबेरनेट्स API संदर्भ
• कुबेरनेट्स के लिए एक-पृष्ठ API संदर्भ v1.33
• कुबेरनेट्स API का उपयोग करना - कुबेरनेट्स के लिए API का अवलोकन।
• API अभिगम नियंत्रण - कुबेरनेट्स API एक्सेस को कैसे नियंत्रित करता है, इस पर विवरण।
• जाने-माने लेबल, टिप्पणी और दाग

आधिकारिक तौर पर समर्थित ग्राहक पुस्तकालय

कुबेरनेट्स API को प्रोग्रामिंग भाषा से कॉल करने के लिए, आप उपयोग कर सकते हैं client libraries. आधिकारिक तौर पर समर्थित client libraries:

• कुबेरनेट्स Go client library
• कुबेरनेट्स Python client library
• कुबेरनेट्स Java client library
• कुबेरनेट्स JavaScript client library
• कुबेरनेट्स C# client library
• कुबेरनेट्स Haskell client library

CLI

• kubectl - कमांड चलाने और कुबेरनेट्स क्लस्टर के प्रबंधन के लिए मुख्य CLI उपकरण।
  • JSONPath - kubectl के साथ प्रयोग करने के लिए सिन्‌टैक्‍स्‌(वाक्य रचना)मार्गदर्शक JSONPath expressions
• kubeadm - एक सुरक्षित कुबेरनेट्स क्लस्टर का आसानी से प्रावधान करने के लिए CLI टूल।

अवयव

• kubelet - प्राथमिक प्रतिनिधि(एजेंट) जो प्रत्येक नोड पर चलता है। क्यूबलेट पॉडस्पेक्स का एक सेट लेता है और यह सुनिश्चित करता है कि वर्णित कंटेनर चल रहे हैं और स्वस्थ हैं।

• kube-apiserver - REST API जो API वस्तु जैसे पॉड्स, सेवाएं, प्रतिकृति नियंत्रक के लिए डेटा को मान्य और कॉन्फ़िगर करता है।

• kube-controller-manager - डेमॉन जो कुबेरनेट्स के साथ भेजे गए कोर कंट्रोल लूप्स को एम्बेड करता है।

• kube-proxy - बैक-एंड के एक सेट में साधारण TCP/UDP स्ट्रीम फॉरवर्डिंग (आगे भेजना) या राउंड-रॉबिन TCP/UDP फॉरवर्डिंग कर सकते हैं।

• kube-scheduler - अनुसूचक जो उपलब्धता, प्रदर्शन और क्षमता का प्रबंधन करता है।

  • अनुसूचक नीतियां
  • अनुसूचक विवरणिका

कॉन्फिग APIs

इस खंड में "अप्रकाशित" API के लिए दस्तावेज़ शामिल हैं जिनका उपयोग कुबेरनेट्स घटकों या उपकरणों को कॉन्फ़िगर करने के लिए किया जाता है। इनमें से अधिकांश APIs, RESTful तरीके से API सर्वर द्वारा उजागर नहीं होते हैं हालांकि वे एक उपयोगकर्ता या क्लस्टर के उपयोगकर्ता या प्रबंधक के लिए आवश्यक हैं।

• kube-apiserver विन्यास (v1alpha1)
• क्यूबलेट विन्यास (v1beta1)
• kube-scheduler विन्यास (v1beta1)
• kube-scheduler विन्यास (v1beta2)
• kube-scheduler नीति संदर्भ (v1)
• kube-proxy विन्यास (v1alpha1)
• audit.k8s.io/v1 API
• Client प्रमाणीकरण API (v1beta1)
• WebhookAdmission विन्यास (v1)

kubeadm के लिए कॉन्फिग API

• v1beta2
• v1beta3

डिज़ाइन दस्तावेज़

कुबेरनेट्स कार्यक्षमता के लिए डिज़ाइन से संबंधित दस्तावेज़ों का एक संग्रह। अच्छे शुरुआती बिंदु हैं कुबेरनेट्स वास्तुकला और कुबेरनेट्स डिज़ाइन अवलोकन.

6.1 - शब्दकोष

6.2 - शेडुलिंग

6.3 - अन्य उपकरण

कुबेरनेट्स सिस्टम के साथ काम करने में आपकी सहायता के लिए कुबेरनेट्स में कई उपकरण शामिल हैं।

crictl

crictl CRI-संगत कंटेनर रनटाइम के निरीक्षण और डिबगिंग के लिए एक कमांड-लाइन इंटरफ़ेस है।

Dashboard

कुबेरनेट्स का वेब डैशबोर्ड आपको क्लस्टर में कंटेनरीकृत अनुप्रयोगों को तैनात करने, उनकी समस्या का निवारण करने और क्लस्टर के संसाधनों को प्रबंधित करने की अनुमति देता है।

Helm

हेल्म पूर्व-कॉन्फ़िगर कुबेरनेट्स संसाधनों के पैकेजों के प्रबंधन के लिए एक उपकरण है। इन पैकेजों को हेल्म चार्ट के रूप में जाना जाता है।

हेल्म का उपयोग करें:

• कुबेरनेट्स चार्ट के रूप में पैक किए गए लोकप्रिय सॉफ़्टवेयर को ढूंढें और उपयोग करें।
• अपने ख़ुद के एप्लिकेशन को कुबेरनेट्स चार्ट के रूप में साझा करें।
• बुद्धिमत्ता से अपने कुबेरनेट्स मैनिफ़ेस्ट फ़ाइलों को प्रबंधित करें।
• हेल्म पैकेजों के रिलीज़ प्रबंधित करें।

Kompose

कॉम्पोज़ एक उपकरण है, जो डॉकर कंपोज़ उपयोगकर्ताओं को कुबेरनेट्स पर जाने में मदद करता है।

कॉम्पोज़ का उपयोग करें:

• डॉकर कंपोज़ फ़ाइल को कुबेरनेट्स ऑब्जेक्ट्स में अनुवाद करें।
• स्थानीय डॉकर डेवलपमेंट से कुबेरनेट्स एप्लीकेशनों को प्रबंधित करें।
• v1 या v2 डॉकर कंपोज़, yaml फ़ाइलों या डिस्ट्रीब्यूटेड एप्लिकेशनो के बंडलों के माध्यम से अपने एप्लिकेशन को प्रबंधित कऱे।

Kui

Kui एक GUI उपकरण है, जो आपके सामान्य kubectl कमांड लाइन अनुरोधों को लेकर ग्राफिक्स के साथ प्रतिक्रिया देता है।

Kui सामान्य kubectl कमांड लाइन अनुरोधों को लेकर ग्राफिक्स के साथ प्रतिक्रिया देता है। ASCII टेबल्स के बजाय, Kui उन टेबल्स के साथ एक GUI प्रदान करता है, जिन्हें आप सॉर्ट कर सकते हैं।

Kui आपको देता है:

• कॉपी और पेस्ट करने के बजाय सीधे लंबे स्वचालित रूप से जेनरेटेड किए गए संसाधनों के नामों पर क्लिक करें।
• Kubectl कमांड टाइप करें और उन्हें निष्पादन होते हुए देखें, यहां तक कि कभी-कभी Kubectl से भी तेज।
• एक जॉब क्वेरी करें और इसके निष्पादन को वॉटरफॉल के डायग्राम के रूप में देखें।
• एक टैब्ड UI का उपयोग करके अपने क्लस्टर में संसाधनों पर क्लिक करें।

Minikube

मिनीक्यूब एक उपकरण है, जो डेवलपमेंट और परीक्षण जैसे उद्देश्यों के लिए आपके वर्कस्टेशन पर स्थानीय रूप से एक-नोड वाले कुबेरनेट्स क्लस्टर को चलाता है।

7 - कुबेरनेटेस डॉक्स में योगदान दे

कुबेरनेटस सभी योगदानकर्ताओ से सुधार का स्वागत करता है चाहे वो नए हो या अनुभवी!

इस वेबसाइट की देख रेख कुबेरनेटस SIG Docs द्वारा की जाती है।

कुबेरनेटस प्रलेखन योगदानकर्ता :

• मौजूदा विषयों को सुधारते हैं
• नए विषय बनाते हैं
• प्रलेखन का अनुवाद करते हैं
• कुबेरनेटस रिलीज चक्र मे प्रलेखन की देख रेख और प्रकाशन करते हैं

शुरू करना

कोई भी प्रलेखन के बारे मे इशू खोल सकता है या कुबेरनेटस वेबसाइट kubernetes/website GitHub रिपॉजिटरी मे बदलाव पुल अनुरोध (PR) द्वारा कर सकता है। आपको Git और Github की जानकारी होनी चाहिए ताकि आप कुबेरनेटेस समुदाय मे प्रभावी रूप से काम कर सकें।

प्रलेखन मे सहयोग करने के लिए:

1. योगदानकर्ता समझौता लाइसेन्स पर हस्ताक्षर करें।
2. प्रलेखन रिपॉजिटरी और वेबसाइट की स्टैटिक साइट जनरेटर से खुद को परिचित करें।
3. सुनिश्चित करें की आपको पुल अनुरोध करना और बदलाओ की समीक्षा करना आता हो।

ऊपर दी गई आकृति नए योगदानकर्ता के लिए दिशानिर्देश हैं। Sign up या review के लिए आप इनमे से कुछ या सभी निर्देशों का पालन कर सकते हैं। अब आप PR ओपन करने के लिए तैयार हैं जो आपके योगदान के उद्देश को पूरा करे जो Open PR खंड मे सूचीबद्ध हैं। आपके सभी प्रश्नों का सदैव स्वागत है।

कुबेरनेटस समुदाय मे कुछ कार्यों के लिए अधिक विश्वास और अभिगम की आवश्यकता होती है। भूमिका और अनुमति के बारे मे ज्यादा जानकारी के लिए
SIG Docs मे भाग लेना को देखें।

आपका पहला योगदान

आप अपने पहले योगदान की तैयारी के लिए दिए गए दिशानिर्देश को देख सकते हैं। नीचे दिया हुआ चित्र दिशानिर्देश और उसकी विस्तार मे जानकारी देता है।

• योगदान करने के विभिन्न तरीकों को जानने के लिए योगदानकर्ता अवलोकन को पढ़ें।
• अच्छे प्रवेश बिन्दु के लिए kubernetes/website इशू सूची को जाचें।
• मौजूदा प्रलेखन पर Github का प्रयोग करते हुए पुल अनुरोध करॆ और इशू दाखिल करने के बारे मे अधिक जानें।
• भाषा और सटीकता के लिए अन्य कुबेरनेटस समुदाय के सदस्यों के पुल अनुरोध की समीक्षा करें।
• कुबेरनेटस प्रकरण और
  स्टाइल मार्गदर्शक को पढ़ें ताकि आप सूचित टिप्पणी दे सकें।
• पेज प्रलेखन टाइप और Hugo shortcodes के बारे मे जानें।

अगले कदम

• रिपॉजिटरी के लोकल क्लोन से काम करना सीखें।

• रिलीज़ में फीचर्स का आलेख करे।

• SIG Docs मे भाग लें और सदस्य या समीक्षक बनें।

• स्थानीयकरण शुरू करे या उसमे सहायता करें।

सिग डॉक्स मे शामिल हो

SIG Docs योगदानकर्ताओ का एक समूह है जो कुबेरनेटेस प्रलेखन और वेबसाईट की देख रेख और उसे प्रकाशित करता है। SIG Docs मे शामिल होना कुबेरनेटस योगदानकर्ताओ (फीचर विकास या उससे अन्यथा) के लिए कुबेरनेटस परियोजना पर प्रभाव डालने का बेहतरीन तरीका है।

SIG Docs भिन्न प्रकार से संवाद करते हैं:

• कुबेरनेटेस Slack चैनल मे #sig-docs से जुड़ें और खुद का परिचय दें!
• kubernetes-sig-docs मेलिंग लिस्ट मे शामिल हो, वहाँ व्यापक विचार-विमर्श होता है और आधिकारिक फैसले का अभिलेखन किया जाता है।
• SIG Docs विडिओ बैठक मे शामिल हो जो हर दो सप्ताह मे होती है। बैठक की घोषणा हमेशा #sig-docs पर की जाती है और कुबेरनेटेस समुदाय बैठक कैलंडर में जोड़ दिया जाता है। आपको Zoom client डाउनलोड करने की जरूरत पड़ेगी या फोन की मदद से भी डायल कर सकते हैं।
• जिन सप्ताह मे Zoom बैठक नहीं हुई हो तब SIG Docs अतुल्यकालिक बैठक को जॉइन करे जो Slack पर होती है। बैठक की घोषणा हमेशा #sig-docs पर होती है। बैठक की घोषणा के बाद आप किसी भी सूत्र मे 24 घंटे तक योगदान कर सकते है।

योगदान करने के अन्य तरीके

• कुबेरनेटस समुदाय साइट पर जाए। Twitter या Slack Overflow मैं भाग ले, कुबेरनेटस स्थानीय आयोजन और मिलन के बारे मे जाने ।
• कुबेरनेटस फीचर विकास में शामिल होने के लिए योगदानकर्ता चीटशीट पढ़ें।
• कुबेरनेटस योगदानकर्ता और अतिरिक्त योगदानकर्ता साधन के बारे मे अधिक जानकारी के लिए योगदानकर्ता साइट पर जाएं।
• ब्लॉग पोस्ट या केस अध्ययन प्रस्तुत करे।

7.1 - प्रलेखन शैली अवलोकन

इस खंड के विषय लेखन शैली, सामग्री स्वरूपण, और संगठन, और कुबेरनेट्स प्रलेखन के लिए विशिष्ट Hugo अनुकूलन का उपयोग करने पर मार्गदर्शन प्रदान करते हैं।

7.2 - साइट विश्लेषिकी देखना

इस पृष्ठ में Kubernetes.io विश्लेषिकी डैशबोर्ड के बारे में जानकारी है।

डैशबोर्ड देखें।

यह डैशबोर्ड Google Data Studio का उपयोग करके बनाया गया है और Google Analytics का उपयोग करके Kubernetes.io पर एकत्रित जानकारी दिखाता है।

डैशबोर्ड का उपयोग करना

डिफ़ॉल्ट रूप से, डैशबोर्ड पिछले 30 दिनों के सभी एकत्रित विश्लेषण दिखाता है। विभिन्न दिनांक सीमा मे आने वाला डेटा देखने के लिए date selector का उपयोग करें। अन्य फ़िल्टरिंग विकल्प आपको उपयोगकर्ता का स्थान, साइट तक पहुंचने के लिए उपयोग किए जाने वाले उपकरण, उपयोग किए गए दस्तावेज़ों के अनुवाद, और बहुत से चीज़ों का डेटा देखने की अनुमति देते हैं।

यदि आप इस डैशबोर्ड में कोई समस्या देखते हैं, या किसी सुधार का अनुरोध करना चाहते हैं, तो कृपया एक इशू बनाएं।

8 - डॉक्स स्मोक टेस्ट पेज

यह पृष्ठ दो उद्देश्यों की पूर्ति करता है:

• यह दिखाने के लिए कि Kubernetes प्रलेखन Markdown का उपयोग कैसे करता है
• एक "स्मोक टेस्ट" दस्तावेज़ प्रदान करना जिसे हम HTML, CSS और टेम्पलेट परिवर्तनों का परीक्षण करने के लिए उपयोग कर सकते हैं जो संपूर्ण प्रलेखन को प्रभावित करते हैं।

शीर्षक स्तर

ऊपर का शीर्षक H2 है। पृष्ठ शीर्षक H1 के रूप में प्रस्तुत होता है। निम्नलिखित अनुभाग H3 - H6 दिखाते हैं।

### H3

यह H3 अनुभाग में है।

#### H4

यह H4 अनुभाग में है।

##### H5

यह H5 अनुभाग में है।

###### H6

यह H6 अनुभाग में है।

परिणाम:

H3

यह H3 अनुभाग में है।

H4

यह H4 अनुभाग में है।

H5

यह H5 अनुभाग में है।

H6

यह H6 अनुभाग में है।

इनलाइन तत्व

इनलाइन तत्व पैराग्राफ, सूची आइटम, चेतावनी या अन्य ब्लॉक-स्तरीय तत्वों के भीतर टेक्स्ट में दिखते हैं।

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

इनलाइन टेक्स्ट शैली

Markdown में आप विभिन्न टेक्स्ट शैलियों का उपयोग कर सकते हैं:

- **बोल्ड**
- _इटालिक_
- ***बोल्ड इटालिक***
- ~~स्ट्राइकथ्रू~~
- <u>रेखांकित</u>
- _<u>रेखांकित इटालिक</u>_
- **<u>रेखांकित बोल्ड</u>**
- ***<u>रेखांकित बोल्ड इटालिक</u>***
- `मोनोस्पेस टेक्स्ट`
- **`मोनोस्पेस बोल्ड`**

परिणाम:

• बोल्ड
• इटालिक
• बोल्ड इटालिक
• स्ट्राइकथ्रू
• रेखांकित
• रेखांकित इटालिक
• रेखांकित बोल्ड
• रेखांकित बोल्ड इटालिक
• मोनोस्पेस टेक्स्ट
• मोनोस्पेस बोल्ड

सूचियाँ

Markdown सूचियों को संसाधित करने के लिए सख्त नियम नहीं रखता। जब हमने Jekyll से Hugo पर स्विच किया, तो कुछ सूचियाँ टूट गईं। उन्हें ठीक करने के लिए निम्न बातों का ध्यान रखें:

• उप-सूची आइटम को 2 स्थान से इंडेंट करें।
• एक सूची को समाप्त करने और दूसरी सूची शुरू करने के लिए, आपको सूचियों के बीच एक HTML टिप्पणी ब्लॉक डालना होगा जो बाएँ किनारे पर संरेखित हो।

बुलेट सूचियाँ

- यह एक सूची आइटम है।
* यह उसी सूची का एक अन्य आइटम है।
- आप `-` और `*` मिला सकते हैं।
  - उप-आइटम बनाने के लिए, दो स्थान इंडेंट करें।
    - यह एक उप-उप-आइटम है।
  - एक अन्य उप-आइटम।

परिणाम:

• यह एक सूची आइटम है।

• यह उसी सूची का एक अन्य आइटम है।

• आप - और * मिला सकते हैं।
  • उप-आइटम बनाने के लिए, दो स्थान इंडेंट करें।
    • यह एक उप-उप-आइटम है।
  • एक अन्य उप-आइटम।

• यह एक नई सूची है। Hugo में, दो लगातार सूचियों को अलग करने के लिए HTML टिप्पणी आवश्यक होती है।

  ls -l
  

  • और एक उप-सूची ब्लॉक स्तर की सामग्री के बाद।

• एक बुलेट सूची आइटम में क्रमांकित उप-सूची हो सकती है:

  1. क्रमांकित उप-सूची 1
  2. क्रमांकित उप-सूची 2

क्रमांकित सूचियाँ

1. यह एक सूची आइटम है।
2. यह एक अन्य सूची आइटम है।

1. यह एक नई सूची है।

2. सूची आइटम में अनुच्छेद और कोड ब्लॉक हो सकते हैं।

   ls -l
   

   • उप-सूची जो ब्लॉक स्तर की सामग्री के बाद आती है।

टैब सूचियाँ

• एक चुनें...
• टैब सूचियाँ स्वरूपित करना
• नेस्टेड शीर्षक

echo 'टैब सूचियों में कोड ब्लॉक हो सकते हैं!'

चेकलिस्ट

• यह एक चेकलिस्ट आइटम है
• यह एक चयनित चेकलिस्ट आइटम है

कोड ब्लॉक

आप कोड ब्लॉक दो तरीकों से बना सकते हैं, तीन बैकटिक के साथ। केवल कोड के लिए बैकटिक का प्रयोग करें।

यह एक कोड ब्लॉक है

ls -l

Hugo शॉर्टकोड के साथ कोड ब्लॉक

{{< alert color="warning" >}}यह एक चेतावनी है।{{< /alert >}}

लिंक

[कुबेरनेट्स पर लिंक](https://kubernetes.io/)

चित्र

![पेंसिल आइकन](/images/pencil.png)

[![पेंसिल आइकन](/images/pencil.png)](https://kubernetes.io)

तालिकाएँ

Mermaid विज़ुअलाइज़ेशन

{{< mermaid >}}
graph TD;
  A-->B;
  A-->C;
  B-->D;
  C-->D;
{{</ mermaid >}}

साइडबार और चेतावनियाँ

यह एक साइडबार है।

sudo dmesg

चेतावनियाँ

सम्मिलन

Katacoda लाइव एम्बेडेड वातावरण