So richten Sie einen Proxy in AWS Lambda für das Parsen und API ein: Vollständiger Leitfaden mit Beispielen

AWS Lambda ist eine serverlose Plattform, die es ermöglicht, Code ohne Serververwaltung auszuführen. Bei der Arbeit mit dem Scraping von Websites, API-Marktplätzen oder der Automatisierung von Aufgaben tritt jedoch häufig ein Problem auf: Lambda-Funktionen verwenden IP-Adressen von AWS, die leicht erkannt und blockiert werden können. In diesem Leitfaden werden wir besprechen, wie man Proxys in Lambda integriert, die IP-Rotation einrichtet und typische Fehler vermeidet.

Der Artikel richtet sich an Entwickler, die Aufgaben über AWS Lambda automatisieren: Daten von geschützten Websites scrapen, Preise von Wettbewerbern überwachen, mit APIs von sozialen Netzwerken oder Marktplätzen arbeiten. Sie erhalten fertige Codebeispiele in Python und Node.js, die Sie sofort nach dem Lesen verwenden können.

Warum Proxys in AWS Lambda benötigt werden

AWS Lambda verwendet standardmäßig IP-Adressen aus dem Pool von Amazon Web Services. Diese Adressen befinden sich in öffentlichen Listen und werden leicht von Bot-Schutzsystemen erkannt. Hier sind die Hauptszenarien, in denen Proxys notwendig werden:

Hauptgründe für die Verwendung von Proxys in Lambda:

• Scraping von geschützten Websites: Viele Websites blockieren Anfragen von IPs von AWS-Rechenzentren. Proxys ermöglichen es, Lambda als normale Benutzer zu maskieren.
• Geolokalisierungsbeschränkungen: Wenn Sie Daten von einer Website abrufen müssen, die nur aus einem bestimmten Land zugänglich ist (z. B. regionale Preise auf Ozon), lösen Proxys mit der benötigten Geolokalisierung das Problem.
• Umgehung von Rate Limiting: APIs vieler Dienste begrenzen die Anzahl der Anfragen von einer IP. Die Rotation von Proxys ermöglicht es, die Last zu verteilen.
• A/B-Tests von Werbung: Überprüfung der Anzeige von Werbeanzeigen aus verschiedenen Regionen zur Analyse von Wettbewerbern.
• Überwachung von Marktplätzen: Verfolgung von Produktpositionen, Preisen von Wettbewerbern auf Wildberries, Ozon, Avito ohne Blockierungen.

Lambda-Funktionen werden häufig nach einem Zeitplan (über CloudWatch Events) oder durch Trigger gestartet, was sie zu einem idealen Werkzeug für die Automatisierung macht. Ohne Proxys stoßen solche Aufgaben jedoch schnell auf Blockierungen von den Zielressourcen.

Welchen Typ von Proxy für Lambda wählen

Die Wahl des Proxytyps hängt von der Aufgabe ab, die Ihre Lambda-Funktion löst. Lassen Sie uns drei Haupttypen und deren Anwendung in einer serverlosen Architektur betrachten:

Empfehlungen zur Auswahl:

• Für das Scraping von Wildberries, Ozon, Avito: Verwenden Sie Residential Proxys mit russischer Geolokalisierung. Diese Plattformen blockieren aktiv IPs von Rechenzentren.
• Für die Überwachung von APIs ohne strengen Schutz: Rechenzentrums-Proxys sind ausreichend, sie sind günstiger und schneller.
• Für die Arbeit mit Instagram, Facebook, TikTok-APIs: Nur mobile oder Residential Proxys — diese Plattformen erkennen und sperren Rechenzentren.
• Für die Umgehung von Cloudflare, PerimeterX: Residential Proxys mit Rotation, idealerweise mit Sticky Sessions (IP für 5-30 Minuten speichern).

Proxy in Lambda mit Python einrichten (requests, urllib3)

Python ist die beliebteste Sprache für Lambda-Funktionen, insbesondere für Aufgaben im Bereich Scraping und Automatisierung. Lassen Sie uns die Einrichtung von Proxys mit der Bibliothek requests betrachten, die in 90% der Fälle verwendet wird.

Grundlegende Einrichtung von HTTP-Proxys

Der einfachste Weg, einen Proxy zu verbinden, besteht darin, den Parameter proxies an die Methode requests.get() zu übergeben:

import requests
import os

def lambda_handler(event, context):
    # Holen Sie sich die Proxy-Anmeldeinformationen aus den Umgebungsvariablen
    proxy_host = os.environ['PROXY_HOST']  # Zum Beispiel: proxy.example.com
    proxy_port = os.environ['PROXY_PORT']  # Zum Beispiel: 8080
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # Erstellen Sie die Proxy-URL mit Authentifizierung
    proxy_url = f"http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        # Machen Sie eine Anfrage über den Proxy
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10  # Wichtig! Timeout festlegen
        )
        
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except requests.exceptions.ProxyError as e:
        print(f"Proxy-Fehler: {e}")
        return {
            'statusCode': 500,
            'body': 'Proxy-Verbindung fehlgeschlagen'
        }
    
    except requests.exceptions.Timeout as e:
        print(f"Timeout-Fehler: {e}")
        return {
            'statusCode': 504,
            'body': 'Anfrage-Timeout'
        }

Wichtige Punkte in diesem Code:

• Umgebungsvariablen: Speichern Sie niemals Proxy-Anmeldeinformationen direkt im Code! Verwenden Sie Umgebungsvariablen in den Lambda-Einstellungen.
• Timeout: Stellen Sie unbedingt ein Timeout ein (10-30 Sekunden). Ohne dieses kann Lambda bis zum Ablauf der maximalen Ausführungszeit hängen bleiben.
• Fehlerbehandlung: Proxys können nicht verfügbar oder langsam sein — behandeln Sie immer die Ausnahmen ProxyError und Timeout.
• HTTP und HTTPS: Geben Sie beide Protokolle im proxies-Dictionary an, auch wenn Sie nur HTTPS verwenden.

SOCKS5-Proxys einrichten

SOCKS5-Proxys bieten ein höheres Maß an Anonymität und arbeiten auf TCP-Ebene, was sie für einige Schutzsysteme unsichtbar macht. Um mit SOCKS5 in requests zu arbeiten, benötigen Sie die Bibliothek requests[socks]:

import requests
import os

def lambda_handler(event, context):
    proxy_host = os.environ['PROXY_HOST']
    proxy_port = os.environ['PROXY_PORT']
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # SOCKS5-Proxy mit Authentifizierung
    proxy_url = f"socks5://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        response = requests.get(
            'https://www.wildberries.ru/catalog/12345/detail.aspx',
            proxies=proxies,
            timeout=15
        )
        
        # Daten scrapen
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except Exception as e:
        print(f"Fehler: {e}")
        return {
            'statusCode': 500,
            'body': str(e)
        }

Wichtig für das Deployment in Lambda: Fügen Sie bei der Verwendung von SOCKS5 in requirements.txt hinzu:

requests[socks]
PySocks

IP über den Proxy überprüfen

Vor dem Start der Hauptlogik ist es nützlich zu überprüfen, ob der Proxy funktioniert und die richtige IP zurückgibt:

def check_proxy_ip(proxies):
    """Überprüft die IP, die die Außenwelt über den Proxy sieht"""
    try:
        response = requests.get(
            'https://api.ipify.org?format=json',
            proxies=proxies,
            timeout=10
        )
        ip_data = response.json()
        print(f"Aktuelle IP über Proxy: {ip_data['ip']}")
        return ip_data['ip']
    except Exception as e:
        print(f"Proxy-Überprüfung fehlgeschlagen: {e}")
        return None

def lambda_handler(event, context):
    # ... Proxy-Einrichtung ...
    
    # Überprüfen Sie die IP vor der Hauptarbeit
    current_ip = check_proxy_ip(proxies)
    if not current_ip:
        return {
            'statusCode': 500,
            'body': 'Proxy-Überprüfung fehlgeschlagen'
        }
    
    # Hauptlogik des Scraping
    # ...

Proxy in Lambda mit Node.js einrichten (axios, got)

Node.js ist die zweitbeliebteste Sprache für Lambda-Funktionen, insbesondere wenn hohe Leistung bei der Arbeit mit APIs erforderlich ist. Lassen Sie uns die Einrichtung von Proxys mit den Bibliotheken axios und got betrachten.

Einrichtung mit axios

Axios ist die beliebteste HTTP-Bibliothek für Node.js. Für die Arbeit mit Proxys benötigen Sie das zusätzliche Paket https-proxy-agent:

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

exports.handler = async (event) => {
    // Holen Sie sich die Anmeldeinformationen aus den Umgebungsvariablen
    const proxyHost = process.env.PROXY_HOST;
    const proxyPort = process.env.PROXY_PORT;
    const proxyUser = process.env.PROXY_USER;
    const proxyPass = process.env.PROXY_PASS;
    
    // Erstellen Sie die Proxy-URL
    const proxyUrl = `http://${proxyUser}:${proxyPass}@${proxyHost}:${proxyPort}`;
    
    // Erstellen Sie einen Agenten für den Proxy
    const agent = new HttpsProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://api.example.com/data', {
            httpsAgent: agent,
            timeout: 10000  // 10 Sekunden
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('Anfrage fehlgeschlagen:', error.message);
        
        return {
            statusCode: 500,
            body: JSON.stringify({
                error: error.message
            })
        };
    }
};

Installation der Abhängigkeiten: Fügen Sie in package.json hinzu:

{
  "dependencies": {
    "axios": "^1.6.0",
    "https-proxy-agent": "^7.0.0"
  }
}

SOCKS5 mit axios einrichten

Für SOCKS5-Proxys verwenden Sie das Paket socks-proxy-agent:

const axios = require('axios');
const { SocksProxyAgent } = require('socks-proxy-agent');

exports.handler = async (event) => {
    const proxyUrl = `socks5://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
    
    const agent = new SocksProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://www.ozon.ru/api/products', {
            httpAgent: agent,
            httpsAgent: agent,
            timeout: 15000
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('Fehler:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Alternative: die Bibliothek got

Got ist eine moderne HTTP-Bibliothek mit nativer Unterstützung für Proxys (benötigt keine separaten Agenten):

const got = require('got');

exports.handler = async (event) => {
    const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
    
    try {
        const response = await got('https://api.example.com/data', {
            agent: {
                http: new (require('http-proxy-agent'))(proxyUrl),
                https: new (require('https-proxy-agent'))(proxyUrl)
            },
            timeout: {
                request: 10000
            },
            responseType: 'json'
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.body)
        };
    } catch (error) {
        console.error('Fehler:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Proxy-Rotation in Lambda: Wie man IPs automatisch wechselt

Die Rotation von Proxys ist entscheidend für Aufgaben, bei denen viele Anfragen ohne Blockierungen gestellt werden müssen. Es gibt zwei Hauptansätze: die Verwendung von Proxy-Diensten mit automatischer Rotation oder die manuelle Verwaltung eines Proxy-Pools.

Automatische Rotation über einen Anbieter

Die meisten Anbieter von Residential Proxys (einschließlich ProxyCove) bieten einen Endpunkt mit automatischer Rotation — jede Anfrage oder alle N Minuten wird die IP automatisch gewechselt:

import requests
import os

def lambda_handler(event, context):
    # Proxy mit automatischer Rotation
    # Format: rotating.proxy.com:port
    # Jede Anfrage = neue IP
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@rotating.proxycove.com:8080"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    results = []
    
    # Machen Sie 10 Anfragen — jede mit einer neuen IP
    for i in range(10):
        try:
            response = requests.get(
                f'https://api.wildberries.ru/products/{i}',
                proxies=proxies,
                timeout=10
            )
            results.append({
                'product_id': i,
                'status': response.status_code,
                'data': response.json()
            })
        except Exception as e:
            results.append({
                'product_id': i,
                'error': str(e)
            })
    
    return {
        'statusCode': 200,
        'body': json.dumps(results)
    }

Manuelle Rotation aus einem Proxy-Pool

Wenn Sie eine Liste von Proxys haben, können Sie die Rotation manuell implementieren. Dies ist nützlich, wenn Sie die Kontrolle darüber benötigen, welcher Proxy für jede Anfrage verwendet wird:

import requests
import random
import json

def lambda_handler(event, context):
    # Liste der Proxys (kann in DynamoDB oder S3 gespeichert werden)
    proxy_pool = [
        {
            'host': 'proxy1.example.com',
            'port': '8080',
            'user': 'user1',
            'pass': 'pass1'
        },
        {
            'host': 'proxy2.example.com',
            'port': '8080',
            'user': 'user2',
            'pass': 'pass2'
        },
        {
            'host': 'proxy3.example.com',
            'port': '8080',
            'user': 'user3',
            'pass': 'pass3'
        }
    ]
    
    results = []
    
    for i in range(10):
        # Wählen Sie einen zufälligen Proxy aus dem Pool
        proxy = random.choice(proxy_pool)
        proxy_url = f"http://{proxy['user']}:{proxy['pass']}@{proxy['host']}:{proxy['port']}"
        
        proxies = {
            'http': proxy_url,
            'https': proxy_url
        }
        
        try:
            response = requests.get(
                f'https://api.example.com/item/{i}',
                proxies=proxies,
                timeout=10
            )
            results.append({
                'item': i,
                'proxy_used': proxy['host'],
                'status': response.status_code
            })
        except Exception as e:
            results.append({
                'item': i,
                'proxy_used': proxy['host'],
                'error': str(e)
            })
    
    return {
        'statusCode': 200,
        'body': json.dumps(results)
    }

Sticky Sessions zur IP-Speicherung

Einige Aufgaben erfordern die Beibehaltung einer IP während einer Sitzung (z. B. Authentifizierung auf einer Website). Proxy-Anbieter bieten Sticky Sessions über einen Parameter in der URL an:

import requests
import uuid

def lambda_handler(event, context):
    # Generieren Sie eine eindeutige session_id
    session_id = str(uuid.uuid4())
    
    # Proxy mit Sticky Session (IP wird für 10 Minuten gespeichert)
    proxy_url = f"http://{os.environ['PROXY_USER']}-session-{session_id}:{os.environ['PROXY_PASS']}@sticky.proxycove.com:8080"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    # Alle Anfragen in dieser Lambda werden mit derselben IP ausgeführt
    # 1. Authentifizierung
    login_response = requests.post(
        'https://example.com/login',
        data={'user': 'test', 'pass': 'test'},
        proxies=proxies
    )
    
    # 2. Daten abrufen (die gleiche IP wird verwendet)
    data_response = requests.get(
        'https://example.com/dashboard',
        proxies=proxies,
        cookies=login_response.cookies
    )
    
    return {
        'statusCode': 200,
        'body': data_response.text
    }

Speichern von Proxy-Anmeldeinformationen über Umgebungsvariablen

Speichern Sie niemals die Anmeldeinformationen für Proxys (Benutzername, Passwort, Host) direkt im Code der Lambda-Funktion. AWS bietet mehrere sichere Möglichkeiten zur Speicherung vertraulicher Daten:

1. Umgebungsvariablen (Basisansatz)

In der AWS Lambda-Konsole → Konfiguration → Umgebungsvariablen hinzufügen:

• PROXY_HOST = proxy.example.com
• PROXY_PORT = 8080
• PROXY_USER = your_username
• PROXY_PASS = your_password

AWS verschlüsselt Umgebungsvariablen automatisch im Ruhezustand. Zugriff auf sie im Code:

# Python
import os
proxy_host = os.environ['PROXY_HOST']

// Node.js
const proxyHost = process.env.PROXY_HOST;

2. AWS Secrets Manager (empfohlen für die Produktion)

Verwenden Sie für maximale Sicherheit den AWS Secrets Manager — er bietet automatische Rotation von Geheimnissen und detaillierte Zugriffskontrolle:

import boto3
import json
from botocore.exceptions import ClientError

def get_proxy_credentials():
    secret_name = "proxy-credentials"
    region_name = "us-east-1"
    
    session = boto3.session.Session()
    client = session.client(
        service_name='secretsmanager',
        region_name=region_name
    )
    
    try:
        get_secret_value_response = client.get_secret_value(
            SecretId=secret_name
        )
        secret = json.loads(get_secret_value_response['SecretString'])
        return secret
    except ClientError as e:
        print(f"Fehler beim Abrufen des Geheimnisses: {e}")
        raise e

def lambda_handler(event, context):
    # Holen Sie sich die Anmeldeinformationen aus dem Secrets Manager
    creds = get_proxy_credentials()
    
    proxy_url = f"http://{creds['user']}:{creds['password']}@{creds['host']}:{creds['port']}"
    
    # Verwenden Sie den Proxy
    # ...

Wichtig: Vergessen Sie nicht, der Lambda-Funktion IAM-Rechte für den Zugriff auf den Secrets Manager hinzuzufügen:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "secretsmanager:GetSecretValue"
      ],
      "Resource": "arn:aws:secretsmanager:us-east-1:123456789:secret:proxy-credentials-*"
    }
  ]
}

Typische Fehler und deren Lösungen

Bei der Arbeit mit Proxys in Lambda stoßen Entwickler häufig auf dieselben Probleme. Lassen Sie uns die häufigsten und deren Lösungen betrachten:

Fehler: ProxyError / Verbindungs-Timeout

Lösung:

# 1. Überprüfen Sie die Anmeldeinformationen
print(f"Verwende Proxy: {proxy_host}:{proxy_port}")
print(f"Benutzer: {proxy_user}")

# 2. Erhöhen Sie das Timeout
response = requests.get(url, proxies=proxies, timeout=30)

# 3. Fügen Sie eine Retry-Logik hinzu
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

session = requests.Session()
retry = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry)
session.mount('http://', adapter)
session.mount('https://', adapter)

response = session.get(url, proxies=proxies, timeout=30)

Fehler: SSL-Zertifikatsüberprüfung fehlgeschlagen

Lösung (mit Vorsicht verwenden!):

# Deaktivieren der SSL-Überprüfung (nur für Tests!)
response = requests.get(
    url,
    proxies=proxies,
    verify=False  # NICHT in der Produktion verwenden!
)

# Besser: Geben Sie den Pfad zum CA-Zertifikat an
response = requests.get(
    url,
    proxies=proxies,
    verify='/path/to/ca-bundle.crt'
)

Fehler: Lambda-Timeout (Aufgabe nach X Sekunden abgelaufen)

Lösung:

• Erhöhen Sie das Timeout der Lambda-Funktion: Konfiguration → Allgemeine Konfiguration → Timeout (maximal 15 Minuten)
• Verringern Sie die Anzahl der Anfragen pro Ausführung
• Verwenden Sie asynchrone Anfragen (asyncio in Python, Promise.all in Node.js)
• Wechseln Sie zu schnelleren Proxys für nicht kritische Aufgaben

# Python: asynchrone Anfragen zur Beschleunigung
import asyncio
import aiohttp

async def fetch_url(session, url, proxy):
    async with session.get(url, proxy=proxy, timeout=10) as response:
        return await response.text()

async def lambda_handler_async(event, context):
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    
    urls = [f'https://api.example.com/item/{i}' for i in range(50)]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url, proxy_url) for url in urls]
        results = await asyncio.gather(*tasks)
    
    return {
        'statusCode': 200,
        'body': json.dumps({'count': len(results)})
    }

def lambda_handler(event, context):
    return asyncio.run(lambda_handler_async(event, context))

Fehler: 407 Proxy-Authentifizierung erforderlich

Lösung:

# Überprüfen Sie das Format der Proxy-URL
# Richtig:
proxy_url = f"http://{user}:{password}@{host}:{port}"

# Falsch (Protokoll fehlt):
proxy_url = f"{user}:{password}@{host}:{port}"  # ❌

# Wenn der Proxy IP-Authentifizierung erfordert:
# 1. Ermitteln Sie die externe IP Ihrer Lambda (kann sich ändern!)
# 2. Fügen Sie diese IP zur Whitelist des Proxy-Anbieters hinzu
# 3. Verwenden Sie den Proxy ohne Benutzer:Passwort

# Abrufen der externen IP von Lambda:
response = requests.get('https://api.ipify.org?format=json')
lambda_ip = response.json()['ip']
print(f"Externe IP von Lambda: {lambda_ip}")

Optimierung der Lambda-Leistung mit Proxys

Die Verwendung von Proxys fügt jeder Anfrage Verzögerung hinzu. Hier sind bewährte Methoden, um die Auswirkungen auf die Leistung zu minimieren:

1. Connection Pooling

Wiederverwenden Sie TCP-Verbindungen, anstatt für jede Anfrage eine neue zu erstellen:

# Python: Verwenden Sie Session anstelle von requests.get()
import requests

# Erstellen Sie die Sitzung einmal (kann außerhalb des Handlers platziert werden)
session = requests.Session()
session.proxies = {
    'http': proxy_url,
    'https': proxy_url
}

def lambda_handler(event, context):
    # Alle Anfragen verwenden wiederverwendete Verbindungen
    for i in range(100):
        response = session.get(f'https://api.example.com/item/{i}')
        # Verarbeiten Sie die Antwort...

2. Parallele Anfragen

Wenn viele unabhängige Anfragen gestellt werden müssen, führen Sie sie parallel aus:

// Node.js: Parallele Anfragen mit Promise.all
const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

const agent = new HttpsProxyAgent(proxyUrl);

exports.handler = async (event) => {
    const urls = Array.from({length: 50}, (_, i) => 
        `https://api.example.com/item/${i}`
    );
    
    // Alle Anfragen werden parallel ausgeführt
    const promises = urls.map(url => 
        axios.get(url, { 
            httpsAgent: agent,
            timeout: 10000
        })
    );
    
    try {
        const results = await Promise.all(promises);
        return {
            statusCode: 200,
            body: JSON.stringify({
                count: results.length,
                data: results.map(r => r.data)
            })
        };
    } catch (error) {
        console.error('Fehler:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

3. Ergebnisse cachen

Wenn sich die Daten selten ändern, cachen Sie die Ergebnisse in DynamoDB oder S3:

import boto3
import json
import time

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('proxy-cache')

def get_cached_or_fetch(url, proxies, cache_ttl=3600):
    """Gibt Daten aus dem Cache zurück oder macht eine Anfrage über den Proxy"""
    
    # Überprüfen Sie den Cache
    try:
        response = table.get_item(Key={'url': url})
        if 'Item' in response:
            item = response['Item']
            if time.time() - item['timestamp'] < cache_ttl:
                print(f"Cache-Hit für {url}")
                return item['data']
    except Exception as e:
        print(f"Cache-Fehler: {e}")
    
    # Cache ist leer oder abgelaufen — Anfrage stellen
    print(f"Cache-Miss für {url}, abrufen...")
    response = requests.get(url, proxies=proxies, timeout=10)
    data = response.text
    
    # Im Cache speichern
    try:
        table.put_item(Item={
            'url': url,
            'data': data,
            'timestamp': int(time.time())
        })
    except Exception as e:
        print(f"Cache-Speicherfehler: {e}")
    
    return data

4. Wählen Sie den richtigen Proxytyp

Vergleich der Geschwindigkeit verschiedener Proxytypen unter realen Bedingungen:

Zusammenfassung: Die Wahl des richtigen Proxytyps ist entscheidend für die Effizienz Ihrer Lambda-Funktion. Berücksichtigen Sie die spezifischen Anforderungen Ihrer Anwendung und testen Sie verschiedene Optionen, um die beste Leistung zu erzielen.