GraphQL API için Proxy Nasıl Ayarlanır: IP Rotasyonu ve Rate Limiting Aşma Örnek Kodları ile

GraphQL API'leri giderek daha popüler hale geliyor, ancak bununla birlikte sınırlamalar da artıyor: rate limiting, IP engellemeleri, coğrafi filtreler. Eğer GraphQL üzerinden büyük veri hacimleriyle çalışıyorsanız — e-ticaret platformlarını parse ediyorsanız, sosyal medya analitiği topluyorsanız veya API'leri test ediyorsanız — proxy olmadan yapamazsınız. Bu yazıda, GraphQL istekleri için proxy'nin nasıl doğru bir şekilde ayarlanacağını, IP dönüşümünü nasıl gerçekleştireceğinizi ve engellemelerden nasıl kaçınacağınızı inceleyeceğiz.

Python ve Node.js üzerinde pratik örnekler göstereceğiz, yaygın hataları inceleyeceğiz ve farklı görevler için proxy türü seçimi konusunda önerilerde bulunacağız.

GraphQL istekleri için proxy'ye neden ihtiyaç var

GraphQL API'leri genellikle kısa sürede büyük veri hacimleri elde etmek için kullanılır. REST API'lerinden farklı olarak, veriler birçok uç noktaya bölünmüşken, GraphQL gerekli olan her şeyi tek bir istekle talep etmenizi sağlar. Bu kullanışlıdır, ancak sorunlar yaratır:

• Rate limiting — çoğu kamuya açık GraphQL API'si bir IP'den gelen istek sayısını sınırlar (örneğin, GitHub API: saatte 5000 istek, Shopify: saniyede 2 istek)
• IP engellemeleri — limitlerin aşılması veya şüpheli aktiviteler durumunda IP'niz birkaç saat veya sonsuza dek engellenebilir
• Coğrafi kısıtlamalar — bazı API'ler yalnızca belirli ülkelerden erişilebilir (örneğin, yerel pazar yerleri veya bölgesel hizmetler)
• Parsing koruması — sunucular isteklerin kalıplarını izler ve şüpheli IP'leri engeller

Proxy'ler bu sorunları çözer, istekleri birçok IP adresi üzerinden dağıtarak, farklı bölgelerden gelen istekleri taklit ederek ve engellemeleri aşarak çalışmanıza olanak tanır. Bu, özellikle aşağıdaki durumlarda önemlidir:

• E-ticaret platformlarından veri parse etme (Shopify, WooCommerce GraphQL API)
• Sosyal medya analitiği toplama (Facebook Graph API, Instagram API)
• Fiyat ve ürün mevcudiyetini izleme
• Farklı coğrafi konumlardan API test etme
• Analiz ve araştırmalar için veri toplama otomasyonu

GraphQL ile çalışmak için hangi proxy türünü seçmelisiniz

Proxy türü seçimi, görev ve API gereksinimlerine bağlıdır. GraphQL istekleri için üç ana türü ve bunların kullanımını inceleyelim:

Seçim önerileri:

• Kamuya açık API'ler için (GitHub, OpenWeather) — veri merkezi proxy'leri yeterlidir, hızlı ve ucuzdur
• E-ticaret için (Shopify, WooCommerce) — konut proxy'leri, çünkü bu platformlar veri merkezi proxy'lerini aktif olarak filtreler
• Sosyal medya için (Facebook Graph API, Instagram) — mobil veya konut proxy'leri zorunludur
• Toplu parse işlemleri için — kombinasyon: ana trafik için veri merkezleri + engellemelerde dönüşüm için konut proxy'leri

GraphQL için Python'da proxy ayarı (requests, httpx, gql)

Python, API'lerle çalışmak için en popüler dillerden biridir. GraphQL istekleri için proxy ayarlamanın üç yolunu inceleyelim.

Seçenek 1: requests kütüphanesi (basit HTTP istemcisi)

En basit yol, standart requests kütüphanesini kullanmaktır. Karmaşık mantık gerektirmeyen temel GraphQL istekleri için uygundur.

import requests
import json

# Proxy ayarı
proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080'
}

# GraphQL isteği
query = """
query {
  products(first: 10) {
    edges {
      node {
        id
        title
        priceRange {
          minVariantPrice {
            amount
          }
        }
      }
    }
  }
}
"""

# Proxy üzerinden istek gönderme
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))

Seçenek 2: httpx kütüphanesi (asenkron istekler)

Eğer birçok isteği paralel olarak göndermeniz gerekiyorsa, httpx kütüphanesini async/await desteği ile kullanın:

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 için proxy ayarı
    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()

# Kullanım
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))

Seçenek 3: gql kütüphanesi (özel GraphQL istemcisi)

GraphQL ile ileri düzey çalışmak için gql kütüphanesini kullanın — şemaların doğrulanmasını, önbellekleme ve isteklerle kolay çalışmayı destekler:

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

# Proxy ile taşıma ayarı
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
)

# İstemci oluşturma
client = Client(transport=transport, fetch_schema_from_transport=True)

# GraphQL isteği
query = gql("""
    query GetProducts($first: Int!) {
        products(first: $first) {
            edges {
                node {
                    id
                    title
                    variants(first: 1) {
                        edges {
                            node {
                                price
                            }
                        }
                    }
                }
            }
        }
    }
""")

# İsteği yürütme
result = client.execute(query, variable_values={"first": 20})
print(result)

GraphQL için Node.js'te proxy ayarı (axios, apollo-client)

Node.js, GraphQL API'leri ile çalışmak için de yaygın olarak kullanılmaktadır. İki ana yaklaşımı inceleyelim.

Seçenek 1: Proxy ile Axios

Proxy desteği ile basit ve esnek bir HTTP istemcisi:

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

// Proxy ayarı
const proxyUrl = 'http://username:password@proxy.example.com:8080';
const httpsAgent = new HttpsProxyAgent(proxyUrl);

// GraphQL isteği
const query = `
  query {
    products(first: 10) {
      edges {
        node {
          id
          title
          priceRange {
            minVariantPrice {
              amount
            }
          }
        }
      }
    }
  }
`;

// İsteği gönderme
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('Hata:', error.message);
});

Seçenek 2: Proxy ile Apollo Client

Apollo Client, Node.js ve tarayıcı için en popüler GraphQL istemcisidir. Özel fetch ile proxy ayarı:

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

// Proxy ajanı
const proxyUrl = 'http://user:pass@proxy.example.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);

// Proxy ile özel fetch
const customFetch = (uri, options) => {
  return fetch(uri, {
    ...options,
    agent: agent
  });
};

// Apollo Client oluşturma
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 isteği
const GET_REPOS = gql`
  query GetRepositories($login: String!) {
    user(login: $login) {
      repositories(first: 5) {
        nodes {
          name
          stargazerCount
        }
      }
    }
  }
`;

// İsteği yürütme
client.query({
  query: GET_REPOS,
  variables: { login: 'facebook' }
})
.then(result => {
  console.log(JSON.stringify(result.data, null, 2));
})
.catch(error => {
  console.error('Hata:', error);
});

Rate limiting aşmak için proxy dönüşümünün uygulanması

Proxy dönüşümü, API sınırlamalarını aşmak için anahtar bir tekniktir. Tüm istekleri tek bir IP üzerinden göndermek yerine, bunları birçok proxy arasında dağıtırsınız. Bu, rate limiting'i aşmanıza ve engellemelerden kaçınmanıza olanak tanır.

Python'da basit dönüşüm

Dönüşümün temel bir uygulaması, proxy'leri döngüsel olarak değiştirmektir:

import requests
import itertools
import time

# Proxy listesi
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',
]

# Sonsuz bir iteratör oluşturma
proxy_pool = itertools.cycle(PROXY_LIST)

def make_graphql_request(query):
    """Dönüşümlü proxy ile GraphQL isteği gönderme"""
    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} ile hata: {e}")
        # Bir sonraki proxy'ye geçiyoruz
        return make_graphql_request(query)

# Kullanım örneği
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)  # İstekler arasında bekleme süresi

Hataları izleyen akıllı dönüşüm

Çalışmayan proxy'leri izleyen ve otomatik olarak havuzdan çıkaran daha gelişmiş bir versiyon:

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):
        """Rastgele bir aktif proxy al"""
        if not self.active_proxies:
            raise Exception("Tüm proxy'ler erişilemez!")
        return random.choice(self.active_proxies)
    
    def mark_failure(self, proxy):
        """Başarısız denemeyi işaretle"""
        self.failures[proxy] += 1
        if self.failures[proxy] >= self.max_failures:
            print(f"{proxy} havuzdan çıkarıldı (hata limiti aşıldı)")
            if proxy in self.active_proxies:
                self.active_proxies.remove(proxy)
    
    def mark_success(self, proxy):
        """Başarı durumunda hata sayacını sıfırla"""
        self.failures[proxy] = 0

# Başlatma
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):
    """Otomatik tekrarlarla GraphQL isteği"""
    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()
            
            # Başarı — hata sayacını sıfırla
            rotator.mark_success(proxy)
            return response.json()
            
        except Exception as e:
            print(f"{proxy} ile {attempt + 1}/{max_retries} denemesi başarısız: {e}")
            rotator.mark_failure(proxy)
            time.sleep(2)  # Tekrar denemeden önce bekleme süresi
    
    raise Exception("Tüm denemelerden sonra isteği gerçekleştiremedim")

# Kullanım
query = 'query { products(first: 10) { edges { node { id title } } } }'
result = graphql_request_with_retry(query)
print(result)

GraphQL istekleri için başlıklar ve User-Agent ayarları

Doğru HTTP başlıkları, proxy üzerinden GraphQL API'leri ile başarılı bir şekilde çalışmak için kritik öneme sahiptir. Birçok API, yalnızca IP'yi değil, aynı zamanda istek başlıklarını da kontrol eder.

GraphQL için zorunlu başlıklar

headers = {
    # İçerik türü — her zaman application/json olmalıdır
    'Content-Type': 'application/json',
    
    # Yetkilendirme (API'ye bağlıdır)
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
    # veya
    'X-Shopify-Storefront-Access-Token': 'token_here',
    
    # User-Agent — gerçek bir tarayıcıyı taklit et
    '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 kabul ettiğimizi belirtin
    'Accept': 'application/json',
    
    # Accept-Language — kullanıcı dili
    'Accept-Language': 'en-US,en;q=0.9',
    
    # Accept-Encoding — sıkıştırma desteği
    'Accept-Encoding': 'gzip, deflate, br',
    
    # Referer — isteğin geldiği yer (isteğe bağlı)
    'Referer': 'https://example.com/',
    
    # Origin — CORS istekleri için
    'Origin': 'https://example.com'
}

User-Agent dönüşümü

Daha fazla anonimlik için User-Agent'ı proxy ile birlikte döndürmek önerilir:

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):
    """Rastgele başlıklar oluşturma"""
    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'
    }

Proxy üzerinden hata işleme ve tekrar denemeler

Proxy ile çalışırken hatalar kaçınılmazdır: zaman aşımı, erişilemeyen proxy'ler, engellemeler. Bu durumları doğru bir şekilde işlemek ve tekrar deneme mekanizması uygulamak önemlidir.

Proxy üzerinden GraphQL için yaygın hatalar

• Zaman aşımı — proxy yavaş veya aşırı yüklenmiş (timeout'u 30-60 saniye artırın)
• HTTP 407 Proxy Authentication Required — proxy için yanlış kullanıcı adı/parola
• HTTP 429 Too Many Requests — rate limit aşıldı (proxy dönüşümü gerekli)
• HTTP 403 Forbidden — proxy IP'si engellendi (proxy türünü konut proxy'leri ile değiştirin)
• Connection refused — proxy erişilemez (havuzdan çıkarın)

Gelişmiş hata işleme

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

def graphql_request_robust(query, proxy, max_retries=3, backoff=2):
    """
    Tüm hata türlerini işleyen güvenilir GraphQL isteği
    
    Args:
        query: GraphQL isteği
        proxy: Proxy URL'si
        max_retries: maksimum deneme sayısı
        backoff: denemeler arasındaki gecikme çarpanı
    """
    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
            )
            
            # Rate limiting kontrolü
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 60))
                print(f"Rate limit! {retry_after} saniye bekleniyor...")
                time.sleep(retry_after)
                continue
            
            # IP engelleme kontrolü
            if response.status_code == 403:
                print(f"{proxy} IP'si engellendi! Başka bir proxy gerekli.")
                raise Exception("IP engellendi")
            
            # Proxy yetkilendirme hatası kontrolü
            if response.status_code == 407:
                print(f"{proxy} proxy yetkilendirme hatası")
                raise Exception("Proxy yetkilendirme başarısız")
            
            response.raise_for_status()
            
            # GraphQL hataları kontrolü
            data = response.json()
            if 'errors' in data:
                print(f"GraphQL hataları: {data['errors']}")
                # Bazı hatalar tekrar edilebilir, bazıları ise değil
                if is_retryable_graphql_error(data['errors']):
                    time.sleep(backoff * (attempt + 1))
                    continue
                else:
                    raise Exception(f"GraphQL hatası: {data['errors']}")
            
            return data
            
        except (ProxyError, ConnectionError) as e:
            print(f"{attempt + 1}. deneme: Proxy erişilemez - {e}")
            time.sleep(backoff * (attempt + 1))
            
        except Timeout as e:
            print(f"{attempt + 1}. deneme: Zaman aşımı - {e}")
            time.sleep(backoff * (attempt + 1))
            
        except requests.exceptions.HTTPError as e:
            print(f"{attempt + 1}. deneme: HTTP hatası - {e}")
            if attempt < max_retries - 1:
                time.sleep(backoff * (attempt + 1))
            else:
                raise
    
    raise Exception(f"Tüm denemelerden sonra isteği gerçekleştiremedim")

def is_retryable_graphql_error(errors):
    """GraphQL hatası durumunda isteğin tekrar edilip edilemeyeceğini belirler"""
    retryable_codes = ['THROTTLED', 'INTERNAL_ERROR', 'TIMEOUT']
    for error in errors:
        if error.get('extensions', {}).get('code') in retryable_codes:
            return True
    return False

Proxy üzerinden GraphQL ile çalışmanın en iyi uygulamaları

GraphQL API'leri ile proxy üzerinden etkili bir şekilde çalışmak için önerilerimizi özetleyelim:

Büyük projeler için önerilen mimari

Eğer büyük veri hacimleri ile çalışıyorsanız, aşağıdaki mimariyi öneririz:

1. Görev kuyruğu (Redis, RabbitMQ) — istekleri işçiler arasında dağıtmak için
2. İşçi havuzu — her işçi kendi proxy'sini kullanır
3. Proxy yöneticisi — proxy'lerin durumunu izler ve bunları işçiler arasında dağıtır
4. Veritabanı — sonuçları ve görev durumunu saklamak için
5. İzleme — hataları, hızı, proxy kullanımını izleme

Sonuç

GraphQL API'leri ile proxy üzerinden çalışmak, yalnızca isteğe proxies parametresi eklemekten ibaret değildir. Güvenilir ve etkili bir çalışma için proxy dönüşümünü, doğru hata işlemesini, başlık ayarlarını ve API limitlerine uyumu sağlamanız gerekir. Python ve Node.js üzerinde hemen projelerinizde kullanabileceğiniz pratik örnekleri inceledik.

Temel çıkarımlar: korunan API'ler için konut proxy'leri kullanın (Shopify, Facebook), kamuya açık API'ler ve toplu parse işlemleri için veri merkezi proxy'leri kullanın, çalışmayan proxy'leri hariç tutarak otomatik dönüşüm uygulayın, gecikmeler ekleyin ve tüm hata türlerini işleyin. Bu, herhangi bir GraphQL API ile engellemeler olmadan istikrarlı bir şekilde çalışmanıza olanak tanır.

Eğer GraphQL API'leri ile üretim ortamında çalışmayı planlıyorsanız, konut proxy'lerini kullanmanızı öneririz — bunlar maksimum istikrar ve minimum engellenme riski sağlar. Test ve geliştirme için veri merkezi proxy'leri yeterlidir — bunlar daha hızlı ve daha ucuzdur.