https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/imaxe.cloud टीम के इंजीनियरिंग नोट्स, सूची की नई सुविधाएं और व्यावहारिक मार्गदर्शिकाएं।2026-08-22T15:25:49Z© 2026 imaxe.cloudHugoimaxe टीमhttps://www.imaxe.cloud/https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/%E0%A4%A1%E0%A4%BF%E0%A4%AB%E0%A4%BC%E0%A5%89%E0%A4%B2%E0%A5%8D%E0%A4%9F-arm64/2026-08-04T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/arm64-por-defecto_hu_99c180b1a81b7f6a.webp" alt="प्रोसेसर के सिलिकॉन का सूक्ष्मदर्शी विवरण" width="1200" height="675"></p><p>हर AMI किसी एक विशिष्ट CPU आर्किटेक्चर के लिए बनती है: x86_64 (Intel या AMD) या ARM64 (aarch64, यानी AWS Graviton और समकक्षों वाली)। ऐसी कोई इमेज नहीं होती जो «दोनों के लिए चले»: ये अलग-अलग बाइनरी हैं। इसलिए अपना कैटलॉग तैयार करते समय हमें तय करना था कि डिफ़ॉल्ट विकल्प कौन सा होगा।</p> <p>हमने लागत, प्रदर्शन, दक्षता, इकोसिस्टम की परिपक्वता और बाज़ार की दिशा देखी। निष्कर्ष साफ़ था: <strong>आज अधिकांश वर्कलोड के लिए ARM64 सबसे अच्छा दाँव है।</strong> और हम अपनी इमेज इसी तरह बनाते हैं।</p> <h2 id="arm64-जयदतर-क-लए-कय-जतत-ह">ARM64 ज़्यादातर के लिए क्यों जीतता है</h2> <h3 id="1-बहतर-मलय-परदरशन">1. बेहतर मूल्य-प्रदर्शन</h3> <p>यही निर्णायक तर्क है। ARM (Graviton) इंस्टेंस लगातार अपने x86 समकक्षों से <strong>हर यूरो पर ज़्यादा प्रदर्शन</strong> देते हैं — वेब, API, माइक्रोसर्विस, कंटेनर, डेटाबेस और क़तारों जैसे व्यापक वर्कलोड में। व्यवहार में ARM पर जाने का मतलब आमतौर पर कंप्यूट लागत में <strong>20 % से 40 %</strong> की बचत होता है। महँगे होते क्लाउड में यह अंतर नज़रअंदाज़ करने लायक़ नहीं।</p> <h3 id="2-जयद-दकषत-कम-बजल">2. ज़्यादा दक्षता, कम बिजली</h3> <p>ARM प्रोसेसर शुरू से ही खपत को अनुकूलित करते हुए बने। इसका मतलब है प्रति वाट ज़्यादा काम, कम ऊर्जा लागत और प्रति कंप्यूट इकाई <strong>कम कार्बन फ़ुटप्रिंट</strong>। अगर स्थिरता आपके —या आपके ग्राहकों के— लक्ष्यों में है, तो ARM आपके पक्ष में खेलता है।</p> <h3 id="3-इकससटम-अब-परपकव-ह">3. इकोसिस्टम अब परिपक्व है</h3> <p>कुछ साल पहले «क्या इसका ARM संस्करण होगा?» एक जायज़ सवाल था। आज सर्वर सॉफ़्टवेयर का विशाल बहुमत —ऑपरेटिंग सिस्टम, भाषाएँ, रनटाइम, डेटाबेस, लोकप्रिय कंटेनर इमेज— प्रथम श्रेणी का ARM64 समर्थन रखता है। संगतता अपवाद से हटकर नियम बन चुकी है।</p> <h3 id="4-वह-सरकष-वह-परचलन-मडल">4. वही सुरक्षा, वही परिचालन मॉडल</h3> <p>आर्किटेक्चर बदलने से आपका काम करने का तरीक़ा नहीं बदलता: कॉन्फ़िगरेशन, हार्डनिंग, cloud-init, आपके प्रोविज़निंग स्क्रिप्ट और पाइपलाइन वही रहते हैं। ARM64 आपसे आपकी परिचालन प्रक्रिया या सुरक्षा मुद्रा में कुछ छोड़ने को नहीं कहता।</p> <h2 id="एक-तलक-म-तलन">एक तालिका में तुलना</h2> <table> <thead> <tr> <th>मानदंड</th> <th>ARM64 (Graviton)</th> <th>x86_64 (Intel/AMD)</th> </tr> </thead> <tbody> <tr> <td>मूल्य-प्रदर्शन</td> <td>अधिकांश वर्कलोड में बेहतर</td> <td>अच्छा, पर प्रति इकाई महँगा</td> </tr> <tr> <td>ऊर्जा दक्षता</td> <td>बहुत ऊँची</td> <td>कम</td> </tr> <tr> <td>सॉफ़्टवेयर संगतता</td> <td>आज उत्कृष्ट और व्यापक</td> <td>अधिकतम, सार्वभौमिक</td> </tr> <tr> <td>पुराने प्रोप्राइटरी बाइनरी</td> <td>कभी-कभी ARM संस्करण नहीं</td> <td>पूर्ण समर्थन</td> </tr> <tr> <td>बाज़ार की दिशा</td> <td>बढ़ती और रणनीतिक</td> <td>स्थापित</td> </tr> <tr> <td>सामान्य लागत</td> <td>कम: 20 % से 40 % के बीच</td> <td>अधिक</td> </tr> </tbody> </table> <p><em>आधुनिक वर्कलोड के लिए ARM64 वहीं जीतता है जहाँ सबसे ज़्यादा फ़र्क़ पड़ता है: लागत, दक्षता और भविष्य।</em></p> <h2 id="x86_64-कब-भ-समझदर-ह">x86_64 कब भी समझदारी है</h2> <p>ईमानदारी अच्छे चुनाव का हिस्सा है। कुछ मामलों में x86_64 ही सही विकल्प रहता है, और हम नहीं चाहते कि कोई ऐसा माइग्रेशन थोपे जो ज़िंदगी मुश्किल कर दे:</p> <ul> <li><strong>प्रोप्राइटरी सॉफ़्टवेयर या बाइनरी</strong> जो केवल x86 के लिए कंपाइल मिलते हैं।</li> <li><strong>नेटिव डिपेंडेंसी</strong> —कंपाइल किए गए एक्सटेंशन— जिनका ARM बिल्ड उपलब्ध नहीं।</li> <li>x86 से बँधे <strong>लीगेसी टूल</strong> या तृतीय-पक्ष एकीकरण।</li> <li>x86 निर्देशों के लिए हाथ से अनुकूलित <strong>बहुत विशिष्ट वर्कलोड</strong>।</li> </ul> <h2 id="हमर-फसल-डफलट-arm64-मगन-पर-x86_64">हमारा फ़ैसला: डिफ़ॉल्ट ARM64, माँगने पर x86_64</h2> <p>इन्हीं वजहों से <strong>हमारी AMI डिफ़ॉल्ट रूप से ARM64 पर बनती हैं।</strong> हमें लगता है कि यही अधिकांश के लिए सबसे ज़्यादा मूल्य देता है: उसी काम के लिए कम पैसा, कम बिजली, और वह आर्किटेक्चर जो क्लाउड की दिशा तय कर रहा है।</p> <p>पर हम जानते हैं कि हर वर्कलोड इसमें फ़िट नहीं बैठती। इसीलिए, <strong>अगर आपको x86_64 चाहिए तो बस कहिए: हम आपके लिए कस्टम इमेज तैयार करते हैं</strong> — वही कॉन्फ़िगरेशन, वही हार्डनिंग, वही गुणवत्ता, बस x86_64 के लिए बनी हुई। वही उत्पाद, वही आधार, आर्किटेक्चर आपके केस के अनुसार।</p> <h2 id="30-सकड-म-कस-तय-कर">30 सेकंड में कैसे तय करें</h2> <ul> <li>आधुनिक स्टैक —वेब, API, कंटेनर, व्याख्यायित भाषाएँ, सामान्य डेटाबेस—: बिना झिझक <strong>ARM64</strong>।</li> <li>कोई प्रोप्राइटरी बाइनरी या ऐसी डिपेंडेंसी है जो सिर्फ़ x86 पर चलती है? <strong>हमसे x86_64 वैरिएंट माँगिए।</strong></li> <li>तय नहीं कर पा रहे? ARM64 से शुरू कीजिए और आज़माइए; कुछ न जमे तो हम x86_64 बना देंगे, बस।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>आपकी AMI ARM64 हैं या x86_64?</strong></p> <p>डिफ़ॉल्ट रूप से हम उन्हें ARM64 (Graviton) पर बनाते हैं, क्योंकि अधिकांश वर्कलोड के लिए यही सबसे अच्छा मूल्य-प्रदर्शन देता है। x86_64 चाहिए तो उसी कॉन्फ़िगरेशन और गुणवत्ता के साथ कस्टम बना देते हैं।</p> <p><strong>ARM64 इस्तेमाल करने के लिए क्या मुझे एप्लिकेशन बदलना होगा?</strong></p> <p>ज़्यादातर मामलों में नहीं। व्याख्यायित भाषाएँ और आधुनिक सॉफ़्टवेयर ARM पर बिना बदलाव चलते हैं। दिक़्क़त सिर्फ़ प्रोप्राइटरी बाइनरी या बिना ARM संस्करण की नेटिव डिपेंडेंसी से आती है; ऐसे मामलों में हम x86_64 वैरिएंट देते हैं।</p> <p><strong>कस्टम x86_64 इमेज कैसे माँगूँ?</strong></p> <p>बस अनुरोध कीजिए। हम उसी आधार और उसी हार्डनिंग से शुरू कर इमेज को x86_64 के लिए बनाते हैं, ताकि आपको वही उत्पाद ठीक उसी आर्किटेक्चर पर मिले जिसकी ज़रूरत है।</p> <p><strong>क्या ARM64 से सचमुच बचत होगी?</strong></p> <p>उपयुक्त वर्कलोड के लिए कंप्यूट लागत में 20 % से 40 % की बचत आम है, साथ में बिजली की खपत भी कम। अपने केस के लिए पुष्टि का तरीक़ा है अपनी वर्कलोड चलाकर तुलना करना।</p> <p><em>imaxe.cloud में हम ARM64 पर दाँव लगाते हैं क्योंकि हमें लगता है कि यह आपके बिल, आपके प्रदर्शन और इस ग्रह — तीनों के लिए बेहतर है। और अगर आपको x86_64 चाहिए, तो बस कहिए: हम कस्टम बना देंगे।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/ami-%E0%A4%86%E0%A4%95%E0%A4%BE%E0%A4%B0-%E0%A4%94%E0%A4%B0-%E0%A4%AC%E0%A5%82%E0%A4%9F-%E0%A4%85%E0%A4%A8%E0%A5%81%E0%A4%95%E0%A5%82%E0%A4%B2%E0%A4%A8/2026-07-31T00:00:00Z2026-08-22T15:25:49Z

फूली हुई इमेज धीरे बूट होती है, स्टोर करने में महँगी पड़ती है और अटैक सरफ़ेस बढ़ा देती है। AMI को दुबला करना और बूट तेज़ करना एक ही झटके में आपका ऑटोस्केलिंग, बिल और सुरक्षा सुधारता है। तरीक़ा यह रहा।

<p><img src="https://www.imaxe.cloud/blog-covers/optimizar-tamano-arranque-ami_hu_69b1788d3fbcbc6c.webp" alt="काली पृष्ठभूमि पर जेबी स्टॉपवॉच" width="1200" height="675"></p><p>इमेज का आकार और बूट समय तकनीकी ब्योरा लगते हैं, पर ये उन तीन चीज़ों पर असर डालते हैं जो कारोबार के लिए मायने रखती हैं: <strong>ऑटोस्केलिंग की गति</strong> —किसी उछाल का जवाब देने में कितना समय लगता है—, <strong>लागत</strong> —स्टोरेज और बूट के इंतज़ार में ख़ाली बैठी कंप्यूट— और <strong>सुरक्षा</strong>: कम सॉफ़्टवेयर यानी कम अटैक सरफ़ेस।</p> <p>दुबली और तेज़ इमेज लगभग हमेशा बेहतर इमेज होती है।</p> <h2 id="इमज-दबल-कर-कम-ह-जयद-ह">इमेज दुबली करें: कम ही ज़्यादा है</h2> <ul> <li><strong>न्यूनतम आधार से शुरू करें</strong>: पूर्ण इंस्टॉलेशन के बजाय ऑपरेटिंग सिस्टम के <em>minimal</em> संस्करण लें।</li> <li><strong>सिर्फ़ ज़रूरी इंस्टॉल करें</strong>: हर अतिरिक्त पैकेज वज़न, रखरखाव और अटैक सरफ़ेस है।</li> <li><strong>बिल्ड के बाद सफ़ाई करें</strong>: सील करने से पहले पैकेज कैश (<code>dnf clean all</code>, <code>apt-get clean</code>), लॉग, दस्तावेज़ और अस्थायी फ़ाइलें हटाएँ।</li> <li><strong>बिल्ड टूल हटाएँ</strong>: अगर कुछ कंपाइल किया है, तो कंपाइलर और डेवलपमेंट डिपेंडेंसी निकाल दें।</li> <li><strong>वॉल्यूम का आकार देखें</strong>: सॉफ़्टवेयर 8 GB का हो तो 100 GB की डिस्क क्यों ढोएँ।</li> </ul> <h2 id="बट-तज-कर">बूट तेज़ करें</h2> <ul> <li><strong>बेक करें, बूट पर इंस्टॉल नहीं</strong>: user-data में जो भी इंस्टॉल करेंगे वह बूट समय है; उसे इमेज में ले जाइए।</li> <li><strong>शुरुआत में न्यूनतम सेवाएँ</strong>: पहले बूट पर जिसकी ज़रूरत न हो, उसे बंद रखें।</li> <li><strong>डिपेंडेंसी प्रीलोड करें</strong>: ड्राइवर, रनटाइम और बेस कंटेनर पहले से मौजूद हों तो शुरुआती डाउनलोड बच जाते हैं।</li> <li><strong>cloud-init अनुकूलित करें</strong>: छोटा और आइडेम्पोटेंट user-data जल्दी बूट होता है।</li> <li><strong>स्नैपशॉट और प्रोविज़निंग</strong>: वॉल्यूम को तेज़ी से भरने के लिए क्लाउड के विकल्पों का लाभ लें।</li> </ul> <h2 id="असर-आकड-म">असर, आँकड़ों में</h2> <table> <thead> <tr> <th>साधन</th> <th>ऑटोस्केलिंग पर असर</th> <th>लागत और सुरक्षा पर असर</th> </tr> </thead> <tbody> <tr> <td>छोटी इमेज</td> <td>कॉपी और लॉन्च तेज़</td> <td>स्नैपशॉट लागत कम, CVE कम</td> </tr> <tr> <td>तेज़ बूट</td> <td>उछाल का जवाब जल्दी</td> <td>बिना सेवा दिए चुकाई कंप्यूट कम</td> </tr> <tr> <td>कम पैकेज</td> <td>लोड और आरंभ करने को कम</td> <td>घटी हुई अटैक सरफ़ेस</td> </tr> </tbody> </table> <p><em>इमेज का अनुकूलन एक साथ प्रदर्शन, लागत और सुरक्षा सुधारता है।</em></p> <h2 id="जररत-स-जयद-बरक-न-लगए">ज़रूरत से ज़्यादा ब्रेक न लगाएँ</h2> <p>अनुकूलन का मतलब अंग-भंग नहीं। ज़रूरत से ज़्यादा हटाने पर सूक्ष्म डिपेंडेंसी टूट सकती हैं या डिबगिंग मुश्किल हो सकती है। सही अनुशासन: आकार और बूट समय को पाइपलाइन का हिस्सा बनाकर मापें, विवेक से काटें, हमेशा स्टेजिंग में जाँचें और लिखें कि क्या हटाया और क्यों। इन मीट्रिक को इमेज की गुणवत्ता का संकेतक मानिए, सनक नहीं।</p> <h2 id="अनकलन-चकलसट">अनुकूलन चेकलिस्ट</h2> <ul> <li>ऑपरेटिंग सिस्टम का न्यूनतम आधार।</li> <li>केवल अनिवार्य पैकेज।</li> <li>सील करने से पहले कैश, लॉग और अस्थायी फ़ाइलों की सफ़ाई।</li> <li>अंतिम इमेज में कोई कंपाइलेशन टूल नहीं।</li> <li>छोटा user-data; भारी सामान इमेज में बेक।</li> <li>वॉल्यूम का आकार वास्तविक ज़रूरत के अनुरूप।</li> <li>पाइपलाइन में आकार और बूट के मीट्रिक।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>इमेज अनुकूलित करके बूट कितना तेज़ हो सकता है?</strong></p> <p>शुरुआती स्थिति पर निर्भर है, पर user-data से इंस्टॉलेशन इमेज में ले जाना और शुरुआती सेवाएँ घटाना आम तौर पर बूट को काफ़ी छोटा कर देता है, जिससे ऑटोस्केलिंग की प्रतिक्रिया सीधे बेहतर होती है।</p> <p><strong>क्या छोटी इमेज ज़्यादा सुरक्षित होती है?</strong></p> <p>आम तौर पर हाँ: कम इंस्टॉल सॉफ़्टवेयर यानी कम संभावित भेद्यताएँ और छोटी अटैक सरफ़ेस, साथ ही ऑडिट करना आसान।</p> <p><strong>क्या न्यूनतम OS इस्तेमाल करना सार्थक है?</strong></p> <p>अधिकांश सर्वर वर्कलोड के लिए हाँ: जल्दी बूट होता है, कम जगह लेता है और ज़्यादा सुरक्षित है। बस इतना न घटाइए कि निदान कठिन हो जाए या सचमुच ज़रूरी डिपेंडेंसी टूट जाएँ।</p> <p><em>imaxe.cloud में हम ध्यान रखते हैं कि हमारी इमेज हल्की, जल्दी बूट होने वाली और आसानी से संभालने योग्य हों।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/ai-gpu-%E0%A4%87%E0%A4%AE%E0%A5%87%E0%A4%9C-2026/2026-07-28T00:00:00Z2026-08-22T15:25:49Z

GPU पर AI का माहौल हाथ से खड़ा करना ड्राइवरों, CUDA संस्करणों और आपस में न बैठने वाले फ़्रेमवर्क का मेला है। अच्छी तरह तैयार GPU इमेज आपके कई दिन बचा देती है। 2026 में AI की AMI में क्या होना चाहिए, यह रहा।

<p><img src="https://www.imaxe.cloud/blog-covers/imagenes-ia-gpu-2026_hu_57244b43363ee40d.webp" alt="हीटसिंक और पंखों वाला ग्राफ़िक्स कार्ड" width="1200" height="675"></p><p>प्रोडक्शन में AI के 2026 का बड़ा विषय बनने के साथ, ज़्यादा से ज़्यादा टीमें मॉडल प्रशिक्षित करने और इन्फ़रेंस चलाने के लिए GPU इंस्टेंस चला रही हैं। पर GPU अकेले काम नहीं करता: उसे एक बहुत विशिष्ट सॉफ़्टवेयर स्टैक चाहिए —<strong>NVIDIA ड्राइवर, CUDA, cuDNN, फ़्रेमवर्क</strong>— जिनके संस्करण आपस में बैठने चाहिए। हर इंस्टेंस पर यह सब हाथ से तैयार करना धीमा और नाज़ुक है।</p> <p>इसीलिए <strong>GPU के लिए तैयार इमेज</strong> का मोल है: वह उस सत्यापित स्टैक को एक बार समेट लेती है और काम के लिए तैयार बूट होती है।</p> <h2 id="ai-क-ami-म-कय-हन-चहए">AI की AMI में क्या होना चाहिए</h2> <ul> <li>लक्षित GPU के अनुकूल <strong>NVIDIA ड्राइवर</strong>, जैसे त्वरित इंस्टेंस परिवारों वाले।</li> <li>आप जिन फ़्रेमवर्क का उपयोग करेंगे उनसे संरेखित संस्करणों में <strong>CUDA और cuDNN</strong>।</li> <li>PyTorch या TensorFlow जैसे <strong>फ़्रेमवर्क</strong>, या बेहतर हो तो उन्हें कंटेनर में चलाने के लिए <strong>NVIDIA Container Toolkit</strong>।</li> <li>पहले से इंस्टॉल <strong>MLOps औज़ार</strong> और GPU निगरानी, जैसे DCGM।</li> <li><strong>बूट अनुकूलन</strong>: पहले से लोड ड्राइवर, ताकि हर लॉन्च में मिनट —और GPU का पैसा— न गँवाएँ।</li> </ul> <h2 id="खद-बनए-य-तयर-इमज-ल">ख़ुद बनाएँ या तैयार इमेज लें</h2> <table> <thead> <tr> <th>विकल्प</th> <th>लाभ</th> <th>बदले में</th> </tr> </thead> <tbody> <tr> <td>आधिकारिक GPU इमेज (NVIDIA GPU-Optimized, Deep Learning)</td> <td>सत्यापित और अनुरक्षित स्टैक</td> <td>संस्करणों पर कम नियंत्रण</td> </tr> <tr> <td>कस्टम इमेज</td> <td>संस्करण और हार्डनिंग पर पूरा नियंत्रण</td> <td>रखरखाव आपके ज़िम्मे</td> </tr> <tr> <td>बेस AMI पर GPU कंटेनर</td> <td>पोर्टेबिलिटी और पुनरुत्पाद्यता</td> <td>टूलकिट और ड्राइवर वाले नोड चाहिए</td> </tr> </tbody> </table> <p><em>तय कीजिए कि संस्करण नियंत्रण और रखरखाव का कितना भार उठाना है।</em></p> <h2 id="लगत-क-रज-gpu-महग-ह">लागत का राज: GPU महँगा है</h2> <p>GPU का समय आपके AI बिल का सबसे महँगा संसाधन है, और <strong>निष्क्रिय GPU</strong> घटाना 2026 की प्राथमिकताओं में है। इमेज इस पर सीधे असर डालती है:</p> <ul> <li><strong>तेज़ बूट</strong>: ड्राइवर और डिपेंडेंसी पहले से तैयार वाली इमेज उन मिनटों से बचाती है जब GPU का पैसा चुकता है पर काम नहीं होता।</li> <li><strong>GPU कंटेनर</strong>: मॉडल का परिवेश पैक कर लीजिए, ताकि ड्राइवर वाले किसी भी नोड पर तुरंत दोहराया जा सके।</li> <li><strong>एज पर इन्फ़रेंस</strong>: हल्की इमेज, ताकि मॉडल डेटा के पास जाएँ और विलंब व लागत घटे।</li> <li><strong>स्केलिंग और स्पॉट</strong>: तैयार इमेज को स्पॉट इंस्टेंस से जोड़कर रुकावट सह लेने वाली वर्कलोड सस्ती करें।</li> </ul> <h2 id="अचछ-तर-तरक">अच्छे तौर-तरीक़े</h2> <ul> <li>ड्राइवर, CUDA और फ़्रेमवर्क के <strong>संस्करण</strong> तय कर दस्तावेज़ करें: संगतता नाज़ुक है।</li> <li>ड्राइवर और ऑपरेटिंग सिस्टम के सुरक्षा पैच आने पर इमेज <strong>अद्यतन रखें</strong>।</li> <li>तेज़ इटरेशन के लिए <strong>प्लेटफ़ॉर्म परत</strong> —ड्राइवर, टूलकिट— को <strong>मॉडल परत</strong> —कंटेनर— से अलग रखें।</li> <li><strong>प्रति इन्फ़रेंस लागत</strong> नापें और उसी हिसाब से इमेज तथा इंस्टेंस अनुकूलित करें।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>आधिकारिक Deep Learning AMI लूँ या अपनी बनाऊँ?</strong></p> <p>आधिकारिक GPU इमेज बहुत समय बचाती हैं और सत्यापित स्टैक साथ लाती हैं। अपनी तब बनाइए जब विशिष्ट संस्करण, ख़ास हार्डनिंग या कड़ा अनुपालन चाहिए।</p> <p><strong>GPU पर तेज़ बूट इतना अहम क्यों है?</strong></p> <p>क्योंकि GPU सबसे महँगा संसाधन है: GPU इंस्टेंस ड्राइवर इंस्टॉल करते हुए जो भी मिनट बिताता है, वह बिना उत्पादन के चुकाया पैसा है। सब कुछ पहले से इंस्टॉल वाली इमेज यह बर्बादी घटाती है।</p> <p><strong>GPU पर AI के लिए कंटेनर या सीधा इंस्टॉलेशन?</strong></p> <p>NVIDIA Container Toolkit के साथ GPU कंटेनर पुनरुत्पाद्यता और पोर्टेबिलिटी देते हैं, और यही अनुशंसित तरीक़ा है। इसके लिए नोड पर ड्राइवर चाहिए, जिसे अच्छी बेस AMI हल कर देती है।</p> <p><em>imaxe.cloud में हम AI वर्कलोड के विकास पर क़रीबी नज़र रखते हैं ताकि हमारी इमेज आपको ड्राइवर के नरक और धीमे बूट से बचाएँ।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/arm-graviton-%E0%A4%AC%E0%A4%9A%E0%A4%A4/2026-07-24T00:00:00Z2026-08-22T15:25:49Z

ARM अब फ़ोन तक सीमित नहीं रहा: आज यह क्लाउड का बड़ा हिस्सा चलाता है और ऐसा मूल्य-प्रदर्शन देता है जिसे नज़रअंदाज़ करना मुश्किल है। इमेज को Graviton पर ले जाने से बिल में ठीक-ठाक कटौती हो सकती है। बताते हैं कैसे, और किन सावधानियों के साथ।

<p><img src="https://www.imaxe.cloud/blog-covers/arm-graviton-ahorro_hu_564873198e07c9a3.webp" alt="मदरबोर्ड पर लगा Exynos चिप" width="1200" height="675"></p><p><strong>AWS Graviton</strong> जैसे ARM-आधारित प्रोसेसर प्रोडक्शन वर्कलोड के लिए पहली पंक्ति का विकल्प बन चुके हैं। इनका प्रस्ताव सीधा और दमदार है: कई वर्कलोड के लिए पारंपरिक x86 विकल्पों से <strong>बेहतर मूल्य-प्रदर्शन</strong>, और कम ऊर्जा खपत।</p> <p>क्लाउड महँगा होते जाने के दौर में —2026 के बड़े रुझानों में से एक— ARM पर जाना FinOps रणनीति के भीतर बचत का सबसे प्रभावी लीवर है।</p> <h2 id="कतन-बचत-ह-सकत-ह">कितनी बचत हो सकती है</h2> <p>आँकड़े वर्कलोड के हिसाब से बदलते हैं, पर उद्योग लगातार बताता है कि Graviton पर जाने से उपयुक्त वर्कलोड में कंप्यूट लागत में लगभग <strong>20 % से 40 %</strong> तक की सार्थक बचत होती है — प्रति vCPU बेहतर क़ीमत और अधिक दक्षता के चलते। यह जादू नहीं है: अपनी असली वर्कलोड पर सत्यापित करना ज़रूरी है, पर संभावना बड़ी है और अक्सर यह मेज़ पर छोड़ा हुआ पैसा होता है।</p> <h2 id="कय-आसन-स-जत-ह-और-कसम-सवधन-चहए">क्या आसानी से जाता है और किसमें सावधानी चाहिए</h2> <table> <thead> <tr> <th>आसानी से माइग्रेट होता है</th> <th>सत्यापन ज़रूरी</th> </tr> </thead> <tbody> <tr> <td>व्याख्यायित भाषाएँ: Python, Node, Java, Go</td> <td>केवल x86 के लिए कंपाइल बाइनरी</td> </tr> <tr> <td>मल्टी-आर्किटेक्चर इमेज वाले कंटेनर</td> <td>बिना ARM बिल्ड की नेटिव डिपेंडेंसी</td> </tr> <tr> <td>वेब, API और माइक्रोसर्विस</td> <td>बिना ARM संस्करण वाला प्रोप्राइटरी सॉफ़्टवेयर</td> </tr> <tr> <td>सामान्य डेटाबेस और कैश</td> <td>विशिष्ट ड्राइवर या एक्सटेंशन</td> </tr> </tbody> </table> <p><em>अधिकांश आधुनिक वर्कलोड बिना नाटक के माइग्रेट हो जाते हैं; नेटिव डिपेंडेंसी पर नज़र रखें।</em></p> <h2 id="मलट-आरकटकचर-इमज-क-भमक">मल्टी-आर्किटेक्चर इमेज की भूमिका</h2> <p>साफ़-सुथरे माइग्रेशन की कुंजी है अपनी इमेज <strong>दोनों आर्किटेक्चर</strong> —x86_64 और arm64— के लिए बनाना। कंटेनर की दुनिया में <em>multi-arch</em> इमेज एक ही टैग को दोनों पर चलने देती हैं। AMI की दुनिया में अच्छा रहता है कि आपकी पाइपलाइन —Packer या EC2 Image Builder— x86 के साथ-साथ arm64 इमेज भी बनाए, वही प्रोविज़नर दोबारा इस्तेमाल करते हुए।</p> <h2 id="पच-चरण-क-मइगरशन-यजन">पाँच चरणों की माइग्रेशन योजना</h2> <ol> <li>अपने वर्कलोड की <strong>सूची बनाएँ</strong> और ऐसी डिपेंडेंसी पहचानें जिनका ARM संस्करण न हो।</li> <li>पाइपलाइन में x86 के समानांतर <strong>arm64 इमेज बनाएँ</strong>।</li> <li>स्टेजिंग में <strong>परखें</strong>: प्रदर्शन, संगतता और कार्यात्मक परिणाम।</li> <li>कैनरी या ब्लू/ग्रीन से <strong>चरणबद्ध माइग्रेट करें</strong>, असली लागत और प्रदर्शन नापते हुए।</li> <li><strong>अनुकूलित करें</strong>: Graviton इंस्टेंस प्रकार को वर्कलोड की प्रोफ़ाइल से मिलाएँ।</li> </ol> <h2 id="azure-और-gcp-पर-भ-arm">Azure और GCP पर भी ARM</h2> <p>यह रुझान सिर्फ़ AWS का नहीं है। Azure ARM-आधारित मशीनें देता है —Cobalt और पार्टनरों की— और Google Cloud के पास Axion तथा Tau T2A जैसे ARM इंस्टेंस हैं। यदि आप अपनी इमेज को कोड की तरह और कई आर्किटेक्चर के लिए डिज़ाइन करते हैं, तो किसी भी क्लाउड पर सर्वोत्तम मूल्य-प्रदर्शन चुनने की आज़ादी मिल जाती है।</p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>Graviton से ठीक-ठीक कितनी बचत होगी?</strong></p> <p>यह आपकी वर्कलोड पर निर्भर है, पर उपयुक्त वर्कलोड में कंप्यूट लागत में 20 % से 40 % की बचत आम है। पक्के तौर पर जानने का एक ही तरीक़ा है: असली वर्कलोड को ARM इंस्टेंस पर चलाकर तुलना करना।</p> <p><strong>क्या मुझे ARM के लिए एप्लिकेशन दोबारा लिखना होगा?</strong></p> <p>कम ही। व्याख्यायित भाषाएँ और अधिकांश आधुनिक सॉफ़्टवेयर ARM पर बिना बदलाव चलते हैं। काम वहाँ आता है जहाँ केवल x86 के लिए कंपाइल बाइनरी या बिना ARM संस्करण की नेटिव डिपेंडेंसी हों।</p> <p><strong>क्या मेरी इमेज x86 और ARM दोनों पर एक साथ चल सकती हैं?</strong></p> <p>हाँ: मल्टी-आर्किटेक्चर कंटेनर इमेज और दोनों वैरिएंट बनाने वाली AMI पाइपलाइन से। इस तरह आप क्रमिक रूप से माइग्रेट करते हैं और कहीं अटकते नहीं।</p> <p><em>imaxe.cloud में हम अपनी इमेज इस तरह सोचते हैं कि हर आर्किटेक्चर का सर्वोत्तम इस्तेमाल हो और आपकी लागत तथा प्रदर्शन दोनों बेहतर हों।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/%E0%A4%AC%E0%A4%BF%E0%A4%A8%E0%A4%BE-%E0%A4%A1%E0%A4%BE%E0%A4%89%E0%A4%A8%E0%A4%9F%E0%A4%BE%E0%A4%87%E0%A4%AE-ami-%E0%A4%AE%E0%A4%BE%E0%A4%87%E0%A4%97%E0%A5%8D%E0%A4%B0%E0%A5%87%E0%A4%B6%E0%A4%A8/2026-07-21T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/migrar-ami-sin-downtime_hu_1ed2f0ccb833f256.webp" alt="रेल पटरी के पास लगा कांटा बदलने का लीवर" width="1200" height="675"></p><p>आपके इंस्टेंस जिस AMI का उपयोग करते हैं उसे बदलना, सेवा के चलते रहते हुए उसकी नींव बदलने जैसा है। ग़लत ढंग से किया तो कटौती; सही ढंग से किया तो उपयोगकर्ता को लगभग दिखता ही नहीं। अच्छी ख़बर: ऐसे परखे हुए पैटर्न मौजूद हैं जो इस माइग्रेशन को सुरक्षित और उलटने योग्य बनाते हैं।</p> <p>साझा आधार यह है कि चालू इंस्टेंस न छेड़ें, बल्कि <strong>नई AMI से नए इंस्टेंस चलाएँ</strong> और ट्रैफ़िक नियंत्रित ढंग से खिसकाएँ।</p> <h2 id="मइगरशन-स-पहल-जमन-तयर-कर">माइग्रेशन से पहले: ज़मीन तैयार करें</h2> <ul> <li>प्रोडक्शन जैसी स्टेजिंग में <strong>नई AMI परखें</strong>।</li> <li><strong>भरोसेमंद हेल्थ चेक</strong>: ऐसी जाँच तय करें जो पुष्टि करे कि नया इंस्टेंस सचमुच स्वस्थ है।</li> <li><strong>रोलबैक योजना</strong>: पिछला संस्करण और उस पर लौटने की प्रक्रिया तैयार रखें।</li> <li><strong>ऑब्ज़र्वेबिलिटी</strong>: मीट्रिक और अलर्ट, ताकि गिरावट तुरंत पकड़ में आए।</li> </ul> <h2 id="शनय-डउनटइम-क-मइगरशन-रणनतय">शून्य डाउनटाइम की माइग्रेशन रणनीतियाँ</h2> <table> <thead> <tr> <th>रणनीति</th> <th>कैसे काम करती है</th> <th>किसके लिए आदर्श</th> </tr> </thead> <tbody> <tr> <td>रोलिंग अपडेट</td> <td>इंस्टेंस को जत्थों में, धीरे-धीरे बदलती है</td> <td>Auto Scaling Group वाली सेवाएँ</td> </tr> <tr> <td>ब्लू/ग्रीन</td> <td>नया परिवेश खड़ा कर एक झटके में ट्रैफ़िक बदलते हैं</td> <td>तत्काल रोलबैक वाली माइग्रेशन</td> </tr> <tr> <td>कैनरी</td> <td>ट्रैफ़िक का छोटा हिस्सा नए संस्करण को भेजते हैं</td> <td>कम जोखिम में प्रोडक्शन में सत्यापन</td> </tr> </tbody> </table> <p><em>सेवा रोके बिना AMI बदलने के तीन पैटर्न।</em></p> <h3 id="रलग-अपडट">रोलिंग अपडेट</h3> <p>आप Launch Template में नई AMI डालते हैं और Auto Scaling Group इंस्टेंस को लहरों में बदलता है: नए चलाता है, उनके हेल्थ चेक पास होने का इंतज़ार करता है और पुराने हटा देता है। सरल, बिना अतिरिक्त इन्फ़्रास्ट्रक्चर — हालाँकि कुछ देर दोनों संस्करण साथ चलते हैं।</p> <h3 id="बलगरन">ब्लू/ग्रीन</h3> <p>आप नई AMI के साथ समानांतर परिवेश (<em>green</em>) खड़ा करते हैं, जबकि मौजूदा (<em>blue</em>) सेवा देता रहता है। green सत्यापित होते ही लोड बैलेंसर या DNS पर ट्रैफ़िक मोड़ देते हैं। कुछ बिगड़े तो सेकंडों में blue पर लौट आते हैं। यही सबसे तेज़ रोलबैक वाला पैटर्न है, बदले में कुछ समय के लिए संसाधन दोगुने करने पड़ते हैं।</p> <h3 id="कनर">कैनरी</h3> <p>आप ट्रैफ़िक का छोटा हिस्सा नई AMI वाले इंस्टेंस को भेजते हैं और देखते हैं। मीट्रिक टिके रहें तो प्रतिशत धीरे-धीरे 100 % तक बढ़ाते हैं। इससे किसी अप्रत्याशित गड़बड़ी का प्रभाव-क्षेत्र न्यूनतम रहता है।</p> <h2 id="मइगरशन-क-बद">माइग्रेशन के बाद</h2> <ul> <li>माइग्रेशन को सफल मानने से पहले उचित समय तक मीट्रिक और लॉग देखें।</li> <li>पुरानी AMI को <strong>अप्रचलित</strong> चिह्नित करें ताकि ग़लती से दोबारा न चले।</li> <li>तैनात संस्करण और बदलाव का कारण दस्तावेज़ करें।</li> <li>पिछली इमेज तुरंत न हटाएँ: रोलबैक की ज़रूरत पड़ सकती है, इसलिए संभालकर रखें।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>शून्य डाउनटाइम के लिए कौन-सी रणनीति सबसे अच्छी है?</strong></p> <p>ब्लू/ग्रीन सबसे तेज़ रोलबैक देती है; रोलिंग अपडेट ज़्यादा सरल और सस्ती है; कैनरी प्रोडक्शन में सत्यापन कर जोखिम घटाती है। चुनाव आपकी जोखिम-सहनशीलता और इन्फ़्रास्ट्रक्चर बजट पर निर्भर है।</p> <p><strong>क्या माइग्रेट करने के लिए इन्फ़्रास्ट्रक्चर दोगुना करना पड़ता है?</strong></p> <p>केवल ब्लू/ग्रीन में, और वह भी अस्थायी रूप से। रोलिंग अपडेट या कैनरी में आप वही समूह इस्तेमाल कर इंस्टेंस बदलते जाते हैं, पूरा परिवेश दोहराए बिना।</p> <p><strong>वापस लौट पाने की गारंटी कैसे करूँ?</strong></p> <p>पिछली AMI और उसका Launch Template संभालकर रखें, भरोसेमंद हेल्थ चेक तय करें और माइग्रेशन शुरू करने से पहले रोलबैक प्रक्रिया परख लें।</p> <p><em>imaxe.cloud में हम अपनी इमेज का संस्करण रखते हैं ताकि संस्करणों के बीच माइग्रेशन पूर्वानुमेय और उलटने योग्य रहे।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/byol-%E0%A4%AC%E0%A4%A8%E0%A4%BE%E0%A4%AE-%E0%A4%AA%E0%A5%8D%E0%A4%B0%E0%A4%A4%E0%A4%BF-%E0%A4%98%E0%A4%82%E0%A4%9F%E0%A4%BE/2026-07-17T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/byol-vs-pago-por-hora_hu_5e9a1e84b468f504.webp" alt="मेज़ पर यूरो के सिक्के और नोट" width="1200" height="675"></p><p>जब आप किसी AMI से इंस्टेंस लॉन्च करते हैं, तो कंप्यूट की लागत —यानी EC2 इंस्टेंस— के अलावा इमेज के <strong>सॉफ़्टवेयर</strong> से जुड़ी लागत भी हो सकती है। यह लागत मुख्यतः तीन मॉडलों में बँटती है: मुफ़्त (ओपन सोर्स), इंस्टेंस के साथ प्रति घंटा भुगतान, और BYOL (अपना लाइसेंस लाना)।</p> <p>इस अंतर को समझना बिल में चौंकाने वाली रक़मों और लाइसेंस अनुपालन की परेशानियों से बचाता है।</p> <h2 id="मडल-सफ-सफ">मॉडल, साफ़-साफ़</h2> <table> <thead> <tr> <th>मॉडल</th> <th>आप कैसे भुगतान करते हैं</th> <th>मुख्य लाभ</th> </tr> </thead> <tbody> <tr> <td>मुफ़्त या ओपन सोर्स</td> <td>सिर्फ़ इंस्टेंस का भुगतान</td> <td>न्यूनतम लागत, कोई सॉफ़्टवेयर लाइसेंस नहीं</td> </tr> <tr> <td>प्रति घंटा (PAYG)</td> <td>सॉफ़्टवेयर उपयोग के प्रति घंटे पर बिलिंग</td> <td>कोई प्रतिबद्धता नहीं: स्केल करें, बंद करें</td> </tr> <tr> <td>BYOL</td> <td>पहले से मौजूद लाइसेंस दोबारा इस्तेमाल</td> <td>पुराने निवेश का लाभ और नियंत्रण बरक़रार</td> </tr> </tbody> </table> <p><em>मशीन इमेज में सॉफ़्टवेयर लागत के तीन मॉडल।</em></p> <h2 id="परत-घट-भगतन-सबस-पहल-लचलपन">प्रति घंटा भुगतान: सबसे पहले लचीलापन</h2> <p>उपयोग-आधारित मॉडल में सॉफ़्टवेयर की लागत इंस्टेंस की लागत में जुड़ती है और उपयोग के प्रति घंटे या सेकंड पर बिल होती है। यह तब आदर्श है जब आपकी वर्कलोड परिवर्तनशील या अप्रत्याशित हो: कोई शुरुआती प्रतिबद्धता नहीं, ज़रूरत पर स्केल कीजिए और बंद करते ही भुगतान रुक जाता है। बदले में, गहन और लगातार उपयोग पर यह लंबे समय में अपना लाइसेंस अमॉर्टाइज़ करने से महँगा पड़ सकता है।</p> <ul> <li><strong>पक्ष में</strong>: शून्य शुरुआती निवेश, पूर्ण लचीलापन, रखरखाव व सहायता अक्सर शामिल।</li> <li><strong>विपक्ष में</strong>: प्रति घंटा लागत जो 24/7 जुड़कर अमॉर्टाइज़्ड लाइसेंस से आगे निकल सकती है।</li> </ul> <h2 id="byol-ज-पहल-स-ह-उसक-लभ-उठए">BYOL: जो पहले से है उसका लाभ उठाएँ</h2> <p><strong>Bring Your Own License</strong> के साथ आप पहले से मौजूद लाइसेंस —मसलन किसी एंटरप्राइज़ समझौते का— क्लाउड की इमेज पर दोबारा इस्तेमाल करते हैं। अगर आप लाइसेंस में पहले ही निवेश कर चुके हैं तो इससे लागत घट सकती है, पर ज़िम्मेदारियाँ भी आती हैं: निर्माता की शर्तें माननी होंगी, क्लाउड में लाइसेंस की पोर्टेबिलिटी पर नज़र रखनी होगी और अनुपालन आपको ही संभालना होगा।</p> <ul> <li><strong>पक्ष में</strong>: पुराने निवेश का उपयोग, लगातार उपयोग पर संभावित बचत, अपने विक्रेता के साथ निरंतरता।</li> <li><strong>विपक्ष में</strong>: अनुपालन की जटिलता, निर्माता के ऑडिट का जोखिम और प्रबंधन आपके ज़िम्मे।</li> </ul> <h2 id="छप-लगत-जन-पर-नजर-रख">छिपी लागतें जिन पर नज़र रखें</h2> <ul> <li><strong>स्टोरेज</strong>: इमेज के EBS स्नैपशॉट की लागत होती है, चाहे सॉफ़्टवेयर मुफ़्त हो।</li> <li><strong>डेटा ट्रांसफ़र</strong>: रीजनों के बीच या इंटरनेट की ओर।</li> <li><strong>सहायता</strong>: क्या वह प्रति घंटा क़ीमत में शामिल है या अलग से?</li> <li><strong>इंस्टेंस प्रकार</strong>: सॉफ़्टवेयर को बड़े इंस्टेंस चाहिए हो सकते हैं, जिससे कंप्यूट महँगा होता है।</li> <li><strong>लाइसेंस पोर्टेबिलिटी</strong>: कुछ BYOL लाइसेंस डेडिकेटेड टेनेंसी माँगते हैं, जो महँगी है।</li> </ul> <h2 id="फसल-कस-कर">फ़ैसला कैसे करें</h2> <p>व्यावहारिक नियम: <strong>परिवर्तनशील या अल्पकालिक</strong> वर्कलोड के लिए प्रति घंटा भुगतान लचीलेपन के कारण आम तौर पर जीतता है। <strong>लगातार 24/7 और दीर्घजीवी</strong> वर्कलोड के लिए लाइसेंस अमॉर्टाइज़ करना या क्षमता आरक्षित करना कुल लागत घटा सकता है। अपने असली उपयोग प्रोफ़ाइल पर हिसाब लगाइए —सबसे बुरे केस पर नहीं— और छिपी लागतें शामिल करना न भूलें।</p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>सस्ता क्या है, BYOL या प्रति घंटा भुगतान?</strong></p> <p>आपके उपयोग पर निर्भर है। परिवर्तनशील या रुक-रुक कर चलने वाली वर्कलोड में प्रति घंटा जीतता है; अगर आपके पास अमॉर्टाइज़ करने लायक़ लाइसेंस हैं और उपयोग लगातार 24/7 है, तो BYOL फ़ायदेमंद हो सकता है।</p> <p><strong>क्या AMI का मुफ़्त सॉफ़्टवेयर मतलब शून्य लागत?</strong></p> <p>पूरी तरह नहीं: सॉफ़्टवेयर ओपन सोर्स हो तब भी आप इंस्टेंस, स्नैपशॉट स्टोरेज और डेटा ट्रांसफ़र का भुगतान करते रहते हैं।</p> <p><strong>BYOL में क़ानूनी जोखिम क्या हैं?</strong></p> <p>आपको क्लाउड में उपयोग और लाइसेंस पोर्टेबिलिटी पर निर्माता की शर्तें माननी होती हैं। उल्लंघन किसी ऑडिट में सामने आ सकता है, इसलिए शर्तों को ध्यान से पढ़ना ठीक रहता है।</p> <p><em>imaxe.cloud में हम हर इमेज का लागत मॉडल समझने में आपकी मदद करते हैं ताकि आप साफ़ आँकड़ों के साथ चुनाव करें।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/ami-%E0%A4%B8%E0%A5%80%E0%A4%95%E0%A5%8D%E0%A4%B0%E0%A5%87%E0%A4%9F-%E0%A4%AA%E0%A5%8D%E0%A4%B0%E0%A4%AC%E0%A4%82%E0%A4%A7%E0%A4%A8/2026-07-14T00:00:00Z2026-08-22T15:25:49Z

इमेज के भीतर रखा पासवर्ड होते हुए रिसाव है: वह कॉपी होता है, साझा होता है और हमेशा के लिए किसी स्नैपशॉट में बैठा रहता है। नियम सरल है और अपवाद नहीं मानता: सीक्रेट कभी इमेज में नहीं जाते। सही तरीक़ा यह है।

<p><img src="https://www.imaxe.cloud/blog-covers/gestion-secretos-ami_hu_ed7ffbea445a9c3c.webp" alt="बैंक तिजोरी का बख़्तरबंद दरवाज़ा" width="1200" height="675"></p><p>जब आप किसी क्रेडेंशियल को AMI में जड़ देते हैं, तो वह इमेज की हर प्रति के साथ फैलता है, स्नैपशॉट में उकेरा रह जाता है और ऐसे खातों या रीजनों तक पहुँच सकता है जिनकी आपने कल्पना भी नहीं की थी। बस इतना काफ़ी है कि इमेज पर पढ़ने की पहुँच रखने वाला कोई उसे निकाल ले। और चूँकि इमेज संस्करणों के हिसाब से सहेजी जाती हैं, वह सीक्रेट उस दिन के बहुत बाद तक ज़िंदा रह सकता है जब आपने उसे बदल दिया मान लिया था।</p> <p>सुनहरा नियम: <strong>इमेज मशीन को परिभाषित करती है; सीक्रेट रनटाइम पर सौंपे जाते हैं</strong>।</p> <h2 id="सकरट-कह-रहन-चहए">सीक्रेट कहाँ रहने चाहिए</h2> <table> <thead> <tr> <th>सेवा</th> <th>क्लाउड या परिवेश</th> <th>किसके लिए आदर्श</th> </tr> </thead> <tbody> <tr> <td>AWS Secrets Manager</td> <td>AWS</td> <td>बदले जा सकने वाले क्रेडेंशियल, नेटिव एकीकरण</td> </tr> <tr> <td>AWS SSM Parameter Store</td> <td>AWS</td> <td>सरल पैरामीटर और सीक्रेट, कम लागत</td> </tr> <tr> <td>HashiCorp Vault</td> <td>मल्टीक्लाउड</td> <td>गतिशील सीक्रेट और सूक्ष्म नियंत्रण</td> </tr> <tr> <td>Azure Key Vault / Google Secret Manager</td> <td>Azure / GCP</td> <td>हर क्लाउड में नेटिव समकक्ष</td> </tr> </tbody> </table> <p><em>सीक्रेट किसी समर्पित प्रबंधक में रखें, कभी इमेज में या साफ़ पाठ user-data में नहीं।</em></p> <h2 id="सह-पटरन-पसवरड-नह-पहचन">सही पैटर्न: पासवर्ड नहीं, पहचान</h2> <p>किसी इंस्टेंस को संसाधनों तक पहुँच देने का सबसे सुरक्षित तरीक़ा उसे पासवर्ड देना नहीं, बल्कि <strong>पहचान</strong> देना है। AWS में इंस्टेंस से जुड़ी <strong>IAM भूमिका</strong> उसे अस्थायी और स्वतः बदलने वाले क्रेडेंशियल दिलाती है, बिना किसी कुंजी को इमेज में ले जाए।</p> <ul> <li><strong>इंस्टेंस IAM भूमिकाएँ</strong>: इंस्टेंस भूमिका ग्रहण कर अस्थायी क्रेडेंशियल पाता है।</li> <li><strong>Kubernetes में IRSA</strong>: प्रति पॉड पहचान, नोड पर साझा कुंजियों के बिना।</li> <li><strong>Vault से गतिशील सीक्रेट</strong>: माँग पर बनने वाले अल्पजीवी क्रेडेंशियल।</li> <li><strong>रनटाइम इंजेक्शन</strong>: एप्लिकेशन आरंभ में सीक्रेट प्रबंधक से पढ़ता है, बेक की गई फ़ाइल से नहीं।</li> </ul> <h2 id="मटडट-क-रकष-कर-imdsv2">मेटाडेटा की रक्षा करें: IMDSv2</h2> <p>भूमिका के अस्थायी क्रेडेंशियल इंस्टेंस मेटाडेटा सेवा से मिलते हैं। SSRF दोष का लाभ उठाकर कोई हमलावर उन्हें चुराने की कोशिश कर सकता है। <strong>IMDSv2</strong> सत्र टोकन माँगता है और इस श्रेणी के हमलों को घटाता है: अपने लॉन्च में इसे अनिवार्य कर दें।</p> <h2 id="सवचछत-इमज-म-नशन-न-छड">स्वच्छता: इमेज में निशान न छोड़ें</h2> <ul> <li>AMI सील करने से पहले शेल इतिहास, क्रेडेंशियल वाले लॉग, अस्थायी SSH कुंजियाँ और सीक्रेट वाली कॉन्फ़िगरेशन फ़ाइलें <strong>मिटा दें</strong>।</li> <li>फ़ाइल सिस्टम के लिए अनुकूलित gitleaks या trufflehog जैसे औज़ारों से इमेज में <strong>सीक्रेट</strong> खोजें।</li> <li><code>~/.ssh/authorized_keys</code> में अतिरिक्त <strong>अधिकृत कुंजियाँ</strong> न छोड़ें।</li> <li>सीक्रेट वाली <strong>सार्वजनिक AMI</strong> से बचें: प्रकाशित करें तो जाँच लें कि कुछ लीक न हो।</li> </ul> <h2 id="तवरत-चकलसट">त्वरित चेकलिस्ट</h2> <ul> <li>इमेज में शून्य बेक्ड सीक्रेट।</li> <li>भूमिकाओं या फ़ेडरेटेड पहचान के साथ सीक्रेट प्रबंधक।</li> <li>IMDSv2 अनिवार्य।</li> <li>पाइपलाइन में सीक्रेट स्कैन।</li> <li>सील करने से पहले निशानों की सफ़ाई।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>अगर मेरे एप्लिकेशन को बूट पर ही सीक्रेट चाहिए तो?</strong></p> <p>वह इंस्टेंस की पहचान का उपयोग कर रनटाइम पर सीक्रेट प्रबंधक से पढ़े। इस तरह सीक्रेट कभी इमेज के भीतर नहीं जाता और बिना पुनर्निर्माण बदला जा सकता है।</p> <p><strong>क्या सीक्रेट भेजने के लिए user-data इस्तेमाल करना सुरक्षित है?</strong></p> <p>साफ़ पाठ में नहीं: user-data मेटाडेटा से पढ़ा जा सकता है। ज़्यादा से ज़्यादा इसका उपयोग यह बताने के लिए करें कि प्रबंधक से कौन-सा सीक्रेट लाना है, और मेटाडेटा को IMDSv2 से बचाएँ।</p> <p><strong>कैसे पता करूँ कि किसी इमेज में पहले से बेक्ड सीक्रेट हैं?</strong></p> <p>उसके फ़ाइल सिस्टम पर सीक्रेट पहचान औज़ारों से स्कैन करके, और उपयोग से पहले कॉन्फ़िगरेशन फ़ाइलें, इतिहास और अधिकृत कुंजियाँ जाँचकर।</p> <p><em>imaxe.cloud में हम क्रेडेंशियल से मुक्त इमेज बनाते हैं, जो सीक्रेट प्रबंधकों और फ़ेडरेटेड पहचान के साथ जुड़ने के लिए सोची गई हैं।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/%E0%A4%AE%E0%A4%B6%E0%A5%80%E0%A4%A8-%E0%A4%87%E0%A4%AE%E0%A5%87%E0%A4%9C-sbom/2026-07-10T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/sbom-imagenes-de-maquina_hu_ffc36a1f6a89fff9.webp" alt="गोदाम के रैक पर ढेर लगे और सूचीबद्ध पैलेट" width="1200" height="675"></p><p><strong>SBOM</strong> (<em>Software Bill of Materials</em>) आपके सॉफ़्टवेयर की «सामग्री सूची» है: किसी इमेज में मौजूद पैकेज, लाइब्रेरी, संस्करण और डिपेंडेंसी की पूरी फ़ेहरिस्त। पोषण लेबल की तरह, यह ठीक-ठीक बताता है कि भीतर क्या है।</p> <p>इसका मूल्य किसी गंभीर भेद्यता वाले दिन साफ़ दिखता है: दर्जनों इमेज हाथ से खंगालने के बजाय आप SBOM देखते हैं और सेकंडों में जान जाते हैं कि किन इमेजों में प्रभावित कंपोनेंट है और किस संस्करण में।</p> <h2 id="यह-आपक-इमज-क-लए-कय-मयन-रखत-ह">यह आपकी इमेज के लिए क्यों मायने रखता है</h2> <ul> <li><strong>CVE पर तेज़ प्रतिक्रिया</strong>: तुरंत पता चलता है कि नई भेद्यता आप पर लागू है या नहीं।</li> <li><strong>आपूर्ति शृंखला सुरक्षा</strong>: हर कंपोनेंट कहाँ से आया, यह पता रहता है।</li> <li><strong>अनुपालन</strong>: अधिकाधिक ढाँचे और ग्राहक इसे प्रमाण के रूप में माँगते हैं।</li> <li><strong>पारदर्शिता</strong>: अगर आप इमेज प्रकाशित करते हैं, तो SBOM उपयोगकर्ताओं में भरोसा जगाता है।</li> </ul> <h2 id="मनक-पररप">मानक प्रारूप</h2> <table> <thead> <tr> <th>प्रारूप</th> <th>उद्गम</th> <th>टिप्पणी</th> </tr> </thead> <tbody> <tr> <td>SPDX</td> <td>Linux Foundation / ISO</td> <td>ISO मानक, अनुपालन में बहुप्रचलित</td> </tr> <tr> <td>CycloneDX</td> <td>OWASP</td> <td>सुरक्षा-उन्मुख, भेद्यता विश्लेषण के लिए समृद्ध</td> </tr> </tbody> </table> <p><em>दो प्रमुख SBOM प्रारूप; कई औज़ार दोनों में निर्यात करते हैं।</em></p> <h2 id="कस-इमज-क-sbom-चरण-दर-चरण-कस-बनए">किसी इमेज का SBOM चरण-दर-चरण कैसे बनाएँ</h2> <ol> <li><strong>औज़ार चुनें</strong>: Anchore का Syft इमेज और फ़ाइल सिस्टम के SBOM बनाने का वास्तविक मानक है; क्लाउड-नेटिव विकल्प भी हैं।</li> <li><strong>पाइपलाइन में बनाएँ</strong>: AMI के बिल्ड के दौरान फ़ाइल सिस्टम स्कैन कर SBOM तैयार करें, जैसे CycloneDX और SPDX में।</li> <li><strong>भेद्यता विश्लेषण करें</strong>: SBOM को Grype या Trivy से गुज़ारकर CVE डेटाबेस से मिलाएँ।</li> <li><strong>हस्ताक्षर और संग्रह</strong>: SBOM पर हस्ताक्षर करें —जैसे cosign से— और इमेज संस्करण से जुड़े आर्टिफ़ैक्ट के रूप में सहेजें।</li> <li><strong>ज़रूरत पड़ने पर देखें</strong>: नई CVE आने पर संग्रहित SBOM देखकर दायरा तय करें।</li> </ol> <h2 id="2026-क-नयमक-सदरभ">2026 का नियामक संदर्भ</h2> <p>SBOM वर्षों से आपूर्ति शृंखला सुरक्षा की अच्छी प्रथा के रूप में वज़न बढ़ा रहा है। नियामक तस्वीर, हालाँकि, बारीक है: अमेरिका में प्रशासन ने 2026 में विरासत में मिले सॉफ़्टवेयर प्रमाणन आदेशों को अधिक जोखिम-आधारित रुख़ की ओर संशोधित किया, जबकि यूरोपीय संघ में Cyber Resilience Act जैसे नियम सॉफ़्टवेयर पारदर्शिता और कंपोनेंट सूची को आगे बढ़ा रहे हैं। व्यावहारिक निष्कर्ष: नियामक उतार-चढ़ाव से परे, SBOM रखना एक रक्षात्मक व व्यावसायिक बढ़त है, जिसे अपनाना ठीक रहता है।</p> <h2 id="अचछ-तर-तरक">अच्छे तौर-तरीक़े</h2> <ul> <li>हर बिल्ड में SBOM <strong>स्वचालित रूप से</strong> बनाएँ, हाथ से नहीं।</li> <li>जिस इमेज का है, उसके साथ <strong>संस्करण सहित</strong> सहेजें।</li> <li>कार्रवाई योग्य बनाने के लिए इसे <strong>भेद्यता स्कैन</strong> से जोड़ें।</li> <li><strong>अखंडता</strong> और मूल की गारंटी के लिए हस्ताक्षर करें।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या SBOM और भेद्यता स्कैन एक ही चीज़ हैं?</strong></p> <p>नहीं। SBOM कंपोनेंट की सूची है; स्कैन उस सूची को CVE डेटाबेस से मिलाकर भेद्यताएँ ढूँढ़ता है। ये एक-दूसरे के पूरक हैं: पहले पता चलता है कि आपके पास क्या है, फिर यह कि वह भेद्य है या नहीं।</p> <p><strong>SPDX या CycloneDX?</strong></p> <p>SPDX एक ISO मानक है, अनुपालन में ख़ूब इस्तेमाल होता है; CycloneDX अधिक सुरक्षा-उन्मुख है। कई औज़ार दोनों में निर्यात करते हैं, इसलिए किसी एक को चुनना ज़रूरी नहीं।</p> <p><strong>अगर मैं केवल तृतीय-पक्ष इमेज इस्तेमाल करता हूँ, तब भी SBOM चाहिए?</strong></p> <p>हाँ। जिन इमेज का उपयोग करते हैं उनका SBOM माँगना या बनाना आपको उनका जोखिम आँकने और भेद्यताओं पर जल्दी प्रतिक्रिया देने देता है, भले ही उन्हें आपने न बनाया हो।</p> <p><em>imaxe.cloud में हम पारदर्शिता पर दाँव लगाते हैं: अपनी इमेज के सॉफ़्टवेयर की सूची बनाना और दस्तावेज़ करना उन्हें ठीक से बनाने का ही हिस्सा है।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/cloud-init-user-data/2026-07-07T00:00:00Z2026-08-22T15:25:49Z

गोल्डन AMI स्थिर चीज़ें संभालती है; cloud-init बदलने वाली। user-data और cloud-init में महारत ही आपको एक ही इमेज को हज़ार परिदृश्यों में बिना दोबारा पकाए इस्तेमाल करने देती है। यह रही व्यावहारिक गाइड।

<p><img src="https://www.imaxe.cloud/blog-covers/cloud-init-user-data_hu_6c8986f026962556.webp" alt="टर्मिनल में सिस्टम अपडेट दिखाता लैपटॉप" width="1200" height="675"></p><p><strong>cloud-init</strong> क्लाउड इंस्टेंस को उनके पहले बूट पर आरंभ करने का वास्तविक मानक है। जब आप कोई इंस्टेंस लॉन्च कर उसे <strong>user-data</strong> स्क्रिप्ट देते हैं, तो cloud-init ही उसे पढ़ता और चलाता है: उपयोगकर्ता बनाता है, फ़ाइलें लिखता है, पैकेज इंस्टॉल करता है, डिस्क माउंट करता है या सेवाएँ शुरू करता है।</p> <p>आदर्श संयोजन साफ़ है: <strong>गोल्डन AMI</strong> में वह रहता है जो नहीं बदलता —ऑपरेटिंग सिस्टम, रनटाइम, हार्डनिंग— और <strong>user-data</strong> वह लाता है जो परिवेश या इंस्टेंस के हिसाब से बदलता है: कॉन्फ़िगरेशन, इंजेक्ट किए गए सीक्रेट, भूमिका। इस तरह एक ही इमेज कई संदर्भों में काम आती है।</p> <h2 id="user-data-लखन-क-द-तरक">user-data लिखने के दो तरीक़े</h2> <p>user-data कई प्रारूप स्वीकारता है; सबसे आम दो हैं शेल स्क्रिप्ट और cloud-config।</p> <ul> <li><strong>शेल स्क्रिप्ट</strong>: <code>#!/bin/bash</code> से शुरू होती है। छोटे-फुर्तीले कामों के लिए सीधी और सरल।</li> <li><strong>cloud-config</strong>: <code>#cloud-config</code> से शुरू होता है और घोषणात्मक YAML इस्तेमाल करता है। उपयोगकर्ता, पैकेज, फ़ाइल और कमांड कॉन्फ़िगर करने के लिए ज़्यादा साफ़, पठनीय और आइडेम्पोटेंट।</li> </ul> <h3 id="cloud-config-क-उदहरण">cloud-config का उदाहरण</h3> <p>एक सामान्य <code>#cloud-config</code> में <code>packages:</code> (इंस्टॉल करने के पैकेज), <code>write_files:</code> (कॉन्फ़िगरेशन फ़ाइलें), <code>runcmd:</code> (अंतिम कमांड) और <code>users:</code> (खाते और कुंजियाँ) जैसे खंड होते हैं। घोषणात्मक होने के कारण यह लंबी स्क्रिप्ट की तुलना में समीक्षा और रखरखाव में आसान है।</p> <h2 id="अचछ-तर-तरक">अच्छे तौर-तरीक़े</h2> <ul> <li><strong>user-data छोटा रखें</strong>: यदि यह बहुत बढ़ जाए, तो शायद वह चीज़ AMI में बेक होनी चाहिए।</li> <li><strong>आइडेम्पोटेंस</strong>: कमांड ऐसे बनाएँ कि दोबारा चलाने पर कुछ न बिगड़े।</li> <li><strong>user-data में सीक्रेट कभी साफ़ पाठ में न रखें</strong>: यह इंस्टेंस मेटाडेटा से पढ़ा जा सकता है। उन्हें रनटाइम पर Secrets Manager, Parameter Store या Vault से इंजेक्ट करें।</li> <li><strong>मेटाडेटा तक पहुँच सुरक्षित करें</strong>: SSRF के ज़रिए क्रेडेंशियल चोरी घटाने के लिए IMDSv2 इस्तेमाल करें।</li> <li><strong>लॉग रखें और डिबग करें</strong>: कुछ बिगड़े तो cloud-init के लॉग (<code>/var/log/cloud-init-output.log</code>) आपके सबसे अच्छे दोस्त हैं।</li> </ul> <h2 id="बकग-य-बटग-कय-कह-रख">बेकिंग या बूटिंग: क्या कहाँ रखें</h2> <table> <thead> <tr> <th>AMI में (बेकिंग)</th> <th>user-data में (बूटिंग)</th> </tr> </thead> <tbody> <tr> <td>ऑपरेटिंग सिस्टम और पैच</td> <td>परिवेश-विशिष्ट कॉन्फ़िगरेशन</td> </tr> <tr> <td>रनटाइम, एजेंट और हार्डनिंग</td> <td>प्रति इंस्टेंस चर और पैरामीटर</td> </tr> <tr> <td>स्थिर और भारी सॉफ़्टवेयर</td> <td>क्लस्टर में पंजीकरण और डिस्कवरी</td> </tr> <tr> <td>जो कुछ भी इंस्टॉल होने में समय लेता है</td> <td>रनटाइम पर सीक्रेट इंजेक्शन</td> </tr> </tbody> </table> <p><em>सुनहरा नियम: स्थिर और धीमा बेक होता है; परिवर्तनशील और हल्का बूट पर जाता है।</em></p> <h2 id="घट-बरबद-करन-वल-आम-गलतय">घंटों बर्बाद कराने वाली आम ग़लतियाँ</h2> <ul> <li>जो इमेज में होना चाहिए उसे user-data में डालना, जिससे बूट धीमे और नाज़ुक हो जाते हैं।</li> <li>मेटाडेटा में सीक्रेट साफ़ पाठ में उजागर करना।</li> <li>यह मान लेना कि user-data हर बूट पर दोबारा चलता है: डिफ़ॉल्ट रूप से वह सिर्फ़ पहले बूट पर चलता है।</li> <li>जब इंस्टेंस «वैसा नहीं करता जैसा करना चाहिए» तो cloud-init के लॉग न देखना।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या user-data हर रीबूट पर चलता है?</strong></p> <p>डिफ़ॉल्ट रूप से केवल पहले बूट पर। cloud-init को कुछ हिस्सों के लिए हर बूट पर चलाने हेतु कॉन्फ़िगर किया जा सकता है, पर यह सोच-समझकर और आइडेम्पोटेंट ढंग से करना चाहिए।</p> <p><strong>क्या user-data में पासवर्ड भेजना सुरक्षित है?</strong></p> <p>नहीं। user-data इंस्टेंस मेटाडेटा से पढ़ा जा सकता है। सीक्रेट मैनेजर इस्तेमाल कर उन्हें रनटाइम पर इंजेक्ट करें, और मेटाडेटा को IMDSv2 से सुरक्षित रखें।</p> <p><strong>क्या cloud-init सिर्फ़ AWS पर चलता है?</strong></p> <p>नहीं। cloud-init मल्टी-प्लेटफ़ॉर्म है और AWS, Azure, GCP व अन्य पर चलता है, जो इसे बूट के पोर्टेबल स्वचालन के लिए आदर्श बनाता है।</p> <p><em>imaxe.cloud में हम ऐसी इमेज बनाते हैं जो cloud-init के साथ मिलकर काम करने के लिए सोची गई हैं, ताकि एक ही AMI आपके कई परिदृश्यों में काम आए।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/kubernetes-%E0%A4%B9%E0%A4%BE%E0%A4%B0%E0%A5%8D%E0%A4%A1%E0%A4%A8%E0%A5%8D%E0%A4%A1-ami/2026-07-03T00:00:00Z2026-08-22T15:25:49Z

Kubernetes उतना ही सुरक्षित है जितने वे नोड्स जिन पर वह चलता है। एक हार्डन्ड, पैच किया हुआ और ट्यून किया हुआ नोड AMI वह नींव है जिसे कई टीमें नज़रअंदाज़ कर देती हैं। बताते हैं कि EKS और सेल्फ-मैनेज्ड क्लस्टर के लिए आदर्श बेस इमेज कैसे बनाएँ।

<p><img src="https://www.imaxe.cloud/blog-covers/ami-endurecida-kubernetes_hu_448c2b0b32cba86a.webp" alt="ब्रेमरहाफ़ेन कंटेनर टर्मिनल का हवाई दृश्य" width="1200" height="675"></p><p>यह मान लेना आसान है कि कंटेनरों के साथ काम करते समय होस्ट की सुरक्षा मायने नहीं रखती। सच्चाई इसके ठीक उलट है: हर Kubernetes नोड एक मशीन है जो किसी इमेज से बूट होती है, और होस्ट में सेंध उस पर चल रहे सभी पॉड्स को खतरे में डाल देती है। इसलिए <strong>नोड का AMI</strong> सुरक्षा का एक अहम हिस्सा है।</p> <p>आपके पास तीन रास्ते हैं: आधिकारिक ऑप्टिमाइज़्ड AMI को जस का तस इस्तेमाल करना, उसे आधार बनाकर कस्टमाइज़ करना, या अपना खुद का बनाना। गंभीर प्रोडक्शन के लिए, हार्डन्ड बेस पर कस्टमाइज़ करना या बनाना ही सुझाया जाता है।</p> <h2 id="एक-अचछ-नड-ami-म-कय-हन-चहए">एक अच्छे नोड AMI में क्या होना चाहिए</h2> <ul> <li>कंटेनर रनटाइम के लिए <strong>ऑप्टिमाइज़्ड बेस</strong>, जिसमें containerd और kubelet सही ढंग से कॉन्फ़िगर हों।</li> <li>ऑपरेटिंग सिस्टम की <strong>CIS हार्डनिंग</strong> और, जहाँ लागू हो, CIS Benchmark for Kubernetes की भी।</li> <li>कर्नेल और कंपोनेंट्स की <strong>अद्यतन पैचिंग</strong>, समय-समय पर पुनर्निर्माण के साथ।</li> <li><strong>ज़रूरी एजेंट</strong> —लॉग, मेट्रिक्स, सुरक्षा— तेज़ बूट के लिए पहले से इंस्टॉल।</li> <li><strong>कोई बेक्ड सीक्रेट या क्रेडेंशियल नहीं</strong>; पहचान IAM Roles for Service Accounts (IRSA) या समकक्ष के ज़रिए।</li> <li><strong>न्यूनतम कॉन्फ़िगरेशन</strong>: वे पैकेज और सेवाएँ हटा दें जिनकी नोड को ज़रूरत नहीं।</li> </ul> <h2 id="eks-क-लए-इमज-वकलप">EKS के लिए इमेज विकल्प</h2> <table> <thead> <tr> <th>विकल्प</th> <th>लाभ</th> <th>कब चुनें</th> </tr> </thead> <tbody> <tr> <td>EKS ऑप्टिमाइज़्ड AMI (AL2023)</td> <td>आधिकारिक, AWS द्वारा अनुरक्षित</td> <td>सामान्य शुरुआती बिंदु</td> </tr> <tr> <td>Bottlerocket</td> <td>कंटेनर-केंद्रित न्यूनतम OS, अपरिवर्तनीय</td> <td>अधिकतम सुरक्षा, न्यूनतम सतह</td> </tr> <tr> <td>कस्टम AMI</td> <td>हार्डनिंग और एजेंटों पर पूरा नियंत्रण</td> <td>कड़ी अनुपालन आवश्यकताएँ</td> </tr> </tbody> </table> <p><em>नियंत्रण और सुविधा के बीच अपने संतुलन के हिसाब से नोड बेस चुनें।</em></p> <h2 id="bottlerocket-पहल-कटनर">Bottlerocket: पहले कंटेनर</h2> <p>Bottlerocket AWS का एक न्यूनतमवादी ऑपरेटिंग सिस्टम है, जो विशेष रूप से कंटेनर चलाने के लिए बना है। इसकी अटैक सरफ़ेस बेहद छोटी है, यह अपरिवर्तनीय है और इमेज के ज़रिए अपडेट होता है —हॉट पैचिंग से नहीं—, जो अपरिवर्तनीय इन्फ़्रास्ट्रक्चर के दर्शन से बख़ूबी मेल खाता है। यदि आपकी प्राथमिकता न्यूनतम रखरखाव में नोड सुरक्षा है, तो यह गंभीर मूल्यांकन का हक़दार है।</p> <h2 id="बन-तकलफ-नड-अपडट-करन">बिना तकलीफ़ नोड अपडेट करना</h2> <p>हार्डन्ड नोड AMI तभी काम का है जब आप नोड्स को अद्यतन रखें। यहाँ अपरिवर्तनीय पैटर्न चमकता है:</p> <ul> <li><strong>बदलें, पैच न करें</strong>: नया AMI संस्करण प्रकाशित करें और नोड्स रोटेट करें।</li> <li><strong>नोड ग्रुप का रोलिंग अपडेट</strong>: <em>cordon</em> और <em>drain</em> से खाली करें और एक-एक नोड बदलें।</li> <li>नए AMI के साथ प्रतिस्थापन को स्वचालित करने के लिए <strong>Managed Node Groups</strong> या Karpenter।</li> <li><strong>PodDisruptionBudgets</strong>, ताकि रोटेशन आपकी सेवाओं की उपलब्धता पर असर न डाले।</li> </ul> <h2 id="आम-गलतय">आम गलतियाँ</h2> <ul> <li>डिफ़ॉल्ट ऑप्टिमाइज़्ड AMI को महीनों बिना अपडेट किए इस्तेमाल करना।</li> <li>फ़ेडरेटेड आइडेंटिटी की जगह क्लस्टर क्रेडेंशियल इमेज में बेक कर देना।</li> <li>ख़ुद kubelet और फ़ाइल सिस्टम अनुमतियों की हार्डनिंग भूल जाना।</li> <li>नोड्स तक SSH पहुँच सीमित न करना: आदर्श रूप से शून्य SSH और केवल SSM से पहुँच।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या मुझे कस्टम AMI चाहिए या EKS की ऑप्टिमाइज़्ड काफ़ी है?</strong></p> <p>शुरुआत के लिए आधिकारिक ऑप्टिमाइज़्ड AMI अच्छा शुरुआती बिंदु है। यदि अनुपालन या सुरक्षा की कड़ी आवश्यकताएँ हैं, तो उसे कस्टमाइज़ करें या अपनी हार्डनिंग और एजेंटों के साथ अपना बनाएँ।</p> <p><strong>क्या Bottlerocket सामान्य Linux AMI की जगह ले लेता है?</strong></p> <p>उन नोड्स के लिए जो केवल कंटेनर चलाते हैं, हाँ: छोटी अटैक सरफ़ेस और अपरिवर्तनीय अपडेट। यह उन वर्कलोड के लिए उपयुक्त नहीं जिन्हें सामान्य-उद्देश्य OS चाहिए।</p> <p><strong>नया AMI प्रकाशित करने पर नोड्स कैसे अपडेट करूँ?</strong></p> <p>नोड ग्रुप के रोलिंग अपडेट से: उन्हें क्रमशः खाली कर बदला जाता है, PodDisruptionBudgets का सम्मान करते हुए, ताकि सेवा प्रभावित न हो।</p> <p><em>imaxe.cloud में हम ऐसी हार्डन्ड बेस इमेज डिज़ाइन करते हैं जो आपके Kubernetes नोड्स की आदर्श नींव बनती हैं।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/cve-%E0%A4%95%E0%A5%87-%E0%A4%AC%E0%A4%BE%E0%A4%A6-ami-%E0%A4%AA%E0%A5%81%E0%A4%A8%E0%A4%B0%E0%A5%8D%E0%A4%A8%E0%A4%BF%E0%A4%B0%E0%A5%8D%E0%A4%AE%E0%A4%BE%E0%A4%A3/2026-06-30T00:00:00Z2026-08-22T15:25:49Z

जब अगला Log4Shell आएगा, घड़ी चलने लगेगी। जो संगठन घंटों में अपनी इमेज दोबारा बनाकर बाँट देते हैं वे चैन से सोते हैं; हाथ से पैच करने वाले नहीं। यह रही गंभीर CVE का स्वचालित जवाब देने की आर्किटेक्चर।

<p><img src="https://www.imaxe.cloud/blog-covers/reconstruir-ami-ante-cve_hu_920b537b3bf25409.webp" alt="लाल बत्ती वाला अग्नि-चेतावनी बटन" width="1200" height="675"></p><p>किसी गंभीर भेद्यता के प्रकाशित होने और आपके द्वारा उसे सभी इंस्टेंस पर ठीक करने के बीच जो समय बीतता है, वही <strong>एक्सपोज़र विंडो</strong> है। वह जितनी लंबी होगी, हमलावर के पास उसका फ़ायदा उठाने को उतना ही समय। सर्वर-दर-सर्वर पैच करने के पारंपरिक मॉडल में यह विंडो दिनों या हफ़्तों में नापी जाती है। अच्छी तरह स्वचालित अपरिवर्तनीय इमेज मॉडल में, घंटों में।</p> <p>कुंजी यह है कि CVE की प्रतिक्रिया को एक पुनरुत्पाद्य इंजीनियरिंग प्रक्रिया माना जाए, न कि आख़िरी घड़ी की मैनुअल दौड़।</p> <h2 id="सवचलत-परतकरय-क-आरकटकचर">स्वचालित प्रतिक्रिया की आर्किटेक्चर</h2> <p>लक्ष्य यह है कि आपको प्रभावित करने वाली गंभीर CVE आते ही एक नई पैच की हुई इमेज जन्मे, सत्यापित हो और न्यूनतम मानवीय हस्तक्षेप के साथ तैनाती के लिए तैयार रहे। इस परिपथ के चार हिस्से हैं।</p> <h3 id="1-पहचन">1. पहचान</h3> <ul> <li>Amazon Inspector, Trivy या Grype से अपनी प्रचलित इमेजों का <strong>निरंतर स्कैन</strong>।</li> <li><strong>भेद्यता फ़ीड</strong> —NVD, ऑपरेटिंग सिस्टम विक्रेता की सूचनाएँ— जो अलर्ट को खिलाती हैं।</li> <li>हर इमेज का <strong>SBOM</strong>, ताकि सेकंडों में पता चले कि भेद्य कंपोनेंट मौजूद है या नहीं।</li> </ul> <h3 id="2-टरगर">2. ट्रिगर</h3> <ul> <li>गंभीर या उच्च गंभीरता का अलर्ट पुनर्निर्माण पाइपलाइन चलाता है — जैसे EventBridge से CodeBuild की ओर, या आपके CI को webhook से।</li> <li>प्रोडक्शन के लिए मानवीय अनुमोदन रखा जा सकता है, जबकि निर्माण और सत्यापन पूरी तरह स्वचालित रहें।</li> </ul> <h3 id="3-पनरनरमण-और-सतयपन">3. पुनर्निर्माण और सत्यापन</h3> <ul> <li>पाइपलाइन —Packer या EC2 Image Builder— अद्यतन आधार से इमेज दोबारा बनाती है, <code>dnf</code>/<code>apt update</code> और सामान्य हार्डनिंग लगाते हुए।</li> <li>नई इमेज को <strong>दोबारा स्कैन</strong> किया जाता है: यदि CVE बनी रहे तो प्रकाशित करने का कोई अर्थ नहीं।</li> <li><strong>परीक्षण</strong> चलते हैं: बूट, स्मोक टेस्ट, InSpec — ताकि कुछ टूटे नहीं।</li> </ul> <h3 id="4-वतरण-और-तनत">4. वितरण और तैनाती</h3> <ul> <li>नई AMI का <strong>संस्करण</strong> बनता है, ज़रूरी रीजनों में कॉपी होती है और SSM Parameter Store का पॉइंटर अपडेट होता है।</li> <li><strong>Launch Template</strong> अपडेट होता है और Auto Scaling Group <em>रोलिंग अपडेट</em> या ब्लू/ग्रीन तैनाती करता है।</li> <li>भेद्य इमेज को <strong>अप्रचलित</strong> चिह्नित किया जाता है ताकि कोई उन्हें ग़लती से न चलाए।</li> </ul> <h2 id="मखय-मटरक-पच-क-mttr">मुख्य मीट्रिक: पैच का MTTR</h2> <p><strong>गंभीर CVE के प्रकाशन से लेकर आपके पूरे बेड़े के सुधरी इमेज पर आ जाने तक का औसत समय</strong> मापिए। यही वह संकेतक है जो आपकी परिपक्वता का सार है। इसे हफ़्तों से घंटों तक लाना, इमेज पाइपलाइन में निवेश का सबसे बड़ा प्रतिफल है।</p> <table> <thead> <tr> <th>परिपक्वता स्तर</th> <th>सामान्य MTTR</th> <th>पैच कैसे होता है</th> </tr> </thead> <tbody> <tr> <td>मैनुअल</td> <td>दिन या हफ़्ते</td> <td>सर्वर-दर-सर्वर SSH</td> </tr> <tr> <td>अर्ध-स्वचालित</td> <td>घंटों से एक-दो दिन</td> <td>मैनुअल रीबिल्ड और रोलिंग</td> </tr> <tr> <td>स्वचालित</td> <td>घंटे</td> <td>ट्रिगर, रीबिल्ड और डिप्लॉय</td> </tr> </tbody> </table> <p><em>पाइपलाइन का स्वचालन एक्सपोज़र विंडो को नाटकीय रूप से घटा देता है।</em></p> <h2 id="अचछ-तर-तरक">अच्छे तौर-तरीक़े</h2> <ul> <li><strong>पूर्वाभ्यास कीजिए</strong>: असल ज़रूरत पड़ने से पहले नक़ली CVE से पूरा परिपथ परखिए।</li> <li><strong>क्रमिक तैनाती</strong>: कैनरी या रोलिंग, ताकि सेवा गिराए बिना गिरावट पकड़ी जाए।</li> <li><strong>रोलबैक तैयार</strong>: पिछला संस्करण संभालकर रखें और तत्काल वापसी की योजना रखें।</li> <li><strong>संप्रेषण</strong>: दर्ज करें कि हर पुनर्निर्माण किस CVE से हुआ; यह अनुपालन का प्रमाण है।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या हर CVE पर दोबारा बनाना चाहिए?</strong></p> <p>नहीं। गंभीरता और शोषण-योग्यता के आधार पर प्राथमिकता दीजिए, और यह भी देखिए कि प्रभावित कंपोनेंट सचमुच आपकी इमेज में है या नहीं — यहाँ SBOM निर्णायक है। गंभीर और शोषण योग्य उच्च CVE तत्काल पुनर्निर्माण की माँग करती हैं; बाक़ी नियमित चक्र तक रुक सकती हैं।</p> <p><strong>नई इमेज तैनात करते समय प्रोडक्शन टूटने से कैसे बचूँ?</strong></p> <p>प्रकाशन से पहले स्वचालित सत्यापन —स्मोक टेस्ट, InSpec— और क्रमिक तैनाती से: कैनरी, रोलिंग या ब्लू/ग्रीन, रोलबैक तैयार रखते हुए।</p> <p><strong>क्या यह AWS के बाहर भी स्वचालित हो सकता है?</strong></p> <p>हाँ। पैटर्न —पहचान, ट्रिगर, पुनर्निर्माण, तैनाती— Azure और GCP में उनके समकक्षों के साथ भी लागू होता है; Packer निर्माण चरण में पोर्टेबिलिटी देता है।</p> <p><em>imaxe.cloud में हम नई भेद्यताओं के सामने अपनी इमेज तेज़ी से दोबारा बनाते और स्कैन करते हैं ताकि आप अद्यतन आधार से शुरू करें।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/aws-azure-gcp-%E0%A4%87%E0%A4%AE%E0%A5%87%E0%A4%9C/2026-06-26T00:00:00Z2026-08-22T15:25:49Z

AMI, Managed Image, Custom Image: एक ही चीज़ — मशीनें शुरू करने का टेम्पलेट — के लिए हर क्लाउड का अपना नाम और अपने नियम हैं। अगर आप कई क्लाउड पर काम करते हैं, तो अंतर समझना आपको आश्चर्यों से बचाता है।

<p><img src="https://www.imaxe.cloud/blog-covers/aws-azure-gcp-imagenes_hu_4cc3e453ad41116a.webp" alt="19 इंच के रैक में पैच पैनल और ईथरनेट स्विच" width="1200" height="675"></p><p>तीनों बड़े क्लाउड एक ही समस्या हल करते हैं —एक जैसी मशीनें शुरू करने के लिए पुन: प्रयोज्य टेम्पलेट रखना— पर अपने-अपने तरीक़ों और नामों के साथ। इन समकक्षताओं को जानना बिना घर्षण वाली मल्टीक्लाउड रणनीति बनाने का पहला क़दम है।</p> <p>AWS में इसे <strong>AMI</strong> (Amazon Machine Image) कहते हैं; Azure में <strong>Managed Image</strong> और सबसे बढ़कर <strong>Azure Compute Gallery</strong> (पहले Shared Image Gallery); Google Cloud में <strong>Custom Image</strong>। सभी एक पूर्व-कॉन्फ़िगर बूट डिस्क को समेटते हैं, पर संस्करण, साझा करने और वितरण के तरीक़े में भिन्न हैं।</p> <h2 id="एक-नजर-म-समककषतए">एक नज़र में समकक्षताएँ</h2> <table> <thead> <tr> <th>अवधारणा</th> <th>AWS</th> <th>Azure</th> <th>Google Cloud</th> </tr> </thead> <tbody> <tr> <td>मशीन इमेज</td> <td>AMI</td> <td>Managed Image</td> <td>Custom Image</td> </tr> <tr> <td>कैटलॉग या गैलरी</td> <td>कोई नेटिव नहीं: टैग और SSM</td> <td>Azure Compute Gallery</td> <td>Image Family</td> </tr> <tr> <td>प्रबंधित संस्करण</td> <td>मैनुअल, नाम और टैग से</td> <td>Gallery में नेटिव</td> <td>Image Family: प्रति परिवार नवीनतम</td> </tr> <tr> <td>मल्टी-रीजन वितरण</td> <td>AMI की प्रति</td> <td>Gallery में प्रतिकृतियाँ</td> <td>डिफ़ॉल्ट रूप से वैश्विक इमेज</td> </tr> <tr> <td>अंतर्निहित भंडारण</td> <td>EBS स्नैपशॉट</td> <td>Managed Disks</td> <td>Persistent Disk</td> </tr> <tr> <td>एन्क्रिप्शन</td> <td>KMS</td> <td>प्लेटफ़ॉर्म या ग्राहक कुंजियाँ</td> <td>Google-प्रबंधित या CMEK</td> </tr> </tbody> </table> <p><em>तीनों बड़े क्लाउड में मशीन इमेज की कार्यात्मक समकक्षताएँ।</em></p> <h2 id="aws-ami-वसतवक-मनक">AWS AMI: वास्तविक मानक</h2> <p>AMI संभवतः सबसे प्रसिद्ध इमेज प्रारूप है और इसका इकोसिस्टम सबसे बड़ा। इसकी ताक़त है परिपक्वता: विशाल कैटलॉग, EC2 Image Builder व Marketplace के साथ एकीकरण और बहुत बड़ा समुदाय। इसकी ऐतिहासिक कमज़ोरी है प्रबंधित संस्करण वाली नेटिव इमेज गैलरी का अभाव: संस्करण और मल्टी-रीजन वितरण नामकरण परिपाटियों, टैग, SSM Parameter Store और रीजनों के बीच स्पष्ट प्रतियों से सुलझाए जाते हैं।</p> <h2 id="azure-compute-gallery-ससकरण-और-परतकतय-बलट-इन">Azure Compute Gallery: संस्करण और प्रतिकृतियाँ बिल्ट-इन</h2> <p>Azure ने इमेज गवर्नेंस पर ज़ोरदार दाँव लगाया है। <strong>Compute Gallery</strong> नेटिव रूप से इमेज परिभाषाएँ, संस्करण और कई रीजनों तक स्वचालित प्रतिकृतियाँ देती है, साथ ही सूक्ष्म पहुँच नियंत्रण। बड़े संगठनों के लिए, जिन्हें टीमों और रीजनों के हिसाब से व्यवस्थित रूप से इमेज बाँटनी होती हैं, यह मॉडल बहुत आरामदेह है। बदले में अवधारणाओं की सीखने की ढलान थोड़ी तीखी है।</p> <h2 id="gcp-custom-image-वशवक-सरलत">GCP Custom Image: वैश्विक सरलता</h2> <p>Google Cloud सरलता के लिए जाना जाता है। इसकी इमेज डिफ़ॉल्ट रूप से <strong>वैश्विक</strong> होती हैं —रीजन-दर-रीजन कॉपी करने की ज़रूरत नहीं— और <strong>Image Family</strong> की अवधारणा संस्करण को सुंदर ढंग से हल करती है: आप परिवार की ओर इशारा करते हैं और हमेशा नवीनतम अप्रचलित-रहित इमेज मिलती है। यह घर्षण घटाने वाला न्यूनतमवादी मॉडल है, ख़ासकर उन टीमों के लिए आकर्षक जो परिचालन सरलता को महत्व देती हैं।</p> <h2 id="मलटकलउड-रणनत-एक-टमपलट-तन-इमज">मल्टीक्लाउड रणनीति: एक टेम्पलेट, तीन इमेज</h2> <p>अगर आप कई क्लाउड पर प्रकाशित या तैनात करते हैं, तो तीन अलग बिल्ड प्रक्रियाएँ बनाए रखना तकलीफ़देह है। उद्योग का समाधान है <strong>Packer</strong>: साझा प्रोविज़नर वाला एक टेम्पलेट और प्रति क्लाउड एक source ब्लॉक, जो उसी परिभाषा से AMI, Managed Image और Custom Image समानांतर बना सकता है।</p> <ul> <li>तीनों क्लाउड पर वही इंस्टॉलेशन और हार्डनिंग स्क्रिप्ट <strong>पुन: उपयोग</strong> करें।</li> <li>परिवेशों के बीच <strong>विचलन घटाएँ</strong>: वही कॉन्फ़िगरेशन, तीन गंतव्य।</li> <li>नामों और मेटाडेटा की साझा योजना से <strong>सुसंगत संस्करण</strong> रखें।</li> <li>हर गैलरी में प्रकाशन <strong>स्वचालित करें</strong>: Gallery, Image Family, टैग और SSM।</li> </ul> <h2 id="चन-कन-स">चुनें कौन सा?</h2> <p>कोई निरपेक्ष विजेता नहीं; यह आपके संदर्भ पर निर्भर है। इकोसिस्टम और परिपक्वता चाहिए तो AWS। नेटिव संस्करण व प्रतिकृतियों के साथ एंटरप्राइज़ इमेज गवर्नेंस चाहिए तो Azure की Compute Gallery चमकती है। बिना प्रतियों के सरलता और वैश्विक पहुँच पसंद है तो GCP। और अगर आप कई क्लाउड में रहते हैं, तो उत्तर कोई प्लेटफ़ॉर्म नहीं बल्कि एक <strong>अभ्यास</strong> है: अपनी इमेज को कोड की तरह वर्णित करें और उन्हें पोर्टेबल ढंग से बनाएँ।</p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या मैं AWS की AMI सीधे Azure या GCP पर ले जा सकता हूँ?</strong></p> <p>सीधे नहीं: प्रारूप और अंतर्निहित भंडारण अलग हैं। सामान्य तरीक़ा है साझा टेम्पलेट से हर क्लाउड पर इमेज दोबारा बनाना, जैसे Packer से; या हर प्रदाता की आयात प्रक्रिया से डिस्क आयात करना।</p> <p><strong>किस क्लाउड में इमेज संस्करण सबसे बेहतर है?</strong></p> <p>Azure Compute Gallery बिल्ट-इन सबसे पूर्ण प्रबंधित संस्करण देती है; GCP इसे Image Families से सुंदर ढंग से हल करता है; AWS को अपनी परिपाटियाँ ज़्यादा चाहिए, हालाँकि वह बहुत लचीला है।</p> <p><strong>क्या मल्टीक्लाउड इमेज रणनीति सार्थक है?</strong></p> <p>अगर आप डेटा संप्रभुता, लचीलेपन या विक्रेता-निर्भरता से बचने के लिए कई क्लाउड पर काम करते हैं, तो हाँ। कुंजी यह है कि इमेज को कोड की तरह इस्तेमाल करें ताकि रखरखाव का श्रम कई गुना न हो जाए।</p> <p><em>imaxe.cloud में हम डिज़ाइन से ही पोर्टेबिलिटी सोचते हैं ताकि आपकी तैनातियाँ किसी एक क्लाउड पर निर्भर न रहें।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/%E0%A4%95%E0%A5%8D%E0%A4%B2%E0%A4%BE%E0%A4%89%E0%A4%A1-%E0%A4%B0%E0%A5%81%E0%A4%9D%E0%A4%BE%E0%A4%A8-2026/2026-06-23T00:00:00Z2026-08-22T15:25:49Z

2026 ऐसा क्लाउड लेकर आता है जो महँगा, ज़्यादा नियंत्रित और ज़्यादा बुद्धिमान है। जो इन्फ़्रास्ट्रक्चर बनाते और तैनात करते हैं, उनके लिए तीन धाराएँ —अपरिवर्तनीयता, लागत नियंत्रण और AI से स्वचालन— तय करती हैं कि इस साल ध्यान कहाँ लगाना है।

<p><img src="https://www.imaxe.cloud/blog-covers/tendencias-cloud-2026_hu_c649ca0919e5a33f.webp" alt="CERN के डेटा सेंटर में सर्वरों की क़तार" width="1200" height="675"></p><p>2026 की पहली बड़ी ख़बर असुविधाजनक है: क़ीमतों में लगातार गिरावट का दौर ख़त्म हो चुका है। ऊर्जा लागत का दबाव, AI में भारी निवेश और GPU की माँग दरों को ऊपर धकेल रहे हैं। छूट अब नियम नहीं, अपवाद है।</p> <p>यह बुनियादी बदलाव बाक़ी सब कुछ तय करता है। जब क्लाउड सस्ता था, बर्बादी सह ली जाती थी; जब वह महँगा होता है, दक्षता प्रबंधन की प्राथमिकता बन जाती है। इसीलिए साल के रुझान «कम में ज़्यादा» और विवेकपूर्ण स्वचालन के इर्द-गिर्द घूमते हैं।</p> <h2 id="1-अपरवरतनय-इनफरसटरकचर-एक-मनक-क-रप-म">1. अपरिवर्तनीय इन्फ़्रास्ट्रक्चर एक मानक के रूप में</h2> <p>«इमेज बनाओ और बदल दो» मॉडल डिफ़ॉल्ट अभ्यास के रूप में मज़बूत हो रहा है। चालू सर्वर पैच करने के बजाय टीमें संस्करणित इमेज बेक करती हैं और इंस्टेंस बदलकर तैनात करती हैं। इससे मिलती हैं पूर्वानुमेय तैनातियाँ, साफ़ रोलबैक और छोटी अटैक सरफ़ेस। <strong>गोल्डन AMI</strong> और सुशासित मशीन इमेज इस दृष्टिकोण की धुरी हैं।</p> <h2 id="2-finops-परबधन-बरड-तक-पहचत-ह">2. FinOps प्रबंधन बोर्ड तक पहुँचता है</h2> <p>क्लाउड लागत प्रबंधन किसी तकनीकी टीम का मामला न रहकर कारोबारी प्राथमिकता बन जाता है। इस साल सबसे ज़्यादा इस्तेमाल होने वाले साधन:</p> <ul> <li>हर वर्कलोड की <strong>टैगिंग और दृश्यता</strong>, ताकि पता चले कौन कितना ख़र्च करता है।</li> <li>इकाई लागत पर काम करने के लिए <strong>रिज़र्व्ड और स्पॉट इंस्टेंस</strong>।</li> <li><strong>इमेज अनुकूलन</strong>: हल्की इमेज, तेज़ बूट और अनाथ स्नैपशॉट की सफ़ाई — एक क्लासिक छिपी लागत।</li> <li>निरंतर <strong>राइटसाइज़िंग</strong> और ख़ाली संसाधनों को बंद करना।</li> <li>बेहतर मूल्य-प्रदर्शन के कारण <strong>ARM और Graviton को अपनाना</strong>।</li> </ul> <h2 id="3-ai-परयग-स-मनफ-तक">3. AI: प्रयोग से मुनाफ़े तक</h2> <p>शुरुआती बुख़ार के बाद 2026 वह साल है जब AI का प्रतिफल निचोड़ा जाएगा। ध्यान हटता है निष्क्रिय GPU समय घटाने, इन्फ़रेंस अनुकूलित करने और मॉडलों को एज तक ले जाने पर। साथ ही <strong>AI एजेंट मेश</strong> का पैटर्न उभरता है: ऐसे हब जो एजेंटों के बीच संवाद का शासन करते हैं, लागत नियंत्रण लगाते हैं और अनुरोधों को उस सबसे सस्ते मॉडल तक भेजते हैं जो काम कर दे।</p> <h2 id="4-मलटकलउड-और-एज-जमन-पर-पर-रखकर">4. मल्टीक्लाउड और एज, ज़मीन पर पैर रखकर</h2> <p>मल्टीक्लाउड आम हो रहा है, पर व्यावहारिकता के साथ: फ़ैशन के लिए नहीं, बल्कि विक्रेता-निर्भरता से बचने, डेटा संप्रभुता की शर्तें पूरी करने और हर क्लाउड का सर्वोत्तम लेने के लिए। मशीन इमेज की पोर्टेबिलिटी —एक टेम्पलेट जो कई क्लाउड के लिए इमेज बनाए— का मूल्य बढ़ता है। समानांतर में <strong>एज</strong> बढ़ता है, ताकि AI और IoT के दबाव में कंप्यूट डेटा के पास पहुँचे।</p> <h2 id="5-वनयमन-अनपलन-क-सल">5. विनियमन: अनुपालन का साल</h2> <p>नियामक ढाँचा कड़ा होता है। 2026 में यूरोपीय AI विनियमन के अहम चरण और उत्तरदायित्व की नई निर्देशिकाएँ लागू होती हैं, और कई क्षेत्राधिकारों में क्लाउड शासन की अपेक्षाएँ सख़्त होती हैं। इन्फ़्रास्ट्रक्चर के लिए सीधा नतीजा: पारदर्शिता —आप कौन-सा सॉफ़्टवेयर चलाते हैं, उसे कैसे सुरक्षित करते हैं, यह कैसे साबित करते हैं— अनिवार्य हो जाती है। ऑडिट योग्य इमेज शृंखलाएँ और SBOM अब विलासिता नहीं रहीं।</p> <h2 id="आपक-इनफरसटरकचर-क-लए-इसक-मतलब">आपके इन्फ़्रास्ट्रक्चर के लिए इसका मतलब</h2> <table> <thead> <tr> <th>रुझान</th> <th>व्यावहारिक निहितार्थ</th> <th>अनुशंसित कार्रवाई</th> </tr> </thead> <tbody> <tr> <td>महँगा क्लाउड</td> <td>हर संसाधन मायने रखता है</td> <td>FinOps और कुशल इमेज</td> </tr> <tr> <td>अपरिवर्तनीयता</td> <td>कम विचलन, ज़्यादा नियंत्रण</td> <td>गोल्डन AMI पाइपलाइन</td> </tr> <tr> <td>प्रोडक्शन में AI</td> <td>इन्फ़रेंस और लागत अनुकूलित करें</td> <td>साझा GPU, एज, एजेंट</td> </tr> <tr> <td>मल्टीक्लाउड</td> <td>निर्भरता से बचें</td> <td>Packer से पोर्टेबल इमेज</td> </tr> <tr> <td>विनियमन</td> <td>अनिवार्य पारदर्शिता</td> <td>SBOM और ऑडिट योग्य शृंखलाएँ</td> </tr> </tbody> </table> <p><em>रुझान से आपके रोज़मर्रा की ठोस कार्रवाई तक।</em></p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या 2026 में क्लाउड की क़ीमत सचमुच बढ़ेगी?</strong></p> <p>विश्लेषक ऊर्जा और GPU लागत से ऊपर की ओर दबाव बताते हैं, और छूट अपवाद बनती जा रही है। इसीलिए इस साल FinOps और संसाधन दक्षता का वज़न इतना बढ़ा है।</p> <p><strong>AI एजेंट मेश क्या है?</strong></p> <p>यह एक आर्किटेक्चर है जहाँ केंद्रीय हब AI एजेंटों के बीच संवाद का शासन करता है — सुरक्षा, लागत नियंत्रण और अनुरोधों को सबसे उपयुक्त तथा किफ़ायती मॉडल तक भेजने का काम करते हुए।</p> <p><strong>अपरिवर्तनीयता नई नहीं है, फिर रुझान क्यों?</strong></p> <p>क्योंकि संदर्भ ने उसे लगभग अनिवार्य बना दिया है: बढ़ती लागत, कड़ा विनियमन और ऑडिट योग्य तैनातियों की ज़रूरत — ये सब «संस्करणित इमेज और प्रतिस्थापन» मॉडल को मानक बना देते हैं।</p> <p><em>imaxe.cloud में हम इन रुझानों पर क़रीबी नज़र रखते हैं ताकि हमारी इमेज आने वाले क्लाउड में फ़िट बैठें: कुशल, पोर्टेबल और ऑडिट योग्य।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/ami-%E0%A4%AC%E0%A4%A8%E0%A4%BE%E0%A4%AE-%E0%A4%95%E0%A4%82%E0%A4%9F%E0%A5%87%E0%A4%A8%E0%A4%B0/2026-06-19T00:00:00Z2026-08-22T15:25:49Z

मशीन इमेज या कंटेनर? सवाल ही ग़लत ढंग से रखा गया है: ये प्रतिस्पर्धी नहीं, पूरक हैं। हर एक क्या हल करता है, यह समझना ओवर-इंजीनियरिंग से बचाता है और हर वर्कलोड के लिए सही औज़ार चुनने में मदद करता है।

<p><img src="https://www.imaxe.cloud/blog-covers/amis-vs-contenedores_hu_9942fe419781baec.webp" alt="रॉटरडैम बंदरगाह पर ढेर लगे मालवाहक कंटेनर" width="1200" height="675"></p><p>एक <strong>AMI</strong> पूरा ऑपरेटिंग सिस्टम और आपका सॉफ़्टवेयर पैक करती है: यह एक पूरी वर्चुअल मशीन का टेम्पलेट है। एक <strong>कंटेनर</strong> केवल आपका एप्लिकेशन और उसकी डिपेंडेंसी पैक करता है और होस्ट का कर्नेल साझा करता है। आकार और आइसोलेशन मॉडल का यही अंतर लगभग सब कुछ समझा देता है।</p> <p>यह लड़ाई नहीं है: व्यवहार में कंटेनर उन वर्चुअल मशीनों <strong>के ऊपर</strong> चलते हैं जो किसी AMI से बूट होती हैं। काम का सवाल यह नहीं कि कौन जीतता है, बल्कि यह कि कौन किस परत को हल करता है।</p> <h2 id="आमन-समन-तलन">आमने-सामने तुलना</h2> <table> <thead> <tr> <th>आयाम</th> <th>AMI (वर्चुअल मशीन)</th> <th>कंटेनर</th> </tr> </thead> <tbody> <tr> <td>क्या शामिल है</td> <td>पूरा OS और सॉफ़्टवेयर</td> <td>ऐप और डिपेंडेंसी</td> </tr> <tr> <td>आइसोलेशन</td> <td>मज़बूत, हाइपरवाइज़र से</td> <td>प्रोसेस स्तर पर, साझा कर्नेल</td> </tr> <tr> <td>आकार</td> <td>गीगाबाइट</td> <td>मेगाबाइट</td> </tr> <tr> <td>बूट</td> <td>सेकंड से मिनट</td> <td>मिलीसेकंड से सेकंड</td> </tr> <tr> <td>घनत्व</td> <td>कम: प्रति इंस्टेंस एक VM</td> <td>ऊँचा: प्रति होस्ट कई</td> </tr> <tr> <td>पोर्टेबिलिटी</td> <td>क्लाउड या हाइपरवाइज़र से बँधी</td> <td>बहुत ऊँची: रनटाइम वाला कोई भी होस्ट</td> </tr> <tr> <td>OS रखरखाव</td> <td>आप संभालते हैं</td> <td>होस्ट या बेस इमेज से विरासत में</td> </tr> <tr> <td>आदर्श स्थिति</td> <td>मोनोलिथ, होस्ट, समर्पित VM</td> <td>माइक्रोसर्विस, तेज़ स्केलिंग</td> </tr> </tbody> </table> <p><em>AMI और कंटेनर अलग-अलग परतों पर अलग-अलग समस्याएँ हल करते हैं।</em></p> <h2 id="ami-कब-चन">AMI कब चुनें</h2> <ul> <li><strong>मज़बूत आइसोलेशन अनिवार्य हो</strong>: मल्टी-टेनेंट वर्कलोड या कड़ी नियामक शर्तें जहाँ हाइपरवाइज़र स्तर का आइसोलेशन ज़रूरी है।</li> <li><strong>ऐसा सॉफ़्टवेयर जो पूरी मशीन की अपेक्षा रखता हो</strong>: डेटाबेस, लीगेसी एप्लिकेशन, नेटवर्क या सुरक्षा उपकरण।</li> <li><strong>ऑपरेटिंग सिस्टम पर पूरा नियंत्रण</strong>: जब कर्नेल मॉड्यूल, विशिष्ट ड्राइवर या OS की बारीक ट्यूनिंग चाहिए।</li> <li><strong>आपके नोड्स का आधार</strong>: कंटेनरों की दुनिया में भी आपके Kubernetes नोड्स किसी AMI से ही बूट होते हैं।</li> </ul> <h2 id="कटनर-कब-चन">कंटेनर कब चुनें</h2> <ul> <li><strong>माइक्रोसर्विस</strong> जो स्वतंत्र रूप से स्केल और डिप्लॉय होते हैं।</li> <li>सतत एकीकरण और डिलीवरी के साथ <strong>तेज़ डिप्लॉयमेंट चक्र</strong>।</li> <li>कई छोटे वर्कलोड से हार्डवेयर निचोड़ने के लिए <strong>ऊँचा घनत्व</strong>।</li> <li>विकास, परीक्षण और कई क्लाउड के बीच <strong>पोर्टेबिलिटी</strong>।</li> </ul> <h2 id="परपकव-उततर-दन-क-मलए">परिपक्व उत्तर: दोनों को मिलाएँ</h2> <p>उन्नत टीमें एक या दूसरा नहीं चुनतीं, वे परतें बनाती हैं। वे होस्ट के आधार के रूप में एक <strong>हार्डन्ड गोल्डन AMI</strong> बनाती हैं —पैच की हुई, CIS हार्डनिंग और सुरक्षा एजेंटों के साथ— और उस पर अपने कंटेनर चलाती हैं। इस तरह उन्हें दोनों दुनियाओं का सर्वोत्तम मिलता है: मशीन इमेज स्तर पर होस्ट की सुरक्षा और नियंत्रण, और एप्लिकेशन स्तर पर कंटेनरों की फुर्ती और घनत्व।</p> <ul> <li>हार्डन्ड और संस्करणित AMI पर आधारित Kubernetes या ECS नोड्स।</li> <li>होस्ट का अपडेट AMI बदलकर (अपरिवर्तनीय), हॉट पैचिंग से नहीं।</li> <li>एप्लिकेशन के तेज़ जीवनचक्र के लिए कंटेनर।</li> </ul> <h2 id="microvm-सम-धधल-हत-ज-रह-ह">MicroVM: सीमा धुँधली होती जा रही है</h2> <p>Firecracker जैसी तकनीकें —जो AWS Lambda और Fargate के पीछे हैं— <strong>microVM</strong> बनाती हैं: वर्चुअल मशीन का मज़बूत आइसोलेशन, पर मिलीसेकंड में बूट, लगभग कंटेनर जैसा। यह संकेत है कि भविष्य «VM या कंटेनर» नहीं, बल्कि एक निरंतरता है जिसमें आप हर वर्कलोड के लिए आइसोलेशन और फुर्ती के बीच सही बिंदु चुनते हैं।</p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या कंटेनर AMI को अप्रचलित बना देते हैं?</strong></p> <p>नहीं। कंटेनर उन मशीनों पर चलते हैं जो इमेज से बूट होती हैं। आपके कंटेनर चलाने वाले नोड्स के लिए हार्डन्ड AMI आज भी आदर्श आधार है।</p> <p><strong>VM और कंटेनर में ज़्यादा सुरक्षित क्या है?</strong></p> <p>VM डिज़ाइन से ही मज़बूत आइसोलेशन देती है। कंटेनर कर्नेल साझा करते हैं, इसलिए अतिरिक्त नियंत्रण चाहिए। बहुत संवेदनशील वर्कलोड के लिए VM और हार्डन्ड कंटेनर का संयोजन सामान्य है।</p> <p><strong>क्या मैं AMI से कंटेनर पर आसानी से माइग्रेट कर सकता हूँ?</strong></p> <p>एप्लिकेशन पर निर्भर है। स्टेटलेस और मॉड्यूलर सेवाएँ अच्छे से माइग्रेट होती हैं; OS से गहरे जुड़े मोनोलिथ ज़्यादा मेहनत माँगते हैं। अक्सर हाइब्रिड और क्रमिक रुख़ बेहतर रहता है।</p> <p><em>imaxe.cloud में हम हर वर्कलोड के लिए सही औज़ार में भरोसा रखते हैं: इसीलिए हमारी इमेज सीधे होस्ट के रूप में भी काम आती हैं और आपके कंटेनरों के हार्डन्ड आधार के रूप में भी।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/%E0%A4%AD%E0%A4%B0%E0%A5%8B%E0%A4%B8%E0%A5%87%E0%A4%AE%E0%A4%82%E0%A4%A6-ami-%E0%A4%95%E0%A5%88%E0%A4%B8%E0%A5%87-%E0%A4%9A%E0%A5%81%E0%A4%A8%E0%A5%87%E0%A4%82/2026-06-16T00:00:00Z2026-08-22T15:25:49Z

हर सार्वजनिक इमेज सुरक्षित नहीं होती, और हर सुरक्षित इमेज आपके केस में फ़िट नहीं बैठती। किसी और की AMI पर इंस्टेंस चलाने से पहले बोनट के नीचे झाँक लेना ठीक रहता है। यह रही वह चेकलिस्ट जो समझदार टीमें इस्तेमाल करती हैं।

<p><img src="https://www.imaxe.cloud/blog-covers/elegir-ami-de-confianza_hu_ab14e41f927a6439.webp" alt="डाक टिकट को जाँचता आवर्धक लेंस" width="1200" height="675"></p><p>किसी AMI से इंस्टेंस लॉन्च करना व्यवहार में अपने खाते में किसी और के पैक किए सॉफ़्टवेयर को चलाना है। अगर इमेज में मालवेयर, क्रिप्टो माइनर, अंतर्निहित कुंजियाँ या केवल बिना पैच वाले पैकेज हों, तो वह जोखिम सीधे आपके इन्फ़्रास्ट्रक्चर में आ जाता है। ठीक इसी मक़सद से बनी दुर्भावनापूर्ण सार्वजनिक इमेजों के प्रलेखित मामले मौजूद हैं।</p> <p>समाधान पैरानॉइया नहीं, बल्कि दोहराने योग्य <strong>सत्यापन प्रक्रिया</strong> है। AMI अच्छी तरह चुनना किसी को नौकरी पर रखने जैसा है: चाबियाँ सौंपने से पहले आप पहचान, संदर्भ और स्थिति जाँचते हैं।</p> <h2 id="भरसमद-ami-क-पच-सतभ">भरोसेमंद AMI के पाँच स्तंभ</h2> <p>हर उम्मीदवार इमेज को इन पाँच कसौटियों पर परखें। यदि कई पर विफल हो, तो दूसरी ढूँढ़ें।</p> <h3 id="1-मल-इस-परकशत-कन-करत-ह">1. मूल: इसे प्रकाशित कौन करता है?</h3> <ul> <li>इमेज प्रकाशित करने वाले खाते का <strong>owner ID</strong> जाँचें; गुमनाम या अनजान मालिकों से सावधान रहें।</li> <li>आधिकारिक विक्रेताओं, सत्यापित साझेदारों या प्रमाणित प्रतिष्ठा वाले प्रकाशकों की इमेज प्राथमिकता दें।</li> <li>जाँचें कि नाम और विवरण किसी वैध स्रोत से मेल खाते हैं: <em>typosquatting</em> वाली नक़लों से सतर्क रहें।</li> </ul> <h3 id="2-सरकष-भतर-कय-ह">2. सुरक्षा: भीतर क्या है?</h3> <ul> <li>क्या यह <strong>हार्डन्ड</strong> है (CIS या समकक्ष) या असुरक्षित आधार है?</li> <li>क्या <strong>स्नैपशॉट एन्क्रिप्टेड</strong> हैं?</li> <li>प्रोडक्शन से पहले Inspector, Trivy या समकक्ष से ख़ुद स्कैन कर CVE और सीक्रेट खोजें।</li> <li>जाँचें कि इसमें अनजान <strong>अधिकृत SSH कुंजियाँ</strong> या अतिरिक्त उपयोगकर्ता न हों।</li> </ul> <h3 id="3-रखरखव-कय-यह-जवत-ह">3. रखरखाव: क्या यह जीवित है?</h3> <ul> <li>यह <strong>कितनी बार अपडेट</strong> होती है? साल भर से बिना नए संस्करण वाली इमेज ख़तरे की घंटी है।</li> <li>क्या प्रकाशक हर संस्करण में <strong>ठीक की गई CVE</strong> बताता है?</li> <li>क्या इसमें क्या है और कैसे कॉन्फ़िगर होती है, इसका स्पष्ट <strong>दस्तावेज़</strong> है?</li> </ul> <h3 id="4-सगतत-कय-यह-आपक-कस-म-चलग">4. संगतता: क्या यह आपके केस में चलेगी?</h3> <ul> <li>सही आर्किटेक्चर (<strong>x86_64</strong> बनाम <strong>ARM/Graviton</strong>) और वर्चुअलाइज़ेशन प्रकार।</li> <li>उपलब्ध रीजन और उसे अपने रीजन में कॉपी करने की संभावना।</li> <li>आपके ज़रूरी इंस्टेंस प्रकार का समर्थन और आपके ऑटोमेशन से संगतता।</li> </ul> <h3 id="5-लगत-और-लइसस-आप-कय-और-कन-शरत-पर-चकत-ह">5. लागत और लाइसेंस: आप क्या और किन शर्तों पर चुकाते हैं?</h3> <ul> <li>लागत मॉडल: मुफ़्त, प्रति घंटा या BYOL।</li> <li>शामिल सॉफ़्टवेयर का लाइसेंस और उसकी बाध्यताएँ।</li> <li><strong>स्नैपशॉट</strong> और संबद्ध स्टोरेज की लागत।</li> </ul> <h2 id="तवरत-सतयपन-चकलसट">त्वरित सत्यापन चेकलिस्ट</h2> <table> <thead> <tr> <th>जाँच</th> <th>अच्छा संकेत</th> <th>ख़तरे का संकेत</th> </tr> </thead> <tbody> <tr> <td>मालिक</td> <td>सत्यापित और जाना-पहचाना owner</td> <td>गुमनाम या अभी-अभी बना खाता</td> </tr> <tr> <td>एन्क्रिप्शन</td> <td>एन्क्रिप्टेड स्नैपशॉट</td> <td>बिना एन्क्रिप्शन</td> </tr> <tr> <td>अपडेट</td> <td>हालिया और नियमित संस्करण</td> <td>12 महीने से कोई बदलाव नहीं</td> </tr> <tr> <td>दस्तावेज़</td> <td>रिलीज़ नोट्स और CVE</td> <td>नगण्य या नदारद</td> </tr> <tr> <td>अपना स्कैन</td> <td>कोई गंभीर CVE या सीक्रेट नहीं</td> <td>भेद्यताएँ या अंतर्निहित कुंजियाँ</td> </tr> <tr> <td>लागत</td> <td>स्पष्ट और पूर्वानुमेय मॉडल</td> <td>छिपी स्टोरेज लागत</td> </tr> </tbody> </table> <p><em>किसी AMI को प्रोडक्शन में ले जाने से पहले हर बिंदु जाँचें।</em></p> <h2 id="अचछ-अभयस-ज-मल-ह-उस-पर-दबर-पकए">अच्छा अभ्यास: जो मिला है उसी पर दोबारा पकाएँ</h2> <p>भरोसेमंद इमेज भी पुरानी पड़ती है। सबसे सुरक्षित अभ्यास यह है कि एक विश्वसनीय बेस AMI लें और उसे <strong>अपनी पाइपलाइन में दोबारा पकाएँ</strong>: अपने पैच, अपनी हार्डनिंग और अपना कॉन्फ़िगरेशन लगाएँ, अपनी कुंजी से एन्क्रिप्ट करें और संस्करण दें। इस तरह स्रोत इमेज का अच्छा हिस्सा विरासत में मिलता है और आपकी अपनी गुणवत्ता जाँच व पारदर्शिता जुड़ जाती है।</p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या समुदाय की सार्वजनिक AMI इस्तेमाल करना सुरक्षित है?</strong></p> <p>हो सकता है, पर मालिक, सामग्री और स्थिति जाँचनी होगी और इस्तेमाल से पहले स्कैन करना होगा। प्रोडक्शन के लिए किसी भरोसेमंद प्रकाशक की इमेज बेहतर है, या ख़ुद दोबारा पका लीजिए।</p> <p><strong>कैसे पता चले कि किसी AMI में बैकडोर है?</strong></p> <p>कोई तरीक़ा अचूक नहीं, पर इमेज स्कैन करना, उपयोगकर्ता व अधिकृत कुंजियाँ देखना, निर्धारित कार्य जाँचना और एक अलग-थलग टेस्ट इंस्टेंस पर नेटवर्क ट्रैफ़िक परखना जोखिम काफ़ी घटा देता है।</p> <p><strong>क्या मुफ़्त की तुलना में सशुल्क इमेजों पर ज़्यादा भरोसा करूँ?</strong></p> <p>क़ीमत सुरक्षा की गारंटी नहीं, पर जो प्रकाशक अपनी इमेज संभालता और दस्तावेज़ करता है —सशुल्क हो या नहीं— वह आम तौर पर किसी परित्यक्त गुमनाम इमेज से ज़्यादा भरोसा देता है।</p> <p><em>imaxe.cloud में हम स्पष्ट मूल, एन्क्रिप्शन और निरंतर अपडेट वाली इमेज बनाते हैं ताकि आप भरोसे के साथ तैनात कर सकें।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/%E0%A4%95%E0%A5%8D%E0%A4%B2%E0%A4%BE%E0%A4%89%E0%A4%A1-%E0%A4%8F%E0%A4%A8%E0%A5%8D%E0%A4%95%E0%A5%8D%E0%A4%B0%E0%A4%BF%E0%A4%AA%E0%A5%8D%E0%A4%B6%E0%A4%A8-%E0%A4%AA%E0%A5%88%E0%A4%9A%E0%A4%BF%E0%A4%82%E0%A4%97-%E0%A4%85%E0%A4%A8%E0%A5%81%E0%A4%AA%E0%A4%BE%E0%A4%B2%E0%A4%A8/2026-06-12T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/cifrado-parches-cumplimiento-cloud_hu_d680a8e49016fa16.webp" alt="कीबोर्ड दिखाती एनिग्मा सिफ़र मशीन" width="1200" height="675"></p><p>संगठन नेटवर्क और एप्लिकेशन की सुरक्षा पर ख़ूब निवेश करते हैं, पर अक्सर उसी <strong>बेस इमेज</strong> को नज़रअंदाज़ कर देते हैं जिससे सब कुछ शुरू होता है। पुराने पैकेज या बिना एन्क्रिप्शन वाले स्नैपशॉट वाली AMI, उससे जन्मे हर इंस्टेंस तक जोखिम फैला देती है। अच्छी ख़बर: इमेज की सुरक्षा एक ही नियंत्रण बिंदु है और बेहद फ़ायदेमंद है।</p> <p>इसे हल करने वाली त्रयी कहने में सरल और निभाने में कठिन है: <strong>एन्क्रिप्शन</strong>, <strong>पैच</strong> और <strong>प्रमाणित अनुपालन</strong>।</p> <h2 id="1-एनकरपशन-वशरम-और-परगमन-दन-म-डट-क-रकष">1. एन्क्रिप्शन: विश्राम और पारगमन दोनों में डेटा की रक्षा</h2> <p>जब बाक़ी सब विफल हो जाए तो एन्क्रिप्शन ही बचाव की रेखा है। मशीन इमेज के लिए यह कई स्तरों पर काम करता है:</p> <ul> <li>AWS KMS से <strong>एन्क्रिप्टेड EBS स्नैपशॉट</strong>, या दूसरी क्लाउड में Azure Disk Encryption और Google CMEK।</li> <li>स्वचालित रोटेशन और न्यूनतम पहुँच नीतियों के साथ <strong>ग्राहक-प्रबंधित कुंजियाँ (CMK)</strong>।</li> <li>खाते के स्तर पर चालू <strong>डिफ़ॉल्ट एन्क्रिप्शन</strong>, ताकि कोई इमेज बिना एन्क्रिप्शन न जन्मे।</li> <li><strong>सीक्रेट इमेज से बाहर रखें</strong>: पासवर्ड या टोकन कभी बेक न करें; उन्हें Secrets Manager, Vault या Parameter Store से रनटाइम में इंजेक्ट करें।</li> </ul> <h2 id="2-पच-cve-क-सथ-दड">2. पैच: CVE के साथ दौड़</h2> <p>हर दिन भेद्यताएँ प्रकाशित होती हैं। इमेज जिस दिन बनती है उस दिन सुरक्षित होती है, और हर बीतते दिन के साथ थोड़ी कम। अपरिवर्तनीय दुनिया में पैच प्रबंधन का मतलब चालू सर्वर अपडेट करना नहीं, बल्कि बार-बार <strong>फिर से पकाना</strong> है।</p> <ul> <li><strong>पुनर्निर्माण की लय</strong>: बेस इमेज कम से कम हर महीने दोबारा बनाएँ, और अपने स्टैक की गंभीर CVE पर तुरंत।</li> <li><strong>पाइपलाइन में स्कैन</strong>: प्रकाशन से पहले CVE पकड़ने के लिए Trivy, Grype या Amazon Inspector जोड़ें।</li> <li><strong>क्वालिटी गेट</strong>: तय सीमा से ऊपर भेद्यताएँ मिलें —जैसे गंभीर या शोषण योग्य उच्च— तो प्रकाशन रोक दें।</li> <li><strong>SBOM</strong>: <em>सॉफ़्टवेयर बिल ऑफ़ मैटीरियल्स</em> बनाएँ ताकि पता रहे कि हर इमेज में क्या है और अगला Log4Shell आने पर तुरंत जवाब दे सकें।</li> </ul> <h2 id="3-अनपलन-करन-ह-नह-दखन-भ">3. अनुपालन: करना ही नहीं, दिखाना भी</h2> <p>ऑडिट में सुरक्षित होना काफ़ी नहीं: प्रमाणों से साबित करना होता है। सुशासित इमेज यह प्रमाण स्वाभाविक रूप से पैदा करती हैं।</p> <table> <thead> <tr> <th>ढाँचा</th> <th>आपकी इमेज से क्या अपेक्षा</th> <th>आप क्या प्रमाण दे सकते हैं</th> </tr> </thead> <tbody> <tr> <td>SOC 2</td> <td>सुसंगत और निगरानीयुक्त सुरक्षा नियंत्रण</td> <td>हार्डनिंग रिपोर्ट और बिल्ड लॉग</td> </tr> <tr> <td>ISO 27001</td> <td>भेद्यता प्रबंधन और परिवर्तन नियंत्रण</td> <td>CVE स्कैन, संस्करण और SBOM</td> </tr> <tr> <td>PCI DSS</td> <td>सुरक्षित कॉन्फ़िगरेशन और प्रलेखित पैचिंग</td> <td>CIS बेंचमार्क और पुनर्निर्माण इतिहास</td> </tr> <tr> <td>ENS / GDPR</td> <td>एन्क्रिप्शन और डेटा न्यूनीकरण</td> <td>KMS एन्क्रिप्शन और इमेज में निजी डेटा का अभाव</td> </tr> </tbody> </table> <p><em>सुरक्षित इमेज के अभ्यास अनुपालन प्रमाण में कैसे बदलते हैं।</em></p> <h2 id="2026-क-नय-नयमक-सदरभ">2026 का नया नियामक संदर्भ</h2> <p>नियामक माहौल सख़्त हो रहा है। 2026 में यूरोपीय एआई विनियमन के प्रमुख चरण और उत्पाद उत्तरदायित्व की नई निर्देशिकाएँ लागू होती हैं, और कई क्षेत्राधिकार क्लाउड शासन व अनुपालन की अपेक्षाएँ कड़ी कर रहे हैं। व्यावहारिक अनुवाद: आप कौन-सा सॉफ़्टवेयर चलाते हैं और उसे कैसे सुरक्षित करते हैं — इसकी पारदर्शिता अब वैकल्पिक नहीं रही। ऑडिट योग्य इमेज शृंखला ही आपका सबसे अच्छा बीमा है।</p> <h2 id="इमज-सरकष-चकलसट">इमेज सुरक्षा चेकलिस्ट</h2> <ul> <li>डिफ़ॉल्ट एन्क्रिप्शन चालू और स्नैपशॉट CMK के साथ।</li> <li>कोई बेक्ड सीक्रेट नहीं; क्रेडेंशियल का बाहरी प्रबंधन।</li> <li>हर बिल्ड में CVE स्कैन, क्वालिटी गेट सहित।</li> <li>नियमित पुनर्निर्माण और गंभीर CVE पर तत्काल।</li> <li>CIS बेंचमार्क लागू और सत्यापित।</li> <li>SBOM और बिल्ड लॉग प्रमाण के रूप में संग्रहित।</li> <li>अप्रचलित इमेज की सुरक्षित विदाई।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>अपरिवर्तनीय इमेज को कितनी बार पैच करना चाहिए?</strong></p> <p>उसे गर्म-पैच नहीं किया जाता: दोबारा बनाया जाता है। मासिक चक्र अच्छा न्यूनतम है, साथ में आपके सॉफ़्टवेयर को छूने वाली गंभीर CVE पर असाधारण पुनर्निर्माण।</p> <p><strong>SBOM क्या है और मुझे इसकी ज़रूरत क्यों है?</strong></p> <p>SBOM आपकी इमेज के सारे सॉफ़्टवेयर और डिपेंडेंसी की सूची है। इससे मिनटों में पता चल जाता है कि कोई नई भेद्यता आप पर लागू है या नहीं, और अनुपालन में इसकी माँग लगातार बढ़ रही है।</p> <p><strong>क्या एन्क्रिप्शन प्रदर्शन पर असर डालता है?</strong></p> <p>KMS के साथ EBS एन्क्रिप्शन पारदर्शी है और अधिकांश वर्कलोड के लिए इसका प्रदर्शन-प्रभाव व्यावहारिक रूप से अगोचर है।</p> <p><em>imaxe.cloud में हम अपनी इमेज पर एन्क्रिप्शन, स्कैन और निरंतर अपडेट लागू करते हैं ताकि आप ऐसी बुनियाद से शुरू करें जिसे किसी भी ऑडिट में टिकाया जा सके।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/cis-%E0%A4%B9%E0%A4%BE%E0%A4%B0%E0%A5%8D%E0%A4%A1%E0%A4%A8%E0%A4%BF%E0%A4%82%E0%A4%97-ec2-ami/2026-06-09T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/hardening-cis-ami-ec2_hu_8c72206698ec85fc.webp" alt="धातु के फाटक पर लगा ताला और ज़ंजीर" width="1200" height="675"></p><p><strong>CIS बेंचमार्क</strong> सुरक्षित कॉन्फ़िगरेशन की मार्गदर्शिकाएँ हैं, जिन्हें Center for Internet Security प्रकाशित करता है और जो विशेषज्ञों की सहमति से बनती हैं। ये ऑपरेटिंग सिस्टम —Amazon Linux, Ubuntu, RHEL, Windows— को सैकड़ों ठोस सिफ़ारिशों से ढँकती हैं: फ़ाइल अनुमतियाँ, कर्नेल पैरामीटर, पासवर्ड नीतियाँ, बंद करने योग्य सेवाएँ या ऑडिट कॉन्फ़िगरेशन।</p> <p>हार्डनिंग को <strong>AMI</strong> पर लागू करना —हर तैनात सर्वर पर नहीं— सबसे कारगर है: एक बार सख़्त कीजिए और हर इंस्टेंस सुरक्षित पैदा होगा। यही «डिफ़ॉल्ट रूप से सुरक्षित» दृष्टिकोण है, जिसकी माँग ISO 27001, SOC 2, PCI DSS या राष्ट्रीय सुरक्षा ढाँचे करते हैं।</p> <h2 id="l1-और-l2-सतर-कतन-कस">L1 और L2 स्तर: कितना कसें</h2> <p>CIS स्तर के हिसाब से प्रोफ़ाइल तय करता है। सही चुनाव अति-उत्साह में एप्लिकेशन तोड़ने से बचाता है।</p> <table> <thead> <tr> <th>प्रोफ़ाइल</th> <th>उद्देश्य</th> <th>कब इस्तेमाल करें</th> </tr> </thead> <tbody> <tr> <td>Level 1 (L1)</td> <td>बिना उल्लेखनीय कार्यात्मक असर के आवश्यक सुरक्षा</td> <td>अधिकांश वर्कलोड के लिए शुरुआती बिंदु</td> </tr> <tr> <td>Level 2 (L2)</td> <td>संवेदनशील परिवेशों के लिए गहन रक्षा</td> <td>नियंत्रित डेटा, ऊँचा जोखिम; समायोजन लग सकते हैं</td> </tr> <tr> <td>STIG</td> <td>अमेरिकी रक्षा विभाग की अपेक्षाएँ</td> <td>सरकारी या रक्षा अनुबंध</td> </tr> </tbody> </table> <p><em>CIS हार्डनिंग प्रोफ़ाइल और उनका दायरा।</em></p> <h2 id="इमज-म-हरडनग-सवचलत-कस-कर">इमेज में हार्डनिंग स्वचालित कैसे करें</h2> <p>हाथ से सख़्ती न स्केल होती है, न ऑडिट योग्य। इसे बिल्ड पाइपलाइन में लाने के तीन सबसे प्रचलित रास्ते ये हैं:</p> <ul> <li><strong>CIS कंपोनेंट के साथ EC2 Image Builder</strong>: AWS प्रबंधित CIS स्तरों से एकीकरण देता है, जो बिल्ड के दौरान बेंचमार्क लगाते और जाँचते हैं; Marketplace में CIS Hardened इमेज का विकल्प भी है।</li> <li><strong>हार्डनिंग रोल के साथ Ansible</strong>: Packer के प्रोविज़नर के भीतर Linux के लिए CIS-आधारित रोल दोबारा इस्तेमाल करें; यह क्लाउडों के बीच पोर्टेबल है।</li> <li><strong>अपनी आइडेम्पोटेंट स्क्रिप्ट</strong>: विशिष्ट मामलों के लिए — पूरा नियंत्रण फ़ायदा, रखरखाव नुक़सान।</li> </ul> <h2 id="उचच-परभव-वल-नयतरण-ज-छटन-न-चहए">उच्च प्रभाव वाले नियंत्रण जो छूटने न चाहिए</h2> <p>अगर प्राथमिकता तय करनी हो, तो ये CIS नियंत्रण सबसे कम लागत में सबसे ज़्यादा जोखिम घटाते हैं:</p> <ul> <li><strong>SSH से सीधा root प्रवेश बंद करें</strong> और कुंजी से पहुँच अनिवार्य करें, पासवर्ड से कभी नहीं।</li> <li>अटैक सरफ़ेस घटाने के लिए <strong>अनावश्यक पैकेज और सेवाएँ हटाएँ</strong>।</li> <li><strong>होस्ट फ़ायरवॉल कॉन्फ़िगर करें</strong> (firewalld या nftables) डिफ़ॉल्ट अस्वीकृति के साथ।</li> <li><strong>ऑडिटिंग चालू करें</strong> (<code>auditd</code>) और घटनाओं का केंद्रीकृत लॉग रखें।</li> <li>स्पूफ़िंग और नेटवर्क हमलों के विरुद्ध <strong>सुरक्षित कर्नेल पैरामीटर</strong> (<code>sysctl</code>) लगाएँ।</li> <li><strong>कड़ी पासवर्ड नीतियाँ और खाता लॉकआउट।</strong></li> <li><strong>महत्वपूर्ण फ़ाइलों पर सही अनुमतियाँ</strong>: <code>/etc/passwd</code>, <code>/etc/shadow</code> और बूट डायरेक्टरी।</li> </ul> <h2 id="जच-क-हरडनग-सचमच-लग">जाँचें कि हार्डनिंग सचमुच लगी</h2> <p>बिना सत्यापन सख़्ती करना श्रद्धा का काम है। एक स्वचालित सत्यापन चरण जोड़ें जो इमेज को बेंचमार्क पर अंक दे और सीमा से नीचे रहने पर बिल्ड विफल कर दे।</p> <ul> <li><strong>CIS-CAT, InSpec या OpenSCAP</strong> ताज़ा बेक इंस्टेंस को स्कैन कर अनुपालन रिपोर्ट बनाते हैं।</li> <li><strong>उत्तीर्ण सीमा</strong>: क्वालिटी गेट के रूप में तय करें, जैसे «L1 के ≥ 95 % नियंत्रण पास»।</li> <li><strong>ऑडिट प्रमाण</strong>: रिपोर्ट को बिल्ड आर्टिफ़ैक्ट के रूप में रखें; अगली SOC 2 या ISO ऑडिट में यह सोना साबित होगी।</li> </ul> <h2 id="सतलन-एपलकशन-तड-बन-सरकष">संतुलन: एप्लिकेशन तोड़े बिना सुरक्षा</h2> <p>क्लासिक ग़लती है L2 को आँख मूँदकर लगाना और फिर पता चलना कि एप्लिकेशन चलता ही नहीं। समझदार रणनीति: L1 से शुरू करें, मापें और स्टेजिंग में परखते हुए चुनिंदा L2 नियंत्रण बढ़ाएँ। हर न्यायोचित अपवाद दर्ज करें; कारण सहित बंद किया नियंत्रण ऑडिट में स्वीकार्य है, चुपचाप बंद किया नहीं।</p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>क्या CIS हार्डनिंग मेरे इंस्टेंस धीमे कर देती है?</strong></p> <p>L1 प्रोफ़ाइल का प्रदर्शन-प्रभाव व्यावहारिक रूप से शून्य है। L2 के कुछ सघन ऑडिट नियंत्रण अतिरिक्त भार डाल सकते हैं, इसीलिए उन्हें चुनिंदा ढंग से लगाया और मापा जाता है।</p> <p><strong>क्या मुझे CIS Hardened इमेज ख़रीदनी होंगी या ख़ुद कर सकता हूँ?</strong></p> <p>आप ख़ुद Ansible, OpenSCAP या EC2 Image Builder के कंपोनेंट से सख़्ती कर सकते हैं। Marketplace की CIS Hardened इमेज मेहनत बचाती हैं और सत्यापन साथ लाती हैं, पर अनिवार्य नहीं।</p> <p><strong>क्या हार्डनिंग से ही ISO 27001 या PCI DSS पूरा हो जाता है?</strong></p> <p>हार्डनिंग एक अहम तकनीकी नियंत्रण है, पर अनुपालन में प्रक्रियाएँ, नीतियाँ और प्रमाण भी आते हैं। AMI सख़्त करना आपको काफ़ी क़रीब ले जाता है, पर बाक़ी ढाँचे की जगह नहीं लेता।</p> <p><em>imaxe.cloud में हम उद्योग की अच्छी प्रथाओं के अनुसार हार्डन्ड इमेज से शुरुआत करते हैं ताकि आप सुरक्षित आधार पर तैनात करें।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/ami-%E0%A4%9C%E0%A5%80%E0%A4%B5%E0%A4%A8%E0%A4%9A%E0%A4%95%E0%A5%8D%E0%A4%B0/2026-06-05T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/ciclo-de-vida-ami_hu_d04b0e8cea647c79.webp" alt="खुले हुए हार्ड डिस्क की प्लेट और हेड" width="1200" height="675"></p><p>कई टीमें AMI को ऐसी चीज़ मानती हैं जो एक बार बनाई और भुला दी जाती है। समस्या महीनों बाद दिखती है: दर्जनों बिना टैग वाली इमेज, ऐसे EBS स्नैपशॉट जिनके बारे में किसी को नहीं पता कि हटाए जा सकते हैं या नहीं, और बिना स्पष्टीकरण बढ़ता बिल। <strong>AMI का जीवनचक्र</strong> संभालने का मतलब है उसे एक सॉफ़्टवेयर आर्टिफ़ैक्ट की तरह देखना — जन्म, संस्करण, परिपक्वता, डेप्रिकेशन और विदाई के साथ।</p> <p>अच्छी इमेज गवर्नेंस लागत घटाती है, सुरक्षा सुधारती है —कोई ग़लती से साल भर पुरानी बिना पैच वाली इमेज नहीं चलाता— और अनुपालन ऑडिट आसान बनाती है।</p> <h2 id="चरण-1--अरथपरण-ससकरण">चरण 1 — अर्थपूर्ण संस्करण</h2> <p>संस्करण रीढ़ की हड्डी है। इसके बिना «आख़िरी अच्छी AMI» गलियारे की बातचीत है, आँकड़ा नहीं। हम एक पठनीय और सुसंगत योजना की सलाह देते हैं।</p> <ul> <li><strong>संस्करण सहित नाम</strong>: जैसे <code>imaxe-ubuntu22-nginx-2026.07.1</code>, जिसमें उत्पाद, आधार और कैलेंडर संस्करण हों।</li> <li><strong>अनिवार्य टैग</strong>: <code>Version</code>, <code>GitCommit</code>, <code>BuildDate</code>, <code>Owner</code>, <code>Environment</code>, <code>CISLevel</code>, <code>Status</code>।</li> <li><strong>अपरिवर्तनीय: एक संस्करण, एक आर्टिफ़ैक्ट।</strong> प्रकाशित AMI को कभी न बदलें; नया संस्करण बनाएँ।</li> <li><strong>केंद्रीय रजिस्ट्री</strong>: «मौजूदा प्रोडक्शन AMI» का ID रखने के लिए AWS Systems Manager Parameter Store इस्तेमाल करें, ताकि आपके Launch Template उसे संदर्भ से पढ़ें।</li> </ul> <h2 id="चरण-2--छर-स-छर-तक-एनकरपशन">चरण 2 — छोर से छोर तक एन्क्रिप्शन</h2> <p>AMI का डेटा EBS स्नैपशॉट में रहता है। अगर वे एन्क्रिप्ट नहीं हैं, तो कोई भी बेतरतीब प्रति संभावित रिसाव है। एन्क्रिप्शन नियम होना चाहिए, अपवाद नहीं।</p> <ul> <li><strong>डिफ़ॉल्ट एन्क्रिप्शन</strong>: खाते और रीजन स्तर पर <em>EBS encryption by default</em> चालू करें।</li> <li><strong>आपकी प्रबंधित कुंजियाँ (CMK)</strong>: अनुमतियाँ और रोटेशन नियंत्रित करने के लिए AWS की डिफ़ॉल्ट कुंजी के बजाय अपनी KMS कुंजी इस्तेमाल करें।</li> <li><strong>कॉपी यानी दोबारा एन्क्रिप्शन</strong>: AMI को दूसरे रीजन या खाते में कॉपी करते समय उसे गंतव्य कुंजी से दोबारा एन्क्रिप्ट कर लें।</li> <li><strong>KMS grants से साझा करें</strong>: दूसरे खातों को AMI बाँटते समय न्यूनतम नीतियों के साथ कुंजी तक पहुँच दें।</li> </ul> <h2 id="चरण-3--डपरकशन-हटन-स-पहल-चतवन">चरण 3 — डेप्रिकेशन: हटाने से पहले चेतावनी</h2> <p>AWS किसी AMI को तारीख़ के साथ <strong>अप्रचलित</strong> (<em>deprecated</em>) चिह्नित करने देता है। उस क्षण से वह खोजों में डिफ़ॉल्ट रूप से दिखना बंद हो जाती है, पर जो उसे स्पष्ट रूप से संदर्भित करता है उसके लिए काम करती रहती है। यह «चालू» और «हटाई हुई» के बीच का सभ्य क़दम है: आप चेतावनी देते हैं, माइग्रेशन का समय देते हैं और तैनातियाँ नहीं तोड़ते।</p> <h2 id="चरण-4--सवचलत-सफई-और-सनपशट-क-छप-लगत">चरण 4 — स्वचालित सफ़ाई (और स्नैपशॉट की छिपी लागत)</h2> <p>पैसा यहीं है। जब आप कोई AMI हटाते हैं, तो उससे जुड़े EBS स्नैपशॉट <strong>अपने आप नहीं हटते</strong>। रहस्यमय ढंग से बढ़ते स्टोरेज बिलों का यही नंबर एक कारण है। विदाई की नीति को AMI डीरजिस्टर करना चाहिए और उसके बाद अनाथ स्नैपशॉट हटाने चाहिए।</p> <ul> <li><strong>रिटेंशन नीति</strong>: N हालिया संस्करण रखें (जैसे आख़िरी तीन) और बाक़ी विदा करें।</li> <li><strong>क्लाउड से स्वचालित करें</strong>: Amazon Data Lifecycle Manager (DLM) नीति के आधार पर इमेज बनाना और हटाना संभाल सकता है।</li> <li><strong>अनाथ स्नैपशॉट खोजें</strong>: बिना जुड़ी AMI वाले स्नैपशॉट का समय-समय पर ऑडिट कर उन्हें हटाएँ।</li> <li><strong>कभी आँख मूँदकर न हटाएँ</strong>: विदा करने से पहले जाँचें कि कोई सक्रिय इंस्टेंस या Launch Template उस AMI पर निर्भर तो नहीं।</li> </ul> <h2 id="जवनचकर-सरश-तलक">जीवनचक्र सारांश तालिका</h2> <table> <thead> <tr> <th>चरण</th> <th>मुख्य क्रिया</th> <th>उपकरण या सेवा</th> </tr> </thead> <tbody> <tr> <td>निर्माण</td> <td>पुनरुत्पाद्य बिल्ड और टैगिंग</td> <td>Packer / EC2 Image Builder</td> </tr> <tr> <td>एन्क्रिप्शन</td> <td>CMK से एन्क्रिप्टेड स्नैपशॉट</td> <td>AWS KMS + EBS default encryption</td> </tr> <tr> <td>वितरण</td> <td>मल्टी-रीजन या मल्टी-अकाउंट कॉपी व पुनः एन्क्रिप्शन</td> <td>AMI copy / AWS RAM</td> </tr> <tr> <td>प्रचलन</td> <td>मौजूदा ID की रजिस्ट्री</td> <td>SSM Parameter Store</td> </tr> <tr> <td>डेप्रिकेशन</td> <td>तारीख़ के साथ अप्रचलित चिह्नित करना</td> <td><code>ec2 enable-image-deprecation</code></td> </tr> <tr> <td>विदाई</td> <td>डीरजिस्टर और स्नैपशॉट हटाना</td> <td>DLM / निर्धारित स्क्रिप्ट</td> </tr> </tbody> </table> <p><em>AMI गवर्नेंस के छह चरण और उन्हें स्वचालित करने का तरीक़ा।</em></p> <h2 id="जन-मटरक-पर-नजर-रख">जिन मीट्रिक पर नज़र रखें</h2> <ul> <li>उपयोग में मौजूद AMI की <strong>औसत आयु</strong>: जितनी कम, उतने बेहतर पैच।</li> <li><strong>अनाथ स्नैपशॉट की संख्या</strong> और उनकी मासिक लागत।</li> <li><strong>एन्क्रिप्टेड AMI का प्रतिशत</strong>, लक्ष्य 100 %।</li> <li><strong>गंभीर CVE से नई इमेज प्रकाशन तक का समय</strong>, यानी पैच का MTTR।</li> </ul> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>AMI हटा देने के बाद भी मेरा EBS बिल क्यों बढ़ रहा है?</strong></p> <p>क्योंकि AMI डीरजिस्टर करने से उसके स्नैपशॉट नहीं हटते। उन्हें स्पष्ट रूप से हटाना होगा। अनाथ स्नैपशॉट का नियमित ऑडिट करें; आम तौर पर यही सबसे बड़ी छिपी लागत होती है।</p> <p><strong>क्या एन्क्रिप्टेड AMI दूसरे खाते से साझा करना सुरक्षित है?</strong></p> <p>हाँ, बशर्ते आप KMS कुंजी तक पहुँच किसी विशिष्ट grant और न्यूनतम अनुमतियों से दें। उस पहुँच के बिना गंतव्य खाता इमेज लॉन्च नहीं कर पाएगा।</p> <p><strong>AMI के कितने संस्करण रखने चाहिए?</strong></p> <p>यह आपकी रोलबैक और अनुपालन ज़रूरतों पर निर्भर है, पर दो से चार हालिया संस्करण रखना आम तौर पर रोलबैक सुरक्षा और लागत के बीच अच्छा संतुलन होता है।</p> <p><em>imaxe.cloud में हम अपनी इमेज शुरू से ही संस्करण और एन्क्रिप्शन के साथ डिज़ाइन करते हैं, ताकि उनका जीवनचक्र पूर्वानुमेय और ऑडिट योग्य रहे।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/golden-ami-packer-%E0%A4%AA%E0%A4%BE%E0%A4%87%E0%A4%AA%E0%A4%B2%E0%A4%BE%E0%A4%87%E0%A4%A8/2026-06-02T00:00:00Z2026-08-22T15:25:49Z

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

<p><img src="https://www.imaxe.cloud/blog-covers/golden-ami-packer-pipeline_hu_cdeb95d898f689f8.webp" alt="सिस्टम रूम में सर्वर कैबिनेट" width="1200" height="675"></p><p><strong>गोल्डन AMI</strong> («सुनहरी इमेज») एक पूर्व-कॉन्फ़िगर, हार्डन्ड और सत्यापित Amazon Machine Image है, जो एक जैसे EC2 इंस्टेंस चलाने का इकलौता टेम्पलेट बनती है। हर बार ख़ाली सर्वर चलाकर हाथ से डिपेंडेंसी लगाने के बजाय, आप सब कुछ एक ही बार «बेक» कर देते हैं —पैच किया ऑपरेटिंग सिस्टम, एजेंट, रनटाइम, कॉन्फ़िगरेशन और सुरक्षा नियंत्रण— और हर तैनाती में उसे दोबारा इस्तेमाल करते हैं।</p> <p>यह दृष्टिकोण <strong>अपरिवर्तनीय इन्फ़्रास्ट्रक्चर</strong> की बुनियाद है: सर्वरों को गर्म हालत में पैच नहीं किया जाता, बल्कि नई इमेज बनाकर इंस्टेंस बदल दिए जाते हैं। नतीजा: कम कॉन्फ़िगरेशन विचलन, ऑटोस्केलिंग में तेज़ बूट, और ऐसी तैनातियाँ जिन्हें ऑडिट और वापस दोनों किया जा सकता है।</p> <h2 id="गलडन-ami-बनम-बट-पर-बटसटरपग">गोल्डन AMI बनाम बूट पर बूटस्ट्रैपिंग</h2> <p>दो दर्शन हैं। <strong>बूटस्ट्रैपिंग</strong> में इंस्टेंस बूट पर ख़ुद को कॉन्फ़िगर करता है (user-data, Ansible pull, cloud-init)। यह लचीला है पर धीमा और नाज़ुक: कोई पैकेज रिपॉज़िटरी गिरी तो आपकी ऑटोस्केलिंग विफल। <strong>गोल्डन AMI (बेकिंग)</strong> मॉडल में भारी काम पाइपलाइन में एक ही बार होता है; बूट लगभग तात्कालिक और नियतात्मक। अधिकांश परिपक्व टीमें दोनों मिलाती हैं: स्थिर हिस्सा बेक करती हैं और बूट पर सिर्फ़ वही कॉन्फ़िगरेशन छोड़ती हैं जो परिवेश के साथ बदलता है।</p> <h2 id="packer-ह-कय">Packer ही क्यों</h2> <p>HashiCorp का Packer एक ही टेम्पलेट से स्वचालित और मल्टीक्लाउड मशीन इमेज बनाने का वास्तविक मानक औज़ार है। आप इमेज को कोड (HCL2) की तरह परिभाषित करते हैं; यह एक अस्थायी इंस्टेंस चलाता है, आपके प्रोविज़नर लगाता है, AMI बनाता है और अस्थायी संसाधन नष्ट कर देता है। वही टेम्पलेट AWS, Azure और GCP के लिए इमेज बना सकता है, जो कई क्लाउड पर प्रकाशित करने वालों के लिए आदर्श है।</p> <ul> <li><strong>पुनरुत्पाद्य</strong>: इमेज Git में संस्करणित फ़ाइल में वर्णित होती है।</li> <li><strong>मल्टीक्लाउड</strong>: AMI, Azure Managed Image और GCP Custom Image के लिए एक ही प्रवाह।</li> <li><strong>एकीकृत करने योग्य</strong>: CI/CD में बैठता है (GitHub Actions, GitLab CI, CodePipeline)।</li> <li><strong>ऑडिट योग्य</strong>: हर बिल्ड दर्ज रहता है, अपने manifest और आर्टिफ़ैक्ट के साथ।</li> </ul> <h2 id="packer-टमपलट-hcl2-क-शररक">Packer टेम्पलेट (HCL2) की शारीरिकी</h2> <p>आधुनिक टेम्पलेट खंडों में बँटा होता है। <strong>source</strong> खंड बिल्डर (जैसे <code>amazon-ebs</code>), बेस AMI, इंस्टेंस प्रकार और रीजन तय करता है। <strong>build</strong> खंड उन <strong>प्रोविज़नर</strong> को जोड़ता है जो सॉफ़्टवेयर इंस्टॉल और कॉन्फ़िगर करते हैं। <strong>post-processor</strong> ऐसे आर्टिफ़ैक्ट बनाते हैं, जैसे बनी AMI के ID वाला JSON manifest।</p> <h3 id="टपपण-सहत-नयनतम-उदहरण">टिप्पणी सहित न्यूनतम उदाहरण</h3> <p><code>source &quot;amazon-ebs&quot; &quot;app&quot;</code> — किसी आधिकारिक बेस AMI से शुरू होता है, जिसे <code>data &quot;amazon-ami&quot;</code> से मालिक और नाम पैटर्न पर छानकर गतिशील रूप से खोजा जाता है, ताकि कोई ऐसा ID न ठुक जाए जो बाद में बेकार हो जाए।</p> <p><code>provisioner &quot;shell&quot;</code> — इंस्टॉलेशन और अपडेट स्क्रिप्ट चलाता है (<code>dnf update -y</code>, रनटाइम, CloudWatch एजेंट, SSM एजेंट)।</p> <p><code>provisioner &quot;ansible&quot;</code> — अगर आपके पास पहले से Ansible रोल हैं, तो उन्हीं से इमेज को आइडेम्पोटेंट ढंग से कॉन्फ़िगर करें।</p> <p><code>post-processor &quot;manifest&quot;</code> — <code>manifest.json</code> लिखता है जिसमें <code>artifact_id</code> होता है; आपकी पाइपलाइन उसे पढ़कर जानती है कि कौन-सी AMI जन्मी।</p> <h2 id="चरण-दर-चरण-पइपलइन">चरण-दर-चरण पाइपलाइन</h2> <p>गोल्डन AMI को कमिट से प्रोडक्शन तक सुरक्षित और दोहराने योग्य ढंग से ले जाने के लिए हम यह प्रवाह सुझाते हैं:</p> <table> <thead> <tr> <th>चरण</th> <th>क्या होता है</th> <th>सामान्य औज़ार</th> </tr> </thead> <tbody> <tr> <td>1. Commit</td> <td>टेम्पलेट या स्क्रिप्ट बदलकर Git में पुश करते हैं</td> <td>Git / PR समीक्षा</td> </tr> <tr> <td>2. Validate</td> <td><code>packer fmt</code> + <code>packer validate</code> वाक्यविन्यास जाँचते हैं</td> <td>Packer, CI</td> </tr> <tr> <td>3. Build</td> <td>Packer अस्थायी इंस्टेंस चलाकर प्रोविज़नर लगाता है</td> <td>Packer</td> </tr> <tr> <td>4. Harden</td> <td>CIS बेंचमार्क लगता है और क्रेडेंशियल साफ़ होते हैं</td> <td>Ansible / CIS</td> </tr> <tr> <td>5. Scan</td> <td>भेद्यता और सीक्रेट स्कैन</td> <td>Trivy, Inspector</td> </tr> <tr> <td>6. Test</td> <td>एक इंस्टेंस चलाकर सत्यापन होता है</td> <td>InSpec / Goss</td> </tr> <tr> <td>7. Tag &amp; version</td> <td>AMI पर टैग लगते हैं (संस्करण, कमिट, तारीख़)</td> <td>AWS CLI</td> </tr> <tr> <td>8. Distribute</td> <td>दूसरे रीजन या खातों में साझा या कॉपी होती है</td> <td>AWS RAM / copy</td> </tr> <tr> <td>9. Deploy</td> <td>Launch Template में AMI का संदर्भ दिया जाता है</td> <td>Terraform / ASG</td> </tr> </tbody> </table> <p><em>नौ चरणों वाली गोल्डन AMI पाइपलाइन का संदर्भ प्रवाह।</em></p> <h2 id="ज-अभयस-सचमच-फरक-डलत-ह">जो अभ्यास सचमुच फ़र्क़ डालते हैं</h2> <ul> <li><strong>बेस AMI को कभी ID से न बाँधें</strong>: उसे मालिक और नाम से गतिशील रूप से खोजें ताकि हमेशा नवीनतम पैच विरासत में मिलें।</li> <li><strong>इमेज का संस्करण रखें</strong> स्पष्ट योजना से (जैसे <code>app-2026.07.1</code>) और Git कमिट AMI टैग में सहेजें।</li> <li><strong>सील करने से पहले साफ़ करें</strong>: लॉग, शेल इतिहास, अस्थायी SSH कुंजियाँ और पैकेज कैश हटाएँ ताकि सीक्रेट न रिसें।</li> <li><strong>हमेशा स्कैन करें</strong>: Trivy या Amazon Inspector जोड़ें ताकि ज्ञात CVE प्रकाशित न हों।</li> <li><strong>स्नैपशॉट एन्क्रिप्ट करें</strong> पहले ही मिनट से अपनी KMS कुंजी के साथ।</li> <li><strong>समाप्ति स्वचालित करें</strong>: पुराने संस्करण अप्रचलित चिह्नित कर हटाएँ ताकि लागत क़ाबू में रहे।</li> </ul> <h2 id="packer-य-ec2-image-builder-कय-चन">Packer या EC2 Image Builder: क्या चुनूँ?</h2> <p>अगर आप सिर्फ़ AWS पर काम करते हैं और Inspector के साथ नेटिव एकीकरण, प्रबंधित CIS कंपोनेंट और शून्य रखरखाव वाली इन्फ़्रास्ट्रक्चर पसंद करते हैं, तो <strong>EC2 Image Builder</strong> ठोस और बिना लाइसेंस लागत वाला विकल्प है। अगर एक ही टेम्पलेट से कई क्लाउड के लिए बनाना है, या आपके पास पहले से HashiCorp इकोसिस्टम (Terraform, Vault) है, तो <strong>Packer</strong> ज़्यादा पोर्टेबिलिटी देगा। ये परस्पर अनन्य नहीं: कई टीमें मल्टीक्लाउड तर्क के लिए Packer और आंतरिक AWS पाइपलाइनों के लिए Image Builder इस्तेमाल करती हैं।</p> <h2 id="अकसर-पछ-जन-वल-सवल">अक्सर पूछे जाने वाले सवाल</h2> <p><strong>गोल्डन AMI कितनी बार दोबारा बनानी चाहिए?</strong></p> <p>कम से कम ऑपरेटिंग सिस्टम के हर पैच चक्र पर (मासिक आम तौर पर अच्छी लय है) और जब भी आपके स्टैक में कोई गंभीर CVE प्रकाशित हो। स्वचालित पाइपलाइन से मिनटों में माँग पर पुनर्निर्माण संभव है।</p> <p><strong>क्या वही Packer टेम्पलेट AWS और Azure दोनों के लिए इस्तेमाल हो सकता है?</strong></p> <p>हाँ। Packer एक ही बिल्ड में कई बिल्डर समर्थित करता है। प्रोविज़नर साझा रहते हैं और सिर्फ़ हर क्लाउड का source खंड बदलता है, जिससे समानांतर में AMI, Managed Image और Custom Image बनती हैं।</p> <p><strong>गोल्डन AMI या कंटेनर?</strong></p> <p>यह «या» का सवाल नहीं है। गोल्डन AMI होस्ट परत और बिना कंटेनराइज़ वर्कलोड के लिए आदर्श हैं; कंटेनर उसके ऊपर चलते हैं। दरअसल, हार्डन्ड गोल्डन AMI आपके Kubernetes नोड्स के लिए बेहतरीन आधार बनती है।</p> <p><em>imaxe.cloud में हम हार्डन्ड और अद्यतन बेस इमेज बनाते और संभालते हैं ताकि आपकी पाइपलाइन भरोसेमंद बुनियाद से शुरू हो।</em></p>https://www.imaxe.cloud/hi/%E0%A4%AC%E0%A5%8D%E0%A4%B2%E0%A5%89%E0%A4%97/zabbix-7-lts/2026-05-28T00:00:00Z2026-08-22T15:25:49Z

नवीनीकृत frontend, SLA widgets और पुनर्लिखित SQS रीडर। हम नई LTS लाइन की सुविधाओं और बिना इतिहास खोए 6.0 से माइग्रेट करने का तरीका बताते हैं।

<p><img src="https://www.imaxe.cloud/blog-covers/zabbix-7-lts_hu_a2d5ca0fc6cd5b29.webp" alt="नियंत्रण कक्ष में डायग्नोस्टिक मॉनिटर" width="1200" height="675"></p>