Node.js ऐप्स में प्रॉक्सी सेटअप: कोड उदाहरणों के साथ पूर्ण गाइड

Node.js अनुप्रयोगों के विकास में, पार्सिंग, स्वचालन या API के साथ काम करते समय प्रॉक्सी सर्वरों का उपयोग करने की आवश्यकता अक्सर होती है। यह भौगोलिक प्रतिबंधों को बायपास करने, लोड को वितरित करने और IP द्वारा ब्लॉक से बचने की अनुमति देता है। इस गाइड में, हम Node.js में प्रॉक्सी सेटअप के सभी तरीकों पर चर्चा करेंगे - बुनियादी से लेकर रोटेशन और त्रुटियों को संभालने की उन्नत तकनीकों तक।

Node.js में प्रॉक्सी के साथ काम करने की बुनियादी अवधारणाएँ

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

Node.js में HTTP अनुरोधों के लिए उपयोग की जाने वाली पुस्तकालय के आधार पर प्रॉक्सी के साथ काम करने के कई बुनियादी तरीके हैं। सबसे लोकप्रिय विकल्प हैं:

• इनबिल्ट http/https मॉड्यूल — अतिरिक्त निर्भरताओं के बिना बुनियादी कार्यक्षमता
• Axios — सुविधाजनक API और प्रॉमिस समर्थन के साथ लोकप्रिय पुस्तकालय
• Got — TypeScript समर्थन के साथ आधुनिक विकल्प
• node-fetch — Node.js के लिए Fetch API का कार्यान्वयन
• request — पुरानी, लेकिन अभी भी उपयोग की जाने वाली पुस्तकालय (नए प्रोजेक्ट्स के लिए अनुशंसित नहीं)

प्रॉक्सी सर्वर विभिन्न प्रोटोकॉल का समर्थन करते हैं। Node.js के साथ काम करने के लिए सबसे अधिक उपयोग किए जाने वाले प्रोटोकॉल हैं:

पार्सिंग और स्वचालन के कार्यों के लिए, डेवलपर्स अक्सर रिहायशी प्रॉक्सी का उपयोग करते हैं, क्योंकि उनके पास वास्तविक घरेलू उपयोगकर्ताओं के IP पते होते हैं और वे लक्षित साइटों द्वारा ब्लॉक होने की संभावना कम होती है।

इनबिल्ट http/https मॉड्यूल के माध्यम से प्रॉक्सी सेटअप

Node.js HTTP अनुरोधों के लिए http और https के लिए इनबिल्ट मॉड्यूल प्रदान करता है। प्रॉक्सी को कनेक्ट करने के लिए, आप http-proxy-agent या https-proxy-agent पुस्तकालय का उपयोग कर सकते हैं।

सबसे पहले आवश्यक पैकेज स्थापित करें:

npm install http-proxy-agent https-proxy-agent

इनबिल्ट मॉड्यूल के साथ HTTP प्रॉक्सी का उपयोग करने का उदाहरण:

const http = require('http');
const { HttpProxyAgent } = require('http-proxy-agent');

// प्रॉक्सी सेटिंग्स
const proxyUrl = 'http://username:password@proxy-server.com:8080';
const agent = new HttpProxyAgent(proxyUrl);

// अनुरोध विकल्प
const options = {
  hostname: 'api.example.com',
  path: '/endpoint',
  method: 'GET',
  agent: agent,
  headers: {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  }
};

// अनुरोध निष्पादित करना
const req = http.request(options, (res) => {
  let data = '';
  
  res.on('data', (chunk) => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('Response:', data);
  });
});

req.on('error', (error) => {
  console.error('Request failed:', error.message);
});

req.end();

HTTPS कनेक्शनों के लिए https-proxy-agent का उपयोग करें:

const https = require('https');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = 'http://username:password@proxy-server.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);

const options = {
  hostname: 'api.example.com',
  path: '/secure-endpoint',
  method: 'GET',
  agent: agent
};

https.get(options, (res) => {
  let data = '';
  
  res.on('data', (chunk) => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('Secure response:', data);
  });
}).on('error', (error) => {
  console.error('HTTPS request failed:', error.message);
});

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

Axios पुस्तकालय में प्रॉक्सी के साथ काम करना

Axios — Node.js में HTTP अनुरोधों के लिए सबसे लोकप्रिय पुस्तकालयों में से एक है। यह प्रॉक्सी सेटअप के लिए एक सुविधाजनक API प्रदान करता है और स्वचालित रूप से प्रॉमिस को संभालता है।

Axios स्थापित करना:

npm install axios

Axios में प्रॉक्सी सेटअप का बुनियादी उदाहरण इस प्रकार है:

const axios = require('axios');

// तरीका 1: अनुरोध कॉन्फ़िगरेशन में प्रॉक्सी सेट करना
axios.get('https://api.example.com/data', {
  proxy: {
    protocol: 'http',
    host: 'proxy-server.com',
    port: 8080,
    auth: {
      username: 'your-username',
      password: 'your-password'
    }
  }
})
.then(response => {
  console.log('Data:', response.data);
})
.catch(error => {
  console.error('Error:', error.message);
});

एक ही प्रॉक्सी सेटिंग्स का बार-बार उपयोग करने के लिए, प्रॉक्सी के साथ एक Axios उदाहरण बनाना सुविधाजनक है:

const axios = require('axios');

// प्रॉक्सी सेटिंग्स के साथ उदाहरण बनाना
const axiosWithProxy = axios.create({
  proxy: {
    protocol: 'http',
    host: 'proxy-server.com',
    port: 8080,
    auth: {
      username: 'your-username',
      password: 'your-password'
    }
  },
  timeout: 10000,
  headers: {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  }
});

// उदाहरण का उपयोग करना
async function fetchData() {
  try {
    const response = await axiosWithProxy.get('https://api.example.com/data');
    console.log('Response:', response.data);
    return response.data;
  } catch (error) {
    console.error('Request failed:', error.message);
    throw error;
  }
}

fetchData();

HTTPS प्रॉक्सी के साथ CONNECT विधि के माध्यम से काम करने के लिए, आप अतिरिक्त एजेंट का उपयोग कर सकते हैं:

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = 'http://username:password@proxy-server.com:8080';
const httpsAgent = new HttpsProxyAgent(proxyUrl);

const axiosInstance = axios.create({
  httpsAgent: httpsAgent,
  timeout: 15000
});

// उपयोग
axiosInstance.get('https://api.example.com/secure-data')
  .then(response => console.log(response.data))
  .catch(error => console.error(error.message));

Axios स्वचालित रूप से रीडायरेक्शन को संभालता है और लॉगिंग और त्रुटियों को संभालने के लिए इंटरसेप्टर्स का समर्थन करता है, जो इसे प्रॉक्सी के सक्रिय उपयोग वाले प्रोजेक्ट्स के लिए एक उत्कृष्ट विकल्प बनाता है।

got और node-fetch में प्रॉक्सी सेटअप

Got — Axios का एक आधुनिक विकल्प है, जिसमें TypeScript का उत्कृष्ट समर्थन और त्रुटियों को संभालने की उन्नत सुविधाएँ हैं। Node-fetch Node.js के लिए मानक Fetch API को लागू करता है।

Got में प्रॉक्सी के साथ काम करना

Got और आवश्यक एजेंट स्थापित करना:

npm install got https-proxy-agent

Got में प्रॉक्सी सेटअप का उदाहरण:

const got = require('got');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = 'http://username:password@proxy-server.com:8080';
const agent = {
  https: new HttpsProxyAgent(proxyUrl)
};

// प्रॉक्सी के साथ Got का उदाहरण बनाना
const gotWithProxy = got.extend({
  agent: agent,
  timeout: {
    request: 10000
  },
  retry: {
    limit: 3,
    methods: ['GET', 'POST']
  }
});

// उपयोग
async function fetchWithGot() {
  try {
    const response = await gotWithProxy('https://api.example.com/data');
    console.log('Response:', JSON.parse(response.body));
  } catch (error) {
    console.error('Got request failed:', error.message);
  }
}

fetchWithGot();

node-fetch में प्रॉक्सी के साथ काम करना

Node-fetch को प्रॉक्सी के साथ काम करने के लिए एजेंट को स्पष्ट रूप से सेट करने की आवश्यकता होती है:

npm install node-fetch https-proxy-agent

const fetch = require('node-fetch');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = 'http://username:password@proxy-server.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);

async function fetchWithProxy() {
  try {
    const response = await fetch('https://api.example.com/data', {
      agent: agent,
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
      }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log('Data:', data);
    return data;
  } catch (error) {
    console.error('Fetch failed:', error.message);
    throw error;
  }
}

fetchWithProxy();

Got बॉक्स से बाहर अधिक समृद्ध कार्यक्षमता प्रदान करता है (स्वचालित पुनः प्रयास, टाइमआउट, त्रुटियों को संभालना), जबकि node-fetch मानक Fetch API के करीब है और उन डेवलपर्स के लिए उपयुक्त है जो ब्राउज़र के JavaScript से परिचित हैं।

socks-proxy-agent के माध्यम से SOCKS5 प्रॉक्सी कनेक्शन

SOCKS5 एक सार्वभौमिक प्रॉक्सी प्रोटोकॉल है, जो HTTP/HTTPS की तुलना में निम्न स्तर पर काम करता है। यह UDP और WebSocket कनेक्शनों सहित किसी भी प्रकार के ट्रैफ़िक का समर्थन करता है। Node.js में SOCKS5 के साथ काम करने के लिए socks-proxy-agent पुस्तकालय का उपयोग किया जाता है।

आवश्यक पैकेज स्थापित करना:

npm install socks-proxy-agent

विभिन्न पुस्तकालयों के साथ SOCKS5 प्रॉक्सी का उपयोग करने का उदाहरण:

const { SocksProxyAgent } = require('socks-proxy-agent');
const https = require('https');

// प्रॉक्सी सेटअप SOCKS5 के साथ ऑथेंटिकेशन
const proxyUrl = 'socks5://username:password@proxy-server.com:1080';
const agent = new SocksProxyAgent(proxyUrl);

const options = {
  hostname: 'api.example.com',
  path: '/endpoint',
  method: 'GET',
  agent: agent
};

https.get(options, (res) => {
  let data = '';
  
  res.on('data', (chunk) => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('SOCKS5 response:', data);
  });
}).on('error', (error) => {
  console.error('SOCKS5 request failed:', error.message);
});

Axios के साथ SOCKS5 का उपयोग:

const axios = require('axios');
const { SocksProxyAgent } = require('socks-proxy-agent');

const proxyUrl = 'socks5://username:password@proxy-server.com:1080';
const httpsAgent = new SocksProxyAgent(proxyUrl);
const httpAgent = new SocksProxyAgent(proxyUrl);

const axiosWithSocks = axios.create({
  httpAgent: httpAgent,
  httpsAgent: httpsAgent,
  timeout: 15000
});

async function fetchViaSocks5() {
  try {
    const response = await axiosWithSocks.get('https://api.example.com/data');
    console.log('Data via SOCKS5:', response.data);
    return response.data;
  } catch (error) {
    console.error('SOCKS5 request error:', error.message);
    throw error;
  }
}

fetchViaSocks5();

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

लोड वितरण के लिए प्रॉक्सी रोटेशन का कार्यान्वयन

बड़े डेटा सेट को पार्स करते समय या API के साथ काम करते समय, जिनके पास एक IP से अनुरोधों की संख्या पर सीमाएँ होती हैं, प्रॉक्सी रोटेशन का उपयोग करना आवश्यक होता है। यह कई प्रॉक्सी सर्वरों के बीच अनुरोधों को वितरित करने और ब्लॉक से बचने की अनुमति देता है।

प्रॉक्सी रोटेशन का एक सरल कार्यान्वयन उदाहरण:

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

class ProxyRotator {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
  }
  
  // गोलाकार तरीके से अगला प्रॉक्सी प्राप्त करें
  getNextProxy() {
    const proxy = this.proxyList[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
    return proxy;
  }
  
  // यादृच्छिक प्रॉक्सी प्राप्त करें
  getRandomProxy() {
    const randomIndex = Math.floor(Math.random() * this.proxyList.length);
    return this.proxyList[randomIndex];
  }
  
  // वर्तमान प्रॉक्सी के साथ Axios उदाहरण बनाएँ
  createAxiosInstance(useRandom = false) {
    const proxyUrl = useRandom ? this.getRandomProxy() : this.getNextProxy();
    const agent = new HttpsProxyAgent(proxyUrl);
    
    return axios.create({
      httpsAgent: agent,
      timeout: 10000,
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
      }
    });
  }
}

// प्रॉक्सी सूची
const proxyList = [
  'http://user1:pass1@proxy1.example.com:8080',
  'http://user2:pass2@proxy2.example.com:8080',
  'http://user3:pass3@proxy3.example.com:8080',
  'http://user4:pass4@proxy4.example.com:8080'
];

const rotator = new ProxyRotator(proxyList);

// रोटेशन का उपयोग करना
async function fetchWithRotation(url) {
  const axiosInstance = rotator.createAxiosInstance();
  
  try {
    const response = await axiosInstance.get(url);
    console.log('Success with proxy');
    return response.data;
  } catch (error) {
    console.error('Request failed:', error.message);
    throw error;
  }
}

// रोटेशन के साथ बड़े पैमाने पर पार्सिंग का उदाहरण
async function massiveParsing(urls) {
  const results = [];
  
  for (const url of urls) {
    try {
      const data = await fetchWithRotation(url);
      results.push({ url, success: true, data });
      
      // अनुरोधों के बीच देरी
      await new Promise(resolve => setTimeout(resolve, 1000));
    } catch (error) {
      results.push({ url, success: false, error: error.message });
    }
  }
  
  return results;
}

// पार्सिंग शुरू करना
const urlsToParse = [
  'https://api.example.com/data/1',
  'https://api.example.com/data/2',
  'https://api.example.com/data/3',
  'https://api.example.com/data/4',
  'https://api.example.com/data/5'
];

massiveParsing(urlsToParse)
  .then(results => console.log('Parsing results:', results))
  .catch(error => console.error('Parsing error:', error));

एक अधिक उन्नत उदाहरण जिसमें प्रॉक्सी की स्थिति को ट्रैक करना और काम नहीं करने वालों को स्वचालित रूप से बाहर करना शामिल है:

class AdvancedProxyRotator {
  constructor(proxyList, maxFailures = 3) {
    this.proxyList = proxyList.map(url => ({
      url,
      failures: 0,
      active: true,
      lastUsed: null
    }));
    this.maxFailures = maxFailures;
    this.currentIndex = 0;
  }
  
  // सक्रिय प्रॉक्सी प्राप्त करें
  getActiveProxy() {
    const activeProxies = this.proxyList.filter(p => p.active);
    
    if (activeProxies.length === 0) {
      throw new Error('कोई सक्रिय प्रॉक्सी उपलब्ध नहीं है');
    }
    
    // सबसे लंबे समय तक उपयोग नहीं की गई प्रॉक्सी खोजें
    const proxy = activeProxies.reduce((oldest, current) => {
      if (!oldest.lastUsed) return oldest;
      if (!current.lastUsed) return current;
      return current.lastUsed < oldest.lastUsed ? current : oldest;
    });
    
    proxy.lastUsed = Date.now();
    return proxy;
  }
  
  // प्रॉक्सी को सफल के रूप में चिह्नित करें
  markSuccess(proxyUrl) {
    const proxy = this.proxyList.find(p => p.url === proxyUrl);
    if (proxy) {
      proxy.failures = 0;
    }
  }
  
  // प्रॉक्सी को असफल के रूप में चिह्नित करें
  markFailure(proxyUrl) {
    const proxy = this.proxyList.find(p => p.url === proxyUrl);
    if (proxy) {
      proxy.failures++;
      if (proxy.failures >= this.maxFailures) {
        proxy.active = false;
        console.warn(`प्रॉक्सी ${proxyUrl} को ${proxy.failures} असफलताओं के बाद निष्क्रिय किया गया`);
      }
    }
  }
  
  // रोटेशन के साथ Axios उदाहरण बनाएँ
  async createAxiosInstance() {
    const proxy = this.getActiveProxy();
    const agent = new HttpsProxyAgent(proxy.url);
    
    return {
      instance: axios.create({
        httpsAgent: agent,
        timeout: 10000
      }),
      proxyUrl: proxy.url
    };
  }
  
  // प्रॉक्सी की स्थिति प्राप्त करें
  getStats() {
    return {
      total: this.proxyList.length,
      active: this.proxyList.filter(p => p.active).length,
      inactive: this.proxyList.filter(p => !p.active).length,
      proxies: this.proxyList.map(p => ({
        url: p.url.replace(/\/\/.*@/, '//***@'), // क्रेडेंशियल्स छिपाएं
        active: p.active,
        failures: p.failures
      }))
    };
  }
}

// उन्नत रोटेटर का उपयोग करना
const advancedRotator = new AdvancedProxyRotator(proxyList);

async function fetchWithAdvancedRotation(url) {
  const { instance, proxyUrl } = await advancedRotator.createAxiosInstance();
  
  try {
    const response = await instance.get(url);
    advancedRotator.markSuccess(proxyUrl);
    return response.data;
  } catch (error) {
    advancedRotator.markFailure(proxyUrl);
    throw error;
  }
}

// स्थिति की रिपोर्टिंग के लिए समय-समय पर
setInterval(() => {
  console.log('Proxy stats:', advancedRotator.getStats());
}, 30000);

यह प्रणाली स्वचालित रूप से काम नहीं करने वाली प्रॉक्सियों को रोटेशन से बाहर करती है और सक्रिय सर्वरों के बीच लोड को समान रूप से वितरित करती है। यह बड़े डेटा सेट के साथ काम करते समय महत्वपूर्ण है।

त्रुटियों को संभालना और प्रॉक्सी का स्वचालित स्विचिंग

प्रॉक्सी के साथ काम करते समय त्रुटियाँ अनिवार्य रूप से उत्पन्न होती हैं: टाइमआउट, कनेक्शन अस्वीकृत, लक्षित सर्वर द्वारा ब्लॉक। त्रुटियों को सही ढंग से संभालना और दूसरे प्रॉक्सी पर स्वचालित रूप से स्विच करना अनुप्रयोग की विश्वसनीयता को बढ़ाता है।

स्वचालित पुनः प्रयास और प्रॉक्सी स्विचिंग के साथ प्रणाली का कार्यान्वयन का उदाहरण:

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

class ResilientProxyClient {
  constructor(proxyList, maxRetries = 3) {
    this.proxyList = proxyList;
    this.maxRetries = maxRetries;
    this.currentProxyIndex = 0;
  }
  
  // अगला प्रॉक्सी प्राप्त करें
  getNextProxy() {
    const proxy = this.proxyList[this.currentProxyIndex];
    this.currentProxyIndex = (this.currentProxyIndex + 1) % this.proxyList.length;
    return proxy;
  }
  
  // त्रुटि के प्रकार को निर्धारित करें
  isRetryableError(error) {
    // त्रुटियाँ जिनके लिए अनुरोध को पुनः प्रयास करना चाहिए
    const retryableCodes = ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'ECONNREFUSED'];
    const retryableStatuses = [408, 429, 500, 502, 503, 504];
    
    if (error.code && retryableCodes.includes(error.code)) {
      return true;
    }
    
    if (error.response && retryableStatuses.includes(error.response.status)) {
      return true;
    }
    
    return false;
  }
  
  // स्वचालित पुनः प्रयास के साथ अनुरोध निष्पादित करें
  async request(url, options = {}, attempt = 1) {
    const proxyUrl = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxyUrl);
    
    const config = {
      ...options,
      httpsAgent: agent,
      timeout: 10000,
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        ...options.headers
      }
    };
    
    try {
      console.log(`Attempt ${attempt}/${this.maxRetries} with proxy: ${proxyUrl.replace(/\/\/.*@/, '//***@')}`);
      const response = await axios.get(url, config);
      console.log(`Attempt ${attempt} पर सफलता`);
      return response.data;
    } catch (error) {
      console.error(`Attempt ${attempt} असफल: ${error.message}`);
      
      // यदि पुनः प्रयास की सीमा तक पहुँच गया
      if (attempt >= this.maxRetries) {
        console.error(`Max retries (${this.maxRetries}) ${url} के लिए पहुँच गया`);
        throw error;
      }
      
      // यदि त्रुटि पुनः प्रयास करने योग्य नहीं है
      if (!this.isRetryableError(error)) {
        console.error(`Non-retryable error: ${error.message}`);
        throw error;
      }
      
      // पुनः प्रयास से पहले एक्सपोनेंशियल देरी
      const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
      console.log(`Retry से पहले ${delay}ms तक प्रतीक्षा कर रहा हूँ...`);
      await new Promise(resolve => setTimeout(resolve, delay));
      
      // अगले प्रॉक्सी के साथ पुनः प्रयास
      return this.request(url, options, attempt + 1);
    }
  }
  
  // त्रुटियों को संभालने के साथ URL का बैच अनुरोध
  async batchRequest(urls, concurrency = 3) {
    const results = [];
    const queue = [...urls];
    const active = [];
    
    while (queue.length > 0 || active.length > 0) {
      // समानांतरता की सीमा तक पहुँचने तक नई कार्यों को शुरू करें
      while (active.length < concurrency && queue.length > 0) {
        const url = queue.shift();
        const promise = this.request(url)
          .then(data => ({ url, success: true, data }))
          .catch(error => ({ url, success: false, error: error.message }))
          .finally(() => {
            const index = active.indexOf(promise);
            if (index > -1) active.splice(index, 1);
          });
        
        active.push(promise);
      }
      
      // कम से कम एक कार्य के पूरा होने का इंतजार करें
      if (active.length > 0) {
        const result = await Promise.race(active);
        results.push(result);
      }
    }
    
    return results;
  }
}

// उपयोग
const proxyList = [
  'http://user1:pass1@proxy1.example.com:8080',
  'http://user2:pass2@proxy2.example.com:8080',
  'http://user3:pass3@proxy3.example.com:8080'
];

const client = new ResilientProxyClient(proxyList, 3);

// एकल अनुरोध
client.request('https://api.example.com/data')
  .then(data => console.log('Data:', data))
  .catch(error => console.error('Final error:', error.message));

// बैच प्रोसेसिंग
const urls = [
  'https://api.example.com/data/1',
  'https://api.example.com/data/2',
  'https://api.example.com/data/3',
  'https://api.example.com/data/4',
  'https://api.example.com/data/5'
];

client.batchRequest(urls, 3)
  .then(results => {
    const successful = results.filter(r => r.success).length;
    const failed = results.filter(r => !r.success).length;
    console.log(`पूर्ण: ${successful} सफल, ${failed} असफल`);
    console.log('परिणाम:', results);
  });

यह कार्यान्वयन शामिल करता है:

• त्रुटि पर अगले प्रॉक्सी पर स्वचालित रूप से स्विच करना
• पुनः प्रयासों के बीच एक्सपोनेंशियल देरी (1s, 2s, 4s, 8s, 10s अधिकतम)
• पुनः प्रयास करने के लिए त्रुटि के प्रकार को निर्धारित करना
• बैच प्रोसेसिंग के दौरान समानांतरता को नियंत्रित करना
• डिबगिंग के लिए विस्तृत लॉगिंग

सर्वोत्तम प्रथाएँ और प्रदर्शन अनुकूलन

Node.js अनुप्रयोगों में प्रॉक्सी के साथ काम करते समय स्थिरता और प्रदर्शन सुनिश्चित करने के लिए निम्नलिखित सिफारिशों का पालन करना चाहिए:

1. कनेक्शनों का प्रबंधन

प्रत्येक अनुरोध के लिए नए बनाने के बजाय HTTP एजेंटों का पुन: उपयोग करें। यह कनेक्शन स्थापित करने पर ओवरहेड को कम करता है:

const { HttpsProxyAgent } = require('https-proxy-agent');

// खराब: प्रत्येक अनुरोध के लिए एजेंट बनाना
async function badExample(url) {
  const agent = new HttpsProxyAgent(proxyUrl);
  return axios.get(url, { httpsAgent: agent });
}

// अच्छा: एजेंट का पुनः उपयोग करना
const agent = new HttpsProxyAgent(proxyUrl);
const axiosInstance = axios.create({
  httpsAgent: agent,
  httpAgent: agent
});

async function goodExample(url) {
  return axiosInstance.get(url);
}

2. टाइमआउट सेट करना

हमेशा एप्लिकेशन के लटकने से रोकने के लिए उचित टाइमआउट सेट करें:

const axiosInstance = axios.create({
  httpsAgent: agent,
  timeout: 10000, // सामान्य टाइमआउट
  // Got के लिए टाइमआउट सेटिंग्स
  // timeout: {
  //   lookup: 1000,    // DNS लुकअप
  //   connect: 2000,   // प्रॉक्सी से कनेक्ट करना
  //   secureConnect: 2000, // SSL हैंडशेक
  //   socket: 5000,    // सॉकेट की निष्क्रियता
  //   response: 3000,  // प्रतिक्रिया के पहले बाइट की प्रतीक्षा
  //   send: 10000,     // अनुरोध भेजना
  //   request: 15000   // पूरा अनुरोध
  // }
});

3. समानांतरता को नियंत्रित करना

ओवरलोडिंग से बचने के लिए एक साथ अनुरोधों की संख्या को सीमित करें:

const pLimit = require('p-limit');

// 5 समानांतर अनुरोधों तक सीमित करना
const limit = pLimit(5);

async function processUrls(urls) {
  const promises = urls.map(url => 
    limit(() => axiosInstance.get(url))
  );
  
  return Promise.allSettled(promises);
}

4. User-Agent का रोटेशन

अधिक गुमनामी के लिए प्रॉक्सी रोटेशन के साथ User-Agent का रोटेशन संयोजित करें:

const userAgents = [
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0'
];

function getRandomUserAgent() {
  return userAgents[Math.floor(Math.random() * userAgents.length)];
}

async function fetchWithRandomUA(url) {
  return axiosInstance.get(url, {
    headers: {
      'User-Agent': getRandomUserAgent()
    }
  });
}

5. मॉनिटरिंग और लॉगिंग

प्रॉक्सी के प्रदर्शन को ट्रैक करने के लिए एक मॉनिटरिंग सिस्टम लागू करें:

class ProxyMonitor {
  constructor() {
    this.stats = new Map();
  }
  
  recordRequest(proxyUrl, success, responseTime) {
    if (!this.stats.has(proxyUrl)) {
      this.stats.set(proxyUrl, {
        total: 0,
        success: 0,
        failed: 0,
        totalResponseTime: 0,
        avgResponseTime: 0
      });
    }
    
    const stat = this.stats.get(proxyUrl);
    stat.total++;
    
    if (success) {
      stat.success++;
      stat.totalResponseTime += responseTime;
      stat.avgResponseTime = stat.totalResponseTime / stat.success;
    } else {
      stat.failed++;
    }
  }
  
  getReport() {
    const report = [];
    
    this.stats.forEach((stat, proxyUrl) => {
      report.push({
        proxy: proxyUrl.replace(/\/\/.*@/, '//***@'),
        successRate: ((stat.success / stat.total) * 100).toFixed(2) + '%',
        avgResponseTime: stat.avgResponseTime.toFixed(0) + 'ms',
        total: stat.total,
        success: stat.success,
        failed: stat.failed
      });
    });
    
    return report;
  }
}

const monitor = new ProxyMonitor();

// मॉनिटरिंग के साथ अनुरोधों के लिए लपेटना
async function monitoredRequest(url, proxyUrl) {
  const startTime = Date.now();
  
  try {
    const response = await axiosInstance.get(url);
    const responseTime = Date.now() - startTime;
    monitor.recordRequest(proxyUrl, true, responseTime);
    return response.data;
  } catch (error) {
    const responseTime = Date.now() - startTime;
    monitor.recordRequest(proxyUrl, false, responseTime);
    throw error;
  }
}

// समय-समय पर रिपोर्ट
setInterval(() => {
  console.table(monitor.getReport());
}, 60000);

6. प्रॉक्सी के प्रकार का चयन

कार्य के आधार पर प्रॉक्सी के प्रकार का चयन करें:

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

7. क्रेडेंशियल्स की सुरक्षा

कभी भी प्रॉक्सी क्रेडेंशियल्स को कोड में न रखें। पर्यावरणीय चर का उपयोग करें:

// .env फ़ाइल
PROXY_HOST=proxy-server.com
PROXY_PORT=8080
PROXY_USERNAME=your-username
PROXY_PASSWORD=your-password

// कोड में
require('dotenv').config();

const proxyUrl = `http://${process.env.PROXY_USERNAME}:${process.env.PROXY_PASSWORD}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;

// या प्रॉक्सी सूची के लिए
const proxyList = process.env.PROXY_LIST.split(',').map(proxy => proxy.trim());

निष्कर्ष

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

ध्यान में रखने योग्य मुख्य बिंदु:

• HTTP अनुरोधों के लिए पुस्तकालय का चयन कार्य के अनुसार करें: Axios सामान्यता के लिए, Got TypeScript प्रोजेक्ट्स के लिए, node-fetch ब्राउज़र API के साथ संगतता के लिए
• असामान्य प्रोटोकॉल के साथ काम करने और अधिकतम लचीलापन के लिए SOCKS5 प्रॉक्सी का उपयोग करें
• लोड वितरण और ब्लॉक से बचने के लिए प्रॉक्सी रोटेशन का कार्यान्वयन करें
• स्वचालित पुनः प्रयास और प्रॉक्सी स्विचिंग के साथ त्रुटियों को संभालने की प्रणाली लागू करें
• प्रॉक्सी के प्रदर्शन की निगरानी करें और काम नहीं करने वालों को स्वचालित रूप से बाहर करें
• HTTP एजेंटों का पुनः उपयोग करें और उचित टाइमआउट सेट करें
• क्रेडेंशियल्स को कोड में नहीं, बल्कि पर्यावरणीय चर में रखें

अपने Node.js अनुप्रयोगों के लिए प्रॉक्सी का चयन करते समय कार्य की विशिष्टता पर विचार करें। सुरक्षित प्लेटफार्मों के पार्सिंग और IP की प्रतिष्ठा के प्रति संवेदनशील API के साथ काम करने के लिए, रिहायशी प्रॉक्सी का उपयोग करने की सिफारिश की जाती है - वे वास्तविक घरेलू उपयोगकर्ताओं के IP पते का उपयोग करके उच्च स्तर की गुमनामी और न्यूनतम ब्लॉक जोखिम सुनिश्चित करते हैं।