چگونه پروکسی را برای API گراف‌کیوال تنظیم کنیم: چرخش IP و دور زدن محدودیت نرخ با مثال‌های کد

API های GraphQL روز به روز محبوب‌تر می‌شوند، اما به موازات آن محدودیت‌ها نیز افزایش می‌یابند: محدودیت نرخ، مسدودسازی بر اساس IP، فیلترهای جغرافیایی. اگر شما با حجم بالایی از داده‌ها از طریق GraphQL کار می‌کنید — از سایت‌های تجارت الکترونیک داده‌برداری می‌کنید، تجزیه و تحلیل از شبکه‌های اجتماعی جمع‌آوری می‌کنید یا API را آزمایش می‌کنید — بدون پروکسی نمی‌توانید کار کنید. در این مقاله بررسی خواهیم کرد که چگونه پروکسی را به درستی برای درخواست‌های GraphQL تنظیم کنیم، چرخش IP را پیاده‌سازی کنیم و از مسدودسازی‌ها جلوگیری کنیم.

ما نمونه‌های عملی را با Python و Node.js نشان خواهیم داد، اشتباهات رایج را بررسی خواهیم کرد و توصیه‌هایی برای انتخاب نوع پروکسی برای وظایف مختلف ارائه خواهیم داد.

چرا به پروکسی برای درخواست‌های GraphQL نیاز داریم

API های GraphQL اغلب برای دریافت حجم بالایی از داده‌ها در زمان کوتاه استفاده می‌شوند. بر خلاف API های REST که داده‌ها در چندین نقطه پایانی تقسیم شده‌اند، GraphQL اجازه می‌دهد همه چیز را با یک درخواست بپرسید. این بسیار راحت است، اما مشکلاتی را ایجاد می‌کند:

• محدودیت نرخ — اکثر API های عمومی GraphQL تعداد درخواست‌ها از یک IP را محدود می‌کنند (به عنوان مثال، API گیت‌هاب: 5000 درخواست در ساعت، Shopify: 2 درخواست در ثانیه)
• مسدودسازی IP — در صورت تجاوز از محدودیت‌ها یا فعالیت مشکوک، IP شما ممکن است برای چند ساعت یا به طور دائمی مسدود شود
• محدودیت‌های جغرافیایی — برخی API ها فقط از کشورهای خاص قابل دسترسی هستند (به عنوان مثال، بازارهای محلی یا خدمات منطقه‌ای)
• محافظت در برابر داده‌برداری — سرورها الگوهای درخواست را ردیابی کرده و IP های مشکوک را مسدود می‌کنند

پروکسی این مشکلات را حل می‌کند و اجازه می‌دهد درخواست‌ها را از طریق چندین آدرس IP توزیع کنید، درخواست‌ها را از مناطق مختلف شبیه‌سازی کنید و از مسدودسازی‌ها دور بزنید. این به ویژه در کار با:

• داده‌برداری از پلتفرم‌های تجارت الکترونیک (API GraphQL Shopify، WooCommerce)
• جمع‌آوری تجزیه و تحلیل از شبکه‌های اجتماعی (API Graph Facebook، API Instagram)
• نظارت بر قیمت‌ها و موجودی کالاها
• آزمایش API از مکان‌های جغرافیایی مختلف
• خودکارسازی جمع‌آوری داده‌ها برای تجزیه و تحلیل و تحقیقات

کدام نوع پروکسی را برای کار با GraphQL انتخاب کنیم

انتخاب نوع پروکسی بستگی به وظیفه و الزامات API دارد. سه نوع اصلی و کاربردهای آن‌ها برای درخواست‌های GraphQL را بررسی می‌کنیم:

توصیه‌ها برای انتخاب:

• برای API های عمومی (GitHub، OpenWeather) — پروکسی‌های دیتاسنتر کافی هستند، آن‌ها سریع و ارزان هستند
• برای تجارت الکترونیک (Shopify، WooCommerce) — پروکسی‌های مسکونی، زیرا این پلتفرم‌ها به شدت دیتاسنترها را فیلتر می‌کنند
• برای شبکه‌های اجتماعی (API Graph Facebook، Instagram) — پروکسی‌های موبایلی یا مسکونی الزامی هستند
• برای داده‌برداری انبوه — ترکیبی: دیتاسنترها برای ترافیک اصلی + مسکونی‌ها برای چرخش در صورت مسدودسازی

تنظیم پروکسی در Python برای GraphQL (requests, httpx, gql)

Python یکی از محبوب‌ترین زبان‌ها برای کار با API است. سه روش تنظیم پروکسی برای درخواست‌های GraphQL را بررسی می‌کنیم.

گزینه 1: کتابخانه requests (کلاینت HTTP ساده)

ساده‌ترین روش — استفاده از کتابخانه استاندارد requests. مناسب برای درخواست‌های پایه GraphQL بدون منطق پیچیده.

import requests
import json

# تنظیم پروکسی
proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080'
}

# درخواست GraphQL
query = """
query {
  products(first: 10) {
    edges {
      node {
        id
        title
        priceRange {
          minVariantPrice {
            amount
          }
        }
      }
    }
  }
}
"""

# ارسال درخواست از طریق پروکسی
url = "https://your-shop.myshopify.com/api/2024-01/graphql.json"
headers = {
    'Content-Type': 'application/json',
    'X-Shopify-Storefront-Access-Token': 'your_token_here',
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

response = requests.post(
    url,
    json={'query': query},
    headers=headers,
    proxies=proxies,
    timeout=30
)

data = response.json()
print(json.dumps(data, indent=2))

گزینه 2: کتابخانه httpx (درخواست‌های غیرهمزمان)

اگر نیاز به ارسال چندین درخواست به صورت همزمان دارید، از httpx با پشتیبانی از async/await استفاده کنید:

import httpx
import asyncio
import json

async def fetch_graphql(query, proxy_url):
    url = "https://api.example.com/graphql"
    headers = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_TOKEN',
        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)'
    }
    
    # تنظیم پروکسی برای httpx
    proxies = {
        "http://": proxy_url,
        "https://": proxy_url
    }
    
    async with httpx.AsyncClient(proxies=proxies, timeout=30.0) as client:
        response = await client.post(
            url,
            json={'query': query},
            headers=headers
        )
        return response.json()

# استفاده
query = """
query {
  viewer {
    login
    repositories(first: 5) {
      nodes {
        name
        stargazerCount
      }
    }
  }
}
"""

proxy = "http://user:pass@proxy.example.com:8080"
result = asyncio.run(fetch_graphql(query, proxy))
print(json.dumps(result, indent=2))

گزینه 3: کتابخانه gql (کلاینت تخصصی GraphQL)

برای کار پیشرفته با GraphQL از کتابخانه gql استفاده کنید — این کتابخانه از اعتبارسنجی طرح، کش کردن و کار راحت با درخواست‌ها پشتیبانی می‌کند:

from gql import gql, Client
from gql.transport.requests import RequestsHTTPTransport

# تنظیم حمل و نقل با پروکسی
transport = RequestsHTTPTransport(
    url='https://api.example.com/graphql',
    headers={
        'Authorization': 'Bearer YOUR_TOKEN',
        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64)'
    },
    proxies={
        'http': 'http://user:pass@proxy.example.com:8080',
        'https': 'http://user:pass@proxy.example.com:8080'
    },
    timeout=30
)

# ایجاد کلاینت
client = Client(transport=transport, fetch_schema_from_transport=True)

# درخواست GraphQL
query = gql("""
    query GetProducts($first: Int!) {
        products(first: $first) {
            edges {
                node {
                    id
                    title
                    variants(first: 1) {
                        edges {
                            node {
                                price
                            }
                        }
                    }
                }
            }
        }
    }
""")

# اجرای درخواست
result = client.execute(query, variable_values={"first": 20})
print(result)

تنظیم پروکسی در Node.js برای GraphQL (axios, apollo-client)

Node.js نیز به طور گسترده‌ای برای کار با API های GraphQL استفاده می‌شود. دو روش اصلی را بررسی می‌کنیم.

گزینه 1: Axios با پروکسی

کلاینت HTTP ساده و انعطاف‌پذیر با پشتیبانی از پروکسی:

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

// تنظیم پروکسی
const proxyUrl = 'http://username:password@proxy.example.com:8080';
const httpsAgent = new HttpsProxyAgent(proxyUrl);

// درخواست GraphQL
const query = `
  query {
    products(first: 10) {
      edges {
        node {
          id
          title
          priceRange {
            minVariantPrice {
              amount
            }
          }
        }
      }
    }
  }
`;

// ارسال درخواست
axios.post('https://your-shop.myshopify.com/api/2024-01/graphql.json', 
  { query },
  {
    headers: {
      'Content-Type': 'application/json',
      'X-Shopify-Storefront-Access-Token': 'your_token_here',
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
    },
    httpsAgent: httpsAgent,
    timeout: 30000
  }
)
.then(response => {
  console.log(JSON.stringify(response.data, null, 2));
})
.catch(error => {
  console.error('خطا:', error.message);
});

گزینه 2: Apollo Client با پروکسی

Apollo Client — محبوب‌ترین کلاینت GraphQL برای Node.js و مرورگر. تنظیم پروکسی از طریق fetch سفارشی:

const { ApolloClient, InMemoryCache, HttpLink, gql } = require('@apollo/client');
const fetch = require('cross-fetch');
const HttpsProxyAgent = require('https-proxy-agent');

// پروکسی ایجنت
const proxyUrl = 'http://user:pass@proxy.example.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);

// fetch سفارشی با پروکسی
const customFetch = (uri, options) => {
  return fetch(uri, {
    ...options,
    agent: agent
  });
};

// ایجاد Apollo Client
const client = new ApolloClient({
  link: new HttpLink({
    uri: 'https://api.example.com/graphql',
    fetch: customFetch,
    headers: {
      'Authorization': 'Bearer YOUR_TOKEN',
      'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)'
    }
  }),
  cache: new InMemoryCache()
});

// درخواست GraphQL
const GET_REPOS = gql`
  query GetRepositories($login: String!) {
    user(login: $login) {
      repositories(first: 5) {
        nodes {
          name
          stargazerCount
        }
      }
    }
  }
`;

// اجرای درخواست
client.query({
  query: GET_REPOS,
  variables: { login: 'facebook' }
})
.then(result => {
  console.log(JSON.stringify(result.data, null, 2));
})
.catch(error => {
  console.error('خطا:', error);
});

پیاده‌سازی چرخش پروکسی برای دور زدن محدودیت نرخ

چرخش پروکسی — تکنیک کلیدی برای دور زدن محدودیت‌های API است. به جای ارسال همه درخواست‌ها از یک IP، آن‌ها را بین چندین پروکسی توزیع می‌کنید. این اجازه می‌دهد که محدودیت نرخ را دور بزنید و از مسدودسازی‌ها جلوگیری کنید.

چرخش ساده در Python

پیاده‌سازی پایه چرخش با سوئیچینگ چرخه‌ای پروکسی:

import requests
import itertools
import time

# لیست پروکسی‌ها
PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
    'http://user:pass@proxy4.example.com:8080',
]

# ایجاد یک ایتراکتور بی‌پایان
proxy_pool = itertools.cycle(PROXY_LIST)

def make_graphql_request(query):
    """ارسال درخواست GraphQL با چرخش پروکسی"""
    proxy = next(proxy_pool)
    proxies = {'http': proxy, 'https': proxy}
    
    url = "https://api.example.com/graphql"
    headers = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_TOKEN',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
    }
    
    try:
        response = requests.post(
            url,
            json={'query': query},
            headers=headers,
            proxies=proxies,
            timeout=30
        )
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"خطا با پروکسی {proxy}: {e}")
        # سوئیچ به پروکسی بعدی
        return make_graphql_request(query)

# مثال استفاده
queries = [
    'query { products(first: 10) { edges { node { id title } } } }',
    'query { collections(first: 5) { edges { node { id title } } } }',
    'query { shop { name email } }'
]

for query in queries:
    result = make_graphql_request(query)
    print(result)
    time.sleep(1)  # وقفه بین درخواست‌ها

چرخش هوشمند با ردیابی خطاها

نسخه پیشرفته‌تر که پروکسی‌های غیرعملکردی را ردیابی کرده و به طور خودکار آن‌ها را از استخر حذف می‌کند:

import requests
import random
from collections import defaultdict
import time

class ProxyRotator:
    def __init__(self, proxy_list, max_failures=3):
        self.proxy_list = proxy_list.copy()
        self.max_failures = max_failures
        self.failures = defaultdict(int)
        self.active_proxies = proxy_list.copy()
    
    def get_proxy(self):
        """دریافت یک پروکسی فعال تصادفی"""
        if not self.active_proxies:
            raise Exception("تمام پروکسی‌ها غیرقابل دسترسی هستند!")
        return random.choice(self.active_proxies)
    
    def mark_failure(self, proxy):
        """علامت‌گذاری یک تلاش ناموفق"""
        self.failures[proxy] += 1
        if self.failures[proxy] >= self.max_failures:
            print(f"پروکسی {proxy} از استخر حذف شد (حداکثر خطاها تجاوز شد)")
            if proxy in self.active_proxies:
                self.active_proxies.remove(proxy)
    
    def mark_success(self, proxy):
        """صفر کردن شمارنده خطاها در صورت موفقیت"""
        self.failures[proxy] = 0

# راه‌اندازی
proxies = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
]

rotator = ProxyRotator(proxies)

def graphql_request_with_retry(query, max_retries=3):
    """درخواست GraphQL با تلاش‌های خودکار مجدد"""
    for attempt in range(max_retries):
        proxy = rotator.get_proxy()
        proxies_dict = {'http': proxy, 'https': proxy}
        
        try:
            response = requests.post(
                'https://api.example.com/graphql',
                json={'query': query},
                headers={
                    'Content-Type': 'application/json',
                    'Authorization': 'Bearer TOKEN',
                    'User-Agent': 'Mozilla/5.0'
                },
                proxies=proxies_dict,
                timeout=30
            )
            response.raise_for_status()
            
            # موفقیت — صفر کردن شمارنده خطاها
            rotator.mark_success(proxy)
            return response.json()
            
        except Exception as e:
            print(f"تلاش {attempt + 1}/{max_retries} با {proxy} ناموفق بود: {e}")
            rotator.mark_failure(proxy)
            time.sleep(2)  # وقفه قبل از تکرار
    
    raise Exception("پس از تمام تلاش‌ها، درخواست انجام نشد")

# استفاده
query = 'query { products(first: 10) { edges { node { id title } } } }'
result = graphql_request_with_retry(query)
print(result)

تنظیم هدرها و User-Agent برای درخواست‌های GraphQL

هدرهای HTTP صحیح برای کار موفق با API های GraphQL از طریق پروکسی بسیار مهم هستند. بسیاری از API ها نه تنها IP بلکه هدرهای درخواست را نیز بررسی می‌کنند.

هدرهای الزامی برای GraphQL

headers = {
    # نوع محتوا — همیشه application/json برای GraphQL
    'Content-Type': 'application/json',
    
    # اعتبارسنجی (بسته به API)
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
    # یا
    'X-Shopify-Storefront-Access-Token': 'token_here',
    
    # User-Agent — شبیه‌سازی مرورگر واقعی
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    
    # Accept — مشخص کردن اینکه JSON را قبول می‌کنیم
    'Accept': 'application/json',
    
    # Accept-Language — زبان کاربر
    'Accept-Language': 'en-US,en;q=0.9',
    
    # Accept-Encoding — پشتیبانی از فشرده‌سازی
    'Accept-Encoding': 'gzip, deflate, br',
    
    # Referer — از کجا درخواست آمده است (اختیاری)
    'Referer': 'https://example.com/',
    
    # Origin — برای درخواست‌های CORS
    'Origin': 'https://example.com'
}

چرخش User-Agent

برای ناشناس بودن بیشتر، توصیه می‌شود User-Agent را به همراه پروکسی بچرخانید:

import random

USER_AGENTS = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15'
]

def get_random_headers(token):
    """تولید هدرهای تصادفی"""
    return {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {token}',
        'User-Agent': random.choice(USER_AGENTS),
        'Accept': 'application/json',
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept-Encoding': 'gzip, deflate, br'
    }

مدیریت خطاها و تلاش‌های مجدد از طریق پروکسی

هنگام کار با پروکسی، خطاها اجتناب‌ناپذیر هستند: زمان‌های تایم‌اوت، پروکسی‌های غیرقابل دسترسی، مسدودسازی‌ها. مهم است که این وضعیت‌ها را به درستی مدیریت کنید و مکانیزم تلاش‌های مجدد را پیاده‌سازی کنید.

خطاهای رایج GraphQL از طریق پروکسی

• زمان‌های تایم‌اوت — پروکسی کند یا شلوغ است (زمان تایم‌اوت را به 30-60 ثانیه افزایش دهید)
• HTTP 407 نیاز به احراز هویت پروکسی — نام کاربری/گذرواژه نادرست پروکسی
• HTTP 429 درخواست‌های بیش از حد — محدودیت نرخ تجاوز شده است (نیاز به چرخش پروکسی)
• HTTP 403 ممنوع — IP پروکسی مسدود شده است (نوع پروکسی را به مسکونی تغییر دهید)
• اتصال رد شد — پروکسی در دسترس نیست (از استخر حذف کنید)

مدیریت پیشرفته خطاها

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

def graphql_request_robust(query, proxy, max_retries=3, backoff=2):
    """
    درخواست GraphQL قابل اعتماد با مدیریت تمام انواع خطاها
    
    Args:
        query: درخواست GraphQL
        proxy: URL پروکسی
        max_retries: حداکثر تلاش‌ها
        backoff: ضریب تأخیر بین تلاش‌ها
    """
    url = "https://api.example.com/graphql"
    headers = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer TOKEN',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
    }
    proxies = {'http': proxy, 'https': proxy}
    
    for attempt in range(max_retries):
        try:
            response = requests.post(
                url,
                json={'query': query},
                headers=headers,
                proxies=proxies,
                timeout=30
            )
            
            # بررسی محدودیت نرخ
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 60))
                print(f"محدودیت نرخ! انتظار {retry_after} ثانیه...")
                time.sleep(retry_after)
                continue
            
            # بررسی مسدودسازی IP
            if response.status_code == 403:
                print(f"IP {proxy} مسدود شده است! نیاز به پروکسی دیگری است.")
                raise Exception("IP مسدود شده است")
            
            # بررسی خطاهای احراز هویت پروکسی
            if response.status_code == 407:
                print(f"خطای احراز هویت پروکسی {proxy}")
                raise Exception("احراز هویت پروکسی ناموفق")
            
            response.raise_for_status()
            
            # بررسی خطاهای GraphQL
            data = response.json()
            if 'errors' in data:
                print(f"خطاهای GraphQL: {data['errors']}")
                # برخی خطاها را می‌توان تکرار کرد، برخی دیگر نه
                if is_retryable_graphql_error(data['errors']):
                    time.sleep(backoff * (attempt + 1))
                    continue
                else:
                    raise Exception(f"خطای GraphQL: {data['errors']}")
            
            return data
            
        except (ProxyError, ConnectionError) as e:
            print(f"تلاش {attempt + 1}: پروکسی در دسترس نیست - {e}")
            time.sleep(backoff * (attempt + 1))
            
        except Timeout as e:
            print(f"تلاش {attempt + 1}: زمان تایم‌اوت - {e}")
            time.sleep(backoff * (attempt + 1))
            
        except requests.exceptions.HTTPError as e:
            print(f"تلاش {attempt + 1}: خطای HTTP - {e}")
            if attempt < max_retries - 1:
                time.sleep(backoff * (attempt + 1))
            else:
                raise
    
    raise Exception(f"پس از {max_retries} تلاش، درخواست انجام نشد")

def is_retryable_graphql_error(errors):
    """تعیین می‌کند که آیا می‌توان درخواست را در صورت خطای GraphQL تکرار کرد یا نه"""
    retryable_codes = ['THROTTLED', 'INTERNAL_ERROR', 'TIMEOUT']
    for error in errors:
        if error.get('extensions', {}).get('code') in retryable_codes:
            return True
    return False

بهترین شیوه‌ها برای کار با GraphQL از طریق پروکسی

بیایید جمع‌بندی کنیم و توصیه‌هایی برای کار مؤثر با API های GraphQL از طریق پروکسی ارائه دهیم:

معماری پیشنهادی برای پروژه‌های مقیاس‌پذیر

اگر با حجم بالایی از داده‌ها کار می‌کنید، معماری زیر را توصیه می‌کنیم:

1. صف وظایف (Redis، RabbitMQ) — برای توزیع درخواست‌ها بین کارگران
2. استخر کارگران — هر کارگر از پروکسی خود استفاده می‌کند
3. مدیر پروکسی — وضعیت پروکسی‌ها را ردیابی کرده و آن‌ها را بین کارگران توزیع می‌کند
4. پایگاه داده — برای ذخیره نتایج و وضعیت وظایف
5. نظارت — ردیابی خطاها، سرعت، استفاده از پروکسی

نتیجه‌گیری

کار با API های GraphQL از طریق پروکسی تنها اضافه کردن پارامتر proxies به درخواست نیست. برای کار قابل اعتماد و مؤثر، باید چرخش پروکسی، مدیریت صحیح خطاها، تنظیم هدرها و رعایت محدودیت‌های API را پیاده‌سازی کنید. ما نمونه‌های عملی را با Python و Node.js بررسی کردیم که می‌توانید به راحتی در پروژه‌های خود استفاده کنید.

نکات اصلی: از پروکسی‌های مسکونی برای API های محافظت‌شده (Shopify، Facebook) استفاده کنید، دیتاسنترها را برای API های عمومی و داده‌برداری انبوه انتخاب کنید، چرخش خودکار با حذف پروکسی‌های غیرعملکردی را پیاده‌سازی کنید، تأخیر اضافه کنید و تمام انواع خطاها را مدیریت کنید. این کار به شما اجازه می‌دهد با هر API GraphQL بدون مسدودسازی به طور پایدار کار کنید.

اگر قصد دارید با API های GraphQL در تولید کار کنید، توصیه می‌کنیم از پروکسی‌های مسکونی استفاده کنید — آن‌ها حداکثر ثبات و حداقل خطر مسدودسازی را فراهم می‌کنند. برای آزمایش و توسعه، پروکسی‌های دیتاسنتر مناسب هستند — آن‌ها سریع‌تر و ارزان‌تر هستند.