So richten Sie Proxys in serverlosen Anwendungen ein: AWS Lambda, Vercel, Cloudflare Workers

Serverless Architektur ist zum Standard für moderne Webanwendungen geworden, aber Entwickler stehen regelmäßig vor einem Problem: Alle Anfragen von Lambda-Funktionen oder Edge Functions kommen von den IP-Adressen der Rechenzentren der Cloud-Anbieter. Dies führt zu Blockierungen beim Zugriff auf externe APIs, beim Parsen von Daten oder bei der Automatisierung von Aufgaben. In diesem Leitfaden werden wir untersuchen, wie man Proxys in serverless Funktionen integriert, um Beschränkungen, Rate Limits und Geoblockierungen zu umgehen.

Warum serverless Funktionen Proxys benötigen

Serverless Plattformen (AWS Lambda, Google Cloud Functions, Vercel, Cloudflare Workers) führen Code in der Cloud-Infrastruktur aus und verwenden die IP-Adressen von Rechenzentren. Dies schafft mehrere kritische Probleme für Entwickler:

Problem 1: IP-Blockierungen von Rechenzentren. Viele Dienste blockieren automatisch Anfragen von bekannten IP-Adressen von AWS, Google Cloud oder Azure. Zum Beispiel, beim Parsen von E-Commerce-Webseiten (Amazon, eBay, Wildberries) oder sozialen Netzwerken (Instagram API, TikTok API) erhalten Ihre Lambda-Funktionen HTTP 403 oder Captcha bereits bei der ersten Anfrage. Bot-Schutzsysteme (Cloudflare, Akamai, DataDome) erkennen sofort den Traffic aus Cloud-Rechenzentren.

Problem 2: Rate Limiting auf IP-Ebene. Wenn Sie eine serverless Anwendung mit Tausenden gleichzeitigen Aufrufen bereitstellen, können alle Anfragen von einer oder mehreren IP-Adressen von AWS kommen. Externe APIs erreichen schnell ihre Limits (z.B. GitHub API — 60 Anfragen/Stunde von einer IP, Google Maps API — 100 Anfragen/Sekunde). Selbst wenn Sie einen erweiterten API-Plan bezahlt haben, wird die IP-Beschränkung trotzdem wirksam.

Problem 3: Geoblockierungen. Serverless Funktionen in der Region us-east-1 können nicht auf Inhalte zugreifen, die nur aus Russland, Europa oder Asien verfügbar sind. Dies ist kritisch beim Parsen regionaler Marktplätze (Ozon, Yandex.Market), beim Überprüfen von Anzeigen aus verschiedenen Ländern oder beim Testen der Lokalisierung von Webseiten.

Problem 4: Gemeinsame IP mit anderen Benutzern. In einer serverless Umgebung können Ihre Funktionen eine IP-Adresse erhalten, die bereits von anderen Kunden des Cloud-Anbieters verwendet wurde. Wenn jemand zuvor diese IP missbraucht hat (Spam, DDoS, Parsing), kann sie auf schwarzen Listen stehen. Sie erhalten eine Blockierung ohne eigenes Verschulden.

Die Lösung all dieser Probleme ist die Integration von Proxy-Servern. Proxys ermöglichen es Ihren serverless Funktionen, Anfragen über residente oder mobile IP-Adressen zu senden, die wie normale Benutzer aussehen. Dies hebt Blockierungen auf, umgeht Rate Limits und gewährt Zugang zu geoblockierten Inhalten.

Welche Proxy-Typen für serverless geeignet sind

Die Wahl des Proxy-Typs hängt von der Aufgabe Ihrer serverless Anwendung ab. Lassen Sie uns drei Hauptvarianten und deren Anwendungsszenarien betrachten:

Für die meisten serverless Anwendungen wird empfohlen, residente Proxys zu verwenden. Sie bieten das optimale Gleichgewicht zwischen Geschwindigkeit und Anonymität. Residente IPs sehen aus wie normale Haushaltsbenutzer, was das Umgehen von Bot-Schutzmaßnahmen und Rate Limits ohne signifikante Erhöhung der Latenz ermöglicht.

Rechenzentrums-Proxys eignen sich nur für einfache Aufgaben (Überprüfung von HTTP-Status, Arbeiten mit öffentlichen APIs ohne Beschränkungen). Mobile Proxys sind in spezifischen Fällen erforderlich — wenn Sie mit mobilen APIs arbeiten oder maximale Anonymität entscheidend ist.

Proxy in AWS Lambda einrichten

AWS Lambda ist die beliebteste serverless Plattform, und die Integration von Proxys erfordert hier die richtige Konfiguration des HTTP-Clients. Lambda-Funktionen können verschiedene Programmiersprachen verwenden (Node.js, Python, Go), wir betrachten Beispiele für die gängigsten.

Node.js (axios)

Axios ist die beliebteste Bibliothek für HTTP-Anfragen in Node.js. Um einen Proxy einzurichten, verwenden Sie den Parameter proxy in der Konfiguration:

const axios = require('axios');

exports.handler = async (event) => {
  const proxyConfig = {
    host: 'proxy.example.com',
    port: 8080,
    auth: {
      username: 'your_username',
      password: 'your_password'
    },
    protocol: 'http'
  };

  try {
    const response = await axios.get('https://api.example.com/data', {
      proxy: proxyConfig,
      timeout: 10000 // 10 Sekunden
    });

    return {
      statusCode: 200,
      body: JSON.stringify(response.data)
    };
  } catch (error) {
    console.error('Proxy-Fehler:', error.message);
    return {
      statusCode: 500,
      body: JSON.stringify({ error: error.message })
    };
  }
};

Wichtiger Punkt: Bewahren Sie die Anmeldeinformationen des Proxys im AWS Systems Manager Parameter Store oder im AWS Secrets Manager auf, nicht im Code. Dies gewährleistet Sicherheit und ermöglicht es, den Proxy einfach zu ändern, ohne die Funktion neu zu kompilieren.

Python (requests)

In Python wird die Bibliothek requests mit dem Parameter proxies verwendet:

import requests
import json

def lambda_handler(event, context):
    proxies = {
        'http': 'http://username:password@proxy.example.com:8080',
        'https': 'http://username:password@proxy.example.com:8080'
    }
    
    try:
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10
        )
        
        return {
            'statusCode': 200,
            'body': json.dumps(response.json())
        }
    except requests.exceptions.RequestException as e:
        print(f'Proxy-Fehler: {str(e)}')
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }

Für SOCKS5-Proxys (ein sichereres Protokoll) muss in Python die zusätzliche Bibliothek requests[socks] installiert werden, und das URL-Format muss geändert werden:

proxies = {
    'http': 'socks5://username:password@proxy.example.com:1080',
    'https': 'socks5://username:password@proxy.example.com:1080'
}

Optimierung für kalte Starts

Lambda-Funktionen haben das Problem kalter Starts — die erste Anfrage nach einer Pause dauert 1-3 Sekunden. Bei Verwendung von Proxys erhöht sich diese Zeit. Um Verzögerungen zu minimieren, erstellen Sie den HTTP-Client außerhalb der Handler-Funktion:

const axios = require('axios');

// Erstellen Sie den Client einmal bei der Initialisierung des Containers
const httpClient = axios.create({
  proxy: {
    host: 'proxy.example.com',
    port: 8080,
    auth: {
      username: process.env.PROXY_USER,
      password: process.env.PROXY_PASS
    }
  },
  timeout: 10000
});

exports.handler = async (event) => {
  // Wiederverwendung des Clients bei jedem Aufruf
  const response = await httpClient.get('https://api.example.com/data');
  return {
    statusCode: 200,
    body: JSON.stringify(response.data)
  };
};

Dieser Ansatz reduziert die Zeit für kalte Starts um 200-500 ms, da die Proxy-Konfiguration nur einmal bei der Erstellung des Lambda-Containers ausgeführt wird.

Integration von Proxys in Vercel Edge Functions

Vercel bietet zwei Arten von serverless Funktionen an: Node.js Functions (analog zu Lambda) und Edge Functions (laufen auf CDN). Edge Functions arbeiten in einer Laufzeit, die der von Cloudflare Workers ähnlich ist, mit Einschränkungen bei der Verwendung von Node.js APIs. Lassen Sie uns beide Varianten betrachten.

Vercel Node.js Functions

Für gewöhnliche Vercel Functions verwenden Sie denselben Ansatz wie für AWS Lambda. Erstellen Sie eine Datei api/fetch-data.js:

import axios from 'axios';

export default async function handler(req, res) {
  const proxyConfig = {
    host: process.env.PROXY_HOST,
    port: parseInt(process.env.PROXY_PORT),
    auth: {
      username: process.env.PROXY_USER,
      password: process.env.PROXY_PASS
    }
  };

  try {
    const response = await axios.get(req.query.url, {
      proxy: proxyConfig,
      timeout: 8000
    });

    res.status(200).json(response.data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
}

Fügen Sie Umgebungsvariablen im Vercel Dashboard hinzu (Einstellungen → Umgebungsvariablen): PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS.

Vercel Edge Functions

Edge Functions verwenden die Web Fetch API anstelle von Node.js Bibliotheken. Proxys werden über benutzerdefinierte Header oder Middleware konfiguriert:

export const config = {
  runtime: 'edge',
};

export default async function handler(req) {
  const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
  
  // Für Edge Runtime ist ein Fetch mit Proxy über Agent erforderlich (benötigt Polyfill)
  // Alternative: Verwenden Sie die Proxy-API direkt
  const targetUrl = new URL(req.url).searchParams.get('target');
  
  const response = await fetch(targetUrl, {
    headers: {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
  });

  return new Response(await response.text(), {
    status: response.status,
    headers: response.headers
  });
}

Wichtige Einschränkung: Edge Runtime unterstützt keine Standard Node.js Proxy-Agenten. Für eine vollständige Proxy-Nutzung wird empfohlen, Node.js Functions zu verwenden oder einen Zwischen-Proxy-Server auf einem separaten Server einzurichten, der Anfragen von Edge Functions entgegennimmt.

Proxys in Cloudflare Workers

Cloudflare Workers arbeiten in V8-Isolaten und haben noch strengere Einschränkungen als Vercel Edge Functions. Der Standardansatz zur Verbindung von Proxys über Node.js Bibliotheken funktioniert hier nicht. Es gibt zwei funktionierende Ansätze:

Methode 1: HTTP CONNECT Tunneling

Verwenden Sie einen Proxy, der die HTTP CONNECT-Methode unterstützt. Erstellen Sie einen Tunnel über den Proxy-Server:

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const proxyUrl = 'http://proxy.example.com:8080';
  const targetUrl = 'https://api.example.com/data';
  
  const proxyAuth = btoa(`${PROXY_USER}:${PROXY_PASS}`);
  
  const response = await fetch(proxyUrl, {
    method: 'CONNECT',
    headers: {
      'Host': new URL(targetUrl).host,
      'Proxy-Authorization': `Basic ${proxyAuth}`
    }
  });

  if (response.status === 200) {
    // Tunnel hergestellt, führen Sie die Hauptanfrage aus
    const finalResponse = await fetch(targetUrl, {
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
      }
    });
    
    return finalResponse;
  }
  
  return new Response('Proxy-Verbindung fehlgeschlagen', { status: 502 });
}

Diese Methode funktioniert nur mit HTTP-Proxys, die CONNECT unterstützen. Die meisten Anbieter von residenten Proxys bieten diese Möglichkeit.

Methode 2: Proxy-Gateway (empfohlen)

Ein zuverlässigerer Weg ist die Bereitstellung eines Zwischen-Proxy-Gateways auf einem separaten Server (z.B. auf VPS oder AWS EC2). Der Cloudflare Worker sendet Anfragen an Ihr Gateway, und dieses leitet sie über den Proxy weiter:

// Cloudflare Worker
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const targetUrl = new URL(request.url).searchParams.get('url');
  const gatewayUrl = 'https://your-proxy-gateway.com/fetch';
  
  const response = await fetch(gatewayUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': API_KEY // Schutz Ihres Gateways
    },
    body: JSON.stringify({
      url: targetUrl,
      method: 'GET'
    })
  });

  return response;
}

Auf der Seite des Proxy-Gateways (Node.js Server):

const express = require('express');
const axios = require('axios');

const app = express();
app.use(express.json());

const proxyConfig = {
  host: 'proxy.example.com',
  port: 8080,
  auth: {
    username: process.env.PROXY_USER,
    password: process.env.PROXY_PASS
  }
};

app.post('/fetch', async (req, res) => {
  if (req.headers['x-api-key'] !== process.env.API_KEY) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  try {
    const response = await axios({
      url: req.body.url,
      method: req.body.method || 'GET',
      proxy: proxyConfig,
      timeout: 10000
    });

    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000);

Dieser Ansatz fügt einen zusätzlichen Hop hinzu (erhöht die Latenz um 50-100 ms), bietet jedoch vollständige Kompatibilität und Kontrolle über die Proxy-Verbindung.

IP-Adressen-Rotation in serverless Umgebungen

Einer der Hauptgründe für die Verwendung von Proxys ist die Verteilung von Anfragen auf viele IP-Adressen, um Rate Limits zu umgehen. In der serverless Architektur gibt es zwei Ansätze zur Rotation:

Automatische Rotation auf Seiten des Proxy-Anbieters

Die meisten Anbieter von residenten Proxys bieten rotating Proxys an — Sie verbinden sich mit einem Endpoint, und die IP ändert sich automatisch bei jeder Anfrage oder in einem festgelegten Intervall (z.B. alle 5 Minuten). Dies ist die einfachste Option für serverless:

// Ein Endpoint, IP ändert sich automatisch
const proxyConfig = {
  host: 'rotating.proxy.example.com',
  port: 8080,
  auth: {
    username: 'user-session-' + Date.now(), // Einzigartige Sitzung
    password: 'password'
  }
};

Einige Anbieter ermöglichen die Verwaltung der Rotation über Parameter im Benutzernamen: user-session-random (neue IP bei jeder Anfrage), user-session-sticky-300 (eine IP für 300 Sekunden).

Manuelle Rotation über einen Proxy-Pool

Wenn Sie eine Liste statischer Proxys haben (z.B. wenn Sie dedizierte Proxys gekauft haben), können Sie die Rotation auf Anwendungsebene implementieren. In einer serverless Umgebung verwenden Sie DynamoDB (AWS) oder KV Storage (Cloudflare), um den Zustand zu speichern:

const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();

const PROXY_POOL = [
  { host: 'proxy1.example.com', port: 8080 },
  { host: 'proxy2.example.com', port: 8080 },
  { host: 'proxy3.example.com', port: 8080 }
];

async function getNextProxy() {
  // Aktuellen Index aus DynamoDB abrufen
  const result = await dynamodb.get({
    TableName: 'ProxyRotation',
    Key: { id: 'current_index' }
  }).promise();

  const currentIndex = result.Item?.index || 0;
  const nextIndex = (currentIndex + 1) % PROXY_POOL.length;

  // Index aktualisieren
  await dynamodb.put({
    TableName: 'ProxyRotation',
    Item: { id: 'current_index', index: nextIndex }
  }).promise();

  return PROXY_POOL[currentIndex];
}

exports.handler = async (event) => {
  const proxy = await getNextProxy();
  
  const response = await axios.get('https://api.example.com/data', {
    proxy: {
      ...proxy,
      auth: {
        username: process.env.PROXY_USER,
        password: process.env.PROXY_PASS
      }
    }
  });

  return { statusCode: 200, body: JSON.stringify(response.data) };
};

Diese Methode gibt vollständige Kontrolle über die Rotation, erfordert jedoch zusätzliche Anfragen an DynamoDB (fügt 10-30 ms Latenz hinzu). Für hochbelastete Anwendungen wird empfohlen, den Index im Speicher des Lambda-Containers zwischenzuspeichern und ihn alle 100-1000 Anfragen zu aktualisieren.

Fehler- und Timeout-Behandlung

Proxys fügen Ihrem serverless Anwendung einen zusätzlichen Ausfallpunkt hinzu. Es ist entscheidend, Fehler richtig zu behandeln, um keine Benutzeranfragen zu verlieren.

Typische Fehler bei der Arbeit mit Proxys

Implementierung der Retry-Logik mit Fallback

Fügen Sie automatische Wiederholungen mit einem Wechsel zu einem Backup-Proxy bei Fehlern hinzu:

const axios = require('axios');

const PRIMARY_PROXY = {
  host: 'primary.proxy.com',
  port: 8080,
  auth: { username: 'user', password: 'pass' }
};

const FALLBACK_PROXY = {
  host: 'fallback.proxy.com',
  port: 8080,
  auth: { username: 'user', password: 'pass' }
};

async function fetchWithRetry(url, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const proxy = attempt === 0 ? PRIMARY_PROXY : FALLBACK_PROXY;
    
    try {
      const response = await axios.get(url, {
        proxy,
        timeout: 8000
      });
      
      return response.data;
    } catch (error) {
      console.log(`Versuch ${attempt + 1} fehlgeschlagen:`, error.message);
      
      // Keine Wiederholung bei Client-Fehlern (4xx)
      if (error.response && error.response.status < 500) {
        throw error;
      }
      
      // Letzter Versuch — Fehler weitergeben
      if (attempt === maxRetries - 1) {
        throw error;
      }
      
      // Exponentielle Verzögerung vor der Wiederholung
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
    }
  }
}

exports.handler = async (event) => {
  try {
    const data = await fetchWithRetry('https://api.example.com/data');
    return { statusCode: 200, body: JSON.stringify(data) };
  } catch (error) {
    return { statusCode: 500, body: JSON.stringify({ error: error.message }) };
  }
};

Diese Implementierung gibt drei Versuche für die Anfrage: der erste über den primären Proxy, die anderen über den Backup. Zwischen den Versuchen wurde eine exponentielle Verzögerung (1 Sekunde, 2 Sekunden, 4 Sekunden) hinzugefügt, um keine übermäßige Last zu erzeugen.

Überwachung und Alarme

Richten Sie die Überwachung von Proxy-Fehlern über CloudWatch (AWS), Vercel Analytics oder Sentry ein. Verfolgen Sie die Metriken:

• Prozentsatz erfolgreicher Anfragen über Proxys (sollte >95% sein)
• Durchschnittliche Latenz der Anfragen (ein Anstieg kann auf Probleme mit dem Proxy hinweisen)
• Anzahl der Timeout-Fehler (wenn >5% — Proxy überlastet oder langsam)
• Verteilung der Fehler nach Codes (407, 502, ETIMEDOUT usw.)

Richten Sie Alarme bei Überschreitung von Schwellenwerten ein — dies ermöglicht es, schnell auf einen Backup-Proxy-Anbieter umzuschalten oder die Konfiguration zu ändern.

Fazit

Die Integration von Proxys in serverless Anwendungen löst kritische Probleme: IP-Blockierungen von Rechenzentren, Rate Limiting und Geoblockierungen. Wir haben die Einrichtung von Proxys in AWS Lambda (Node.js und Python), Vercel Functions und Cloudflare Workers sowie die Implementierung von IP-Adressen-Rotation und Fehlerbehandlung behandelt.

Wichtige Empfehlungen: Verwenden Sie residente Proxys für Aufgaben, die hohe Anonymität erfordern (Parsing, Arbeiten mit sozialen Netzwerk-APIs), speichern Sie Anmeldeinformationen in sicheren Speichern (AWS Secrets Manager, Vercel Umgebungsvariablen), implementieren Sie Retry-Logik mit Fallback auf Backup-Proxys und richten Sie die Überwachung von Fehlern ein.

Für serverless Anwendungen mit hohen Anforderungen an die Stabilität empfehlen wir die Verwendung von residierenden Proxys mit automatischer Rotation — sie bieten das optimale Gleichgewicht zwischen Geschwindigkeit, Anonymität und Zuverlässigkeit und minimieren das Risiko von Blockierungen bei der Arbeit mit externen APIs und Diensten.