Korzystanie z Proxies w Node.js (Axios + Puppeteer + SDK)

Po co używać Proxies w Node.js?

Node.js jest jednym z najbardziej popularnych runtimes do budowy skrobali internetowych, integratorów API i narzędzi automatyki. Ale jeśli wysyłasz setki lub tysiące żądań z jednego adresu IP, szybko znajdziesz limity stóp procentowych, CAPTCHA i całkowite zakazy IP. Proxies in Node.js rozwiązać to poprzez przekierowanie żądań przez różne adresy IP, co sprawia, że każdy z nich wydaje się pochodzić od unikalnego użytkownika.

Niezależnie od tego, czy skrobiesz ceny produktów, monitorujesz rankingi wyszukiwarek, czy zbierasz dane publiczne na skalę, proxy są niezbędną infrastrukturą. W tym przewodniku, będziemy obejmować wszystko, czego potrzebujesz, aby zintegrować proxy mieszkaniowe do projektów Node.js za pomocą ProxyHat Node SDKAxios, Puppeteer i Playwright.

Jeśli nadal oceniasz, który typ proxy pasuje do Twojego przypadku użycia, sprawdź nasze porównanie mieszkaniowe vs datacenter vs mobilne proxy.

Instalacja i konfiguracja

Instalacja ProxyHat SDK

Najszybszy sposób, aby rozpocząć jest z oficjalnym Node SDK. Obsługuje uwierzytelnianie, rotację i łączenie połączeń z pola:

npm install proxyhat

Użytkownik będzie również chciał, aby klienci HTTP planujesz używać:

npm install axios puppeteer playwright

Uwierzytelnienie

Wszystkie połączenia proksyHat proxy uwierzytelniają za pomocą API. W Deska rozdzielcza ProxyHatSDK akceptuje je jako opcje konstruktora lub zmienne środowiskowe:

// Option 1: Pass credentials directly
const ProxyHat = require('proxyhat');
const client = new ProxyHat({
  username: 'your_username',
  password: 'your_password',
});
// Option 2: Use environment variables
// Set PROXYHAT_USERNAME and PROXYHAT_PASSWORD in your .env
const client = new ProxyHat();

Prosty GET Wniosek w SDK

SDK zapewnia wysoki poziom fetch metoda, która automatycznie obsługuje rotację proxy:

const ProxyHat = require('proxyhat');
const client = new ProxyHat();
async function main() {
  const response = await client.fetch('https://httpbin.org/ip', {
    country: 'us',
  });
  console.log('Status:', response.status);
  console.log('Body:', await response.text());
}
main().catch(console.error);

Każde wywołanie automatycznie wybiera inny adres IP. Nie wymaga ręcznego formatowania proxy URL.

Stosowanie szczepionki Proxies z lekiem Axios

Axios jest najpopularniejszym klientem HTTP w ekosystemie Node.js. Aby prześledzić żądania Axios poprzez ProxyHat, możesz użyć proxy URL SDK lub skonfigurować Axios bezpośrednio.

Metoda 1: Agent SDK Proxy

const ProxyHat = require('proxyhat');
const axios = require('axios');
const client = new ProxyHat();
const agent = client.createAgent({ country: 'us' });
async function scrapeWithAxios() {
  const response = await axios.get('https://httpbin.org/ip', {
    httpAgent: agent,
    httpsAgent: agent,
    timeout: 30000,
  });
  console.log('IP:', response.data.origin);
}
scrapeWithAxios();

Metoda 2: Bezpośredni URL Proxy

Jeśli wolisz konfigurację manualną, użyj standardowego formatu proxy URL z https-proxy-agent opakowanie:

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
const proxyUrl = 'http://USERNAME:PASSWORD@gate.proxyhat.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);
async function scrapeWithAxios() {
  const response = await axios.get('https://httpbin.org/ip', {
    httpsAgent: agent,
    timeout: 30000,
  });
  console.log('IP:', response.data.origin);
}
scrapeWithAxios();

Axios Instance z domyślnym profilem

Do wielokrotnego użycia należy utworzyć wstępnie skonfigurowaną instancję Axios:

const { HttpsProxyAgent } = require('https-proxy-agent');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
const proxyClient = axios.create({
  httpsAgent: agent,
  timeout: 30000,
  headers: {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
  },
});
// All requests now go through the proxy
const res = await proxyClient.get('https://example.com');

Korzystanie z Proxies z Puppeteer

Puppeteer uruchamia przeglądarkę Chrome bez głowy, która jest idealna do skrobania stron JavaScript- ciężkich. Proxy są skonfigurowane na poziomie uruchamiania przeglądarki.

const puppeteer = require('puppeteer');
async function scrapeWithPuppeteer() {
  const browser = await puppeteer.launch({
    args: ['--proxy-server=gate.proxyhat.com:8080'],
    headless: 'new',
  });
  const page = await browser.newPage();
  // Authenticate with the proxy
  await page.authenticate({
    username: 'USERNAME',
    password: 'PASSWORD',
  });
  await page.goto('https://httpbin.org/ip', {
    waitUntil: 'networkidle2',
    timeout: 60000,
  });
  const content = await page.evaluate(() => document.body.innerText);
  console.log('IP:', content);
  await browser.close();
}
scrapeWithPuppeteer();

Marionetka z Geo-Targeting

Aby wycelować w określony kraj, wpisz kod kraju w nazwę użytkownika. ProxyHat używa formatu USERNAME-country-XX:

await page.authenticate({
  username: 'USERNAME-country-de',  // Route through Germany
  password: 'PASSWORD',
});

Przeglądaj wszystkie dostępne lokalizacje proxy na naszym strona lokalizacji.

Korzystanie z Proxies z Playwright

Playwright obsługuje Chromium, Firefox i WebKit. Konfiguracja Proxy jest wbudowana w opcje startowe, co jeszcze prostsze:

const { chromium } = require('playwright');
async function scrapeWithPlaywright() {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://gate.proxyhat.com:8080',
      username: 'USERNAME',
      password: 'PASSWORD',
    },
  });
  const context = await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://httpbin.org/ip');
  const body = await page.textContent('body');
  console.log('IP:', body);
  await browser.close();
}
scrapeWithPlaywright();

Playwright z Per- Context Proxies

Playwright pozwala na różne proxy dla kontekstu przeglądarki, co jest przydatne do wielokontowego lub wieloregionalnego skrobania:

const browser = await chromium.launch();
// US context
const usContext = await browser.newContext({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME-country-us',
    password: 'PASSWORD',
  },
});
// UK context
const ukContext = await browser.newContext({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME-country-gb',
    password: 'PASSWORD',
  },
});
const usPage = await usContext.newPage();
const ukPage = await ukContext.newPage();
await Promise.all([
  usPage.goto('https://www.google.com/search?q=proxy+service'),
  ukPage.goto('https://www.google.co.uk/search?q=proxy+service'),
]);

Obracanie vs Sticky Sessions

ProxyHat obsługuje dwa tryby sesji, które obsługują różne potrzeby skrawania:

Name

const { HttpsProxyAgent } = require('https-proxy-agent');
const axios = require('axios');
// Generate a random session ID
const sessionId = 'session_' + Math.random().toString(36).slice(2, 10);
const agent = new HttpsProxyAgent(
  `http://USERNAME-session-${sessionId}:PASSWORD@gate.proxyhat.com:8080`
);
// All requests with this agent use the same IP
const client = axios.create({ httpsAgent: agent, timeout: 30000 });
const res1 = await client.get('https://httpbin.org/ip');
const res2 = await client.get('https://httpbin.org/ip');
console.log(res1.data.origin === res2.data.origin); // true

Wnioski o udzielenie pozwolenia na dopuszczenie do obrotu

Geocelowanie jest kluczowe dla Śledzenie SERP, lokalizowane monitorowanie cen, i regionalnej weryfikacji treści. ProxyHat obsługuje cele na poziomie krajowym i miejskim poprzez łańcuch nazw użytkowników:

// Country targeting
const countryAgent = new HttpsProxyAgent(
  'http://USERNAME-country-jp:PASSWORD@gate.proxyhat.com:8080'
);
// City targeting
const cityAgent = new HttpsProxyAgent(
  'http://USERNAME-country-us-city-newyork:PASSWORD@gate.proxyhat.com:8080'
);

Sprawdź naszą pełną listę dostępne lokalizacje dla wspieranych krajów i miast.

Błąd obsługi i zatrzymywania

Błędy sieciowe są nieuniknione przy pracy z proxy w skali. Solidna strategia ponownego testowania jest niezbędna dla skrobaczy:

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
async function fetchWithRetry(url, options = {}) {
  const maxRetries = options.maxRetries || 3;
  const baseDelay = options.baseDelay || 1000;
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const agent = new HttpsProxyAgent(
        'http://USERNAME:PASSWORD@gate.proxyhat.com:8080'
      );
      const response = await axios.get(url, {
        httpsAgent: agent,
        timeout: options.timeout || 30000,
      });
      if (response.status === 200) return response;
      throw new Error(`HTTP ${response.status}`);
    } catch (error) {
      console.warn(`Attempt ${attempt}/${maxRetries} failed: ${error.message}`);
      if (attempt === maxRetries) throw error;
      // Exponential backoff: 1s, 2s, 4s...
      const delay = baseDelay * Math.pow(2, attempt - 1);
      await new Promise(r => setTimeout(r, delay));
    }
  }
}
// Usage
const response = await fetchWithRetry('https://example.com', {
  maxRetries: 3,
  timeout: 20000,
});

Równoczesne rozdrabnianie za pomocą Concurrent Control

Wysyłanie wszystkich żądań jednocześnie z Promise.all może przytłoczyć zarówno swoją maszynę jak i serwer docelowy. Do kontrolowania liczby połączeń równoległych należy użyć ogranicznika wymiany walut:

async function asyncPool(concurrency, items, iteratorFn) {
  const results = [];
  const executing = new Set();
  for (const [index, item] of items.entries()) {
    const promise = Promise.resolve().then(() => iteratorFn(item, index));
    results.push(promise);
    executing.add(promise);
    const cleanup = () => executing.delete(promise);
    promise.then(cleanup, cleanup);
    if (executing.size >= concurrency) {
      await Promise.race(executing);
    }
  }
  return Promise.all(results);
}
// Scrape 100 URLs, 10 at a time
const urls = Array.from({ length: 100 }, (_, i) =>
  `https://example.com/page/${i + 1}`
);
const results = await asyncPool(10, urls, async (url) => {
  return fetchWithRetry(url, { maxRetries: 2, timeout: 15000 });
});

Dla dużej skali projekty skrobania stron internetowych, utrzymanie wzajemnych relacji między 5 i 20 oferuje dobrą równowagę między prędkością i niezawodnością. Przeczytaj nasz przewodnik na temat najlepsze proxy do skrobania stron internetowych w 2026 więcej porad architektonicznych.

Wskazówki dotyczące produkcji

Zarządzanie połączeniami

• Użyj ponownie instancji Axios i agentów zastępczych zamiast tworzenia nowych na żądanie. Unika to wyczerpania gniazda.
• Ustaw keepAlive: true na agenta HTTP dla trwałych połączeń.
• Zamknij przeglądarki Puppeteer / Playwright natychmiast po użyciu do wolnej pamięci.

Pamięć i czas

• W przypadku Marionetki należy stosować page.setRequestInterception(true) blokowanie obrazów, CSS i czcionek tylko wtedy, gdy potrzebujesz zawartości HTML. Zmniejsza to znacznie przepustowość pasma i wykorzystanie pamięci.
• Zawsze ustaw wyraźne timeout na każde życzenie. Brakujący czas jest główną przyczyną wieszania drapaczy.
• Monitor pamięci Node.js z process.memoryUsage() w długotrwale biegających drapaczach.

Prośba o intercepcję do szybszego skracania

const page = await browser.newPage();
await page.setRequestInterception(true);
page.on('request', (req) => {
  const blocked = ['image', 'stylesheet', 'font', 'media'];
  if (blocked.includes(req.resourceType())) {
    req.abort();
  } else {
    req.continue();
  }
});
await page.goto('https://example.com');

Zmienne środowiska

Nigdy nie koduj. Użyj .env plik i załadować go dotenv:

require('dotenv').config();
const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@gate.proxyhat.com:8080`;

Gotowa? Sprawdź nasze plany cenowe znaleźć odpowiednią ilość przepustowości proxy dla Twojego projektu.

Key Takeaways

• W ProxyHat Node SDK jest najszybszym sposobem na dodanie wsparcia proxy. Zainstaluj npm install proxyhat i rozpocząć pobieranie w trzech liniach kodu.
• Axios działa z proxy poprzez https-proxy-agent lub SDK 's built- in agent. Tworzenie wielokrotnego użytku instancji Axios dla efektywności.
• Marionetka akceptuje proxy jako argument startowy. Call page.authenticate() by przekazać referencje.
• Playwright ma natywne wsparcie proxy w jego inauguracji i opcji kontekstowych, w tym proxy kontekstowe dla wieloregionalnych scrating.
• Stosowanie lepkie sesje dla wielostopniowych przepływów pracy oraz obrotowe IP dla gromadzenia danych w skali dużej.
• Zawsze wdrażaj ponowna logika z wykładniczym backoff oraz Kontrola konkursowa w skrobaczach produkcyjnych.
• Zablokować niepotrzebne zasoby w przeglądarkach bez głowy, aby zmniejszyć przepustowość i poprawić prędkość.