Proxy-Einstellungen in Node.js: Ein umfassender Leitfaden mit Beispielen

```html

Bei der Entwicklung von Node.js-Anwendungen für das Scraping, die Automatisierung oder die Arbeit mit APIs besteht häufig die Notwendigkeit, Proxy-Server zu verwenden. Dies ermöglicht es, geografische Einschränkungen zu umgehen, die Last zu verteilen und IP-Sperren zu vermeiden. In diesem Leitfaden werden wir alle Möglichkeiten zur Einrichtung von Proxys in Node.js untersuchen – von grundlegenden bis hin zu fortgeschrittenen Techniken mit Rotation und Fehlerbehandlung.

Grundlegende Konzepte der Arbeit mit Proxys in Node.js

Ein Proxy-Server in Node.js fungiert als Vermittler zwischen Ihrer Anwendung und dem Zielserver. Wenn Sie eine HTTP-Anfrage über einen Proxy senden, verbindet sich Ihre Anwendung zunächst mit dem Proxy-Server, der dann die Anfrage an die endgültige Adresse weiterleitet. Dies ermöglicht es, die echte IP-Adresse Ihres Servers zu verbergen und die IP-Adresse des Proxys zu verwenden.

In Node.js gibt es mehrere grundlegende Möglichkeiten, mit Proxys zu arbeiten, abhängig von der verwendeten Bibliothek für HTTP-Anfragen. Die beliebtesten Optionen sind:

Integrierte http/https-Module – grundlegende Funktionalität ohne zusätzliche Abhängigkeiten
Axios – beliebte Bibliothek mit benutzerfreundlichem API und Unterstützung für Promises
Got – moderne Alternative mit TypeScript-Unterstützung
node-fetch – Implementierung der Fetch API für Node.js
request – veraltete, aber immer noch verwendete Bibliothek (nicht für neue Projekte empfohlen)

Proxy-Server unterstützen verschiedene Protokolle. Für die Arbeit mit Node.js werden am häufigsten verwendet:

Protokoll	Beschreibung	Anwendung
HTTP	Grundprotokoll für unverschlüsselte Verbindungen	Scraping, Arbeiten mit APIs ohne SSL
HTTPS	Proxy mit Unterstützung für SSL/TLS-Verschlüsselung	Sichere Verbindungen, Arbeiten mit geschützten APIs
SOCKS5	Universelles Protokoll für jeden Verkehrstyp	WebSocket, UDP, komplexe Szenarien

Für Scraping- und Automatisierungsaufgaben verwenden Entwickler häufig residential Proxys, da sie echte IP-Adressen von Haushaltsnutzern haben und seltener von Zielwebsites blockiert werden.

Einrichtung von Proxys über das integrierte http/https-Modul

Node.js bietet die integrierten Module http und https für die Arbeit mit HTTP-Anfragen. Zum Verbinden von Proxys kann die Bibliothek http-proxy-agent oder https-proxy-agent verwendet werden.

Zuerst installieren Sie die benötigten Pakete:

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

Beispiel für die Verwendung eines HTTP-Proxys mit dem integrierten Modul:

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

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

// Anfrageoptionen
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'
  }
};

// Anfrage ausführen
const req = http.request(options, (res) => {
  let data = '';
  
  res.on('data', (chunk) => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('Antwort:', data);
  });
});

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

req.end();

Für HTTPS-Verbindungen verwenden Sie 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('Sichere Antwort:', data);
  });
}).on('error', (error) => {
  console.error('HTTPS-Anfrage fehlgeschlagen:', error.message);
});

Dieser Ansatz bietet maximale Kontrolle über die Anfragen, erfordert jedoch mehr Code zur Verarbeitung von Promises und Fehlern. Für die meisten Aufgaben ist es bequemer, spezialisierte Bibliotheken zu verwenden.

Arbeiten mit Proxys in der Axios-Bibliothek

Axios ist eine der beliebtesten Bibliotheken für HTTP-Anfragen in Node.js. Sie bietet eine benutzerfreundliche API zur Konfiguration von Proxys und verarbeitet automatisch Promises.

Installation von Axios:

npm install axios

Die grundlegende Proxy-Konfiguration in Axios sieht folgendermaßen aus:

const axios = require('axios');

// Methode 1: Proxy in der Anfragekonfiguration einstellen
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('Daten:', response.data);
})
.catch(error => {
  console.error('Fehler:', error.message);
});

Für die mehrfache Verwendung derselben Proxy-Einstellungen ist es praktisch, eine Axios-Instanz mit vordefinierter Konfiguration zu erstellen:

const axios = require('axios');

// Erstellen einer Instanz mit Proxy-Einstellungen
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'
  }
});

// Verwendung der Instanz
async function fetchData() {
  try {
    const response = await axiosWithProxy.get('https://api.example.com/data');
    console.log('Antwort:', response.data);
    return response.data;
  } catch (error) {
    console.error('Anfrage fehlgeschlagen:', error.message);
    throw error;
  }
}

fetchData();

Für die Arbeit mit HTTPS-Proxys über die CONNECT-Methode können zusätzliche Agenten verwendet werden:

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
});

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

Axios verarbeitet automatisch Weiterleitungen und unterstützt Interceptoren für Protokollierung und Fehlerbehandlung, was es zu einer ausgezeichneten Wahl für Projekte mit aktivem Proxy-Einsatz macht.

Einrichtung von Proxys in got und node-fetch

Got ist eine moderne Alternative zu Axios mit hervorragender TypeScript-Unterstützung und erweiterten Fehlerbehandlungsfunktionen. Node-fetch implementiert die standardisierte Fetch API für Node.js.

Arbeiten mit Proxys in Got

Installation von Got und benötigten Agenten:

npm install got https-proxy-agent

Beispiel für die Proxy-Einrichtung in 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)
};

// Erstellen einer Got-Instanz mit Proxy
const gotWithProxy = got.extend({
  agent: agent,
  timeout: {
    request: 10000
  },
  retry: {
    limit: 3,
    methods: ['GET', 'POST']
  }
});

// Verwendung
async function fetchWithGot() {
  try {
    const response = await gotWithProxy('https://api.example.com/data');
    console.log('Antwort:', JSON.parse(response.body));
  } catch (error) {
    console.error('Got-Anfrage fehlgeschlagen:', error.message);
  }
}

fetchWithGot();

Arbeiten mit Proxys in node-fetch

Node-fetch erfordert eine explizite Agenten-Konfiguration für die Arbeit mit Proxys:

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-Fehler! Status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log('Daten:', data);
    return data;
  } catch (error) {
    console.error('Fetch fehlgeschlagen:', error.message);
    throw error;
  }
}

fetchWithProxy();

Got bietet eine umfangreichere Funktionalität von Haus aus (automatische Wiederholungen, Timeouts, Fehlerbehandlung), während node-fetch näher an der standardisierten Fetch API ist und sich für Entwickler eignet, die mit browserbasiertem JavaScript vertraut sind.

Verbindung zu SOCKS5-Proxys über socks-proxy-agent

SOCKS5 ist ein universelles Proxy-Protokoll, das auf einer niedrigeren Ebene als HTTP/HTTPS arbeitet. Es unterstützt jeden Verkehrstyp, einschließlich UDP und WebSocket-Verbindungen. Für die Arbeit mit SOCKS5 in Node.js wird die Bibliothek socks-proxy-agent verwendet.

Installation der benötigten Pakete:

npm install socks-proxy-agent

Beispiel für die Verwendung eines SOCKS5-Proxys mit verschiedenen Bibliotheken:

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

// SOCKS5-Proxy mit Authentifizierung einrichten
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-Antwort:', data);
  });
}).on('error', (error) => {
  console.error('SOCKS5-Anfrage fehlgeschlagen:', error.message);
});

Verwendung von SOCKS5 mit Axios:

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('Daten über SOCKS5:', response.data);
    return response.data;
  } catch (error) {
    console.error('SOCKS5-Anfragefehler:', error.message);
    throw error;
  }
}

fetchViaSocks5();

SOCKS5-Proxys sind besonders nützlich für Aufgaben, die die Arbeit mit nicht standardisierten Protokollen erfordern oder wenn maximale Flexibilität benötigt wird. Viele Anbieter bieten mobile Proxys mit SOCKS5-Unterstützung an, was es ermöglicht, mobilen Verkehr für die Arbeit mit mobilen APIs zu emulieren.

Implementierung der Proxy-Rotation zur Lastverteilung

Beim Scraping großer Datenmengen oder bei der Arbeit mit APIs, die Limits für die Anzahl der Anfragen von einer IP haben, ist es notwendig, Proxys zu rotieren. Dies ermöglicht es, Anfragen zwischen mehreren Proxy-Servern zu verteilen und Sperren zu vermeiden.

Beispiel für die Implementierung einer einfachen Proxy-Rotation:

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

class ProxyRotator {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
  }
  
  // Nächsten Proxy im Rundlauf abrufen
  getNextProxy() {
    const proxy = this.proxyList[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
    return proxy;
  }
  
  // Zufälligen Proxy abrufen
  getRandomProxy() {
    const randomIndex = Math.floor(Math.random() * this.proxyList.length);
    return this.proxyList[randomIndex];
  }
  
  // Axios-Instanz mit aktuellem Proxy erstellen
  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'
      }
    });
  }
}

// Liste der Proxys
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);

// Verwendung der Rotation
async function fetchWithRotation(url) {
  const axiosInstance = rotator.createAxiosInstance();
  
  try {
    const response = await axiosInstance.get(url);
    console.log('Erfolg mit Proxy');
    return response.data;
  } catch (error) {
    console.error('Anfrage fehlgeschlagen:', error.message);
    throw error;
  }
}

// Beispiel für massives Scraping mit Rotation
async function massiveParsing(urls) {
  const results = [];
  
  for (const url of urls) {
    try {
      const data = await fetchWithRotation(url);
      results.push({ url, success: true, data });
      
      // Verzögerung zwischen Anfragen
      await new Promise(resolve => setTimeout(resolve, 1000));
    } catch (error) {
      results.push({ url, success: false, error: error.message });
    }
  }
  
  return results;
}

// Scraping starten
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('Scraping-Ergebnisse:', results))
  .catch(error => console.error('Scraping-Fehler:', error));

Ein fortgeschritteneres Beispiel mit der Überwachung des Proxy-Zustands und dem automatischen Ausschluss nicht funktionierender Proxys:

class AdvancedProxyRotator {
  constructor(proxyList, maxFailures = 3) {
    this.proxyList = proxyList.map(url => ({
      url,
      failures: 0,
      active: true,
      lastUsed: null
    }));
    this.maxFailures = maxFailures;
    this.currentIndex = 0;
  }
  
  // Aktiven Proxy abrufen
  getActiveProxy() {
    const activeProxies = this.proxyList.filter(p => p.active);
    
    if (activeProxies.length === 0) {
      throw new Error('Keine aktiven Proxys verfügbar');
    }
    
    // Proxy finden, der am längsten nicht verwendet wurde
    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;
  }
  
  // Proxy als erfolgreich markieren
  markSuccess(proxyUrl) {
    const proxy = this.proxyList.find(p => p.url === proxyUrl);
    if (proxy) {
      proxy.failures = 0;
    }
  }
  
  // Proxy als fehlgeschlagen markieren
  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(`Proxy ${proxyUrl} nach ${proxy.failures} Fehlern deaktiviert`);
      }
    }
  }
  
  // Axios-Instanz mit Rotation erstellen
  async createAxiosInstance() {
    const proxy = this.getActiveProxy();
    const agent = new HttpsProxyAgent(proxy.url);
    
    return {
      instance: axios.create({
        httpsAgent: agent,
        timeout: 10000
      }),
      proxyUrl: proxy.url
    };
  }
  
  // Proxy-Statistik abrufen
  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(/\/\/.*@/, '//***@'), // Anmeldeinformationen verbergen
        active: p.active,
        failures: p.failures
      }))
    };
  }
}

// Verwendung des fortgeschrittenen Rotators
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;
  }
}

// Periodische Ausgabe der Statistik
setInterval(() => {
  console.log('Proxy-Statistik:', advancedRotator.getStats());
}, 30000);

Ein solches System schließt automatisch nicht funktionierende Proxys aus der Rotation aus und verteilt die Last gleichmäßig auf aktive Server. Dies ist entscheidend bei der Arbeit mit großen Datenmengen.

Fehlerbehandlung und automatisches Umschalten von Proxys

Bei der Arbeit mit Proxys treten unvermeidlich Fehler auf: Timeouts, Verbindungsabbrüche, Sperren durch den Zielserver. Eine ordnungsgemäße Fehlerbehandlung und das automatische Umschalten auf einen anderen Proxy erhöhen die Zuverlässigkeit der Anwendung.

Beispiel für die Implementierung eines Systems mit automatischen Wiederholungen und Proxy-Umschaltung:

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;
  }
  
  // Nächsten Proxy abrufen
  getNextProxy() {
    const proxy = this.proxyList[this.currentProxyIndex];
    this.currentProxyIndex = (this.currentProxyIndex + 1) % this.proxyList.length;
    return proxy;
  }
  
  // Fehlerart bestimmen
  isRetryableError(error) {
    // Fehler, bei denen die Anfrage wiederholt werden sollte
    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;
  }
  
  // Anfrage mit automatischen Wiederholungen ausführen
  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(`Versuch ${attempt}/${this.maxRetries} mit Proxy: ${proxyUrl.replace(/\/\/.*@/, '//***@')}`);
      const response = await axios.get(url, config);
      console.log(`Erfolg beim Versuch ${attempt}`);
      return response.data;
    } catch (error) {
      console.error(`Versuch ${attempt} fehlgeschlagen: ${error.message}`);
      
      // Wenn das Wiederholungs-Limit erreicht ist
      if (attempt >= this.maxRetries) {
        console.error(`Maximale Wiederholungen (${this.maxRetries}) für ${url} erreicht`);
        throw error;
      }
      
      // Wenn der Fehler nicht wiederholbar ist
      if (!this.isRetryableError(error)) {
        console.error(`Nicht wiederholbarer Fehler: ${error.message}`);
        throw error;
      }
      
      // Exponentielle Verzögerung vor der Wiederholung
      const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
      console.log(`Warte ${delay}ms vor der Wiederholung...`);
      await new Promise(resolve => setTimeout(resolve, delay));
      
      // Rekursive Wiederholung mit dem nächsten Proxy
      return this.request(url, options, attempt + 1);
    }
  }
  
  // Batchverarbeitung von URLs mit Fehlerbehandlung
  async batchRequest(urls, concurrency = 3) {
    const results = [];
    const queue = [...urls];
    const active = [];
    
    while (queue.length > 0 || active.length > 0) {
      // Neue Aufgaben starten, bis das Parallelitätslimit erreicht ist
      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);
      }
      
      // Warten, bis mindestens eine Aufgabe abgeschlossen ist
      if (active.length > 0) {
        const result = await Promise.race(active);
        results.push(result);
      }
    }
    
    return results;
  }
}

// Verwendung
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);

// Einzelanfrage
client.request('https://api.example.com/data')
  .then(data => console.log('Daten:', data))
  .catch(error => console.error('Endgültiger Fehler:', error.message));

// Batchverarbeitung
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(`Abgeschlossen: ${successful} erfolgreich, ${failed} fehlgeschlagen`);
    console.log('Ergebnisse:', results);
  });

Diese Implementierung umfasst:

Automatisches Umschalten auf den nächsten Proxy bei einem Fehler
Exponentielle Verzögerung zwischen Wiederholungen (1s, 2s, 4s, 8s, max. 10s)
Bestimmung des Fehlertyps zur Entscheidungsfindung über die Wiederholung
Kontrolle der Parallelität bei der Batchverarbeitung
Detaillierte Protokollierung zur Fehlersuche

Best Practices und Leistungsoptimierung

Bei der Arbeit mit Proxys in Node.js-Anwendungen sollten die folgenden Empfehlungen beachtet werden, um Stabilität und Leistung zu gewährleisten:

1. Verbindungsmanagement

Wiederverwenden Sie HTTP-Agenten anstelle von neuen für jede Anfrage zu erstellen. Dies reduziert den Overhead für die Verbindungsherstellung:

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

// Schlecht: Erstellen eines Agenten für jede Anfrage
async function badExample(url) {
  const agent = new HttpsProxyAgent(proxyUrl);
  return axios.get(url, { httpsAgent: agent });
}

// Gut: Wiederverwendung des Agenten
const agent = new HttpsProxyAgent(proxyUrl);
const axiosInstance = axios.create({
  httpsAgent: agent,
  httpAgent: agent
});

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

2. Timeout-Einstellungen

Stellen Sie immer angemessene Timeouts ein, um das Einfrieren der Anwendung zu verhindern:

const axiosInstance = axios.create({
  httpsAgent: agent,
  timeout: 10000, // Gesamter Timeout
  // Detaillierte Timeout-Einstellungen für Got
  // timeout: {
  //   lookup: 1000,    // DNS Lookup
  //   connect: 2000,   // Verbindung zum Proxy
  //   secureConnect: 2000, // SSL Handshake
  //   socket: 5000,    // Socket-Inaktivität
  //   response: 3000,  // Warten auf das erste Byte der Antwort
  //   send: 10000,     // Anfrage senden
  //   request: 15000   // Gesamte Anfrage
  // }
});

3. Kontrolle der Parallelität

Begrenzen Sie die Anzahl gleichzeitiger Anfragen, um Überlastungen zu vermeiden:

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

// Begrenzung auf 5 gleichzeitige Anfragen
const limit = pLimit(5);

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

4. Rotation des User-Agent

Kombinieren Sie die Rotation von Proxys mit der Rotation des User-Agent für mehr Anonymität:

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. Überwachung und Protokollierung

Implementieren Sie ein Überwachungssystem zur Verfolgung der Proxy-Leistung:

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();

// Wrapper für Anfragen mit Überwachung
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;
  }
}

// Periodischer Bericht
setInterval(() => {
  console.table(monitor.getReport());
}, 60000);

6. Auswahl des Proxy-Typs

Wählen Sie den Proxy-Typ je nach Aufgabe:

Aufgabe	Empfohlener Typ	Grund
Massenscraping öffentlicher Daten	Rechenzentrums-Proxys	Hohe Geschwindigkeit, niedriger Preis
Arbeiten mit sozialen Netzwerken und geschützten Plattformen	Residential Proxys	Echte IPs, geringes Risiko einer Sperrung
Emulation von mobilem Verkehr	Mobile Proxys	IPs von Mobilfunkanbietern
Arbeiten mit nicht standardisierten Protokollen	SOCKS5-Proxys	Unterstützung für jeden Verkehr

Für Aufgaben, die ein hohes Maß an Anonymität und ein minimales Risiko von Sperren erfordern, wird empfohlen, residential Proxys zu verwenden. Für das hochgeschwindigkeits-Scraping großer Datenmengen sind Rechenzentrums-Proxys geeignet.

7. Sicherheit der Anmeldeinformationen

Speichern Sie niemals die Anmeldeinformationen des Proxys im Code. Verwenden Sie Umgebungsvariablen:

// .env-Datei
PROXY_HOST=proxy-server.com
PROXY_PORT=8080
PROXY_USERNAME=your-username
PROXY_PASSWORD=your-password

// Im Code
require('dotenv').config();

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

// Oder für die Liste der Proxys
const proxyList = process.env.PROXY_LIST.split(',').map(proxy => proxy.trim());

Fazit

Die Einrichtung von Proxys in Node.js-Anwendungen ist eine wichtige Fähigkeit für Entwickler, die mit Scraping, Automatisierung und der Integration mit externen APIs arbeiten. In diesem Leitfaden haben wir alle grundlegenden Möglichkeiten zur Arbeit mit Proxys untersucht: von der grundlegenden Einrichtung über integrierte Module bis hin zu fortgeschrittenen Techniken mit Rotation, Fehlerbehandlung und Überwachung.

Wichtige Punkte, die Sie sich merken sollten:

Wählen Sie die Bibliothek für HTTP-Anfragen je nach Aufgabe: Axios für Vielseitigkeit, Got für TypeScript-Projekte, node-fetch für die Kompatibilität mit der Browser-API
Verwenden Sie SOCKS5-Proxys für die Arbeit mit nicht standardisierten Protokollen und maximaler Flexibilität
Implementieren Sie die Proxy-Rotation zur Lastverteilung und Vermeidung von Sperren
Implementieren Sie ein Fehlerbehandlungssystem mit automatischen Wiederholungen und Proxy-Umschaltung
Überwachen Sie die Leistung der Proxys und schließen Sie nicht funktionierende automatisch aus
Wiederverwenden Sie HTTP-Agenten und stellen Sie angemessene Timeouts ein
Speichern Sie Anmeldeinformationen in Umgebungsvariablen und nicht im Code

Bei der Auswahl von Proxys für Ihre Node.js-Anwendungen sollten Sie die spezifischen Anforderungen der Aufgabe berücksichtigen. Für das Scraping geschützter Plattformen und die Arbeit mit APIs, die empfindlich auf die Reputation von IPs reagieren, empfehlen wir die Verwendung von residential Proxys – sie bieten ein hohes Maß an Anonymität und minimales Risiko von Sperren durch die Verwendung echter IP-Adressen von Haushaltsnutzern.

```

Proxy-Einrichtung in Node.js-Anwendungen: Umfassender Leitfaden mit Codebeispielen