आप सभी को Node.js के बारे में जानना चाहिए

नमस्कार, हेब्र! मैं आपके लिए जॉर्ज रामोन के "नॉड.जेएस के बारे में सब कुछ जानने की जरूरत है" लेख का अनुवाद प्रस्तुत करता हूं।

आजकल, Node.js प्लेटफ़ॉर्म कुशल और स्केलेबल REST API के निर्माण के लिए सबसे लोकप्रिय प्लेटफार्मों में से एक है। यह हाइब्रिड मोबाइल एप्लिकेशन, डेस्कटॉप प्रोग्राम और यहां तक ​​कि IoT के लिए भी उपयुक्त है।

मैं 6 वर्षों से Node.js प्लेटफ़ॉर्म के साथ काम कर रहा हूं और मैं वास्तव में इसे पसंद करता हूं। यह पोस्ट मुख्य रूप से एक मार्गदर्शक बनने की कोशिश कर रही है कि वास्तव में Node.js कैसे काम करता है।

चलो शुरू हो जाओ !!

क्या चर्चा की जाएगी:

• Node.js से पहले की दुनिया
• समस्या C10K
• Node.js और ईवेंट लूप
• सीपीयू-गहन कार्यों की समस्या
• कार्यकर्ता और उनके प्रवाह

Node.js से पहले की दुनिया

बहुस्तरीय सर्वर

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

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

क्या इसका मतलब यह है कि सर्वर एक समय में केवल एक अनुरोध को संसाधित कर सकता है? सच में नहीं! जब सर्वर को एक नया अनुरोध प्राप्त होता है, तो वह इसे संसाधित करने के लिए एक अलग थ्रेड बनाता है।

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

एन अनुरोधों को संसाधित करने के लिए, सर्वर को एन थ्रेड्स की आवश्यकता होती है। यदि सर्वर को एन + 1 अनुरोध प्राप्त होता है, तो इसे तब तक इंतजार करना चाहिए जब तक कि थ्रेड्स में से एक उपलब्ध न हो जाए।

ऊपर दिए गए आंकड़े में, सर्वर एक बार में 4 अनुरोधों (थ्रेड्स) तक की प्रक्रिया कर सकता है और जब इसे अगले 3 अनुरोध प्राप्त होते हैं, तो इन अनुरोधों को तब तक इंतजार करना होगा जब तक कि इनमें से 4 धागे उपलब्ध नहीं हो जाते।

प्रतिबंधों से छुटकारा पाने का एक तरीका सर्वर में अधिक संसाधन (मेमोरी, प्रोसेसर कोर, आदि) को जोड़ना है, लेकिन यह सबसे अच्छा समाधान नहीं है ...।

और, ज़ाहिर है, तकनीकी सीमाओं के बारे में मत भूलना।

इनपुट / आउटपुट को अवरुद्ध करना

सर्वर पर थ्रेड्स की सीमित संख्या एकमात्र समस्या नहीं है। शायद आपने सोचा है कि एक ही धागा एक ही समय में कई अनुरोधों को संसाधित क्यों नहीं कर सकता है? I / O संचालन अवरुद्ध करने के कारण सभी।

मान लीजिए कि आप एक ऑनलाइन स्टोर विकसित कर रहे हैं और आपको एक पृष्ठ की आवश्यकता है जहां उपयोगकर्ता सभी उत्पादों की सूची देख सकता है।

उपयोगकर्ता http://yourstore.com/products पर दस्तक दे रहा है और सर्वर प्रतिक्रिया में डेटाबेस से सभी उत्पादों के साथ एक HTML फ़ाइल प्रदान करता है। बिल्कुल जटिल नहीं है, है ना?

लेकिन पर्दे के पीछे क्या होता है?

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

I / O ऑपरेशन कितने धीमे हैं? वैसे यह विशिष्ट पर निर्भर करता है। आइए तालिका देखें:

नेटवर्क और डिस्क रीड ऑपरेशन बहुत धीमे हैं। कल्पना करें कि इस समय के दौरान आपके सिस्टम को बाहरी API से कितने अनुरोध या कॉल मिल सकते हैं।

संक्षेप में: I / O संचालन थ्रेड को प्रतीक्षा और अपशिष्ट संसाधन बनाते हैं।

समस्या C10K

समस्या

C10k (eng। C10k; 10k कनेक्शन - 10 हजार कनेक्शन समस्या)

2000 के दशक की शुरुआत में, सर्वर और क्लाइंट मशीनें धीमी थीं। समानांतर में एक ही मशीन से 10,000 क्लाइंट कनेक्शन संसाधित करते समय समस्या उत्पन्न हुई।

लेकिन पारंपरिक धागा-प्रति-अनुरोध मॉडल (अनुरोध पर धागा) इस समस्या को हल क्यों नहीं कर सका? ठीक है, चलो थोड़ा गणित का उपयोग करें।

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

आज, सर्वर और क्लाइंट कंप्यूटर तेजी से और अधिक कुशलता से काम करते हैं और लगभग किसी भी प्रोग्रामिंग भाषा या रूपरेखा इस समस्या का सामना कर सकते हैं। लेकिन वास्तव में, समस्या का समाधान नहीं हुआ है। एक मशीन पर 10 मिलियन क्लाइंट कनेक्शन के लिए, समस्या फिर से लौटती है (लेकिन अब यह C10M समस्या है )।

जावास्क्रिप्ट बचाव?

सावधानी स्पोइलर !!!
Node.js वास्तव में C10K समस्या को हल करता है ... लेकिन कैसे?!

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

लेकिन अगर वे समस्या को हल नहीं कर सकते हैं, तो Node.js कैसे कर सकते हैं! " सभी क्योंकि जावास्क्रिप्ट एकल-थ्रेडेड है ।

Node.js और ईवेंट लूप

Node.js

Node.js एक सर्वर प्लेटफ़ॉर्म है जो Google Chrome इंजन - V8 पर चलता है, जो जावास्क्रिप्ट कोड को मशीन कोड में संकलित कर सकता है।

Node.js एक इवेंट-संचालित मॉडल और एक गैर-अवरोधक I / O आर्किटेक्चर का उपयोग करता है, जो इसे हल्का और कुशल बनाता है। यह कोई ढांचा नहीं है, न ही पुस्तकालय, यह एक जावास्क्रिप्ट रनटाइम है।

एक छोटा सा उदाहरण लिखते हैं:

 // Importing native http module const http = require('http'); // Creating a server instance where every call // the message 'Hello World' is responded to the client const server = http.createServer(function(request, response) { response.write('Hello World'); response.end(); }); // Listening port 8080 server.listen(8080); 

गैर-अवरोधक i / o

Node.js गैर-अवरोधक इनपुट / आउटपुट संचालन का उपयोग करता है, इसका क्या अर्थ है:

• मुख्य धागा I / O संचालन द्वारा अवरुद्ध नहीं किया जाएगा।
• सर्वर अनुरोधों की सेवा जारी रखेगा।
• हमें अतुल्यकालिक कोड के साथ काम करना होगा।

चलिए एक उदाहरण लिखते हैं जिसमें सर्वर एक HTML पेज को /home अनुरोध के जवाब में भेजता है, और अन्य सभी अनुरोधों के लिए - 'हैलो वर्ल्ड'। HTML पेज भेजने के लिए, आपको पहले इसे एक फ़ाइल से पढ़ना होगा।

home.html

 <html> <body> <h1>This is home page</h1> </body> </html> 

index.js

 const http = require('http'); const fs = require('fs'); const server = http.createServer(function(request, response) { if (request.url === '/home') { fs.readFile(`${ __dirname }/home.html`, function (err, content) { if (!err) { response.setHeader('Content-Type', 'text/html'); response.write(content); } else { response.statusCode = 500; response.write('An error has ocurred'); } response.end(); }); } else { response.write('Hello World'); response.end(); } }); server.listen(8080); 

यदि अनुरोधित यूआरएल /home , तो home.html फ़ाइल को पढ़ने के लिए देशी fs मॉड्यूल का उपयोग किया जाता है।

तर्क के रूप में http.createServer और fs.readFile में http.createServer कार्य कॉलबैक हैं । ये फ़ंक्शन भविष्य में कुछ बिंदु पर किया जाएगा (पहला, जैसे ही सर्वर अनुरोध प्राप्त करता है, और दूसरा, जब फ़ाइल को डिस्क से पढ़ा जाता है और बफर में रखा जाता है)।

जबकि फ़ाइल डिस्क से पढ़ी जा रही है, Node.js अन्य अनुरोधों को संसाधित कर सकते हैं और यहां तक ​​कि फ़ाइल को फिर से पढ़ सकते हैं और यह सब एक स्ट्रीम में ... लेकिन कैसे!

घटना पाश

इवेंट लूप वह जादू है जो Node.js. के अंदर होता है यह वस्तुतः एक अंतहीन लूप है और वास्तव में एक धागा है।

Libuv एक सी लाइब्रेरी है जो इस पैटर्न को लागू करती है और Node.js. कर्नेल का हिस्सा है आप यहाँ libuv के बारे में अधिक जान सकते हैं।

एक घटना चक्र में 6 चरण होते हैं, सभी 6 चरणों के प्रत्येक निष्पादन को एक टिक कहा जाता है।

• टाइमर : इस चरण में, setTimeout() और setInterval() विधियों द्वारा निर्धारित कॉलबैक निष्पादित किए जाते हैं;
• लंबित कॉलबैक : लगभग सभी कॉलबैक निष्पादित किए जाते हैं, close घटनाओं, टाइमर और setImmediate() ;
• निष्क्रिय, तैयार : केवल आंतरिक उद्देश्यों के लिए उपयोग किया जाता है;
• पोल : नए I / O ईवेंट प्राप्त करने के लिए जिम्मेदार। इस बिंदु पर Node.js ब्लॉक हो सकते हैं;
• जाँच करें : इस चरण में setImmediate() विधि के कारण कॉलबैक निष्पादित किए जाते हैं;
• करीब कॉलबैक : उदाहरण के लिए socket.on('close', ...) ;

ठीक है, केवल एक धागा है, और यह धागा एक इवेंट लूप है, लेकिन फिर सभी I / O कौन करता है?

ध्यान दो !!!
जब एक इवेंट लूप को I / O ऑपरेशन करने की आवश्यकता होती है, तो वह थ्रेड पूल से OS थ्रेड का उपयोग करता है, और जब कार्य पूरा हो जाता है, तो कॉलबैक लंबित कॉलबैक चरण के दौरान पंक्तिबद्ध होता है।

क्या यह अच्छा नहीं है?

सीपीयू-गहन कार्यों की समस्या

Node.js एकदम सही लगता है! आप जो चाहें बना सकते हैं।

प्राइम नंबरों की गणना के लिए एक एपीआई लिखें।

एक अभाज्य संख्या एक पूर्णांक (प्राकृतिक) संख्या है जो केवल 1 और उसके द्वारा एक से अधिक और विभाज्य है।

एक नंबर एन को देखते हुए, एपीआई को सूची (या सरणी) में पहले एन primes की गणना और वापस करना चाहिए।

primes.js

 function isPrime(n) { for(let i = 2, s = Math.sqrt(n); i <= s; i++) { if(n % i === 0) return false; } return n > 1; } function nthPrime(n) { let counter = n; let iterator = 2; let result = []; while(counter > 0) { isPrime(iterator) && result.push(iterator) && counter--; iterator++; } return result; } module.exports = { isPrime, nthPrime }; 

index.js

 const http = require('http'); const url = require('url'); const primes = require('./primes'); const server = http.createServer(function (request, response) { const { pathname, query } = url.parse(request.url, true); if (pathname === '/primes') { const result = primes.nthPrime(query.n || 0); response.setHeader('Content-Type', 'application/json'); response.write(JSON.stringify(result)); response.end(); } else { response.statusCode = 404; response.write('Not Found'); response.end(); } }); server.listen(8080); 

prime.js आवश्यक गणनाओं का कार्यान्वयन है: isPrime फ़ंक्शन जाँचता है कि क्या संख्या अभाज्य है, और nthPrime N को ऐसे नंबर देता है।

index.js फ़ाइल सर्वर बनाने के लिए ज़िम्मेदार है और प्रत्येक अनुरोध /primes लिए प्रक्रिया करने के लिए prime.js मॉड्यूल का उपयोग करता है। URL में क्वेरी स्ट्रिंग के माध्यम से नंबर N को फेंक दिया जाता है।

पहले 20 अपराधों को प्राप्त करने के लिए हमें http://localhost:8080/primes?n=20 अनुरोध करने की आवश्यकता है।

मान लीजिए कि हमारे पास 3 ग्राहक हैं, जो हमारे पास दस्तक दे रहे हैं और हमारे गैर-अवरोधक I / O API तक पहुंचने का प्रयास कर रहे हैं:

• पहला सवाल 5 सेकंड हर सेकंड।
• दूसरा हर सेकंड 1000 प्राइम मांगता है
• तीसरा अनुरोध करता है 10,000,000,000 प्राइम, लेकिन ...

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

लेकिन लिबवू का क्या? यदि आपको याद है, तो यह लाइब्रेरी Node.js को मुख्य थ्रेड को ब्लॉक करने से बचने के लिए OS थ्रेड्स का उपयोग करके इनपुट / आउटपुट ऑपरेशन करने में मदद करती है और आप बिल्कुल सही हैं, यह हमारी समस्या का समाधान है, लेकिन इसके लिए हमारे मॉड्यूल को भाषा में लिखा जाना चाहिए। C ++ इसलिए libuv इसके साथ काम कर सकता है।

सौभाग्य से, v10.5 के साथ शुरू, देशी कार्यकर्ता थ्रेड्स मॉड्यूल को Node.js. में जोड़ा गया है।

कार्यकर्ता और उनके प्रवाह

जैसा कि प्रलेखन हमें बताता है:

सीपीयू-गहन जावास्क्रिप्ट ऑपरेशन करने के लिए श्रमिक उपयोगी हैं; इनपुट / आउटपुट संचालन के लिए उनका उपयोग न करें, पहले से ही Node.js में निर्मित तंत्र वर्कर थ्रेड की तुलना में ऐसे कार्यों का अधिक कुशलता से सामना करते हैं।

कोड ठीक करें

हमारे कोड को फिर से लिखने का समय आ गया है:

primes-workerthreads.js

 const { workerData, parentPort } = require('worker_threads'); function isPrime(n) { for(let i = 2, s = Math.sqrt(n); i <= s; i++) if(n % i === 0) return false; return n > 1; } function nthPrime(n) { let counter = n; let iterator = 2; let result = []; while(counter > 0) { isPrime(iterator) && result.push(iterator) && counter--; iterator++; } return result; } parentPort.postMessage(nthPrime(workerData.n)); 

index-workerthreads.js

 const http = require('http'); const url = require('url'); const { Worker } = require('worker_threads'); const server = http.createServer(function (request, response) { const { pathname, query } = url.parse(request.url, true); if (pathname === '/primes') { const worker = new Worker('./primes-workerthreads.js', { workerData: { n: query.n || 0 } }); worker.on('error', function () { response.statusCode = 500; response.write('Oops there was an error...'); response.end(); }); let result; worker.on('message', function (message) { result = message; }); worker.on('exit', function () { response.setHeader('Content-Type', 'application/json'); response.write(JSON.stringify(result)); response.end(); }); } else { response.statusCode = 404; response.write('Not Found'); response.end(); } }); server.listen(8080); 

index-workerthreads.js , प्रत्येक रिक्वेस्ट /primes Worker क्लास का एक उदाहरण बनाता है (देशी मॉड्यूल worker_threads ) primes-workerthreads.js में primes-workerthreads.js को अपलोड और primes-workerthreads.js करने के लिए। जब primes की सूची की गणना और तैयार हो जाती है, तो message घटना शुरू हो जाती है - परिणाम मुख्य धारा में आता है क्योंकि कार्यकर्ता के पास कोई काम नहीं बचा है, वह exit घटना को भी ट्रिगर करता है, जिससे मुख्य धारा ग्राहक को डेटा भेजने की अनुमति देती है।

primes-workerthreads.js थोड़ा बदल गया। यह workerData आयात workerData (यह मुख्य थ्रेड से पारित मापदंडों की एक प्रति है) और parentPort जिसके माध्यम से कार्यकर्ता के काम का परिणाम मुख्य थ्रेड में वापस भेज दिया जाता है।

अब हम फिर से अपना उदाहरण देते हैं और देखते हैं कि क्या होता है

मुख्य धागा अब अवरुद्ध नहीं है !!!!!

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

निष्कर्ष

Node.js एक शक्तिशाली तकनीक है जिसे जब भी संभव हो पता लगाया जाना चाहिए।
मेरी व्यक्तिगत सिफारिश - हमेशा उत्सुक रहें! यदि आप जानते हैं कि अंदर से कुछ कैसे काम करता है, तो आप इसके साथ अधिक कुशलता से काम कर सकते हैं।

आज के दोस्तों के लिए बस इतना ही। मुझे उम्मीद है कि यह पोस्ट आपके लिए उपयोगी थी और आपने Node.js. के बारे में कुछ नया सीखा

पढ़ने के लिए धन्यवाद और आपको अगली पोस्टों में देखने के लिए। ।