प्रॉक्सी के माध्यम से कुकीज़ की समस्याओं को कैसे ठीक करें

कुकीज़ प्रॉक्सी के साथ काम करते समय सबसे आम त्रुटियों का स्रोत हैं। सत्र टूट जाते हैं, प्राधिकरण विफल हो जाता है, डेटा खो जाता है। इस लेख में हम समझेंगे कि ऐसा क्यों होता है और स्थिर काम के लिए कुकीज़ के प्रबंधन को सही तरीके से कैसे कॉन्फ़िगर करें।

प्रॉक्सी का उपयोग करते समय कुकीज़ क्यों खो जाती हैं

जब आप प्रॉक्सी के माध्यम से अनुरोध भेजते हैं, तो आपके क्लाइंट और लक्ष्य सर्वर के बीच एक मध्यवर्ती नोड आता है। यह कई समस्याएं पैदा करता है:

• एक सत्र के लिए विभिन्न IP पते। सर्वर को पता चल सकता है कि अनुरोध विभिन्न पते से आ रहे हैं, और कुकीज़ को संदिग्ध मानकर अस्वीकार कर सकता है।
• Set-Cookie हेडर का नुकसान। प्रॉक्सी का गलत कॉन्फ़िगरेशन Set-Cookie हेडर को क्लाइंट तक नहीं पहुंचा सकता।
• डोमेन और पथ का असंगति। यदि प्रॉक्सी Host-हेडर को फिर से लिखता है, तो डोमेन के असंगति के कारण कुकीज़ सहेजी नहीं जा सकती।
• स्थिति को सहेजने की कमी। यदि आप कुकीज़ को सहेजे बिना प्रत्येक अनुरोध को अलग से भेजते हैं, तो सत्र खो जाएगा।

कुकी जार क्या है और इसका उपयोग कैसे करें

कुकी जार एक भंडार है जो कुकीज़ को स्वचालित रूप से प्रबंधित करता है। प्रत्येक अनुरोध में कुकी हेडर को मैन्युअल रूप से जोड़ने के बजाय, आप लाइब्रेरी को यह स्वचालित रूप से करने देते हैं।

अधिकांश HTTP-क्लाइंट में कुकी जार के लिए अंतर्निहित समर्थन है:

import requests
from requests.cookies import RequestsCookieJar

# कुकीज़ को स्टोर करने के लिए जार बनाएं
jar = RequestsCookieJar()

# पहला अनुरोध — सर्वर Set-Cookie भेजेगा
response1 = requests.get(
    'https://example.com/login',
    cookies=jar,
    proxies={'https': 'http://proxy.example.com:8080'}
)

# कुकीज़ स्वचालित रूप से जार में सहेजी गई हैं
print(jar)

# दूसरा अनुरोध — कुकीज़ स्वचालित रूप से भेजी जाएंगी
response2 = requests.get(
    'https://example.com/dashboard',
    cookies=jar,
    proxies={'https': 'http://proxy.example.com:8080'}
)

जार के बिना, Set-Cookie को मैन्युअल रूप से पार्स करना और अगले अनुरोध में जोड़ना पड़ता — यह अविश्वसनीय और बोझिल है।

अनुरोधों के बीच कुकीज़ को सहेजना

यदि आपकी स्क्रिप्ट लंबे समय तक चलती है या आपको पुनः लोड के बाद सत्र को पुनः स्थापित करने की आवश्यकता है, तो कुकीज़ को फ़ाइल में सहेजें:

import requests
from http.cookiejar import LWPCookieJar

# फ़ाइल में सहेजने के साथ जार बनाएं
jar = LWPCookieJar('cookies.txt')

# पुरानी कुकीज़ लोड करें यदि वे मौजूद हैं
try:
    jar.load(ignore_discard=True, ignore_expires=True)
except FileNotFoundError:
    pass

# अनुरोधों में जार का उपयोग करें
response = requests.get(
    'https://example.com/login',
    cookies=jar,
    proxies={'https': 'http://proxy.example.com:8080'}
)

# अपडेट की गई कुकीज़ को सहेजें
jar.save(ignore_discard=True, ignore_expires=True)

फ्लैग ignore_discard=True और ignore_expires=True अस्थायी कुकीज़ को भी सहेजने की अनुमति देते हैं।

कुकीज़ के डोमेन बाइंडिंग के साथ समस्याएं

कुकीज़ में एक Domain विशेषता है जो निर्धारित करती है कि वे किन डोमेन के लिए भेजी जाएंगी। समस्याएं तब उत्पन्न होती हैं जब:

• प्रॉक्सी Host को फिर से लिखता है। यदि प्रॉक्सी Host हेडर को बदलता है, तो कुकी जार कुकी को दूसरे डोमेन से संबंधित मानकर अस्वीकार कर सकता है।
• सबडोमेन मेल नहीं खाते। example.com के लिए कुकी api.example.com पर नहीं भेजी जा सकती।
• पथ मेल नहीं खाता। /api के लिए कुकी /admin पर नहीं भेजी जाएगी।

कुकी विशेषताओं को इस तरह जांचें:

import requests

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

# सभी कुकीज़ को प्रिंट करें
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("---")

यदि Domain बहुत संकीर्ण है, तो स्वचालित प्रबंधन के बजाय कुकीज़ को स्पष्ट रूप से निर्दिष्ट करने का प्रयास करें:

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

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

सुरक्षित और HttpOnly फ्लैग

Secure फ्लैग का मतलब है कि कुकी केवल HTTPS पर भेजी जाती है। यदि आप HTTPS संसाधन तक पहुंचने के लिए HTTP-प्रॉक्सी का उपयोग कर रहे हैं, तो सुनिश्चित करें कि प्रॉक्सी तक कनेक्शन सुरक्षित है या प्रॉक्सी HTTPS को सही तरीके से पास करता है।

HttpOnly फ्लैग JavaScript से कुकी तक पहुंच को प्रतिबंधित करता है। यह अनुरोधों में कुकी भेजने को प्रभावित नहीं करता, लेकिन यह याद रखना महत्वपूर्ण है कि आप ब्राउज़र से ऐसी कुकीज़ को नहीं पढ़ सकते।

आवासीय प्रॉक्सी के साथ काम करते समय सुनिश्चित करें कि:

• प्रॉक्सी HTTPS का समर्थन करता है (CONNECT विधि)
• प्रमाणपत्र वैध हैं (production में verify=False का उपयोग न करें)
• हेडर को प्रॉक्सी द्वारा फिर से नहीं लिखा जाता है

कोड के साथ व्यावहारिक उदाहरण

उदाहरण 1: सत्र को सहेजने के साथ लॉगिन

import requests
from requests.cookies import RequestsCookieJar

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

# लॉगिन
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("लॉगिन सफल")
    
    # सहेजे गए सत्र का उपयोग करें
    dashboard = requests.get(
        'https://example.com/dashboard',
        cookies=jar,
        proxies={'https': proxy}
    )
    print(dashboard.text)

उदाहरण 2: कई अनुरोधों को संभालना

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)  # सर्वर को ओवरलोड न करें

उदाहरण 3: समस्याओं के समय कुकीज़ को स्पष्ट रूप से पास करना

import requests

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

# यदि स्वचालित प्रबंधन काम नहीं करता है
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())

कुकीज़ की समस्याओं का समस्या निवारण

यदि कुकीज़ काम नहीं कर रही हैं, तो इन उपकरणों का उपयोग करें:

समस्या निवारण के लिए लॉगिंग सक्षम करें:

import logging
import requests

logging.basicConfig(level=logging.DEBUG)

# अब सभी अनुरोध हेडर और कुकीज़ को प्रिंट करेंगे
response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy.example.com:8080'}
)

जांचें कि प्रॉक्सी कुकीज़ को ब्लॉक नहीं कर रहा है:

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

# हेडर को देखें:
# Set-Cookie: ... (होना चाहिए)
# Cookie: ... (अगले अनुरोध में भेजा जाना चाहिए)

सारांश

प्रॉक्सी के माध्यम से काम करते समय कुकीज़ की समस्याओं को सही कॉन्फ़िगरेशन से हल किया जाता है:

• कुकी जार का उपयोग करें कुकीज़ के स्वचालित प्रबंधन के लिए
• अनुरोधों के बीच कुकीज़ को फ़ाइल में सहेजें
• डोमेन बाइंडिंग और Path विशेषताओं की जांच करें
• प्रॉक्सी के HTTPS समर्थन को सुनिश्चित करें
• समस्याओं की पहचान के लिए समस्या निवारण का उपयोग करें

स्वचालन और पार्सिंग कार्यों के लिए, जहां प्रॉक्सी के माध्यम से सत्रों के साथ विश्वसनीय काम की आवश्यकता है, आवासीय प्रॉक्सी HTTPS समर्थन और कुकी प्रबंधन के साथ उपयुक्त हैं। सरल कुकी जार से शुरू करें और केवल आवश्यकता होने पर अधिक जटिल योजनाओं में जाएं।