Langsame Proxys: 7 Gründe für Geschwindigkeitsverluste und Methoden zur Beschleunigung

Die Geschwindigkeit der Proxy-Verbindung beeinflusst direkt die Effizienz des Parsings, der Automatisierung und aller Aufgaben, die mit Massenanfragen verbunden sind. Wenn ein Proxy langsam arbeitet, führt dies zu längeren Ausführungszeiten von Skripten, Timeouts und Datenverlust. In diesem Artikel analysieren wir die technischen Gründe für die niedrige Geschwindigkeit und zeigen konkrete Optimierungsmöglichkeiten mit Codebeispielen und Testergebnissen.

Geografische Entfernung des Servers

Die physische Entfernung zwischen Ihrem Server, dem Proxy und der Zielressource ist der Hauptfaktor für die Latenz. Jeder zusätzliche Knoten in der Kette fügt Millisekunden hinzu, die sich bei Massenanfragen summieren.

Ein typisches Anfrage-Schema über einen Proxy sieht so aus: Ihr Server → Proxy-Server → Zielseite → Proxy-Server → Ihr Server. Wenn Ihr Parser in Deutschland ist, der Proxy in den USA und die Zielseite in Japan, müssen die Daten zehntausende Kilometer zurücklegen.

Lösung: Wählen Sie Proxys, die geografisch nahe an der Zielressource liegen. Wenn Sie russische Seiten parsen, verwenden Sie Proxys mit russischen IPs. Für die Arbeit mit globalen Diensten (Google, Amazon) sind Proxys in den USA oder Westeuropa optimal, wo sich die Haupt-Rechenzentren befinden.

Bei residential Proxys achten Sie auf die Möglichkeit, eine bestimmte Stadt oder Region auszuwählen und nicht nur ein Land. Der Unterschied in der Latenz zwischen Proxys aus Moskau und Wladiwostok bei Anfragen an einen Moskauer Server kann 150-200 ms betragen.

Einfluss des Protokolls auf die Datenübertragungsgeschwindigkeit

Die Wahl des Proxy-Protokolls hat einen erheblichen Einfluss auf die Geschwindigkeit. Die Hauptoptionen sind: HTTP/HTTPS, SOCKS4, SOCKS5. Jede hat ihre eigenen Besonderheiten bei der Datenverarbeitung und den Overheads.

HTTP-Proxys sind optimal für Web-Scraping, da sie auf Anwendungsebene arbeiten und Daten cachen können. SOCKS5 ist universeller, fügt jedoch eine zusätzliche Verarbeitungsebene hinzu. Für einfaches HTML-Parsen kann der Geschwindigkeitsunterschied zwischen HTTP und SOCKS5 10-15% betragen.

Beispielkonfiguration in Python (requests):

import requests

# HTTP Proxy - schneller für Web-Anfragen
proxies_http = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

# SOCKS5 - universeller, aber langsamer
proxies_socks = {
    'http': 'socks5://user:pass@proxy.example.com:1080',
    'https': 'socks5://user:pass@proxy.example.com:1080'
}

# Für Web-Scraping verwenden Sie HTTP
response = requests.get('https://example.com', proxies=proxies_http, timeout=10)

Wenn Ihr Anbieter beide Optionen anbietet, testen Sie diese mit realen Aufgaben. Für Rechenzentrums-Proxys zeigt das HTTP-Protokoll normalerweise eine Geschwindigkeit, die 12-18% höher ist als die von SOCKS5 bei identischer Last.

Überlastung des Proxy-Servers und IP-Pools

Wenn ein Proxy-Server zu viele gleichzeitige Verbindungen bedient, sinkt die Geschwindigkeit aufgrund von Bandbreiten- und Rechenressourcenbeschränkungen. Dies ist besonders kritisch für gemeinsame Proxys, bei denen eine IP von Dutzenden von Kunden verwendet wird.

Ein typisches Bild der Überlastung: Zu Beginn des Skriptbetriebs ist die Geschwindigkeit normal (50-100 Anfragen pro Minute), dann sinkt sie plötzlich auf 10-15 Anfragen. Dies geschieht, wenn der Server das Limit der offenen Verbindungen oder der Bandbreite erreicht.

Lösungen:

• Verwenden Sie einen Proxy-Pool anstelle einer einzelnen IP. Die Rotation zwischen 10-20 Proxys verteilt die Last und verringert die Wahrscheinlichkeit einer Blockierung.
• Begrenzen Sie die Anzahl der gleichzeitigen Verbindungen über einen Proxy (nicht mehr als 5-10 parallele Streams empfohlen).
• Für stark belastete Aufgaben wählen Sie private Proxys, bei denen die Ressourcen nicht mit anderen Benutzern geteilt werden.
• Überwachen Sie die Geschwindigkeit in Echtzeit und schließen Sie langsame Proxys automatisch aus der Rotation aus.

Beispiel für die Implementierung eines Pools mit Geschwindigkeitsüberwachung:

import time
import requests
from collections import deque

class ProxyPool:
    def __init__(self, proxies, max_response_time=5.0):
        self.proxies = deque(proxies)
        self.max_response_time = max_response_time
        self.stats = {p: {'total': 0, 'slow': 0} for p in proxies}
    
    def get_proxy(self):
        """Nächsten Proxy aus dem Pool erhalten"""
        proxy = self.proxies[0]
        self.proxies.rotate(-1)  # Nach hinten verschieben
        return proxy
    
    def test_and_remove_slow(self, url='http://httpbin.org/ip'):
        """Langsame Proxys testen und entfernen"""
        for proxy in list(self.proxies):
            try:
                start = time.time()
                requests.get(url, proxies={'http': proxy}, timeout=10)
                response_time = time.time() - start
                
                self.stats[proxy]['total'] += 1
                if response_time > self.max_response_time:
                    self.stats[proxy]['slow'] += 1
                
                # Entfernen, wenn mehr als 50% der Anfragen langsam sind
                slow_ratio = self.stats[proxy]['slow'] / self.stats[proxy]['total']
                if slow_ratio > 0.5 and self.stats[proxy]['total'] > 10:
                    self.proxies.remove(proxy)
                    print(f"Langsame Proxy entfernt: {proxy}")
            except:
                self.proxies.remove(proxy)

# Verwendung
proxies = [
    'http://proxy1.example.com:8080',
    'http://proxy2.example.com:8080',
    'http://proxy3.example.com:8080'
]

pool = ProxyPool(proxies, max_response_time=3.0)
pool.test_and_remove_slow()

# Arbeiten mit dem Pool
for i in range(100):
    proxy = pool.get_proxy()
    # Anfrage über den Proxy ausführen

Verbindungseinstellungen und Timeouts

Falsch konfigurierte Verbindungseinstellungen sind eine häufige Ursache für die scheinbare Langsamkeit von Proxys. Zu große Timeouts lassen das Skript auf nicht erreichbare Proxys warten, während zu kleine zu Abbrüchen normaler Verbindungen führen.

Wichtige Parameter, die die Geschwindigkeit beeinflussen:

• Connection timeout — Wartezeit für die Herstellung einer Verbindung. Optimal: 5-10 Sekunden für residential Proxys, 3-5 für Datacenter-Proxys.
• Read timeout — Wartezeit auf eine Antwort nach der Herstellung einer Verbindung. Abhängig von der Aufgabe: 10-15 Sekunden für Parsing, 30+ für das Herunterladen großer Dateien.
• Keep-Alive — Wiederverwendung von TCP-Verbindungen. Spart bis zu 200-300 ms bei jeder nachfolgenden Anfrage an dieselbe Domain.
• Connection pooling — Pool offener Verbindungen. Kritisch für hohe Leistung bei Massenanfragen.

Optimierte Konfiguration für requests:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# Erstellen Sie eine Sitzung mit optimierten Einstellungen
session = requests.Session()

# Konfiguration der Wiederholungsversuche
retry_strategy = Retry(
    total=3,  # Maximal 3 Versuche
    backoff_factor=0.5,  # Verzögerung zwischen den Versuchen: 0.5, 1, 2 Sekunden
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "POST"]
)

# Adapter mit Verbindungspooling
adapter = HTTPAdapter(
    max_retries=retry_strategy,
    pool_connections=10,  # Pool für 10 Hosts
    pool_maxsize=20  # Maximal 20 Verbindungen
)

session.mount("http://", adapter)
session.mount("https://", adapter)

# Proxy-Einstellungen
session.proxies = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

# Anfrage mit optimalen Timeouts
# (connection_timeout, read_timeout)
response = session.get(
    'https://example.com',
    timeout=(5, 15),  # 5 Sekunden für Verbindung, 15 für Lesen
    headers={'Connection': 'keep-alive'}  # Wiederverwendung der Verbindung
)

Die Verwendung von Sitzungen mit Keep-Alive beim Parsen von 1000 Seiten einer Website beschleunigt die Arbeit um 30-40% im Vergleich zur Erstellung einer neuen Verbindung für jede Anfrage. Die Zeitersparnis bei der Herstellung von TCP-Verbindungen und dem SSL-Handschlag ist bei Massenoperationen entscheidend.

Verschlüsselung und SSL/TLS-Overhead

HTTPS-Verbindungen erfordern zusätzliche Rechenressourcen für die Verschlüsselung/Entschlüsselung von Daten und die Durchführung des SSL/TLS-Handschlags. Bei der Arbeit über Proxys geschieht dies zweimal: zwischen Ihnen und dem Proxy, zwischen dem Proxy und dem Zielserver.

Typische SSL/TLS-Overheads:

• Erster Handshake: 150-300 ms (abhängig vom Algorithmus und der Entfernung)
• Verschlüsselung/Entschlüsselung von Daten: +10-20% zur Übertragungszeit
• Zusätzliche CPU-Belastung des Proxy-Servers bei hohem Traffic

Optimierungsmöglichkeiten:

Bei der Arbeit mit mobilen Proxys, wo die Verbindung langsamer sein kann, werden die SSL-Overheads noch deutlicher. In Tests betrug der Unterschied zwischen HTTP- und HTTPS-Anfragen über 4G-Proxys durchschnittlich 280 ms.

DNS-Resolving und Caching

Jede Anfrage an eine neue Domain erfordert DNS-Resolving — die Umwandlung eines Domainnamens in eine IP-Adresse. Ohne Caching fügt dies 20-100 ms zu jeder Anfrage hinzu, und bei einem langsamen DNS-Server kann die Verzögerung 500+ ms erreichen.

Wenn Sie über einen Proxy arbeiten, können DNS-Anfragen an drei Orten ausgeführt werden:

• Auf Ihrer Seite (der Client löst die Domain auf und übergibt die IP des Proxys)
• Auf dem Proxy-Server (SOCKS5, HTTP CONNECT — der Proxy erhält die Domain und löst sie selbst auf)
• Auf dem Zielserver (selten, bei spezifischen Konfigurationen)

Bei SOCKS5-Proxys erfolgt das DNS-Resolving normalerweise auf der Seite des Proxy-Servers, was langsamer sein kann, wenn der Proxy-Anbieter schlechte DNS-Server hat. HTTP-Proxys lösen häufiger auf der Client-Seite auf.

Methoden zur Beschleunigung von DNS:

import socket
from functools import lru_cache

# Caching des DNS-Resolving auf der Client-Seite
@lru_cache(maxsize=256)
def cached_resolve(hostname):
    """Caching der DNS-Anfrageergebnisse"""
    try:
        return socket.gethostbyname(hostname)
    except socket.gaierror:
        return None

# Verwendung
hostname = 'example.com'
ip = cached_resolve(hostname)
if ip:
    # Verwenden Sie die IP direkt in Anfragen
    url = f'http://{ip}/path'
    headers = {'Host': hostname}  # Ursprünglichen Host im Header angeben

Ein alternativer Ansatz besteht darin, schnelle öffentliche DNS-Server auf Systemebene zu verwenden:

• Google DNS: 8.8.8.8, 8.8.4.4
• Cloudflare DNS: 1.1.1.1, 1.0.0.1
• Quad9: 9.9.9.9

In Linux erfolgt die Konfiguration über /etc/resolv.conf:

nameserver 1.1.1.1
nameserver 8.8.8.8
options timeout:2 attempts:2

Für Python-Skripte mit vielen Domains wird empfohlen, den DNS-Cache vorab zu erwärmen:

import concurrent.futures
import socket

def warmup_dns_cache(domains):
    """Vorab eine Liste von Domains auflösen"""
    def resolve(domain):
        try:
            socket.gethostbyname(domain)
        except:
            pass
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
        executor.map(resolve, domains)

# Liste der Domains zum Parsen
domains = ['site1.com', 'site2.com', 'site3.com']
warmup_dns_cache(domains)

# Jetzt ist DNS bereits im Cache, Anfragen werden schneller

Qualität der Infrastruktur des Anbieters

Die Geschwindigkeit von Proxys hängt direkt von der Qualität der Hardware und der Kommunikationskanäle des Anbieters ab. Günstige Proxys arbeiten oft auf überlasteten Servern mit langsamen Netzwerkschnittstellen und veralteter Hardware.

Kritische Infrastrukturparameter:

Anbieter mit eigener Infrastruktur (keine Wiederverkäufer) bieten in der Regel konstant hohe Geschwindigkeiten. Sie kontrollieren den gesamten Stack: von der Hardware bis zu den Einstellungen der Netzwerkausrüstung.

Anzeichen einer qualitativ hochwertigen Infrastruktur:

• Stabile Geschwindigkeit über den Tag hinweg (Abweichungen von nicht mehr als 15-20% vom Durchschnitt)
• Niedriger Jitter (Variabilität der Latenz) — weniger als 10 ms
• Minimale Paketverluste (<0.1%)
• Schnelle Reaktion des technischen Supports auf Probleme (wichtig für geschäftliche Aufgaben)
• Transparente Informationen über den Standort der Server und die Eigenschaften der Kanäle

Für kritische Aufgaben wird empfohlen, Proxys unter Bedingungen zu testen, die den realen Einsatz möglichst nahe kommen. Kaufen Sie einen Testzugang für 1-3 Tage und führen Sie echte Skripte mit der Überwachung aller Metriken aus.

Methodik zur Geschwindigkeitsprüfung von Proxys

Richtiges Testen hilft, Engpässe zu identifizieren und verschiedene Anbieter objektiv zu vergleichen. Ein einfacher Speedtest reicht nicht aus — es müssen Parameter gemessen werden, die für Ihre Aufgaben wichtig sind.

Schlüsselmetriken zur Messung:

• Latenz — Zeit, die ein Paket für die Hin- und Rückreise benötigt. Kritisch für Aufgaben mit vielen kleinen Anfragen.
• Durchsatz — Datenmenge pro Zeiteinheit. Wichtig für das Herunterladen von Dateien, Bildern.
• Verbindungszeit — Zeit zur Herstellung einer Verbindung. Zeigt die Effizienz für einmalige Anfragen.
• Erfolgsquote — Prozentsatz erfolgreicher Anfragen. Unter 95% — schlechtes Ergebnis.
• Jitter — Variabilität der Latenz. Hoher Jitter (>50 ms) weist auf Instabilität des Kanals hin.

Umfassendes Testskript:

import time
import requests
import statistics
from concurrent.futures import ThreadPoolExecutor, as_completed

def test_proxy_performance(proxy, test_url='https://httpbin.org/get', requests_count=50):
    """
    Umfassendes Testen von Proxys
    
    Args:
        proxy: URL des Proxys
        test_url: URL zum Testen
        requests_count: Anzahl der Testanfragen
    
    Returns:
        dict mit Metriken
    """
    results = {
        'latencies': [],
        'connection_times': [],
        'total_times': [],
        'successes': 0,
        'failures': 0,
        'errors': []
    }
    
    session = requests.Session()
    session.proxies = {'http': proxy, 'https': proxy}
    
    def single_request():
        try:
            start = time.time()
            response = session.get(
                test_url,
                timeout=(5, 15),
                headers={'Connection': 'keep-alive'}
            )
            total_time = time.time() - start
            
            if response.status_code == 200:
                results['successes'] += 1
                results['total_times'].append(total_time)
                # Näherungsweise Schätzung der Latenz
                results['latencies'].append(total_time / 2)
            else:
                results['failures'] += 1
        except Exception as e:
            results['failures'] += 1
            results['errors'].append(str(e))
    
    # Paralleles Ausführen von Anfragen
    with ThreadPoolExecutor(max_workers=10) as executor:
        futures = [executor.submit(single_request) for _ in range(requests_count)]
        for future in as_completed(futures):
            future.result()
    
    # Berechnung der Statistiken
    if results['total_times']:
        metrics = {
            'proxy': proxy,
            'total_requests': requests_count,
            'success_rate': (results['successes'] / requests_count) * 100,
            'avg_response_time': statistics.mean(results['total_times']),
            'median_response_time': statistics.median(results['total_times']),
            'min_response_time': min(results['total_times']),
            'max_response_time': max(results['total_times']),
            'stdev_response_time': statistics.stdev(results['total_times']) if len(results['total_times']) > 1 else 0,
            'jitter': statistics.stdev(results['latencies']) if len(results['latencies']) > 1 else 0,
            'failures': results['failures']
        }
        return metrics
    else:
        return {'proxy': proxy, 'error': 'Alle Anfragen sind fehlgeschlagen'}

# Testen
proxy = 'http://user:pass@proxy.example.com:8080'
metrics = test_proxy_performance(proxy, requests_count=100)

print(f"Proxy: {metrics['proxy']}")
print(f"Erfolgsquote: {metrics['success_rate']:.1f}%")
print(f"Durchschnittliche Antwortzeit: {metrics['avg_response_time']*1000:.0f} ms")
print(f"Median: {metrics['median_response_time']*1000:.0f} ms")
print(f"Jitter: {metrics['jitter']*1000:.0f} ms")
print(f"Standardabweichung: {metrics['stdev_response_time']*1000:.0f} ms")

Für genauere Ergebnisse testen Sie zu verschiedenen Tageszeiten (Morgen, Tag, Abend) und auf verschiedenen Zielwebseiten. Die Geschwindigkeit kann je nach Geografie und Netzwerklast erheblich variieren.

Umfassende Optimierung: Checkliste

Die Anwendung aller beschriebenen Methoden in Kombination ergibt einen kumulativen Effekt. Hier ist ein schrittweiser Plan zur Optimierung der Geschwindigkeit bei der Arbeit über Proxys:

Beispiel für eine optimierte Konfiguration für die Produktion:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
from collections import deque
import time

class OptimizedProxyPool:
    def __init__(self, proxies_list):
        self.proxies = deque(proxies_list)
        self.session = self._create_optimized_session()
        self.stats = {p: {'requests': 0, 'avg_time': 0} for p in proxies_list}
    
    def _create_optimized_session(self):
        """Erstellen Sie eine optimierte Sitzung"""
        session = requests.Session()
        
        # Retry-Strategie
        retry = Retry(
            total=3,
            backoff_factor=0.3,
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["GET", "POST", "PUT"]
        )
        
        # Adapter mit Connection Pooling
        adapter = HTTPAdapter(
            max_retries=retry,
            pool_connections=20,
            pool_maxsize=50,
            pool_block=False
        )
        
        session.mount("http://", adapter)
        session.mount("https://", adapter)
        
        # Keep-Alive-Header
        session.headers.update({
            'Connection': 'keep-alive',
            'Keep-Alive': 'timeout=60, max=100'
        })
        
        return session
    
    def get_best_proxy(self):
        """Proxy mit der besten Leistung erhalten"""
        # Sortierung nach durchschnittlicher Geschwindigkeit
        sorted_proxies = sorted(
            self.stats.items(),
            key=lambda x: x[1]['avg_time'] if x[1]['requests'] > 0 else float('inf')
        )
        return sorted_proxies[0][0] if sorted_proxies else self.proxies[0]
    
    def request(self, url, method='GET', **kwargs):
        """Anfrage über den optimalen Proxy ausführen"""
        proxy = self.get_best_proxy()
        self.session.proxies = {'http': proxy, 'https': proxy}
        
        start = time.time()
        try:
            response = self.session.request(
                method,
                url,
                timeout=(5, 15),  # Verbindung, Lesen
                **kwargs
            )
            
            # Statistiken aktualisieren
            elapsed = time.time() - start
            stats = self.stats[proxy]
            stats['avg_time'] = (
                (stats['avg_time'] * stats['requests'] + elapsed) / 
                (stats['requests'] + 1)
            )
            stats['requests'] += 1
            
            return response
        except Exception as e:
            # Bei einem Fehler den Proxy ans Ende der Warteschlange verschieben
            self.proxies.remove(proxy)
            self.proxies.append(proxy)
            raise e

# Verwendung
proxies = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080'
]

pool = OptimizedProxyPool(proxies)

# Ausführen von Anfragen
for url in ['https://example.com', 'https://example.org']:
    try:
        response = pool.request(url)
        print(f"Erfolgreich: {url}, Status: {response.status_code}")
    except Exception as e:
        print(f"Fehler: {url}, {e}")

Die Anwendung dieser Checkliste ermöglicht eine Steigerung der Geschwindigkeit bei der Arbeit über Proxys um das 2-3-fache im Vergleich zu den Basiseinstellungen. In realen Parsing-Projekten verkürzt dies die Ausführungszeit von Stunden auf Minuten.

Fazit

Langsame Proxy-Leistung ist ein lösbares Problem, wenn man die technischen Gründe versteht und die richtigen Optimierungsmethoden anwendet. Die Hauptfaktoren für die Geschwindigkeit sind geografische Nähe, die Wahl des Protokolls, die Qualität der Infrastruktur des Anbieters und die richtige Konfiguration des Client-Codes.

Ein umfassender Ansatz zur Optimierung umfasst die Auswahl geeigneter Proxys, die Anpassung der Verbindungseinstellungen und die Implementierung effektiver Testmethoden. Durch die Anwendung dieser Strategien können Sie die Leistung Ihrer Proxy-Anwendungen erheblich steigern.