Asynchrone Proxys in Python nutzen Bibliotheken wie aiohttp und httpx, um mehrere gleichzeitige Netzwerkanfragen effizient zu verwalten und zu verhindern, dass I/O-Operationen den Hauptausführungsthread blockieren.

Proxy-Dienste sind von Natur aus I/O-gebunden und verbringen den größten Teil ihrer Betriebszeit damit, auf Netzwerkantworten von Upstream-Servern oder Client-Anfragen zu warten. Traditionelle synchrone (blockierende) I/O-Modelle bearbeiten pro Thread jeweils eine Anfrage, was zu einer ineffizienten Ressourcennutzung und begrenzter Skalierbarkeit führt. Asynchrones I/O, das Pythons asyncio-Framework nutzt, ermöglicht es einem einzelnen Thread, zahlreiche gleichzeitige Verbindungen zu verwalten, indem es den Kontext wechselt, während es auf den Abschluss von I/O-Operationen wartet. Diese Architektur verbessert den Durchsatz und die Reaktionsfähigkeit eines Proxys erheblich.

Kernkonzepte der Asynchronität

Pythons asyncio-Bibliothek bildet die Grundlage für die asynchrone Programmierung. Zu den Schlüsselelementen gehören:

• Event-Loop: Die zentrale Komponente, die Coroutinen plant und ausführt und I/O-Ereignisse und Callbacks verarbeitet.
• Coroutinen (async def): Funktionen, die angehalten und fortgesetzt werden können. Sie werden mit async def definiert und mit await ausgeführt.
• await-Schlüsselwort: Wird verwendet, um die Ausführung einer Coroutine anzuhalten, bis ein Awaitable (eine andere Coroutine, ein Future oder ein Task) abgeschlossen ist. Dies gibt die Kontrolle an den Event-Loop zurück.

aiohttp für asynchrone Proxy-Dienste

aiohttp ist ein asynchrones HTTP-Client-/Server-Framework für asyncio. Es eignet sich gut für den Aufbau sowohl der eingehenden (Server-) als auch der ausgehenden (Client-)Komponenten eines Proxys.

aiohttp als Proxy-Server

aiohttp.web bietet die notwendigen Tools, um einen Webserver zu erstellen, der auf eingehende Client-Anfragen lauscht.

import aiohttp.web

async def handle_request(request):
    """
    A placeholder handler for incoming requests.
    In a real proxy, this would forward the request.
    """
    return aiohttp.web.Response(text=f"Received: {request.method} {request.url}")

async def main():
    app = aiohttp.web.Application()
    app.router.add_route('*', '/{path:.*}', handle_request) # Catch all routes
    runner = aiohttp.web.AppRunner(app)
    await runner.setup()
    site = aiohttp.web.TCPSite(runner, '0.0.0.0', 8080)
    await site.start()
    print("aiohttp proxy server started on port 8080")
    while True:
        await asyncio.sleep(3600) # Keep the server running

if __name__ == '__main__':
    import asyncio
    asyncio.run(main())

aiohttp als asynchroner HTTP-Client

aiohttp.ClientSession wird verwendet, um ausgehende HTTP-Anfragen zu stellen, was für die Weiterleitung von Client-Anfragen an Upstream-Server entscheidend ist. Es verwaltet Verbindungspools und Cookies.

import aiohttp
import asyncio

async def fetch_url(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            response.raise_for_status() # Raise an exception for HTTP errors
            return await response.text()

async def example_client_usage():
    content = await fetch_url('http://httpbin.org/get')
    print(f"Fetched content: {content[:100]}...")

if __name__ == '__main__':
    asyncio.run(example_client_usage())

httpx für asynchrone Proxy-Dienste

httpx ist ein moderner, voll ausgestatteter HTTP-Client für Python, der sowohl synchrone als auch asynchrone APIs bietet. Seine asynchronen Funktionen basieren auf asyncio.

httpx als asynchroner HTTP-Client

httpx.AsyncClient ist die primäre Schnittstelle für asynchrone Anfragen. Es bietet eine requests-ähnliche API, die es Entwicklern, die mit der requests-Bibliothek vertraut sind, intuitiv macht.

import httpx
import asyncio

async def fetch_url_httpx(url):
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        response.raise_for_status() # Raise an exception for HTTP errors
        return response.text

async def example_httpx_client_usage():
    content = await fetch_url_httpx('http://httpbin.org/get')
    print(f"Fetched content (httpx): {content[:100]}...")

if __name__ == '__main__':
    asyncio.run(example_httpx_client_usage())

httpx bietet keine Serverfunktionen; es ist eine reine Client-Bibliothek.

aiohttp vs. httpx Client-Vergleich

Für den Aufbau eines Proxy-Servers ist aiohttp aufgrund seiner Serverfunktionen notwendig. Für die ausgehende Client-Komponente sind beide praktikabel. httpx bietet oft eine einfachere API und integrierte HTTP/2-Unterstützung, was vorteilhaft sein kann.

Aufbau eines asynchronen Proxys mit aiohttp (Server) und httpx (Client)

Dieser Ansatz nutzt aiohttp zur Verarbeitung eingehender Proxy-Anfragen und httpx zur Weiterleitung an den Zielserver. Diese Kombination bietet oft ein gutes Gleichgewicht zwischen Serverkontrolle und Client-Einfachheit/Funktionen.

```python
import aiohttp.web
import httpx
import asyncio
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)

Initialize httpx.AsyncClient once for connection pooling

This client will be used for all outgoing requests

Set a default timeout to prevent hanging connections

OUTGOING_CLIENT = httpx.AsyncClient(timeout=30.0)

async def proxy_handler(request):
"""
Handles incoming client requests, forwards them using httpx,
and returns the response to the client.
"""
target_url = str(request.url).lstrip('/') # Remove leading slash from path

# Reconstruct target URL, preserving scheme, host, and query parameters
# For a typical forward proxy, the client sends full URLs (e.g., GET http://example.com/path)
# For a reverse proxy, the server might only get the path, and needs a base URL.
# This example assumes a forward proxy where the full URL is in the path.
# For a reverse proxy, you'd prepend a fixed base URL:
# target_url = f"http://upstream.example.com{request.url.path_qs}"

# Extract headers, excluding hop-by-hop headers and proxy-specific headers
headers = {
    k: v for k, v in request.headers.items() 
    if k.lower() not in ['host', 'connection', 'keep-alive', 'proxy-authenticate', 
                         'proxy-authorization', 'te', 'trailers', 'transfer-encoding', 
                         'upgrade', 'via', 'x-forwarded-for', 'x-real-ip']
}

# Add X-Forwarded-For if not already present
client_ip = request.remote
if client_ip:
    headers['X-Forwarded-For'] = headers.get('X-Forwarded-For', '') + (', ' if headers.get('X-Forwarded-For') else '') + client_ip

request_method = request.method
request_body = await request.read() if request_method in ('POST', 'PUT', 'PATCH') else None

logger.info(f"Proxying {request_method} {target_url} from {request.remote}")

try:
    # Forward the request using httpx
    proxy_response = await OUTGOING_CLIENT.request(
        method=request_method,