प्रॉक्सी का Google Cloud Functions के साथ एकीकरण: गाइड 2024

```html

Google Cloud Functions एक सर्वरलेस प्लेटफ़ॉर्म है जो बिना सर्वर प्रबंधन के कोड चलाने के लिए है। डेटा खींचने, API अनुरोधों के स्वचालन या डेटा संग्रह करते समय अक्सर प्रॉक्सी के माध्यम से ट्रैफ़िक को रूट करने की आवश्यकता होती है ताकि ब्लॉकों को बायपास किया जा सके, IP रोटेशन और भौगोलिक लक्ष्यीकरण किया जा सके। इस गाइड में हम Python और Node.js में Cloud Functions में प्रॉक्सी सेटअप पर व्यावहारिक उदाहरणों के साथ चर्चा करेंगे।

Cloud Functions में प्रॉक्सी का उपयोग क्यों करें

Google Cloud Functions एक साझा IP पते के साथ एक अलग वातावरण में काम करते हैं। बाहरी API या वेबसाइटों पर बार-बार अनुरोध करते समय समस्याएँ उत्पन्न होती हैं:

IP द्वारा ब्लॉक करना — कई सेवाएँ (Google, Facebook, मार्केटप्लेस) डेटा केंद्रों से ट्रैफ़िक को पहचानती हैं और दर सीमित करने या पूर्ण ब्लॉक लागू करती हैं।
भौगोलिक प्रतिबंध — ऐसे सामग्री तक पहुँचने के लिए जो केवल कुछ देशों में उपलब्ध है (जैसे, Wildberries या Ozon पर क्षेत्रीय कीमतों को खींचना)।
दर सीमित करना — एक IP पता प्रति मिनट सीमित संख्या में अनुरोध कर सकता है। प्रॉक्सी लोड को वितरित करने की अनुमति देती हैं।
गुमनामी — संवेदनशील डेटा या प्रतिस्पर्धी खुफिया के साथ काम करते समय अनुरोधों के वास्तविक स्रोत को छिपाना।

Cloud Functions में प्रॉक्सी के उपयोग के सामान्य परिदृश्य:

प्रतिस्पर्धियों की कीमतों की निगरानी के लिए मार्केटप्लेस (Wildberries, Ozon, Amazon) को खींचना
API या वेब स्क्रैपिंग के माध्यम से सोशल मीडिया (Instagram, TikTok) से डेटा एकत्र करना
विभिन्न क्षेत्रों में विज्ञापन की जाँच करने के लिए स्वचालन
SEO विश्लेषण के लिए खोज इंजनों (Google, Yandex) पर बड़े पैमाने पर अनुरोध
ऐप्लिकेशन के भू-स्थानिक कार्यों का परीक्षण

Cloud Functions के लिए कौन से प्रकार के प्रॉक्सी उपयुक्त हैं

प्रॉक्सी के प्रकार का चयन कार्य, बजट और गुमनामी की आवश्यकताओं पर निर्भर करता है। यहाँ मुख्य विकल्पों की तुलना की गई है:

प्रॉक्सी का प्रकार	गति	गुमनामी	के लिए सबसे अच्छा
डेटा केंद्र प्रॉक्सी	उच्च (50-200 मि.सेक)	मध्यम	सरल वेबसाइटों को खींचना, API अनुरोध, SEO निगरानी
रेसिडेंशियल प्रॉक्सी	मध्यम (200-800 मि.सेक)	उच्च	सोशल मीडिया, मार्केटप्लेस, एंटी-बॉट सिस्टम को बायपास करना
मोबाइल प्रॉक्सी	मध्यम (300-1000 मि.सेक)	बहुत उच्च	Instagram, TikTok, मोबाइल ऐप, Facebook API

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

मार्केटप्लेस को खींचने के लिए (Wildberries, Ozon, Amazon) — रेसिडेंशियल प्रॉक्सी जो अनुरोध के अनुसार रोटेट होती है, ताकि प्रत्येक अनुरोध नए IP से जाए।
API अनुरोधों के लिए (Google Maps API, OpenWeatherMap) — डेटा केंद्र प्रॉक्सी जो उच्च गति वाली होती है, यदि IP पर कठोर सीमाएँ नहीं हैं।
सोशल मीडिया के लिए (Instagram, TikTok) — मोबाइल प्रॉक्सी, क्योंकि इनमें मोबाइल ऑपरेटरों के IP होते हैं और ये शायद ही कभी ब्लॉक होते हैं।
SEO खींचने के लिए (Google, Yandex) — रेसिडेंशियल प्रॉक्सी जो आवश्यक क्षेत्र के लिए भौगोलिक रूप से बंधी होती है।

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

Python डेटा खींचने और स्वचालन के लिए Cloud Functions में सबसे लोकप्रिय भाषा है। हम requests (सिंक्रोनस अनुरोध) और aiohttp (असिंक्रोनस अनुरोध) के साथ प्रॉक्सी का एकीकरण देखेंगे।

requests पुस्तकालय के साथ उदाहरण (HTTP प्रॉक्सी)

import requests
import os

def parse_with_proxy(request):
    # पर्यावरण चर से प्रॉक्सी डेटा प्राप्त करें
    proxy_host = os.environ.get('PROXY_HOST', 'proxy.example.com')
    proxy_port = os.environ.get('PROXY_PORT', '8080')
    proxy_user = os.environ.get('PROXY_USER', 'username')
    proxy_pass = os.environ.get('PROXY_PASS', 'password')
    
    # प्रमाणीकरण के साथ प्रॉक्सी का 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,
            headers={'User-Agent': 'Mozilla/5.0'}
        )
        
        # प्रतिक्रिया की स्थिति की जांच करें
        response.raise_for_status()
        
        return {
            'statusCode': 200,
            'body': response.json(),
            'ip_used': response.headers.get('X-Forwarded-For', 'unknown')
        }
        
    except requests.exceptions.ProxyError as e:
        return {'statusCode': 502, 'error': f'Proxy error: {str(e)}'}
    except requests.exceptions.Timeout:
        return {'statusCode': 504, 'error': 'Request timeout'}
    except requests.exceptions.RequestException as e:
        return {'statusCode': 500, 'error': f'Request failed: {str(e)}'}

महत्वपूर्ण बिंदु:

पर्यावरण चर — प्रॉक्सी डेटा (होस्ट, पोर्ट, लॉगिन, पासवर्ड) को Secret Manager या Cloud Functions के पर्यावरण चर में संग्रहीत करें, कोड में नहीं।
टाइमआउट — सुनिश्चित करें कि timeout सेट करें, ताकि प्रॉक्सी के साथ समस्याओं पर फ़ंक्शन लटक न जाए।
User-Agent — अनुरोधों को वास्तविक ब्राउज़र के रूप में दिखाने के लिए User-Agent हेडर जोड़ें।
त्रुटियों को संभालना — प्रॉक्सी से संबंधित समस्याओं और टाइमआउट को अलग से संभालें।

aiohttp के साथ उदाहरण (असिंक्रोनस अनुरोध)

उच्च लोड वाले कार्यों के लिए (जैसे, 1000+ पृष्ठों को खींचना) aiohttp के साथ असिंक्रोनस अनुरोधों का उपयोग करें:

import aiohttp
import asyncio
import os

async def fetch_with_proxy(url, proxy_url):
    async with aiohttp.ClientSession() as session:
        try:
            async with session.get(
                url,
                proxy=proxy_url,
                timeout=aiohttp.ClientTimeout(total=10),
                headers={'User-Agent': 'Mozilla/5.0'}
            ) as response:
                return await response.text()
        except aiohttp.ClientProxyConnectionError:
            return {'error': 'Proxy connection failed'}
        except asyncio.TimeoutError:
            return {'error': 'Request timeout'}

def parse_multiple_urls(request):
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    
    urls = [
        'https://example.com/page1',
        'https://example.com/page2',
        'https://example.com/page3'
    ]
    
    # असिंक्रोनस अनुरोधों को समानांतर में चलाएं
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    
    tasks = [fetch_with_proxy(url, proxy_url) for url in urls]
    results = loop.run_until_complete(asyncio.gather(*tasks))
    
    return {'statusCode': 200, 'results': results}

असिंक्रोनस दृष्टिकोण प्रॉक्सी के माध्यम से 10-100 समानांतर अनुरोध करने की अनुमति देता है, जो Cloud Functions के निष्पादन समय (9 मिनट तक) के भीतर बड़े डेटा वॉल्यूम को खींचने के लिए महत्वपूर्ण है।

SOCKS5 प्रॉक्सी के साथ काम करना

कुछ प्रॉक्सी प्रदाता UDP ट्रैफ़िक के साथ अधिक विश्वसनीयता के लिए SOCKS5 प्रॉक्सी प्रदान करते हैं या ब्लॉकों को बायपास करते हैं। Python में SOCKS5 के साथ काम करने के लिए requests[socks] पुस्तकालय का उपयोग करें:

# requirements.txt में जोड़ें:
# requests[socks]

import requests

def use_socks5_proxy(request):
    proxy_url = f"socks5://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    response = requests.get(
        'https://api.ipify.org?format=json',
        proxies=proxies,
        timeout=10
    )
    
    return {'statusCode': 200, 'ip': response.json()}

Node.js में प्रॉक्सी सेटअप (axios, node-fetch)

Node.js Cloud Functions के लिए दूसरी सबसे लोकप्रिय भाषा है। हम axios और node-fetch के साथ प्रॉक्सी का एकीकरण देखेंगे।

axios के साथ उदाहरण

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

exports.parseWithProxy = async (req, res) => {
  const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
  
  const agent = new HttpsProxyAgent(proxyUrl);
  
  try {
    const response = await axios.get('https://api.example.com/data', {
      httpsAgent: agent,
      timeout: 10000,
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
      }
    });
    
    res.status(200).json({
      success: true,
      data: response.data,
      proxyUsed: proxyUrl.split('@')[1] // पासवर्ड के बिना होस्ट:पोर्ट लौटाएं
    });
    
  } catch (error) {
    if (error.code === 'ECONNREFUSED') {
      res.status(502).json({ error: 'Proxy connection refused' });
    } else if (error.code === 'ETIMEDOUT') {
      res.status(504).json({ error: 'Proxy timeout' });
    } else {
      res.status(500).json({ error: error.message });
    }
  }
};

package.json के लिए निर्भरताएँ:

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

node-fetch और SOCKS5 के साथ उदाहरण

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

exports.fetchWithSocks5 = async (req, res) => {
  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 fetch('https://api.ipify.org?format=json', {
      agent,
      timeout: 10000
    });
    
    const data = await response.json();
    
    res.status(200).json({
      success: true,
      yourIP: data.ip
    });
    
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

SOCKS5 के लिए निर्भरताएँ:

{
  "dependencies": {
    "node-fetch": "^2.7.0",
    "socks-proxy-agent": "^8.0.2"
  }
}

प्रॉक्सी प्रमाणीकरण: लॉगिन/पासवर्ड और IP व्हाइटलिस्ट

प्रॉक्सी के साथ काम करते समय प्रमाणीकरण के दो मुख्य तरीके हैं:

1. लॉगिन और पासवर्ड द्वारा प्रमाणीकरण

सबसे सामान्य तरीका — प्रॉक्सी के URL में क्रेडेंशियल्स भेजना:

http://username:password@proxy.example.com:8080

फायदे: सेटअप में आसानी, स्रोत के IP को स्थिर करने की आवश्यकता नहीं है।

नुकसान: क्रेडेंशियल्स प्रत्येक अनुरोध में भेजे जाते हैं, थोड़ा ओवरहेड।

2. IP व्हाइटलिस्ट द्वारा प्रमाणीकरण

कुछ प्रदाता Cloud Functions के IP पतों को व्हाइटलिस्ट में जोड़ने की अनुमति देते हैं। समस्या: Cloud Functions Google Cloud के पूल से डायनेमिक IP का उपयोग करते हैं।

समाधान: स्थिर बाहरी IP के माध्यम से आउटबाउंड ट्रैफ़िक को रूट करने के लिए Cloud NAT का उपयोग करें:

Google Cloud में VPC नेटवर्क और सबनेट बनाएं
स्थिर IP के साथ Cloud NAT सेट करें
Cloud Functions को VPC कनेक्टर से कनेक्ट करें
प्रॉक्सी प्रदाता में स्थिर IP को व्हाइटलिस्ट में जोड़ें

प्रॉक्सी सेट करने के बाद लॉगिन और पासवर्ड की आवश्यकता नहीं होती:

proxies = {
    'http': 'http://proxy.example.com:8080',
    'https': 'http://proxy.example.com:8080'
}

सिफारिश: अधिकांश मामलों के लिए लॉगिन/पासवर्ड प्रमाणीकरण का उपयोग करें — यह सरल है और Cloud NAT (प्रति घंटा $0.044 + ट्रैफ़िक) पर अतिरिक्त लागत की आवश्यकता नहीं है।

IP रोटेशन और प्रॉक्सी पूल प्रबंधन

बड़े डेटा वॉल्यूम को खींचते समय ब्लॉकों से बचने के लिए IP रोटेशन का उपयोग करना महत्वपूर्ण है। कई दृष्टिकोण हैं:

1. प्रदाता की ओर से रोटेशन (Rotating Proxies)

कई प्रदाता रोटेटिंग प्रॉक्सी प्रदान करते हैं — एकल एंडपॉइंट, जो प्रत्येक अनुरोध पर या टाइमर के अनुसार IP को स्वचालित रूप से बदलता है:

# एक एंडपॉइंट, IP स्वचालित रूप से बदलता है
proxy_url = "http://username:password@rotating.proxy.com:8080"

# प्रत्येक अनुरोध नए IP से जाता है
for i in range(100):
    response = requests.get('https://api.ipify.org', proxies={'http': proxy_url})
    print(f"Request {i}: IP = {response.text}")

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

नुकसान: विशिष्ट IP पर नियंत्रण नहीं है, यह महंगा हो सकता है।

2. प्रॉक्सी पूल को मैन्युअल रूप से प्रबंधित करना

यदि आपके पास स्थिर प्रॉक्सी की सूची है, तो कोड स्तर पर रोटेशन लागू करें:

import random
import requests

# प्रॉक्सी पूल (Secret Manager से लोड किया जा सकता है)
PROXY_POOL = [
    "http://user:pass@proxy1.example.com:8080",
    "http://user:pass@proxy2.example.com:8080",
    "http://user:pass@proxy3.example.com:8080",
]

def get_random_proxy():
    return random.choice(PROXY_POOL)

def parse_with_rotation(urls):
    results = []
    
    for url in urls:
        proxy = get_random_proxy()
        
        try:
            response = requests.get(
                url,
                proxies={'http': proxy, 'https': proxy},
                timeout=10
            )
            results.append({
                'url': url,
                'status': response.status_code,
                'proxy': proxy.split('@')[1]
            })
        except Exception as e:
            # यदि प्रॉक्सी काम नहीं कर रहा है, तो दूसरे को आजमाएं
            proxy = get_random_proxy()
            response = requests.get(url, proxies={'http': proxy, 'https': proxy})
            results.append({'url': url, 'status': response.status_code})
    
    return results

3. सत्र आधारित प्रॉक्सी (स्टिकी सत्र)

उन कार्यों के लिए जहां सत्र के भीतर एक IP को बनाए रखना आवश्यक है (जैसे, वेबसाइट पर प्रमाणीकरण), प्रॉक्सी के URL में सत्र ID का उपयोग करें:

# लॉगिन में सत्र ID जोड़ें
import uuid

session_id = str(uuid.uuid4())
proxy_url = f"http://username-session-{session_id}:password@proxy.example.com:8080"

# सभी अनुरोध इस session_id के साथ एक IP के माध्यम से जाएंगे
session = requests.Session()
session.proxies = {'http': proxy_url, 'https': proxy_url}

# प्रमाणीकरण
session.post('https://example.com/login', data={'user': 'test', 'pass': '123'})

# उसी सत्र में बाद के अनुरोध
session.get('https://example.com/dashboard')

त्रुटियों को संभालना और टाइमआउट

Cloud Functions में प्रॉक्सी के साथ काम करते समय त्रुटियों को सही ढंग से संभालना महत्वपूर्ण है, ताकि डेटा न खोएं और निष्पादन समय की सीमाएँ न बढ़ें।

त्रुटियों के प्रकार और संभालने के तरीके

त्रुटि	कारण	समाधान
ProxyError	प्रॉक्सी अनुपलब्ध है या गलत क्रेडेंशियल्स	पूल से दूसरे प्रॉक्सी पर स्विच करें
Timeout	धीमी प्रॉक्सी या ओवरलोडेड सर्वर	5-10 सेकंड का टाइमआउट सेट करें, दूसरे IP के साथ पुनः प्रयास करें
407 Proxy Authentication Required	गलत लॉगिन/पासवर्ड	पर्यावरण चर में क्रेडेंशियल्स की जांच करें
429 Too Many Requests	लक्षित वेबसाइट पर दर सीमित करना	अनुरोधों के बीच में देरी जोड़ें, अधिक IP का उपयोग करें
403 Forbidden	प्रॉक्सी का IP वेबसाइट द्वारा ब्लॉक किया गया है	IP बदलें, डेटा केंद्र के बजाय रेसिडेंशियल का उपयोग करें

त्रुटियों को संभालने का एक समग्र उदाहरण

import requests
import time
from requests.exceptions import ProxyError, Timeout, RequestException

def fetch_with_retry(url, proxy_pool, max_retries=3):
    """
    त्रुटियों पर स्वचालित पुनः प्रयास और प्रॉक्सी बदलने के साथ अनुरोध
    """
    for attempt in range(max_retries):
        proxy = random.choice(proxy_pool)
        
        try:
            response = requests.get(
                url,
                proxies={'http': proxy, 'https': proxy},
                timeout=10,
                headers={'User-Agent': 'Mozilla/5.0'}
            )
            
            # स्थिति कोड की जांच करें
            if response.status_code == 200:
                return {'success': True, 'data': response.text, 'proxy': proxy}
            elif response.status_code == 429:
                # दर सीमित करना — प्रतीक्षा करें और फिर से प्रयास करें
                time.sleep(2 ** attempt)  # एक्सपोनेंशियल बैकऑफ
                continue
            elif response.status_code == 403:
                # IP ब्लॉक किया गया — प्रॉक्सी बदलें
                continue
            else:
                return {'success': False, 'status': response.status_code}
                
        except ProxyError:
            # प्रॉक्सी काम नहीं कर रही है — अगली कोशिश करें
            print(f"Proxy {proxy} failed, trying another...")
            continue
        except Timeout:
            # टाइमआउट — दूसरे प्रॉक्सी के साथ पुनः प्रयास करें
            print(f"Timeout with {proxy}, retrying...")
            continue
        except RequestException as e:
            # अन्य त्रुटियाँ
            print(f"Request failed: {e}")
            if attempt == max_retries - 1:
                return {'success': False, 'error': str(e)}
            continue
    
    return {'success': False, 'error': 'Max retries exceeded'}

Cloud Functions में टाइमआउट सेट करना

Cloud Functions के पास निष्पादन समय पर प्रतिबंध है (डिफ़ॉल्ट रूप से 60 सेकंड, अधिकतम 540 सेकंड)। प्रॉक्सी टाइमआउट सेट करते समय इसे ध्यान में रखें:

कनेक्शन टाइमआउट — प्रॉक्सी के साथ कनेक्शन स्थापित करने का समय (5 सेकंड की सिफारिश की जाती है)
रीड टाइमआउट — प्रॉक्सी के माध्यम से लक्षित सर्वर से प्रतिक्रिया प्राप्त करने का समय (10-15 सेकंड की सिफारिश की जाती है)
कुल टाइमआउट — पूरे अनुरोध के लिए कुल समय (फंक्शन के टाइमआउट से कम होना चाहिए)

# Python: अलग-अलग टाइमआउट
response = requests.get(
    url,
    proxies=proxies,
    timeout=(5, 15)  # (कनेक्ट टाइमआउट, रीड टाइमआउट)
)

# Node.js के साथ axios
const response = await axios.get(url, {
  httpsAgent: agent,
  timeout: 10000  // कुल टाइमआउट मिलीसेकंड में
});

सर्वश्रेष्ठ प्रथाएँ और प्रदर्शन अनुकूलन

Cloud Functions में प्रॉक्सी के साथ प्रभावी ढंग से काम करने के लिए सिफारिशें:

1. क्रेडेंशियल्स के लिए पर्यावरण चर का उपयोग करें

कभी भी प्रॉक्सी के लॉगिन और पासवर्ड को कोड में न रखें। Secret Manager या पर्यावरण चर का उपयोग करें:

# Google Cloud में सीक्रेट बनाना
gcloud secrets create proxy-credentials \
    --data-file=proxy-config.json

# Cloud Functions को एक्सेस प्रदान करना
gcloud secrets add-iam-policy-binding proxy-credentials \
    --member=serviceAccount:PROJECT_ID@appspot.gserviceaccount.com \
    --role=roles/secretmanager.secretAccessor

# कोड में सीक्रेट पढ़ना
from google.cloud import secretmanager
import json

def get_proxy_config():
    client = secretmanager.SecretManagerServiceClient()
    name = f"projects/{PROJECT_ID}/secrets/proxy-credentials/versions/latest"
    response = client.access_secret_version(request={"name": name})
    return json.loads(response.payload.data.decode('UTF-8'))

2. डेटा खींचने के परिणामों को कैश करें

Cloud Storage या Firestore का उपयोग करके डेटा को कैश करें, ताकि प्रॉक्सी के माध्यम से पुनः अनुरोध न करना पड़े:

import hashlib
from google.cloud import storage

def fetch_with_cache(url, proxy):
    # URL के आधार पर कैश कुंजी उत्पन्न करें
    cache_key = hashlib.md5(url.encode()).hexdigest()
    
    # Cloud Storage में कैश की जाँच करें
    bucket = storage.Client().bucket('my-cache-bucket')
    blob = bucket.blob(f"cache/{cache_key}.json")
    
    if blob.exists():
        # कैश किए गए डेटा लौटाएं
        return json.loads(blob.download_as_text())
    
    # प्रॉक्सी के माध्यम से अनुरोध करें
    response = requests.get(url, proxies={'http': proxy})
    data = response.json()
    
    # कैश में सहेजें
    blob.upload_from_string(json.dumps(data))
    
    return data

3. निगरानी और लॉगिंग

Cloud Logging के माध्यम से प्रॉक्सी के प्रदर्शन और त्रुटियों की आवृत्ति को ट्रैक करें:

import logging
import time

def fetch_with_logging(url, proxy):
    start_time = time.time()
    
    try:
        response = requests.get(url, proxies={'http': proxy}, timeout=10)
        duration = time.time() - start_time
        
        logging.info({
            'url': url,
            'proxy': proxy.split('@')[1],
            'status': response.status_code,
            'duration': duration,
            'success': True
        })
        
        return response
        
    except Exception as e:
        duration = time.time() - start_time
        
        logging.error({
            'url': url,
            'proxy': proxy.split('@')[1],
            'error': str(e),
            'duration': duration,
            'success': False
        })
        
        raise

4. ठंडी शुरुआत का अनुकूलन

Cloud Functions में ठंडी शुरुआत (cold start) में देरी होती है। निर्भरताओं को न्यूनतम करें और पुस्तकालयों के न्यूनतम संस्करणों का उपयोग करें:

# requirements.txt — केवल आवश्यक पुस्तकालय
requests==2.31.0
# यदि वे महत्वपूर्ण नहीं हैं तो भारी पुस्तकालयों जैसे pandas से बचें

कनेक्शनों को पुनः उपयोग करने के लिए वैश्विक चर का उपयोग करें:

# ठंडी शुरुआत पर एक बार सत्र बनाएं
session = requests.Session()
session.proxies = {'http': PROXY_URL, 'https': PROXY_URL}

def parse_data(request):
    # कॉल के बीच सत्र का पुनः उपयोग करें
    response = session.get('https://api.example.com/data')
    return response.json()

5. भौगोलिक रूप से बंधी प्रॉक्सी

भौगोलिक लक्ष्यीकरण वाले कार्यों के लिए (जैसे, क्षेत्रीय कीमतों को खींचना) विशिष्ट देश या शहर के लिए बंधी प्रॉक्सी का उपयोग करें:

# रेसिडेंशियल प्रॉक्सी के साथ उदाहरण, जहां आप लॉगिन में देश निर्दिष्ट कर सकते हैं
proxy_url = f"http://username-country-ru:password@proxy.example.com:8080"

# या विभिन्न देशों के लिए विभिन्न एंडपॉइंट्स का उपयोग करें
PROXIES_BY_COUNTRY = {
    'RU': 'http://user:pass@ru.proxy.example.com:8080',
    'US': 'http://user:pass@us.proxy.example.com:8080',
    'DE': 'http://user:pass@de.proxy.example.com:8080'
}

def parse_by_country(country_code):
    proxy = PROXIES_BY_COUNTRY.get(country_code)
    response = requests.get('https://example.com', proxies={'http': proxy})
    return response.text

निष्कर्ष

Google Cloud Functions के साथ प्रॉक्सी का एकीकरण डेटा खींचने, स्वचालन और API के साथ काम करने के लिए IP पर सीमाओं के बिना व्यापक संभावनाएँ खोलता है। मुख्य बिंदु जो ध्यान में रखने चाहिए: त्रुटियों को संभालने के लिए सही तरीके से पुनः प्रयास करने की लॉजिक, लटकने से रोकने के लिए टाइमआउट का उपयोग, ब्लॉकों से बचने के लिए IP रोटेशन और Secret Manager में क्रेडेंशियल्स को सुरक्षित रूप से संग्रहीत करना।

अधिकांश डेटा खींचने और स्वचालन कार्यों के लिए रेसिडेंशियल प्रॉक्सी सबसे अच्छा विकल्प होगा — वे उच्च गुमनामी और वास्तविक उपयोगकर्ताओं के IP के उपयोग के कारण कम ब्लॉक दर प्रदान करते हैं। सोशल मीडिया और मोबाइल ऐप के साथ काम करने के लिए हम मोबाइल प्रॉक्सी की सिफारिश करते हैं, जिनमें मोबाइल ऑपरेटरों के IP होते हैं और ये Instagram और TikTok जैसी प्लेटफार्मों द्वारा शायद ही कभी ब्लॉक होते हैं।

प्रॉक्सी के साथ Cloud Functions को सही ढंग से सेट करने पर आप बिना बुनियादी ढाँचे के प्रबंधन के बड़े डेटा वॉल्यूम को संसाधित करने के लिए एक स्केलेबल और किफायती समाधान प्राप्त करते हैं।

```

गूगल क्लाउड फंक्शंस के साथ प्रॉक्सी का एकीकरण: पार्सिंग और स्वचालन के लिए सेटअप