👇🏿 🧑 📋 Node.js: कंटेनरों में चलने वाले अनुप्रयोगों के लिए उपलब्ध स्मृति का प्रबंधन 💆🏼 🌹 🙅🏼

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

सिफारिशों की समीक्षा

मान लीजिए कि एक Node.js अनुप्रयोग एक कंटेनर में एक निर्धारित मेमोरी सीमा के साथ चलता है। अगर हम डॉकर के बारे में बात कर रहे हैं, तो इस सीमा को निर्धारित करने के लिए विकल्प - --memory का उपयोग किया जा सकता है। कंटेनर ऑर्केस्ट्रेशन सिस्टम के साथ काम करते समय कुछ ऐसा ही संभव है। इस स्थिति में, यह अनुशंसा की जाती है कि Node.js एप्लिकेशन शुरू करते समय, --max-old-space-size विकल्प का उपयोग करें। यह आपको प्लेटफ़ॉर्म को यह सूचित करने की अनुमति देता है कि इसके लिए कितनी मेमोरी उपलब्ध है, और इस तथ्य को भी ध्यान में रखना चाहिए कि यह राशि कंटेनर स्तर पर निर्धारित सीमा से कम होनी चाहिए।

जब Node.js एप्लिकेशन कंटेनर के अंदर चलता है, तो एप्लिकेशन द्वारा सक्रिय मेमोरी उपयोग के चरम मूल्य के अनुसार इसके लिए उपलब्ध मेमोरी की क्षमता निर्धारित करें। यह तब किया जाता है जब कंटेनर मेमोरी सीमा को कॉन्फ़िगर किया जा सकता है।

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

डोकर मेमोरी लिमिट

डिफ़ॉल्ट रूप से, कंटेनरों में संसाधन सीमा नहीं होती है और वे उतनी मेमोरी का उपयोग कर सकते हैं जितना ऑपरेटिंग सिस्टम उन्हें अनुमति देता है। docker run कमांड में कमांड लाइन विकल्प होते हैं जो आपको मेमोरी उपयोग या प्रोसेसर संसाधनों के बारे में सीमा निर्धारित करने की अनुमति देते हैं।

कंटेनर लॉन्च कमांड इस तरह दिख सकता है:

 docker run --memory <x><y> --interactive --tty <imagename> bash

कृपया निम्नलिखित पर ध्यान दें:

x कंटेनर में उपलब्ध मेमोरी की मात्रा की सीमा है, जिसे y इकाइयों में व्यक्त किया गया है।
y मान b (बाइट्स), k (किलोबाइट्स), m (मेगाबाइट), g (गीगाबाइट्स) ले सकता है।

यहाँ कंटेनर लॉन्च कमांड का एक उदाहरण दिया गया है:

 docker run --memory 1000000b --interactive --tty <imagename> bash

यहां, मेमोरी सीमा 1000000 बाइट्स पर सेट है।

कंटेनर स्तर पर सेट की गई मेमोरी सीमा की जांच करने के लिए, आप कंटेनर में, निम्न कमांड चला सकते हैं:

 cat /sys/fs/cgroup/memory/memory.limit_in_bytes

चलिए सिस्टम के व्यवहार के बारे में बात करते हैं --max-old-space-size एप्लिकेशन मेमोरी सीमा को निर्दिष्ट करते हुए - --max-old-space-size कुंजी का उपयोग करते हुए। इस मामले में, यह मेमोरी सीमा कंटेनर स्तर पर निर्धारित सीमा के अनुरूप होगी।

कुंजी नाम में "ओल्ड-स्पेस" कहा जाता है, वी 8 द्वारा नियंत्रित ढेर के टुकड़ों में से एक है (वह स्थान जहां "पुराने" जावास्क्रिप्ट ऑब्जेक्ट रखे गए हैं)। यह कुंजी, यदि आप उन विवरणों में नहीं जाते हैं जिन्हें हम नीचे स्पर्श करते हैं, तो अधिकतम ढेर आकार को नियंत्रित करता है। Node.js कमांड लाइन स्विच पर विवरण यहां पाया जा सकता है ।

सामान्य तौर पर, जब कोई एप्लिकेशन कंटेनर में उपलब्ध से अधिक मेमोरी का उपयोग करने की कोशिश करता है, तो इसका संचालन समाप्त हो जाता है।

निम्नलिखित उदाहरण में (एप्लिकेशन फ़ाइल को test-fatal-error.js कहा जाता है), MyRecord ऑब्जेक्ट्स को list सरणी में 10 मिलीसेकंड के अंतराल के साथ रखा गया है। यह एक अनियंत्रित हीप वृद्धि की ओर जाता है, स्मृति रिसाव का अनुकरण करता है।

 'use strict'; const list = []; setInterval(()=> { const record = new MyRecord(); list.push(record); },10); function MyRecord() { var x='hii'; this.name = x.repeat(10000000); this.id = x.repeat(10000000); this.account = x.repeat(10000000); } setInterval(()=> { console.log(process.memoryUsage()) },100);

कृपया ध्यान दें कि जिन कार्यक्रमों की हम यहां चर्चा कर रहे हैं, उन सभी उदाहरणों को डॉकर छवि में रखा गया है, जिन्हें डॉकर हब से डाउनलोड किया जा सकता है:

 docker pull ravali1906/dockermemory

आप इस छवि का उपयोग स्वतंत्र प्रयोगों के लिए कर सकते हैं।

इसके अलावा, आप एप्लिकेशन को डॉकटर कंटेनर में पैक कर सकते हैं, छवि एकत्र कर सकते हैं और मेमोरी सीमा के साथ इसे चला सकते हैं:

 docker run --memory 512m --interactive --tty ravali1906/dockermemory bash

यहाँ ravali1906/dockermemory छवि का नाम है।

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

 $ node --max_old_space_size=1024 test-fatal-error.js { rss: 550498304, heapTotal: 1090719744, heapUsed: 1030627104, external: 8272 } Killed

यहां, - --max_old_space_size मेगाबाइट में इंगित मेमोरी सीमा का प्रतिनिधित्व करता है। process.memoryUsage() विधि स्मृति उपयोग के बारे में जानकारी देती है। मान बाइट्स में व्यक्त किए जाते हैं।

किसी समय आवेदन को जबरन समाप्त कर दिया जाता है। ऐसा तब होता है जब इसके द्वारा उपयोग की जाने वाली मेमोरी की सीमा एक निश्चित सीमा को पार कर जाती है। यह कौन सी सीमा है? मेमोरी की मात्रा पर हम किन सीमाओं के बारे में बात कर सकते हैं?

कुंजी के साथ चलने वाले एप्लिकेशन का अपेक्षित व्यवहार है - अधिकतम-पुराने-स्थान-आकार

डिफ़ॉल्ट रूप से, Node.js (संस्करण 11.x तक) में अधिकतम ढेर का आकार 32-बिट प्लेटफॉर्म पर 700 एमबी और 64-बिट पर 1400 एमबी है। आप इन मूल्यों को यहां सेट करने के बारे में पढ़ सकते हैं।

सिद्धांत रूप में, यदि आप कंटेनर मेमोरी सीमा से अधिक मेमोरी सीमा --max-old-space-size करने के लिए --max-old-space-size कुंजी का उपयोग करते हैं, तो आप लिनक्स OOM किलर कर्नेल कर्नेल सुरक्षा तंत्र द्वारा समाप्त किए जाने वाले एप्लिकेशन की अपेक्षा कर सकते हैं।

वास्तव में, यह नहीं हो सकता है।

कुंजी के साथ चलने वाले एप्लिकेशन का वास्तविक व्यवहार अधिकतम-पुराना-स्थान-आकार है

अनुप्रयोग, लॉन्च के तुरंत बाद, सभी मेमोरी को आवंटित नहीं करता है जिसकी सीमा --max-old-space-size का उपयोग करके निर्दिष्ट की गई है। जावास्क्रिप्ट ढेर का आकार आवेदन की जरूरतों पर निर्भर करता है। आप यह देख सकते हैं कि आवेदन कितनी मेमोरी है जो process.memoryUsage() से heapUsed फ़ील्ड के मान के आधार पर उपयोग करता है। वास्तव में, हम वस्तुओं के लिए ढेर में आवंटित मेमोरी के बारे में बात कर रहे हैं।

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

लेकिन वास्तव में ऐसा नहीं भी हो सकता है।

जब प्रोफाइलिंग संसाधन-गहन Node.js अनुप्रयोग जो किसी दिए गए मेमोरी लिमिट वाले कंटेनरों में चलते हैं, तो निम्न पैटर्न देखे जा सकते हैं:

OOM किलर उस क्षण की तुलना में बहुत बाद में चालू होता है जब heapTotal और heapUsed मेमोरी सीमा की तुलना में काफी अधिक होते हैं।
OOM किलर सीमा से अधिक का जवाब नहीं देता है।

कंटेनरों में Node.js अनुप्रयोगों के व्यवहार की व्याख्या

एक कंटेनर उस पर चलने वाले अनुप्रयोगों के एक महत्वपूर्ण संकेतक की देखरेख करता है। यह RSS (निवासी सेट आकार) है। यह संकेतक एप्लिकेशन की वर्चुअल मेमोरी के एक निश्चित भाग का प्रतिनिधित्व करता है।

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

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

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

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

सबूत

1 उदाहरण संख्या १। एक आवेदन जो एक बफर के लिए मेमोरी आवंटित करता है

निम्न उदाहरण, buffer_example.js , एक प्रोग्राम दिखाता है जो बफर के लिए मेमोरी आवंटित करता है:

 const buf = Buffer.alloc(+process.argv[2] * 1024 * 1024) console.log(Math.round(buf.length / (1024 * 1024))) console.log(Math.round(process.memoryUsage().rss / (1024 * 1024)))

जब कंटेनर लॉन्च किया गया था, तो निर्धारित सीमा से अधिक होने के लिए प्रोग्राम द्वारा आवंटित स्मृति की मात्रा के लिए, पहले निम्न कमांड के साथ कंटेनर चलाएं:

 docker run --memory 1024m --interactive --tty ravali1906/dockermemory bash

उसके बाद, प्रोग्राम चलाएँ:

 $ node buffer_example 2000 2000 16

जैसा कि आप देख सकते हैं, सिस्टम ने प्रोग्राम को पूरा नहीं किया, हालांकि प्रोग्राम द्वारा आवंटित मेमोरी कंटेनर की सीमा से अधिक है। यह इस तथ्य के कारण हुआ कि कार्यक्रम सभी आवंटित मेमोरी के साथ काम नहीं करता है। RSS बहुत छोटा है, यह कंटेनर मेमोरी सीमा से अधिक नहीं है।

2 उदाहरण संख्या 2। डेटा के साथ बफर को आबाद करने वाला एप्लिकेशन

निम्न उदाहरण में, buffer_example_fill.js , मेमोरी न केवल आवंटित की गई है, बल्कि डेटा से भी भरी हुई है:

 const buf = Buffer.alloc(+process.argv[2] * 1024 * 1024,'x') console.log(Math.round(buf.length / (1024 * 1024))) console.log(Math.round(process.memoryUsage().rss / (1024 * 1024)))

कंटेनर चलाएँ:

 docker run --memory 1024m --interactive --tty ravali1906/dockermemory bash

उसके बाद, एप्लिकेशन चलाएँ:

 $ node buffer_example_fill.js 2000 2000 984

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

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

यहां वह कोड है जिसे हम यहां प्रयोग करेंगे (यह वही buffer_example_fill.js फाइल है):

 const buf = Buffer.alloc(+process.argv[2] * 1024 * 1024,'x') console.log(Math.round(buf.length / (1024 * 1024))) console.log(Math.round(process.memoryUsage().rss / (1024 * 1024)))

इस बार, कंटेनर चलाएं, स्वैप फ़ाइल के साथ काम करने की सुविधाओं को स्पष्ट रूप से सेट करें:

 docker run --memory 1024m --memory-swap=1024m --memory-swappiness=0 --interactive --tty ravali1906/dockermemory bash

एप्लिकेशन लॉन्च करें:

 $ node buffer_example_fill.js 2000 Killed

संदेश देखें Killed ? जब --memory-swap कुंजी मान --memory-swap कुंजी मान के बराबर होता है, तो यह कंटेनर को बताता है कि उसे --memory फ़ाइल का उपयोग नहीं करना चाहिए। इसके अलावा, डिफ़ॉल्ट रूप से, ऑपरेटिंग सिस्टम का कर्नेल जिसमें कंटेनर स्वयं चलता है, कंटेनर द्वारा पेज फ़ाइल में उपयोग की जाने वाली अनाम मेमोरी पेजों की एक निश्चित मात्रा को डंप कर सकता है। --memory-swappiness ध्वज को 0 --memory-swappiness , हम इस सुविधा को अक्षम करते हैं। नतीजतन, यह पता चला है कि कंटेनर के अंदर पेजिंग फ़ाइल का उपयोग नहीं किया गया है। यह प्रक्रिया तब समाप्त होती है जब RSS मीट्रिक कंटेनर की मेमोरी सीमा से अधिक हो जाती है।

सामान्य सिफारिशें

जब Node.js अनुप्रयोगों को --max-old-space-size कुंजी के साथ लॉन्च किया जाता है, जिसका मान कंटेनर के प्रारंभ होने पर निर्धारित मेमोरी सीमा से अधिक हो जाता है, तो ऐसा लग सकता है कि Node.js कंटेनर सीमा पर "ध्यान नहीं दे रहा है"। लेकिन, जैसा कि पिछले उदाहरणों से देखा जा सकता है, इस व्यवहार का स्पष्ट कारण यह तथ्य है कि आवेदन केवल - ढेर --max-old-space-size ध्वज के साथ निर्दिष्ट पूरे ढेर मात्रा का उपयोग नहीं करता है।

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

जब आप इस विकल्प को नियंत्रित कर सकते हैं, लेकिन कंटेनर-स्तरीय प्रतिबंधों के साथ नहीं, तो उन मामलों के लिए Node.js के आकार को निर्धारित करने की अनुशंसाएँ

कंटेनर में न्यूनतम Node.js एप्लिकेशन चलाएं और स्थिर RSS आकार (मेरे मामले में, Node.js 10.x के लिए, यह लगभग 20 एमबी है) को मापें।
Node.js के ढेर में न केवल पुराने_क्षेत्र हैं, बल्कि अन्य (जैसे कि new_space, code_space, और इसी तरह) भी हैं। इसलिए, यदि आप मंच के मानक कॉन्फ़िगरेशन को ध्यान में रखते हैं, तो आपको इस तथ्य पर भरोसा करना चाहिए कि कार्यक्रम को लगभग 20 एमबी अधिक मेमोरी की आवश्यकता होगी। यदि मानक सेटिंग्स बदल गई हैं, तो इन परिवर्तनों को भी ध्यान में रखा जाना चाहिए।
अब हमें कंटेनर में उपलब्ध मेमोरी की मात्रा से प्राप्त मूल्य (मान लीजिए कि यह 40 एमबी होगा) को घटाना होगा। क्या रहता है एक मूल्य है, जो मेमोरी से बाहर चलने से प्रोग्राम --max-old-space-size डर के बिना, मुख्य मूल्य - --max-old-space-size रूप में निर्दिष्ट किया जा सकता है।

जिन मामलों में इस पैरामीटर को नियंत्रित किया जा सकता है, उनके लिए कंटेनर मेमोरी लिमिट सेट करने की अनुशंसाएँ, लेकिन Node.js एप्लिकेशन पैरामीटर नहीं हैं

मोड में एप्लिकेशन चलाएं जो आपको इसके द्वारा खपत की गई मेमोरी के चरम मूल्यों का पता लगाने की अनुमति देता है।
आरएसएस के स्कोर का विश्लेषण करें। विशेष रूप से, यहाँ, process.memoryUsage() विधि के साथ, लिनक्स top कमांड काम में आ सकता है।
बशर्ते कि जिस कंटेनर में यह एप्लिकेशन चलाने की योजना है, कुछ भी नहीं लेकिन इसे निष्पादित नहीं किया जाएगा, प्राप्त मूल्य को कंटेनर मेमोरी सीमा के रूप में उपयोग किया जा सकता है। सुरक्षित होने के लिए, इसे कम से कम 10% तक बढ़ाने की सिफारिश की जाती है।

परिणाम

Node.js 12.x में, यहां चर्चा की गई कुछ समस्याओं को ढेर के आकार को अनुकूल रूप से समायोजित करके हल किया जाता है, जो कि उपलब्ध रैम की मात्रा के अनुसार किया जाता है। कंटेनर में Node.js अनुप्रयोगों को चलाने के दौरान यह तंत्र भी काम करता है। लेकिन सेटिंग्स डिफ़ॉल्ट सेटिंग्स से भिन्न हो सकती हैं। उदाहरण के लिए, यह तब होता है जब अनुप्रयोग शुरू करते समय --max_old_space_size कुंजी का उपयोग किया जाता था। ऐसे मामलों के लिए, उपरोक्त सभी प्रासंगिक बने हुए हैं। इससे पता चलता है कि जो कोई कंटेनर में Node.js एप्लिकेशन चलाता है, उसे मेमोरी सेटिंग्स के बारे में सावधान और जिम्मेदार होना चाहिए। इसके अलावा, मेमोरी उपयोग पर मानक सीमाओं का ज्ञान, जो बल्कि रूढ़िवादी है, इन सीमाओं को जानबूझकर बदलकर आवेदन प्रदर्शन में सुधार कर सकता है।

प्रिय पाठकों! डॉकटर कंटेनरों में Node.js अनुप्रयोगों को चलाने के दौरान क्या आप मेमोरी समस्याओं से बाहर आ गए हैं?

Node.js: कंटेनरों में चलने वाले अनुप्रयोगों के लिए उपलब्ध स्मृति का प्रबंधन