Beim Web-Scraping müssen Sie oft Anti-Bot-Mechanismen umgehen, dynamische Inhalte mit Browser-Automatisierungstools wie Puppeteer laden, Proxy-Rotation verwenden, um IP-Sperren zu vermeiden, und CAPTCHAs lösen. Selbst mit diesen Strategien bleibt die Skalierung und Aufrechterhaltung stabiler Sitzungen eine Herausforderung.
In diesem Artikel erfahren Sie, wie Sie vom herkömmlichen Proxy-basierten Scraping auf Bright Data Scraping Browser umsteigen. Erfahren Sie, wie Sie die Proxy-Verwaltung und Skalierung automatisieren und so Entwicklungskosten und Wartungsaufwand reduzieren können. Beide Methoden werden verglichen, wobei Konfiguration, Leistung, Skalierbarkeit und Komplexität behandelt werden.
Hinweis: Die Beispiele in diesem Artikel dienen nur zu Lehrzwecken. Informieren Sie sich immer über die Nutzungsbedingungen der Ziel-Website und beachten Sie die einschlägigen Gesetze und Vorschriften, bevor Sie Daten auslesen.
Voraussetzungen
Bevor Sie mit dem Lernprogramm beginnen, sollten Sie sicherstellen, dass Sie die folgenden Voraussetzungen erfüllen:
- Node.js
- Visual Studio-Code
- Ein kostenloses Bright Data-Konto, damit Sie den Scraping-Browser verwenden können
Beginnen Sie mit der Erstellung eines neuen Node.js-Projektordners, in dem Sie Ihren Code speichern können.
Öffnen Sie dann Ihr Terminal oder Ihre Shell und erstellen Sie mit den folgenden Befehlen ein neues Verzeichnis:
mkdir scraping-tutorialrncd scraping-tutorial
Initialisieren Sie ein neues Node.js-Projekt:
npm init -y
Die Option -y beantwortet automatisch alle Fragen mit Ja und erstellt eine package.json-Datei mit Standardeinstellungen.
Proxy-basiertes Web-Scraping
Bei einem typischen proxy-basierten Ansatz verwenden Sie ein Browser-Automatisierungstool wie Puppeteer, um mit Ihrer Zieldomäne zu interagieren, dynamische Inhalte zu laden und Daten zu extrahieren. Dabei integrieren Sie Proxys, um IP-Sperren zu vermeiden und die Anonymität zu wahren.
Lassen Sie uns schnell ein Web-Scraping-Skript mit Puppeteer erstellen, das Daten von einer E-Commerce-Website mit Hilfe von Proxys ausliest.
Erstellen eines Web-Scraping-Skripts mit Puppeteer
Beginnen Sie mit der Installation von Puppeteer:
npm install puppeteer
Erstellen Sie dann eine Datei namens proxy-scraper.js (Sie können sie beliebig benennen) im Ordner scraping-tutorial und fügen Sie den folgenden Code hinzu:
const puppeteer = require("puppeteer");
(async () => {
// Launch a headless browser
const browser = await puppeteer.launch({
headless: true,
});
const page = await browser.newPage();
const baseUrl = "https://books.toscrape.com/catalogue/page-";
const books = [];
for (let i = 1; i {
let books = [];
document.querySelectorAll(".product_pod").forEach((item) => {
let title = item.querySelector("h3 a")?.getAttribute("title") || "";
let price = item.querySelector(".price_color")?.innerText || "";
books.push({ title, price });
});
return books;
});
books.push(...pageBooks); // Append books from this page to the main list
}
console.log(books); // Print the collected data
await browser.close();
})();
Dieses Skript verwendet Puppeteer, um Buchtitel und Preise von den ersten fünf Seiten der Books to Scrape-Website abzurufen. Es startet einen Headless-Browser, öffnet eine neue Seite und navigiert durch jede Katalogseite.
Für jede Seite verwendet das Skript DOM-Selektoren in page.evaluate(), um Buchtitel und Preise zu extrahieren und die Daten in einem Array zu speichern. Sobald alle Seiten verarbeitet sind, werden die Daten auf der Konsole ausgegeben und der Browser wird geschlossen. Dieser Ansatz extrahiert effizient Daten aus einer paginierten Website.
Testen und führen Sie den Code mit dem folgenden Befehl aus:
node proxy-scraper.jsIhre Ausgabe sollte wie folgt aussehen:
Navigating to: https://books.toscrape.com/catalogue/page-1.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-2.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-3.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-4.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-5.htmlrn[rn { title: 'A Light in the Attic', price: '£51.77' },rn { title: 'Tipping the Velvet', price: '£53.74' },rn { title: 'Soumission', price: '£50.10' },rn { title: 'Sharp Objects', price: '£47.82' },rn { title: 'Sapiens: A Brief History of Humankind', price: '£54.23' },rn { title: 'The Requiem Red', price: '£22.65' },rn…output omitted…rn {rn title: 'In the Country We Love: My Family Divided',rn price: '£22.00'rn }rn]
Proxys einrichten
Proxys werden häufig in Scraping-Konfigurationen eingesetzt, um die Anfragen aufzuteilen und sie unauffindbar zu machen. Ein gängiger Ansatz besteht darin, einen Pool von Proxys zu unterhalten und diese dynamisch zu wechseln.
Legen Sie Ihre Proxys in einem Array ab oder speichern Sie sie in einer separaten Datei, wenn Sie möchten:
const proxies = [
"proxy1.example.com:port",
"proxy2.example.com:port"
// Add more proxies here
];
Proxy-Rotationslogik verwenden
Erweitern wir den Code um eine Logik, die bei jedem Start des Browsers das Proxy-Array durchläuft. Aktualisieren Sie proxy-scraper.js und fügen Sie den folgenden Code ein:
const puppeteer = require("puppeteer");
const proxies = [
"proxy1.example.com:port",
"proxy2.example.com:port"
// Add more proxies here
];
(async () => {
// Choose a random proxy
const randomProxy =
proxies[Math.floor(Math.random() * proxies.length)];
// Launch Puppeteer with proxy
const browser = await puppeteer.launch({
headless: true,
args: [
`--proxy-server=http=${randomProxy}`,
"--no-sandbox",
"--disable-setuid-sandbox",
"--ignore-certificate-errors",
],
});
const page = await browser.newPage();
const baseUrl = "https://books.toscrape.com/catalogue/page-";
const books = [];
for (let i = 1; i {
let books = [];
document.querySelectorAll(".product_pod").forEach((item) => {
let title = item.querySelector("h3 a")?.getAttribute("title") || "";
let price = item.querySelector(".price_color")?.innerText || "";
books.push({ title, price });
});
return books;
});
books.push(...pageBooks); // Append books from this page to the main list
}
console.log(`Using proxy: ${randomProxy}`);
console.log(books); // Print the collected data
await browser.close();
})();
Hinweis: Anstatt die Rotation der Proxys manuell durchzuführen, können Sie eine Bibliothek wie luminati-proxy verwenden, um den Prozess zu automatisieren.
In diesem Code wird ein zufälliger Proxy aus der Proxy-Liste ausgewählt und mit der Option --proxy-server=${randomProxy} auf Puppeteer angewendet. Um eine Entdeckung zu vermeiden, wird auch ein zufälliger User-Agent-String zugewiesen. Die Scraping-Logik wird dann wiederholt, und der für das Scraping von Produktdaten verwendete Proxy wird aufgezeichnet.
Wenn Sie den Code erneut ausführen, sollten Sie eine Ausgabe wie zuvor sehen, jedoch mit einem Zusatz zum verwendeten Proxy:
Navigating to: https://books.toscrape.com/catalogue/page-1.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-2.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-3.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-4.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-5.htmlrnUsing proxy: 115.147.63.59:8081rn…output omitted…
Herausforderungen beim proxy-basierten Scraping
Obwohl ein proxy-basierter Ansatz für viele Anwendungsfälle geeignet ist, können Sie mit einigen der folgenden Herausforderungen konfrontiert werden:
- Häufige Blockierungen: Proxies können blockiert werden, wenn die Website eine strenge Anti-Bot-Erkennung hat.
- Leistungsmehraufwand: Rotierende Proxys und die Wiederholung von Anfragen verlangsamen Ihre Datenerfassungspipeline.
- Komplexe Skalierbarkeit: Die Verwaltung und Rotation eines großen Proxy-Pools für optimale Leistung und Verfügbarkeit ist komplex. Es erfordert einen Lastausgleich, die Vermeidung einer übermäßigen Nutzung von Proxys, Abkühlungsphasen und die Behandlung von Ausfällen in Echtzeit. Die Herausforderung wächst mit der Anzahl der gleichzeitigen Anfragen, da das System sich der Erkennung entziehen muss, während es gleichzeitig die auf der schwarzen Liste stehenden oder unzureichend funktionierenden IPs kontinuierlich überwacht und ersetzt.
- Browser-Wartung: Die Browser-Wartung kann sowohl technisch anspruchsvoll als auch ressourcenintensiv sein. Sie müssen den Fingerabdruck des Browsers (Cookies, Kopfzeilen und andere identifizierende Attribute) ständig aktualisieren und bearbeiten, um das reale Benutzerverhalten zu imitieren und fortschrittliche Anti-Bot-Kontrollen zu umgehen.
- Cloud-Browser-Overhead: Cloud-basierte Browser verursachen zusätzlichen betrieblichen Overhead durch erhöhten Ressourcenbedarf und komplexe Infrastrukturkontrolle, was zu erhöhten Betriebskosten führt. Die Skalierung von Browser-Instanzen für eine gleichbleibende Leistung erschwert den Prozess zusätzlich.
DynamicScraping mit dem Bright Data Scraping Browser
Um diese Herausforderungen zu meistern, können Sie eine einzige API-Lösung wie den Bright Data Scraping Browser verwenden. Sie vereinfacht Ihren Betrieb, macht die manuelle Proxy-Rotation und komplexe Browser-Einstellungen überflüssig und führt häufig zu einer höheren Erfolgsquote beim Abrufen von Daten.
Einrichten Ihres Bright Data-Kontos
Melden Sie sich bei Ihrem Bright Data-Konto an, navigieren Sie zu Proxies & Scraping, scrollen Sie zu Scraping-Browser, und klicken Sie auf Erste Schritte:
Behalten Sie die Standardkonfiguration bei und klicken Sie auf Hinzufügen, um eine neue Scraping-Browser-Instanz zu erstellen:
Nachdem Sie eine Scraping-Browser-Instanz erstellt haben, notieren Sie sich die Puppeteer-URL, da Sie diese bald benötigen werden:
Anpassen des Codes zur Verwendung des Bright Data Scraping Browser
Lassen Sie uns nun den Code so anpassen, dass Sie statt der rotierenden Proxys eine direkte Verbindung zum Bright Data Scraping Browser-Endpunkt herstellen.
Erstellen Sie eine neue Datei namens brightdata-scraper.js und fügen Sie den folgenden Code hinzu:
const puppeteer = require("puppeteer");
(async () => {
// Choose a random proxy
const SBR_WS_ENDPOINT = "YOUR_BRIGHT_DATA_WS_ENDPOINT"
// Launch Puppeteer with proxy
const browser = await puppeteer.connect({
browserWSEndpoint: SBR_WS_ENDPOINT,
});
const page = await browser.newPage();
const baseUrl = "https://books.toscrape.com/catalogue/page-";
const books = [];
for (let i = 1; i {
let books = [];
document.querySelectorAll(".product_pod").forEach((item) => {
let title = item.querySelector("h3 a")?.getAttribute("title") || "";
let price = item.querySelector(".price_color")?.innerText || "";
books.push({ title, price });
});
return books;
});
books.push(...pageBooks); // Append books from this page to the main list
}
console.log(books); // Print the collected data
await browser.close();
})();
Stellen Sie sicher, dass Sie YOUR_BRIGHT_DATA_WS_ENDPOINT durch die URL ersetzen, die Sie im vorherigen Schritt abgerufen haben.
Dieser Code ähnelt dem vorherigen Code, aber anstatt eine Liste von Proxys zu haben und zwischen verschiedenen Proxys zu jonglieren, stellen Sie eine direkte Verbindung mit dem Bright Data-Endpunkt her.
Führen Sie den folgenden Code aus:
node brightdata-scraper.js
Ihr Output sollte derselbe sein wie zuvor, aber jetzt müssen Sie Proxys nicht mehr manuell rotieren oder Benutzeragenten konfigurieren. Der Bright Data Scraping Browser kümmert sich um alles – von der Proxy-Rotation bis zur Umgehung von CAPTCHAs – und gewährleistet so ein unterbrechungsfreies Data Scraping.
Verwandeln Sie den Code in einen Express-Endpunkt
Wenn Sie den Bright Data Scraping Browser in eine größere Anwendung integrieren möchten, können Sie ihn als Express-Endpunkt bereitstellen.
Beginnen Sie mit der Installation von Express:
npm install express
Erstellen Sie eine Datei namens server.js und fügen Sie den folgenden Code hinzu:
const express = require("express");
const puppeteer = require("puppeteer");
const app = express();
const PORT = 3000;
// Needed to parse JSON bodies:
app.use(express.json());
// Your Bright Data Scraping Browser WebSocket endpoint
const SBR_WS_ENDPOINT =
"wss://brd-customer-hl_264b448a-zone-scraping_browser2:[email protected]:9222";
/**
POST /scraper
Body example:
{
"baseUrl": "https://books.toscrape.com/catalogue/page-"
}
*/
app.post("/scrape", async (req, res) => {
const { baseUrl } = req.body;
if (!baseUrl) {
return res.status(400).json({
success: false,
error: 'Missing "baseUrl" in request body.',
});
}
try {
// Connect to the existing Bright Data (Luminati) Scraping Browser
const browser = await puppeteer.connect({
browserWSEndpoint: SBR_WS_ENDPOINT,
});
const page = await browser.newPage();
const books = [];
// Example scraping 5 pages of the base URL
for (let i = 1; i {
const data = [];
document.querySelectorAll(".product_pod").forEach((item) => {
const title = item.querySelector("h3 a")?.getAttribute("title") || "";
const price = item.querySelector(".price_color")?.innerText || "";
data.push({ title, price });
});
return data;
});
books.push(...pageBooks);
}
// Close the browser connection
await browser.close();
// Return JSON with the scraped data
return res.json({
success: true,
books,
});
} catch (error) {
console.error("Scraping error:", error);
return res.status(500).json({
success: false,
error: error.message,
});
}
});
// Start the Express server
app.listen(PORT, () => {
console.log(`Server is listening on http://localhost:${PORT}`);
});
In diesem Code initialisieren Sie eine Express-Anwendung, akzeptieren JSON-Payloads und definieren eine POST /scrape-Route. Clients senden einen JSON-Body, der die baseUrl enthält, die dann an den Bright Data Scraping Browser-Endpunkt mit der Ziel-URL weitergeleitet wird.
Starten Sie Ihren neuen Express-Server:
node server.js
Um den Endpunkt zu testen, können Sie ein Tool wie Postman (oder einen anderen REST-Client Ihrer Wahl) verwenden, oder Sie können curl von Ihrem Terminal oder Ihrer Shell wie folgt verwenden:
curl -X POST http://localhost/scrape
n-H 'Content-Type: application/json'
n-d '{u0022baseUrlu0022: u0022https://books.toscrape.com/catalogue/page-u0022}'rn
Ihre Ausgabe sollte wie folgt aussehen:
{
"success": true,
"books": [
{
"title": "A Light in the Attic",
"price": "£51.77"
},
{
"title": "Tipping the Velvet",
"price": "£53.74"
},
{
"title": "Soumission",
"price": "£50.10"
},
{
"title": "Sharp Objects",
"price": "£47.82"
},
{
"title": "Sapiens: A Brief History of Humankind",
"price": "£54.23"
},
{
"title": "The Requiem Red",
"price": "£22.65"
},
{
"title": "The Dirty Little Secrets of Getting Your Dream Job",
"price": "£33.34"
},
{
"title": "The Coming Woman: A Novel Based on the Life of the Infamous Feminist, Victoria Woodhull",
"price": "£17.93"
},
... output omitted...
{
"title": "Judo: Seven Steps to Black Belt (an Introductory Guide for Beginners)",
"price": "£53.90"
},
{
"title": "Join",
"price": "£35.67"
},
{
"title": "In the Country We Love: My Family Divided",
"price": "£22.00"
}
]
}
Das folgende Diagramm zeigt den Unterschied zwischen der manuellen Einrichtung (rotierender Proxy) und dem Ansatz des Bright Data Scraping Browser:
Die Verwaltung manuell rotierender Proxys erfordert ständige Aufmerksamkeit und Abstimmung, was zu häufigen Blockaden und begrenzter Skalierbarkeit führt.
Der Bright Data Scraping Browser rationalisiert den Prozess, indem er die Verwaltung von Proxys oder Headern überflüssig macht und gleichzeitig durch eine optimierte Infrastruktur schnellere Antwortzeiten ermöglicht. Die integrierten Anti-Bot-Strategien erhöhen die Erfolgsquoten und machen es weniger wahrscheinlich, dass Sie blockiert oder markiert werden.
Der gesamte Code für dieses Tutorial ist in diesem GitHub-Repository verfügbar.
ROI berechnen
Der Wechsel von einer manuellen Proxy-basierten Scraping-Einrichtung zum Bright Data Scraping Browser kann die Entwicklungszeit und -kosten erheblich senken.
Traditionelle Einrichtung
Das tägliche Scraping von Nachrichten-Websites erfordert Folgendes:
- Anfängliche Entwicklung: ~50 Stunden ($5.000 USD bei $100 USD/Stunde)
- Laufende Wartung: ~10 Stunden/Monat ($1.000 USD) für Code-Updates, Infrastruktur, Skalierung und Proxy-Management
- Proxy/IP-Kosten: ~$250 USD/Monat (variiert je nach IP-Bedarf)
Geschätzte monatliche Gesamtkosten: ~$1.250 USD
Bright Data Scraping Browser Einrichtung
- Entwicklungszeit: 5-10 Stunden ($1.000 USD)
- Wartung: ~2-4 Stunden/Monat ($200 USD)
- Kein Proxy- oder Infrastrukturmanagement erforderlich
- Bright Data Servicekosten:
- Traffic-Nutzung: $8.40 USD/GB(z.B. 30GB/Monat = $252 USD)
Geschätzte monatliche Gesamtkosten: ~$450 USD
Durch die Automatisierung der Proxy-Verwaltung und die Skalierung des Bright Data Scraping Browsers werden sowohl die anfänglichen Entwicklungskosten als auch die laufenden Wartungskosten gesenkt, wodurch das Scraping großer Datenmengen effizienter und kostengünstiger wird.
Schlussfolgerung
Durch den Wechsel von einer herkömmlichen Proxy-basierten Web Scraping-Konfiguration zum Bright Data Scraping Browser entfällt die lästige Proxy-Rotation und die manuelle Anti-Bot-Behandlung.
Neben dem Abrufen von HTML bietet Bright Data auch zusätzliche Tools zur Optimierung der Datenextraktion:
- Web Scraper für eine saubere Datenextraktion
- Web Unlocker API zum Scrapen schwierigerer Websites
- Datensätze für den Zugriff auf vorab gesammelte, strukturierte Daten
Diese Lösungen können Ihren Scraping-Prozess vereinfachen, die Arbeitslast verringern und die Skalierbarkeit verbessern.
Keine Kreditkarte erforderlich
