हम एक या दो 1.0 के लिए क्रॉलर लिखते हैं

वेब क्रॉलर (या वेब स्पाइडर) वेब पेजों को क्रॉल करने के लिए खोज इंजन का एक महत्वपूर्ण हिस्सा है, ताकि डेटाबेस में उनके बारे में जानकारी दर्ज की जा सके, मुख्यतः उनके आगे के अनुक्रमण के लिए। खोज इंजन (Google, यैंडेक्स, बिंग), साथ ही साथ एसईओ उत्पाद (SEMrush, MOZ, ahrefs) और न केवल ऐसी चीज है। और यह बात काफी दिलचस्प है: दोनों संभावित और उपयोग के मामलों के मामले में, और तकनीकी कार्यान्वयन के लिए।



इस लेख के साथ, हम आपकी क्रॉलर बाइक बनाना शुरू कर देंगे, कई विशेषताओं का विश्लेषण करेंगे और नुकसान की बैठक करेंगे। एक सरल पुनरावर्ती समारोह से एक स्केलेबल और एक्स्टेंसिबल सेवा के लिए। दिलचस्प होना चाहिए!

परिचय

Iteratively - इसका अर्थ है कि प्रत्येक रिलीज़ के अंत में "उत्पाद" का तैयार-से-उपयोग संस्करण सहमत सीमाओं, सुविधाओं और इंटरफ़ेस के साथ अपेक्षित है।

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

यह मेरा क्रॉलर है। ऐसे कई क्रॉलर हैं, लेकिन यह एक मेरा है।
मेरा क्रॉलर मेरा सबसे अच्छा दोस्त है।

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

समस्या का बयान

हमारे टैय-ब्लॉपर क्रॉलर के पहले (प्रारंभिक) कार्यान्वयन के लिए कार्य निम्नानुसार होगा:

एक-दो क्रॉलर 1.0
एक क्रॉलर स्क्रिप्ट लिखें जो एक छोटी (100 पृष्ठों तक) साइट के आंतरिक <a href /> लिंक को बायपास करती है। नतीजतन, प्राप्त कोड और उनके लिंकिंग के नक्शे के साथ पृष्ठों के URL की एक सूची प्रदान करें। Robots.txt नियम और rel = nofollow लिंक विशेषता को अनदेखा किया जाता है।

चेतावनी! Robot.txt नियमों की अनदेखी स्पष्ट कारणों से एक बुरा विचार है। हम भविष्य में इस चूक के लिए प्रयास करेंगे। इस बीच, पृष्ठों की संख्या को सीमित करने वाले सीमा पैरामीटर को क्रॉल करें ताकि वह DoS को न रोके और प्रायोगिक साइट को आज़माएं (प्रयोगों के लिए अपने निजी "हम्सटर साइट" का उपयोग करना बेहतर है)।

कार्यान्वयन

अधीर के लिए, यहाँ इस समाधान के स्रोत हैं।

1. HTTP (S) क्लाइंट
2. उत्तर के विकल्प
3. लिंक निकालना
4. लिंक तैयारी और फ़िल्टरिंग
5. URL सामान्यीकरण
6. मुख्य समारोह एल्गोरिथ्म
7. वापसी का परिणाम

1. HTTP (एस) क्लाइंट

पहली चीज जो हमें करने में सक्षम होना चाहिए, वह है, वास्तव में, अनुरोध भेजना और HTTP और HTTPS के माध्यम से प्रतिक्रियाएं प्राप्त करना। Node.js में इसके लिए दो मैचिंग क्लाइंट हैं। बेशक, आप एक तैयार ग्राहक अनुरोध ले सकते हैं, लेकिन हमारे कार्य के लिए यह बेहद बेमानी है: हमें बस एक GET अनुरोध भेजने और शरीर और हेडर के साथ प्रतिक्रिया प्राप्त करने की आवश्यकता है।

हमारे लिए आवश्यक दोनों क्लाइंटों का एपीआई एक जैसा है, हम एक नक्शा बनाएंगे:

const clients = { 'http:': require('http'), 'https:': require('https') }; 

हम एक साधारण फंक्शन लाने की घोषणा करते हैं, जिसका एकमात्र पैरामीटर वांछित वेब संसाधन स्ट्रिंग का पूर्ण URL होगा। Url मॉड्यूल का उपयोग करके , हम परिणामस्वरूप स्ट्रिंग को URL ऑब्जेक्ट में पार्स करेंगे। इस ऑब्जेक्ट में प्रोटोकॉल के साथ एक फ़ील्ड है (एक बृहदान्त्र के साथ), जिसके द्वारा हम उचित ग्राहक का चयन करेंगे:

 const url = require('url'); function fetch(dst) { let dstURL = new URL(dst); let client = clients[dstURL.protocol]; if (!client) { throw new Error('Could not select a client for ' + dstURL.protocol); } // ... } 

अगला, चयनित ग्राहक का उपयोग करें और एक वादे में लाने के लिए फ़ंक्शन को लपेटें:

 function fetch(dst) { return new Promise((resolve, reject) => { // ... let req = client.get(dstURL.href, res => { // do something with the response }); req.on('error', err => reject('Failed on the request: ' + err.message)); req.end(); }); } 

अब हम एसिंक्रोनस रूप से प्रतिक्रिया प्राप्त कर सकते हैं, लेकिन अभी हम इसके साथ कुछ नहीं कर रहे हैं।

2. उत्तर विकल्प

साइट को क्रॉल करने के लिए, 3 उत्तर विकल्पों को संसाधित करना पर्याप्त है:

1. ठीक है - एक 2xx स्थिति कोड प्राप्त हुआ था। आगे की प्रक्रिया के परिणामस्वरूप प्रतिक्रिया शरीर को बचाने के लिए आवश्यक है - नए लिंक निकालने।
2. REDIRECT - एक 3xx स्थिति कोड प्राप्त हुआ था। यह दूसरे पृष्ठ पर पुनर्निर्देशित है। इस मामले में, हमें स्थान प्रतिक्रिया शीर्षलेख की आवश्यकता होगी, जहां से हम एक एकल "आउटगोइंग" लिंक लेंगे।
3. NO_DATA - अन्य सभी मामले: स्थान हेडर के बिना 4xx / 5xx और 3xx। हमारे क्रॉलर के आगे जाने के लिए कहीं नहीं है।

इसकी कार्यप्रणाली को दर्शाते हुए प्रोसैस रिस्पांस का पता लगाएगा:

 const ft = { 'OK': 1, // code (2xx), content 'REDIRECT': 2, // code (3xx), location 'NO_DATA': 3 // code }; 

यदि-और की सर्वोत्तम परंपराओं में परिणाम उत्पन्न करने की रणनीति का कार्यान्वयन:

 let code = res.statusCode; let codeGroup = Math.floor(code / 100); // OK if (codeGroup === 2) { let body = []; res.setEncoding('utf8'); res.on('data', chunk => body.push(chunk)); res.on('end', () => resolve({ code, content: body.join(''), type: ft.OK })); } // REDIRECT else if (codeGroup === 3 && res.headers.location) { resolve({ code, location: res.headers.location, type: ft.REDIRECT }); } // NO_DATA (others) else { resolve({ code, type: ft.NO_DATA }); } 

संपूर्ण फ़ंक्शन कोड : भ्रूण फ़ंक्शन उपयोग करने के लिए तैयार है।

3. लिंक का निष्कर्षण

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

यदि परिणाम प्रकार REDIRECT है, तो फ़ंक्शन स्थान फ़ील्ड से एक एकल संदर्भ के साथ एक सरणी लौटाएगा। NO_DATA, तो एक खाली सरणी। यदि ठीक है, तो हमें खोज के लिए प्रस्तुत पाठ सामग्री के लिए पार्सर को कनेक्ट करना होगा।

<a href /> खोज कार्य के लिए , आप एक नियमित अभिव्यक्ति भी लिख सकते हैं। लेकिन यह समाधान बिल्कुल पैमाने पर नहीं है, क्योंकि भविष्य में हम कम से कम लिंक के अन्य विशेषताओं ( रिले ) पर ध्यान देंगे, अधिकतम के रूप में, हम img , लिंक , स्क्रिप्ट , ऑडियो / वीडियो ( स्रोत ) और अन्य संसाधनों के बारे में सोचेंगे। दस्तावेज़ के पाठ को पार्स करना और सामान्य चयनकर्ताओं को दरकिनार करने के लिए इसके नोड्स का एक पेड़ बनाना बहुत अधिक आशाजनक और अधिक सुविधाजनक है।

हम नोड के साथ काम करने के लिए लोकप्रिय JSDOM पुस्तकालय का उपयोग करेंगे।

 const { JSDOM } = require('jsdom'); let document = new JSDOM(fetched.content).window.document; let elements = document.getElementsByTagName('A'); return Array.from(elements) .map(el => el.getAttribute('href')) .filter(href => typeof href === 'string') .map(href => href.trim()) .filter(Boolean); 

हम सभी ए तत्वों को दस्तावेज़ से प्राप्त करते हैं, और फिर href विशेषता के सभी फ़िल्टर किए गए मान, यदि खाली लाइनें नहीं हैं।

4. लिंक की तैयारी और फ़िल्टरिंग

चिमटा के परिणामस्वरूप, हमारे पास लिंक (URL) और दो समस्याओं का एक सेट है: 1) URL सापेक्ष हो सकता है और 2) URL बाहरी संसाधन का नेतृत्व कर सकता है (हमें केवल आंतरिक लोगों की आवश्यकता है)।

पहली समस्या को url.resolve फ़ंक्शन द्वारा मदद की जाएगी , जो स्रोत पृष्ठ के URL के सापेक्ष लैंडिंग पृष्ठ का URL हल करता है।

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

 function getLowerHost(dst) { return (new URL(dst)).hostname.toLowerCase(); } function inScope(dst, base) { let dstHost = getLowerHost(dst); let baseHost = getLowerHost(base); let i = dstHost.indexOf(baseHost); // the same domain or has subdomains return i === 0 || dstHost[i - 1] === '.'; } 

यदि फ़ंक्शन पाया गया था, तो फ़ंक्शन पिछले अक्षर के लिए चेक के साथ सबस्ट्रिंग ( बेसहॉस्ट ) की खोज करता है: चूंकि wwwexample.com और example.com अलग-अलग डोमेन हैं। नतीजतन, हम दिए गए डोमेन को नहीं छोड़ते हैं, लेकिन इसके उप डोमेन को बायपास करते हैं।

हम "निरपेक्षता" जोड़कर और इसके परिणामस्वरूप लिंक को फ़िल्टर करके फ़ंक्शन को परिष्कृत करते हैं:

 function extract(fetched, src, base) { return extractRaw(fetched) .map(href => url.resolve(src, href)) .filter(dst => /^https?\:\/\//i.test(dst)) .filter(dst => inScope(dst, base)); } 

यहां भ्रूण प्राप्त करने का कार्य है, src स्रोत पृष्ठ का URL है, आधार क्रॉल का आधार URL है। आउटपुट पर, हमें आगे की प्रक्रिया के लिए पहले से ही पूर्ण आंतरिक लिंक (URL) की एक सूची मिलती है। संपूर्ण फ़ंक्शन कोड यहां देखा जा सकता है ।

5. URL सामान्यीकरण

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

सामान्यीकरण प्रक्रिया स्रोत URL और उसके घटकों पर लागू परिवर्तनों का एक पूरा सेट है। यहाँ उनमें से कुछ ही हैं:

• योजना और मेजबान संवेदनशील नहीं हैं, इसलिए उन्हें निम्न में परिवर्तित किया जाना चाहिए।
• सभी प्रतिशत (जैसे "% 3A") अपरकेस होना चाहिए।
• डिफ़ॉल्ट पोर्ट (HTTP के लिए 80) को हटाया जा सकता है।
• टुकड़ा ( # ) सर्वर के लिए कभी भी दिखाई नहीं देता है और इसे हटाया भी जा सकता है।

आप हमेशा कुछ तैयार कर सकते हैं (उदाहरण के लिए, सामान्य-यूआरएल ) या सबसे महत्वपूर्ण और सामान्य मामलों को कवर करते हुए अपना खुद का सरल कार्य लिखें:

 function normalize(dst) { let dstUrl = new URL(dst); // ignore userinfo (auth property) let origin = dstUrl.protocol + '//' + dstUrl.hostname; // ignore http(s) standart ports if (dstUrl.port && (!/^https?\:/i.test(dstUrl.protocol) || ![80, 8080, 443].includes(+dstUrl.port))) { origin += ':' + dstUrl.port; } // ignore fragment (hash property) let path = dstUrl.pathname + dstUrl.search; // convert origin to lower case return origin.toLowerCase() // and capitalize letters in escape sequences + path.replace(/%([0-9a-f]{2})/ig, (_, es) => '%' + es.toUpperCase()); } 

हां, क्वेरी पैरामीटर की कोई छँटाई नहीं है, utm टैग्स को अनदेखा करना, _escaped_fragment_ और अन्य चीजों को प्रोसेस करना , जिसकी हमें (बिल्कुल) ज़रूरत नहीं है।

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

6. मुख्य कार्य का एल्गोरिथ्म

समाधान के प्रमुख घटक (आदिम) तैयार हैं, यह सब कुछ एक साथ इकट्ठा करना शुरू करने का समय है। आरंभ करने के लिए, आइए क्रॉल फ़ंक्शन के हस्ताक्षर का निर्धारण करें: इनपुट पर, आरंभ URL और पृष्ठ सीमा। फ़ंक्शन एक वादा लौटाता है जिसका संकल्प एक संचित परिणाम प्रदान करता है; इसे आउटपुट फाइल पर लिखें:

 crawl(start, limit).then(result => { fs.writeFile(output, JSON.stringify(result), 'utf8', err => { if (err) throw err; }); }); 

क्रॉल फ़ंक्शन का सबसे सरल पुनरावर्ती वर्कफ़्लो चरणों में वर्णित किया जा सकता है:

1. कैश का प्रारंभिक परिणाम और परिणाम वस्तु
2. यदि लैंडिंग पृष्ठ URL ( सामान्यीकृत के माध्यम से) कैश में नहीं है, तो
- 2.1। IF सीमा समाप्त हो गई है, END (परिणाम की प्रतीक्षा करें)
- 2.2। कैश में URL जोड़ें
- 2.3। परिणाम में स्रोत और लैंडिंग पृष्ठ के बीच लिंक सहेजें
- 2.4। प्रति पृष्ठ अतुल्यकालिक अनुरोध भेजें ( प्राप्त करें )
- 2.5। यदि अनुरोध सफल है, तो
- - 2.5.1। परिणाम से नए लिंक निकालें ( निकालें )
- - 2.5.2। प्रत्येक नए लिंक के लिए, एल्गोरिथ्म 2-3 को निष्पादित करें
- 2.6। ELSE पृष्ठ को त्रुटि के रूप में चिह्नित करता है
- 2.7। परिणाम के लिए पृष्ठ डेटा सहेजें
- 2.8। यदि यह अंतिम पृष्ठ था, तो परिणाम लाएं
3. ईएलएसई परिणाम में स्रोत और लैंडिंग पृष्ठ के बीच लिंक को बचाएं

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

 function crawl(start, limit = 100) { // initialize cache & result return new Promise((resolve, reject) => { function curl(src, dst) { // check dst in the cache & pages limit // save the link (src -> dst) to the result fetch(dst).then(fetched => { extract(fetched, dst, start).forEach(ln => curl(dst, ln)); }).finally(() => { // save the page's data to the result // check completion and resolve the result }); } curl(null, start); }); } 

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

आप (वैकल्पिक रूप से) यहां कार्यान्वयन कोड के साथ खुद को परिचित कर सकते हैं , लेकिन इससे पहले कि आपको लौटे परिणाम के प्रारूप पर विचार करना चाहिए।

7. लौटाया हुआ परिणाम

हम एक अनूठे आईडी पहचानकर्ता को एक साधारण वेतन वृद्धि के साथ प्रदत्त पृष्ठों के लिए प्रस्तुत करेंगे:

 let id = 0; let cache = {}; // ... let dstNorm = normalize(dst); if (dstNorm in cache === false) { cache[dstNorm] = ++id; // ... } 

परिणाम के लिए, हम पृष्ठों की एक सरणी बनाएंगे, जिसमें हम पृष्ठ पर डेटा के साथ ऑब्जेक्ट जोड़ेंगे: id {संख्या}, url {string} और कोड {संख्या | null} (यह अब पर्याप्त है)। हम ऑब्जेक्ट के रूप में पृष्ठों के बीच लिंक के लिए एक सरणी भी बनाते हैं: (स्रोत पृष्ठ की आईडी ), से (लैंडिंग पृष्ठ की आईडी )।

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

 resolve({ pages: pages.sort((p1, p2) => p1.id - p2.id), links: links.sort((l1, l2) => l1.from - l2.from || l1.to - l2.to), count, fin: count < limit }); 

उदाहरण का उपयोग करें

तैयार क्रॉलर स्क्रिप्ट में निम्नलिखित सारांश है:

 node crawl-cli.js --start="<URL>" [--output="<filename>"] [--limit=<int>] 

प्रक्रिया के प्रमुख बिंदुओं के लॉगिंग को लागू करते हुए, हम स्टार्टअप पर इस तरह की तस्वीर देखेंगे:

 $ node crawl-cli.js --start="https://google.com" --limit=20 [2019-02-26T19:32:10.087Z] Start crawl "https://google.com" with limit 20 [2019-02-26T19:32:10.089Z] Request (#1) "https://google.com/" [2019-02-26T19:32:10.721Z] Fetched (#1) "https://google.com/" with code 301 [2019-02-26T19:32:10.727Z] Request (#2) "https://www.google.com/" [2019-02-26T19:32:11.583Z] Fetched (#2) "https://www.google.com/" with code 200 [2019-02-26T19:32:11.720Z] Request (#3) "https://play.google.com/?hl=ru&tab=w8" [2019-02-26T19:32:11.721Z] Request (#4) "https://mail.google.com/mail/?tab=wm" [2019-02-26T19:32:11.721Z] Request (#5) "https://drive.google.com/?tab=wo" ... [2019-02-26T19:32:12.929Z] Fetched (#11) "https://www.google.com/advanced_search?hl=ru&authuser=0" with code 200 [2019-02-26T19:32:13.382Z] Fetched (#19) "https://translate.google.com/" with code 200 [2019-02-26T19:32:13.782Z] Fetched (#14) "https://plus.google.com/108954345031389568444" with code 200 [2019-02-26T19:32:14.087Z] Finish crawl "https://google.com" on count 20 [2019-02-26T19:32:14.087Z] Save the result in "result.json" 

और यहाँ JSON प्रारूप में परिणाम है:

 { "pages": [ { "id": 1, "url": "https://google.com/", "code": 301 }, { "id": 2, "url": "https://www.google.com/", "code": 200 }, { "id": 3, "url": "https://play.google.com/?hl=ru&tab=w8", "code": 302 }, { "id": 4, "url": "https://mail.google.com/mail/?tab=wm", "code": 302 }, { "id": 5, "url": "https://drive.google.com/?tab=wo", "code": 302 }, // ... { "id": 19, "url": "https://translate.google.com/", "code": 200 }, { "id": 20, "url": "https://calendar.google.com/calendar?tab=wc", "code": 302 } ], "links": [ { "from": 1, "to": 2 }, { "from": 2, "to": 3 }, { "from": 2, "to": 4 }, { "from": 2, "to": 5 }, // ... { "from": 12, "to": 19 }, { "from": 19, "to": 8 } ], "count": 20, "fin": false } 

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

घोषणा 2.0

हमने सबसे सरल कंसोल क्रॉलर का एक संस्करण प्राप्त किया है, जो एक साइट के पृष्ठों को दरकिनार करता है। स्रोत कोड यहाँ है कुछ कार्यों के लिए एक उदाहरण और इकाई परीक्षण भी है।

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