Cara Memperbaiki Masalah Cookies Melalui Proxy

Cookies adalah salah satu sumber kesalahan paling umum saat bekerja dengan proxy. Sesi terputus, autentikasi gagal, data hilang. Dalam artikel ini, kami akan membahas mengapa hal ini terjadi dan cara mengonfigurasi penanganan cookies dengan benar untuk operasi yang stabil.

Mengapa cookies hilang saat menggunakan proxy

Ketika Anda mengirim permintaan melalui proxy, node perantara berada di antara klien Anda dan server target. Ini menciptakan beberapa masalah:

• Alamat IP berbeda untuk satu sesi. Server mungkin memperhatikan bahwa permintaan datang dari alamat berbeda dan menolak cookies sebagai mencurigakan.
• Kehilangan header Set-Cookie. Konfigurasi proxy yang tidak benar mungkin tidak mengirimkan header Set-Cookie ke klien.
• Ketidaksesuaian domain dan path. Jika proxy menulis ulang header Host, cookies mungkin tidak tersimpan karena ketidaksesuaian domain.
• Tidak ada penyimpanan status. Jika Anda mengirim setiap permintaan secara terpisah tanpa menyimpan cookies, sesi akan hilang.

Apa itu cookie jar dan cara menggunakannya

Cookie jar adalah penyimpanan cookies yang secara otomatis mengelola pengiriman dan penerimaannya. Alih-alih menambahkan header Cookie secara manual ke setiap permintaan, Anda membiarkan library melakukannya secara otomatis.

Sebagian besar klien HTTP memiliki dukungan cookie jar bawaan:

import requests
from requests.cookies import RequestsCookieJar

# Buat jar untuk menyimpan cookies
jar = RequestsCookieJar()

# Permintaan pertama — server akan mengirim Set-Cookie
response1 = requests.get(
    'https://example.com/login',
    cookies=jar,
    proxies={'https': 'http://proxy.example.com:8080'}
)

# Cookies secara otomatis disimpan di jar
print(jar)

# Permintaan kedua — cookies akan dikirim secara otomatis
response2 = requests.get(
    'https://example.com/dashboard',
    cookies=jar,
    proxies={'https': 'http://proxy.example.com:8080'}
)

Tanpa jar, Anda harus secara manual mengurai Set-Cookie dan menambahkannya ke permintaan berikutnya — ini tidak dapat diandalkan dan rumit.

Menyimpan cookies antar permintaan

Jika skrip Anda berjalan lama atau Anda perlu memulihkan sesi setelah restart, simpan cookies ke file:

import requests
from http.cookiejar import LWPCookieJar

# Buat jar dengan penyimpanan ke file
jar = LWPCookieJar('cookies.txt')

# Muat cookies lama jika ada
try:
    jar.load(ignore_discard=True, ignore_expires=True)
except FileNotFoundError:
    pass

# Gunakan jar dalam permintaan
response = requests.get(
    'https://example.com/login',
    cookies=jar,
    proxies={'https': 'http://proxy.example.com:8080'}
)

# Simpan cookies yang diperbarui
jar.save(ignore_discard=True, ignore_expires=True)

Flag ignore_discard=True dan ignore_expires=True memungkinkan penyimpanan bahkan cookies sementara.

Masalah dengan pencocokan domain cookies

Cookies memiliki atribut Domain yang menentukan domain mana yang akan mengirimnya. Masalah muncul jika:

• Proxy menulis ulang Host. Jika proxy mengubah header Host, cookie jar mungkin menolak cookie sebagai milik domain lain.
• Subdomain tidak cocok. Cookie untuk example.com mungkin tidak dikirim ke api.example.com.
• Path tidak cocok. Cookie untuk /api tidak akan dikirim ke /admin.

Periksa atribut cookie seperti ini:

import requests

response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy.example.com:8080'}
)

# Cetak semua cookies
for cookie in response.cookies:
    print(f"Name: {cookie.name}")
    print(f"Value: {cookie.value}")
    print(f"Domain: {cookie.domain}")
    print(f"Path: {cookie.path}")
    print(f"Secure: {cookie.secure}")
    print(f"HttpOnly: {cookie.has_nonstandard_attr('HttpOnly')}")
    print("---")

Jika Domain terlalu sempit, coba kirim cookies secara eksplisit alih-alih manajemen otomatis:

headers = {
    'Cookie': 'session_id=abc123; user_token=xyz789'
}

response = requests.get(
    'https://example.com/api',
    headers=headers,
    proxies={'https': 'http://proxy.example.com:8080'}
)

Flag Secure dan HttpOnly

Flag Secure berarti cookie hanya dikirim melalui HTTPS. Jika Anda menggunakan proxy HTTP untuk mengakses sumber daya HTTPS, pastikan koneksi ke proxy dilindungi atau proxy dengan benar meneruskan HTTPS.

Flag HttpOnly melarang akses ke cookie dari JavaScript. Ini tidak mempengaruhi pengiriman cookie dalam permintaan, tetapi penting untuk diingat bahwa Anda tidak dapat membaca cookies tersebut dari browser.

Saat bekerja dengan proxy residensial, pastikan:

• Proxy mendukung HTTPS (metode CONNECT)
• Sertifikat valid (jangan gunakan verify=False di production)
• Header tidak ditulis ulang oleh proxy

Contoh praktis dengan kode

Contoh 1: Login dengan penyimpanan sesi

import requests
from requests.cookies import RequestsCookieJar

jar = RequestsCookieJar()
proxy = 'http://proxy.example.com:8080'

# Login
login_response = requests.post(
    'https://example.com/login',
    data={'username': 'user', 'password': 'pass'},
    cookies=jar,
    proxies={'https': proxy}
)

if login_response.status_code == 200:
    print("Login berhasil")
    
    # Gunakan sesi yang disimpan
    dashboard = requests.get(
        'https://example.com/dashboard',
        cookies=jar,
        proxies={'https': proxy}
    )
    print(dashboard.text)

Contoh 2: Menangani banyak permintaan

import requests
from http.cookiejar import LWPCookieJar
import time

jar = LWPCookieJar('session.txt')
try:
    jar.load(ignore_discard=True)
except:
    pass

proxy = 'http://proxy.example.com:8080'
urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3'
]

for url in urls:
    response = requests.get(
        url,
        cookies=jar,
        proxies={'https': proxy},
        timeout=10
    )
    print(f"{url}: {response.status_code}")
    jar.save(ignore_discard=True)
    time.sleep(1)  # Jangan membebani server

Contoh 3: Pengiriman cookies eksplisit saat ada masalah

import requests

proxy = 'http://proxy.example.com:8080'

# Jika manajemen otomatis tidak bekerja
cookies_dict = {
    'session_id': 'abc123def456',
    'user_pref': 'dark_mode'
}

headers = {
    'User-Agent': 'Mozilla/5.0...',
    'Cookie': '; '.join([f"{k}={v}" for k, v in cookies_dict.items()])
}

response = requests.get(
    'https://example.com/api/data',
    headers=headers,
    proxies={'https': proxy}
)

print(response.json())

Debugging masalah cookies

Jika cookies tidak bekerja, gunakan alat-alat ini:

Aktifkan logging untuk debugging:

import logging
import requests

logging.basicConfig(level=logging.DEBUG)

# Sekarang semua permintaan akan menampilkan header dan cookies
response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy.example.com:8080'}
)

Periksa bahwa proxy tidak memblokir cookies:

curl -v -x http://proxy.example.com:8080 https://example.com

# Lihat header:
# Set-Cookie: ... (harus ada)
# Cookie: ... (harus dikirim dalam permintaan berikutnya)

Ringkasan

Masalah cookies saat bekerja melalui proxy diselesaikan dengan konfigurasi yang tepat:

• Gunakan cookie jar untuk manajemen cookies otomatis
• Simpan cookies antar permintaan ke file
• Periksa pencocokan domain dan atribut Path
• Pastikan dukungan HTTPS proxy
• Gunakan debugging untuk mengidentifikasi masalah

Untuk tugas otomasi dan scraping di mana Anda membutuhkan operasi sesi yang andal melalui proxy, proxy residensial dengan dukungan HTTPS dan manajemen cookies cocok. Mulai dengan cookie jar sederhana dan lanjutkan ke skema yang lebih kompleks hanya jika diperlukan.