Proxys für AI-Training: So sammeln Sie Millionen von Daten für Modelle ohne Sperren

Das Training von AI-Modellen erfordert riesige Datenmengen – Texte, Bilder, Videos, strukturierte Informationen von Websites. Das Problem ist, dass Websites bei massivem Parsing schnell IP-Adressen blockieren, da sie die Aktivität als Bot betrachten. In diesem Artikel werden wir erörtern, wie man die Datensammlung über Proxys richtig organisiert, welchen IP-Typ man für verschiedene Aufgaben wählen sollte und wie man die Infrastruktur für einen stabilen Betrieb einrichtet.

Warum Proxys für AI-Training benötigt werden

Moderne Sprachmodelle wie GPT, LLaMA oder Claude werden auf Milliarden von Texttoken trainiert. Modelle der Computer Vision benötigen Dutzende Millionen Bilder. Empfehlungssysteme analysieren das Verhalten von Nutzern auf Tausenden von Websites. All diese Daten müssen irgendwoher beschafft werden.

Das Hauptproblem ist, dass Websites aktiv gegen massives Parsing geschützt sind. Wenn Sie mehr als 100 Anfragen pro Minute von einer IP senden, werden Sie innerhalb von 5-10 Minuten blockiert. Gründe für die Blockierungen sind:

• Rate Limiting: Begrenzung der Anzahl von Anfragen von einer IP (normalerweise 10-60 Anfragen pro Minute)
• Anti-Bot-Systeme: Cloudflare, Akamai, PerimeterX analysieren das Verhalten und blockieren verdächtige Aktivitäten
• Geografische Einschränkungen: Ein Teil des Inhalts ist nur aus bestimmten Ländern verfügbar
• Schutz vor Wettbewerbern: Marktplätze und Aggregatoren blockieren das massenhafte Sammeln von Preisen und Produkten

Proxys lösen dieses Problem, indem sie Anfragen über Tausende von verschiedenen IP-Adressen verteilen. Anstatt 1000 Anfragen von einer IP zu senden, machen Sie 1-2 Anfragen von jeder der 500-1000 verschiedenen Adressen – das sieht aus wie die Aktivität normaler Nutzer.

Welchen Proxytyp man für die Datensammlung wählen sollte

Für AI-Training werden drei Arten von Proxys verwendet, jede mit ihren eigenen Vorteilen und Einschränkungen. Die Wahl hängt von der Datenquelle, dem Volumen und dem Budget des Projekts ab.

Datacenter-Proxys: Geschwindigkeit für große Volumen

Datacenter-Proxys sind IP-Adressen von Servern in Cloud-Anbietern (AWS, Google Cloud, Hetzner). Der Hauptvorteil ist die Geschwindigkeit und die niedrigen Kosten. Eine Datacenter-IP kann Hunderte von Anfragen pro Sekunde verarbeiten.

Sie eignen sich für das Sammeln von Daten von Quellen, die keinen aggressiven Schutz verwenden: öffentliche APIs (GitHub, Wikipedia, Stack Overflow), staatliche Datenbanken, Nachrichten-Websites ohne Cloudflare, wissenschaftliche Veröffentlichungen. Wenn die Website Daten ohne JavaScript-Rendering bereitstellt und den Browser-Fingerabdruck nicht überprüft, werden Datacenter-Proxys erfolgreich sein.

Nachteil: Viele Websites führen eine Blacklist für IPs von Datencentern. Instagram, Facebook, Google-Suche und große Marktplätze blockieren Datacenter-IP fast sofort. Für solche Quellen sind Residential-Proxys erforderlich.

Residential-Proxys: Umgehung jeglichen Schutzes

Residential-Proxys verwenden IP-Adressen von echten Heimnutzern. Für die Website sieht eine solche Anfrage aus wie ein normaler Besucher von zu Hause. Dies ermöglicht die Umgehung von Cloudflare, Akamai und das Sammeln von Daten aus sozialen Netzwerken und geschützten Plattformen.

Residential-Proxys sind erforderlich für: Instagram, Facebook, Twitter/X (Sammeln von Posts, Kommentaren, Profilen), Google-Suche (Parsing von Suchergebnissen für NLP-Modelle), Marktplätze (Amazon, eBay, Wildberries – Produkte, Bewertungen, Preise), Websites mit Geo-Einschränkungen (Inhalte sind nur aus bestimmten Ländern verfügbar).

Die Kosten sind höher – Bezahlung für den Traffic ($5-15 pro GB). Um Kosten zu sparen, verwenden Sie Residential-Proxys nur für kritische Quellen und parsen einfache Websites über Datacenter.

Mobile-Proxys: Für mobile Anwendungen

Mobile-Proxys verwenden IPs von Mobilfunkanbietern (4G/5G). Sie werden selten benötigt – hauptsächlich für das Sammeln von Daten aus mobilen Anwendungen (TikTok, Instagram-App, mobile Spiele) oder wenn die Website zwischen mobilem und Desktop-Traffic unterscheidet.

Der Vorteil mobiler IPs ist, dass Anbieter CGNAT verwenden (eine IP für Hunderte von Nutzern), daher ist es unwirtschaftlich, solche Adressen zu blockieren. Aber für die meisten Aufgaben des AI-Trainings sind Residential-Proxys ausreichend.

Arten von Datenquellen und Anforderungen an Proxys

Verschiedene Datentypen erfordern unterschiedliche Ansätze für Proxys. Lassen Sie uns beliebte Quellen für das Training von AI-Modellen betrachten.

Textdaten für NLP-Modelle

Für das Training von Sprachmodellen werden Texte von Nachrichten-Websites, Foren, Blogs, sozialen Netzwerken, Wikipedia und spezialisierten Ressourcen gesammelt. Die Volumina betragen Dutzende Terabyte Text.

Eine Besonderheit des Textparsing ist, dass die Struktur (Überschriften, Absätze, Metadaten) erhalten bleiben muss. Verwenden Sie Headless-Browser (Puppeteer, Playwright) für JavaScript-Websites oder einfache HTTP-Clients (requests, axios) für statische Seiten.

Bilder für Computer Vision

Das Training von Erkennungsmodellen erfordert Millionen von Bildern mit Markierungen. Quellen: Google Bilder, Pinterest, Instagram, spezialisierte Fotostocks, E-Commerce-Websites (Produktfotos).

Das Problem ist, dass Bilder viel Speicherplatz benötigen (durchschnittliche Größe 200-500 KB), sodass der Traffic schnell verbraucht wird. Bei der Verwendung von Residential-Proxys (Bezahlung pro GB) ist dies kritisch. Optimierungsstrategie: Zuerst sammeln Sie die URLs der Bilder über Residential, dann laden Sie die Dateien selbst über Datacenter oder direkt herunter (wenn das CDN den Referrer nicht überprüft).

Strukturierte Daten von E-Commerce

Daten zu Produkten, Preisen, Bewertungen werden für das Training von Empfehlungssystemen und Preisbildungsmodellen verwendet. Quellen: Amazon, eBay, Wildberries, Ozon, AliExpress.

Alle großen Marktplätze verwenden Cloudflare oder eigene Anti-Bot-Systeme. Residential-Proxys mit Rotation sind unbedingt erforderlich. Zusätzlich ist der richtige Browser-Fingerabdruck wichtig – verwenden Sie Tools wie puppeteer-extra-plugin-stealth zur Maskierung der Automatisierung.

Video- und Audiodaten

YouTube, TikTok, Podcast-Plattformen – Quellen für das Training von Sprach- und Videoerkennungsmodellen. Das Problem ist der enorme Traffic (ein Video = Hunderte MB). Für solche Aufgaben sind Residential-Proxys wirtschaftlich nicht rentabel.

Lösung: Verwenden Sie Residential nur für das Abrufen von Metadaten und Links zu Videos, und laden Sie die Downloads über Datacenter oder spezielle Tools wie yt-dlp (die in der Lage sind, YouTube-Beschränkungen ohne Proxys zu umgehen).

IP-Rotationsstrategien für unterschiedliche Volumen

Die Rotation von IPs ist ein entscheidender Punkt für stabiles Parsing. Eine falsche Konfiguration führt entweder zu Blockierungen oder zu Überzahlungen für den Traffic.

Rotation nach Anfrage (rotating proxies)

Jede Anfrage erfolgt über eine neue IP. Eignet sich für massives Parsing verschiedener Websites, wenn keine Sitzung gespeichert werden muss. Zum Beispiel das Sammeln von Texten von 10.000 verschiedenen Nachrichten-Websites – jede Website sieht nur 1-2 Anfragen von einer IP.

import requests

# Rotating proxy - jede Anfrage neue IP
proxies = {
    'http': 'http://username:password@rotating.proxycove.com:12345',
    'https': 'http://username:password@rotating.proxycove.com:12345'
}

urls = ['https://site1.com', 'https://site2.com', ...]
for url in urls:
    response = requests.get(url, proxies=proxies)
    # Jede Anfrage erfolgt mit einer neuen IP
    parse_data(response.text)

Vorteil – maximaler Schutz vor Blockierungen. Nachteil – es ist unmöglich, mit Websites zu arbeiten, die Authentifizierung oder das Speichern von Cookies erfordern.

Rotation nach Zeit (sticky sessions)

Die IP bleibt für 5-30 Minuten erhalten und wird dann geändert. Eignet sich für das Parsing einer Website mit Paginierung, wenn man durch die Seiten 1, 2, 3... mit Sitzungsbeibehaltung gehen muss.

import requests
import time

# Sticky session - IP bleibt 10 Minuten erhalten
session_id = generate_random_string()  # einzigartiger Sitzungs-ID
proxies = {
    'http': f'http://username-session-{session_id}:password@sticky.proxycove.com:12345'
}

# Alle Anfragen innerhalb von 10 Minuten erfolgen von einer IP
for page in range(1, 100):
    url = f'https://site.com/catalog?page={page}'
    response = requests.get(url, proxies=proxies)
    parse_page(response.text)
    time.sleep(2)  # Verzögerung zwischen den Anfragen

Passen Sie die Sitzungszeit je nach Rate-Limit der Website an. Wenn das Limit 60 Anfragen pro Minute beträgt, setzen Sie die Sitzung auf 1-2 Minuten und machen Sie nicht mehr als 50 Anfragen.

Pool statischer IPs

Sie erhalten eine Liste von 100-1000 IPs und verwalten selbst die Verteilung der Anfragen. Eignet sich für komplexe Szenarien, bei denen vollständige Kontrolle erforderlich ist: paralleles Parsing verschiedener Abschnitte einer Website, Lastenausgleich, benutzerdefinierte Rotationslogik.

import requests
from itertools import cycle

# Pool aus 500 statischen IPs
ip_pool = [
    'http://user:pass@ip1.proxycove.com:12345',
    'http://user:pass@ip2.proxycove.com:12345',
    # ... 500 Adressen
]

proxy_cycle = cycle(ip_pool)

for url in urls:
    proxy = next(proxy_cycle)  # nächste IP aus dem Pool nehmen
    response = requests.get(url, proxies={'http': proxy, 'https': proxy})
    parse_data(response.text)

Dieser Ansatz bietet maximale Flexibilität, erfordert jedoch mehr Code zur Fehlerbehandlung (wenn eine IP blockiert ist, muss sie aus dem Pool ausgeschlossen werden).

Umgehung von Anti-Bot-Systemen beim Parsing

Proxys lösen das Problem der IP-Blockierungen, aber moderne Websites analysieren Dutzende von Parametern zur Bestimmung von Bots. Selbst mit Residential-IP können Sie blockiert werden, wenn der Fingerabdruck des Browsers Automatisierung verrät.

Was Anti-Bot-Systeme überprüfen

• User-Agent: muss mit einem echten Browser (Chrome, Firefox) übereinstimmen, darf keine Wörter wie "headless" oder "bot" enthalten
• Headers: Die Header müssen typisch für einen Browser sein (Accept, Accept-Language, Accept-Encoding, Referer)
• TLS-Fingerabdruck: Die Parameter der SSL-Verbindung unterscheiden sich zwischen Browsern und Skripten
• JavaScript-Fingerabdruck: WebGL, Canvas, AudioContext, Schriftarten, Plugins, Bildschirmauflösung
• Verhalten: Mausbewegungen, Scrollgeschwindigkeit, Klicks (für Websites mit JavaScript-Rendering)

Werkzeuge zur Maskierung der Automatisierung

Verwenden Sie Headless-Browser mit Maskierungs-Plugins zur Umgehung fortschrittlicher Schutzmaßnahmen:

// Puppeteer mit Stealth-Plugin
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    headless: true,
    args: [
        '--proxy-server=http://username:password@residential.proxycove.com:12345',
        '--disable-blink-features=AutomationControlled'
    ]
});

const page = await browser.newPage();
// Setzen Sie eine realistische Ansicht
await page.setViewport({ width: 1920, height: 1080 });

// Fügen Sie zufällige Verzögerungen hinzu
await page.goto('https://protected-site.com');
await page.waitForTimeout(2000 + Math.random() * 3000);

const data = await page.evaluate(() => {
    return document.querySelector('.data').innerText;
});

await browser.close();

Für Python verwenden Sie Playwright mit ähnlichen Einstellungen oder Selenium mit undetected-chromedriver – einer Bibliothek, die ChromeDriver automatisch patcht, um die Erkennung zu umgehen.

Umgehung von Cloudflare und anderen WAF

Cloudflare verwendet ein JavaScript-Challenge zur Überprüfung des Browsers. Einfache HTTP-Clients (requests, axios) können dies nicht umgehen. Lösungen:

• Headless-Browser: Puppeteer/Playwright mit Stealth-Plugin umgehen die meisten Herausforderungen
• Fertige Lösungen: Bibliotheken wie cloudscraper (Python) oder puppeteer-extra-plugin-recaptcha
• Umgehungsdienste: Spezialisierte APIs (FlareSolverr, Anti-Captcha) lösen die Herausforderungen für Sie

Wichtig: Selbst mit dem richtigen Fingerabdruck machen Sie Pausen zwischen den Anfragen. Das Senden von 100 Anfragen pro Sekunde mit einem perfekten Browser-Fingerabdruck sieht immer noch verdächtig aus. Die optimale Geschwindigkeit liegt bei 10-30 Anfragen pro Minute von einer IP.

Architektur der Infrastruktur für die Datensammlung

Bei der Datensammlung für AI-Training in industriellem Maßstab ist eine durchdachte Architektur erforderlich. Ein einfaches Skript auf einem Server kann nicht mit dem Parsing von Terabytes an Daten umgehen.

Komponenten des Datensammlungssystems

Beispielarchitektur in Python

# worker.py - Parsing-Prozess
import redis
import requests
import json
from datetime import datetime

# Verbindung zu Redis (Aufgabenwarteschlange)
queue = redis.Redis(host='redis-server', port=6379)
# Proxy-Pool
proxies_pool = load_proxies_from_config()

while True:
    # Aufgabe aus der Warteschlange holen
    task = queue.blpop('parsing_queue', timeout=5)
    if not task:
        continue
    
    url = task[1].decode('utf-8')
    proxy = get_next_proxy(proxies_pool)
    
    try:
        response = requests.get(
            url, 
            proxies={'http': proxy, 'https': proxy},
            timeout=30,
            headers={'User-Agent': get_random_user_agent()}
        )
        
        # Daten parsen
        data = parse_html(response.text)
        
        # In S3 speichern
        save_to_s3(data, f'data/{datetime.now().isoformat()}/{hash(url)}.json')
        
        # Erfolg protokollieren
        log_success(url, proxy)
        
    except Exception as e:
        # Bei Fehler Aufgabe zurück in die Warteschlange
        queue.rpush('parsing_queue', url)
        log_error(url, proxy, str(e))
        mark_proxy_as_failed(proxy)

Eine solche Architektur ermöglicht horizontale Skalierung – fügen Sie einfach neue Server mit Workern hinzu. Wenn ein Worker ausfällt, arbeiten die anderen weiter.

Werkzeuge zur Automatisierung der Datensammlung

Für industrielles Parsing werden spezialisierte Frameworks verwendet, die typische Aufgaben sofort lösen.

Scrapy – Framework für Python

Scrapy ist das beliebteste Werkzeug für Web-Scraping in Python. Es unterstützt von Haus aus: paralleles Parsing (Hunderte Anfragen gleichzeitig), automatische Wiederholungen bei Fehlern, Middleware zur Rotation von Proxys und User-Agent, Export in JSON, CSV, XML, Datenbanken.

# settings.py - Scrapy-Konfiguration mit Proxys
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.proxycove.com:12345',
    'http://user:pass@proxy2.proxycove.com:12345',
    # ... Proxy-Liste
]

DOWNLOADER_MIDDLEWARES = {
    'rotating_proxies.middlewares.RotatingProxyMiddleware': 610,
    'rotating_proxies.middlewares.BanDetectionMiddleware': 620,
}

# Parallelität
CONCURRENT_REQUESTS = 100
DOWNLOAD_DELAY = 0.5  # Verzögerung zwischen Anfragen

Scrapy eignet sich für statische Websites (HTML ohne JavaScript). Für dynamische Websites verwenden Sie Scrapy + Splash (Headless-Browser) oder wechseln Sie zu Playwright.

Crawlee – Framework für Node.js

Crawlee (früher Apify SDK) ist das Äquivalent zu Scrapy für JavaScript. Vorteil – native Integration mit Puppeteer und Playwright, integrierte Proxy-Rotation, automatisches Management der Warteschlange, adaptive Parsing-Geschwindigkeit (verlangsamt sich bei Fehlern).

import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';

const proxyConfiguration = new ProxyConfiguration({
    proxyUrls: [
        'http://user:pass@proxy1.proxycove.com:12345',
        'http://user:pass@proxy2.proxycove.com:12345',
    ],
});

const crawler = new PlaywrightCrawler({
    proxyConfiguration,
    maxConcurrency: 50,
    requestHandler: async ({ page, request }) => {
        await page.waitForSelector('.data');
        const data = await page.$$eval('.item', items => 
            items.map(item => ({
                title: item.querySelector('h2').innerText,
                price: item.querySelector('.price').innerText
            }))
        );
        await saveData(data);
    },
});

await crawler.run(['https://site.com/catalog']);

Apache Nutch – für großangelegtes Crawling

Wenn Sie Daten aus dem gesamten Internet sammeln müssen (wie Suchmaschinen), verwenden Sie Apache Nutch. Es ist ein verteilter Crawler, der auf Hadoop basiert. Er kann Petabytes von Daten verarbeiten, entdeckt automatisch neue Seiten über Links und unterstützt Crawling-Richtlinien (robots.txt, sitemap.xml).

Nutch ist schwieriger einzurichten, aber unverzichtbar für das Sammeln von Common Crawl-ähnlichen Datensätzen. Verwenden Sie das Plugin proxy-rotator für die Arbeit mit Proxys.

Optimierung von Geschwindigkeit und Kosten

Das Sammeln von Daten für AI-Training ist kostspielig. Bei Volumina in Terabytes können die Ausgaben für Proxys Zehntausende von Dollar pro Monat erreichen. Lassen Sie uns erörtern, wie man die Kosten optimiert, ohne die Qualität zu beeinträchtigen.

Kombinieren Sie Proxytypen

Verwenden Sie Residential nicht für alle Aufgaben. Teilen Sie die Quellen in drei Kategorien auf:

• Ohne Schutz: Datacenter-Proxys ($0.5-2/IP) – öffentliche APIs, einfache Websites, staatliche Datenbanken
• Mittlerer Schutz: Residential rotating ($5-10/GB) – Nachrichten-Websites mit Cloudflare, Foren
• Hoher Schutz: Residential sticky sessions ($10-15/GB) – soziale Netzwerke, Marktplätze

Beispiel: Sie parsen 100 Nachrichten-Websites. 70 davon arbeiten ohne Cloudflare – verwenden Sie Datacenter. 30 mit Schutz – Residential. Die Einsparungen betragen 60-70% des Budgets für Proxys.

Caching von Anfragen

Wenn Sie eine Website mehrmals parsen (z.B. tägliches Sammeln von Nachrichten), cachen Sie unveränderliche Seiten. Verwenden Sie Redis oder lokalen Speicher für den HTML-Cache.

import hashlib
import redis

cache = redis.Redis(host='localhost', port=6379)

def fetch_with_cache(url, proxies):
    # Überprüfen Sie den Cache
    cache_key = hashlib.md5(url.encode()).hexdigest()
    cached = cache.get(cache_key)
    
    if cached:
        return cached.decode('utf-8')
    
    # Wenn nicht im Cache - Anfrage stellen
    response = requests.get(url, proxies=proxies)
    html = response.text
    
    # Im Cache für 24 Stunden speichern
    cache.setex(cache_key, 86400, html)
    return html

Traffic optimieren

Bei der Verwendung von Residential-Proxys (Bezahlung pro GB) ist es entscheidend, das Traffic-Volumen zu reduzieren:

• Deaktivieren Sie das Laden von Bildern, CSS, Schriftarten, wenn sie nicht benötigt werden (in Puppeteer: page.setRequestInterception)
• Verwenden Sie Kompression (gzip, brotli) – die meisten Proxys unterstützen dies
• Parsen Sie nur die benötigten Elemente – laden Sie nicht die gesamte Seite herunter, wenn nur ein Block benötigt wird
• Für APIs verwenden Sie JSON anstelle von HTML (5-10 Mal weniger Traffic)

Lastverteilung über die Zeit

Viele Websites haben tagsüber unterschiedliche Lasten. Parsen Sie in den Nachtstunden (nach der Zeit des Serverstandorts) – geringere Wahrscheinlichkeit, unter Rate Limiting zu fallen. Berücksichtigen Sie auch die Wochenenden – am Samstag und Sonntag kann der Schutz schwächer sein.

Überwachen Sie die Metriken

Überwachen Sie die Schlüsselkennzahlen zur Optimierung:

Fazit

Das Sammeln von Daten für das Training von AI-Modellen ist eine komplexe Aufgabe, die die richtige Wahl von Proxys, die Einrichtung von Rotationen, die Umgehung von Schutzmaßnahmen und die Optimierung der Kosten erfordert. Die Schlüsselpunkte sind:

• Für einfache Quellen (APIs, Websites ohne Schutz) verwenden Sie Datacenter-Proxys – sie sind schnell und günstig
• Für geschützte Plattformen (soziale Netzwerke, Marktplätze, Websites mit Cloudflare) sind Residential-Proxys erforderlich
• Richten Sie die Rotation je nach Aufgabe ein: nach Anfrage für massives Parsing verschiedener Websites, sticky sessions für die Arbeit mit einer einzigen Website
• Verwenden Sie Headless-Browser mit Maskierungs-Plugins zur Umgehung von Anti-Bot-Systemen
• Bauen Sie eine skalierbare Architektur mit Aufgabenwarteschlangen und parallelen Workern auf
• Optimieren Sie die Ausgaben: kombinieren Sie Proxytypen, cachen Sie Anfragen, reduzieren Sie den Traffic

Bei richtiger Konfiguration können Sie stabil und kosteneffizient Terabytes von Daten sammeln. Beginnen Sie mit einem kleinen Pilotprojekt mit 10-20 Quellen, optimieren Sie den Prozess und skalieren Sie dann auf industrielle Volumen.

Wenn Sie planen, Daten von geschützten Plattformen (soziale Netzwerke, E-Commerce, Websites mit Anti-Bot-Systemen) zu sammeln, empfehlen wir die Verwendung von Residential-Proxys – sie bieten ein hohes Maß an Vertrauen und einen minimalen Prozentsatz an Blockierungen. Für einfache Quellen und APIs sind Datacenter-Proxys ausreichend, die maximale Geschwindigkeit zu niedrigen Kosten bieten.