So richten Sie einen Proxy für die GraphQL-API ein: IP-Rotation und Umgehung von Rate Limiting mit Codebeispielen

GraphQL APIs werden immer beliebter, aber damit steigen auch die Einschränkungen: Rate-Limiting, IP-Sperren, geografische Filter. Wenn Sie mit großen Datenmengen über GraphQL arbeiten – E-Commerce-Plattformen scrapen, Analysen aus sozialen Netzwerken sammeln oder APIs testen – kommen Sie nicht ohne Proxys aus. In diesem Artikel werden wir besprechen, wie man Proxys für GraphQL-Anfragen richtig einrichtet, IP-Rotation implementiert und Sperren vermeidet.

Wir zeigen praktische Beispiele in Python und Node.js, besprechen typische Fehler und geben Empfehlungen zur Auswahl des Proxytyps für verschiedene Aufgaben.

Warum Proxys für GraphQL-Anfragen benötigt werden

GraphQL APIs werden häufig verwendet, um große Datenmengen in kurzer Zeit abzurufen. Im Gegensatz zu REST APIs, bei denen die Daten auf viele Endpunkte verteilt sind, ermöglicht GraphQL, alles Notwendige in einer einzigen Anfrage abzufragen. Das ist praktisch, bringt jedoch Probleme mit sich:

• Rate-Limiting – die meisten öffentlichen GraphQL APIs begrenzen die Anzahl der Anfragen von einer IP (z.B. GitHub API: 5000 Anfragen pro Stunde, Shopify: 2 Anfragen pro Sekunde)
• IP-Sperren – bei Überschreitung der Limits oder verdächtiger Aktivitäten kann Ihre IP für mehrere Stunden oder dauerhaft gesperrt werden
• Geografische Einschränkungen – einige APIs sind nur aus bestimmten Ländern zugänglich (z.B. lokale Marktplätze oder regionale Dienste)
• Schutz vor Scraping – Server überwachen die Anfrage-Muster und sperren verdächtige IPs

Proxys lösen diese Probleme, indem sie es ermöglichen, Anfragen über viele IP-Adressen zu verteilen, Anfragen aus verschiedenen Regionen zu simulieren und Sperren zu umgehen. Dies ist besonders wichtig bei der Arbeit mit:

• Scraping von Daten von E-Commerce-Plattformen (Shopify, WooCommerce GraphQL API)
• Sammeln von Analysen aus sozialen Netzwerken (Facebook Graph API, Instagram API)
• Überwachung von Preisen und Verfügbarkeit von Produkten
• Testen von APIs aus verschiedenen geografischen Standorten
• Automatisierung der Datensammlung für Analysen und Forschung

Welchen Proxytyp für die Arbeit mit GraphQL wählen

Die Wahl des Proxytyps hängt von der Aufgabe und den Anforderungen der API ab. Lassen Sie uns drei Haupttypen und deren Anwendung für GraphQL-Anfragen besprechen:

Empfehlungen zur Auswahl:

• Für öffentliche APIs (GitHub, OpenWeather) – Rechenzentrums-Proxys sind ausreichend, sie sind schnell und kostengünstig
• Für E-Commerce (Shopify, WooCommerce) – Residential Proxys, da diese Plattformen aktiv Rechenzentren filtern
• Für soziale Netzwerke (Facebook Graph API, Instagram) – mobile oder Residential Proxys sind erforderlich
• Für massives Scraping – Kombination: Rechenzentren für den Hauptverkehr + Residential Proxys für die Rotation bei Sperren

Proxy in Python für GraphQL einrichten (requests, httpx, gql)

Python ist eine der beliebtesten Sprachen für die Arbeit mit APIs. Lassen Sie uns drei Möglichkeiten zur Einrichtung von Proxys für GraphQL-Anfragen betrachten.

Option 1: Bibliothek requests (einfacher HTTP-Client)

Der einfachste Weg ist die Verwendung der Standardbibliothek requests. Geeignet für grundlegende GraphQL-Anfragen ohne komplexe Logik.

import requests
import json

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

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

# Anfrage über Proxy senden
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))

Option 2: Bibliothek httpx (asynchrone Anfragen)

Wenn Sie viele Anfragen parallel senden müssen, verwenden Sie httpx mit Unterstützung für 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)'
    }
    
    # Proxy für httpx einrichten
    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()

# Verwendung
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))

Option 3: Bibliothek gql (spezialisierter GraphQL-Client)

Für fortgeschrittene Arbeiten mit GraphQL verwenden Sie die Bibliothek gql – sie unterstützt Schema-Validierung, Caching und eine bequeme Arbeit mit Anfragen:

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

# Transport mit Proxy einrichten
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 erstellen
client = Client(transport=transport, fetch_schema_from_transport=True)

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

# Anfrage ausführen
result = client.execute(query, variable_values={"first": 20})
print(result)

Proxy in Node.js für GraphQL einrichten (axios, apollo-client)

Node.js wird ebenfalls häufig für die Arbeit mit GraphQL APIs verwendet. Lassen Sie uns zwei Hauptansätze betrachten.

Option 1: Axios mit Proxy

Ein einfacher und flexibler HTTP-Client mit Unterstützung für Proxys:

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

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

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

// Anfrage senden
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('Fehler:', error.message);
});

Option 2: Apollo Client mit Proxy

Apollo Client ist der beliebteste GraphQL-Client für Node.js und den Browser. Proxy über einen benutzerdefinierten Fetch einrichten:

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

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

// Benutzerdefinierter Fetch mit Proxy
const customFetch = (uri, options) => {
  return fetch(uri, {
    ...options,
    agent: agent
  });
};

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

// Anfrage ausführen
client.query({
  query: GET_REPOS,
  variables: { login: 'facebook' }
})
.then(result => {
  console.log(JSON.stringify(result.data, null, 2));
})
.catch(error => {
  console.error('Fehler:', error);
});

Implementierung der Proxy-Rotation zur Umgehung von Rate-Limiting

Die Rotation von Proxys ist eine Schlüsseltechnik zur Umgehung von API-Einschränkungen. Anstatt alle Anfragen von einer IP zu senden, verteilen Sie diese auf viele Proxys. Dies ermöglicht es, Rate-Limiting zu umgehen und Sperren zu vermeiden.

Einfache Rotation in Python

Grundlegende Implementierung der Rotation mit zyklischem Wechsel der Proxys:

import requests
import itertools
import time

# Liste der Proxys
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',
]

# Erstellen Sie einen unendlichen Iterator
proxy_pool = itertools.cycle(PROXY_LIST)

def make_graphql_request(query):
    """GraphQL-Anfrage mit Proxy-Rotation senden"""
    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"Fehler mit Proxy {proxy}: {e}")
        # Wechseln Sie zum nächsten Proxy
        return make_graphql_request(query)

# Beispielverwendung
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)  # Pause zwischen den Anfragen

Intelligente Rotation mit Fehlerverfolgung

Eine fortgeschrittenere Version, die nicht funktionierende Proxys verfolgt und automatisch aus dem Pool ausschließt:

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):
        """Einen zufälligen aktiven Proxy abrufen"""
        if not self.active_proxies:
            raise Exception("Alle Proxys sind nicht verfügbar!")
        return random.choice(self.active_proxies)
    
    def mark_failure(self, proxy):
        """Fehlgeschlagene Versuche markieren"""
        self.failures[proxy] += 1
        if self.failures[proxy] >= self.max_failures:
            print(f"Proxy {proxy} aus dem Pool ausgeschlossen (Fehlerlimit überschritten)")
            if proxy in self.active_proxies:
                self.active_proxies.remove(proxy)
    
    def mark_success(self, proxy):
        """Fehlerzähler bei Erfolg zurücksetzen"""
        self.failures[proxy] = 0

# Initialisierung
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-Anfrage mit automatischen Wiederholungen"""
    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()
            
            # Erfolg – Fehlerzähler zurücksetzen
            rotator.mark_success(proxy)
            return response.json()
            
        except Exception as e:
            print(f"Versuch {attempt + 1}/{max_retries} mit {proxy} fehlgeschlagen: {e}")
            rotator.mark_failure(proxy)
            time.sleep(2)  # Pause vor dem Wiederholen
    
    raise Exception("Anfrage konnte nach allen Versuchen nicht ausgeführt werden")

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

Einrichtung von Headern und User-Agent für GraphQL-Anfragen

Die richtigen HTTP-Header sind entscheidend für die erfolgreiche Arbeit mit GraphQL APIs über Proxys. Viele APIs überprüfen nicht nur die IP, sondern auch die Anfrage-Header.

Obligatorische Header für GraphQL

headers = {
    # Inhaltstyp – immer application/json für GraphQL
    'Content-Type': 'application/json',
    
    # Autorisierung (abhängig von der API)
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
    # oder
    'X-Shopify-Storefront-Access-Token': 'token_here',
    
    # User-Agent – simulieren Sie einen echten Browser
    '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 – geben Sie an, dass Sie JSON akzeptieren
    'Accept': 'application/json',
    
    # Accept-Language – Sprache des Benutzers
    'Accept-Language': 'en-US,en;q=0.9',
    
    # Accept-Encoding – Unterstützung für Kompression
    'Accept-Encoding': 'gzip, deflate, br',
    
    # Referer – woher die Anfrage kam (optional)
    'Referer': 'https://example.com/',
    
    # Origin – für CORS-Anfragen
    'Origin': 'https://example.com'
}

Rotation des User-Agent

Für mehr Anonymität wird empfohlen, den User-Agent zusammen mit den Proxys zu rotieren:

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):
    """Zufällige Header generieren"""
    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'
    }

Fehlerbehandlung und Wiederholungsversuche über Proxys

Bei der Arbeit mit Proxys sind Fehler unvermeidlich: Zeitüberschreitungen, nicht verfügbare Proxys, Sperren. Es ist wichtig, diese Situationen richtig zu behandeln und einen Mechanismus für Wiederholungsversuche zu implementieren.

Typische Fehler bei GraphQL über Proxys

• Zeitüberschreitungen – Proxy ist langsam oder überlastet (erhöhen Sie den Timeout auf 30-60 Sekunden)
• HTTP 407 Proxy-Authentifizierung erforderlich – falscher Benutzername/Passwort für den Proxy
• HTTP 429 Zu viele Anfragen – Rate-Limit überschritten (Proxy-Rotation erforderlich)
• HTTP 403 Verboten – IP des Proxys gesperrt (wechseln Sie den Proxytyp auf Residential)
• Verbindung abgelehnt – Proxy nicht verfügbar (aus dem Pool ausschließen)

Fortgeschrittene Fehlerbehandlung

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

def graphql_request_robust(query, proxy, max_retries=3, backoff=2):
    """
    Zuverlässige GraphQL-Anfrage mit Behandlung aller Fehlerarten
    
    Args:
        query: GraphQL-Anfrage
        proxy: Proxy-URL
        max_retries: maximale Versuche
        backoff: Verzögerungsfaktor zwischen den Versuchen
    """
    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
            )
            
            # Überprüfung auf Rate-Limiting
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 60))
                print(f"Rate-Limit! Warte {retry_after} Sekunden...")
                time.sleep(retry_after)
                continue
            
            # Überprüfung auf IP-Sperre
            if response.status_code == 403:
                print(f"IP {proxy} gesperrt! Ein anderer Proxy ist erforderlich.")
                raise Exception("IP gesperrt")
            
            # Überprüfung auf Authentifizierungsfehler des Proxys
            if response.status_code == 407:
                print(f"Authentifizierungsfehler für Proxy {proxy}")
                raise Exception("Proxy-Authentifizierung fehlgeschlagen")
            
            response.raise_for_status()
            
            # Überprüfung auf GraphQL-Fehler
            data = response.json()
            if 'errors' in data:
                print(f"GraphQL-Fehler: {data['errors']}")
                # Einige Fehler können wiederholt werden, andere nicht
                if is_retryable_graphql_error(data['errors']):
                    time.sleep(backoff * (attempt + 1))
                    continue
                else:
                    raise Exception(f"GraphQL-Fehler: {data['errors']}")
            
            return data
            
        except (ProxyError, ConnectionError) as e:
            print(f"Versuch {attempt + 1}: Proxy nicht verfügbar - {e}")
            time.sleep(backoff * (attempt + 1))
            
        except Timeout as e:
            print(f"Versuch {attempt + 1}: Zeitüberschreitung - {e}")
            time.sleep(backoff * (attempt + 1))
            
        except requests.exceptions.HTTPError as e:
            print(f"Versuch {attempt + 1}: HTTP-Fehler - {e}")
            if attempt < max_retries - 1:
                time.sleep(backoff * (attempt + 1))
            else:
                raise
    
    raise Exception(f"Anfrage konnte nach {max_retries} Versuchen nicht ausgeführt werden")

def is_retryable_graphql_error(errors):
    """Bestimmt, ob die Anfrage bei einem GraphQL-Fehler wiederholt werden kann"""
    retryable_codes = ['THROTTLED', 'INTERNAL_ERROR', 'TIMEOUT']
    for error in errors:
        if error.get('extensions', {}).get('code') in retryable_codes:
            return True
    return False

Beste Praktiken für die Arbeit mit GraphQL über Proxys

Lassen Sie uns die wichtigsten Punkte zusammenfassen und Empfehlungen für eine effektive Arbeit mit GraphQL APIs über Proxys geben:

Empfohlene Architektur für großangelegte Projekte

Wenn Sie mit großen Datenmengen arbeiten, empfehlen wir folgende Architektur:

1. Task-Queue (Redis, RabbitMQ) – zur Verteilung von Anfragen zwischen Workern
2. Worker-Pool – jeder Worker verwendet seinen eigenen Proxy
3. Proxy-Manager – überwacht den Zustand der Proxys und verteilt sie zwischen den Workern
4. Datenbank – zur Speicherung von Ergebnissen und Status von Aufgaben
5. Monitoring – Überwachung von Fehlern, Geschwindigkeit, Proxy-Nutzung

Fazit

Die Arbeit mit GraphQL APIs über Proxys ist nicht einfach nur das Hinzufügen des Parameters proxies zur Anfrage. Für eine zuverlässige und effektive Arbeit müssen Sie die Proxy-Rotation implementieren, eine ordnungsgemäße Fehlerbehandlung einrichten, die Header konfigurieren und die API-Limits einhalten. Wir haben praktische Beispiele in Python und Node.js betrachtet, die Sie sofort in Ihren Projekten verwenden können.

Die wichtigsten Erkenntnisse: Verwenden Sie Residential Proxys für geschützte APIs (Shopify, Facebook), Rechenzentren für öffentliche APIs und massives Scraping, implementieren Sie automatische Rotation mit dem Ausschluss nicht funktionierender Proxys, fügen Sie Verzögerungen hinzu und behandeln Sie alle Arten von Fehlern. Dies ermöglicht eine stabile Arbeit mit allen GraphQL APIs ohne Sperren.

Wenn Sie planen, mit GraphQL APIs in der Produktion zu arbeiten, empfehlen wir die Verwendung von Residential Proxys – sie bieten maximale Stabilität und minimales Risiko von Sperren. Für Tests und Entwicklung sind Rechenzentrums-Proxys ausreichend – sie sind schneller und günstiger.