Proxy Lambat: 7 Alasan Penurunan Kecepatan dan Metode Percepatan

Kecepatan koneksi proxy secara langsung mempengaruhi efektivitas pengambilan data, otomatisasi, dan tugas-tugas yang terkait dengan permintaan massal. Ketika proxy berfungsi lambat, ini mengakibatkan peningkatan waktu eksekusi skrip, timeout, dan kehilangan data. Dalam artikel ini, kita akan membahas alasan teknis kecepatan rendah dan menunjukkan cara-cara konkret untuk mengoptimalkan dengan contoh kode dan hasil pengujian.

Jarak Geografis Server

Jarak fisik antara server Anda, proxy, dan sumber daya target adalah faktor utama dalam latensi. Setiap node tambahan dalam rantai menambah milidetik yang terakumulasi saat melakukan permintaan massal.

Skema permintaan tipikal melalui proxy terlihat seperti ini: server Anda → server proxy → situs target → server proxy → server Anda. Jika parser Anda berada di Jerman, proxy di AS, dan situs target di Jepang, data harus melewati puluhan ribu kilometer.

Solusi: Pilih proxy yang secara geografis dekat dengan sumber daya target. Jika Anda mengumpulkan data dari situs Rusia — gunakan proxy dengan IP Rusia. Untuk bekerja dengan layanan global (Google, Amazon), proxy di AS atau Eropa Barat adalah yang paling optimal, di mana pusat data utama berada.

Untuk proxy residensial, perhatikan kemungkinan memilih kota atau wilayah tertentu, bukan hanya negara. Perbedaan ping antara proxy dari Moskow dan Vladivostok saat mengakses server Moskow dapat mencapai 150-200 ms.

Pengaruh Protokol terhadap Kecepatan Transfer Data

Pemilihan protokol proxy secara signifikan mempengaruhi kecepatan. Opsi utama: HTTP/HTTPS, SOCKS4, SOCKS5. Masing-masing memiliki karakteristik pengolahan data dan biaya yang berbeda.

Proxy HTTP adalah yang paling optimal untuk web scraping, karena bekerja pada tingkat aplikasi dan dapat menyimpan data dalam cache. SOCKS5 lebih universal, tetapi menambah lapisan pemrosesan tambahan. Untuk pengambilan data HTML yang sederhana, perbedaan kecepatan antara HTTP dan SOCKS5 dapat mencapai 10-15%.

Contoh Konfigurasi dalam Python (requests):

import requests

# Proxy HTTP - lebih cepat untuk permintaan web
proxies_http = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

# SOCKS5 - lebih universal, tetapi lebih lambat
proxies_socks = {
    'http': 'socks5://user:pass@proxy.example.com:1080',
    'https': 'socks5://user:pass@proxy.example.com:1080'
}

# Untuk web scraping gunakan HTTP
response = requests.get('https://example.com', proxies=proxies_http, timeout=10)

Jika penyedia Anda menawarkan kedua opsi, uji keduanya pada tugas nyata. Untuk bekerja dengan proxy data center, protokol HTTP biasanya menunjukkan kecepatan 12-18% lebih tinggi dibandingkan SOCKS5 dengan beban yang sama.

Kelebihan Beban pada Server Proxy dan Pool IP

Ketika satu server proxy melayani terlalu banyak koneksi simultan, kecepatan menurun karena batasan bandwidth dan sumber daya komputasi. Ini sangat kritis untuk proxy bersama (shared), di mana satu IP digunakan oleh puluhan klien.

Gambaran tipikal kelebihan beban: di awal eksekusi skrip, kecepatan normal (50-100 permintaan per menit), kemudian tiba-tiba turun menjadi 10-15 permintaan. Ini terjadi ketika server mencapai batas koneksi terbuka atau bandwidth.

Solusi:

• Gunakan pool proxy daripada satu IP. Rotasi antara 10-20 proxy membagi beban dan mengurangi kemungkinan pemblokiran.
• Batasi jumlah koneksi simultan melalui satu proxy (disarankan tidak lebih dari 5-10 aliran paralel).
• Untuk tugas dengan beban tinggi, pilih proxy pribadi (dedicated), di mana sumber daya tidak dibagi dengan pengguna lain.
• Pantau kecepatan secara real-time dan secara otomatis kecualikan proxy lambat dari rotasi.

Contoh Implementasi Pool dengan Pemantauan Kecepatan:

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):
        """Ambil proxy berikutnya dari pool"""
        proxy = self.proxies[0]
        self.proxies.rotate(-1)  # Pindahkan ke belakang
        return proxy
    
    def test_and_remove_slow(self, url='http://httpbin.org/ip'):
        """Uji dan hapus proxy lambat"""
        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
                
                # Hapus jika lebih dari 50% permintaan lambat
                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"Proxy lambat dihapus: {proxy}")
            except:
                self.proxies.remove(proxy)

# Penggunaan
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()

# Bekerja dengan pool
for i in range(100):
    proxy = pool.get_proxy()
    # Lakukan permintaan melalui proxy

Pengaturan Koneksi dan Timeout

Parameter koneksi yang tidak diatur dengan benar adalah penyebab umum dari lambatnya proxy yang tampak. Timeout yang terlalu besar membuat skrip menunggu proxy yang tidak tersedia, sementara yang terlalu kecil mengakibatkan terputusnya koneksi normal.

Parameter kunci yang mempengaruhi kecepatan:

• Connection timeout — waktu tunggu untuk membuat koneksi. Optimal: 5-10 detik untuk proxy residensial, 3-5 untuk proxy data center.
• Read timeout — waktu tunggu untuk respons setelah koneksi dibuat. Tergantung pada tugas: 10-15 detik untuk pengambilan data, 30+ untuk mengunduh file besar.
• Keep-Alive — penggunaan kembali koneksi TCP. Menghemat hingga 200-300 ms pada setiap permintaan berikutnya ke domain yang sama.
• Connection pooling — pool koneksi terbuka. Kritis untuk kinerja tinggi saat melakukan permintaan massal.

Konfigurasi yang Dioptimalkan untuk requests:

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

# Membuat sesi dengan pengaturan yang dioptimalkan
session = requests.Session()

# Pengaturan retry
retry_strategy = Retry(
    total=3,  # Maksimum 3 percobaan
    backoff_factor=0.5,  # Penundaan antara percobaan: 0.5, 1, 2 detik
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "POST"]
)

# Adapter dengan pool koneksi
adapter = HTTPAdapter(
    max_retries=retry_strategy,
    pool_connections=10,  # Pool untuk 10 host
    pool_maxsize=20  # Maksimum 20 koneksi
)

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

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

# Permintaan dengan timeout optimal
# (connection_timeout, read_timeout)
response = session.get(
    'https://example.com',
    timeout=(5, 15),  # 5 detik untuk koneksi, 15 untuk membaca
    headers={'Connection': 'keep-alive'}  # Penggunaan kembali koneksi
)

Menggunakan sesi dengan Keep-Alive saat mengumpulkan 1000 halaman dari satu situs mempercepat pekerjaan hingga 30-40% dibandingkan dengan membuat koneksi baru untuk setiap permintaan. Penghematan waktu dalam membuat koneksi TCP dan SSL handshake sangat penting dalam operasi massal.

Biaya Enkripsi dan SSL/TLS

Koneksi HTTPS memerlukan sumber daya komputasi tambahan untuk enkripsi/dekripsi data dan pelaksanaan SSL/TLS handshake. Saat bekerja melalui proxy, ini terjadi dua kali: antara Anda dan proxy, antara proxy dan server target.

Biaya tipikal SSL/TLS:

• Handshake awal: 150-300 ms (tergantung pada algoritma dan jarak)
• Enkripsi/dekripsi data: +10-20% pada waktu transfer
• Beban tambahan pada CPU server proxy saat lalu lintas tinggi

Cara Optimasi:

Saat bekerja dengan proxy seluler, di mana saluran komunikasi mungkin lebih lambat, biaya SSL menjadi lebih terlihat. Dalam pengujian, perbedaan antara permintaan HTTP dan HTTPS melalui proxy 4G rata-rata mencapai 280 ms.

Resolusi DNS dan Cache

Setiap permintaan ke domain baru memerlukan resolusi DNS — mengubah nama domain menjadi alamat IP. Tanpa caching, ini menambah 20-100 ms untuk setiap permintaan, dan pada server DNS yang lambat, latensi dapat mencapai 500+ ms.

Ketika Anda bekerja melalui proxy, permintaan DNS dapat dilakukan di tiga tempat:

• Di sisi Anda (klien menyelesaikan domain dan mengirimkan IP proxy)
• Di server proxy (SOCKS5, HTTP CONNECT — proxy mendapatkan domain dan menyelesaikannya sendiri)
• Di server target (jarang, pada konfigurasi tertentu)

Untuk proxy SOCKS5, resolusi DNS biasanya terjadi di sisi server proxy, yang mungkin lebih lambat jika penyedia proxy memiliki server DNS yang buruk. Proxy HTTP lebih sering menyelesaikan di sisi klien.

Metode Mempercepat DNS:

import socket
from functools import lru_cache

# Caching resolusi DNS di sisi klien
@lru_cache(maxsize=256)
def cached_resolve(hostname):
    """Menyimpan hasil permintaan DNS"""
    try:
        return socket.gethostbyname(hostname)
    except socket.gaierror:
        return None

# Penggunaan
hostname = 'example.com'
ip = cached_resolve(hostname)
if ip:
    # Gunakan IP langsung dalam permintaan
    url = f'http://{ip}/path'
    headers = {'Host': hostname}  # Tentukan host asli dalam header

Pendekatan alternatif adalah menggunakan server DNS publik yang cepat di tingkat sistem:

• 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

Di Linux, pengaturan dilakukan melalui /etc/resolv.conf:

nameserver 1.1.1.1
nameserver 8.8.8.8
options timeout:2 attempts:2

Untuk skrip Python dengan banyak domain, disarankan untuk memanaskan cache DNS terlebih dahulu:

import concurrent.futures
import socket

def warmup_dns_cache(domains):
    """Menyelesaikan daftar domain terlebih dahulu"""
    def resolve(domain):
        try:
            socket.gethostbyname(domain)
        except:
            pass
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
        executor.map(resolve, domains)

# Daftar domain untuk pengambilan data
domains = ['site1.com', 'site2.com', 'site3.com']
warmup_dns_cache(domains)

# Sekarang DNS sudah dalam cache, permintaan akan lebih cepat

Kualitas Infrastruktur Penyedia

Kecepatan proxy secara langsung bergantung pada kualitas perangkat keras dan saluran komunikasi penyedia. Proxy murah sering kali berjalan di server yang kelebihan beban dengan antarmuka jaringan yang lambat dan perangkat keras yang usang.

Parameter Kritis Infrastruktur:

Penyedia dengan infrastruktur sendiri (bukan reseller) biasanya memberikan kecepatan yang stabil dan tinggi. Mereka mengontrol seluruh tumpukan: dari perangkat keras hingga pengaturan perangkat jaringan.

Tanda-tanda Infrastruktur Berkualitas:

• Kecepatan stabil sepanjang hari (deviasi tidak lebih dari 15-20% dari rata-rata)
• Jitter rendah (variabilitas latensi) — kurang dari 10 ms
• Kehilangan paket minimal (<0.1%)
• Respons cepat dari dukungan teknis terhadap masalah (penting untuk tugas bisnis)
• Informasi transparan tentang lokasi server dan karakteristik saluran

Untuk tugas kritis, disarankan untuk menguji proxy dalam kondisi yang mendekati nyata. Beli akses uji selama 1-3 hari dan jalankan skrip nyata dengan pemantauan semua metrik.

Metodologi Pengujian Kecepatan Proxy

Pengujian yang tepat membantu mengidentifikasi bottleneck dan membandingkan penyedia secara objektif. Pengujian kecepatan sederhana tidak cukup — Anda perlu mengukur parameter yang penting untuk tugas Anda.

Metrik Kunci untuk Diukur:

• Latency (latensi) — waktu yang dibutuhkan paket untuk pergi dan kembali. Kritis untuk tugas dengan banyak permintaan kecil.
• Throughput (kapasitas) — volume data per unit waktu. Penting untuk mengunduh file, gambar.
• Waktu Koneksi — waktu untuk membuat koneksi. Menunjukkan efisiensi untuk permintaan sekali jalan.
• Tingkat Keberhasilan — persentase permintaan yang berhasil. Di bawah 95% — indikator buruk.
• Jitter — variasi latensi. Jitter tinggi (>50 ms) menunjukkan ketidakstabilan saluran.

Skrip Komprehensif untuk Pengujian:

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):
    """
    Pengujian komprehensif proxy
    
    Args:
        proxy: URL proxy
        test_url: URL untuk pengujian
        requests_count: Jumlah permintaan uji
    
    Returns:
        dict dengan metrik
    """
    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)
                # Perkiraan latensi
                results['latencies'].append(total_time / 2)
            else:
                results['failures'] += 1
        except Exception as e:
            results['failures'] += 1
            results['errors'].append(str(e))
    
    # Eksekusi permintaan secara paralel
    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()
    
    # Hitung statistik
    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': 'Semua permintaan gagal'}

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

print(f"Proxy: {metrics['proxy']}")
print(f"Tingkat keberhasilan: {metrics['success_rate']:.1f}%")
print(f"Waktu respons rata-rata: {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"Standar deviasi: {metrics['stdev_response_time']*1000:.0f} ms")

Untuk hasil yang lebih akurat, uji pada waktu yang berbeda sepanjang hari (pagi, siang, sore) dan di berbagai situs target. Kecepatan dapat bervariasi secara signifikan tergantung pada geografi dan beban jaringan.

Optimasi Menyeluruh: Daftar Periksa

Penerapan semua metode yang dijelaskan secara bersamaan memberikan efek kumulatif. Berikut adalah rencana langkah demi langkah untuk mengoptimalkan kecepatan kerja melalui proxy:

Contoh Konfigurasi yang Dioptimalkan untuk Produksi:

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):
        """Membuat sesi yang dioptimalkan"""
        session = requests.Session()
        
        # Strategi retry
        retry = Retry(
            total=3,
            backoff_factor=0.3,
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["GET", "POST", "PUT"]
        )
        
        # Adapter dengan connection pooling
        adapter = HTTPAdapter(
            max_retries=retry,
            pool_connections=20,
            pool_maxsize=50,
            pool_block=False
        )
        
        session.mount("http://", adapter)
        session.mount("https://", adapter)
        
        # Header Keep-Alive
        session.headers.update({
            'Connection': 'keep-alive',
            'Keep-Alive': 'timeout=60, max=100'
        })
        
        return session
    
    def get_best_proxy(self):
        """Dapatkan proxy dengan kinerja terbaik"""
        # Pengurutan berdasarkan kecepatan rata-rata
        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):
        """Lakukan permintaan melalui proxy yang optimal"""
        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),  # koneksi, baca
                **kwargs
            )
            
            # Perbarui statistik
            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:
            # Jika terjadi kesalahan, pindahkan proxy ke akhir antrean
            self.proxies.remove(proxy)
            self.proxies.append(proxy)
            raise e

# Penggunaan
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)

# Melakukan permintaan
for url in ['https://example.com', 'https://example.org']:
    try:
        response = pool.request(url)
        print(f"Sukses: {url}, status: {response.status_code}")
    except Exception as e:
        print(f"Kesalahan: {url}, {e}")

Penerapan daftar periksa ini memungkinkan peningkatan kecepatan kerja melalui proxy 2-3 kali lipat dibandingkan dengan pengaturan dasar. Dalam proyek pengambilan data nyata, ini mengurangi waktu eksekusi tugas dari jam menjadi menit.

Kesimpulan

Lambatnya kerja proxy adalah masalah yang dapat diselesaikan jika memahami alasan teknis dan menerapkan metode optimasi yang tepat. Faktor utama kecepatan: kedekatan geografis, pemilihan protokol, kualitas infrastruktur penyedia, dan pengaturan kode klien yang benar.

Pendekatan komprehensif untuk optimasi mencakup semua aspek ini, dan dengan menerapkan langkah-langkah yang tepat, Anda dapat secara signifikan meningkatkan kinerja sistem Anda.