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

90d निष्क्रियता के बाद मुद्दे पुराने हो जाते हैं।
/remove-lifecycle stale साथ समस्या को ताज़ा के रूप में चिह्नित करें।
अतिरिक्त 30d निष्क्रियता के बाद बासी मुद्दे सड़ जाते हैं और अंततः बंद हो जाते हैं।

अगर इस मुद्दे को अभी बंद करना सुरक्षित है तो कृपया इसे /close ।

सिग-टेस्टिंग, कुबेरनेट्स/टेस्ट-इंफ्रा और/या फेजटा को फीडबैक भेजें ।
/जीवनचक्र बासी

इसे फिर से लाना जैसा कि इसे https://github.com/kubernetes/charts/pull/5919 में उठाया गया था

मेरी हाल की टिप्पणी के कुछ हिस्सों की प्रतिलिपि बनाना:

हम विशेष रूप से अपने चार्ट के लघु संस्करण को लघु अनुप्रयोग संस्करण के साथ संरेखित रखना चुनते हैं (हालाँकि पैच संस्करण संख्याएँ अलग हो सकती हैं, और अलग हो सकती हैं)।

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

मुझे पता है कि चार्ट संस्करण के साथ ऐपवर्सन को आज़माने और संरेखित करने की अनुशंसा नहीं की जाती है, लेकिन इस तरह, एक उपयोगकर्ता जानता है कि वे किसी भी प्रमाणपत्र-प्रबंधक 0.3.x के साथ हेल्म चार्ट संस्करण 0.3.x और प्रमाण के साथ चार्ट संस्करण 0.4.x का उपयोग कर सकते हैं। -प्रबंधक 0.4.x। संगतता को मामूली संस्करण के भीतर परिभाषित किया गया है।

/निकालें-जीवनचक्र बासी

मैं इसे चर्चा के लिए वापस लाना चाहता हूं।

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

ऊपर संदर्भित मेरे मूल प्रस्ताव की प्रतिलिपि बनाना:

हेल्म चार्ट को परिनियोजित करने के लिए हमारे वर्तमान वर्कफ़्लो में ऐसे कार्य शामिल हैं जो हेल्म अपग्रेड सीएलआई कमांड को कॉल करते हैं और उसी चार्ट संस्करण के लिए रिलीज़ को संशोधित करते समय ऐपवर्सन सेट करने के लिए फ़्लैग पास करने में सक्षम होना अच्छा होगा।

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

अपने स्वयं के आंतरिक अनुप्रयोगों को विकसित करते समय ऐप स्वयं उस चार्ट की तुलना में बहुत अधिक बदलता है जो इसे तैनात करता है। आमतौर पर हमारा कंटीन्यूअस डिप्लॉयमेंट कमांड एक helm upgrade जिसमें --set imageTag=<new_version> से अधिक कुछ नहीं होता (जाहिर है, कंटेनर संस्करण को सेट करने के लिए चार्ट में कहीं और इस्तेमाल किया जाता है) यदि हम इसे --app-version से बदलते हैं तो यह देगा हमें helm ls में एक और दृश्य बिंदु यह देखने के लिए कि तैनात किए गए चार्ट के संस्करण के साथ कोड के कौन से संस्करण तैनात किए गए हैं।

इसे और अधिक दृश्यमान बनाने के लिए अन्यथा मैंने imageTag मेटाडेटा टैग को सेट करने पर मानकीकृत किया है जो इंस्टॉल/अपग्रेड पर पास किए गए इमेजटैग पर सेट हो जाता है। यह मुझे K8s डैशबोर्ड का उपयोग करने या इमेजटैग के साथ आसानी से ग्राफाना डैशबोर्ड बनाने की अनुमति देता है, लेकिन मुझे कमांड लाइन छोड़ने और माउस क्लिक करने की आवश्यकता होती है।

इसके बारे में कोई ख़बर?

धन्यवाद

इस पर किसी भी अद्यतन। ऐसा लगता है कि @Eraac का PR helm upgrade --set imageTag=<imagetag> भी चलाते हैं, हालांकि यह helm ls आउटपुट में सूचीबद्ध एपीपी संस्करण को अपडेट नहीं करता है। --set app-version या --set version सक्षम होने के कारण हमें helm upgrade चलाने की अनुमति मिलेगी जैसे कि helm ls तैनात किए गए संस्करण को सही ढंग से दिखाता है।

कोई सुधार?

आने वाला समय जल्द ही प्यारा होगा!

यह बहुत उपयोगी होगा

हम इंस्टॉल समय पर ऐप संस्करण सेट करने की क्षमता भी पसंद करेंगे क्योंकि हम एप्लिकेशन को परिनियोजित करने के लिए सामान्य चार्ट का उपयोग करते हैं

+1

+1

यह बहुत मददगार होगा

एक ही अनुरोध

कृपया +1 के साथ स्पैम बंद करें। पहले से ही एक पीआर (https://github.com/helm/helm/pull/4961) है और लोग प्रस्ताव पर चर्चा कर रहे हैं। आखिरी जवाब 2 दिन पहले भी था।

नमस्ते @ filipre

पहले से ही एक पीआर (#4961) है और लोग प्रस्ताव पर चर्चा कर रहे हैं।

उस पीआर के अनुसार, इसे यहां स्थानांतरित किया गया था:
https://github.com/helm/helm/pull/5492
यह #4961 का नवीनतम पीआर है और ऐसा लगता है कि हम किसी समीक्षा के विलय की प्रतीक्षा कर रहे हैं ...

@filipre क्या आप कृपया कह सकते हैं: पीआर के साथ क्या होता है? ऐसा लगता है कि आधे महीने में पीआर की कोई चाल नहीं चल रही है

यह बहुत उपयोगी होगा। मैं कुछ ऐसी चीज में भाग गया जहां मुझे ऐप के संस्करण 0.6.0 पर पिन करने की आवश्यकता है, और चार्ट संस्करण का ऐप संस्करण से कोई संबंध नहीं है।

मैं सहमत हूं, मुझे भी लगता है कि यह बहुत उपयोगी होगा। कोई सुधार?

देखें https://github.com/helm/helm/pull/5492#issuecomment -509662190।

बस इस मुद्दे को अभी मारा जब मुझे एहसास हुआ कि यह एक हेल्म चार्ट लिखते समय एक मुद्दा होगा जिसे हम कई अनुप्रयोगों के लिए पुन: उपयोग करने की योजना बना रहे हैं। इस समस्या को सरल तरीके से हल करने में प्रगति की कमी को देखते हुए (यानी इंस्टॉल पर ऐप संस्करण सेट करने के लिए ध्वज के साथ), मैं एक विकल्प लेकर आया हूं जो अभी काम करना चाहिए। यह वास्तव में बहुत आसान है - केवल helm fetch पहले untar विकल्प के साथ करें, और फिर helm package --app-version ध्वज के साथ जो वहां मौजूद है, फिर उस स्थानीय चार्ट को स्थापित करने के लिए आगे बढ़ें।

यह आदर्श नहीं है, लेकिन helm list में अंतिम परिणाम सही है, और सीआई सर्वर पर ऐसा करना बहुत आसान है। हालांकि --app-version को helm install और helm upgrade पर उपलब्ध होना पसंद करेंगे।

#5492 में चर्चा का सारांश यह था कि एक आदेश जो helm package और helm install के तर्क को लपेटता है, मूल रूप से इस मुद्दे में वर्णित उपयोग के मामले को हल करेगा।

दूसरे शब्दों में, आप निम्न को चलाकर इसे हल कर सकते हैं:

$ helm package myapp --app-version 1.0.0
$ helm install myapp-1.0.0.tgz

(हाल ही में बंद हुए पीआर से यहां ले जा रहा है - इसलिए यह निर्वाण में समाप्त नहीं होता है)

यहाँ इस पर मेरे 2 सेंट हैं:
मान लें कि हमारे पास chart version X साथ एक सेवा तैनात करने वाला एक शीर्ष appVersion Y ।

पतवार चार्ट पर Kubernetes के बुनियादी ढांचे के अंदर का वर्णन किया जाता है chart version X जिनमें से एक सेवा की मेजबानी के लिए प्रयोग किया जाता है appVersion Y ।

प्रारंभिक विकास के दौरान X और Y नियमित रूप से बदलेंगे। हालांकि, किसी बिंदु पर X कमोबेश स्थिर रहेगा और Y बदलना जारी रहेगा (जब तक कि Y में बुनियादी ढांचे के लिए कुछ नई आवश्यकताएं न हों, जो कि बहुत कम बार होता है। Y के विकास चक्र में)।

इस टिकट में प्रस्तावित दृष्टिकोण के साथ एक ऐप वर्जन Y , Y+1 , Y+N , आदि को तैनात करने के लिए संस्करण X पर एक स्थिर हेल्म चार्ट पैकेज ले सकता है।

हालांकि, इस ध्वज को हेलम इंस्टॉल या अपग्रेड के दौरान ओवरराइड करने की इजाजत नहीं दी जा रही है और इसके बजाय केवल उदाहरण के लिए पैकेज प्रभावी रूप से X और Y दोनों को एक साथ जोड़ देगा और मुझे हमेशा एक नया X+1 बनाने के लिए मजबूर करेगा। Y+1 । यह मेरे लिए अनावश्यक लगता है और इसके परिणामस्वरूप एक टन हेलम पैकेज होंगे जो प्रभावी रूप से इसके अलावा नहीं बदले हैं कि वे एक नए appVersion को संदर्भित कर रहे हैं। मेरे दृष्टिकोण से, किसी एप्लिकेशन का एक संस्करण और उस एप्लिकेशन की मेजबानी करने वाले बुनियादी ढांचे के एक संस्करण का संबंध है, लेकिन फिर भी स्वतंत्र रूप से संस्करण होना चाहिए या हो सकता है। यह कैसे किया जा रहा है, इसे संबंधित विकास टीमों पर छोड़ दिया जाना चाहिए।

सारांश:

यह दृष्टिकोण निश्चित रूप से काम करता है, लेकिन इसके परिणामस्वरूप बहुत सारे अनावश्यक हेल्म पैकेज भी मिलते हैं जहां केवल AppVersion बदल गया है:
$ helm package myapp --app-version 1.0.0 $ helm install myapp-1.0.0.tgz

हाँ, लेकिन मुझे लगता है कि यदि आप ऊपर बताए गए दृष्टिकोण को अपनाते हैं तो यह कोई समस्या नहीं है। अपने चार्ट को बिना ऐप वर्जन सेट (या 0.0.0 या कुछ) के चार्ट रेपो पर पुश करें, फिर जब आप इसका उपयोग करना चाहते हैं, तो helm fetch , फिर इसे सही ऐप संस्करण के साथ पैकेज करें, फिर स्थानीय का उपयोग करें .tgz फ़ाइल और उस चार्ट को धक्का न दें। इस तरह आपका चार्ट रेपो साफ रहता है और आपके पास केवल वास्तविक चार्ट परिवर्तन होते हैं।

हाँ, यह काम करेगा। इस मामले में कोई भी सीधे परिनियोजन आर्टिफैक्ट का उपभोग नहीं कर सकता है (उदाहरण के लिए सीधे हेल्म रिपोजिटरी से इंस्टॉल करके), लेकिन इसे हमेशा एक अतिरिक्त चरण के माध्यम से भेजना पड़ता है जो आर्टिफैक्ट को बदलता है।

जहां यह तर्क दिया गया था कि Charts.yaml अपरिवर्तनीय होना चाहिए, मेरा तर्क है कि परिनियोजन विरूपण साक्ष्य होना चाहिए।

_मेरे विचारों को https://github.com/helm/helm/pull/5492#issuecomment -520029902_ से सारांशित करना

समुदाय पैकेज, चार्ट और संस्करणों की व्याख्या कैसे करता है, इसमें एक समस्या है। @BenjaminSchiborr , मुझे आशा है कि यह आपको समझ में आएगा।

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

ऐसा कोई तरीका नहीं है जिससे आप चार्ट से बाहर रिलीज़ कर सकें । यह सिर्फ इस तरह से काम नहीं करता है!

मंच पर अपने ऐप को परिनियोजित करने से पहले, आपके पास एक चार्ट होना चाहिए। फिर, आपको helm package का उपयोग करके, दोनों संस्करणों को ठीक करते हुए, अपने ऐप को चार्ट के साथ पैकेज करना होगा। इसका परिणाम एक पैकेज में होगा, जिसे किसी भी स्तर पर परिनियोजित किया जा सकता है। फिर, आप इस पैकेज को helm install का उपयोग करके, उदाहरण के लिए, क्यूए चरण पर, इसे यूए पर प्रचारित करते हुए और फिर उत्पादन पर स्थापित करते हैं।

यह किसी भी पैकेज-उन्मुख सॉफ़्टवेयर के काम करने का तरीका है।

दुविधा

helm install को एक स्रोत की आवश्यकता है, जिसे स्थापित किया जाना चाहिए। स्रोत हो सकता है:

1. पैकेज का नाम, रजिस्ट्री से उपलब्ध है
2. पैकेज फ़ाइल पथ, यदि पैकेज पहले ही डाउनलोड या बनाया जा चुका है
3. पैकेज URL, यदि यह HTTP का उपयोग करके उपलब्ध है
4. चार्ट निर्देशिका पथ

चौथा दृष्टिकोण यहाँ एक काली भेड़ की तरह लगता है, क्या आपको नहीं लगता? यही कारण है कि पीपीएल पैकेज और चार्ट को भ्रमित करता है। और यही समस्याओं की जड़ है।

विचार

जंगली में दो प्रकार के ऐप्स हैं:

बड़ा/मध्यम - यह वह जगह है जहां हमारे पास बेहतर आत्मनिरीक्षण और गुणवत्ता की गारंटी के लिए विस्तृत, बारीक प्रवाह स्थापित करने के लिए समय, पैसा और संसाधन हैं।
छोटा - एक माइक्रोसर्विस, पालतू परियोजना, PoC, कम लागत वाली परियोजनाएं, DevOps ज्ञान या यहां तक ​​कि विकास प्रक्रिया परीक्षण के लिए परियोजनाएं।

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

यही कारण है कि helm install ऐसे उपयोग की अनुमति देता है, जैसे helm package & helm install । लेकिन यह पूर्ण helm package क्षमताएं प्रदान नहीं करता है, जैसे कि --app-version ।

helm install helm package & helm install , लेकिन यह helm install एक गड़बड़ बना देगा, समर्थन, परीक्षण और अच्छे अभ्यास करने के लिए एक नरक।

प्रस्ताव 1

helm install सरल बनाएं। इसे helm समझ को सरल बनाने के लिए, कोडबेस को सरल बनाने, परीक्षण करने और इसे राय देने के लिए केवल पैकेज प्रदान करने की अनुमति देनी चाहिए।

प्रस्ताव 2 - helm run

नया आदेश पेश करें: helm run । एक आदेश, जो बस काम करना चाहिए। छोटे ऐप्स के लिए आदर्श। या शायद मध्यम और बड़ा भी।

इसे helm package और helm install को संयोजित करना चाहिए, दोनों कमांड से क्षमताओं को प्रदान करना, उन लोगों को छोड़कर जो इस तरह के उपयोगकेस में कोई मतलब नहीं रखते हैं।

helm package एक बिल्ड बनाता है, जैसा कि go build करता है। go run निर्माण प्रक्रिया के बिना ऐप शुरू करने की अनुमति देता है, इसलिए helm run यहां एक ठोस नाम की तरह दिखता है।

विचार करने के लिए अतिरिक्त बातें:

• क्या इसे इसके बजाय upgrade --install उपयोग करना चाहिए?
• क्या इसमें डिफ़ॉल्ट रूप से --atomic सक्षम होना चाहिए?

@iorlas ,
आपकी टिप्पणियाँ समझ में आती हैं। हालांकि, आप मान रहे हैं कि केवल एक अंतिम पैकेज हो सकता है जो विरासत में बुनियादी ढांचे के संस्करण और सॉफ्टवेयर संस्करण दोनों को एक साथ जोड़ता है, जबकि मैं मान रहा हूं कि मेरे पास मेरे सॉफ़्टवेयर संस्करण के लिए एक पैकेज है और मेरे बुनियादी ढांचे के लिए एक पैकेज है और मैं उन्हें बांधना चाहता हूं एक रिलीज में (उदाहरण के लिए एक वांछित राज्य विन्यास के माध्यम से जो सॉफ्टवेयर संस्करण और बुनियादी ढांचे के संस्करण को संदर्भित करता है)।

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

मैं ठीक हूं अगर इससे कुछ दीर्घकालिक लाभ होता है। मैं बस इसे नहीं देखता।

@BenjaminSchiborr ठीक है, मैं इसे थोड़ा सा तोड़ दूं।

आपके पास अपना चार्ट (== बुनियादी ढांचा) हो सकता है, जिसका संस्करण X ।
आपके पास अपना आवेदन, संस्करण Y ।

helm अभी कैसे काम करता है, यह helm package चरण पर बुनियादी ढांचे और एप्लिकेशन संस्करणों को एक साथ जोड़ता है। फिर, आपको रिलीज का उत्पादन करते हुए इसे k8s नेमस्पेस से जोड़ना होगा।

तो सूत्र है: package(infra + app) + k8s = Release

आप वास्तव में क्या चाहते हैं, इस मध्य-चरण को छोड़ना और सभी 3 घटकों को एक चरण पर एक साथ बांधना है - रिलीज। इस तरह: infra + app + k8s = Release । क्या मैं सही हूँ?

सतह पर helm run करेगा। हुड के तहत, यह वही होगा।

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

आइए मैं यह वर्णन करने का प्रयास करता हूं कि इसका उपयोग कैसे किया जाना चाहिए और इसे अपने दृष्टिकोण से देखना बहुत अच्छा होगा।

हेल्म स्वयं k8s टेम्प्लेटिंग और परिनियोजन को दूर करने के लिए बनाया गया है, इसकी निर्भरता के साथ एप्लिकेशन और इन्फ्रास्ट्रक्चर को एक साथ जोड़ते हैं: मैन्युअल रूप से टेम्प्लेट को फिर से लिखने के बजाय, इसे K8s पर लागू करना और फिर नया इमेज टैग प्रदान करना, आपको केवल एक कमांड की आवश्यकता है - helm upgrade । एमएसआई या डिबेट पैकेज की तरह।

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

तो आपकी रजिस्ट्री में कई पैकेज होना सही बात है, क्योंकि पैकेज बुनियादी ढांचा नहीं है, पैकेज ऐप है, क्योंकि ऐप का मतलब K8s w/o इंफ्रास्ट्रक्चर में नहीं है।

यदि आपकी समस्या यह है कि आपके पास रेपो में बहुत अधिक पैकेज हैं, तो मैं रिपोजिटरी के बजाय कलाकृतियों का उपयोग करने का सुझाव दूंगा। मैं इसे सीआई में करता हूं: ऐप बनाएं, डॉकर रजिस्ट्री को भेजें, पैकेज बनाएं, इसे रिलीज के लिए आर्टिफैक्ट के रूप में सहेजें। सर्किलसीआई, ट्रैविस, एज़्योर पाइपलाइन कलाकृतियों के रूप में निर्माण के लिए संलग्न फाइलों को बनाने का समर्थन करते हैं। क्या आप ऐसा ही कर सकते हैं?

शायद मुझे हेल्म की बात याद आ रही है। हो सकता है कि हेल्म यहां एक बिंदु चूक गया हो। मुझे लगता है कि यह टिकट उसी का मूल्यांकन करने के बारे में है। और व्यक्तिगत रूप से - मेरे क्षितिज के विस्तार के बारे में भी :)

लेकिन हाँ, संक्षेप में आप जो कह रहे हैं वह सही है। मैं नहीं चाहता कि सॉफ़्टवेयर संस्करण हेलम पैकेज/रिलीज़ से जुड़ा हो, इसलिए अनिवार्य रूप से यह infra + app + k8s = Release । उसी तरह जैसे मैं अपने सॉफ़्टवेयर संस्करण के गुणों को अपने हेलम पैकेज/रिलीज़ से बंधा हुआ नहीं चाहता (शायद समझदार डिफ़ॉल्ट के अलावा जिसे मैं ओवरराइड कर सकता हूं)।

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

क्या आप विस्तार से बता सकते हैं?

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

मैं जिस बात का जिक्र कर रहा था वह बहुत सारे पैक किए गए हेल्म चार्ट थे (जिसमें पहले से ही ऐपवर्सन शामिल है)। इसे एक हेल्म चार्ट संस्करण के रूप में सोचें जो स्थिर है और एक ऐप संस्करण है जो दिन में सैकड़ों बार बदलता है। इसलिए प्रतिदिन एक रिपॉजिटरी में प्रति सेवा कुछ सौ पैकेज्ड हेल्म चार्ट जो बाद में एक ऑटोमेशन द्वारा खपत किए जाते हैं।

(मेरी पाइपलाइनें आम तौर पर आपके जैसी ही दिखती हैं: ऐप बनाएं -> डॉकर छवि (ऐपवर्सन में परिणाम) -> पैकेज चार्ट (अपडेट किए गए ऐपवर्सन के साथ) -> रिपोजिटरी को धक्का देता है?

मुझे लगता है कि यह टिकट उसी का मूल्यांकन करने के बारे में है।

पक्का! मेरी राय में, हमारे पास पहले से ही अमूर्तता के बहुत सारे स्तर हैं, इसलिए यहाँ एक पतवार होना थोड़ा भारी है 😄इसके अलावा, यहाँ k8s ऑपरेटर हैं, जो हेल्म द्वारा हल की जाने वाली समस्याओं में से कुछ (शायद सबसे?) के लिए बनाए गए हैं। लेकिन यह एक और समय के लिए एक विषय है, हे।

इसे एक हेल्म चार्ट संस्करण के रूप में सोचें जो स्थिर है और एक ऐप संस्करण है जो दिन में सैकड़ों बार बदलता है। इसलिए प्रतिदिन एक रिपॉजिटरी में प्रति सेवा कुछ सौ पैकेज्ड हेल्म चार्ट जो बाद में एक ऑटोमेशन द्वारा खपत किए जाते हैं।

हाँ, यह निश्चित रूप से बहुत ज्यादा लगता है, लेकिन यह इरादा है। जैसे, आपके पास बिल्ड रन है, इसे कुछ कलाकृतियों का उत्पादन करना चाहिए, फिर इसे मंच पर तैनात करने के लिए उपयोग करने के लिए सहेजना चाहिए। जैसे... हम एक बिल्ड रन कैसे बना सकते हैं जिसका बिल्ड परिणाम नहीं है? जब हम तैनाती करते हैं तो क्या हमें निर्माण उत्पन्न करना चाहिए? यह वाकई गलत होगा। हालाँकि कुछ CI पाइपलाइन JS बिल्ड के लिए ऐसा करती हैं।

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

बेशक हम रजिस्ट्री पर जगह बचाने के लिए docker save कर सकते हैं और बाद में बिल्ड एरिफैक्ट्स रिटेंशन पॉलिसी में स्वीप कर सकते हैं। लेकिन इसलिए हम इसे helm package कर सकते हैं और एक फाइल के रूप में रख सकते हैं।

लेकिन मैं निश्चित रूप से आपकी बात देखता हूं, हमारे पास एक "इंस्टॉलर" हो सकता है, जो एक ऐप संस्करण को स्वीकार कर सकता है। चूंकि इस तरह के इंस्टॉलर में बुनियादी ढांचा है, आप इसे वही रख सकते हैं, बस ऐप संस्करण बदल सकते हैं। साफ और सरल दिखता है, लेकिन एक समस्या है।

ऐप स्वयं k8s पर्यावरण w/o आधारभूत संरचना में समझ में नहीं आता है ।

क्या होगा यदि आपका ऐप कुछ बुनियादी ढांचे पर निर्भर करता है? मूल उदाहरण - configmap.

क्या होगा अगर आपको ऐप को रोलबैक करने की आवश्यकता होगी?
आपको ऐप को डाउनग्रेड करना होगा, लेकिन फिर आपको इंफ्रास्ट्रक्चर को भी डाउनग्रेड करना होगा।

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

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

हमारे पास पहले से ही अमूर्तता के बहुत सारे स्तर हैं
सभी अच्छे और सरल विंक

मुझे लगता है कि आपका अंतिम बिंदु बहुत आश्वस्त करने वाला है:

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

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

लेकिन अकेले पतवार, हाँ, 100% समस्या । मुझे लगता है कि यही कारण है कि विचार स्पष्ट रूप से ऐपवर्सन को ओवरराइड करने की अनुमति देना था और डिफ़ॉल्ट रूप से, इसे अनुमति नहीं देना था।

चार्ट संस्करण और एप्लिकेशन संस्करण को एक साथ जोड़ने के बारे में मुझे एक बात पसंद है कि यह स्पष्ट हो जाता है कि कौन सा एप्लिकेशन संस्करण किस चार्ट से संबंधित है। यदि आपको एक विशिष्ट संस्करण को फिर से तैनात करने की आवश्यकता है, तो आपको यह याद रखने की आवश्यकता नहीं है कि कौन सा एप्लिकेशन संस्करण किस चार्ट संस्करण के साथ संगत था। क्योंकि वे एक साथ जुड़े हुए हैं, आप बस सही चार्ट संस्करण देखें और आप सुनिश्चित होंगे कि एप्लिकेशन और चार्ट मेल खाते हैं। मुझे लगता है कि यह मूल रूप से @iorlas ने वर्णित किया है, है ना?

अंत में, चार्ट संस्करण "सुपर" -वर्जन के रूप में कार्य करेगा:

• कोई भी परिवर्तन (चाहे उसने एप्लिकेशन या बुनियादी ढांचे, यानी चार्ट को बदल दिया हो) के परिणामस्वरूप एक नया चार्ट संस्करण होगा, अर्थात नए एप्लिकेशन संस्करण का अर्थ होगा कि चार्ट संस्करण भी बदल गया है
• एक नया चार्ट संस्करण यह नहीं दर्शाता है कि एप्लिकेशन संस्करण बदल गया है

दस्तावेज़ीकरण उद्देश्यों (और शायद अन्य फैंसी विचारों) के लिए आप स्वयं एक और "केवल-चार्ट" संस्करण पेश कर सकते हैं जो केवल चार्ट परिभाषा को ही संदर्भित करेगा।

@ फिलीप्रे
हां हां! वर्तमान वास्तुकला डिजाइन निर्णयों के आधार पर हेल्म को इस तरह काम करना चाहिए था। जैसा की मैं देख पा रहा हूँ।

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

@बेंजामिनशिबोर

हालांकि, कई लोगों के लिए शायद ऐसा नहीं है

पक्का! यहां तक ​​कि संपूर्ण k8s, कंटेनरीकरण बहुत अधिक हो सकता है।

मुझे इसे थोड़ा अन्य दृष्टिकोण से तोड़ने की कोशिश करने दें, समस्या को खोजने की कोशिश कर रहा है जिसके लिए पतवार बनाई गई है:

• इंफ्रास्ट्रक्चर इंस्टेंस है कि पूरा उत्पाद कैसे काम करता है: सास इंस्टेंस, वीएम पूल, के 8 एस सेटअप, ऐप वर्जन (डेटाबेस, ऑब्जर्वेबिलिटी टूल्स, राउटर, साइडकार और प्रोडक्ट एप्स इंस्टेंस सहित)
• इंफ्रास्ट्रक्चर इंस्टेंस को सच्चाई के एक स्रोत की जरूरत है। अब हमारे पास टेराफॉर्म जैसी सुविधाएं हैं।
• एक फोल्डर में बहुत सी चीजें = कठिन। हमें इसे विघटित करने की आवश्यकता है। हैलो टेराफॉर्म मॉड्यूल।
• एक फोल्डर में प्लेटफॉर्म और एप्लिकेशन दोनों = हार्ड। हमें विघटित होने की जरूरत है। हैलो प्लेटफॉर्म और कंटेनर। K8s में कदम।
  
  
  
  1. तो, टेराफॉर्म मॉड्यूल प्लेटफॉर्म का प्रबंधन कर सकते हैं, जिसमें खाली, उपयोग में आसान कंटेनर परत का निर्माण शामिल है
  
  
  2. K8s कंटेनरों का प्रबंधन करता है,
  
  
• कई K8s ऐप्स (डेटाबेस और सामान सहित) के लिए कई YAML फाइलें = हार्ड। इसे प्रति ऐप फ़ोल्डर में विभाजित करें।
  
  
  
  1. तो वहाँ हमारे पास PostgreSQL, Redis, MyPetShop जैसे कुछ फ़ोल्डर हैं। जिनमें से प्रत्येक के पास हमारे पास मौजूद संसाधनों के लिए YAML फाइलें हैं। और इसे K8s में लागू करने के लिए इसके ऐप संस्करणों को सेट करने की आवश्यकता है।
  
  
• हैलो हेल्म - उपकरण, जो इन फ़ोल्डरों (चार्ट्स कहा जाता है) को सेट करने की अनुमति देता है, लेकिन अधिक: इसे एक साथ लागू करें, रोलबैक।
• चार्ट ठोस दिखता है। आइए चरों का समर्थन करके इसका पुन: उपयोग करें। अब चार्ट एक इन्फ्रास्ट्रक्चर नहीं है, बल्कि इन्फ्रास्ट्रक्चर टेम्प्लेट है।
• चार्ट शानदार लग रहा है। आइए इसे दोस्तों के साथ साझा करें। हर बार जब हम चार्ट को अपडेट करते हैं, तो हमें इसे index.

तो, यह बहुत अच्छा लगता है और सभी, w/o पैकेज बिल्कुल। तो, आपको इस चार्ट को लागू करने की आवश्यकता है, फिर आवेदन संस्करण प्रदान करें। और यह होना चाहिए।

लेकिन समस्या उत्पन्न होती है: कोई भी यह याद नहीं रखना चाहता कि किस ऐप संस्करण के लिए कौन सा चार्ट आवश्यक है। किस ऐप संस्करण के लिए नया कॉन्फ़िगरेशन मान प्रदान करने के लिए कौन सा चार्ट अपडेट किया गया है।

दिन के अंत में, हम चाहते हैं कि "myApp संस्करण 1.4.2 को K8s ऐप के रूप में सेटअप करें" , जो सभी जोखिमों, निर्भरताओं, परिवर्तनों को एक आर्टिफैक्ट - एप्लिकेशन इंस्टॉलर में बदल देता है, जो कि apps versions + hooks + setup logic + infrastructure to connect it all । यही कारण है कि हमारे पास एमएसआई, देब, आरपीएम, यहां तक ​​कि एनपीएम, गो मोड, पिप, जेम जैसी चीजें हैं।

यह वह जगह है जहाँ पैकेज दृश्य पर आता है। और पैकेज, परिभाषा के अनुसार, सीआई/सीडी प्रवाह के भीतर इंस्टाल करने योग्य रिलीज के रूप में बनाया जाना चाहिए। तो हम इसे हमारे सिस्टम (k8s क्लस्टर) पर रजिस्ट्री और/या सेटअप में भेज सकते हैं।

और कोई अन्य परियोजना अलग नहीं है। जब हम helm install सीधे चार्ट करते हैं, w/o पैकेज, हम वही काम करते हैं। लेकिन पैकेज बनाने के बजाय, हम इसे अलग-अलग चरणों में बनाते हैं। इसे ऐप बिल्डिंग प्रोसेस पर बनाने के बजाय, हम इसे रिलीज़ स्टेप पर बनाते हैं। हम अभी भी बुनियादी ढांचे और ऐप संस्करणों को एक साथ जोड़ते हैं । परोक्ष रूप से ।

मजेदार बात है:

• निर्भरता अद्यतन = इंफ्रास्ट्रक्चर टेम्पलेट (चार्ट) संस्करण अपडेट करें
• ऐप अपडेट किया गया = एक कांटा उत्पन्न करें, इंफ्रास्ट्रक्चर टेम्पलेट (चार्ट) का सबसेट - पैकेज, इसके अपने संस्करण के साथ

फिर भी, k8s ऑपरेटरों को वर्तमान समस्याओं पर प्रक्षेपित किया जाना है, इसलिए केवल एक उपकरण होना चाहिए, जो ऑपरेटरों की तरह काम करे, लेकिन आसान रिलीज प्रक्रिया प्रदान करे, जैसा कि पतवार करता है।

कोई विचार? हम यहां कुछ नया बना रहे होंगे, लेकिन बेहतर

आप जो वर्णन कर रहे हैं वह उन अनुप्रयोगों के लिए बहुत मायने रखता है जो अन्य लोगों द्वारा इंफ्रा पर उपयोग किए जाने के लिए हैं जिन पर आपका नियंत्रण नहीं है। हालांकि, एंटरप्राइज़ परिदृश्यों में पैकेज बनाना व्यस्त हो जाता है: हमारे पास दर्जनों कुकी-कटर माइक्रोसर्विसेज हो सकते हैं, जो साझा या कुकी-कटर वातावरण में तैनात होते हैं, और सीआई/सीडी पाइपलाइन परिभाषा के आधार पर जो रेपो में ही रहता है (सोचें) azure-pipelines.yaml), "पैकेज संस्करण" केवल मास्टर शाखा के एक विशेष संस्करण से निर्मित एक निर्माण है। मतलब, मुझे वास्तव में कहीं भी "पैकेज" को स्टोर करने की आवश्यकता नहीं है - मेरा बिल्ड एक ही पैकेज का उत्पादन करेगा, उसी बिट्स और कॉन्फिगमैप्स में उपयोग किए जाने वाले समान वैरिएबल आदि। इस तरह के परिदृश्यों में, मैं केवल हेल्म चार्ट को प्रकट करूंगा जब सर्विस इन्फ्रा में बदलाव होता है, जो बहुत कम होता है। हेल्म इस तस्वीर में है क्योंकि 1) मुझे पहले से ही इन्फ्रा के कुछ टुकड़ों को तैनात करने के लिए इसका इस्तेमाल करना होगा (उदाहरण के लिए, nginx), 2) मुझे k8s yaml को टेम्प्लेट करने के साथ पहिया को फिर से स्थापित करने की आवश्यकता नहीं है।

@वास्कर

आइए इसे प्रोजेक्ट करें, उदाहरण के लिए, docker. डॉकर इमेज भी एक पैकेज है। यह ओएस इमेज = इंफ्रास्ट्रक्चर के साथ बायनेरिज़ को एक साथ जोड़ता है। मेरा मानना ​​​​है कि हर बार जब हम एक बिल्ड बनाते हैं तो डॉक इमेज बनाने का कारण हेल्म पैकेज बनाने के समान होता है।

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

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

वैसे भी, मुझे लगता है, हम गलत रास्ते पर चले गए। क्या कोई हेलम का उपयोग करता है और फिर छवि को मैन्युअल रूप से अपडेट करता है? मेरा मानना ​​​​है कि हमारे पास 3 सामान्य उपयोग-मामले हैं:

1. helm package chart -> helm install package
2. helm install chart
3. helm install -> kubectl set image

@wasker आपका कौन सा है? मुझे विश्वास है, तीसरा नहीं। यहां तक ​​कि यह इंफ्रास्ट्रक्चर कॉन्फ़िगरेशन और एप्लिकेशन वर्जनिंग का वास्तविक अलगाव है, इसके साथ काम करना बुरा होगा। चूंकि, इसका मतलब होगा, जब आपको बुनियादी ढांचे को अद्यतन करने की आवश्यकता होगी, तो आप सभी संस्करणों को खो देंगे। आपको इसे चार्ट में, मैन्युअल रूप से, या प्रत्येक परिनियोजन के लिए kubectl set image में अपडेट करना होगा।

तो, हम दूसरे के बारे में बात कर रहे हैं, helm install chart , "w/o the पैकेजिंग"। तो, पतवार हमेशा तस्वीर में होता है । समस्या यह है कि पैकेज बनाया गया है, लेकिन रनटाइम में - जब हम अपना ऐप तैनात करते हैं। तो सीआई बिल्ड पैकेज निर्माण के प्रभारी हैं, परोक्ष रूप से, जब हमें इसे तैनात करने की आवश्यकता होती है।

और अगर इसे गोलांग पर प्रोजेक्ट करते हैं, तो ऐसा अभ्यास स्रोत कोड भेजने और इसे बनाने और बाइनरी का उपयोग करने के बजाय इसे डॉकटर में go run रूप में चलाने जैसा दिखता है।

तो, पैकेजिंग कदम को छोड़ने सरल बनाना है । है ना ?

यहीं से हम बात करना शुरू कर सकते हैं। यहाँ https://github.com/helm/helm/issues/3555#issuecomment -529022699 मेरा प्रस्ताव है। helm run और इसे go run रूप में मॉडल करें।

अगर हमें वास्तव में बुनियादी ढांचे और ऐप संस्करण को विभाजित करने की आवश्यकता है , तो इसका मतलब है कि केवल बुनियादी ढांचे को अद्यतन/बीज करने के लिए पतवार का उपयोग करना होगा। यहां तक ​​​​कि मैं ऐसा करने का एक तरीका देखना चाहता हूं, मैं वह देख सकता हूं, जो अपडेट पर सिरदर्द नहीं जोड़ेगा। हम मौजूदा परिनियोजन संस्करणों और सामानों को अनदेखा कर सकते हैं... लेकिन मुझे लगता है कि यह बहुत गलत है, इसे बनाने में समय की बर्बादी होगी।

आइए इसे प्रोजेक्ट करें, उदाहरण के लिए, docker. डॉकर इमेज भी एक पैकेज है। यह ओएस इमेज = इंफ्रास्ट्रक्चर के साथ बायनेरिज़ को एक साथ जोड़ता है। मेरा मानना ​​​​है कि हर बार जब हम एक बिल्ड बनाते हैं तो डॉक इमेज बनाने का कारण हेल्म पैकेज बनाने के समान होता है।

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

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

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

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

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

मेरा प्रश्न है - _दोनों दृष्टिकोणों का समर्थन क्यों नहीं करते?_ प्रत्येक दृष्टिकोण के पक्ष और विपक्ष हैं। मूल रूप से, इसका समर्थन न करना केवल कुछ पूर्णतः मान्य कार्यप्रवाहों को और अधिक कठिन बना रहा है। उदाहरण के लिए, फ्लक्स सीडी और उसके हेल्म ऑपरेटर का उपयोग करना। यदि आपके पास एक साझा हेल्म चार्ट है (यानी क्योंकि आपके पास एक निश्चित प्रकार की सेवा है जिसे आप कई तैनात करते हैं और वे समान विशेषताओं को साझा करते हैं), तो उपयोगी helm list आउटपुट प्राप्त करने के लिए आपके पास एक नया हेल्म होना चाहिए प्रत्येक ऐप के लिए चार्ट, और प्रत्येक रिलीज़ को अपने स्वयं के हेल्म चार्ट की भी आवश्यकता होती है। यह अकेले पाइपलाइनों को जटिल बनाता है, क्योंकि यदि चार्ट को साझा किया जा सकता है, तो इसकी अपनी पाइपलाइन हो सकती है जो केवल चार्ट के अपडेट होने पर चलती है, और एप्लिकेशन पाइपलाइनों को एक भी हेल्म कमांड चलाने की आवश्यकता नहीं होगी (बशर्ते फ्लक्स सीडी के लिए समर्थन जोड़ा गया हो) इंस्टॉल / अपग्रेड पर एक नया ऐप वर्जन फ्लैग)।

मेरा प्रश्न है - क्यों न दोनों दृष्टिकोणों का समर्थन किया जाए?

मैं ठीक यही सोच रहा हूं।

मेरे मामले में "सुपर संस्करण" हेलम चार्ट नहीं है बल्कि एक और परत है जो सिर्फ हेलम चार्ट का उपयोग करता है। मेरे लिए एक एकल हेल्म चार्ट अर्थहीन है क्योंकि यह कई अन्य लोगों के बीच केवल एक छोटी सी सेवा का वर्णन करता है। केवल एक साथ वे एक सार्थक रिलीज बनाते हैं।
इस प्रकार मेरे मामले में "सुपर वर्जन" उन सभी रिलीज का एक साथ सारांश है (जो वास्तव में इसका संस्करण है)।

फिर भी, हेल्म चार्ट को वर्णनात्मक "सुपर संस्करण" के रूप में रखने के लिए एक तर्क है।

@seeruk के बिंदु पर वापस: दोनों का समर्थन क्यों नहीं करते?

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

मैं हेल्म को कैसे देखता हूं

चार्ट के बजाय पैकेज स्थापित करने के बारे में इस वर्तमान बहस को पढ़ने तक मेरा मानना ​​है कि हेल्म मुख्य रूप से संबंधित कुबेरनेट्स संसाधनों का वर्णन करने के लिए एक इंटरफ़ेस है। यह विश्वास मुख्य रूप से हेल्म दस्तावेज़ीकरण से आता है जो यह कहता है:

हेल्म कुबेरनेट्स में चार्ट स्थापित करता है, प्रत्येक स्थापना के लिए एक नई रिलीज़ बनाता है। और नए चार्ट खोजने के लिए, आप हेल्म चार्ट रिपॉजिटरी खोज सकते हैं।

संदर्भ के लिए, वर्तमान स्थिर पतवार डॉक्स भी बताते हैं:

एक चार्ट एक हेल्म पैकेज है। इसमें Kubernetes क्लस्टर के अंदर किसी एप्लिकेशन, टूल या सेवा को चलाने के लिए आवश्यक सभी संसाधन परिभाषाएँ शामिल हैं। इसे कुबेरनेट्स की तरह समझें जो होमब्रू फॉर्मूला, एपीटी डीपीकेजी, या यम आरपीएम फ़ाइल के बराबर है।

तो अब कुछ भ्रम है! हेल्म डॉक्स स्पष्ट रूप से कहते हैं कि "एक चार्ट एक हेल्म पैकेज है," लेकिन अगर ऐसा है, तो पृथ्वी पर helm install गैर-पैक किए गए चार्ट रेपो को क्यों स्वीकार करता है?

यह व्यवहार है जिसने मेरे वर्तमान दृष्टिकोण को प्रभावित किया है कि पतवार क्या है और इसे कैसे काम करना चाहिए:

हेल्म _what_ की संरचना के बीच एक मैपर के रूप में कार्य करता है जो क्लस्टर में जा रहा है और _What properties_ उन चीजों में है।

तो अब सवाल यह है: "हेल्म की तैनाती क्या है?"

हेल्म परिनियोजन क्या है?

जब मैं helm install release-name ./local_chart चलाता हूं तो मैं उम्मीद कर रहा हूं कि सभी चार्ट टेम्पलेट्स को स्थानीय रूप से निर्दिष्ट मानों के साथ प्रस्तुत किया जाए (या तो डिफ़ॉल्ट या ओवरराइड के माध्यम से) और प्रस्तुत संस्करणों को कुबेरनेट्स में धक्का दें। मैं यह भी उम्मीद करता हूं कि अगर मैं रोलबैक करता हूं तो हेल्म पहले से तैनात कुबेरनेट्स ऑब्जेक्ट्स को बनाए रखेगा। "एक प्रदान की गई टेम्पलेट्स के संग्रह" (जो कुछ मेटाडेटा शामिल हैं) की इस अवधारणा एक रिलीज है और एक पैकेज है। उन सभी संसाधन परिभाषाओं (भले ही वे नहीं बदली हों) को रिलीज के अस्तित्व के लिए बंडल_ में वर्णित _उनके राज्य में होना चाहिए (या वापस रोल किया जाना चाहिए)।

इससे, मुझे लगता है कि हेलम केवल वास्तव में संकुल को तैनात करता है । ऐसा लगता है कि यह एकमात्र शब्दार्थ रूप से सही बात है जिसे आप कह सकते हैं; हालाँकि, इन पैकेजों को कैसे वितरित किया जाता है, इस बारे में तर्क व्यवहार में इस बहस का मूल कारण प्रतीत होता है। विशेष रूप से, "क्या ऐप संस्करण को अपग्रेड करना या बदलना एक नया पैकेज है?"

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

यह इस वजह से है कि मैंने अपनी रजिस्ट्रियों को साफ करना शुरू कर दिया है और विकास के अलावा :latest से कभी भी तैनात नहीं किया है। डॉकर छवि से रिलीज टैग के बजाय "मेटा-टैग" का उपयोग किसी दिए गए कोड बेस पर दिए गए परिनियोजन को असंभव बना देता है। हमने इसे कठिन तरीके से सीखा (लेकिन शुक्र है कि परीक्षण में, और उत्पाद में नहीं)।

किस पैटर्न का उपयोग किया जाना चाहिए?

यह पहले से ही हेल्म द्वारा माना गया है: पैकेज ।

यह देखते हुए कि यह पैटर्न लागू पैटर्न है, भले ही यह 100% स्पष्ट न हो, यह तार्किक रूप से सुसंगत लगता है कि --appVersion ध्वज प्रदान किया जाना चाहिए। इसका "क्यों" उत्तर देना शायद किसी और चीज़ से अधिक महत्वपूर्ण है, इसलिए मुझे उस उत्तर के साथ अपना योगदान समाप्त करने दें।

--appVersion का समर्थन क्यों करें?

आइए परिनियोजन के एक विशेष मामले पर एक नज़र डालें:

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

यह कंपनी क्या करे?

1. दो अलग, लगभग समान, शीर्ष चार्ट बनाएं जो केवल appVersion में भिन्न हों?
2. एक हेल्म चार्ट का उपयोग करें लेकिन प्रमुख ऐप संस्करणों के बीच लगातार appVersion फ़्लॉप करते हुए अपडेट करें?
3. appVersion को ध्वज के साथ ओवरराइड करें (वर्तमान में असमर्थित) जिससे कमांड लाइन पर संभावित डेवलपर त्रुटि हो सकती है?
4. appVersion से Chart.yaml और values.yaml पुनर्स्कोप करें?

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

प्रस्ताव 2 में प्रस्ताव 1 की तुलना में कम ओवरहेड है लेकिन चार्ट में उच्च परिवर्तनशीलता का परिचय देता है। यदि आप helm install release-name https://remote-repo.com/chart चलाने के लिए जाते हैं और चार्ट का सबसे अद्यतित संस्करण एप्लिकेशन का गलत संस्करण है तो क्या होगा? ओह। शायद सबसे अच्छा तरीका नहीं है।

प्रस्ताव 3 वह है जिस पर हम वर्तमान में चर्चा कर रहे हैं। मैं व्यक्तिगत रूप से विकल्प को नापसंद करता हूं, लेकिन केवल इसलिए कि मुझे लगता है कि यह समस्या का गलत समाधान है। क्या यह ऐपवर्सन को कॉन्फ़िगर करने योग्य बनाता है? ज़रूर। लेकिन यह भी वही समस्या है जो आप चलाते समय चलाते हैं helm install release-name https://remote-repo/chart : मेटाडेटा अल्पकालिक है और केवल हेल्म द्वारा बनाए रखा जाता है।

मैं वास्तव में बहुत हैरान हूं कि किसी ने अभी तक प्रस्ताव 4 या ऐसा कुछ पेश नहीं किया है। यह ऐप वर्जन को ऐसी स्थिति में रखता है जहां इसे ओवरराइड किया जा सकता है ( helm run जैसा कुछ सक्षम करना), helm package द्वारा उत्पन्न पैकेज में निहित किया जा सकता है, और वास्तव में एक एप्लिकेशन संस्करण की अवधारणा को डी-टंगल करता है एक चार्ट संस्करण से appVersion की अवधारणा को एक पतवार परिनियोजन के साथ जोड़ते हुए (ऐपवर्सन को कहीं सही होना चाहिए?)

मुझे आशा है कि यह मददगार था। 👀 यह पीआर।

@jrkarnes : एक अर्थ में 4) पहले ही प्रस्तावित किया जा चुका है और कई लोगों द्वारा वर्कअराउंड के रूप में उपयोग किया जा रहा है (यहां देखें https://github.com/helm/helm/pull/5492#issuecomment-517255692)। आप अपने चार्ट टेम्प्लेट में कुछ इस तरह का उपयोग कर सकते हैं:

{{ default .Values.appVersion .Chart.AppVersion }}

यह आपको appVersion को Charts.yaml में डिफ़ॉल्ट के रूप में उपयोग करने और Values.yaml (जिसे इंस्टॉल/अपग्रेड कॉल के दौरान ओवरराइड किया जा सकता है) में कुछ के साथ ओवरराइड करने की अनुमति देगा। नकारात्मक पक्ष यह है कि उदाहरण के लिए helm ls यह आपको या तो नहीं या गलत appVersion दिखाएगा।

@BenjaminSchiborr मुझे इसके बारे में बताने के लिए धन्यवाद। जैसा कि मैंने कहा, मैं बहुत सीमित समय के लिए helm कार्यक्षेत्र के अंदर रहा हूं भी ज्ञान मेरे लिए अच्छा ज्ञान है।

मुझे लगता है कि मेरे चौथे प्रस्ताव को थोड़ा गलत समझा गया था। {{ default .Values.appVersion .Chart.AppVersion}} जैसा कुछ होने के बजाय आप {{ .Values.Helm.AppVersion}} उपयोग करेंगे और values.yaml पास appVersion बजाय Chart.yaml

@jrkarnes
मैं अभी यही सोच रहा हूं। जैसे, ऐप वर्जन को यूनिक स्नोफ्लेक के रूप में क्यों माना जाना चाहिए। यह चार्ट का मूल्य है।

इसके पीछे तर्क करना आसान है: सब कुछ बुनियादी ढांचे का हिस्सा है। तो, इंफ्रा का संस्करण है। दो संस्करण क्यों?

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

मैं इसके बारे में थोड़ा और सोचूंगा

@jrkarnes
मैं अभी यही सोच रहा हूं। जैसे, ऐप वर्जन को यूनिक स्नोफ्लेक के रूप में क्यों माना जाना चाहिए। यह चार्ट का मूल्य है।

इसके पीछे तर्क करना आसान है: सब कुछ बुनियादी ढांचे का हिस्सा है। तो, इंफ्रा का संस्करण है। दो संस्करण क्यों?

मूल रूप से चार्ट संस्करण को एप्लिकेशन संस्करण से अलग रखना समझ में आता है । एक त्वरित उदाहरण शायद यह साबित करने का सबसे अच्छा तरीका है कि यह मामला है।

मान लें कि आपके पास एक एप्लिकेशन परिनियोजित है जो ver 4.0.0 आपके चार्ट संस्करण ver 1.1.0 पर चल रहा है। अपने संचालन के दौरान आप महसूस करते हैं कि आपको इस एप्लिकेशन के लिए क्रॉन कार्य चलाने की आवश्यकता होगी। क्रोनजॉब ऑब्जेक्ट लिखने और इसे क्लस्टर में लागू करने के बजाय, आप महसूस करते हैं कि इस चार्ट को चलाने वाले अन्य लोगों को भी क्रोन कार्य की भी आवश्यकता होगी ... इसलिए आप इसे अपने चार्ट में जोड़ते हैं। आपका चार्ट अब ver 1.2.0 बढ़ गया है लेकिन चार्ट द्वारा प्रबंधित एप्लिकेशन में कोई बदलाव नहीं हुआ है, यह अभी भी ver 4.0.0 ।

इसका उलटा भी लागू होता है और इस पीआर में पहले से ही बहस का विषय है।

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

मैं इसके बारे में थोड़ा और सोचूंगा

साइड केस या प्रोजेक्शन के बारे में सोचने के बजाय, MySql जैसी चीजों के बारे में सोचें, जिसमें तीन व्यापक रूप से उपयोग किए गए और समर्थित इंजन संस्करण हैं: [5.6, 5.7, 8.0] । एक क्लस्टर में mysql इंस्टेंस को तैनात करने के लिए आपके पास हमेशा होगा:

• एक पॉड चुने हुए संस्करण के MySQL का एक उदाहरण चला रहा है
• एक सेवा जो पॉड को क्यूब-डीएनएस रिज़ॉल्यूशन की अनुमति देती है (या एचए में चलने पर पॉड्स)
• पॉड्स के लिए एक पीवी (एस) जिसमें पीवीसी के साथ अपना डेटा लिखना है

MySql 5.6, 5.7, या 8.0 को परिनियोजित करने के लिए चार्ट सभी इंजन (एप्लिकेशन) संस्करणों के लिए अपेक्षाकृत समान होना चाहिए

मैं देखता हूं कि ऐप संस्करण की "ज़रूरत" पर सोचने के बारे में आपका क्या मतलब है। मुझे लगता है कि helm ls या helm inspect चलाते समय डेवलपर या संचालन सुविधा के लिए नीचे आता है।

+1 से @jrkarnes अंतिम पोस्ट। चार्ट और ऐप संस्करणों को अलग-अलग अवधारणाओं के रूप में रखने में बहुत अधिक मूल्य है क्योंकि चार्ट संस्करण "इन्फ्रास्ट्रक्चर संस्करण" है।

अगर मैं दूसरों के उपभोग के लिए चार्ट प्रकाशित कर रहा हूं, तो यह उन परियोजनाओं के लिए बुनियादी ढांचे का हिस्सा बन जाता है जो इस पर निर्भरता लेते हैं। हालांकि, अगर मैं कभी भी अपने आवेदन को दूसरों द्वारा उपभोग करने का इरादा नहीं रखता हूं, तो मुझे केवल अपने चार्ट संस्करण को समय-समय पर संशोधित करना है, जब चार्ट स्वयं बदलता है , लेकिन अन्यथा मुझे केवल मेरे ऐप संस्करण को सीआई के अनुरूप होना चाहिए /सीडी आउटपुट। उपयोग चार्ट के इस स्वाद में अपेक्षाकृत कम ही घूमता है, फिर भी ऐप संस्करण प्रत्येक सीआई घटना पर संशोधित होता है। मेरा कोड रेपो कोड और इंफ़्रा संस्करण के बीच संबंध बनाए रखता है जो कोड के इस संस्करण को चलाने के लिए लागू होता है। दूसरे शब्दों में, helm install last-known-good-chart-version साथ मेरी तैनाती को वापस करने के बजाय, मैं बस एक सूचक के साथ अपनी सीडी पाइपलाइन को फिर से चलाता हूं अंतिम ज्ञात अच्छी प्रतिबद्ध आईडी के लिए।

@iorlas मैंने helm run लिए आपका प्रस्ताव पढ़ लिया है और मुझे इससे कोई समस्या नहीं है। जबकि मुझे लगता है कि इंस्टॉल/रन डिकोटॉमी होना जरूरी नहीं है, अगर यह ऐप वर्जन को म्यूटेबल बनाने के बारे में हेल्म मेंटेनर्स के दिमाग को आराम देता है, तो मैं इसके साथ ठीक हूं। :)

@iorlas क्या आपको यह सोचने का मौका मिला है कि आप इस प्रस्ताव के साथ क्या करना चाहेंगे?

मुझे नहीं लगता कि मैं समझ रहा हूं कि {{ default .Values.appVersion .Chart.AppVersion}} जुड़े कार्य-आसपास के कार्य कैसे होते हैं। मुझे यह त्रुटि मिल रही है:

त्रुटि: YAML को JSON में परिवर्तित करने में त्रुटि: yaml: अमान्य मानचित्र कुंजी: मानचित्र [इंटरफ़ेस {}] इंटरफ़ेस {}। Values.appVersion | डिफ़ॉल्ट \"0.0.1\"": इंटरफ़ेस {}(शून्य)}[

यहाँ मेरा चार्ट.yaml है:

name: demo-helm
version: 0.0.1
appVersion: {{ .Values.appVersion | default "0.0.1" }}
home: http://example.com
description: Demo Helm

@IRobL आपको इस स्निपेट को templates/deployment.yaml में डालना होगा, जहां संस्करण का उपयोग किया जाता है। values.yaml जैसी फ़ाइलों को टेम्प्लेट के रूप में नहीं माना जाता है।

@jrkarnes मैं एक अनुरक्षक नहीं हूं, इसलिए अंतिम शब्द अन्य लोगों पर होगा, मुझे लगता है। लेकिन वैसे भी, मैं पिछले कुछ हफ्तों में काफी व्यस्त था। आगामी सप्ताह में मैं helm और इसके packages को प्रबंधित करने के लिए अपने वर्तमान दृष्टिकोण का पुनर्मूल्यांकन करूँगा।

हम मेरे द्वारा वर्णित दृष्टिकोण का उपयोग करते हैं:

• Helm Chart ऐप रिपॉजिटरी का एक हिस्सा है
• एप्लिकेशन बिल्ड का उत्पादन करता है:
  
  
  
  • डॉकर छवि -> डॉकर रजिस्ट्री
  
  
  • स्टेटिक फ़ाइलें -> सीडीएन सेवा
  
  
  • हेल्म पैकेज -> सीआई स्टोरेज
  
  
• तो, हेल्म पैकेज मुख्य आर्टिफैक्ट है, जो सभी एप्लिकेशन कलाकृतियों को एक साथ बांधता है
• परिनियोजन पर, install ने कहा पैकेज

वर्तमान चिंताएं:

• निर्माण प्रक्रिया की जटिलता।
  
  
  
  • डॉकर छवि और स्थिर फ़ाइलों के बजाय, अतिरिक्त फ़ाइल ( helm package ) उत्पन्न होती है
  
  
  • go build / make install परिणामी फ़ाइल के अलावा हमें किन मुख्य कारणों की आवश्यकता है?
  
  
  • क्या मूल्य है?
  
  
  • आवेदन क्यों करें?
  
  
  • कब आवेदन करें?
  
  
• निर्माण अवधि
  
  
  
  • भले ही हमें इसे तैनात करने की आवश्यकता न हो, फिर भी हम कुछ समय और पैसा बर्बाद करते हैं। 2-5 सेकंड। ज्यादा नहीं, लेकिन व्यर्थ का काम व्यर्थ है।
  
  
• इंफ्रास्ट्रक्चर टेम्प्लेट अपडेट की जटिलता
  
  
  
  • जब चार्ट अपडेट किया जाता है, तो मूल्यों को भी अपडेट किया जाना चाहिए
  
  
  • चार्ट एक रेपो है, मान दूसरा है, मूल्यों के प्रत्येक अद्यतन का अर्थ है थोड़ा सिरदर्द
  
  

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

आह, मैं देखता हूं कि वह चाल अब क्यों काम नहीं करेगी कि आपने इसे मेरे लिए इंगित किया, धन्यवाद। यहाँ एक तरकीब है जो मुझे लगता है कि हेल्म 2.x का उपयोग करने वाले कई लोगों के लिए ठीक काम करती है, यह मानते हुए कि आप अपने हेलम टूल को इस प्रकार के ओवरहेड टुकड़ों के साथ लपेटने में सहज हैं:

APP_VERSION=0.0.7
sed -i.bak "s/^appVersion:.*\\\$/appVersion: $APP_VERSION/" helm/Chart.yaml
helm install --name helm_demo helm/

@IRobL

सामान्य तौर पर, यदि आप एक परिनियोजन को sed के साथ लपेट रहे हैं, तो इसका मतलब है कि एक टेम्प्लेटिंग इंजन वह नहीं कर रहा है जिसकी आपको आवश्यकता है, जो इस चर्चा का संपूर्ण बिंदु है।

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

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

अक्टू 7, 2019, पर 3:33 pm पर, IRobL [email protected] लिखा है:

आह, मैं देखता हूं कि वह चाल अब क्यों काम नहीं करेगी कि आपने इसे मेरे लिए इंगित किया, धन्यवाद। यहाँ एक तरकीब है जो मुझे लगता है कि हेल्म 2.x का उपयोग करने वाले कई लोगों के लिए ठीक काम करती है, यह मानते हुए कि आप अपने हेलम टूल को इस प्रकार के ओवरहेड टुकड़ों के साथ लपेटने में सहज हैं:

APP_VERSION=0.0.7
sed -i.bak "s/^a ppVersion:. *\\$/appVersion: $APP_VERSION/" helm/Chart.yaml
हेलम इंस्टाल --नाम helm_demo हेलम/
-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें, या थ्रेड को म्यूट करें।

@jrkarnes , जब आप बुरा अभ्यास कहते हैं, तो क्या आप कह रहे हैं कि स्क्रिप्टिंग के साथ helm कमांड को लपेटने की आवश्यकता अवांछनीय है? अगर ऐसा है तो मैं पूरी तरह सहमत हूं। मैं यह नहीं कह रहा हूं कि मैं --app-version झंडा जोड़ने के खिलाफ हूं; इसके विपरीत मुझे लगता है कि यह पतवार के लिए एक बहुत ही सुविधाजनक अतिरिक्त होगा। स्पष्ट रूप से इस पीआर के आधार पर, मैं एकमात्र व्यक्ति नहीं हूं जो हेलम का उपयोग कर रहा है जो ऐपवर्सन वैरिएबल को वास्तविक निर्माण के साथ संगत रखना चाहता है। मैं एक पुन: प्रयोज्य बिल्ड पाइपलाइन लाइब्रेरी विकसित कर रहा हूं जो प्रतिलिपि प्रस्तुत करने योग्य बिल्ड बनाने के लिए विभिन्न बिल्ड टूल्स को एक साथ लपेटता है - यह बड़े तकनीकी संगठनों के लिए एक आम प्रथा है। मेरे उपयोग के मामले में, पाइपलाइन पुस्तकालय डॉकटर कंटेनरों का निर्माण करता है, उन्हें प्रकाशित करता है, और अंततः उन्हें एप्लिकेशन की बिल्ड पाइपलाइन से पतवार के माध्यम से तैनात करता है (उदाहरण के लिए, तीसरे पीआर के पहले निर्माण के लिए ऐप संस्करण 1.0.1-pr-3.1 पर विचार करें) एक ऐप, जो संभावित रूप से संस्करण 1.0.1 के लिए एक पूर्व-रिलीज़ है)।

मेरी कंपनी की बिल्ड पाइपलाइन लाइब्रेरी में इस मुद्दे के आसपास काम करने के बाद भी, मैं निश्चित रूप से हेल्म में निर्मित --app-version स्विच होने से अधिक सहज महसूस करूंगा; यह सिर्फ तैनाती को संभालने का एक और अधिक लचीला तरीका लगता है। मेरा मतलब है, एक बाहरी सिस्टम या एक इंजीनियर को चार्ट फ़ाइल में क्यों जाना चाहिए और प्रत्येक तैनाती से पहले एक यमल को अपडेट करना चाहिए यदि इसे एक बिल्ड प्लेटफॉर्म द्वारा स्वचालित किया जा सकता है जो गलती से संख्याओं को गड़बड़ नहीं कर सकता है? मेरे दृष्टिकोण से, ऐपवर्सन कार्यक्षमता को मेरे संगठन द्वारा पूरी तरह से त्यागने की आवश्यकता होगी, या "मैला" sed काम को हमारे पाइपलाइन लाइब्रेरी कोड में जोड़ने की आवश्यकता होगी, इसलिए मैंने सोचा कि मैं इसे इसके लिए साझा करूंगा कोई और जो इस समस्या का समाधान कर रहा था।

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

यही कारण है कि यह जनसंपर्क इतना आसान हल नहीं था। चूंकि, फिक्स स्पष्ट है, लेकिन यह हेल्म डिजाइन के अनुरूप नहीं है। इसलिए कुछ अस्थायी समाधान प्रदान किए जाते हैं।

और आप app-version ध्वज के बारे में सही हैं। आपको इसे प्रदान करना चाहिए, फिर हेल्म को अपने आप ही सब कुछ संभाल लेना चाहिए।

क्या मुझे आपसे एक सवाल पूछने की अनुमति है? आप अपने उत्पाद में हेल्म का उपयोग कैसे करते हैं? जब आप helm install ? आप इसका सटीक उपयोग कैसे करते हैं? क्या आपने helm package का उपयोग करने पर विचार किया है?

मैंने कल रात helm package पर एक और नज़र डाली। मैं वास्तव में उस पर बेचा नहीं गया था। sed बहुत लंबे समय से आसपास है और बहुत स्थिर है। ये सभी tiller / package / install उप-आदेश अपेक्षाकृत नए हैं, और कम स्थिर हैं। अपनी बात को स्पष्ट करने में मदद करने के लिए, महीनों पहले, मैंने तय किया कि "निश्चित रूप से टिलर काम कर सकता है" भले ही मैंने किसी का प्लगइन देखा हो जो टिलर की आवश्यकता को दरकिनार कर देता हो। मैंने प्लगइन को कुछ ऐसी चीज के रूप में देखा जो कम मुख्यधारा रही होगी, लेकिन मैं तब से खुद को लात मार रहा हूं। अगर मुझे प्लगइन पर भरोसा होता, तो मैं अब की तुलना में कहीं बेहतर स्थिति में होता। हेल्म के अनुरक्षकों ने यह भी पुष्टि की है कि वे सहमत हैं कि यह एक अप्राप्य डिजाइन था और यह भविष्य के रिलीज में बंद हो जाएगा।

मुझे लगता है कि इन सरल सेड ऑपरेशन को करने के लिए helm package का उपयोग करना मेरी ओर से एक गलती होगी। वैसे भी package लिए आपका उपयोग-मामला क्या है? मुझे ऐसा लगता है कि helm package की पूरी अवधारणा वेब 2.0/संस्करण नियंत्रण रिलीज के बिंदु को पहली जगह में एक बाइनरी ज़िप में पैकेजिंग द्वारा याद करती है जब आधुनिक प्रौद्योगिकी समूह उसी प्रक्रिया को प्राप्त करने के लिए टैगिंग की शक्ति का लाभ उठा रहे हैं। लेकिन एक दुबले और अधिक ऑडिट-सक्षम तरीके से।

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

@IRobL

जब आप बुरा अभ्यास कहते हैं, तो क्या आप कह रहे हैं कि स्क्रिप्टिंग के साथ हेल कमांड को लपेटने की आवश्यकता अवांछनीय है?

हां। यह ठीक।

मेरे उपयोग के मामले में, पाइपलाइन पुस्तकालय डॉकटर कंटेनर बनाता है, उन्हें प्रकाशित करता है, और अंततः उन्हें एप्लिकेशन की बिल्ड पाइपलाइन से पतवार के माध्यम से तैनात करता है

ठीक यही हम भी कर रहे हैं।

मेरी कंपनी की बिल्ड पाइपलाइन लाइब्रेरी में इस मुद्दे के आसपास काम करने के बाद भी, मुझे निश्चित रूप से हेल्म में निर्मित --app-version स्विच होने में अधिक सहज महसूस होगा

मैं इसे एक कदम आगे ले जाऊंगा और कहूंगा कि appVersion Chart.yaml फ़ाइल की संपत्ति होना शायद गलत है। यदि मूल्य को मक्खी पर बदला जा सकता है, तो इसे "अपरिवर्तनीय मान सेट" के रूप में नहीं माना जाना चाहिए। मेरा मानना ​​​​है कि मैंने पिछली टिप्पणी में इसी बात की वकालत की थी।

ये सभी टिलर/पैकेज/इंस्टॉल उपकमांड अपेक्षाकृत नए हैं, और कम स्थिर हैं।

एफडब्ल्यूआईडब्ल्यू, Tiller हेल्म 3 में कुछ नहीं होने जा रहा है। आपने बाद में अपनी पोस्ट में इसका उल्लेख किया; हालांकि, मैं इसे सिर्फ इसलिए दोहरा रहा हूं क्योंकि यह दिखाता है कि "कुबेरनेट्स बाइनरी" बनाने और इसे Tiller शिपिंग करने का helm package सिंटैक्स शायद एक बुरा अभ्यास है।

मुझे लगता है कि इन सरल सेड ऑपरेशन को करने के लिए हेल्म पैकेज का उपयोग करना मेरी ओर से एक गलती होगी। वैसे भी पैकेज के लिए आपका उपयोग-मामला क्या है?

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

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

इस प्रकार, helm package को अंततः _दैट ऑडियंस_ द्वारा उपभोग करने का इरादा था। उपकरण निश्चित रूप से उन क्षेत्रों में बहुत अधिक उपयोग देख रहा है जो टीम (मुझे लगता है) को विश्वास नहीं था कि उपकरण उठाएगा, या कभी भी इसका उपयोग करने का इरादा नहीं था।

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

मैं मूल रूप से इसके बाद kubectl apply -f s के समूह के साथ awk तरह हेलम का इलाज कर रहा हूं। मानवीय त्रुटि से बचने के लिए मूल्यों का ध्यान रखने के लिए एक स्वचालित उपकरण का होना बहुत अधिक साफ है।

ऐसा लगता है कि आपके और मेरे पास बहुत सारे समान मूल्य हैं और हो सकता है कि आप बहुत सी समान चीजें कर रहे हों।

@IRobL

टिलर

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

मुझे लगता है कि इन सरल सेड ऑपरेशन को करने के लिए हेल्म पैकेज का उपयोग करना मेरी ओर से एक गलती होगी।

मुझे लगता है कि आप मेरी बात याद कर रहे हैं। मुझे दोबारा प्रयास करने दें। sed किसके लिए बनाया गया है? डेटा की एक धारा को बदलने के लिए। यह आपको किसी भी इनपुट के लिए एपीआई और परिणाम देते हुए परिवर्तनों की समस्या को दूर करना चाहिए।

क्या होगा यदि आपने एक स्क्रिप्ट बनाई है, जहां आपका sed कमांड काम नहीं करता है (यानी आपको रेगेक्स में गलती है)? तो आपने एक निष्कर्ष निकाला, यह काम नहीं करता है। क्या आप यह समझने की कोशिश करेंगे कि क्यों sed अपने आप काम नहीं करता है, या आप पर्ल स्क्रिप्ट के साथ एक अतिरिक्त पाइप जोड़ेंगे?

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

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

@jrkarnes

हां, हम दोनों समान हितों को ध्यान में रखते हुए शीर्ष पर पहुंच रहे हैं। मुझे वास्तव में इस बात का एहसास नहीं था कि package कमांड की जड़ टिलर द्वारा बताई गई गलतियों से जुड़ी हुई थी, इन अंतर्दृष्टि को मेरे साथ साझा करने के लिए धन्यवाद!

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

आपका बिल्ड प्लेटफॉर्म बीटीडब्ल्यू क्या है? मैं जो पाइपलाइन कोड लिख रहा हूं वह जेनकिंस के लिए ग्लोबल पाइपलाइन लाइब्रेरी के रूप में लिखा गया है।

@IRobL मुख्य समस्या यह है: आप हेलम को परिनियोजन स्क्रिप्ट के रूप में देख रहे हैं। लेकिन हेम ऐसा नहीं है। पतवार एक अमूर्त परत है। हेल्म आपकी सभी कलाकृतियों को लेता है और एक प्लेटफॉर्म के रूप में K8s पर काम की एक इकाई के रूप में लागू होता है।

हेल्म एक पैकेजर है। हेल्म को तैनाती को आसान बनाने के लिए डिज़ाइन किया गया है। यह आपकी कलाकृतियों से "इंस्टॉलर" बनाता है, इसलिए आप इसे अपने OS - K8s पर "इंस्टॉल" कर सकते हैं।

app-version में install का तकनीकी ऋण से कोई लेना-देना नहीं है। जब आप इसे install या upgrade करना चाहते हैं तो इसकी बिल्कुल भी आवश्यकता नहीं है। वही Chart.yml । इसे बिल्कुल भी नहीं बदला जाना चाहिए, क्योंकि यह एक डिफ़ॉल्ट कॉन्फ़िगरेशन फ़ाइल है, जिसमें वास्तविक चार्ट का संस्करण होता है, लेकिन चार्ट आपका सॉफ़्टवेयर नहीं है। आप बस इसे गलत इस्तेमाल कर रहे हैं।

उस दृष्टिकोण से, आप package का उपयोग करने पर विचार क्यों नहीं करेंगे? यह आपके लिए बहुत जटिल लगता है या क्या?

थोड़ी देर के लिए इस मुद्दे पर लूप से बाहर हो गया, लेकिन मैंने इस तरह के बिंदु को कुछ बार फसल देखा है:

हेल्म एक पैकेजर है। हेल्म को तैनाती को आसान बनाने के लिए डिज़ाइन किया गया है। यह आपकी कलाकृतियों से "इंस्टॉलर" बनाता है, इसलिए आप इसे अपने OS - K8s पर "इंस्टॉल" कर सकते हैं।

मूल रूप से, हेल्म _किसी भी तरह से_ इंस्टॉलर नहीं बनाता है। यह "बाइनरी" नहीं बनाता है। यह ".deb" फ़ाइल या समान के समान कुछ नहीं बनाता है। यह कुछ डिफ़ॉल्ट और/या प्रीसेट मानों के साथ कुबेरनेट्स मैनिफ़ेस्ट के कुछ टेम्प्लेट का एक संग्रह बनाता है। आपका वास्तविक सॉफ्टवेयर उस हेल्म चार्ट में नहीं रहता है। इसके साथ पैक नहीं किया जाता है। यह अपरिवर्तनीय होने की गारंटी नहीं है।

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

--app-version लिए helm install और helm upgrade पर उपलब्ध होने का यह मूल कारण है (कम से कम IMO)। अगर सचमुच कुछ भी नहीं बदला है तो आपको अपने चार्ट को फिर से क्यों पैकेज करना चाहिए?

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

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

यह कुछ डिफ़ॉल्ट और/या प्रीसेट मानों के साथ कुबेरनेट्स मैनिफ़ेस्ट के कुछ टेम्प्लेट का एक संग्रह बनाता है।

लेकिन deb फ़ाइल कॉन्फ़िगरेशन फ़ाइलों, कमांडों, मैनिफ़ेस्ट और/या प्रीसेट मानों का एक ही सेट है। एमएसआई इंस्टॉलर के समान या यहां तक ​​कि, जो करीब एक है, जेंटो इमर्ज पैकेज सिस्टम में ईबिल्ड। इसके अलावा, ब्रू पैकेज के समान।

तो K8s के लिए पैकेज मैनेजर नहीं तो हेल्म क्या है? आप क्या अंतर देखते हैं?

यह अपरिवर्तनीय होने की गारंटी नहीं है।

क्यों नहीं? यदि आप पैकेज जनरेशन के बाद पैकेज को बदलते हैं, तो यह गलत है। यदि आप install/upgrade प्रक्रिया के दौरान अतिरिक्त विकल्पों की आपूर्ति करते हैं, तो यह सभी पैकेजिंग प्रणालियों की तरह अभिप्रेत है।

मैं कुबेरनेट्स मैनिफ़ेस्ट के एक संस्करणित विवरण के रूप में एक हेल्म चार्ट देखता हूं

आपके पास पहले से ही एक है - जीआईटी। तो, आपको हेल्म की आवश्यकता क्यों होगी?

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

इस डिज़ाइन में, ऐपवर्सन को हेल्म पैकेज बिल्ड की विशेषता के रूप में नहीं माना जाना चाहिए। इसे मूल्यों में विन्यास पैरामीटर के रूप में माना जाना चाहिए।

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

इस मामले में आप ऐप इंफ्रास्ट्रक्चर मेनिफेस्ट और ऐप संस्करण के युग्मन को खो देंगे। चूंकि, इमेज टैग बदलने से नया हेल्म अपग्रेड ट्रिगर नहीं होगा (अगर फ्लक्स लोग इसे दूसरे तरीके से कर रहे हैं तो मुझे सही करें)। उस स्थिति में, आपके पास कॉन्फ़िगरेशन टेम्पलेट के रूप में हेल्म होगा। उस स्थिति में, आपको --app-version की बिल्कुल भी आवश्यकता नहीं है।

लेकिन deb फ़ाइल कॉन्फ़िगरेशन फ़ाइलों, कमांडों, मैनिफ़ेस्ट और/या प्रीसेट मानों का एक ही सेट है। एमएसआई इंस्टॉलर के समान या यहां तक ​​कि, जो करीब एक है, जेंटो इमर्ज पैकेज सिस्टम में ईबिल्ड। इसके अलावा, ब्रू पैकेज के समान।

.deb और .msi पैकेज के लिए यहां आपके विवरण में एक प्रमुख घटक गायब है - वास्तविक चीज जो स्थापित की जा रही है। यदि आप किसी .deb फ़ाइल की सामग्री को देखते हैं, तो आपको निर्मित सॉफ़्टवेयर - _THE_ सॉफ़्टवेयर मिलेगा जो कि स्थापित होने वाला है। आम तौर पर (हमेशा .deb के मामले में?) तैनात किया जा रहा आवेदन आंतरिक रूप से जुड़ा हुआ है, और उस पैकेज का हिस्सा है (ब्रू के मामले में नहीं)।

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

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

उदाहरण के लिए आपको केवल स्थिर चार्ट रेपो को देखने की जरूरत है। मूल्यों के माध्यम से उपयोग की जा रही छवि को ओवरराइड करने के लिए कितने एप्लिकेशन आपको अनुमति देते हैं? (ढेर सारा_)

तो K8s के लिए पैकेज मैनेजर नहीं तो हेल्म क्या है? आप क्या अंतर देखते हैं?

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

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

मुझे जो मुख्य जटिलता दिखाई दे रही है वह यह है कि 2 उपयोग-मामले हैं:

• तृतीय-पक्ष एप्लिकेशन परिनियोजित करना।
• प्रथम-पक्ष अनुप्रयोगों को परिनियोजित करना।

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

प्रथम-पक्ष अनुप्रयोगों के मामले में, आपके पास अनुप्रयोगों के वर्ग को परिनियोजित करने का एक मानक तरीका हो सकता है। उदाहरण के लिए Icelolly में हम अपनी गो सेवाओं को लगभग एक ही तरह से लिखते और तैनात करते हैं। इसके लिए, हम वास्तव में कुबेरनेट्स में तैनात हमारी सभी गो सेवाओं के लिए अभी एक चार्ट का उपयोग करने में सक्षम हैं (हम अभी helm package वर्कअराउंड का उपयोग करते हैं)। यदि हम अपने स्वयं के अनुप्रयोगों को परिनियोजित करने के लिए अपना दृष्टिकोण बदलते हैं, तो हम चार्ट को अपडेट करेंगे। हम अपने चार्ट को SemVer के साथ संस्करणित करते हैं, इसलिए जो एप्लिकेशन अपडेट नहीं होते हैं वे तब तक प्रभावित नहीं होंगे जब तक हम उन्हें अपडेट नहीं करना चाहते।

बस इस नोट पर; हमारा go-service चार्ट आखिरी बार लगभग एक महीने पहले अपडेट किया गया था। उस समय के दौरान शायद हमारे पास दसियों से सैकड़ों परिनियोजन थे - सभी उस चार्ट को बदले बिना।

एक मामले में, आप बस सादगी चाहते हैं। दूसरे मामले में आप नियंत्रण और प्रबंधन में आसानी चाहते हैं।

इस मामले में आप ऐप इंफ्रास्ट्रक्चर मेनिफेस्ट और ऐप संस्करण के युग्मन को खो देंगे। चूंकि, इमेज टैग बदलने से नया हेल्म अपग्रेड ट्रिगर नहीं होगा (अगर फ्लक्स लोग इसे दूसरे तरीके से कर रहे हैं तो मुझे सही करें)। उस स्थिति में, आपके पास कॉन्फ़िगरेशन टेम्पलेट के रूप में हेल्म होगा। उस स्थिति में, आपको --app-version की बिल्कुल भी आवश्यकता नहीं है।

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

helm list एक उपयोगी कमांड है। यह देखने में सक्षम होना कि कौन से एप्लिकेशन संस्करण तैनात किए गए हैं, वास्तव में अभी भी उपयोगी है। हमारे अनुप्रयोगों वर्तमान में साथ पतवार के माध्यम से स्थापित करने के लिए helm package हम केवल आवेदन संस्करण (के माध्यम से सेट दृष्टिकोण --app-version पर helm package ) ताकि के उत्पादन में helm list है उपयोगी। इसलिए अगर हम इसे helm install|upgrade पर सेट कर सकें तो यह हमारे लिए और आसान हो जाएगा। हमें केवल संस्करण बदलने के लिए चार्ट लाने और उसे दोबारा पैक करने की आवश्यकता नहीं होगी।

वास्तव में, helm list और रोलबैक को संभालना संभवत: एकमात्र कारण हैं जो हम प्रथम-पक्ष सॉफ़्टवेयर के लिए हेल्म का उपयोग कर रहे हैं।

.deb और .msi पैकेज के लिए आपके विवरण में एक प्रमुख घटक गायब है - वास्तविक चीज़ जो स्थापित की जा रही है।

"इंस्टॉल" लक्ष्य प्लेटफॉर्म पर आवश्यक सुविधाएं (फ़ोल्डर, कॉन्फ़िगरेशन, बायनेरिज़, डीबी फ़ेचिंग, डेटा रीफ़्रेशिंग/माइग्रेशन) स्थापित करने की एक प्रक्रिया है।

deb वह सब संभालता है। तो हेल्म पैकेज करता है। आपका क्या मतलब है हेलम पैकेज "वास्तव में स्थापित" नहीं है?

यदि आप किसी .deb फ़ाइल की सामग्री को देखते हैं, तो आपको निर्मित सॉफ़्टवेयर मिलेगा - वह सॉफ़्टवेयर जो इंस्टॉल होने वाला है।

असत्य। कभी-कभी आपको सॉफ्टवेयर ही मिल जाएगा। कभी-कभी आपको कुछ सॉफ्टवेयर टुकड़े मिल जाएंगे। कभी-कभी आपको ऐसे सॉफ़्टवेयर लाने के लिए स्क्रिप्ट के एक सेट के अलावा कुछ नहीं मिलेगा। तो, यहाँ मुख्य बिंदु - इससे कोई फर्क नहीं पड़ता , क्योंकि Linux और K8s दिए गए एप्लिकेशन को होस्ट करने के लिए प्लेटफ़ॉर्म हैं, एक सार्वभौमिक एप्लिकेशन प्रारूप को स्वीकार करते हुए। और छवि के नाम, कॉन्फ़िगरेशन पैरामीटर - पैकेज के टुकड़े हैं।

ब्रू वास्तव में वर्तमान में हेल्म के समान ही है, क्योंकि यह केवल निर्देश है कि इसे कैसे स्थापित किया जाना चाहिए, और स्रोत/पैकेज को कहां से डाउनलोड किया जाना चाहिए।

बिल्कुल। क्या आप मुझे समझाने की कोशिश कर रहे हैं कि ब्रू पैकेज मैनेजर नहीं है?

यहाँ बिल्कुल स्पष्ट होना; एक हेल्म चार्ट _is एक विशिष्ट एप्लिकेशन संस्करण के लिए आंतरिक रूप से बंधा नहीं है ...
मूल्यों के माध्यम से उपयोग की जा रही छवि को ओवरराइड करने के लिए कितने एप्लिकेशन आपको अनुमति देते हैं? (ढेर सारा)

तुम पूरी तरह ठीक हो। k8s टेम्प्लेट के लिए हेल्म एक आसान टेम्प्लेटिंग इंजन से अधिक नहीं हो सकता है। मुझे ऐसे सॉफ़्टवेयर अस्तित्व में कोई समस्या नहीं है: यह थोड़ी मदद करता है, आधुनिक वितरण अभ्यास को नहीं बदलेगा।

समस्या यह है कि हेल्म टेंपलेटिंग इंजन से कहीं अधिक है। यह सभी लाभों और कमियों के साथ एक पैकेजिंग प्रबंधक है। और उस पारिस्थितिकी तंत्र में जहां पैकेज प्रबंधक मौजूद है, अन्य पैकेज प्रबंधन द्वारा कुछ प्रबंधक रखना एक बुरा अभ्यास है। इससे भी बदतर - काम कर रहे w/o पैकेज मैनेजर।

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

जिस बिंदु पर मैं बहस कर रहा हूं वह यह है कि कुछ उपयोग-मामलों में ऐसा होना वास्तव में वांछनीय है।

हाँ, यह केंद्रीय बिंदु है: क्या यह किसी भी उत्पाद के लिए वांछनीय है?

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

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

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

तृतीय-पक्ष एप्लिकेशन परिनियोजित करना।

अगर मैं पूरी तरह से हेल्म चार्ट का उपयोग करके कोई भी पीएसक्यूएल/माईएसक्यूएल संस्करण स्थापित कर सकता हूं तो मुझे बहुत खुशी होगी। विरासत परियोजनाओं को बनाए रखना, नए लोगों के लिए बुनियादी ढांचे को पेश करना बहुत आसान होगा। चार्ट अपडेट के बारे में सूचित करना और भी आसान हो गया है। हमारे पास बायनेरिज़ के लिए प्रत्येक रिलीज़ के लिए इतनी सारी tar.gz फ़ाइलें क्यों हैं, लेकिन हेलम पैकेज के लिए tar.gz फ़ाइलों का एक ही सेट नहीं हो सकता है?

@iorlas मैंने अभी इसे और अस्वीकृत पीआर के माध्यम से पढ़ा है और आप कुछ बहुत अच्छे अंक बनाते हैं। आपने मुझे आश्वस्त किया है कि मुझे अपने निर्माण/रिलीज के अन्य आर्टिफैक्ट के रूप में अपने हेल्म चार्ट को पैकेजिंग शुरू करने की आवश्यकता है।

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

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

आम तौर पर मैं एक पीआर जमा करना चाहता हूं और न केवल ऐसा लगता है जैसे मैं किसी चीज के बारे में शिकायत कर रहा हूं, लेकिन मुझे यकीन नहीं है कि 3.0 दस्तावेज परिवर्तनों के साथ क्या हो रहा है।

@jonstelly दस्तावेज़ीकरण में निश्चित रूप से एक अंतर है। यहां तक ​​​​कि मैं भी पहले सोच रहा था कि --app-version जाने के लिए अच्छा है, लेकिन फिर भी इसे गायब नहीं किया जा सका w/oa कारण।

डॉक्स को निश्चित रूप से कुछ स्पष्टीकरण और सामान्य समस्याओं के परिचय की आवश्यकता है। फिर, हेल्म विकास चक्र परिचय। लेकिन मेरा मानना ​​है कि टीम तीसरे संस्करण में व्यस्त है। और मैं अभी भी बहुत व्यस्त हूँ :(

"इंस्टॉल" लक्ष्य प्लेटफॉर्म पर आवश्यक सुविधाएं (फ़ोल्डर, कॉन्फ़िगरेशन, बायनेरिज़, डीबी फ़ेचिंग, डेटा रीफ़्रेशिंग/माइग्रेशन) स्थापित करने की एक प्रक्रिया है।

deb वह सब संभालता है। तो हेल्म पैकेज करता है। आपका क्या मतलब है हेलम पैकेज "वास्तव में स्थापित" नहीं है?

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

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

जहाँ तक मेरी जानकारी है, वास्तव में आप यहाँ गलत हैं। .deb फ़ाइल एक AR संग्रह है। आप इसे निकाल सकते हैं और सामग्री को देख सकते हैं, और अंततः यह कुछ मेटाडेटा, और कुछ फ़ाइलें हैं। .deb फ़ाइलों में सैद्धांतिक रूप से पैच हो सकते हैं, लेकिन अक्सर ऐसा नहीं होता है। यदि किसी .deb फ़ाइल में सॉफ़्टवेयर लाने के लिए एक स्क्रिप्ट है, तो इसका अर्थ यह होगा कि यह स्क्रिप्ट है जिसे .deb फ़ाइल द्वारा स्थापित किया जा रहा है, न कि स्वयं सॉफ़्टवेयर। यह एक इंस्टॉलर स्थापित करने जैसा है।

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

बिल्कुल। क्या आप मुझे समझाने की कोशिश कर रहे हैं कि ब्रू पैकेज मैनेजर नहीं है?

नहीं। मैं केवल इतना कह रहा हूं कि हेल्म की तरह, ब्रू के माध्यम से सॉफ़्टवेयर स्थापित करने के लिए प्रदान की गई स्क्रिप्ट बस यही हैं - स्क्रिप्ट। अनुप्रयोगों को अलग से बनाया, पैक और वितरित किया जाता है और उन लिपियों द्वारा खींचा जाता है। यह ब्रू को किसी पैकेज मैनेजर से कम नहीं बनाता है, ठीक वैसे ही जैसे मैं कह रहा हूं कि हेल्म कुबेरनेट्स पैकेज मैनेजर से कम नहीं है। यह इस मुद्दे की बात नहीं है, हालांकि, हम इस बात पर बहस नहीं कर रहे हैं कि हेल्म पैकेज मैनेजर है या नहीं, हम यह तय करने का प्रयास कर रहे हैं कि --app-version फ्लैग को helm install|upgrade जोड़ा जाना चाहिए या नहीं।

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

क्षमा करें, मैं स्पष्ट नहीं हूं कि आपका क्या मतलब है। क्या पुराना/जटिल/प्रबंधित करना कठिन है?

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

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

एफ़टीपी पर पुराने अपलोड का उपयोग करने के बारे में मुझे यकीन है कि आप पहले से ही जानते हैं कि कई _लॉट_ फ़ायदे हैं।

वैसे भी, यह सब द्वारा है। मुझे लगता है कि अंततः जैसा कि मैंने पहले ही उल्लेख किया है, मेरी राय में, यह सब नीचे आता है; क्या हेल्म अनुरक्षक इस अन्य उपयोग-मामले को सक्षम करना चाहते हैं, या लोगों के लिए इसे इस तरह से उपयोग करना अधिक कठिन बनाना चाहते हैं? अंत में, यह किसी भी तरह से _वास्तव में बहुत बड़ा अंतर नहीं है। मेरे लिए, यह अच्छा होगा यदि मुझे अपने आंतरिक चार्ट को पैकेज नहीं करना पड़े, जो कि शायद ही कभी बदलता है, प्रत्येक बिल्ड पर केवल एक एप्लिकेशन संस्करण सेट करने के लिए, जिसका उपयोग केवल एक सूची में वर्तमान संस्करण को दिखाने के लिए किया जाता है। प्रथम-पक्ष ऐप्स के लिए, मैं ईमानदार रहूंगा, मैंने सवाल किया है कि क्या हेल्म वैसे भी सही दृष्टिकोण है।

डॉकर छवि को हेल्म चार्ट में पैक नहीं किया जाता है

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

A.deb फ़ाइल एक AR संग्रह है
आप इसे निकाल सकते हैं और सामग्री को देख सकते हैं
और अंततः यह कुछ मेटाडेटा है
और कुछ फ़ाइलें

जैसे.... एक हेल्म पैकेज!

यदि आपके पास ... एक .deb है जहां .deb जाता है और .deb फ़ाइल को स्थापित करने की प्रक्रिया के भाग के रूप में स्थापित करने के लिए सॉफ़्टवेयर डाउनलोड करता है ...
यह एक इंस्टॉलर स्थापित करने जैसा है। ...

हां, यह एक इंस्टॉलर की तरह होगा जिसके अंदर इंस्टॉलर है। हास्यमय ठीक? यदि संभव हो तो मैं करने के लिए

• ब्रू के पास पैकेज के रूप में YAML है, लेकिन रिमोट स्टोरेज से बायनेरिज़ प्राप्त करता है
• इमर्ज (जेंटू) ने परिभाषा के रूप में ईबिल्ड किया है, जो गिट क्लोन भी डाउनलोड करता है

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

लेकिन कृपया, मुख्य बिंदु से न चूकें: इससे कोई फर्क नहीं पड़ता ! यहां तक ​​​​कि खाली पैकेज, जिसमें केवल संदर्भ है, एक पैकेज है। शायद आप एक और शब्द, इंस्टॉलर स्वीकार करेंगे?

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

और हम सभी के पास एक ही पाइपलाइन है - एक डॉकर छवि बनाने के लिए।

हम यह तय करने का प्रयास कर रहे हैं कि एक सामान्य उपयोग-मामले को सुविधाजनक बनाने के लिए --app-version ध्वज को हेलम इंस्टॉल | अपग्रेड में जोड़ा जाना चाहिए या नहीं।

यह एक कुंजी है। लेकिन हम कैसे तय कर सकते हैं? हमें दो प्रश्न पूछने चाहिए:

• क्या यह संभव है? हां
• क्या करना सही बात है? हां? नहीं?

अगर पीपीएल कुछ कर रहा है, तो क्या इसका मतलब यह है कि यह अच्छी बात है? प्रगति करने के लिए, हमें हर चीज पर सवाल उठाने की जरूरत है।

क्षमा करें, मैं स्पष्ट नहीं हूं कि आपका क्या मतलब है। क्या पुराना/जटिल/प्रबंधित करना कठिन है?

लेट प्रोजेक्ट को ब्रू पर ले जाएं, क्योंकि ब्रू वास्तव में हेल्म के करीब है और पहले से ही व्यापक रूप से सफलतापूर्वक उपयोग किया जाता है। आप Gentroo Ebuilds या deb पर प्रोजेक्ट कर सकते हैं, तस्वीर नहीं बदलेगी।

• रगड़ा हुआ। पिछली बार कब आपको मैन्युअल रूप से MySQL/PSQL इंस्टॉल करना पड़ा था? हम इससे क्यों हटे हैं? ये कारण, कली।
• जटिल। यह "क्यों" में से एक है: आपको स्वतंत्र रूप से बुनियादी ढांचे को स्थापित करने की आवश्यकता है, आपको यह जानना होगा कि कौन सा सॉफ़्टवेयर संस्करण के साथ सबसे अच्छा काम करता है। कभी-कभी आपको कुछ सॉफ़्टवेयर संस्करण चलाने के लिए बुनियादी ढांचे को अनुकूलित करने की आवश्यकता होगी। क्यों परेशान होना? आप पूरे प्रश्न का प्रतिनिधित्व क्यों नहीं करेंगे?
• प्रबंधन करना कठिन। जब आपके पास केवल एक आर्टिफ़ैक्ट हो सकता है, तो आपको बुनियादी ढांचे और ऐप दोनों संस्करणों को प्रबंधित करने की आवश्यकता होगी। अपने जीवन को कठिन क्यों बना रहे हो?

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

फिर से, अंतर मूल रूप से यह है कि आपके द्वारा उल्लिखित सभी चीजें आंतरिक रूप से जुड़ी हुई हैं।

हर बार नहीं। उदाहरण के लिए, डॉकर छवि में एसएसआर बीई और सीडीएन का संदर्भ हो सकता है।

डॉकरफाइल, इसलिए सुनिश्चित नहीं है कि वह बिंदु किस बारे में है - लेकिन आप अक्सर छवियों के नए संस्करण बनाने के लिए इसे बदलने के बिना एक ही डॉकरफाइल का उपयोग करेंगे (मेरा मतलब है, अगर आपको हर बार मैन्युअल रूप से कुछ बदलना पड़ा तो स्वचालन से परेशान क्यों हैं, है ना?)

यही तो बात है। यहां तक ​​​​कि जब डॉकरफाइल नहीं बदला जाता है, तब भी आप नई छवि बनाते हैं। यदि आपका स्रोत कोड नहीं बदला गया है, लेकिन Dockerfile है, तो आप नई छवि बनाते हैं। तो, संक्षेप में, Dockerfile भी एक पैकेज है। वही हेलम के लिए जाता है। क्या आपको ऐसा नहीं लगता?

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

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

अंत में, यह वास्तव में किसी भी तरह से बहुत बड़ा अंतर नहीं है।

मुझे विश्वास है, यह है। हो सकता है कि यह कोडबेस में बहुत अधिक सौदा नहीं है, लेकिन यह कंटेनरीकरण विकास को स्थिर कर देगा।

डॉकर छवि को हेल्म चार्ट में पैक नहीं किया जाता है

छवि स्वयं पैक नहीं है, लेकिन संदर्भ (पढ़ें: पिन) है। निश्चित रूप से, हम पांडित्यपूर्ण हो सकते हैं और इस बात पर पकड़ बना सकते हैं कि अलग-अलग आकार (एमबी से जीबी तक) की शाब्दिक छवि helm package (स्पॉइलर: यह नहीं है) की कलाकृति में शामिल है या नहीं, लेकिन सार कथन "किसी एप्लिकेशन के कोड का दिया गया संस्करण एक हेल्म पैकेज में शामिल है" अभी भी मौलिक रूप से सही है। आप कैसे अप्रासंगिक हैं, इसमें फंसना चाहते हैं या नहीं।

उदाहरण के भूमि वापस करने के लिए जा रहे हैं, कहते हैं कि तुम एक आवेदन जो आप आंतरिक रूप संस्करणीकृत किया है जाने 1.9.9 एक चार्ट पर संस्करणीकृत पर चल रहे 1.2.5 । ताकि कोई भ्रम न हो, एप्लिकेशन कंटेनर के लिए डॉकर इमेज शा fakeshaA ।

आपकी टीम तय करती है कि आपके आवेदन के संस्करण 2.0.0 में एक फ़ाइल का एक स्थानीय फाइल सिस्टम संस्करण होने जा रहा है जिसे आप HTTP पर संदर्भित करते थे। इसका कारण महत्वहीन है लेकिन आपके लिए इसका परिणाम बहुत गंभीर है। अब आपको अपने परिनियोजन के लिए pv और pvc ताकि अपग्रेड के बीच ये अब-स्थानीय फ़ाइलें खो न जाएं। आवश्यकता को देखते हुए, आप आगे बढ़ते हैं और अपने हेल्म चार्ट को अपडेट करते हैं ताकि यह pv और pvc ताकि 2.0.0 की ओर बढ़ना अत्यधिक विघटनकारी न हो।

चार्ट बदलने से पहले, आपके पास Artifact A एप्लिकेशन वर्जन 1.9.9 को इंफ्रास्ट्रक्चर वर्जन 1.2.5 लिंक करना है। अब आप चार्ट बदलते हैं... _आपका हेल्म चार्ट अब v. 1.3.0 _ है और आप 1.9.9 को इंफ्रास्ट्रक्चर वर्जन 1.3.0 जोड़ने वाला एक आर्टिफैक्ट तैयार करेंगे। हम इसे Artifact B कहेंगे

जब 2.0.0 लिए कोड परिनियोजन डॉकर छवि sha fakeShaB साथ लाइव हो जाता है, तो आप 2.0.0 को इन्फ्रा संस्करण 1.3.0 जोड़ने वाला एक और आर्टिफैक्ट तैयार करेंगे। यह Artifact C

अब मान लें कि यह पता चला है कि एक समस्या है जिसे आप 2.0.0 रिलीज के साथ पूरी तरह से नहीं समझते हैं और आपको वापस रोल करना होगा। आप Artifact B का उपयोग करके रोलबैक करते हैं ... लेकिन यह समस्या का समाधान नहीं करता है इसलिए आप Artifact A फिर से रोलबैक करते हैं और समस्या हल हो जाती है।

आपके द्वारा चलाई जाने वाली एकमात्र समस्या यह है कि क्या आपके कलाकृतियों के संदर्भ में डॉकर रजिस्ट्री में अभी भी उन कलाकृतियों में संदर्भित छवि है या नहीं।

कोई फर्क नहीं पड़ता, आपके पास अभी भी किसी एप्लिकेशन के संस्करण और आधारभूत संरचना के संस्करण के बीच एक संबंध है। यह हेल्म का उद्देश्य है। अन्यथा बहस करना मूर्खता है।

@iorlas :

आइए .deb तुलनाओं को अलग रखें। मुझे लगता है कि यह सिर्फ हमें भटका रहा है।

हर बार नहीं। उदाहरण के लिए, डॉकर छवि में एसएसआर बीई और सीडीएन का संदर्भ हो सकता है।

ये बहुत सही है। हालांकि उस पर और बाद में।

यही तो बात है। यहां तक ​​​​कि जब डॉकरफाइल नहीं बदला जाता है, तब भी आप नई छवि बनाते हैं। यदि आपका स्रोत कोड नहीं बदला गया है, लेकिन Dockerfile है, तो आप नई छवि बनाते हैं। तो, संक्षेप में, Dockerfile भी एक पैकेज है। वही हेलम के लिए जाता है। क्या आपको ऐसा नहीं लगता?

आप करते हैं, लेकिन ऐसा इसलिए है क्योंकि उस निर्माण प्रक्रिया (यानी एक डॉकर छवि) के अंत में उत्पाद _both_ Dockerfile, और उस चीज़ पर निर्भर करता है जिसे आप इसमें डाल रहे हैं। उन दो घटकों के बिना एक छवि मौजूद नहीं हो सकती।

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

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

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

दरअसल, काश ऐसा ही होता। लेकिन यह अभी नहीं है।

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

हालांकि यह हकीकत नहीं है। ऐसा नहीं है कि हेल्म कैसे काम करता है, और मुझे नहीं पता कि यह कभी भी वास्तव में होगा। लेकिन कभी मत कहो, है ना?

@jrkarnes :

छवि स्वयं पैक नहीं है, लेकिन संदर्भ (पढ़ें: पिन) है।

ज़रूर, लेकिन एक सामान्य उपयोग-मामला इस मान को ओवरराइड करने के लिए मानों का उपयोग कर रहा है। मैंने इसे तृतीय और प्रथम-पक्ष चार्ट दोनों के साथ उपयोग किया है। यह एक विकल्प नहीं होता अगर यह ऐसा कुछ नहीं होता जिसे लोग इस्तेमाल करते हैं।

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

मुझे नहीं लगता कि हम किसी भी चीज़ के बारे में पांडित्यपूर्ण हैं - जैसा कि आपने पहले ही बताया है, यह कहना तथ्यात्मक रूप से गलत होगा कि डॉकर छवि "निर्मित" हेल्म चार्ट के अंदर पैक की गई है।

"किसी एप्लिकेशन के कोड का दिया गया संस्करण एक हेल्म पैकेज में शामिल है" अभी भी मौलिक रूप से सही है।

लेकिन वास्तव में नहीं, जैसा कि मेरे पहले बिंदु के खिलाफ बहस होगी। आप जो तैनात किया जा रहा है उसे बदल सकते हैं। नरक, यदि आप चाहें तो hello-world छवि चलाने के लिए आप अधिकांश चार्ट बदल सकते हैं। यह बेकार होगा, लेकिन यह मेरी बात को अच्छी तरह से साबित करता है - हेल्म चार्ट आपके आवेदन से जुड़ा नहीं है। एक _expectation_ है कि आप इसे सही छवि के साथ उपयोग करेंगे, और शायद डिफ़ॉल्ट रूप से यह करेगा, लेकिन यह निश्चित रूप से _हैव_ नहीं है - और _no way_ में एप्लिकेशन का कोड हेल्म चार्ट में शामिल है, अन्यथा पैक किया गया है।

उदाहरणों के देश में वापस जाने पर, [...] और समस्या हल हो जाती है।

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

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

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

तो फिर, जैसा कि मैंने @iorlas से कहा है, सवाल यह है कि क्या हेल्म को अनुकूलित करना चाहिए? इस उपयोग-मामले को सक्षम न करने का क्या कारण है? यदि कारण सिर्फ "क्योंकि यह वर्तमान में नहीं है" तो यह एक बहुत ही खराब कारण है यदि आप मुझसे पूछें। ऐसा लगता है कि इस चर्चा में से किसी ने भी अब तक इस प्रश्न का उत्तर नहीं दिया है।

... उस निर्माण प्रक्रिया के अंत में उत्पाद (यानी एक डॉकर छवि) डॉकरफाइल और उस चीज पर निर्भर करता है जिसे आप डाल रहे हैं। ... उन दो घटकों के बिना एक छवि मौजूद नहीं हो सकती।

तो ... हेल्म पैकेज को चार्ट और ऐप संस्करण (= डॉकर छवि) की आवश्यकता होती है और यह मौजूद नहीं हो सकता है।

एक हेल्म चार्ट किसी एप्लिकेशन के बनने से पहले मौजूद हो सकता है - कोड की एक पंक्ति के लिखे जाने से पहले। ... हेल्म चार्ट पूरी तरह से बिना किसी और चीज के मौजूद हो सकता है। जैसा मैंने कहा, यह बेकार होगा

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

तो, मेरी परिकल्पना है : हेल्म पैकेज लगभग बेकार w/oa डॉकर छवि है। डॉकर छवि लगभग बेकार w/oa स्रोत कोड है। अंतर अमूर्तता का एक स्तर है। दोनों चीजें पैकेज जैसी वस्तुएं हैं ।

लेकिन मैं सिर्फ अपनी बात को स्पष्ट करने की कोशिश कर रहा हूं कि वे बिल्कुल भी जुड़े हुए नहीं हैं।

हां हां! यह वास्तव में अच्छा है कि हमारे पास हर चीज पर विस्तार से चर्चा करने के लिए पीपीएल तैयार है। डब्ल्यू / ओ आप, डब्ल्यू / ओ अनुमानों और दावों, हम भविष्य के पौधे को जीवित नहीं बनायेंगे

मुझे नहीं लगता कि यह एक साहसिक दावा है, ऐसा होता है - यह पहले से ही सच है। ... तो जैसा कि मैंने पहले कहा है, यह सब नीचे आता है; क्या हेल्म अनुरक्षक इस उपयोग-मामले को सक्षम करना चाहते हैं, या नहीं - इसके अलावा और कुछ नहीं है।

तथ्य। इस तरह के बदलाव को करने और स्वीकार करने के लिए, इसका मूल्यांकन किया जाना चाहिए: क्या ऐसा करना सही है ?

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

इसलिए, मैं इस दृष्टिकोण के खिलाफ नहीं हूं। मैं देखता हूं कि यह कैसे जी सकता है (मेरा प्रस्ताव helm run )। लेकिन जब हमारे पास हस्तक्षेप करने और संभवतः पूरे उद्योग को ठीक करने का मौका है, जबकि बहुत देर नहीं हुई है, मैं प्रत्येक उपयोग का मूल्यांकन करूंगा, किसी भी नुकसान और समस्याओं पर चर्चा करूंगा।

उस परिदृश्य में एक हेल्म चार्ट बनाने के लिए जब आपका एप्लिकेशन बदलता है तो आपको इसे फिर से बनाना होगा

हां। अभी भी यह मामला हो सकता है। हमारे पास एक पाइपलाइन है जहां push बजाय हम डॉकर छवि के save / load रहे हैं। और यह काफी अच्छा काम करता है। मुझे अभी ऐसा नहीं लग रहा है, लेकिन मूल रूप से यह बहुत साफ-सुथरा तरीका है। समस्या यह है कि, K8s को अभी भी "स्टार्टर" - डॉकर छवि को स्थानांतरित करने के लिए बस के रूप में दूरस्थ डॉकर रजिस्ट्री की आवश्यकता होगी।

आइए अपना ध्यान कम करें, दोस्तों

आपका हेल्म चार्ट आंतरिक रूप से तैनात किए जा रहे एप्लिकेशन संस्करण से जुड़ा होगा - जैसे डॉकर छवि बनाना।

यह यहीं एक महत्वपूर्ण अंतर है। और @seeruk ने इसे

1. डॉकर इमेज हेल्म पैकेज से बंधी नहीं है। केवल इसका संदर्भ है।
2. यह इन रास्तों को स्वतंत्र रूप से जारी करने का अवसर देता है।

मुख्य सवाल:

1. स्वतंत्र दृष्टिकोण के जोखिम क्या हैं? (अर्थात यदि कुछ देवोपास इसका प्रयोग करेंगे तो उसके विरुद्ध हम क्या तर्क देंगे)
2. पैकेजिंग दृष्टिकोण इसे कैसे हल करता है?
3. क्या मूल्य है?
4. हम इस विशेष प्रश्न में कंटेनरीकरण का भविष्य कैसे देखते हैं?

@सीरुक :

तो फिर, जैसा कि मैंने @iorlas से कहा है, सवाल यह है कि क्या हेल्म को अनुकूलित करना चाहिए? इस उपयोग-मामले को सक्षम न करने का क्या कारण है? यदि कारण सिर्फ "क्योंकि यह वर्तमान में नहीं है" तो यह एक बहुत ही खराब कारण है यदि आप मुझसे पूछें। ऐसा लगता है कि इस चर्चा में से किसी ने भी अब तक इस प्रश्न का उत्तर नहीं दिया है।

आपने बहुत अच्छे स्पष्टीकरण और अंक दिए हैं। व्यक्तिगत रूप से मुझे लगता है कि हेल्म को अनुकूलन करना चाहिए। CI/CD इस बात का भविष्य है कि सॉफ़्टवेयर कैसे बनाया जाएगा, और ईमानदारी से --atomic जैसे व्यवहारों के साथ हेलम पहले से ही एक विश्वसनीय परिनियोजन उपकरण के रूप में अधिक लचीला हो रहा है। हालाँकि, यह मुद्दा बहुत पुराना है, इसलिए मुझे लगता है कि पीआर का विलय प्रक्रिया में "अगला चरण" नहीं है।

एक प्लगइन बनाना, कहो helm-ci-cd इस विशेष --app-version सुविधा के लिए व्यवहार्य हो ( helm-ci-cd लिए अन्य अच्छे उम्मीदवार हो सकते हैं, install/ upgrade द्वैत देखें जिसे हम CI/CD ppl पहले ही रैपिंग के माध्यम से एकीकृत कर चुके हैं।

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

हम सिर्फ चार्ट.यमल में ग्रूवी के साथ पढ़ते हैं, फिर ऐप संस्करण सेट करते हैं और तैनाती समय के दौरान फ़ाइल को ओवरराइट करते हैं। फिर हेल्म अपग्रेड करें। यह अच्छा होता अगर यह पतवार का हिस्सा होता लेकिन मैं इस पर भरोसा नहीं करता।

इसे Google'ing के माध्यम से मिला। वही नाव, वास्तव में।

यदि verison: चार्ट संस्करण है, तो इसका अर्थ है कि चार्ट के YAML में परिवर्तन होने पर यह संस्करण बदल जाता है। चूंकि चार्ट कॉन्फ़िगर करने योग्य मानों वाला एक टेम्प्लेट है, इसलिए यह मान लेना सुरक्षित है कि आप चार्ट की YAML फ़ाइलों को संशोधित किए बिना कई संस्करणों, 1.2, 1.3, 1.6, 1.8, आदि के ऐप्स को परिनियोजित करने के लिए चार्ट 1.3 का उपयोग कर सकते हैं।

अब चार्ट.yaml के भीतर हार्ड कोड appVersion: में आता है - आपको परिनियोजित एप्लिकेशन के संस्करण को अपडेट (और प्रतिबिंबित) करने के लिए चार्ट फ़ाइल को संपादित करने के लिए मजबूर करता है।

निश्चित रूप से एक --app-version CLI विकल्प की आवश्यकता है जिसका उपयोग हम चार्ट टेम्प्लेट के भीतर समान version: 1.3.0 चार्ट के साथ विभिन्न संस्करणों को परिनियोजित करने के लिए _application_ के संस्करण को संदर्भित करने के लिए कर सकते हैं।

@सीरुक

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

यह हमारे विवाद का मुद्दा है और मुझे नहीं लगता कि हम दोनों में से कोई एक दूसरे को मना पाएगा। कभी-कभी एक पेशेवर सेटिंग में जब राय की बात आती है तो अपरिवर्तनीय मतभेद होना _ठीक है। मैं निश्चित रूप से स्टालमैन की हर बात से सहमत नहीं हूं और अगर हम हर उस चीज के बारे में खाइयों में उतरते हैं जिस पर वह और मैं असहमत हैं तो हम आम सहमति तक पहुंचने से पहले मर जाएंगे।

मैंने इसे चर्चा में आगे कहा और मुझे लगता है कि यह दोहराना है:

[...] मुझे लगता है कि हेलम केवल कभी भी वास्तव में पैकेजों को तैनात करता है। ऐसा लगता है कि यह एकमात्र शब्दार्थ रूप से सही बात है जिसे आप कह सकते हैं; हालाँकि, इन पैकेजों को कैसे वितरित किया जाता है, इस बारे में तर्क व्यवहार में इस बहस का मूल कारण प्रतीत होता है। विशेष रूप से, "क्या ऐप संस्करण को अपग्रेड करना या बदलना एक नया पैकेज है?"

एक प्रथम पक्ष हेल्म चार्ट (मैं MySQL का उपयोग करना पसंद करता हूं इसलिए मैं इसका उपयोग करता रहूंगा) बिना कॉन्फ़िगरेशन के एक संसाधन को क्लस्टर में स्थापित करना चाहिए क्योंकि चार्ट निर्माता ने इसका वर्णन किया और इसका इरादा किया । MySQL के लिए वास्तविक चार्ट को देखते हुए दो गुण हैं जो वास्तविक MySQL इंजन को शामिल करने योग्य हैं:

• image (डिफ़ॉल्ट mysql )
• imageTag (डिफ़ॉल्ट 5.7.14 )

फिर, उनकी Chart.yaml फ़ाइल में:

apiVersion: v1
name: mysql
version: 1.4.0
appVersion: 5.7.27

ध्यान दें कि appVersion और डिफ़ॉल्ट imageTag मेल नहीं खाते । यदि मैं helm list चलाता हूं तो मुझे एक रिपोर्ट प्राप्त होगी कि "ऐप संस्करण" (पढ़ें; इंजन संस्करण) एक राज्य है जो वास्तविक ऐप संस्करण को प्रतिबिंबित नहीं करता है जो कि क्लस्टर_ में स्थापित है।

कहीं भी आपको चार्ट और एप्लिकेशन संस्करण को सख्ती से लिंक करने की आवश्यकता नहीं है (ठीक वैसे ही जैसे अभी वास्तव में, आपको उनकी आवश्यकता नहीं है)।

यह सही है; और मेरी राय में, एक डिजाइन दोष।

तो फिर, जैसा कि मैंने @iorlas से कहा है, सवाल यह है कि क्या हेल्म को अनुकूलित करना चाहिए?

हां। मैं कुछ सुझावों को एक क्षण में संबोधित करूंगा।

@IRobL

एक प्लगइन बनाना, कहो helm-ci-cd इस विशेष --app-संस्करण सुविधा के लिए व्यवहार्य होगा ( @jrkarnes शायद पीआर योगदानकर्ता के रूप में इस से बात कर सकता है)?

आप अपने स्वयं के प्रश्न का उत्तर इसके साथ देते हैं:

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

अगर हमें फ़ंक्शन को सही करने के लिए इसे प्लगइन के रूप में करना है, तो मैं उस दृष्टिकोण की वकालत करूंगा; हालांकि, मुझे लगता है कि यह गलत समस्या का समाधान कर रहा है। जैसा कि मैंने पहले @seeruk से कहा था, मुझे लगता है कि appVersion अपरिवर्तनीय Chart.yaml फ़ाइल में एक आंतरिक संपत्ति होना एक डिज़ाइन दोष है। appVersion की संपत्ति है image कि चार्ट के माध्यम से क्लस्टर में स्थापित किया जा रहा है, और यह छवि अपने साथ संदर्भित से किसी तरह से ली गई है tag ।

helm-ci प्लगइन के बारे में सोचते समय, आप और कौन-सी सुविधाएँ या ऐड-इन्स वहाँ होने की उम्मीद करेंगे? मुझे नहीं लगता कि केवल appVersion को अपरिवर्तनीय Chart.yaml संपत्तियों में से टॉगल करना एक प्लगइन होने के वारंट के लिए एक मूल्य-वर्धित के लिए पर्याप्त है।

@IRobL और @seeruk एक साथ:

मुझे लगता है कि हमारी अलग-अलग राय आती है कि हम हेलम के अधिक सामान्य अंतिम उपयोगकर्ता को कौन देखते हैं। यदि अंतिम-उपयोगकर्ता को कोई ऐसा व्यक्ति माना जाता है जो बहुत अधिक कॉन्फ़िगरेशन नहीं कर रहा है या टेम्पलेट्स में खुदाई नहीं कर रहा है, तो helm ls विशेष रूप से उपयोगी नहीं हो सकता है और बिंदु विवादास्पद है।

हालाँकि... यदि आप एक क्लस्टर को प्रबंधित करने के लिए एक प्रशासनिक उपकरण और सहायक के रूप में पतवार का उपयोग कर रहे हैं या यदि आप एक CI/CD संदर्भ में हेल्म का अधिक उपयोग कर रहे हैं, तो --appVersion स्विच बहुत अधिक समाप्त होता

एक आदर्श दुनिया में, मैं तर्क दूंगा कि appVersion एक व्युत्पन्न संपत्ति होनी चाहिए और डॉकर छवि मेटाडेटा से आना चाहिए; ऐसा करना संभव नहीं है, अहंकार, विवाद की कमी।

मैंने जो कहा उसके बारे में

हां। मैं कुछ सुझावों को एक पल में संबोधित करूंगा ...
... एक helm-ci प्लगइन के बारे में सोचकर, आप और कौन-सी सुविधाएँ या ऐड-इन्स वहाँ होने की अपेक्षा करेंगे?

मेरे पास एक व्यक्तिगत सूची है जो एक अच्छा प्रारंभिक बिंदु हो सकता है:

• helm को CICD मोड में चलाने से _only_ पहले जारी किए गए पैकेजों की स्थिति की तुलना वर्तमान में लागू किए जा रहे पैकेज से नहीं होगी। . इसके बजाय, किसी रिलीज़ का प्रत्येक परिनियोजन upgrade चलने पर टेम्प्लेट किए गए प्रत्येक मैनिफ़ेस्ट को पूरी तरह से लागू करेगा।
• helm-cicd बेस कुबेरनेट्स कमांड को रैप करना चाहिए। मैं helm describe या helm logs चलाने का प्रयास करने की संख्या की गणना नहीं कर सकता।
• helm-cicd मुझे यह देखने की अनुमति देनी चाहिए कि किसी भिन्न उपयोगकर्ता द्वारा चलाए जाने पर कमांड के परिणाम क्या होते हैं। यदि हम RBAC का उपयोग कर रहे हैं, तो मैं देखना चाहूंगा कि जब कोई अनधिकृत उपयोगकर्ता कुछ करने का प्रयास करता है तो क्या होता है।
• helm-cicd बाद में संपादित करने के लिए मैनिफेस्ट के संग्रह में नामस्थान को विघटित करने में सक्षम होना चाहिए।
• helm-cicd एक रिलीज को नेमस्पेस में _transplant_ करने में सक्षम होना चाहिए।

वे बड़े हैं... लेकिन एक पूर्ण helm-ci प्लगइन पर चर्चा करना इस पीआर/मुद्दे (वर्तमान में) के दायरे से बाहर है।

मैं वह सब कुछ पढ़ता हूं जो आप लोग लिखते हैं और मैं प्रवचन की सराहना करता हूं। मुझे आपकी प्रतिक्रिया की प्रतीक्षा होगी।

अभी अपने समय में काफी व्यस्त हूं, लेकिन कुछ बिंदुओं पर आपको सुधारना चाहता हूं। @jrkarnes

मुझे लगता है कि अपरिवर्तनीय चार्ट.yaml फ़ाइल में ऐपवर्सन एक आंतरिक संपत्ति होना एक डिज़ाइन दोष है

यह नहीं। जब कुछ इस तरह से बनाया जाता है और दूसरा नहीं, तो हमेशा एक कारण होता है, यहां तक ​​कि वह जंगली भी होता है । इस मामले में, यह विचारधारा है जो मैं खड़ा हूं: एक पैकेज = एक बिल्ड, चार्ट = बिल्ड के लिए टेम्पलेट, पैकेज = ऐप + इंफ्रा।

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

_मुझे क्यों लगता है कि इसे इस तरह डिज़ाइन किया गया है? वही helm list मौजूदा संकुल संस्करण स्थापित प्रदर्शित करने के लिए सेट है।_

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

MySQL चार्ट के साथ एक अतिरिक्त समस्या है। आप सही हैं, helm list में स्थापित MySQL संस्करण को देखना बेहतर होगा, लेकिन यह संस्करण का सिर्फ एक हिस्सा है, क्योंकि एक छवि टैग भी है, जो शायद यहां संस्करण का एक हिस्सा है।

तो फिर, जैसा कि मैंने @iorlas से कहा है, सवाल यह है कि क्या हेल्म को अनुकूलित करना चाहिए?
हां। मैं कुछ सुझावों को एक क्षण में संबोधित करूंगा।

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

एक आदर्श दुनिया में, मैं तर्क दूंगा कि ऐपवर्सन एक व्युत्पन्न संपत्ति होनी चाहिए और डॉकर छवि मेटाडेटा से आना चाहिए; ऐसा करना संभव नहीं है, अहंकार, विवाद की कमी।

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

समस्या है, ऐसा नहीं है। यह सिर्फ एक हिस्सा है, आर्टिफैक्ट। छोटे से लेकर बड़े उत्पादों तक आपके पास कई कलाकृतियां एक साथ बंधी होंगी। कभी-कभी आप बिल्ड प्रक्रिया के भीतर डॉकर फ़ाइल में संस्करण पास करेंगे, कभी-कभी आपके पास एक कॉन्फिग मैप होगा, जो कई कलाकृतियों को एक साथ जोड़ता है। और आपके पास एक डॉकर फ़ाइल नहीं होगी जिसमें यह सब होगा।

मेरे पास एक व्यक्तिगत सूची है जो एक अच्छा प्रारंभिक बिंदु हो सकता है

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

कृपया ध्यान दें!

ठीक है, हमने वहाँ और वहाँ कई विचार किए हैं। मेरा मानना ​​​​है कि सबसे अच्छा मामला परिदृश्य होगा:

• ऐप संस्करण बदलने की क्षमता, पहले पैकेज बनाने की आवश्यकता है
• helm ls में उचित ऐप संस्करण देखने की क्षमता
• किसी भी एपीआई (जैसे हेल्म ऑपरेटर) को मध्य स्थिति में ऐप संस्करण को निर्दिष्ट/अपग्रेड करने की अनुमति दें

हमारे पास दो दृष्टिकोण प्रदान किए गए हैं:

1. helm install एक पैकेज स्थापित करने के लिए बनाया गया है। यह चार्ट की स्थापना का भी समर्थन करता है, लेकिन यह सीमित है। आइए helm install सरल करें और इसे इसके उद्देश्य की पूर्ति के लिए छोड़ दें - संकुल स्थापित करें। दूसरे, आइए helm run , जिसका इरादा सरल प्रवाह प्रदान करना है: helm package और helm run मिलाएं, दोनों कमांड तर्क प्रदान करें, लेकिन उन लोगों को फ़िल्टर करें जिनका ऐसे मामले में कोई मतलब नहीं है .
2. app-version को helm install cmd में जोड़ें। यह इस एपीआई को ब्लोट करेगा और पैकेजों का उपयोग करने के विचार को छुपाएगा, यह छुपाएगा (जैसे यह अभी करता है) पैकेज को इंस्टॉलर के रूप में उपयोग करने की विचारधारा, जो कम से कम कुछ के लिए, यदि अधिकतर नहीं, परियोजनाओं के लिए कुल समझ में आता है।

क्या हम इस बात से सहमत हो सकते हैं कि ये दोनों दृष्टिकोण अभी हमारे सभी संघर्षों का समाधान करेंगे?

एक प्लगइन एक लापता सुविधा के लिए एक समाधान है जिसे कोर देव समर्थन नहीं करना चाहते हैं या उसके पास समय नहीं है इसलिए मुझे परवाह नहीं है कि यह एक प्लगइन है।

हेल्म को इस विचारधारा के इर्द-गिर्द डिज़ाइन किया गया है, ताकि K8s को OS और पैकेज को आपके ऐप के लिए इंस्टॉलर/अपडेटर के रूप में माना जा सके।

ऊह। मैं समझ गया। कुबेरनेट्स के लिए एक हेल्म चार्ट [पैकेज] एक "आरपीएम" [प्रति-कहना] होना चाहिए। पूरी तरह से मुझे मिली छाप नहीं: हेलम ऐप को तैनात करने के लिए चार्ट का उपयोग करता है। चार्ट/पैकेज "k8s के लिए स्वरूपित" ऐप है।

मैं उस के साथ ठीक हूँ। यह समझ में आता है - जैसे ही हम नए कंटेनर बनाते हैं, हमें अभी अपने बिल्ड सर्वर को ऐप वर्जन में अपडेट करने की आवश्यकता है:

• कंटेनर बनाएं - टैग "v1.2"
• चार्ट.yaml अपडेट करें - ऐप वर्जन: "v1.2" --- मुझे लगता है कि पहले से ही helm package --app-version कमांड भी है।
• पैकेज चार्ट: helm package --app-version v1.2 => पैकेज [चार्ट] -v1.2.tgz (यानी एक "पैकेज [चार्ट] -v1.2.rpm")
• परिनियोजन सर्वर का उपयोग करके पैकेज परिनियोजित करें, हेल्म इंस्टाल पैकेज [चार्ट] -v1.2 (उदाहरण के लिए उपयुक्त ऐप @ v1.2 स्थापित करें)

अब, क्या मैं इनमें से किसी को समझने में गलती कर रहा हूँ? यदि पैकेज-v1.2 v1.2 ऐप वर्जन नहीं है, तो क्यों नहीं? क्या यह इरादा नहीं होगा? उदाहरण के लिए आरपीएम ऐप का संस्करण है, पैकेज नहीं (चार्ट)।

संपादित करें:

यदि पैकेज-v1.2 v1.2 ऐप वर्जन नहीं है, तो क्यों नहीं? क्या यह इरादा नहीं होगा?

अब मैं देखता हूं कि लोग चार्ट.संस्करण और चार्ट.एपसंस्करण पर एकसमान होने पर टिप्पणी क्यों कर रहे हैं। तर्क यहां दोनों तरीकों से जा सकते हैं ... एक स्थिर "चार्ट" बिल्ड वाला ऐप, आप पैकेज-v1.2 से इसकी संस्करण संख्या बदलने की अपेक्षा करेंगे। लेकिन आप यह भी तर्क दे सकते हैं कि पैकेज-v1.2 चार्ट संस्करण संख्या होगी - जब yaml फ़ाइलें बदलती हैं।

आप एक स्थिर चार्ट संस्करण (1.2) का प्रबंधन कैसे करते हैं, जो बढ़ते हुए ऐप संस्करण (1.6) से अलग है? क्या package-[version] 1.2 होगा? या 1.6? मान लें कि आपने चार्ट संस्करण 1.2 परिनियोजित किया है लेकिन ऐप संस्करण पैकेजिंग पर बदल गया है: helm package --app-version 1.6 ?

➜  chart git:(master) ✗ helm package --app-version 1.5 nginx
Successfully packaged chart and saved it to: /Users/Documents/source/docker/nginx/chart/nginx-0.1.0.tgz

:(

.... इतना अधिक भ्रामक।

कुबेरनेट्स के लिए एक हेल्म चार्ट [पैकेज] का मतलब "आरपीएम" [प्रति-कहना] होना है

बिल्कुल! लेकिन कभी-कभी यह बहुत सख्त या बहुत अधिक परेशानी महसूस करता है, यहीं पर शॉर्टकट की जरूरत होती है।

अब, क्या मैं इनमें से किसी को समझने में गलती कर रहा हूँ? यदि पैकेज-v1.2 v1.2 ऐप वर्जन नहीं है, तो क्यों नहीं? क्या यह इरादा नहीं होगा? उदाहरण के लिए आरपीएम ऐप का संस्करण है, पैकेज नहीं (चार्ट)।

यह एक और चर्चा के लिए एक समस्या है, लेकिन वर्तमान में पैकेज का नाम चार्ट संस्करण के नाम पर रखा जाएगा, ऐप संस्करण के लिए नहीं। मुझे इसका कारण नहीं पता, मुझे लगता है कि यह दूसरी तरह से होना चाहिए। मुझे लगता है, यह ऐतिहासिक मुद्दा है, लेकिन मेरे दिमाग में, आपके जैसा, यह package-{app-version}.tgz होना चाहिए।

मेरे पिछले संदेशों के अनुसार, संस्करण के 4 घटक हैं:

• चार्ट
• अनुप्रयोग
• पैकेज
• रिहाई

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

अगर हम ऐप की पैकेजिंग की विचारधारा चुनेंगे, तो ऐप वर्जन पूरी तरह से समझ में आएगा, क्योंकि एक ही प्रक्रिया ऐप, इमेज और पैकेज दोनों का निर्माण करती है। इसलिए, जब हम वितरण चरण में जाएंगे, तो यह स्पष्ट होगा कि फाइलों को कैसे बुलाया जाता है, किस फाइल को स्थापित करना है। अभी हमें पाइपलाइनों में पैकेज का नाम हार्डकोड करना है >_<

@iorlas

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

मुझे इस कथन के बारे में सोचने में कुछ हफ़्ते लगे और मैं आपके साथ 100% सहमत हूँ। साथ ही, अब मैं समझता हूं कि हमारे विचारों में अंतर कहां से आता है...

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

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

जबकि कई बार हमें यह देखने के लिए helm template का उपयोग करना चाहिए कि एक संभावित चार्ट कैसे परिनियोजित होने जा रहा है, इसे देखने में बहुत उपयोग होता है vi-ca-vi run जिसमें एक है विकास पाइपलाइनों में एक स्टार होने का दोहरा उद्देश्य (जहां हम जरूरी नहीं कि एक पैकेज रखना चाहते हैं क्योंकि वेग बहुत अधिक होने पर इसका कोई मूल्य नहीं है)।

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

जैसा कि मैंने कहा, एक पूर्ण ब्रह्मांड में, एक स्थापित वस्तु के संस्करण का आत्मनिरीक्षण किया जाएगा। हालांकि यह मुझे एक विचार देता है।

अगर हम चार्ट को कैसे तैनात किया जाता है, इस बारे में मैंने जो कहा है, उसे ध्यान में रखते हैं, तो क्या होगा यदि हमारे पास helm describe पर ध्वज के साथ सभी उप-घटकों को अलग करने की क्षमता हो? यही कारण है कि एप्लिकेशन-संस्करण निर्दिष्ट करने की जरूरत का समाधान नहीं होता है, लेकिन यह इसे और अधिक स्पष्ट वास्तव में क्या स्थापित किया गया है (जो एक ध्वज के साथ एप्लिकेशन-संस्करण को समायोजित करने के लिए इच्छुक के पीछे असली ताकत का हिस्सा है) पड़ता है।

मैंने सभी टिप्पणियां पढ़ीं और इस मामले पर पूरी तरह से योग्य राय नहीं है।

मैं यहां आया क्योंकि मेरी कंपनी एक निजी हेल्म रिपोजिटरी रखती है और हमारे चार्ट का 9 0% मुख्य रूप से एक परिनियोजन है जिसमें एक कंटेनर स्पेक है। इन मामलों में, यदि हम छवि के टैग को सूचीबद्ध करने के लिए appVersion का उपयोग कर सकते हैं, तो हम एक चर की नकल करने से बचेंगे और हम इस संस्करण को helm version चलाते हुए देख पाएंगे।

इस धागे को पढ़ने के बाद, मुझे ऐसा लगता है कि यह एक सुविधा होगी, हालांकि यह वास्तव में एक अच्छी सुविधा होगी जिसका उपयोग मैं कभी भी विलय कर दूंगा।

अनुरोध के अनुसार, मैं दूसरों के देखने के लिए पिछले धागे से अपना अंतिम उत्तर शामिल करने जा रहा हूं

हम्म। जब आप appVersion को डॉकर टैग (एक तार्किक संघ) से बांधना शुरू करते हैं तो यह वह जगह है जहां चीजें एक-दूसरे के साथ विपरीत होने लगती हैं। यह वह जगह है जहां हमें परेशानी हो रही है, अर्थात देव परिदृश्य जिसका मैंने ऊपर उल्लेख किया है। चूँकि version एक SemVer होना चाहिए, इसलिए हम डॉकर टैग को चार्ट के रूप में उपयोग नहीं कर सकते हैं version ।

जब चार्ट पर appVersion स्पष्ट नहीं होता है तो हम डेवलपर्स के लिए एक दृश्य संस्करण अंतर कैसे बनाते हैं?

k8s इसके अनुप्रयोगों के साथ कैसे काम करता है, इसके कारण: एक देव दुनिया में, बोर्ड भर में टैग संस्करणों को अनुमति देने का कोई तरीका है।

यह ~ या ^ ऑपरेटरों के संदर्भ में सेमवर कैन जैसी चीजें नहीं कर सका, क्योंकि संस्करण को पूरी तरह से आदेश दिया गया था, बिना अर्थशास्त्र के।

क्यों नहीं? हम इसे हर समय php composer । हम SemVer का उपयोग कर सकते हैं या हम स्ट्रिंग संस्करणों का उपयोग कर सकते हैं जिन्हें केवल वर्जनिंग स्कीमा में पार्स या अनदेखा किया जाता है, अर्थात यदि version एक SemVer संख्या नहीं है, तो इसे ~ और ^ पैटर्न मिलान।

चूंकि आप #7299 पर मेरी टिप्पणी को उद्धृत कर रहे हैं, इसलिए मैं "यह नहीं कर सका" को "यह नहीं किया" (और शायद अभी भी नहीं) के रूप में स्पष्ट कर दूंगा।

.deb और .rpm संकुल के लिए, संस्करण स्ट्रिंग को विशिष्ट तरीकों (हाइफ़न द्वारा) में विभाजित किया गया है, लेकिन उनका कोई अर्थपूर्ण अर्थ नहीं है जैसे "यह एपीआई-उसके साथ संगत है" और इसलिए आप "दे" जैसी अभिव्यक्ति उत्पन्न नहीं कर सकते हैं me नवीनतम API-संगत संस्करण" या "मुझे एक अपरिवर्तित API के साथ नवीनतम संस्करण दें", जैसा कि आप SemVer के साथ कर सकते हैं।

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

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

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

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

जिस तरह से चार्ट को https://github.com/helm/charts/ में संस्करणित किया गया है, उससे मैं थोड़ा कम खुश हूं, क्योंकि वहां चार्ट का संस्करण है, सॉफ्टवेयर नहीं, जिससे कभी-कभार मामूली (स्थिर) चार्ट version अपडेट जो पश्चगामी संगतता को तोड़ते हैं । मुझे लगता है कि यह एक संभावित और मुश्किल से बचने वाला परिणाम है जब आप चार्ट के version को इसमें शामिल चीजों के संस्करण से अलग करते हैं।

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

@jrkarnes

यदि हम चार्ट को कैसे तैनात किया जाता है, इस बारे में मैंने जो कहा है, उसे ध्यान में रखते हैं, तो क्या होगा यदि हमारे पास सभी उप-घटकों को शीर्ष पर ध्वज के साथ प्रदर्शित करने की क्षमता है? यह ऐप-संस्करण को निर्दिष्ट करने की आवश्यकता को ठीक नहीं करता है, लेकिन यह इसे और अधिक स्पष्ट करता है कि वास्तव में क्या स्थापित किया गया है (जो ध्वज के साथ ऐप-संस्करण को समायोजित करने के पीछे ड्राइविंग बल का हिस्सा है)।

मुझे यह देखना बिल्कुल अच्छा लगेगा। उदाहरण के लिए #6932 पर एक संबंधित सुविधा अनुरोध है।

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

यह विचार कि ऐपवर्सन डॉकर छवि मेटाडेटा से संबंधित है, निश्चित रूप से हमारे उपयोग-मामले में फिट नहीं है, क्योंकि कम से कम हमारे कुछ चार्ट

मैं यह नहीं कह रहा हूं कि _the_ इच्छित उपयोग था। मैंने केवल इतना कहा कि यह एक तार्किक संघ है। आप अभी भी अपने आंतरिक यम के "तार्किक कंटेनर" के रूप में appVersion का उपयोग कर रहे हैं।

मैं अभी भी नहीं जानता कि कैसे version को SemVer में लॉक करने से कोई लाभ होता है। क्या हेलम केवल version (और appVersion ) का विश्लेषण कर सकता है और वहां से आगे बढ़ सकता है?

मुझे लगता है कि मेरा कहना था कि हम appVersion का उपयोग बिल्कुल नहीं कर रहे हैं, यह आमतौर पर हमारे चार्ट.yaml में मौजूद नहीं होता है, और जब यह मौजूद होता है, तो यह version के समान होता है।

version को SemVer में लॉक करने का लाभ यह है कि आप इस पर विभिन्न SemVer ऑपरेटरों का उपयोग कर सकते हैं, और इसे स्थापित करके ऑर्डरिंग और मिलान करने के लिए मज़बूती से पार्स कर सकते हैं।

RPM और DEB पैकेजिंग सिस्टम में एक ही बात है, सिवाय इसके कि उनके वर्जनिंग सिस्टम एक अलग सिंटैक्स का उपयोग करते हैं, लेकिन सिमेंटिक पार्सिंग कारणों के लिए अभी भी एक प्रतिबंधित सिंटैक्स है। उनके पास अलग-अलग शब्दार्थ भी हैं जिनकी वे परवाह करते हैं।

यह देखते हुए कि हेलम/चार्ट रेपो कैसे चलाया गया था, मुझे लगता है कि एक डीईबी या आरपीएम-शैली संस्करण के साथ एक version फ़ील्ड सेमवर प्लस appVersion स्ट्रिंग से बेहतर विकल्प होता। हालांकि, यह एक पूरी तरह से अलग, पहले से ही रवाना हुआ जहाज है। और मेरी युवावस्था में एक अपस्ट्रीम वेंडर और डेबियन पैकेजर दोनों होने के कारण, मैं इस बात की सराहना करता हूं कि "किस संस्करण संख्या को यहां टकराने की आवश्यकता है?" हमारे " version इज द वन ट्रुथ" पैकेज में।

"कभी-कभी यह SemVer है" के साथ समस्या यह है कि SemVer बहुत कुछ ऐसा

नमस्ते। इस फीचर के बारे में कोई खबर नहीं है।

सभी टिप्पणियों को पढ़ने के बाद, मैं देख सकता हूँ कि यह वास्तव में मददगार होगा।

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

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

चूंकि हेलम सूची में रिलीज की जानकारी प्रदर्शित होनी चाहिए, इसलिए हमें इस रिलीज के भीतर तैनात ऐप के संस्करण को देखने में सक्षम होना चाहिए।

मैंने इसी तरह के मुद्दे में टिप्पणी छोड़ दी https://github.com/helm/helm/issues/7517
क्या हम इसे value.yaml में ओवरराइड करने की क्षमता जोड़ सकते हैं?
फिर हमें मुफ्त में कमांड लाइन विकल्प मिलता है --set

अगर हम किसी भी एप्लिकेशन के लिए हेलम का उपयोग करने का प्रयास करते हैं तो यह बिल्कुल बेकार है। कोई भी उत्पादन अनुप्रयोगों के लिए सिमेंटिक वर्जनिंग का उपयोग नहीं करता है।

मैं सहमत हूँ। हम वर्तमान में अपरिवर्तनीय _application_ आधारित चार्ट के लिए चार्ट संग्रहालय का उपयोग करने के लिए अवरुद्ध हैं। चार्ट संस्करण! = ऐप संस्करण, चार्ट संग्रहालय के माध्यम से जारी करना हमारे लिए असंभव बना रहा है।

मैंने ऊपर चर्चा के एक समूह (सभी नहीं) के माध्यम से पढ़ा, इसलिए क्षमा करें यदि मैं कुछ बिंदुओं/विचारों को दोहरा रहा हूं। मैं एक अधिक सुविचारित प्रतिक्रिया को आगे बढ़ाने की कोशिश कर रहा हूं।

जब मैं helm ls करता हूं तो मुझे ऐपवर्सन देखना पसंद है और अवधारणात्मक रूप से .Values.image.tag से आगे बढ़ना एक अच्छा था लेकिन इसे परिनियोजन समय पर सेट करने में सक्षम नहीं होना एक वास्तविक शो स्टॉपर है और ऐसा कुछ है जो मेरे पास है वापस करने के लिए.

मैं दृढ़ हूं कि (चार्ट) version चार्ट का संस्करण है और appVersion डॉकर टैग है। हमारी सीआई प्रक्रिया में डॉकर टैग भी एक गिट टैग है।
हमारे पास कई माइक्रोसर्विसेज भी हैं और हम चीजों को यथासंभव डीआरवाई रखने की इच्छा रखते हैं। हमारे पास स्थानीय चार्ट रेपो में सामान्य चार्ट हैं क्योंकि जावा-स्प्रिंगबूट ऐप्स के विशाल थोक समान हैं। अधिकांश टॉमकैट ऐप्स समान हैं (लेकिन स्प्रिंगबूट वाले से अलग)। अन्य तकनीकों के लिए कुल्ला और दोहराएं। तब हमारे पास पर्यावरणीय मूल्य होते हैं क्योंकि परिनियोजन विभिन्न वातावरणों के माध्यम से अपना रास्ता बनाता है
इनमें से प्रत्येक माइक्रोसर्विसेज सीआई/सीडी के माध्यम से सामान्य चार्ट का उपयोग करता है
जैसे helm upgrade release-name private-repo/generic-chart --values <environment>.yaml --set image.tag=<docker tag from build step> --namespace <environment> --install मैं उपयोग करना चाहते हों .Chart.AppVersion बजाय .Values.image.tag , लेकिन मैं एक तरह से हमारे संगठन के लिए कुशल है कि में तैनात करने के लिए सक्षम होना चाहिए।

अगर मैं helm ls हूं तो मेरे पास CHART और APP VERSION इसलिए पूरे चार्ट संस्करण को ऐप संस्करण से मेल खाना चाहिए, वहीं इसके चेहरे पर फ्लैट हो जाता है। उस मार्ग को जारी रखने से लोग बस अलग-थलग पड़ जाएंगे और किसी बिंदु पर परियोजना को रोक दिया जाएगा क्योंकि वह मानसिकता बहुत सख्त है और न कि बहुत से लोग इसके पीछे हैं। यह " image.* , nameOverride और fullnameOverride . image.* को परिनियोजन.yaml आदि में हार्ड कोड किया जा सकता है" के मार्ग से नीचे जाना शुरू कर रहा है। बहुत समान कारणों से।

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

उपरोक्त सभी का नतीजा यह सवाल पूछता है कि "हेलम चार्ट रेपो का उपयोग क्यों कर सकता है?"।
इंस्टॉल / अपग्रेड समय पर appVersion को अधिलेखित करने में सक्षम नहीं होने का मतलब है कि आपको पहले से ही चार्ट को डाउनलोड और अनपैक करने की आवश्यकता है, appVersion प्रति इंस्टॉल/अपग्रेड संपादित करें, या आप आवश्यक डॉकटर कंटेनरों को पैकेज में भी डाल सकते हैं। चार्ट।
अपवाद वह है जहां पूरी तरह से मानक इंस्टॉल हो रहा है, और ऑटो जनरेटिंग पासवर्ड और इसी तरह के आसपास पहले से ही बहुत बहस है।
मुझे पता है कि आखिरी पैराग्राफ ऐसा लग रहा था जैसे मैं एक खरगोश के छेद के नीचे जा रहा था और खुद को एक कोने में चित्रित कर रहा था, लेकिन वह है जहां "ऐपवर्सन डॉकर टैग है और कमांड लाइन या मूल्यों के माध्यम से ऐपवर्सन सेट नहीं कर सकता" हमें ले जाता है।

@timothyclarke : आपके द्वारा यहां वर्णित helm upgrade उपयोग-मामले के लिए आप जो करना चाहते हैं, वह पहले helm package , जो आपको --version और --app-version सेट करने देता है। helm install टैरबॉल कर सकते हैं, और इसे सीआई आर्टिफैक्ट के रूप में रख सकते हैं, जो इंस्टॉल के लिए आपकी प्रजनन क्षमता को बढ़ाता है, क्योंकि इसमें किसी भी --set पैरामीटर जोड़ने की आवश्यकता नहीं होगी। हम इसी पर चले गए हैं, हालांकि "जेनेरिक-चार्ट" पहलू के बिना, क्योंकि हमारे चार्ट सामान्य नहीं हैं।

यह भी करने के लिए निर्माण मेटाडाटा को जोड़ने के लिए एक अच्छा मौका है Version , की तरह कुछ के साथ +g<shortCommitSHA> ।

प्रति #7517, जो मुझे sed कॉलों का एक गुच्छा निकालने देता है जो हमारे सीआई परीक्षण क्लस्टर पर स्थापित करने से पहले image.tag को फिर से लिख रहे थे, और फिर बाद में पैकेजिंग करते समय।

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

मेरे लिए, इंस्टॉल-समय पर ऐप-संस्करण (या संस्करण) को ओवरराइड करने का जोखिम यह है कि चार्ट को फिर से बनाने की कोशिश कर रहे किसी और के लिए यह स्पष्ट रूप से दिखाई नहीं दे रहा है, यह किया गया था। जब तक इसे किसी तरह से वैल्यू सपोर्ट में हैक नहीं किया जाता है, यह तब नहीं होगा जब कोई helm get values -o yaml का उपयोग करके चार्ट की वर्तमान कॉन्फ़िगरेशन को निकालता है, इसलिए यह _one more बात_ बन जाता है जो आपके लाइव चार्ट परिनियोजन को आपके द्वारा प्राप्त की गई चीज़ों से अलग बनाता है। helm install <some way to specify a particular package> --values <values from helm get values> , उदाहरण के लिए, परीक्षण सेटअप पर उत्पादन में देखी गई समस्या को पुन: उत्पन्न करने का प्रयास करते समय।

मेरे लिए, इंस्टॉल-समय पर ऐप-संस्करण (या संस्करण) को ओवरराइड करने का जोखिम यह है कि चार्ट को फिर से बनाने की कोशिश कर रहे किसी और के लिए यह स्पष्ट रूप से दिखाई नहीं दे रहा है, यह किया गया था। जब तक इसे किसी तरह वैल्यू सपोर्ट में हैक नहीं किया जाता है, यह तब नहीं होगा जब कोई helm get values -o yaml का उपयोग करके चार्ट की वर्तमान कॉन्फ़िगरेशन को निकालता है

तुमने सिर पर कील ठोक दी है। यह पहले दिन से values.yml में मधुमक्खी होनी चाहिए।

जबकि मैं इस विशेषता के खिलाफ दार्शनिक तर्कों को समझता हूं, क्षेत्र अभ्यास से पता चलता है कि इससे लोगों को बहुत मदद मिलेगी - जिसमें हम भी शामिल हैं।

जंगली में कई चार्ट हैं जो आपको ऐप के संस्करण को values.yml माध्यम से सेट करने देते हैं, खासकर क्योंकि इसे यहां सेट नहीं किया जा सकता है।

मुझे यकीन नहीं है कि इस पर चर्चा की गई है (एक त्वरित CTRL + F किया और कोई निशान नहीं मिला), लेकिन वैकल्पिक समाधान के रूप में appVersion सभी को एक साथ हटाने के बारे में क्या? मुझे ऐसा लगता है, कि यह पूरे भ्रम से बच जाएगा।

अभी appVersion को "विशेष" मान के रूप में माना जाता है। मुझे लगता है, कि यह दृश्यता प्रदान करने के लिए है, उदाहरण के लिए मेरे पास प्रोमेथियस का चार्ट संस्करण 123.5.6 हो सकता है, लेकिन इसमें ऐपवर्सन: 2.17.1 होगा, इसलिए मुझे पता है कि इसमें कौन सा सुरक्षा पैच संस्करण है और प्रोमेथियस क्या अपेक्षा करता है और मैं helm ls का उपयोग करके इसे देख सकते हैं।

मुझे लगता है कि इसे कुछ अलग तरीके से प्रदान किया जा सकता है। शायद रिलीज लेबल के माध्यम से? या शायद jsonPath सभी रिलीज पर क्वेरी, kubectl साथ क्या संभव है जैसे:

kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="ExternalIP")].address}'

फिर, उस के समर्थन को helm द्वारा लागू किए जाने के बजाय सर्वोत्तम प्रथाओं में स्थानांतरित कर दिया जाएगा। इसे भी लिटाया जा सकता है।

दूसरी ओर, यह हो सकता है कि बहुत से लोग appVersion मौजूदा कार्यान्वयन पर भरोसा करते हैं, इस पर भी विचार करने की आवश्यकता है।

हो सकता है कि एक कदम पीछे हटने और समझने से कि वास्तव में appVersion क्यों जोड़ा गया है, इस मुद्दे को हल करने में मदद करेगा?

@bokysan यह पहले values.yaml था इसे Chart.yaml में स्थानांतरित कर दिया गया था, मैं पूरे helm ls लिए अनुमान लगा रहा हूं कि इस तरह के कमांड चलाने के बजाय चार्ट और डॉकर टैग दोनों दिखा रहा है जैसा
kubectl get deployment <release name> -o jsonpath='{.spec.template.spec.containers[0].image}'

@TBBle मैं आपके प्रत्येक बिंदु को संबोधित

जैसे ही आपको initContainers और sidecars का उपयोग शुरू करने की आवश्यकता होती है, appVersion का पूरा आधार उसके चेहरे पर सपाट हो जाता है। वास्तविक दुनिया का उदाहरण देने के लिए मुझे वर्तमान में जिन परियोजनाओं को प्रबंधित करने की आवश्यकता है उनमें से एक में PHP साइडकार के साथ nginx है। Nginx और php टैग अक्सर नहीं बदलते हैं। कोड लिखने वाले डेवलपर्स के लिए PHP कंटेनर / संस्करण बहुत महत्वपूर्ण है। कंटेनर जो सबसे अधिक बार बदलता है वह initContainer जो सामग्री प्रदान करता है।
क्या मैं appVersion को initContainer , php कंटेनर में सेट करता हूं या यह nginx , और इनमें से केवल एक को चुनकर कौन सी जानकारी खो गई है?

यदि यह आपके उपयोगकर्ताओं के लिए महत्वपूर्ण है, तो यह निश्चित रूप से PHP संस्करण होना चाहिए? यही आप विज्ञापन कर रहे हैं। आप तीनों को अपने ऐप वर्जन में भी चिपका सकते हैं, यह एक फ्रीटेक्स्ट फ़ील्ड है।

यदि आप appVersion == कंटेनर छवि टैग को बाध्य करना चाहते हैं, तो आप गैर-तुच्छ चार्ट के साथ चुनौतीपूर्ण पाएंगे, यानी एक से अधिक कंटेनर वाले चार्ट, या बिना कंटेनर वाले। हालांकि यह वास्तव में इसका मुद्दा नहीं है, या यह imageVersion । यदि आप किसी एकल अपस्ट्रीम ऐप की पैकेजिंग कर रहे हैं, तो उसके संस्करण का उपयोग करें। यदि आप कई अपस्ट्रीम ऐप्स का पैकेज बना रहे हैं, तो एक चुनें, उदाहरण के लिए प्रोमेथियस-ऑपरेटर का चार्ट, या ऐपवर्सन को अनदेखा करें, क्योंकि यह एक वैकल्पिक फ़ील्ड है।

यदि आपका चार्ट स्रोत एप्लिकेशन का _भाग है, उदाहरण के लिए एगोन्स, तो बस appVersion खाली छोड़ दें, या यदि आपके पास इस पर निर्भर टूलिंग है तो इसे version से कॉपी करें।

इनमें से कोई भी चीज़ helm install -समय के निर्णय होने की आवश्यकता नहीं है। जैसा कि मैंने पहले उल्लेख किया है, helm package "तृतीय-पक्ष चार्ट के लिए इंस्टॉल समय पर एक अलग अपस्ट्रीम संस्करण को स्विच आउट करें" को छोड़कर सभी वर्कफ़्लो के लिए पर्याप्त देर हो चुकी है और यह --values या --set में होना चाहिए

ईमानदारी से, वास्तविक गायब विशेषता शायद " appVersion से tpl " पास करें, ताकि आप इसे .Values.image.tag या आपके लिए जो भी काम कर सकें, से पढ़ सकें।

यदि आप appVersion == कंटेनर छवि टैग को बाध्य करना चाहते हैं

तब हम शायद https://github.com/helm/helm/issues/7517 में हैं, शायद यही वह जगह है जहां से यह सब उपजा है।

मैं इस चर्चा को बिल्कुल नहीं समझता। लोगों को ऐप संस्करण का उपयोग करने का विकल्प इस तरह से क्यों नहीं देना जो उन्हें लगता है कि उनके लिए सबसे उपयुक्त है, इतना बड़ा मुद्दा है?

मेरे लिए एक मौजूदा रूप में यह APP VERSION बिल्कुल भी नहीं होना सबसे अच्छा होगा। यह हमारे प्रोजेक्ट में लोगों के बीच केवल भ्रम पैदा कर रहा है। हमारे पास>80 सेवाएं हैं जो एक ही हेलम चार्ट का उपयोग कर रही हैं और क्योंकि APP VERSION को helm upgrade -i ... आसानी से बदलना संभव नहीं है, मुझे लगता है कि हमारे सभी एप्लिकेशन हमेशा 1.0 साथ रहेंगे

मैं यह भी देखता हूं कि मुझे बस सभी से यह कहना है कि helm list उपयोग न करें क्योंकि यह उनके लिए उपयोगी नहीं होगा। यह जांचने के लिए कि उनके पास हमारे अनुप्रयोगों का कौन सा संस्करण है, उन्हें कुछ और उपयोग करने की आवश्यकता होगी।

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

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

यदि "चार्ट (संस्करण)" और "एपीपी संस्करण" बिल्ड-टाइम ("हेल्म पैकेज") पर बंधे हैं, तो दो अलग-अलग मान होने का पूरा लाभ कुछ हद तक खो गया है। चार्ट बनाने और चार्ट संस्करण को बढ़ाए/अपडेट किए बिना ऐप संस्करण को अपडेट करने से बड़ी परेशानी होगी क्योंकि एक ही चार्ट संस्करण आपको बहुत अलग परिणाम देगा। :-<

तो अभी के लिए हमें हर रिलीज के साथ पैकेज बनाने और "चार्ट (संस्करण)" और "एपीपी संस्करण" को एक पागल/अस्पष्ट स्थिति में चलाने के लिए सिंक में बढ़ाने के लिए मजबूर होना पड़ता है।

जैसा कि मैंने अभी सीखा, हम "एपीपी संस्करण" को छोड़ सकते हैं, क्योंकि यह वैकल्पिक है और कुछ कस्टम मूल्य का उपयोग नहीं करते हैं और हमारी छवि के लिए {{चार्ट.एपवर्सन}} के बजाय इसका उपयोग करते हैं .... लेकिन फिर helm list होगा कम जानकारीपूर्ण हो। :-<

उपयोगकर्ताओं (डेवलपर्स) के दृष्टिकोण से:

• स्थापित समय पर कुछ संस्करण संपत्ति/ध्वज/मूल्य सेट करने की क्षमता
• "XX संस्करण" लेबल के साथ हेलम सूची/इतिहास आउटपुट में उस संस्करण संपत्ति/ध्वज/मूल्य को देखने की क्षमता

कोई मौका हम इसे पूरा कर सकते हैं?

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

मुझे लगता है कि यह असंरेखण की जड़ है। ऐप संस्करण का लाभ जैसा कि मैं इसका उपयोग करता हूं, और जैसा कि वर्तमान सेटअप द्वारा अपेक्षित प्रतीत होता है, यह है कि आप उस चार्ट संस्करण_ के लिए लिपटे एप्लिकेशन के संस्करण को जानते हैं, क्योंकि चार्ट संस्करण पूरे चार्ट का संस्करण है, न कि चार्ट में टेम्प्लेट का संस्करण। अंत में जोड़ा गया "ओह, और ऐपवर्सन के साथ गड़बड़ न करें" की आवश्यकता के लिए मुझे "हमें हेल्म चार्ट के संस्करण ~ XY की आवश्यकता है" जैसे प्रत्येक कथन से नफरत होगी।

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

उपयोग-मामले के लिए @pniederlag वर्णन कर रहा है, appVersion एक टेम्पलेट होने में सक्षम होने के कारण जो मान प्रविष्टि पर इंगित करता है helm list वही करेगा जो वांछित है, जब तक कि चार्ट इसके होने का समर्थन करता है एप्लिकेशन संस्करण (शायद एक कंटेनर टैग) इंस्टॉल समय पर --set या --values हर दूसरे "इंस्टॉल समय पर बदला गया" कॉन्फ़िगरेशन विकल्प की तरह बदल गया।

यहां मुझे AppVersion साथ कोई समस्या मिली है।

हम रिलीज़ संस्करण और AppVersions दोनों का उपयोग कर रहे हैं।

उन्हें अभी सेट करने के लिए - मुझे helm package स्पष्ट रूप से helm upgrade --install से पहले कॉल करना होगा ताकि दोनों संस्करणों के सेट होने के साथ एक स्थानीय टार-आर्काइव बनाया जा सके।

अब मैं helm-secrets समर्थन जोड़ रहा हूं, और...
और यह रैपर helm package साथ काम नहीं कर सकता!

तो अब क्या?
हमारे सभी संस्करणों के समर्थन और प्रवाह को छोड़ दें?
सीक्रेट्स का उपयोग करके ड्रॉप करें?
कोई विचार?

वास्तव में यह helm-secrets लिए एक और समस्या है, लेकिन यह --set app-version क्षमता से भी संबंधित है, जिसकी चर्चा यहां भी की गई है, क्योंकि अगर मैं इसे इस तरह से उपयोग कर सकता हूं - मुझे helm package को कॉल करने की आवश्यकता नहीं है

UPD ओह, रुको... मैं अभी भी helm secrets upgrade chart.tgz -f secrets.yaml का उपयोग करने में सक्षम हूं ...
ठीक।
लेकिन फिर भी, --set app-version जोड़ने के लिए +1।

तो अब क्या?
हमारे सभी संस्करणों के समर्थन और प्रवाह को छोड़ दें?
सीक्रेट्स का उपयोग करके ड्रॉप करें?
कोई विचार?

हम दो पैकेज बनाते हैं: एक हेल्म पैकेज जिसमें सिर्फ चार्ट होते हैं, जिसमें env मान और सीक्रेट फाइल नहीं होती है। हम इस पैकेज का नाम बदलकर chart-{app-version}.tgz क्योंकि चार्ट-संस्करण का हमारे लिए कोई मतलब नहीं है, न ही चार्ट-संस्करण हमारे ऐप-संस्करण सिंटैक्स का समर्थन करता है। हमारे ऐप अपडेट में कोई भी संभावित चार्ट अपडेट (गिट टैगिंग का उपयोग करके समान रेपो) शामिल है।

फिर हमारे पास एक दूसरा tgz है जो पर्यावरण विशिष्ट है, chart-{app-version}-{env}.tgz जिसमें चार्ट tgz, मान yaml, और एन्क्रिप्टेड रहस्य फ़ाइल शामिल है। इस फ़ाइल में एक "package.yaml" भी शामिल है जिसमें helm-secrets का उपयोग करके परिनियोजित करने के लिए हमारी स्वचालित स्क्रिप्ट के लिए टैग, ऐप और पर्यावरण नाम जैसे मान शामिल हैं।

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

sed -i -E "s/^appVersion: (.*)/appVersion: ${deploy.project.version}/" ${chartPath}/Chart.yaml

यह मुश्किल है, लेकिन यह अपेक्षा के अनुरूप काम करता है।

@bvis
आपके समाधान के साथ समस्या यह है कि आपको चार्ट को अपनी CI/CD पाइपलाइन में संपादित करना होगा।
यदि आप एक केंद्रीकृत चार्ट रेपो का उपयोग करते हैं, तो आपको helm pull repo/chart --untar में मजबूर किया जाता है

चार्ट.yaml/appVersion प्रोग्रामेटिक रूप से इंजेक्शन लगाने के साथ कोई और प्रगति? क्या कोई उपाय हैं? यह सीआई/सीडी हेल्म में जबरदस्त बढ़ावा देगा।

@jakovistuk जहां तक ​​​​मैं कह सकता हूं, चार्ट जो कंटेनर संस्करण दिखाने के लिए ऐपवर्सन का उपयोग करते हैं, इसे सीधे चार्ट.यमल के माध्यम से करते हैं, जैसा कि उदाहरण के लिए nginx-ingress/Chart.yaml में देखा गया है ...

मैंने इस मुद्दे पर काफी समय से ज्यादा विचार नहीं किया है, इसलिए यह वास्तव में एक बेवकूफ सवाल हो सकता है, लेकिन क्या ऐपवर्सन को ओवरराइड करने के लिए हेल्म सीएलआई का उपयोग करने का कोई तरीका है?

ऐसा लगता है कि यहां बहुत से लोग 'ऐपवर्सन' फ़ील्ड को ओवरराइड करने का तरीका पूछ रहे हैं। इस मुद्दे में मूल मंशा/अनुरोध -एप-संस्करण को -वर्जन के प्रतिस्थापन के रूप में अनुमति देना है, ताकि उपयोगकर्ता 'हेल्म फ़ेच-ऐप-वर्जन = v0.15.0' चला सके और हेल्म यह पता लगाएगा कि नवीनतम चार्ट संस्करण क्या है एक ऐप वर्जन के रूप में निर्दिष्ट v0.15.0 और उसे प्राप्त करें।

हमारे प्रोजेक्ट/चार्ट (सर्टिफिकेट-मैनेजर) में हम इसे अंतिम उपयोगकर्ताओं के लिए जितना संभव हो सके स्पष्ट करना चाहते हैं कि वे कौन सा संस्करण इंस्टॉल कर रहे हैं, इसलिए उन्हें चार्ट संस्करण के बजाय ऐप संस्करण द्वारा इंस्टॉल करने की अनुमति देना कहीं अधिक प्राकृतिक इंस्टॉलेशन अनुभव होगा।

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

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

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

जब तक यह हल नहीं हो जाता (या नहीं) यहां बताया गया है कि मैंने इसे अपने सीआई/सीडी (गिटलैब) में कैसे हल किया:

ऐप-संस्करण के साथ चार्ट को पैकेज करें, फिर उसे परिनियोजित करें।
मुझे पता है कि चार्ट संस्करण ऐप वर्जन के समान नहीं है, लेकिन हमारे मामले में यह वर्कअराउंड के रूप में ठीक है।

deploy:
  image: alpine/helm:3.2.4
  stage: deploy
  environment:
    name: ${ENV}
  script:
    - helm package --app-version=${CI_COMMIT_TAG} --version=${CI_COMMIT_TAG} ${NAMESPACE}
    -  | 
       helm upgrade -i --wait ${CI_PROJECT_NAME} ./${NAMESPACE}-${CI_COMMIT_TAG}.tgz \
       --set image.repository="${CI_REGISTRY_IMAGE}" \
       --set image.tag="${CI_COMMIT_TAG}" \
       --set-string ingress.enabled="${INGRESS}" \
       --set service.port="${CONTAINER_PORT}" \
       --set service.targetPort="${CONTAINER_PORT}" \
       --set dc="${CI_ENVIRONMENT_NAME}" \
       --set project="${CI_PROJECT_NAME}" \
       --namespace ${NAMESPACE}
    - helm history ${CI_PROJECT_NAME} -n ${NAMESPACE}
  tags:
    - kubernetes
  only:
    - tags

यदि आप अपने image.tag से {{ .Chart.AppVersion }} तक डिफॉल्ट करते हैं तो आपको इंस्टॉल के दौरान इसे --set आवश्यकता नहीं होगी, यह पहले से ही सही होगा। यह ऑटो-बिल्ड के लिए भी अच्छी तरह से काम करता है, जब आपकी डॉकर छवियों को SHA1 के साथ टैग किया जाता है, इसलिए ऐपवर्जन डॉकर छवि टैग से मेल खाता है, और संस्करण एक ऑटो-बिल्ड सेमवर है।

यदि आपका AppVersion SemVer होता है, तो संस्करण AppVersion के समान होने में कोई समस्या नहीं है।

मेरी टीम द्वारा निर्मित पैकेजों के लिए, हम उन चीजों की ओर बढ़ रहे हैं जो AppVersion की तलाश में हैं, उदाहरण के लिए image.tag, यदि AppVersion सेट नहीं है, तो संस्करण के लिए डिफ़ॉल्ट। यह बहुत बड़ा अंतर नहीं है, टैग की गई रिलीज़ के लिए helm package लिए केवल एक कम तर्क, लेकिन केवल तभी समझ में आता है जब आपका चार्ट उसी SCM से बनाया गया हो जिस चीज़ की आप पैकेजिंग कर रहे हैं।

@TBBle यह काम नहीं करेगा यदि आप अपना छवि टैग सेट करने के लिए उप-चार्ट का उपयोग कर रहे हैं

क्या आपका मतलब है कि image.tag सबचार्ट में है, लेकिन आप पैरेंट चार्ट के संस्करण का उपयोग करने का प्रयास कर रहे हैं? यदि हां, तो यह बहुत अजीब है, और इसे प्रबंधित करना आसान नहीं होगा। मैंने अभी-अभी इस लेआउट को https://github.com/googleforgames/open-match/ के हेल्म चार्ट में बाउंस किया है। मेरा सुझाव है कि इस मामले में उप-चार्ट को मुख्य चार्ट में वापस रोल करें।

चार्ट स्वतंत्र रूप से पृथक/प्रयोग करने योग्य इकाइयाँ होने चाहिए, कार्य करने के लिए पैरेंट-चार्ट व्यवहार पर निर्भर नहीं होना चाहिए। उपचार्ट का अपना संस्करण है, _that_ वह है जिसे इसकी छवियों का उपयोग करना चाहिए, अन्यथा, यह एक उपचार्ट क्यों है?

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

या शायद मैंने आपके द्वारा किए जा रहे अवलोकन को गलत समझा है।

@haimari दुर्भाग्य से, यह काम नहीं कर रहा है (https://github.com/helm/helm/issues/6921 से संबंधित?):

> helm package $DIR/deployment/chart --app-version="1111e8" --version="3454e5" --namespace stage
Error: Invalid Semantic Version

लेकिन, यह काम करता है:

> helm package $DIR/deployment/chart --app-version="0.0.0-1111e8" --version="0.0.0-3454e5" --namespace stage
Successfully packaged chart and saved it to: /Users/aws/service-0.0.0-3454e5.tgz

और यह भी (लेकिन गंदा लगता है):

> helm package $DIR/deployment/chart --app-version="0-1111e8" --version="0-3454e5" --namespace stage
Successfully packaged chart and saved it to: /Users/aws/service-0-3454e5.tgz

पतवार संस्करण संस्करण। BuildInfo {संस्करण: "v3.4.0", GitCommit: "7090a89efc8a18f3d8178bf47d2462450349a004", GitTreeState: "डर्टी", GoVersion: "go1.15.3"}

मुझे लगता है कि @haimari का समाधान केवल इसलिए काम करता है क्योंकि वे अपनी सीआई पाइपलाइन में सेवर-संगत टैग का उपयोग करते हैं (यानी यह टैग किए गए रिलीज के लिए नौकरी चलाने के लिए एक उदाहरण होगा, प्रत्येक प्रतिबद्धता पर नहीं चलाया जाएगा)

@ a0s : मैं आम तौर पर सुझाव देता हूं:

helm package $DIR/deployment/chart --app-version="<container image tag>" --version="<semver version>"

और फिर अपने कंटेनर छवि टैग का मूल्य {{ Values.image.tag | default .Chart.AppVersion | default .Chart.Version जैसा कुछ होना चाहिए, ताकि आपको इसे ऑन-द-फ्लाई बदलने की आवश्यकता न हो, जैसा कि @haimari करता है।

आपके उदाहरणों में आपके पास दो अलग-अलग गिट संस्करण प्रतीत होते हैं, क्या यह सही है? क्या एक कंटेनर छवि के लिए है, और एक चार्ट के लिए है?

SemVer के साथ, आप वास्तव में git कमिट SHA को सेवर के सार्थक हिस्से में नहीं डाल सकते हैं, क्योंकि semver का मतलब ऑर्डर करना है, और git कमिट SHAs सॉर्ट करने योग्य नहीं हैं।

तो आप 0.0.1-alpha.<build-id>+g<gitcommitsha> जैसे कुछ संस्करण का उपयोग करना चाहेंगे जहां <build-id> आपके सीआई सिस्टम से पाइपलाइन या जॉब आईडी की तरह है, इसलिए यह हमेशा ऊपर जा रहा है कि आप अपनी परियोजना के लिए प्रतिबद्ध हैं। इस तरह जब आप मांगते हैं तो आपको हमेशा नवीनतम बिल्ड मिलता है।

SemVer में, - का उपयोग करने का अर्थ है कि यह उस संस्करण के लिए एक पूर्व-रिलीज़ है, इसलिए 0.0.1-<anything> 0.0.0 और 0.0.1 रिलीज़ के बीच आता है। + बाद का हिस्सा बिल्ड-इन्फो है, और इसे सॉर्ट करने के लिए अनदेखा किया जाता है, इसलिए गिट एसएचए या शाखा नाम या अन्य गैर-क्रमबद्ध ट्रैकिंग जानकारी डालने के लिए एक अच्छी जगह है।

तो आपने यहां जो उपयोग किया है, उसके साथ 0-3454e5 अगली प्रतिबद्धता की तुलना में नया प्रतीत होगा, यदि इसका SHA 2 से शुरू होता है, उदाहरण के लिए, 0-2764e1 ।

आपके उदाहरणों में आपके पास दो अलग-अलग गिट संस्करण प्रतीत होते हैं, क्या यह सही है? क्या एक कंटेनर छवि के लिए है, और एक चार्ट के लिए है?

हां, ऐप और चार्ट - सॉफ्टवेयर के दो स्वतंत्र टुकड़े हैं।

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

क्या होगा अगर मैं नहीं चाहता (और यहां तक ​​​​कि कल्पना भी नहीं कर सकता) नवीनतम के लिए पूछें।

0.0.1-alpha.<build-id>+g<gitcommitsha>

यह स्ट्रिंग (प्रक्षेप के बाद) मानक helm list आउटपुट के एक कॉलम में फ़िट होने के लिए बहुत लंबा लगता है :)

मैं हमेशा जानता हूं कि ऐप का कौन सा संस्करण (शा हैश) मैं इंस्टॉल करना चाहता हूं (इसे --set args के साथ पास करें)। और मैं हमेशा जानता हूं कि मैं चार्ट के किस संस्करण का उपयोग करता हूं (जैसा कि git checkout chart && helm pack && helm upgrade .tar.gz का उपयोग करूंगा)

क्या गलत जा सकता है?
1) नियमित helm upgrade दौरान एक त्रुटि। ठीक है, मैं त्रुटि को ठीक कर दूंगा और फिर से कोशिश करूंगा (ऐप की एक और शा कमिट के साथ - 99%) (या इसके बजाय --atomic का उपयोग करके)
2) मैनुअल रोलिंग बैक: helm rollback <RELEASE_NAME> या सीआई/सीडी के माध्यम से पिछले शा प्रतिबद्ध तैनाती।

मुझे क्या याद आया?

पीएस ईमानदारी से, मैं केवल जानकारी के उद्देश्य के लिए संस्करण और ऐप-संस्करण में लघु शा भाग का उपयोग करना चाहता हूं ( helm list )

यदि यह केवल सूचना के उद्देश्यों के लिए है, तो यह + के बाद एक SemVer में जाता है, न कि - । यदि आप रिलीज के आदेश, या किसी को हेल्म चार्ट वितरित करने के बारे में परवाह नहीं करते हैं, और आपका चार्ट या ऐप पहले से ही सेमवर्ड नहीं है, तो 0+g<commitsha> एक वैध सेमवर है (0.0.0 के बराबर)।

ओपन मैच के हेल्म ऑटो-बिल्ट चार्ट यही करते हैं, उदाहरण के लिए; वे सभी वर्तमान में 0.0.0-dev , और हमने उस 0.0.0-dev+g<commitsha> को बनाना शुरू कर