सर्वरलेस एप्लिकेशनों में प्रॉक्सी कैसे सेट करें: AWS लैम्ब्डा, वेरसेल, क्लाउडफ्लेयर वर्कर्स

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

सर्वरलेस फ़ंक्शंस को प्रॉक्सी की आवश्यकता क्यों है

सर्वरलेस प्लेटफ़ॉर्म (AWS Lambda, Google Cloud Functions, Vercel, Cloudflare Workers) क्लाउड अवसंरचना में कोड चलाते हैं, डेटा केंद्रों के IP पतों का उपयोग करते हैं। इससे डेवलपर्स के लिए कई महत्वपूर्ण समस्याएँ उत्पन्न होती हैं:

समस्या 1: डेटा केंद्रों के IP द्वारा ब्लॉकिंग। कई सेवाएँ AWS, Google Cloud या Azure के ज्ञात IP पतों से आने वाले अनुरोधों को स्वचालित रूप से ब्लॉक कर देती हैं। उदाहरण के लिए, ई-कॉमर्स साइटों (Amazon, eBay, Wildberries) या सोशल नेटवर्क (Instagram API, TikTok API) से डेटा पार्स करते समय, आपके Lambda फ़ंक्शंस पहले ही अनुरोध पर HTTP 403 या कैप्चा प्राप्त कर सकते हैं। बॉट सुरक्षा प्रणाली (Cloudflare, Akamai, DataDome) तुरंत क्लाउड डेटा केंद्रों से आने वाले ट्रैफ़िक को पहचान लेती हैं।

समस्या 2: IP स्तर पर दर सीमित करना। यदि आप हजारों समवर्ती कॉल के साथ एक सर्वरलेस एप्लिकेशन तैनात कर रहे हैं, तो सभी अनुरोध एक या एक से अधिक AWS IP पतों से आ सकते हैं। बाहरी API जल्दी से सीमाओं तक पहुँच जाते हैं (उदाहरण के लिए, GitHub API — 60 अनुरोध/घंटा एक IP से, Google Maps API — 100 अनुरोध/सेकंड)। भले ही आपके पास API का विस्तारित योजना हो, IP पर सीमाएँ फिर भी लागू होंगी।

समस्या 3: भू-प्रतिबंध। us-east-1 क्षेत्र में सर्वरलेस फ़ंक्शंस रूस, यूरोप या एशिया से केवल उपलब्ध सामग्री तक पहुँच नहीं पाएंगे। यह क्षेत्रीय मार्केटप्लेस (Ozon, Yandex.Market) से डेटा पार्स करते समय, विभिन्न देशों से विज्ञापनों की जांच करते समय या साइटों की स्थानीयकरण का परीक्षण करते समय महत्वपूर्ण है।

समस्या 4: अन्य उपयोगकर्ताओं के साथ साझा IP। सर्वरलेस वातावरण में, आपके फ़ंक्शंस को एक IP पता मिल सकता है, जिसका पहले अन्य क्लाउड प्रदाता के ग्राहकों द्वारा उपयोग किया गया था। यदि किसी ने पहले इस IP का दुरुपयोग किया है (स्पैम, DDoS, पार्सिंग), तो यह काले सूचियों में हो सकता है। आपको बिना किसी गलती के ब्लॉक किया जा सकता है।

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

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

प्रॉक्सी के प्रकार का चयन आपके सर्वरलेस एप्लिकेशन के कार्य पर निर्भर करता है। तीन मुख्य विकल्पों और उनके उपयोग के परिदृश्यों पर विचार करें:

अधिकांश सर्वरलेस एप्लिकेशनों के लिए निवासी प्रॉक्सी का उपयोग करने की सिफारिश की जाती है। वे गति और गोपनीयता के बीच संतुलन प्रदान करते हैं। निवासी IP सामान्य घरेलू उपयोगकर्ताओं के रूप में दिखते हैं, जिससे बॉट सुरक्षा और दर सीमाओं को बिना महत्वपूर्ण विलंबता बढ़ाए बायपास करना संभव होता है।

डेटा केंद्र प्रॉक्सी केवल सरल कार्यों के लिए उपयुक्त हैं (HTTP स्थिति की जांच, बिना सीमाओं के सार्वजनिक API के साथ काम करना)। मोबाइल प्रॉक्सी विशिष्ट मामलों में आवश्यक हैं - जब आप मोबाइल API के साथ काम कर रहे हैं या जब आपको अधिकतम गोपनीयता की आवश्यकता होती है।

AWS Lambda में प्रॉक्सी सेट करना

AWS Lambda सबसे लोकप्रिय सर्वरलेस प्लेटफ़ॉर्म है, और यहां प्रॉक्सी का एकीकरण HTTP-क्लाइंट की सही सेटिंग की आवश्यकता है। Lambda फ़ंक्शंस विभिन्न प्रोग्रामिंग भाषाओं (Node.js, Python, Go) का उपयोग कर सकते हैं, आइए सबसे सामान्य के लिए उदाहरण देखें।

Node.js (axios)

Axios Node.js में HTTP अनुरोधों के लिए सबसे लोकप्रिय पुस्तकालय है। प्रॉक्सी सेट करने के लिए कॉन्फ़िगरेशन में proxy पैरामीटर का उपयोग करें:

const axios = require('axios');

exports.handler = async (event) => {
  const proxyConfig = {
    host: 'proxy.example.com',
    port: 8080,
    auth: {
      username: 'your_username',
      password: 'your_password'
    },
    protocol: 'http'
  };

  try {
    const response = await axios.get('https://api.example.com/data', {
      proxy: proxyConfig,
      timeout: 10000 // 10 सेकंड
    });

    return {
      statusCode: 200,
      body: JSON.stringify(response.data)
    };
  } catch (error) {
    console.error('Proxy error:', error.message);
    return {
      statusCode: 500,
      body: JSON.stringify({ error: error.message })
    };
  }
};

महत्वपूर्ण बिंदु: प्रॉक्सी क्रेडेंशियल्स को AWS Systems Manager Parameter Store या AWS Secrets Manager में स्टोर करें, न कि कोड में। यह सुरक्षा सुनिश्चित करेगा और प्रॉक्सी को बिना फ़ंक्शन को फिर से बनाने के आसानी से बदलने की अनुमति देगा।

Python (requests)

Python में प्रॉक्सी के साथ काम करने के लिए requests पुस्तकालय का उपयोग किया जाता है, जिसमें proxies पैरामीटर होता है:

import requests
import json

def lambda_handler(event, context):
    proxies = {
        'http': 'http://username:password@proxy.example.com:8080',
        'https': 'http://username:password@proxy.example.com:8080'
    }
    
    try:
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10
        )
        
        return {
            'statusCode': 200,
            'body': json.dumps(response.json())
        }
    except requests.exceptions.RequestException as e:
        print(f'Proxy error: {str(e)}')
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }

SOCKS5 प्रॉक्सी (अधिक सुरक्षित प्रोटोकॉल) के लिए Python में अतिरिक्त पुस्तकालय requests[socks] स्थापित करना आवश्यक है और URL प्रारूप को बदलना होगा:

proxies = {
    'http': 'socks5://username:password@proxy.example.com:1080',
    'https': 'socks5://username:password@proxy.example.com:1080'
}

ठंडी शुरुआत के लिए अनुकूलन

Lambda फ़ंक्शंस को ठंडी शुरुआत की समस्या होती है - ठहराव के बाद पहला अनुरोध 1-3 सेकंड लेता है। प्रॉक्सी का उपयोग करते समय यह समय बढ़ जाता है। विलंबता को न्यूनतम करने के लिए, हैंडलर फ़ंक्शन के बाहर HTTP-क्लाइंट बनाएं:

const axios = require('axios');

// कंटेनर के आरंभ में एक बार क्लाइंट बनाएं
const httpClient = axios.create({
  proxy: {
    host: 'proxy.example.com',
    port: 8080,
    auth: {
      username: process.env.PROXY_USER,
      password: process.env.PROXY_PASS
    }
  },
  timeout: 10000
});

exports.handler = async (event) => {
  // प्रत्येक कॉल पर क्लाइंट का पुन: उपयोग करें
  const response = await httpClient.get('https://api.example.com/data');
  return {
    statusCode: 200,
    body: JSON.stringify(response.data)
  };
};

यह दृष्टिकोण ठंडी शुरुआत के समय को 200-500 मि.सेकंड तक कम करता है, क्योंकि प्रॉक्सी कॉन्फ़िगरेशन केवल एक बार Lambda कंटेनर बनाने के समय किया जाता है।

Vercel Edge फ़ंक्शंस में प्रॉक्सी का एकीकरण

Vercel दो प्रकार के सर्वरलेस फ़ंक्शंस प्रदान करता है: Node.js फ़ंक्शंस (Lambda के समान) और Edge फ़ंक्शंस (CDN पर चलाए जाते हैं)। Edge फ़ंक्शंस Cloudflare Workers के करीब के रनटाइम में काम करते हैं, Node.js API के उपयोग पर सीमाएँ होती हैं। दोनों विकल्पों पर विचार करें।

Vercel Node.js फ़ंक्शंस

सामान्य Vercel फ़ंक्शंस के लिए वही दृष्टिकोण अपनाएँ जो AWS Lambda के लिए है। एक फ़ाइल बनाएं api/fetch-data.js:

import axios from 'axios';

export default async function handler(req, res) {
  const proxyConfig = {
    host: process.env.PROXY_HOST,
    port: parseInt(process.env.PROXY_PORT),
    auth: {
      username: process.env.PROXY_USER,
      password: process.env.PROXY_PASS
    }
  };

  try {
    const response = await axios.get(req.query.url, {
      proxy: proxyConfig,
      timeout: 8000
    });

    res.status(200).json(response.data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
}

Vercel डैशबोर्ड (Settings → Environment Variables) में पर्यावरण चर जोड़ें: PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS।

Vercel Edge फ़ंक्शंस

Edge फ़ंक्शंस Web Fetch API का उपयोग करते हैं, Node.js पुस्तकालयों के बजाय। प्रॉक्सी को कस्टम हेडर या मिडलवेयर के माध्यम से सेट किया जाता है:

export const config = {
  runtime: 'edge',
};

export default async function handler(req) {
  const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
  
  // Edge Runtime के लिए प्रॉक्सी के साथ fetch के लिए एजेंट की आवश्यकता होती है (पॉलीफिल की आवश्यकता होती है)
  // विकल्प: सीधे प्रॉक्सी API का उपयोग करें
  const targetUrl = new URL(req.url).searchParams.get('target');
  
  const response = await fetch(targetUrl, {
    headers: {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
  });

  return new Response(await response.text(), {
    status: response.status,
    headers: response.headers
  });
}

महत्वपूर्ण सीमा: Edge Runtime मानक Node.js प्रॉक्सी एजेंटों का समर्थन नहीं करता है। प्रॉक्सी के साथ पूर्ण कार्यक्षमता के लिए Node.js फ़ंक्शंस का उपयोग करना या एक अलग सर्वर पर एक मध्यवर्ती प्रॉक्सी सर्वर बनाना अनुशंसित है, जो Edge फ़ंक्शंस से अनुरोध प्राप्त करेगा।

Cloudflare Workers में प्रॉक्सी

Cloudflare Workers V8 आइसोलेट्स में काम करते हैं और Vercel Edge फ़ंक्शंस की तुलना में और भी अधिक सख्त सीमाएँ होती हैं। यहाँ Node.js पुस्तकालयों के माध्यम से प्रॉक्सी को जोड़ने का मानक तरीका काम नहीं करता है। दो कार्यशील दृष्टिकोण हैं:

विधि 1: HTTP CONNECT टनलिंग

उस प्रॉक्सी का उपयोग करें जो HTTP CONNECT विधि का समर्थन करता है। प्रॉक्सी सर्वर के माध्यम से एक टनल बनाएं:

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const proxyUrl = 'http://proxy.example.com:8080';
  const targetUrl = 'https://api.example.com/data';
  
  const proxyAuth = btoa(`${PROXY_USER}:${PROXY_PASS}`);
  
  const response = await fetch(proxyUrl, {
    method: 'CONNECT',
    headers: {
      'Host': new URL(targetUrl).host,
      'Proxy-Authorization': `Basic ${proxyAuth}`
    }
  });

  if (response.status === 200) {
    // टनल स्थापित हो गया है, मुख्य अनुरोध करें
    const finalResponse = await fetch(targetUrl, {
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
      }
    });
    
    return finalResponse;
  }
  
  return new Response('Proxy connection failed', { status: 502 });
}

यह विधि केवल HTTP प्रॉक्सी के साथ काम करती है जो CONNECT का समर्थन करते हैं। अधिकांश निवासी प्रॉक्सी प्रदाता यह सुविधा प्रदान करते हैं।

विधि 2: प्रॉक्सी गेटवे (अनुशंसित)

एक अधिक विश्वसनीय तरीका है कि एक अलग सर्वर (जैसे VPS या AWS EC2) पर एक मध्यवर्ती प्रॉक्सी गेटवे तैनात करें। Cloudflare Worker आपके गेटवे पर अनुरोध भेजता है, और वह फिर प्रॉक्सी के माध्यम से उन्हें अग्रेषित करता है:

// Cloudflare Worker
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const targetUrl = new URL(request.url).searchParams.get('url');
  const gatewayUrl = 'https://your-proxy-gateway.com/fetch';
  
  const response = await fetch(gatewayUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': API_KEY // आपके गेटवे की सुरक्षा
    },
    body: JSON.stringify({
      url: targetUrl,
      method: 'GET'
    })
  });

  return response;
}

प्रॉक्सी गेटवे के पक्ष में (Node.js सर्वर):

const express = require('express');
const axios = require('axios');

const app = express();
app.use(express.json());

const proxyConfig = {
  host: 'proxy.example.com',
  port: 8080,
  auth: {
    username: process.env.PROXY_USER,
    password: process.env.PROXY_PASS
  }
};

app.post('/fetch', async (req, res) => {
  if (req.headers['x-api-key'] !== process.env.API_KEY) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  try {
    const response = await axios({
      url: req.body.url,
      method: req.body.method || 'GET',
      proxy: proxyConfig,
      timeout: 10000
    });

    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000);

यह दृष्टिकोण एक अतिरिक्त हॉप जोड़ता है (50-100 मि.सेकंड की विलंबता बढ़ाता है), लेकिन प्रॉक्सी कनेक्शन पर पूर्ण संगतता और नियंत्रण सुनिश्चित करता है।

सर्वरलेस वातावरण में IP पतों का रोटेशन

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

प्रॉक्सी प्रदाता की ओर से स्वचालित रोटेशन

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

// एक एंडपॉइंट, IP स्वचालित रूप से बदलता है
const proxyConfig = {
  host: 'rotating.proxy.example.com',
  port: 8080,
  auth: {
    username: 'user-session-' + Date.now(), // अद्वितीय सत्र
    password: 'password'
  }
};

कुछ प्रदाता उपयोगकर्ता नाम में पैरामीटर के माध्यम से रोटेशन को प्रबंधित करने की अनुमति देते हैं: user-session-random (प्रत्येक अनुरोध पर नया IP), user-session-sticky-300 (300 सेकंड के लिए एक IP)।

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

यदि आपके पास स्थिर प्रॉक्सी की सूची है (उदाहरण के लिए, आपने समर्पित प्रॉक्सी खरीदी है), तो आप एप्लिकेशन स्तर पर रोटेशन लागू कर सकते हैं। सर्वरलेस वातावरण में, स्थिति संग्रहीत करने के लिए DynamoDB (AWS) या KV स्टोरेज (Cloudflare) का उपयोग करें:

const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();

const PROXY_POOL = [
  { host: 'proxy1.example.com', port: 8080 },
  { host: 'proxy2.example.com', port: 8080 },
  { host: 'proxy3.example.com', port: 8080 }
];

async function getNextProxy() {
  // DynamoDB से वर्तमान अनुक्रमांक प्राप्त करें
  const result = await dynamodb.get({
    TableName: 'ProxyRotation',
    Key: { id: 'current_index' }
  }).promise();

  const currentIndex = result.Item?.index || 0;
  const nextIndex = (currentIndex + 1) % PROXY_POOL.length;

  // अनुक्रमांक अपडेट करें
  await dynamodb.put({
    TableName: 'ProxyRotation',
    Item: { id: 'current_index', index: nextIndex }
  }).promise();

  return PROXY_POOL[currentIndex];
}

exports.handler = async (event) => {
  const proxy = await getNextProxy();
  
  const response = await axios.get('https://api.example.com/data', {
    proxy: {
      ...proxy,
      auth: {
        username: process.env.PROXY_USER,
        password: process.env.PROXY_PASS
      }
    }
  });

  return { statusCode: 200, body: JSON.stringify(response.data) };
};

यह विधि रोटेशन पर पूर्ण नियंत्रण देती है, लेकिन DynamoDB के लिए अतिरिक्त अनुरोधों की आवश्यकता होती है (10-30 मि.सेकंड की विलंबता जोड़ती है)। उच्च लोड वाले एप्लिकेशनों के लिए, Lambda कंटेनर में अनुक्रमांक को कैश करने और इसे 100-1000 अनुरोधों में एक बार अपडेट करने की सिफारिश की जाती है।

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

प्रॉक्सी आपके सर्वरलेस एप्लिकेशन में एक अतिरिक्त विफलता बिंदु जोड़ते हैं। यह महत्वपूर्ण है कि त्रुटियों को सही ढंग से संभाला जाए ताकि उपयोगकर्ताओं के अनुरोधों को न खोया जाए।

प्रॉक्सी के साथ काम करते समय सामान्य त्रुटियाँ

फॉलबैक के साथ पुनः प्रयास लॉजिक का कार्यान्वयन

त्रुटियों के समय स्वचालित पुनः प्रयास जोड़ें और बैकअप प्रॉक्सी पर स्विच करें:

const axios = require('axios');

const PRIMARY_PROXY = {
  host: 'primary.proxy.com',
  port: 8080,
  auth: { username: 'user', password: 'pass' }
};

const FALLBACK_PROXY = {
  host: 'fallback.proxy.com',
  port: 8080,
  auth: { username: 'user', password: 'pass' }
};

async function fetchWithRetry(url, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const proxy = attempt === 0 ? PRIMARY_PROXY : FALLBACK_PROXY;
    
    try {
      const response = await axios.get(url, {
        proxy,
        timeout: 8000
      });
      
      return response.data;
    } catch (error) {
      console.log(`Attempt ${attempt + 1} failed:`, error.message);
      
      // क्लाइंट त्रुटियों (4xx) पर पुनः प्रयास नहीं करें
      if (error.response && error.response.status < 500) {
        throw error;
      }
      
      // अंतिम प्रयास — त्रुटि को फेंकें
      if (attempt === maxRetries - 1) {
        throw error;
      }
      
      // पुनः प्रयास से पहले एक्सपोनेंशियल विलंब
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
    }
  }
}

exports.handler = async (event) => {
  try {
    const data = await fetchWithRetry('https://api.example.com/data');
    return { statusCode: 200, body: JSON.stringify(data) };
  } catch (error) {
    return { statusCode: 500, body: JSON.stringify({ error: error.message }) };
  }
};

यह कार्यान्वयन अनुरोध के लिए तीन प्रयास देता है: पहला प्राथमिक प्रॉक्सी के माध्यम से, अन्य बैकअप के माध्यम से। प्रयासों के बीच एक्सपोनेंशियल विलंब (1 सेकंड, 2 सेकंड, 4 सेकंड) जोड़ा गया है ताकि अतिरिक्त लोड न बने।

निगरानी और अलर्ट

प्रॉक्सी त्रुटियों की निगरानी के लिए CloudWatch (AWS), Vercel Analytics या Sentry का उपयोग करें। निम्नलिखित मीट्रिक पर नज़र रखें:

• प्रॉक्सी के माध्यम से सफल अनुरोधों का प्रतिशत (95% से अधिक होना चाहिए)
• अनुरोधों की औसत विलंबता (वृद्धि प्रॉक्सी के साथ समस्याओं का संकेत दे सकती है)
• टाइमआउट त्रुटियों की संख्या (यदि >5% — प्रॉक्सी ओवरलोड या धीमा है)
• कोड के अनुसार त्रुटियों का वितरण (407, 502, ETIMEDOUT आदि)

थ्रेशोल्ड को पार करने पर अलर्ट सेट करें — इससे आपको बैकअप प्रॉक्सी प्रदाता पर जल्दी स्विच करने या कॉन्फ़िगरेशन बदलने की अनुमति मिलेगी।

निष्कर्ष

सर्वरलेस एप्लिकेशनों में प्रॉक्सी का एकीकरण महत्वपूर्ण समस्याओं को हल करता है: डेटा केंद्रों के IP द्वारा ब्लॉकिंग, दर सीमित करना और भू-प्रतिबंध। हमने AWS Lambda (Node.js और Python), Vercel फ़ंक्शंस और Cloudflare Workers में प्रॉक्सी सेट करने, IP पतों के रोटेशन और त्रुटियों को संभालने की प्रक्रिया पर विचार किया।

मुख्य सिफारिशें: उच्च गोपनीयता की आवश्यकता वाले कार्यों के लिए निवासी प्रॉक्सी का उपयोग करें (पार्सिंग, सोशल मीडिया API के साथ काम करना), क्रेडेंशियल्स को सुरक्षित स्टोरेज (AWS Secrets Manager, Vercel Environment Variables) में स्टोर करें, बैकअप प्रॉक्सी पर स्विच करने के लिए पुनः प्रयास लॉजिक लागू करें और त्रुटियों की निगरानी सेट करें।

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