Yavaş Proxy: Hız Düşüşünün 7 Nedeni ve Hızlandırma Yöntemleri

Proxy bağlantısının hızı, veri çekme, otomasyon ve toplu isteklerle ilgili her türlü görevin etkinliğini doğrudan etkiler. Proxy yavaş çalıştığında, bu, betiklerin çalışma süresinin artmasına, zaman aşımına ve veri kaybına yol açar. Bu makalede, düşük hızın teknik nedenlerini inceleyecek ve kod örnekleri ve test sonuçları ile birlikte belirli optimizasyon yöntemlerini göstereceğiz.

Sunucunun Coğrafi Uzaklığı

Sunucunuz ile proxy ve hedef kaynak arasındaki fiziksel mesafe, gecikmenin (latency) ana faktörüdür. Zincirdeki her ek düğüm, toplu isteklerde biriken milisaniyeler ekler.

Proxy üzerinden yapılan tipik bir istek şeması şöyle görünür: sunucunuz → proxy sunucusu → hedef site → proxy sunucusu → sunucunuz. Eğer parser'ınız Almanya'da, proxy ABD'de ve hedef site Japonya'da ise, veriler on binlerce kilometre yol alır.

Çözüm: Hedef kaynağa coğrafi olarak yakın proxy'ler seçin. Eğer Rus sitelerini çekiyorsanız — Rus IP'li proxy kullanın. Küresel hizmetlerle (Google, Amazon) çalışırken, ana veri merkezlerinin bulunduğu ABD veya Batı Avrupa'daki proxy'ler en uygunudur.

Konut proxy'leri için belirli bir şehir veya bölge seçme imkânına dikkat edin, sadece ülke değil. Moskova ve Vladivostok'tan gelen proxy'ler için Moskova sunucusuna erişim sırasında ping farkı 150-200 ms'ye kadar çıkabilir.

Protokolün Veri İletim Hızına Etkisi

Proxy protokolü seçimi, hız üzerinde önemli bir etkiye sahiptir. Temel seçenekler: HTTP/HTTPS, SOCKS4, SOCKS5. Her birinin veri işleme ve giderleri ile ilgili kendine özgü özellikleri vardır.

HTTP proxy'leri, uygulama seviyesinde çalıştıkları ve verileri önbelleğe alabilecekleri için web scraping için en uygunudur. SOCKS5 daha evrenseldir, ancak ek bir işleme katmanı ekler. Basit HTML parsing için HTTP ile SOCKS5 arasındaki hız farkı %10-15 olabilir.

Python'da yapılandırma örneği (requests):

import requests

# HTTP proxy - web istekleri için daha hızlı
proxies_http = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

# SOCKS5 - daha evrensel, ama daha yavaş
proxies_socks = {
    'http': 'socks5://user:pass@proxy.example.com:1080',
    'https': 'socks5://user:pass@proxy.example.com:1080'
}

# Web scraping için HTTP kullanın
response = requests.get('https://example.com', proxies=proxies_http, timeout=10)

Sağlayıcınız her iki seçeneği de sunuyorsa, bunları gerçek görevlerde test edin. Veri merkezi proxy'leri için HTTP protokolü genellikle aynı yük altında SOCKS5'ten %12-18 daha hızlıdır.

Proxy Sunucusunun Aşırı Yüklenmesi ve IP Havuzları

Bir proxy sunucusu çok fazla eşzamanlı bağlantıyı hizmet ettiğinde, hız, kanalın bant genişliği ve hesaplama kaynakları sınırlamaları nedeniyle düşer. Bu, bir IP'nin onlarca müşteri tarafından kullanıldığı paylaşımlı (shared) proxy'ler için özellikle kritiktir.

Aşırı yüklenmenin tipik bir görüntüsü: betiğin başında hız normaldir (dakikada 50-100 istek), ardından aniden 10-15 isteğe düşer. Bu, sunucunun açık bağlantı veya bant genişliği limitine ulaştığında olur.

Çözümler:

• Tek bir IP yerine proxy havuzu kullanın. 10-20 proxy arasında döngü yapmak, yükü dağıtır ve engellenme olasılığını azaltır.
• Bir proxy üzerinden eşzamanlı bağlantı sayısını sınırlayın (önerilen maksimum 5-10 paralel akıştır).
• Yüksek yüklenmeli görevler için, diğer kullanıcılarla kaynakları paylaşmayan özel (dedicated) proxy'ler seçin.
• Gerçek zamanlı hız izleme yapın ve yavaş proxy'leri otomatik olarak döngüden çıkarın.

Hız izleme ile havuzun uygulanması örneği:

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):
        """Havuzdan bir sonraki proxy'yi al"""
        proxy = self.proxies[0]
        self.proxies.rotate(-1)  # Sona taşı
        return proxy
    
    def test_and_remove_slow(self, url='http://httpbin.org/ip'):
        """Yavaş proxy'leri test et ve kaldır"""
        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
                
                # %50'den fazla istek yavaşsa kaldır
                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"Yavaş proxy kaldırıldı: {proxy}")
            except:
                self.proxies.remove(proxy)

# Kullanım
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()

# Havuz ile çalışma
for i in range(100):
    proxy = pool.get_proxy()
    # Proxy üzerinden istek yap

Bağlantı Ayarları ve Zaman Aşımı

Yanlış ayarlanmış bağlantı parametreleri, proxy'nin yavaş görünmesinin yaygın bir nedenidir. Çok büyük zaman aşımı değerleri, betiğin erişilemeyen proxy'leri beklemesine neden olurken, çok küçük olanlar normal bağlantıların kopmasına yol açar.

Hız üzerinde etkili olan anahtar parametreler:

• Bağlantı zaman aşımı — bağlantının kurulması için bekleme süresi. Optimum: konut proxy'leri için 5-10 saniye, veri merkezi proxy'leri için 3-5 saniye.
• Okuma zaman aşımı — bağlantı kurulduktan sonra yanıt bekleme süresi. Göreve bağlı: parsing için 10-15 saniye, büyük dosyaların indirilmesi için 30+ saniye.
• Keep-Alive — TCP bağlantılarının yeniden kullanımı. Aynı alan adına yapılan her sonraki istekte 200-300 ms kadar tasarruf sağlar.
• Bağlantı havuzu — açık bağlantı havuzu. Toplu isteklerde yüksek performans için kritik öneme sahiptir.

Requests için optimize edilmiş yapılandırma:

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

# Optimize edilmiş ayarlarla bir oturum oluştur
session = requests.Session()

# Yeniden deneme ayarları
retry_strategy = Retry(
    total=3,  # Maksimum 3 deneme
    backoff_factor=0.5,  # Denemeler arasındaki gecikme: 0.5, 1, 2 saniye
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "POST"]
)

# Bağlantı havuzu ile adaptör
adapter = HTTPAdapter(
    max_retries=retry_strategy,
    pool_connections=10,  # 10 host için havuz
    pool_maxsize=20  # Maksimum 20 bağlantı
)

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

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

# Optimum zaman aşımı ile istek
# (connection_timeout, read_timeout)
response = session.get(
    'https://example.com',
    timeout=(5, 15),  # 5 saniye bağlantı, 15 saniye okuma
    headers={'Connection': 'keep-alive'}  # Bağlantının yeniden kullanımı
)

1000 sayfanın bir web sitesinden çekilmesi sırasında Keep-Alive ile oturum kullanmak, her istek için yeni bir bağlantı kurmaktan %30-40 daha hızlıdır. TCP bağlantısının kurulması ve SSL el sıkışması sırasında zaman tasarrufu, toplu işlemlerde kritik öneme sahiptir.

Şifreleme ve SSL/TLS Giderleri

HTTPS bağlantıları, verilerin şifrelenmesi/şifresinin çözülmesi ve SSL/TLS el sıkışmasının gerçekleştirilmesi için ek hesaplama kaynakları gerektirir. Proxy üzerinden çalışırken, bu iki kez gerçekleşir: sizinle proxy arasında, proxy ile hedef sunucu arasında.

Tipik SSL/TLS giderleri:

• İlk el sıkışma: 150-300 ms (algoritmaya ve mesafeye bağlı)
• Verilerin şifrelenmesi/şifresinin çözülmesi: iletim süresine +%10-20
• Yüksek trafik sırasında proxy sunucusundaki CPU üzerindeki ek yük

Optimizasyon Yöntemleri:

Mobil proxy'ler ile çalışırken, iletişim kanalı daha yavaş olabileceğinden, SSL giderleri daha belirgin hale gelir. Testlerde, 4G proxy'leri üzerinden HTTP ve HTTPS istekleri arasındaki fark ortalama 280 ms olmuştur.

DNS Çözümleme ve Önbellekleme

Yeni bir domaine her istek, alan adının IP adresine dönüştürülmesi için DNS çözümlemesi gerektirir. Önbellekleme olmadan, bu her isteğe 20-100 ms ekler ve yavaş bir DNS sunucusu ile gecikme 500+ ms'ye kadar çıkabilir.

Proxy üzerinden çalıştığınızda, DNS istekleri üç yerde gerçekleştirilebilir:

• Sizin tarafınızda (istemci domaini çözümler ve proxy'nin IP'sini iletir)
• Proxy sunucusunda (SOCKS5, HTTP CONNECT — proxy domaini alır ve kendisi çözümler)
• Hedef sunucuda (nadiren, özel yapılandırmalarda)

SOCKS5 proxy'leri için DNS çözümlemesi genellikle proxy sunucusunda gerçekleşir, bu da sağlayıcının kötü DNS sunucuları varsa daha yavaş olabilir. HTTP proxy'leri daha sık istemci tarafında çözümleme yapar.

DNS'yi Hızlandırma Yöntemleri:

import socket
from functools import lru_cache

# İstemci tarafında DNS çözümlemesini önbelleğe alma
@lru_cache(maxsize=256)
def cached_resolve(hostname):
    """DNS isteklerinin sonuçlarını önbelleğe al"""
    try:
        return socket.gethostbyname(hostname)
    except socket.gaierror:
        return None

# Kullanım
hostname = 'example.com'
ip = cached_resolve(hostname)
if ip:
    # İsteklerde IP'yi doğrudan kullan
    url = f'http://{ip}/path'
    headers = {'Host': hostname}  # Başlıkta orijinal hostu belirt

Alternatif bir yaklaşım, sistem düzeyinde hızlı kamuya açık DNS sunucularını kullanmaktır:

• 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

Linux'te ayar, /etc/resolv.conf üzerinden yapılır:

nameserver 1.1.1.1
nameserver 8.8.8.8
options timeout:2 attempts:2

Birçok domain ile çalışan Python betikleri için DNS önbelleğini önceden ısıtmak önerilir:

import concurrent.futures
import socket

def warmup_dns_cache(domains):
    """Domain listesini önceden çözümle"""
    def resolve(domain):
        try:
            socket.gethostbyname(domain)
        except:
            pass
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
        executor.map(resolve, domains)

# Çekilecek domain listesi
domains = ['site1.com', 'site2.com', 'site3.com']
warmup_dns_cache(domains)

# Artık DNS önbellekte, istekler daha hızlı olacaktır

Sağlayıcının Altyapı Kalitesi

Proxy'nin hızı, sağlayıcının ekipmanının ve iletişim kanallarının kalitesine doğrudan bağlıdır. Ucuz proxy'ler genellikle yavaş ağ arayüzleri ve eski donanımlarla aşırı yüklenmiş sunucularda çalışır.

Altyapının kritik parametreleri:

Kendi altyapısına sahip sağlayıcılar (satıcılar değil) genellikle sürekli yüksek hız sağlar. Donanımdan ağ ekipmanlarının ayarlarına kadar tüm yığını kontrol ederler.

Kaliteli altyapının belirtileri:

• Gün boyunca istikrarlı hız (ortalama ile %15-20 sapma)
• Düşük jitter (gecikme varyasyonu) — 10 ms'den az
• Minimum paket kaybı (<0.1%)
• Problemlere hızlı teknik destek yanıtı (iş görevleri için önemli)
• Sunucuların konumu ve kanal özellikleri hakkında şeffaf bilgi

Kritik görevler için, proxy'leri gerçek savaş koşullarına en yakın koşullarda test etmeniz önerilir. 1-3 gün süreyle test erişimi satın alın ve tüm metrikleri izleyerek gerçek betikleri çalıştırın.

Proxy Hız Testi Yöntemi

Doğru test, darboğazları belirlemeye ve farklı sağlayıcıları nesnel bir şekilde karşılaştırmaya yardımcı olur. Basit bir hız testi yeterli değildir — görevleriniz için önemli olan parametreleri ölçmeniz gerekir.

Ölçüm için anahtar metrikler:

• Gecikme (latency) — paketin gidiş-dönüş süresi. Çok sayıda küçük istek içeren görevler için kritik öneme sahiptir.
• Bant Genişliği (throughput) — birim zamanda iletilen veri miktarı. Dosya, resim yüklemeleri için önemlidir.
• Bağlantı süresi — bağlantının kurulma süresi. Tek seferlik istekler için etkinliği gösterir.
• Başarı oranı — başarılı isteklerin yüzdesi. %95'in altında — kötü bir gösterge.
• Jitter — gecikme varyasyonu. Yüksek jitter (>50 ms) kanalın istikrarsız olduğunu gösterir.

Kapsamlı test için betik:

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):
    """
    Proxy'nin kapsamlı test edilmesi
    
    Args:
        proxy: Proxy URL'si
        test_url: Test için URL
        requests_count: Test isteklerinin sayısı
    
    Returns:
        Metrikleri içeren dict
    """
    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)
                # Gecikmeyi yaklaşık olarak tahmin et
                results['latencies'].append(total_time / 2)
            else:
                results['failures'] += 1
        except Exception as e:
            results['failures'] += 1
            results['errors'].append(str(e))
    
    # Paralel isteklerin gerçekleştirilmesi
    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()
    
    # İstatistiklerin hesaplanması
    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': 'Tüm istekler başarısız oldu'}

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

print(f"Proxy: {metrics['proxy']}")
print(f"Başarı oranı: {metrics['success_rate']:.1f}%")
print(f"Ortalama yanıt süresi: {metrics['avg_response_time']*1000:.0f} ms")
print(f"Medyan: {metrics['median_response_time']*1000:.0f} ms")
print(f"Jitter: {metrics['jitter']*1000:.0f} ms")
print(f"Standart sapma: {metrics['stdev_response_time']*1000:.0f} ms")

Daha doğru sonuçlar için, farklı zaman dilimlerinde (sabah, öğle, akşam) ve farklı hedef sitelerde test edin. Hız, coğrafyaya ve ağ yüküne bağlı olarak önemli ölçüde değişebilir.

Kapsamlı Optimizasyon: Kontrol Listesi

Tüm bu yöntemlerin bir arada uygulanması, kümülatif bir etki yaratır. İşte proxy üzerinden çalışma hızını optimize etmek için adım adım bir plan:

Üretim için optimize edilmiş yapılandırma örneği:

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):
        """Optimize edilmiş bir oturum oluştur"""
        session = requests.Session()
        
        # Yeniden deneme stratejisi
        retry = Retry(
            total=3,
            backoff_factor=0.3,
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["GET", "POST", "PUT"]
        )
        
        # Bağlantı havuzu ile adaptör
        adapter = HTTPAdapter(
            max_retries=retry,
            pool_connections=20,
            pool_maxsize=50,
            pool_block=False
        )
        
        session.mount("http://", adapter)
        session.mount("https://", adapter)
        
        # Keep-Alive başlıkları
        session.headers.update({
            'Connection': 'keep-alive',
            'Keep-Alive': 'timeout=60, max=100'
        })
        
        return session
    
    def get_best_proxy(self):
        """En iyi performansa sahip proxy'yi al"""
        # Ortalama hıza göre sıralama
        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):
        """Optimize edilmiş proxy üzerinden istek yap"""
        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),  # bağlantı, okuma
                **kwargs
            )
            
            # İstatistikleri güncelle
            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:
            # Hata durumunda proxy'yi kuyruğun sonuna taşı
            self.proxies.remove(proxy)
            self.proxies.append(proxy)
            raise e

# Kullanım
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)

# İsteklerin gerçekleştirilmesi
for url in ['https://example.com', 'https://example.org']:
    try:
        response = pool.request(url)
        print(f"Başarılı: {url}, durum: {response.status_code}")
    except Exception as e:
        print(f"Hata: {url}, {e}")

Bu kontrol listesinin uygulanması, proxy üzerinden çalışma hızını temel ayarlarla karşılaştırıldığında 2-3 kat artırır. Gerçek veri çekme projelerinde, bu görevlerin tamamlanma süresini saatlerden dakikalara kısaltır.

Sonuç

Proxy'nin yavaş çalışması, teknik nedenleri anladığınızda ve doğru optimizasyon yöntemlerini uyguladığınızda çözülebilir bir sorundur. Hız üzerindeki temel faktörler: coğrafi yakınlık, protokol seçimi, sağlayıcının altyapı kalitesi ve istemci kodunun doğru ayarlanmasıdır.

Optimizasyona yönelik kapsamlı bir yaklaşım, proxy'nin hızını önemli ölçüde artırabilir ve veri çekme süreçlerinizi daha verimli hale getirebilir.