AWS Lambda में पार्सिंग और API के लिए प्रॉक्सी सेट करने का तरीका: उदाहरणों के साथ पूर्ण गाइड

AWS Lambda एक सर्वरलेस प्लेटफ़ॉर्म है जो बिना सर्वरों का प्रबंधन किए कोड चलाने की अनुमति देता है। हालाँकि, वेबसाइटों, मार्केटप्लेस API या कार्यों के स्वचालन के साथ काम करते समय अक्सर एक समस्या उत्पन्न होती है: Lambda फ़ंक्शन AWS के IP पते का उपयोग करते हैं, जिन्हें आसानी से पहचाना और ब्लॉक किया जा सकता है। इस मार्गदर्शिका में, हम देखेंगे कि Lambda में प्रॉक्सी को कैसे एकीकृत किया जाए, IP रोटेशन को कैसे सेटअप किया जाए और सामान्य गलतियों से कैसे बचा जाए।

यह लेख उन डेवलपर्स के लिए है जो AWS Lambda के माध्यम से कार्यों का स्वचालन करते हैं: सुरक्षित वेबसाइटों से डेटा पार्सिंग, प्रतिस्पर्धियों की कीमतों की निगरानी, सामाजिक नेटवर्क या मार्केटप्लेस API के साथ काम करना। आप Python और Node.js पर तैयार कोड उदाहरण प्राप्त करेंगे, जिन्हें पढ़ने के तुरंत बाद उपयोग किया जा सकता है।

AWS Lambda में प्रॉक्सी की आवश्यकता क्यों है

AWS Lambda डिफ़ॉल्ट रूप से Amazon Web Services के पूल से IP पते का उपयोग करता है। ये पते सार्वजनिक सूचियों में होते हैं और बॉट सुरक्षा प्रणालियों द्वारा आसानी से पहचाने जाते हैं। यहाँ कुछ प्रमुख परिदृश्य हैं जब प्रॉक्सी आवश्यक हो जाते हैं:

Lambda में प्रॉक्सी का उपयोग करने के मुख्य कारण:

• सुरक्षित वेबसाइटों से पार्सिंग: कई वेबसाइटें AWS डेटा सेंटर के IP से अनुरोधों को ब्लॉक करती हैं। प्रॉक्सी Lambda को सामान्य उपयोगकर्ताओं के रूप में छिपाने की अनुमति देती हैं।
• भौगोलिक प्रतिबंध: यदि आपको किसी वेबसाइट से डेटा प्राप्त करने की आवश्यकता है, जो केवल एक निश्चित देश से उपलब्ध है (उदाहरण के लिए, Ozon पर क्षेत्रीय कीमतें), तो आवश्यक भौगोलिक स्थिति के साथ प्रॉक्सी समस्या का समाधान करती है।
• रेट लिमिटिंग को बायपास करना: कई सेवाओं के API एक IP से अनुरोधों की संख्या को सीमित करते हैं। प्रॉक्सी का रोटेशन लोड को वितरित करने की अनुमति देता है।
• A/B विज्ञापन परीक्षण: प्रतिस्पर्धियों के विश्लेषण के लिए विभिन्न क्षेत्रों से विज्ञापन दिखाने की जांच।
• मार्केटप्लेस की निगरानी: Wildberries, Ozon, Avito पर उत्पादों की स्थिति, प्रतिस्पर्धियों की कीमतों की निगरानी बिना ब्लॉक के।

Lambda फ़ंक्शन अक्सर शेड्यूल (CloudWatch Events के माध्यम से) या ट्रिगर्स द्वारा चलाए जाते हैं, जो उन्हें स्वचालन के लिए एक आदर्श उपकरण बनाते हैं। हालाँकि, बिना प्रॉक्सी के, ऐसे कार्य जल्दी लक्षित संसाधनों द्वारा ब्लॉक हो जाते हैं।

Lambda के लिए किस प्रकार की प्रॉक्सी चुनें

प्रॉक्सी के प्रकार का चयन उस कार्य पर निर्भर करता है जिसे आपकी Lambda फ़ंक्शन हल कर रही है। हम तीन मुख्य प्रकारों और सर्वरलेस आर्किटेक्चर में उनके उपयोग पर चर्चा करेंगे:

चुनने के लिए सिफारिशें:

• Wildberries, Ozon, Avito से पार्सिंग के लिए: रूसी भौगोलिक स्थिति के साथ निवासीय प्रॉक्सी का उपयोग करें। ये प्लेटफ़ॉर्म डेटा सेंटर के IP को सक्रिय रूप से ब्लॉक करते हैं।
• कड़ी सुरक्षा के बिना API की निगरानी के लिए: डेटा सेंटर प्रॉक्सी पर्याप्त हैं, वे सस्ते और तेज़ हैं।
• Instagram, Facebook, TikTok API के साथ काम करने के लिए: केवल मोबाइल या निवासीय प्रॉक्सी - ये प्लेटफ़ॉर्म डेटा सेंटर को पहचानते और ब्लॉक करते हैं।
• Cloudflare, PerimeterX को बायपास करने के लिए: रोटेशन के साथ निवासीय प्रॉक्सी, वांछनीय रूप से स्टिकी सत्रों के साथ (5-30 मिनट के लिए IP को बनाए रखना)।

Python (requests, urllib3) पर Lambda में प्रॉक्सी सेटअप

Python Lambda फ़ंक्शनों के लिए सबसे लोकप्रिय भाषा है, विशेष रूप से पार्सिंग और स्वचालन कार्यों के लिए। हम requests पुस्तकालय के साथ प्रॉक्सी सेटअप पर विचार करेंगे, जिसका उपयोग 90% मामलों में किया जाता है।

HTTP प्रॉक्सी का बुनियादी सेटअप

प्रॉक्सी को कनेक्ट करने का सबसे सरल तरीका proxies पैरामीटर को requests.get() विधि में पास करना है:

import requests
import os

def lambda_handler(event, context):
    # प्रॉक्सी से क्रेडेंशियल्स प्राप्त करें
    proxy_host = os.environ['PROXY_HOST']  # उदाहरण: proxy.example.com
    proxy_port = os.environ['PROXY_PORT']  # उदाहरण: 8080
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # प्रॉक्सी के साथ प्रमाणीकरण URL बनाना
    proxy_url = f"http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        # प्रॉक्सी के माध्यम से अनुरोध करें
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10  # महत्वपूर्ण! टाइमआउट सेट करें
        )
        
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except requests.exceptions.ProxyError as e:
        print(f"Proxy error: {e}")
        return {
            'statusCode': 500,
            'body': 'Proxy connection failed'
        }
    
    except requests.exceptions.Timeout as e:
        print(f"Timeout error: {e}")
        return {
            'statusCode': 504,
            'body': 'Request timeout'
        }

इस कोड के प्रमुख बिंदु:

• एनवायरनमेंट वेरिएबल्स: कभी भी प्रॉक्सी क्रेडेंशियल्स को कोड में सीधे न रखें! Lambda सेटिंग्स में एनवायरनमेंट वेरिएबल्स का उपयोग करें।
• टाइमआउट: हमेशा टाइमआउट सेट करें (10-30 सेकंड)। इसके बिना Lambda अधिकतम निष्पादन समय समाप्त होने तक लटका रह सकता है।
• त्रुटि प्रबंधन: प्रॉक्सी अनुपलब्ध या धीमे हो सकते हैं - हमेशा ProxyError और Timeout अपवादों को प्रबंधित करें।
• HTTP और HTTPS: proxies शब्दकोश में दोनों प्रोटोकॉल निर्दिष्ट करें, भले ही आप केवल HTTPS का उपयोग कर रहे हों।

SOCKS5 प्रॉक्सी का सेटअप

SOCKS5 प्रॉक्सी अधिक गुमनामी का स्तर प्रदान करते हैं और TCP स्तर पर काम करते हैं, जिससे वे कुछ सुरक्षा प्रणालियों के लिए अदृश्य हो जाते हैं। SOCKS5 के साथ काम करने के लिए requests[socks] पुस्तकालय की आवश्यकता होती है:

import requests
import os

def lambda_handler(event, context):
    proxy_host = os.environ['PROXY_HOST']
    proxy_port = os.environ['PROXY_PORT']
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # प्रमाणीकरण के साथ SOCKS5 प्रॉक्सी
    proxy_url = f"socks5://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        response = requests.get(
            'https://www.wildberries.ru/catalog/12345/detail.aspx',
            proxies=proxies,
            timeout=15
        )
        
        # डेटा पार्स करें
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except Exception as e:
        print(f"Error: {e}")
        return {
            'statusCode': 500,
            'body': str(e)
        }

Lambda में डिप्लॉयमेंट के लिए महत्वपूर्ण: SOCKS5 का उपयोग करते समय requirements.txt में जोड़ें:

requests[socks]
PySocks

प्रॉक्सी के माध्यम से IP की जांच

मुख्य लॉजिक को चलाने से पहले यह जांचना उपयोगी है कि प्रॉक्सी काम कर रहा है और सही IP लौटाता है:

def check_proxy_ip(proxies):
    """प्रॉक्सी के माध्यम से बाहरी दुनिया द्वारा देखे जाने वाले IP की जांच करता है"""
    try:
        response = requests.get(
            'https://api.ipify.org?format=json',
            proxies=proxies,
            timeout=10
        )
        ip_data = response.json()
        print(f"प्रॉक्सी के माध्यम से वर्तमान IP: {ip_data['ip']}")
        return ip_data['ip']
    except Exception as e:
        print(f"प्रॉक्सी जांच विफल: {e}")
        return None

def lambda_handler(event, context):
    # ... प्रॉक्सी सेटअप ...
    
    # मुख्य कार्य से पहले IP की जांच करें
    current_ip = check_proxy_ip(proxies)
    if not current_ip:
        return {
            'statusCode': 500,
            'body': 'प्रॉक्सी सत्यापन विफल'
        }
    
    # पार्सिंग का मुख्य लॉजिक
    # ...

Node.js (axios, got) पर Lambda में प्रॉक्सी सेटअप

Node.js Lambda फ़ंक्शनों के लिए दूसरी सबसे लोकप्रिय भाषा है, विशेष रूप से API के साथ काम करते समय उच्च प्रदर्शन की आवश्यकता होती है। हम axios और got पुस्तकालयों के साथ प्रॉक्सी सेटअप पर विचार करेंगे।

axios के साथ सेटअप

Axios Node.js के लिए सबसे लोकप्रिय HTTP पुस्तकालय है। प्रॉक्सी के साथ काम करने के लिए एक अतिरिक्त पैकेज https-proxy-agent की आवश्यकता होती है:

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

exports.handler = async (event) => {
    // एनवायरनमेंट वेरिएबल्स से क्रेडेंशियल्स प्राप्त करें
    const proxyHost = process.env.PROXY_HOST;
    const proxyPort = process.env.PROXY_PORT;
    const proxyUser = process.env.PROXY_USER;
    const proxyPass = process.env.PROXY_PASS;
    
    // प्रॉक्सी URL बनाना
    const proxyUrl = `http://${proxyUser}:${proxyPass}@${proxyHost}:${proxyPort}`;
    
    // प्रॉक्सी के लिए एजेंट बनाना
    const agent = new HttpsProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://api.example.com/data', {
            httpsAgent: agent,
            timeout: 10000  // 10 सेकंड
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('अनुरोध विफल:', error.message);
        
        return {
            statusCode: 500,
            body: JSON.stringify({
                error: error.message
            })
        };
    }
};

निर्भरता स्थापित करना: package.json में जोड़ें:

{
  "dependencies": {
    "axios": "^1.6.0",
    "https-proxy-agent": "^7.0.0"
  }
}

axios के साथ SOCKS5 सेटअप

SOCKS5 प्रॉक्सी के लिए socks-proxy-agent पैकेज का उपयोग करें:

const axios = require('axios');
const { SocksProxyAgent } = require('socks-proxy-agent');

exports.handler = async (event) => {
    const proxyUrl = `socks5://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
    
    const agent = new SocksProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://www.ozon.ru/api/products', {
            httpAgent: agent,
            httpsAgent: agent,
            timeout: 15000
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('त्रुटि:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

विकल्प: got पुस्तकालय

Got एक आधुनिक HTTP पुस्तकालय है जिसमें प्रॉक्सी का स्वदेशी समर्थन है (अलग एजेंट की आवश्यकता नहीं है):

const got = require('got');

exports.handler = async (event) => {
    const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
    
    try {
        const response = await got('https://api.example.com/data', {
            agent: {
                http: new (require('http-proxy-agent'))(proxyUrl),
                https: new (require('https-proxy-agent'))(proxyUrl)
            },
            timeout: {
                request: 10000
            },
            responseType: 'json'
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.body)
        };
    } catch (error) {
        console.error('त्रुटि:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Lambda में प्रॉक्सी रोटेशन: IP को स्वचालित रूप से कैसे बदलें

प्रॉक्सी का रोटेशन उन कार्यों के लिए महत्वपूर्ण है जहाँ बिना ब्लॉक के कई अनुरोध करने की आवश्यकता होती है। दो मुख्य दृष्टिकोण हैं: स्वचालित रोटेशन के साथ प्रॉक्सी सेवाओं का उपयोग करना या प्रॉक्सी पूल का मैनुअल प्रबंधन।

प्रदाता के माध्यम से स्वचालित रोटेशन

अधिकांश निवासीय प्रॉक्सी प्रदाता (ProxyCove सहित) स्वचालित रोटेशन के साथ एक एंडपॉइंट प्रदान करते हैं - प्रत्येक अनुरोध या हर N मिनट में IP स्वचालित रूप से बदल जाता है:

import requests
import os

def lambda_handler(event, context):
    # स्वचालित रोटेशन के साथ प्रॉक्सी
    # प्रारूप: rotating.proxy.com:port
    # प्रत्येक अनुरोध = नया IP
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@rotating.proxycove.com:8080"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    results = []
    
    # 10 अनुरोध करें - प्रत्येक नए IP के साथ
    for i in range(10):
        try:
            response = requests.get(
                f'https://api.wildberries.ru/products/{i}',
                proxies=proxies,
                timeout=10
            )
            results.append({
                'product_id': i,
                'status': response.status_code,
                'data': response.json()
            })
        except Exception as e:
            results.append({
                'product_id': i,
                'error': str(e)
            })
    
    return {
        'statusCode': 200,
        'body': json.dumps(results)
    }

प्रॉक्सी पूल से मैनुअल रोटेशन

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

import requests
import random
import json

def lambda_handler(event, context):
    # प्रॉक्सी की सूची (DynamoDB या S3 में स्टोर की जा सकती है)
    proxy_pool = [
        {
            'host': 'proxy1.example.com',
            'port': '8080',
            'user': 'user1',
            'pass': 'pass1'
        },
        {
            'host': 'proxy2.example.com',
            'port': '8080',
            'user': 'user2',
            'pass': 'pass2'
        },
        {
            'host': 'proxy3.example.com',
            'port': '8080',
            'user': 'user3',
            'pass': 'pass3'
        }
    ]
    
    results = []
    
    for i in range(10):
        # पूल से एक यादृच्छिक प्रॉक्सी चुनें
        proxy = random.choice(proxy_pool)
        proxy_url = f"http://{proxy['user']}:{proxy['pass']}@{proxy['host']}:{proxy['port']}"
        
        proxies = {
            'http': proxy_url,
            'https': proxy_url
        }
        
        try:
            response = requests.get(
                f'https://api.example.com/item/{i}',
                proxies=proxies,
                timeout=10
            )
            results.append({
                'item': i,
                'proxy_used': proxy['host'],
                'status': response.status_code
            })
        except Exception as e:
            results.append({
                'item': i,
                'proxy_used': proxy['host'],
                'error': str(e)
            })
    
    return {
        'statusCode': 200,
        'body': json.dumps(results)
    }

IP को बनाए रखने के लिए स्टिकी सत्र

कुछ कार्यों के लिए सत्र के दौरान एक IP को बनाए रखना आवश्यक होता है (उदाहरण के लिए, वेबसाइट पर प्रमाणीकरण)। प्रॉक्सी प्रदाता URL में एक पैरामीटर के माध्यम से स्टिकी सत्र प्रदान करते हैं:

import requests
import uuid

def lambda_handler(event, context):
    # एक अद्वितीय session_id उत्पन्न करें
    session_id = str(uuid.uuid4())
    
    # स्टिकी सत्र के साथ प्रॉक्सी (IP 10 मिनट के लिए बनाए रखा जाता है)
    proxy_url = f"http://{os.environ['PROXY_USER']}-session-{session_id}:{os.environ['PROXY_PASS']}@sticky.proxycove.com:8080"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    # इस Lambda में सभी अनुरोध एक ही IP के साथ किए जाएंगे
    # 1. प्रमाणीकरण
    login_response = requests.post(
        'https://example.com/login',
        data={'user': 'test', 'pass': 'test'},
        proxies=proxies
    )
    
    # 2. डेटा प्राप्त करना (उसी IP का उपयोग किया जाता है)
    data_response = requests.get(
        'https://example.com/dashboard',
        proxies=proxies,
        cookies=login_response.cookies
    )
    
    return {
        'statusCode': 200,
        'body': data_response.text
    }

एनवायरनमेंट वेरिएबल्स के माध्यम से प्रॉक्सी क्रेडेंशियल्स को स्टोर करना

कभी भी प्रॉक्सी क्रेडेंशियल्स (लॉगिन, पासवर्ड, होस्ट) को Lambda फ़ंक्शन के कोड में सीधे न रखें। AWS संवेदनशील डेटा को स्टोर करने के लिए कई सुरक्षित तरीके प्रदान करता है:

1. एनवायरनमेंट वेरिएबल्स (बुनियादी तरीका)

AWS Lambda कंसोल → कॉन्फ़िगरेशन → एनवायरनमेंट वेरिएबल्स में जोड़ें:

• PROXY_HOST = proxy.example.com
• PROXY_PORT = 8080
• PROXY_USER = your_username
• PROXY_PASS = your_password

AWS स्वचालित रूप से एनवायरनमेंट वेरिएबल्स को विश्राम में एन्क्रिप्ट करता है। कोड में उनके लिए पहुंच:

# Python
import os
proxy_host = os.environ['PROXY_HOST']

// Node.js
const proxyHost = process.env.PROXY_HOST;

2. AWS Secrets Manager (उत्पादन के लिए अनुशंसित)

अधिकतम सुरक्षा के लिए AWS Secrets Manager का उपयोग करें - यह स्वचालित रूप से रहस्यों का रोटेशन और विस्तृत पहुंच नियंत्रण प्रदान करता है:

import boto3
import json
from botocore.exceptions import ClientError

def get_proxy_credentials():
    secret_name = "proxy-credentials"
    region_name = "us-east-1"
    
    session = boto3.session.Session()
    client = session.client(
        service_name='secretsmanager',
        region_name=region_name
    )
    
    try:
        get_secret_value_response = client.get_secret_value(
            SecretId=secret_name
        )
        secret = json.loads(get_secret_value_response['SecretString'])
        return secret
    except ClientError as e:
        print(f"गुप्त प्राप्त करने में त्रुटि: {e}")
        raise e

def lambda_handler(event, context):
    # Secrets Manager से क्रेडेंशियल्स प्राप्त करें
    creds = get_proxy_credentials()
    
    proxy_url = f"http://{creds['user']}:{creds['password']}@{creds['host']}:{creds['port']}"
    
    # प्रॉक्सी का उपयोग करें
    # ...

महत्वपूर्ण: Secrets Manager तक पहुंच के लिए Lambda फ़ंक्शन के लिए IAM अधिकार जोड़ना न भूलें:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "secretsmanager:GetSecretValue"
      ],
      "Resource": "arn:aws:secretsmanager:us-east-1:123456789:secret:proxy-credentials-*"
    }
  ]
}

सामान्य गलतियाँ और उनका समाधान

Lambda में प्रॉक्सी के साथ काम करते समय डेवलपर्स अक्सर समान समस्याओं का सामना करते हैं। हम सबसे सामान्य समस्याओं और उनके समाधान पर चर्चा करेंगे:

त्रुटि: ProxyError / Connection timeout

समाधान:

# 1. क्रेडेंशियल्स की जांच करें
print(f"प्रॉक्सी का उपयोग कर रहे हैं: {proxy_host}:{proxy_port}")
print(f"उपयोगकर्ता: {proxy_user}")

# 2. टाइमआउट बढ़ाएँ
response = requests.get(url, proxies=proxies, timeout=30)

# 3. पुनः प्रयास लॉजिक जोड़ें
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

session = requests.Session()
retry = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry)
session.mount('http://', adapter)
session.mount('https://', adapter)

response = session.get(url, proxies=proxies, timeout=30)

त्रुटि: SSL प्रमाणपत्र सत्यापन विफल

समाधान (सावधानी से उपयोग करें!):

# SSL सत्यापन बंद करना (केवल परीक्षण के लिए!)
response = requests.get(
    url,
    proxies=proxies,
    verify=False  # उत्पादन में उपयोग न करें!
)

# बेहतर: CA प्रमाणपत्र के पथ को निर्दिष्ट करें
response = requests.get(
    url,
    proxies=proxies,
    verify='/path/to/ca-bundle.crt'
)

त्रुटि: Lambda टाइमआउट (कार्य X सेकंड के बाद समय समाप्त हो गया)

समाधान:

• Lambda फ़ंक्शन का टाइमआउट बढ़ाएँ: कॉन्फ़िगरेशन → सामान्य कॉन्फ़िगरेशन → टाइमआउट (अधिकतम 15 मिनट)
• एक निष्पादन में अनुरोधों की संख्या कम करें
• असिंक्रोनस अनुरोधों का उपयोग करें (Python में asyncio, Node.js में Promise.all)
• गैर-आवश्यक कार्यों के लिए तेज़ प्रॉक्सी पर स्विच करें

# Python: गति बढ़ाने के लिए असिंक्रोनस अनुरोध
import asyncio
import aiohttp

async def fetch_url(session, url, proxy):
    async with session.get(url, proxy=proxy, timeout=10) as response:
        return await response.text()

async def lambda_handler_async(event, context):
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    
    urls = [f'https://api.example.com/item/{i}' for i in range(50)]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url, proxy_url) for url in urls]
        results = await asyncio.gather(*tasks)
    
    return {
        'statusCode': 200,
        'body': json.dumps({'count': len(results)})
    }

def lambda_handler(event, context):
    return asyncio.run(lambda_handler_async(event, context))

त्रुटि: 407 प्रॉक्सी प्रमाणीकरण आवश्यक

समाधान:

# प्रॉक्सी URL प्रारूप की जांच करें
# सही:
proxy_url = f"http://{user}:{password}@{host}:{port}"

# गलत (प्रोटोकॉल छूट गया):
proxy_url = f"{user}:{password}@{host}:{port}"  # ❌

# यदि प्रॉक्सी IP प्रमाणीकरण की आवश्यकता है:
# 1. अपनी Lambda का बाहरी IP जानें (यह बदल सकता है!)
# 2. इस IP को प्रॉक्सी प्रदाता की व्हाइटलिस्ट में जोड़ें
# 3. बिना user:pass के प्रॉक्सी का उपयोग करें

# Lambda का बाहरी IP प्राप्त करना:
response = requests.get('https://api.ipify.org?format=json')
lambda_ip = response.json()['ip']
print(f"Lambda बाहरी IP: {lambda_ip}")

प्रॉक्सी के साथ Lambda के प्रदर्शन का अनुकूलन

प्रॉक्सी का उपयोग प्रत्येक अनुरोध में देरी जोड़ता है। प्रदर्शन पर प्रभाव को न्यूनतम करने के लिए यहाँ कुछ परीक्षण किए गए तरीके हैं:

1. कनेक्शन पूलिंग

प्रत्येक अनुरोध के लिए नया बनाने के बजाय TCP कनेक्शनों का पुन: उपयोग करें:

# Python: requests.get() के बजाय Session का उपयोग करें
import requests

# एक बार सत्र बनाएं (handler के बाहर रखा जा सकता है)
session = requests.Session()
session.proxies = {
    'http': proxy_url,
    'https': proxy_url
}

def lambda_handler(event, context):
    # सभी अनुरोध कनेक्शनों का पुन: उपयोग करते हैं
    for i in range(100):
        response = session.get(f'https://api.example.com/item/{i}')
        # प्रतिक्रिया को संसाधित करें...

2. समानांतर अनुरोध

यदि आपको कई स्वतंत्र अनुरोध करने की आवश्यकता है, तो उन्हें समानांतर में करें:

// Node.js: Promise.all के साथ समानांतर अनुरोध
const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

const agent = new HttpsProxyAgent(proxyUrl);

exports.handler = async (event) => {
    const urls = Array.from({length: 50}, (_, i) => 
        `https://api.example.com/item/${i}`
    );
    
    // सभी अनुरोध समानांतर में किए जाते हैं
    const promises = urls.map(url => 
        axios.get(url, { 
            httpsAgent: agent,
            timeout: 10000
        })
    );
    
    try {
        const results = await Promise.all(promises);
        return {
            statusCode: 200,
            body: JSON.stringify({
                count: results.length,
                data: results.map(r => r.data)
            })
        };
    } catch (error) {
        console.error('त्रुटि:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

3. परिणामों को कैश करना

यदि डेटा कम बदलता है, तो परिणामों को DynamoDB या S3 में कैश करें:

import boto3
import json
import time

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('proxy-cache')

def get_cached_or_fetch(url, proxies, cache_ttl=3600):
    """कैश से डेटा लौटाता है या प्रॉक्सी के माध्यम से अनुरोध करता है"""
    
    # कैश की जांच करें
    try:
        response = table.get_item(Key={'url': url})
        if 'Item' in response:
            item = response['Item']
            if time.time() - item['timestamp'] < cache_ttl:
                print(f"{url} के लिए कैश हिट")
                return item['data']
    except Exception as e:
        print(f"कैश त्रुटि: {e}")
    
    # कैश खाली है या पुराना है - अनुरोध करें
    print(f"{url} के लिए कैश मिस, लाने...")
    response = requests.get(url, proxies=proxies, timeout=10)
    data = response.text
    
    # कैश में सहेजें
    try:
        table.put_item(Item={
            'url': url,
            'data': data,
            'timestamp': int(time.time())
        })
    except Exception as e:
        print(f"कैश सहेजने में त्रुटि: {e}")
    
    return data

4. सही प्रकार की प्रॉक्सी का चयन

वास्तविक परिस्थितियों में विभिन्न प्रकार की प्रॉक्सी की गति की तुलना:

प्रदर्शन को अनुकूलित करने के लिए सुझाव:

• डेटा सेंटर प्रॉक्सी: सामान्य API अनुरोधों के लिए उपयुक्त।
• निवासीय प्रॉक्सी: सुरक्षित वेबसाइटों के लिए।
• मोबाइल प्रॉक्सी: मोबाइल ऐप्स के लिए।