كيفية إعداد بروكسي لـ GraphQL API: تدوير IP وتجاوز قيود المعدل مع أمثلة على الكود

أصبحت واجهات برمجة التطبيقات GraphQL أكثر شيوعًا، ولكن مع ذلك تزداد القيود: تحديد المعدل، حظر IP، الفلاتر الجغرافية. إذا كنت تعمل مع كميات كبيرة من البيانات عبر GraphQL - تقوم بجمع بيانات من منصات التجارة الإلكترونية، تجمع التحليلات من وسائل التواصل الاجتماعي أو تختبر واجهة برمجة التطبيقات - فلن تتمكن من الاستغناء عن البروكسي. في هذه المقالة، سنناقش كيفية إعداد البروكسي بشكل صحيح لطلبات GraphQL، وتنفيذ تدوير IP وتجنب الحظر.

سنقدم أمثلة عملية على Python وNode.js، وسنناقش الأخطاء الشائعة وسنقدم توصيات لاختيار نوع البروكسي لمهام مختلفة.

لماذا تحتاج بروكسي لطلبات GraphQL

تُستخدم واجهات برمجة التطبيقات GraphQL غالبًا للحصول على كميات كبيرة من البيانات في وقت قصير. على عكس واجهات برمجة التطبيقات REST، حيث يتم تقسيم البيانات عبر العديد من نقاط النهاية، يسمح GraphQL بطلب كل ما تحتاجه في طلب واحد. هذا مريح، ولكنه يخلق مشاكل:

• تحديد المعدل - معظم واجهات برمجة التطبيقات العامة لGraphQL تحد من عدد الطلبات من IP واحد (على سبيل المثال، واجهة برمجة التطبيقات GitHub: 5000 طلب في الساعة، Shopify: طلبان في الثانية)
• حظر IP - عند تجاوز الحدود أو النشاط المشبوه، قد يتم حظر IP الخاص بك لعدة ساعات أو إلى الأبد
• قيود جغرافية - بعض واجهات برمجة التطبيقات متاحة فقط من دول معينة (على سبيل المثال، الأسواق المحلية أو الخدمات الإقليمية)
• حماية من التجريف - تتعقب الخوادم أنماط الطلبات وتقوم بحظر IPs المشبوهة

تحل البروكسي هذه المشاكل، مما يسمح بتوزيع الطلبات عبر العديد من عناوين IP، وتقليد الطلبات من مناطق مختلفة وتجاوز الحظر. هذا مهم بشكل خاص عند العمل مع:

• تجريف البيانات من منصات التجارة الإلكترونية (Shopify، WooCommerce GraphQL API)
• جمع التحليلات من وسائل التواصل الاجتماعي (Facebook Graph API، Instagram API)
• مراقبة الأسعار وتوافر المنتجات
• اختبار واجهات برمجة التطبيقات من مواقع جغرافية مختلفة
• أتمتة جمع البيانات للتحليلات والأبحاث

أي نوع من البروكسي يجب اختياره للعمل مع GraphQL

يعتمد اختيار نوع البروكسي على المهمة ومتطلبات واجهة برمجة التطبيقات. دعنا نستعرض ثلاثة أنواع رئيسية وتطبيقاتها لطلبات GraphQL:

توصيات للاختيار:

• لواجهات برمجة التطبيقات العامة (GitHub، OpenWeather) - يكفي بروكسي مراكز البيانات، فهي سريعة وغير مكلفة
• للتجارة الإلكترونية (Shopify، WooCommerce) - بروكسي سكنية، حيث تقوم هذه المنصات بتصفية مراكز البيانات بنشاط
• لوسائل التواصل الاجتماعي (Facebook Graph API، Instagram) - بروكسي موبايل أو سكنية ضرورية
• للتجريف الجماعي - مزيج: مراكز البيانات للحركة الأساسية + سكنية للتدوير عند الحظر

إعداد البروكسي في Python لGraphQL (requests، httpx، gql)

Python هو واحد من أكثر اللغات شعبية للعمل مع واجهات برمجة التطبيقات. دعنا نستعرض ثلاث طرق لإعداد البروكسي لطلبات 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 أيضًا على نطاق واسع للعمل مع واجهات برمجة التطبيقات 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:', 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:', error);
});

تنفيذ تدوير البروكسي لتجاوز تحديد المعدل

تدوير البروكسي هو تقنية رئيسية لتجاوز قيود واجهة برمجة التطبيقات. بدلاً من إرسال جميع الطلبات من 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 الصحيحة ضرورية لنجاح العمل مع واجهات برمجة التطبيقات GraphQL عبر البروكسي. تتحقق العديد من واجهات برمجة التطبيقات ليس فقط من IP، ولكن أيضًا من رؤوس الطلب.

الرؤوس الإلزامية لGraphQL

headers = {
    # نوع المحتوى - دائمًا application/json لGraphQL
    'Content-Type': 'application/json',
    
    # التفويض (يعتمد على واجهة برمجة التطبيقات)
    '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، مثل 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، مثل Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML، مثل Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML، مثل 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، مثل 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 عبر البروكسي

دعونا نلخص ونقدم توصيات للعمل الفعال مع واجهات برمجة التطبيقات GraphQL عبر البروكسي:

الهيكل الموصى به للمشاريع الكبيرة

إذا كنت تعمل مع كميات كبيرة من البيانات، نوصي بالهيكل التالي:

1. طابور المهام (Redis، RabbitMQ) - لتوزيع الطلبات بين العمال
2. مجموعة العمال - يستخدم كل عامل بروكسي خاص به
3. مدير البروكسي - يتتبع حالة البروكسيات ويوزعها بين العمال
4. قاعدة البيانات - لتخزين النتائج وحالة المهام
5. المراقبة - تتبع الأخطاء، السرعة، استخدام البروكسيات

الخاتمة

العمل مع واجهات برمجة التطبيقات GraphQL عبر البروكسي ليس مجرد إضافة معلمة proxies في الطلب. للعمل بشكل موثوق وفعال، يجب تنفيذ تدوير البروكسي، معالجة الأخطاء بشكل صحيح، إعداد الرؤوس والالتزام بحدود واجهة برمجة التطبيقات. لقد استعرضنا أمثلة عملية على Python وNode.js يمكن استخدامها مباشرة في مشاريعك.

الاستنتاجات الرئيسية: استخدم بروكسي سكنية لواجهات برمجة التطبيقات المحمية (Shopify، Facebook)، ومراكز البيانات لواجهات برمجة التطبيقات العامة والتجريف الجماعي، نفذ تدويرًا تلقائيًا مع استبعاد البروكسيات غير العاملة، أضف تأخيرات وتعامل مع جميع أنواع الأخطاء. سيسمح لك ذلك بالعمل بشكل مستقر مع أي واجهة برمجة تطبيقات GraphQL دون حظر.

إذا كنت تخطط للعمل مع واجهات برمجة التطبيقات GraphQL في الإنتاج، نوصي باستخدام بروكسي سكنية - فهي توفر أقصى استقرار وأقل خطر للحظر. للاختبار والتطوير، يمكن استخدام بروكسي مراكز البيانات - فهي أسرع وأرخص.